meltygui 0.1.0__py3-none-any.whl

meltygui/core/styling/global_style.py

@@ -0,0 +1,338 @@
+from typing import Any
+
+from meltygui.core.rendering.window_decoration import window
+
+
+@window
+class BackgroundSettings:
+    dot_spacing = 4.917
+    dot_size = 1.798
+    emphasis_size = 1.2
+    dot_color = (0.2, 0.23, 0.3, 1.0)
+    bg_color = (0.027, 0.055, 0.07, 1.0)
+
+
+class GlobalStyle:
+    object_corner_radius = 5.0
+    window_corner_radius = 5.0
+    item_corner_radius = 5.0
+
+    attr_name_indent = 20
+    base_value = 0.3
+    secondary_value = 0.5
+    background_settings = BackgroundSettings()
+    widget_styles = {}
+    excluded_names = set()
+    skip_if_none = set()
+    profiler = {
+        "object_attr": {
+            'dynamic_value': 0.042,
+            'dynamic_offset': -3.855,
+            'dynamic_saturation_factor': -3.855,
+            'dynamic_saturation_offset': -3.855,
+            'value': -3.855,
+            'saturation': 0.5
+        },
+    }
+    dropdown = {
+        "standard": {
+            "background": {
+                "value": 0.01,
+                "saturation": 1.0,
+                "alpha": 1.0,
+                'max_value': 1.0
+            },
+            "text": {
+                "value": 0.01,
+                "saturation": 1.0,
+                "alpha": 1.0,
+                'max_value': 1.0
+            },
+            "button": {
+                "value": 0.12,
+                "saturation": 0.9,
+                "alpha": 1.0,
+                'max_value': 1.0
+            }
+        },
+        "hovered": {
+            "background": {
+                "value": 0.066,
+                "saturation": 1.0,
+                "alpha": 1.0,
+                'max_value': 1.0
+            },
+            "text": {
+                "value": 0.01,
+                "saturation": 1.0,
+                "alpha": 1.0,
+                'max_value': 1.0
+            },
+            "button": {
+                "value": 0.12,
+                "saturation": 0.9,
+                "alpha": 1.0,
+                'max_value': 1.0
+            }
+        },
+    }
+
+    indented_bg = {
+        "dict_child": {
+            "value": 0.01,
+            "saturation": 1.0,
+            "alpha": 1.0,
+            'max_value': 1.0
+        },
+        "dict_child_outline": {
+            "value": 0.01,
+            "saturation": 1.0,
+            "alpha": 1.0,
+            'max_value': 1.0
+        },
+        "object_attr": {
+            "value": 0.12,
+            "saturation": 0.9,
+            "alpha": 1.0,
+            'max_value': 1.0,
+            'dynamic_value': 0.042,
+            'dynamic_offset': -3.855,
+        },
+        "object_attr_outline": {
+            "value": 0.01,
+            "saturation": 1.0,
+            "alpha": 1.0,
+            'max_value': 1.0
+        },
+    }
+    radio_button = {
+        "active_base": {
+            "value": 0.2,
+            "saturation": 1.0,
+            "alpha": 1.0,
+            'max_value': 1.0
+        },
+        "active_hover": {
+            "value": 0.5,
+            "saturation": 1.0,
+            "alpha": 1.0,
+            'max_value': 1.0
+        },
+        "active_pressed": {
+            "value": 0.3,
+            "saturation": 0.4,
+            "alpha": 0.35,
+            'max_value': 1.0
+        },
+        "inactive_base": {
+            "value": 0.2,
+            "saturation": 0.4,
+            "alpha": 0.35,
+            'max_value': 1.0
+        },
+        "inactive_hover": {
+            "value": 0.4,
+            "saturation": 0.5,
+            "alpha": 1.0,
+            'max_value': 1.0
+        },
+        "inactive_pressed": {
+            "value": 0.35,
+            "saturation": 0.5,
+            "alpha": 0.35,
+            'max_value': 1.0
+        },
+
+    }
+
+    main_const = {
+        "window": {
+            "background": {
+                "value": 0.01,
+                "saturation": 0.7,
+                "alpha": 1.0
+            },
+            "border": {
+                "value": 0.34,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "child_bg": {
+                "value": 0.01,
+                "saturation": 0.7,
+                "alpha": 1.0
+            },
+            "popup_bg": {
+                "value": 0.01,
+                "saturation": 0.7,
+                "alpha": 1.0
+            },
+            "title_bg": {
+                "value": 0.01,
+                "saturation": 0.7,
+                "alpha": 1.0
+            },
+            "title_bg_active": {
+                "value": 0.01,
+                "saturation": 0.7,
+                "alpha": 1.0
+            },
+            "title_bg_collapsed": {
+                "value": 0.01,
+                "saturation": 0.5,
+                "alpha": 1.0
+            },
+            "header": {
+                "value": 0.01,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "header_hovered": {
+                "value": 0.45,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "header_active": {
+                "value": 0.55,
+                "saturation": 1.0,
+                "alpha": 1.0
+            }
+        },
+
+        "widget": {
+            "text": {
+                "value": 0.95,
+                "saturation": 0.2,
+                "alpha": 1.0
+            },
+            "text_disabled": {
+                "value": 0.5,
+                "saturation": 0.2,
+                "alpha": 1.0
+            },
+            "resize_grip": {
+                "value": 0.35,
+                "saturation": 0.8,
+                "alpha": 1.0
+            },
+            "resize_hovered": {
+                "value": 0.45,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "resize_active": {
+                "value": 0.55,
+                "saturation": 1.0,
+                "alpha": 1.0
+            },
+            "button": {
+                "value": 0.35,
+                "saturation": 0.8,
+                "alpha": 1.0
+            },
+            "button_hovered": {
+                "value": 0.45,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "button_active": {
+                "value": 0.55,
+                "saturation": 1.0,
+                "alpha": 1.0
+            },
+            "check_mark": {
+                "value": 0.9,
+                "saturation": 1.0,
+                "alpha": 1.0
+            },
+            "text_selected_bg": {
+                "value": 0.35,
+                "saturation": 0.8,
+                "alpha": 1.0
+            },
+            "slider_grab": {
+                "value": 0.5,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "slider_grab_active": {
+                "value": 0.6,
+                "saturation": 1.0,
+                "alpha": 1.0
+            },
+            "scrollbar_grab": {
+                "value": 0.5,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "scrollbar_grab_hovered": {
+                "value": 0.5,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "scrollbar_grab_active": {
+                "value": 0.5,
+                "saturation": 0.9,
+                "alpha": 1.0
+            }
+        },
+
+        "frame": {
+            "frame_bg": {
+                "value": 0.15,
+                "saturation": 0.9,
+                "alpha": 1.0
+            },
+            "frame_hovered": {
+                "value": 0.25,
+                "saturation": 0.5,
+                "alpha": 1.0
+            },
+            "frame_active": {
+                "value": 0.3,
+                "saturation": 0.6,
+                "alpha": 1.0
+            },
+            "separator": {
+                "value": 0.4,
+                "saturation": 0.7,
+                "alpha": 1.0
+            }
+        },
+
+        "tab": {
+            "tab": {
+                "value": 0.25,
+                "saturation": 0.7,
+                "alpha": 1.0
+            },
+            "tab_hovered": {
+                "value": 0.35,
+                "saturation": 0.8,
+                "alpha": 1.0
+            },
+            "tab_active": {
+                "value": 0.4,
+                "saturation": 0.9,
+                "alpha": 1.0
+            }
+        }
+    }
+
+    @classmethod
+    def get_global_constant(cls, constant_name: str, folder, default_type=None, default: Any = None):
+
+        if not hasattr(cls, folder) or getattr(cls, folder) is None:
+            setattr(cls, folder, {})
+        constant_dict = getattr(cls, folder)
+        if constant_name not in constant_dict or constant_dict[constant_name] is None and default is not None:
+            constant_dict[constant_name] = default
+
+        if default_type is not None and (constant_name not in constant_dict
+                                         or not isinstance(constant_dict[constant_name], default_type)):
+            constant_dict[constant_name] = default_type()
+        #
+        # if hasattr(self.settings, "_base_pref") and self.settings._base_pref is not None:
+        #     setattr(self.settings._base_pref._constants, folder, f"global_constant.{folder}")
+
+        return constant_dict[constant_name]

meltygui/core/styling/style.py

@@ -0,0 +1,198 @@
+"""Residual backgrounds and the draw-list renderer's text colour policy.
+
+Tuple colours remain absolute extended sRGB. Style opts into signed shifts;
+the renderer works in linear scRGB, just like hdr_color.
+"""
+import math
+
+
+class Style(tuple):
+    def __new__(cls, rgb=(0, 0, 0), *, absolute=False, shadow_offset=None,
+                font_size=None, font_weight=None, tint_fn=None,
+                font_size_fn=None, font_weight_fn=None, shadow_fn=None):
+        values = tuple(float(value) for value in rgb)
+        if len(values) not in (3, 4) or not all(map(math.isfinite, values)):
+            raise ValueError("Style requires three finite channels and optional alpha")
+        style = super().__new__(cls, values)
+        style.absolute = bool(absolute)
+        for name, fn in (("tint_fn", tint_fn), ("font_size_fn", font_size_fn),
+                         ("font_weight_fn", font_weight_fn), ("shadow_fn", shadow_fn)):
+            if fn is not None and not callable(fn):
+                raise TypeError(f"{name} must be callable or None")
+            setattr(style, name, fn)
+        for name, value in (("shadow_offset", shadow_offset), ("font_size", font_size),
+                            ("font_weight", font_weight)):
+            if value is not None:
+                value = float(value)
+                if not math.isfinite(value):
+                    raise ValueError(f"{name} must be finite")
+            setattr(style, name, value)
+        return style
+
+    def __repr__(self):
+        return (f"Style({tuple(self)!r}, absolute={self.absolute!r}, "
+                f"shadow_offset={self.shadow_offset!r}, font_size={self.font_size!r}, "
+                f"font_weight={self.font_weight!r}, tint_fn={self.tint_fn!r}, "
+                f"font_size_fn={self.font_size_fn!r}, font_weight_fn={self.font_weight_fn!r}, "
+                f"shadow_fn={self.shadow_fn!r})")
+
+    def __getnewargs_ex__(self):
+        return (tuple(self),), {"absolute": self.absolute, "shadow_offset": self.shadow_offset,
+                               "font_size": self.font_size, "font_weight": self.font_weight,
+                               "tint_fn": self.tint_fn, "font_size_fn": self.font_size_fn,
+                               "font_weight_fn": self.font_weight_fn, "shadow_fn": self.shadow_fn}
+
+    def __eq__(self, other):
+        if not isinstance(other, tuple):
+            return NotImplemented
+        # Plain tuples mean absolute. Metadata must participate in dirty
+        # detection: switching black from residual to absolute is an edit.
+        absolute = other.absolute if isinstance(other, Style) else True
+        return (self.absolute == absolute
+                and all(getattr(self, name, None) == getattr(other, name, None)
+                        for name in ("shadow_offset", "font_size", "font_weight", "tint_fn",
+                                     "font_size_fn", "font_weight_fn", "shadow_fn"))
+                and tuple.__eq__(self, other))
+
+    def __ne__(self, other):
+        equal = self.__eq__(other)
+        return NotImplemented if equal is NotImplemented else not equal
+
+    __hash__ = tuple.__hash__
+
+
+def default_scalar_accumulation(context, residual):
+    """Default size, weight, and shadow policy; also an explicit subtree reset."""
+    return context + residual
+
+
+def _scalar(fn, context, residual):
+    value = float(fn(context, residual))
+    if not math.isfinite(value):
+        raise ValueError("Style accumulation callback must return a finite scalar")
+    return value
+
+
+def _font_value(value, absolute, base):
+    return value(base) if callable(value) else (value if absolute else base + value)
+
+
+def _font_step(previous, absolute, fn, residual):
+    # Evaluate against the selected font's real base size/weight, not a delta
+    # from zero. An explicit base font inside a font view keeps its own context.
+    return lambda base: _scalar(fn, _font_value(previous, absolute, base), residual)
+
+
+def resolve_font_style(style, parent=(0.0, 0.0, False, False)):
+    """Compose inherited policies; evaluate nonlinear steps at font selection.
+
+    The first four fields keep the existing delta/absolute representation.
+    Custom functions append two inherited policies and may turn a field into
+    a deferred scalar calculation. This preserves native font selection and
+    avoids guessing the font family/base size before the view requests it.
+    """
+    values = list(parent[:4])
+    functions = list(parent[4:] or (default_scalar_accumulation,) * 2)
+    for i, name in enumerate(('font_size', 'font_weight')):
+        override = getattr(style, name + '_fn', None)
+        if override is not None:
+            functions[i] = override
+        value = getattr(style, name, None)
+        if value is not None:
+            if style.absolute:
+                values[i], values[i + 2] = value, True
+            elif functions[i] is default_scalar_accumulation and not callable(values[i]):
+                values[i] += value
+            else:
+                values[i] = _font_step(values[i], values[i + 2], functions[i], value)
+                values[i + 2] = True
+    if any(fn is not default_scalar_accumulation for fn in functions):
+        values.extend(functions)
+    return tuple(values)
+
+
+def evaluate_font_style(context, size, weight):
+    return (_font_value(context[0], context[2], size),
+            _font_value(context[1], context[3], weight))
+
+
+def resolve_shadow_offset(style, parent=0.0, shadow_fn=None):
+    """Signed shadow depth; omitted values inherit, absolute values bypass policy."""
+    offset = getattr(style, 'shadow_offset', None)
+    if offset is None:
+        return parent
+    if style.absolute:
+        return offset
+    fn = getattr(style, 'shadow_fn', None)
+    if fn is None:
+        fn = shadow_fn if shadow_fn is not None else default_scalar_accumulation
+    return _scalar(fn, parent, offset)
+
+
+def default_tint_accumulation(context_tint, tint_res):
+    """Current extended-sRGB policy: positive toward white, negative toward zero."""
+    return tuple(channel + max(-1.0, min(1.0, delta)) *
+                 (max(0.0, 1.0 - channel) if delta >= 0 else channel)
+                 for channel, delta in zip(context_tint, tint_res))
+
+
+def draw_background(style, parent, tint_fn=None):
+    """Resolve one deferred background to linear RGBA for the paint pass.
+
+    tint_fn receives extended-sRGB triples, before linear conversion/compositing.
+    The default moves positive residuals toward white, negative toward black.
+    Absolute colours keep HDR headroom and wide gamut. Alpha composites in
+    linear light against the enclosing background before descendants use it.
+    """
+    from meltygui.hdr_color import srgb_to_linear
+    from meltygui.hdr_color import linear_to_srgb
+
+    if style is None:
+        return parent
+    if isinstance(style, Style) and not style.absolute:
+        base = tuple(linear_to_srgb(channel) for channel in parent[:3])
+        accumulate = getattr(style, 'tint_fn', None)
+        if accumulate is None:
+            accumulate = tint_fn if tint_fn is not None else default_tint_accumulation
+        rgb = tuple(float(c) for c in accumulate(base, tuple(style[:3])))
+        if len(rgb) != 3 or not all(map(math.isfinite, rgb)):
+            raise ValueError("tint_fn must return three finite extended-sRGB channels")
+    else:
+        rgb = style[:3]
+    alpha = max(0.0, min(1.0, style[3])) if len(style) == 4 else 1.0
+    return tuple(srgb_to_linear(channel) * alpha + behind * (1 - alpha)
+                 for channel, behind in zip(rgb, parent)) + (1.0,)
+
+
+def adjust_text_color():
+    """The single text-colour policy, executed per glyph pixel on the GPU.
+
+    Edit this function to change text appearance. The suggestion and sampled
+    background are linear scRGB. Preserve readable suggestions, otherwise
+    move toward black or reference white by the smallest necessary amount.
+    Coverage/opacity remain the draw-list renderer's responsibility.
+    """
+    return """
+    uniform sampler2D StyleContext;
+    uniform int DynamicStyles;
+    uniform float TextContrast;
+
+    vec3 adjust_text_color(vec3 suggestion) {
+        vec3 background = texelFetch(StyleContext, ivec2(gl_FragCoord.xy), 0).rgb;
+        vec3 weights = vec3(0.2126, 0.7152, 0.0722);
+        float behind = max(0.0, dot(background, weights));
+        float proposed = max(0.0, dot(suggestion, weights));
+        float ratio = (max(behind, proposed) + 0.05) /
+                      (min(behind, proposed) + 0.05);
+        if (ratio >= TextContrast) return suggestion;
+
+        float dark = (behind + 0.05) / TextContrast - 0.05;
+        float light = (behind + 0.05) * TextContrast - 0.05;
+        float toDark = dark >= 0.0 && proposed > 0.0
+            ? clamp((proposed - dark) / proposed, 0.0, 1.0) : 2.0;
+        float toLight = light <= 1.0 && proposed < 1.0
+            ? clamp((light - proposed) / (1.0 - proposed), 0.0, 1.0) : 2.0;
+        return toDark <= toLight ? mix(suggestion, vec3(0), toDark)
+                                : mix(suggestion, vec3(1), toLight);
+    }
+    """