meltygui 0.1.0__py3-none-any.whl

meltygui/core/windowing/backends/wayland_protocol.py

@@ -0,0 +1,101 @@
+"""Small ctypes libwayland binding; xdg protocol metadata comes from bundled XML."""
+import ctypes as C
+from pathlib import Path
+import xml.etree.ElementTree as ET
+
+P = C.c_void_p
+U = C.c_uint32
+I = C.c_int32
+
+
+class Interface(C.Structure):
+    pass
+
+
+class Message(C.Structure):
+    _fields_ = [('name', C.c_char_p), ('signature', C.c_char_p),
+                ('types', C.POINTER(C.POINTER(Interface)))]
+
+
+Interface._fields_ = [('name', C.c_char_p), ('version', C.c_int),
+                     ('method_count', C.c_int), ('methods', C.POINTER(Message)),
+                     ('event_count', C.c_int), ('events', C.POINTER(Message))]
+
+
+def function(lib, name, result, *args):
+    fn = getattr(lib, name)
+    fn.restype, fn.argtypes = result, list(args)
+    return fn
+
+
+class Native:
+    def __init__(self):
+        self.lib = C.CDLL('libwayland-client.so.0', use_errno=True)
+        self.connect = function(self.lib, 'wl_display_connect', P, C.c_char_p)
+        self.connect_fd = function(self.lib, 'wl_display_connect_to_fd', P, C.c_int)
+        self.disconnect = function(self.lib, 'wl_display_disconnect', None, P)
+        self.dispatch = function(self.lib, 'wl_display_dispatch', C.c_int, P)
+        self.pending = function(self.lib, 'wl_display_dispatch_pending', C.c_int, P)
+        self.prepare_read = function(self.lib, 'wl_display_prepare_read', C.c_int, P)
+        self.read_events = function(self.lib, 'wl_display_read_events', C.c_int, P)
+        self.cancel_read = function(self.lib, 'wl_display_cancel_read', None, P)
+        self.roundtrip = function(self.lib, 'wl_display_roundtrip', C.c_int, P)
+        self.flush = function(self.lib, 'wl_display_flush', C.c_int, P)
+        self.get_fd = function(self.lib, 'wl_display_get_fd', C.c_int, P)
+        self.get_version = function(self.lib, 'wl_proxy_get_version', U, P)
+        self.destroy = function(self.lib, 'wl_proxy_destroy', None, P)
+        self.listen = function(self.lib, 'wl_proxy_add_listener', C.c_int, P, C.POINTER(P), P)
+        self.marshal = function(self.lib, 'wl_proxy_marshal_flags', P, P, U, C.POINTER(Interface), U, U)
+        self.interfaces = {name: Interface.in_dll(self.lib, name + '_interface') for name in
+                           ('wl_registry', 'wl_compositor', 'wl_surface', 'wl_seat',
+                            'wl_pointer', 'wl_keyboard', 'wl_output', 'wl_shm', 'wl_shm_pool', 'wl_buffer',
+                            'wl_data_device_manager', 'wl_data_device', 'wl_data_offer',
+                            'wl_data_source')}
+        self.keepalive = []
+        directory = Path(__file__).with_name('protocols')
+        nodes = [node for filename in ('xdg-shell.xml', 'xdg-decoration-unstable-v1.xml')
+                 for node in ET.parse(directory / filename).getroot().findall('interface')]
+        for node in nodes:
+            self.interfaces[node.get('name')] = Interface()
+        for node in nodes:
+            interface = self.interfaces[node.get('name')]
+            interface.name = node.get('name').encode()
+            interface.version = 1  # All our xdg objects negotiate v1.
+            for kind, count_field, messages_field in [('request', 'method_count', 'methods'),
+                                                       ('event', 'event_count', 'events')]:
+                messages = []
+                for event in node.findall(kind):
+                    args = event.findall('arg')
+                    signature = (event.get('since', '') if event.get('since', '1') != '1' else '')
+                    signature += ''.join(('?' if arg.get('allow-null') == 'true' else '') +
+                                         {'int':'i', 'uint':'u', 'fixed':'f', 'string':'s',
+                                          'object':'o', 'new_id':'n', 'array':'a', 'fd':'h'}[arg.get('type')]
+                                         for arg in args)
+                    types = (C.POINTER(Interface) * len(args))(*[
+                        C.pointer(self.interfaces[arg.get('interface')]) if arg.get('interface') else None
+                        for arg in args])
+                    self.keepalive.append(types)
+                    messages.append(Message(event.get('name').encode(), signature.encode(), types))
+                table = (Message * len(messages))(*messages)
+                self.keepalive.append(table)
+                setattr(interface, count_field, len(messages))
+                setattr(interface, messages_field, table)
+
+    def request(self, proxy, opcode, *args, interface=None, version=None, destroy=False):
+        result_interface = C.pointer(self.interfaces[interface]) if interface else None
+        version = self.get_version(proxy) if version is None else version
+        return self.marshal(proxy, opcode, result_interface, version, int(destroy), *args)
+
+    def listener(self, proxy, callbacks, error_handler):
+        functions = []
+        for types, callback in callbacks:
+            def invoke(data, obj, *args, _callback=callback):
+                try:
+                    _callback(*args)
+                except BaseException as error:
+                    error_handler(error)
+            functions.append(C.CFUNCTYPE(None, P, P, *types)(invoke))
+        table = (P * len(functions))(*[C.cast(fn, P) for fn in functions])
+        self.keepalive.extend([functions, table])
+        if self.listen(proxy, table, None) != 0:
+            raise RuntimeError('wl_proxy_add_listener failed')

