meltygui 0.1.0__py3-none-any.whl

meltygui/core/layout/grid_core.py

@@ -0,0 +1,117 @@
+import numpy as np
+from OpenGL.GL import *
+
+from meltygui.core.styling.global_style import BackgroundSettings
+
+
+class GridDotsBackground:
+    def __init__(self, dot_spacing=15.0, dot_size=1.0, emphasis_size=1.2, dot_color=(0.2, 0.23, 0.3, 1.0),
+                 bg_color=(0.05, 0.055, 0.07, 1.0)):
+        self.dot_spacing = dot_spacing
+        self.dot_size = dot_size
+        self.emphasis_size = emphasis_size
+        self.dot_color = dot_color
+        self.bg_color = bg_color
+        self.root = None
+
+        vertex_shader = """
+        #version 330 core
+        layout (location = 0) in vec2 position;
+        uniform vec2 resolution;
+        void main() {
+            gl_Position = vec4(position, 0.0, 1.0);
+        }
+        """
+
+        fragment_shader = """
+        #version 330 core
+        out vec4 FragColor;
+        uniform vec2 resolution;
+        uniform float dotSpacing;
+        uniform float dotSize;
+        uniform float emphasisSize;
+        uniform vec4 dotColor;
+        uniform vec4 bgColor;
+
+        void main() {
+            vec2 pos = gl_FragCoord.xy;
+            vec2 grid = mod(pos, dotSpacing * 5.0);
+            vec2 smallGrid = mod(pos, dotSpacing);
+
+            // Check if this is an emphasis point (every 5th dot)
+            bool isEmphasis = grid.x < dotSpacing && grid.y < dotSpacing;
+            float currentDotSize = isEmphasis ? dotSize * emphasisSize : dotSize;
+
+            float dist = length(smallGrid - dotSpacing/2.0);
+            float dot = 1.0 - smoothstep(currentDotSize - 1.0, currentDotSize, dist);
+            vec4 bg = vec4(0.05, 0.055, 0.07, 1.0);
+            
+            FragColor = mix(bgColor, dotColor, dot);
+        }
+        """
+        self.shader = self.create_shader_program(vertex_shader, fragment_shader)
+
+        vertices = np.array([
+            -1.0, -1.0,
+            1.0, -1.0,
+            1.0, 1.0,
+            -1.0, 1.0
+        ], dtype=np.float32)
+
+        self.vao = glGenVertexArrays(1)
+        self.vbo = glGenBuffers(1)
+
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None)
+        glEnableVertexAttribArray(0)
+
+    def set_root(self, root):
+        self.root = root
+
+    def create_shader_program(self, vertex_src, fragment_src):
+        vertex_shader = glCreateShader(GL_VERTEX_SHADER)
+        glShaderSource(vertex_shader, vertex_src)
+        glCompileShader(vertex_shader)
+
+        fragment_shader = glCreateShader(GL_FRAGMENT_SHADER)
+        glShaderSource(fragment_shader, fragment_src)
+        glCompileShader(fragment_shader)
+
+        program = glCreateProgram()
+        glAttachShader(program, vertex_shader)
+        glAttachShader(program, fragment_shader)
+        glLinkProgram(program)
+
+        glDeleteShader(vertex_shader)
+        glDeleteShader(fragment_shader)
+
+        return program
+
+    def render(self, width, height):
+        if self.root is not None:
+            glUseProgram(self.shader)
+            glUniform2f(glGetUniformLocation(self.shader, "resolution"), width, height)
+            glUniform1f(glGetUniformLocation(self.shader, "dotSpacing"), BackgroundSettings.dot_spacing)
+            glUniform1f(glGetUniformLocation(self.shader, "dotSize"), BackgroundSettings.dot_size)
+            glUniform1f(glGetUniformLocation(self.shader, "emphasisSize"), BackgroundSettings.emphasis_size)
+            glUniform4f(glGetUniformLocation(self.shader, "dotColor"), *BackgroundSettings.dot_color)
+            glUniform4f(glGetUniformLocation(self.shader, "bgColor"), *BackgroundSettings.bg_color)
+
+            glBindVertexArray(self.vao)
+            glDrawArrays(GL_TRIANGLE_FAN, 0, 4)
+        else:
+
+            glUseProgram(self.shader)
+            glUniform2f(glGetUniformLocation(self.shader, "resolution"), width, height)
+            glUniform1f(glGetUniformLocation(self.shader, "dotSpacing"), self.dot_spacing)
+            glUniform1f(glGetUniformLocation(self.shader, "dotSize"), self.dot_size)
+            glUniform1f(glGetUniformLocation(self.shader, "emphasisSize"), self.emphasis_size)
+            glUniform4f(glGetUniformLocation(self.shader, "dotColor"), *self.dot_color)
+            glUniform4f(glGetUniformLocation(self.shader, "bgColor"), *self.bg_color)
+
+            #    vec4 bgColor = vec4(0.05, 0.055, 0.07, 1.0);
+
+            glBindVertexArray(self.vao)
+            glDrawArrays(GL_TRIANGLE_FAN, 0, 4)