meltygui/core/windowing/dock_core.py

@@ -0,0 +1,182 @@
+"""Fast Dock: the Dock's window list drawn directly to the draw list.
+
+One @render_func body replaces draw_collection + the per-row
+draw_managed_window / button / draw_tuple widgets. Rows are plain draw-list
+rects/text with manual hit-testing, so a frame costs a handful of draw calls
+instead of a render_func wrapper per widget. It still lives inside a normal
+meltygui window (Mode.WINDOW chrome: drag, header, scroll, blit cache). Open
+rows' buttons get their shadows from add_shadow() — standalone depth marks
+that need no per-button draw_state for the compositor to see.
+
+Interaction model: while the view is hovered the wrapper invalidates its tile
+every frame (core_render's _bounding_hovered branch), so hover highlights and
+clicks resolve inside the body with no per-row state. While NOT hovered the
+tile is a cached blit — external changes (a window closed via its own X, a new
+registration, a tint edit elsewhere) are caught by fast_dock_sync(), called
+once per frame from the always-rendering root.
+"""
+import colorsys
+import ctypes
+import struct
+
+import meltygui_imgui as imgui
+from meltygui.hdr_color import pack_color
+
+from meltygui.core.melty import Melty
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.runtime.toggles import WindowManager
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.styling.fonts import Font
+from meltygui.core.cache.tile_cache import add_glow
+from meltygui.core.cache.tile_cache import add_shadow
+from meltygui.core.cache.tile_cache import clear_glows
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.core_decoration import Core
+
+_last_signature = None
+
+
+def _row_tint(managed_window, window_draw_state):
+    """The tint shown for a row: instance attr wins over the draw_state's,
+    same precedence as draw_managed_window."""
+    window_value = managed_window.input_value
+    if window_value is not None and getattr(window_value, "tint", None) is not None:
+        return window_value.tint
+    return window_draw_state.tint
+
+
+def _row_icon(name, managed_window, window_draw_state):
+    """The icon shown for a row: the window draw_state's kwargs win over the
+    @window registration's — same fallback order as the tint lookup in
+    window_index."""
+    icon = (window_draw_state._kwargs or {}).get("icon") if window_draw_state is not None else None
+    if not icon:
+        label = str(name).split("##")[0].strip()
+        registration = (Melty.annotated_window_classes.get(label)
+                        or Melty.annotated_window_classes.get(str(name)))
+        if registration is not None:
+            window_class, window_kwargs = registration
+            icon = window_kwargs.get("icon") or getattr(window_class, "icon", None)
+    return icon
+
+
+def _dock_signature():
+    rows = []
+    for managed_window in Melty.registered_windows.values():
+        window_draw_state = managed_window.draw_state
+        if window_draw_state is None:
+            continue
+        name = str(window_draw_state.name)
+        rows.append((name, window_draw_state.closed, window_draw_state.live,
+                     _row_tint(managed_window, window_draw_state),
+                     _row_icon(name, managed_window, window_draw_state)))
+    rows.sort(key=lambda row: row[0])
+    return tuple(rows)
+
+
+def fast_dock_sync():
+    """Once per frame from the root: repaint the Fast Dock when any window's
+    dock-visible state changed OUTSIDE the dock (its own close button, a new
+    window registering, a tint edit elsewhere). The dock's own clicks happen
+    while it's hovered, where the wrapper already re-renders every frame."""
+    global _last_signature
+    signature = _dock_signature()
+    if signature != _last_signature:
+        _last_signature = signature
+        Melty.cache.invalidate_up_by_obj(Melty.registered_windows, force=True)
+        request_render()
+
+
+def _summon(window_draw_state, dock_draw_state, row_top):
+    """Reposition `window_draw_state` just right of the dock at this row and
+    raise it — the same math as the old dock's name/target buttons, now via
+    Melty.summon_window so the placement is bounded to the display (a row low
+    in a long dock would otherwise open the window with its bottom off the
+    bottom of the screen)."""
+    this_window_right = dock_draw_state.abs_left + dock_draw_state.width
+    Core.melty.summon_window(window_draw_state, this_window_right + 10, row_top)
+
+
+def _mix(style_manager, tint, value, factor, saturation):
+    # Rows whose window never set a tint fall back to this bright neutral.
+    fallback_tint = (2.558, 0.5, 0.5)
+    color = tint if (isinstance(tint, tuple) and len(tint) >= 3) else fallback_tint
+    return style_manager.make_color_rgb(color[0], color[1], color[2], value=value,
+                                        factor=factor, saturation_scale=saturation)
+
+
+def _color_u32(color, alpha=1.0):
+    return pack_color(color[0], color[1], color[2], alpha)
+
+
+def _floor_value(rgb, min_value):
+    """`rgb` with its hsv value raised to at least `min_value` (hue and
+    saturation kept). Same floor as open_files._tab_text_color's
+    min_brightness: a dark window tint otherwise scales the open row's text
+    toward black."""
+    if min_value <= 0.0:
+        return rgb
+    h, s, v = colorsys.rgb_to_hsv(*rgb[:3])
+    if v >= min_value:
+        return rgb
+    return colorsys.hsv_to_rgb(h, s, min(min_value, 1.0)) + tuple(rgb[3:])
+
+
+def _scale_saturation(rgb, scale):
+    """`rgb` with its hsv saturation multiplied by `scale` (hue and value
+    kept). This works where a saturation_scale into _mix does not: _mix's
+    make_color_rgb only applies saturation_scale to the THEME-derived half
+    of the blend, and at icon_bg_factor 0.45 most of the tile color is the
+    raw window tint — so the knob barely moved the result. Scaling the
+    FINAL color desaturates all of it."""
+    if scale >= 1.0:
+        return rgb
+    h, s, v = colorsys.rgb_to_hsv(*rgb[:3])
+    return colorsys.hsv_to_rgb(h, s * max(0.0, scale), v) + tuple(rgb[3:])
+
+
+# (font_size, glyph) → the glyph's ink rect relative to the add_text pen.
+_glyph_ink_cache = {}
+
+
+def _draw_glyph_ink_centered(draw_list, glyph, center_x, center_y, color_u32):
+    """add_text with the glyph's INK rect centered on (center_x, center_y).
+
+    calc_text_size measures the font's LINE BOX; an icon glyph's ink sits
+    wherever the face put it inside that box, so box-centering reads a few
+    px off per glyph (the Important tiles made it visible). imgui does know
+    the true ink rect — it is the quad add_text emits. So: draw at the
+    box-centered guess, read the 4 vertices just written off the draw list,
+    shift them onto the true center in place (same frame, no flicker), and
+    cache the pen→ink offset so every later draw positions the pen exactly.
+    A glyph missing from the atlas emits no quad and keeps the box guess."""
+    line_box = imgui.calc_text_size(glyph)
+    pen_x = center_x - line_box[0] / 2.0
+    pen_y = center_y - line_box[1] / 2.0
+    key = (imgui.get_font_size(), glyph)
+    ink = _glyph_ink_cache.get(key)
+    if ink is not None:
+        ink_x0, ink_y0, ink_x1, ink_y1 = ink
+        draw_list.add_text(center_x - (ink_x0 + ink_x1) / 2.0,
+                           center_y - (ink_y0 + ink_y1) / 2.0, color_u32, glyph)
+        return
+    vertex_start = draw_list.vtx_buffer_size
+    draw_list.add_text(pen_x, pen_y, color_u32, glyph)
+    if draw_list.vtx_buffer_size != vertex_start + 4:
+        return                                            # glyph not in the atlas: box guess stands
+    vertex_base = draw_list.vtx_buffer_data + vertex_start * imgui.VERTEX_SIZE
+    raw = ctypes.string_at(vertex_base, 3 * imgui.VERTEX_SIZE)
+    ink_x0, ink_y0 = struct.unpack_from("ff", raw, 0)
+    ink_x1, ink_y1 = struct.unpack_from("ff", raw, 2 * imgui.VERTEX_SIZE)
+    _glyph_ink_cache[key] = (ink_x0 - pen_x, ink_y0 - pen_y, ink_x1 - pen_x, ink_y1 - pen_y)
+    shift_x = center_x - (ink_x0 + ink_x1) / 2.0
+    shift_y = center_y - (ink_y0 + ink_y1) / 2.0
+    if abs(shift_x) > 0.01 or abs(shift_y) > 0.01:
+        for vertex_index in range(4):
+            position = ctypes.cast(vertex_base + vertex_index * imgui.VERTEX_SIZE,
+                                   ctypes.POINTER(ctypes.c_float))
+            position[0] += shift_x
+            position[1] += shift_y
+
+
+from meltygui.core.layout.layout_core import dock_header