meltygui/core/layout/header_core.py

@@ -0,0 +1,23 @@
+"""Header core functions and supporting definitions."""
+
+
+
+def _jump_to_view_source(draw_state):
+    """Open the code editor on the def of the function that renders
+    `draw_state` — the raw function under the @render_func wrapper, resolved
+    the way the context menu's inputs tab does (`inspect.unwrap`). A view
+    with no source file (a lambda, a C function) does nothing."""
+    import inspect
+    from pathlib import Path
+    view_fn = getattr(draw_state, "_view_func", None)
+    if view_fn is None:
+        return
+    try:
+        view_fn = inspect.unwrap(view_fn)
+        fn_file = inspect.getsourcefile(view_fn)
+    except (TypeError, ValueError):
+        return
+    if not fn_file:
+        return
+    from meltygui.core.runtime.extensions import jump_to_symbol as _jump_to_symbol_def
+    _jump_to_symbol_def(view_fn, Path(fn_file))

meltygui/core/layout/header_runtime.py

@@ -0,0 +1,67 @@
+import colorsys
+import os
+import sys
+import types
+from types import NoneType
+from typing import MutableMapping
+
+import meltygui.core.windowing.window_api as glfw
+import meltygui_imgui as imgui
+from meltygui.hdr_color import pack_color
+from meltygui.core.styling.style import Style
+from meltygui_imgui.core import _DrawList
+
+import meltygui.core.input.mouse_cursor as mouse_cursor
+from meltygui.core.styling.global_style import GlobalStyle
+from meltygui.core.melty import Melty
+from meltygui.core.melty import add_to_collection
+from meltygui.core.rendering.render_funcs import RenderFuncs
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.runtime.toggles import Tint
+from meltygui.utils.render_utils import push_style_var
+from meltygui.utils.render_utils import push_style_color
+from meltygui.utils.render_utils import pop_style_color
+from meltygui.utils.render_utils import pop_style_var
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.windowing.glfw_utils import print_stack_trace
+from meltygui.core.conversion.bubbling import _BubblingDict
+from meltygui.core.layout.cursor_core import same_line
+from meltygui.core.cache.tile_cache import add_shadow
+from meltygui.core.rendering.window_decoration import window
+
+
+def open_file(path, app=None):
+    def default_file_manager():
+        # Detect platform
+        if sys.platform.startswith('darwin'):
+            return "open"
+        elif os.name == 'nt':
+            return "explorer"
+        elif os.name == 'posix':
+            return "nemo"
+
+    if app is None:
+        app = default_file_manager()
+
+    import subprocess
+    if os.path.exists(path):
+        subprocess.Popen([app, path])
+    else:
+        print(f"Path does not exist: {path}")
+
+
+def _brightness_clamp_fn():
+    """Compatibility accessor for the shared color model."""
+    from meltygui.model.color_model import _brightness_clamp
+    return _brightness_clamp
+
+
+# (r, g, b, hovered) → label rgb for flat_button's explicit text_color path
+_TEXT_COLOR_MEMO = globals().get("_TEXT_COLOR_MEMO", {})
+
+
+from meltygui.view.header_view import flat_button
+flat_button = window(tint=(0.0, 0.335, 0.772, 1.0))(flat_button)
+
+
+from meltygui.core.layout.header_core import _jump_to_view_source

meltygui/core/layout/layout_core.py

@@ -0,0 +1,87 @@
+"""Layout core functions and supporting definitions."""
+from meltygui.core.melty import Melty
+from meltygui.core.runtime.toggles import Toggles
+import meltygui_imgui as imgui
+
+
+def dock_header(draw_state=None, style_manager=None, **kwargs):
+    """The Fast Dock's window header: the standard chrome plus the All /
+    Important tab strip drawn IN the header band. Drawn from the body the
+    strip was clipped whenever tab_pad_y lifted it above the content rect;
+    as header content it owns the band legitimately. This function is
+    draw-only: it stamps each tab's screen rect on
+    draw_state._dock_tab_rects and the BODY resolves clicks there, where
+    the left_mouse_down event reliably arrives."""
+    from meltygui.view.header_view import draw_header
+    from meltygui.core.cache.tile_cache import add_shadow
+    from meltygui.core.windowing.dock_core import _color_u32
+    from meltygui.core.windowing.dock_core import _floor_value
+
+    # The wrapper hands us the cursor already parked at the header origin -
+    # capture it BEFORE the chrome draws and moves it.
+    header_x, header_y = imgui.get_cursor_screen_pos()
+    changed = draw_header(draw_state=draw_state, style_manager=style_manager, **kwargs)
+
+    # ---- layout (same px discipline as the body) ----
+    px = Melty.px
+    # [tint=(0.35, 0.85, 0.94)]
+    tab_strip_x = px(30.0)                                # left inset: sits right of the tint widget
+    tab_height = px(26.0)
+    tab_gap = px(6.6)                                     # gap between tabs
+    tab_pad_x = px(10.0)                                  # tab label side padding
+    tab_nudge_y = px(0.0)                                 # vertical trim from the header band
+    corner = px(6.0)
+    text_nudge_x, text_nudge_y = px(2.0), px(-1.0)        # optical centering of glyphs
+
+    # ---- styling (the body's open/closed row families) ----
+    open_bg_value, open_text_value = 0.16, 1.357
+    closed_bg_value, closed_text_value = 0.045, 0.463
+    hover_bg_boost, hover_text_boost = 0.05, 1.5
+    open_saturation, text_saturation = 1.315, 0.8
+
+    if style_manager is None:
+        style_manager = Melty.style_manager
+    draw_list = imgui.get_window_draw_list()
+    mouse_x, mouse_y = imgui.get_mouse_pos()
+    hover_ok = draw_state._bounding_hovered
+    dock_tab = getattr(draw_state, "dock_tab", None) or "all"
+    clip = getattr(draw_state, "abs_clip_rect", None)
+
+    tab_left = header_x + tab_strip_x
+    tab_top = header_y + tab_nudge_y
+    tab_bottom = tab_top + tab_height
+    tab_rects = []
+    for tab_key, tab_label in (("all", "All"), ("important", "Important")):
+        tab_width = imgui.calc_text_size(tab_label)[0] + 2.0 * tab_pad_x
+        tab_right = tab_left + tab_width
+        is_active = dock_tab == tab_key
+        tab_hovered = (hover_ok and tab_left <= mouse_x <= tab_right
+                       and tab_top <= mouse_y <= tab_bottom)
+        bg_value = (open_bg_value if is_active else closed_bg_value) \
+            + (hover_bg_boost if tab_hovered else 0.0)
+        text_value = (open_text_value if is_active else closed_text_value) \
+            + (hover_text_boost if tab_hovered else 0.0)
+        if is_active:
+            add_shadow((tab_left, tab_top, tab_width, tab_height), offset=11,
+                       corner_radius=corner, clip=clip)
+        # Tabs carry no tint of their own: factor=1.0 makes make_color_rgb
+        # ignore the rgb args and return the window's current tint at the
+        # desired value/saturation - the strip follows the header tint.
+        if is_active or tab_hovered:
+            tab_bg = style_manager.make_color_rgb(0.0, 0.0, 0.0, value=bg_value, factor=1.0,
+                                                  saturation_scale=open_saturation)
+            draw_list.add_rect_filled(tab_left, tab_top, tab_right, tab_bottom,
+                                      _color_u32(tab_bg), rounding=corner)
+        tab_text = _floor_value(
+            style_manager.make_color_rgb(0.0, 0.0, 0.0, value=text_value, factor=1.0,
+                                         saturation_scale=text_saturation),
+            Toggles.FastDock.active_text_min_brightness if is_active
+            else Toggles.FastDock.inactive_text_min_brightness)
+        label_size = imgui.calc_text_size(tab_label)
+        draw_list.add_text(tab_left + tab_pad_x + text_nudge_x,
+                           tab_top + (tab_height - label_size[1]) / 2.0 + text_nudge_y,
+                           _color_u32(tab_text), tab_label)
+        tab_rects.append((tab_key, (tab_left, tab_top, tab_right, tab_bottom)))
+        tab_left = tab_right + tab_gap
+    draw_state._dock_tab_rects = tuple(tab_rects)
+    return changed