meltygui/core/windowing/frame_geometry.py

@@ -0,0 +1,42 @@
+"""Geometric relationships between caller-owned frames and native surfaces.
+
+A surface body is connected by two fixed gaps, not a second free window inside
+its native frame. Both native containment and local layout use this relationship.
+"""
+
+
+class SurfaceBinding:
+    def __init__(self, window, axis, near_gap, far_gap):
+        self.window = window
+        self.axis = axis
+        self.near_gap = float(near_gap)
+        self.far_gap = float(far_gap)
+
+    def content_size(self, native_size):
+        return native_size - self.near_gap - self.far_gap
+
+    def minimum_size(self, content_minimum):
+        return content_minimum + self.near_gap + self.far_gap
+
+    def cells(self, native_edges, frame_edges):
+        near, far = native_edges
+        frame_near, frame_far = frame_edges
+        return ([(near, frame_near, self.near_gap, self.near_gap),
+                 (frame_far, far, self.far_gap, self.far_gap)])
+
+
+class EdgeProjection:
+    """Private native/display edge copies with their stable source identities.
+
+    A context owns this collection for one local solve. Keeping the projection
+    together also leaves Context's existing slot layout intact during hotswap.
+    """
+    def __init__(self, native, screen, binding):
+        self.binding = binding
+        self.native = tuple(dict(edge) for edge in native)
+        self.screen = tuple(dict(edge) for edge in screen)
+        self.sources = {id(local): source for local, source in
+                        zip((*self.native, *self.screen), (*native, *screen))}
+
+    def __iter__(self):
+        return iter((*self.native, *self.screen))