meltygui-imgui 2.0.0.post3__cp313-cp313-win_amd64.whl

meltygui_imgui/integrations/pyglet.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+import warnings
+from distutils.version import LooseVersion
+
+from pyglet.window import key, mouse, Window
+import pyglet
+import pyglet.clock
+
+import meltygui_imgui
+
+from . import compute_fb_scale
+from .opengl import FixedPipelineRenderer, ProgrammablePipelineRenderer
+
+
+class PygletMixin(object):
+    REVERSE_KEY_MAP = {
+        key.TAB: meltygui_imgui.KEY_TAB,
+        key.LEFT: meltygui_imgui.KEY_LEFT_ARROW,
+        key.RIGHT: meltygui_imgui.KEY_RIGHT_ARROW,
+        key.UP: meltygui_imgui.KEY_UP_ARROW,
+        key.DOWN: meltygui_imgui.KEY_DOWN_ARROW,
+        key.PAGEUP: meltygui_imgui.KEY_PAGE_UP,
+        key.PAGEDOWN: meltygui_imgui.KEY_PAGE_DOWN,
+        key.HOME: meltygui_imgui.KEY_HOME,
+        key.END: meltygui_imgui.KEY_END,
+        key.INSERT: meltygui_imgui.KEY_INSERT,
+        key.DELETE: meltygui_imgui.KEY_DELETE,
+        key.BACKSPACE: meltygui_imgui.KEY_BACKSPACE,
+        key.SPACE: meltygui_imgui.KEY_SPACE,
+        key.RETURN: meltygui_imgui.KEY_ENTER,
+        key.ESCAPE: meltygui_imgui.KEY_ESCAPE,
+        key.NUM_ENTER: meltygui_imgui.KEY_PAD_ENTER,
+        key.A: meltygui_imgui.KEY_A,
+        key.C: meltygui_imgui.KEY_C,
+        key.V: meltygui_imgui.KEY_V,
+        key.X: meltygui_imgui.KEY_X,
+        key.Y: meltygui_imgui.KEY_Y,
+        key.Z: meltygui_imgui.KEY_Z,
+    }
+    _gui_time = None
+
+    MOUSE_CURSORS = {
+        meltygui_imgui.MOUSE_CURSOR_ARROW: Window.CURSOR_DEFAULT,
+        meltygui_imgui.MOUSE_CURSOR_TEXT_INPUT: Window.CURSOR_TEXT,
+        meltygui_imgui.MOUSE_CURSOR_RESIZE_ALL: Window.CURSOR_SIZE,
+        meltygui_imgui.MOUSE_CURSOR_RESIZE_NS: Window.CURSOR_SIZE_UP_DOWN,
+        meltygui_imgui.MOUSE_CURSOR_RESIZE_EW: Window.CURSOR_SIZE_LEFT_RIGHT,
+        meltygui_imgui.MOUSE_CURSOR_RESIZE_NESW: Window.CURSOR_SIZE_DOWN_LEFT,
+        meltygui_imgui.MOUSE_CURSOR_RESIZE_NWSE: Window.CURSOR_SIZE_DOWN_RIGHT,
+        meltygui_imgui.MOUSE_CURSOR_HAND: Window.CURSOR_HAND
+    }
+
+    def __init__(self):
+        super(PygletMixin, self).__init__()
+        self._cursor = -2
+        self._window = None
+        # Let Dear meltygui_imgui know we have mouse cursor support
+        self.io.backend_flags |= meltygui_imgui.BACKEND_HAS_MOUSE_CURSORS
+
+    def _set_pixel_ratio(self, window):
+        window_size = window.get_size()
+        self.io.display_size = window_size
+        # It is conceivable that the pyglet version will not be solely
+        # determinant of whether we use the fixed or programmable, so do some
+        # minor introspection here to check.
+        if hasattr(window, 'get_viewport_size'):
+            viewport_size = window.get_viewport_size()
+            self.io.display_fb_scale = compute_fb_scale(window_size, viewport_size)
+        elif hasattr(window, 'get_pixel_ratio'):
+            self.io.display_fb_scale = (window.get_pixel_ratio(),
+                                        window.get_pixel_ratio())
+        else:
+            # Default to 1.0 in this unlikely circumstance
+            self.io.display_fb_scale = (1.0, 1.0)
+
+
+    def _attach_callbacks(self, window):
+        self._window = window
+        window.push_handlers(
+            self.on_mouse_motion,
+            self.on_key_press,
+            self.on_key_release,
+            self.on_text,
+            self.on_mouse_drag,
+            self.on_mouse_press,
+            self.on_mouse_release,
+            self.on_mouse_scroll,
+            self.on_resize,
+        )
+
+
+    def _map_keys(self):
+        key_map = self.io.key_map
+
+        # note: we cannot use default mechanism of mapping keys
+        #       because pyglet uses weird key translation scheme
+        for value in self.REVERSE_KEY_MAP.values():
+            key_map[value] = value
+
+    def _on_mods_change(self, mods, key_pressed = 0):
+        self.io.key_ctrl = mods & key.MOD_CTRL or \
+                            key_pressed in (key.LCTRL, key.RCTRL)
+        self.io.key_super = mods & key.MOD_COMMAND or \
+                            key_pressed in (key.LCOMMAND, key.RCOMMAND)
+        self.io.key_alt = mods & key.MOD_ALT or \
+                            key_pressed in (key.LALT, key.RALT)
+        self.io.key_shift = mods & key.MOD_SHIFT or \
+                            key_pressed in (key.LSHIFT, key.RSHIFT)
+
+    def _handle_mouse_cursor(self):
+        if self.io.config_flags & meltygui_imgui.CONFIG_NO_MOUSE_CURSOR_CHANGE:
+            return
+
+        mouse_cursor = meltygui_imgui.get_mouse_cursor()
+        window = self._window
+        if self._cursor != mouse_cursor:
+            self._cursor = mouse_cursor
+            if mouse_cursor == meltygui_imgui.MOUSE_CURSOR_NONE:
+                window.set_mouse_visible(False)
+            else:
+                cursor = self.MOUSE_CURSORS.get(mouse_cursor)
+                window.set_mouse_cursor(window.get_system_mouse_cursor(cursor))
+
+    def on_mouse_motion(self, x, y, dx, dy):
+        self.io.mouse_pos = x, self.io.display_size.y - y
+
+    def on_key_press(self, key_pressed, mods):
+        if key_pressed in self.REVERSE_KEY_MAP:
+            self.io.keys_down[self.REVERSE_KEY_MAP[key_pressed]] = True
+        self._on_mods_change(mods, key_pressed)
+
+    def on_key_release(self, key_released, mods):
+        if key_released in self.REVERSE_KEY_MAP:
+            self.io.keys_down[self.REVERSE_KEY_MAP[key_released]] = False
+        self._on_mods_change(mods)
+
+    def on_text(self, text):
+        io = meltygui_imgui.get_io()
+
+        for char in text:
+            io.add_input_character(ord(char))
+
+    def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
+        self.io.mouse_pos = x, self.io.display_size.y - y
+
+        if button == mouse.LEFT:
+            self.io.mouse_down[0] = 1
+
+        if button == mouse.MIDDLE:
+            self.io.mouse_down[1] = 1
+
+        if button == mouse.RIGHT:
+            self.io.mouse_down[2] = 1
+
+    def on_mouse_press(self, x, y, button, modifiers):
+        self.io.mouse_pos = x, self.io.display_size.y - y
+
+        if button == mouse.LEFT:
+            self.io.mouse_down[0] = 1
+
+        if button == mouse.MIDDLE:
+            self.io.mouse_down[1] = 1
+
+        if button == mouse.RIGHT:
+            self.io.mouse_down[2] = 1
+
+    def on_mouse_release(self, x, y, button, modifiers):
+        self.io.mouse_pos = x, self.io.display_size.y - y
+
+        if button == mouse.LEFT:
+            self.io.mouse_down[0] = 0
+
+        if button == mouse.MIDDLE:
+            self.io.mouse_down[1] = 0
+
+        if button == mouse.RIGHT:
+            self.io.mouse_down[2] = 0
+
+    def on_mouse_scroll(self, x, y, mods, scroll):
+        self.io.mouse_wheel = scroll
+
+    def on_resize(self, width, height):
+        self.io.display_size = width, height
+    
+    def process_inputs(self):
+        io = meltygui_imgui.get_io()
+        
+        current_time = pyglet.clock.tick()
+
+        if self._gui_time:
+            io.delta_time = current_time - self._gui_time
+        else:
+            io.delta_time = 1. / 60.
+        if(io.delta_time <= 0.0): io.delta_time = 1./ 1000.
+        self._gui_time = current_time
+
+
+class PygletFixedPipelineRenderer(PygletMixin, FixedPipelineRenderer):
+    def __init__(self, window, attach_callbacks=True):
+        super(PygletFixedPipelineRenderer, self).__init__()
+        self._set_pixel_ratio(window)
+        self._map_keys()
+        if attach_callbacks: self._attach_callbacks(window)
+
+    def render(self, draw_data):
+        super(PygletFixedPipelineRenderer, self).render(draw_data)
+        self._handle_mouse_cursor()
+
+
+class PygletProgrammablePipelineRenderer(PygletMixin, ProgrammablePipelineRenderer):
+    def __init__(self, window, attach_callbacks = True):
+        super(PygletProgrammablePipelineRenderer, self).__init__()
+        self._set_pixel_ratio(window)
+        self._map_keys()
+        if attach_callbacks: self._attach_callbacks(window)
+
+    def render(self, draw_data):
+        super(PygletProgrammablePipelineRenderer, self).render(draw_data)
+        self._handle_mouse_cursor()
+
+
+class PygletRenderer(PygletFixedPipelineRenderer):
+    def __init__(self, window, attach_callbacks=True):
+        warnings.warn("PygletRenderer is deprecated; please use either "
+                      "PygletFixedPipelineRenderer (for OpenGL 2.1, pyglet < 2.0) or "
+                      "PygletProgrammablePipelineRenderer (for later versions) or "
+                      "create_renderer(window) to auto-detect.",
+                      DeprecationWarning)
+        super(PygletRenderer, self).__init__(window, attach_callbacks)
+
+
+def create_renderer(window, attach_callbacks=True):
+    """
+    This is a helper function that wraps the appropriate version of the Pyglet
+    renderer class, based on the version of pyglet being used.
+    """
+    # Determine the context version
+    # Pyglet < 2.0 has issues with ProgrammablePipeline even when the context
+    # is OpenGL 3, so we need to check the pyglet version rather than looking
+    # at window.config.major_version to see if we want to use programmable.
+    if LooseVersion(pyglet.version) < LooseVersion('2.0'):
+        return PygletFixedPipelineRenderer(window, attach_callbacks)
+    else:
+        return PygletProgrammablePipelineRenderer(window, attach_callbacks)

meltygui_imgui/integrations/sdl2.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from sdl2 import *
+
+import meltygui_imgui
+import ctypes
+
+from .opengl import ProgrammablePipelineRenderer
+
+
+class SDL2Renderer(ProgrammablePipelineRenderer):
+    """Basic SDL2 integration implementation."""
+    MOUSE_WHEEL_OFFSET_SCALE = 0.5
+
+    def __init__(self, window):
+        super(SDL2Renderer, self).__init__()
+        self.window = window
+
+        self._mouse_pressed = [False, False, False]
+        self._mouse_wheel = 0.0
+        self._gui_time = None
+
+        width_ptr = ctypes.pointer(ctypes.c_int(0))
+        height_ptr = ctypes.pointer(ctypes.c_int(0))
+        SDL_GetWindowSize(self.window, width_ptr, height_ptr)
+
+        self.io.display_size = width_ptr[0], height_ptr[0]
+        self.io.get_clipboard_text_fn = self._get_clipboard_text
+        self.io.set_clipboard_text_fn = self._set_clipboard_text
+
+        self._map_keys()
+
+    def _get_clipboard_text(self):
+        return SDL_GetClipboardText()
+
+    def _set_clipboard_text(self, text):
+        SDL_SetClipboardText(ctypes.c_char_p(text.encode()))
+
+    def _map_keys(self):
+        key_map = self.io.key_map
+
+        key_map[meltygui_imgui.KEY_TAB] = SDL_SCANCODE_TAB
+        key_map[meltygui_imgui.KEY_LEFT_ARROW] = SDL_SCANCODE_LEFT
+        key_map[meltygui_imgui.KEY_RIGHT_ARROW] = SDL_SCANCODE_RIGHT
+        key_map[meltygui_imgui.KEY_UP_ARROW] = SDL_SCANCODE_UP
+        key_map[meltygui_imgui.KEY_DOWN_ARROW] = SDL_SCANCODE_DOWN
+        key_map[meltygui_imgui.KEY_PAGE_UP] = SDL_SCANCODE_PAGEUP
+        key_map[meltygui_imgui.KEY_PAGE_DOWN] = SDL_SCANCODE_PAGEDOWN
+        key_map[meltygui_imgui.KEY_HOME] = SDL_SCANCODE_HOME
+        key_map[meltygui_imgui.KEY_END] = SDL_SCANCODE_END
+        key_map[meltygui_imgui.KEY_INSERT] = SDL_SCANCODE_INSERT
+        key_map[meltygui_imgui.KEY_DELETE] = SDL_SCANCODE_DELETE
+        key_map[meltygui_imgui.KEY_BACKSPACE] = SDL_SCANCODE_BACKSPACE
+        key_map[meltygui_imgui.KEY_SPACE] = SDL_SCANCODE_SPACE
+        key_map[meltygui_imgui.KEY_ENTER] = SDL_SCANCODE_RETURN
+        key_map[meltygui_imgui.KEY_ESCAPE] = SDL_SCANCODE_ESCAPE
+        key_map[meltygui_imgui.KEY_PAD_ENTER] = SDL_SCANCODE_KP_ENTER
+        key_map[meltygui_imgui.KEY_A] = SDL_SCANCODE_A
+        key_map[meltygui_imgui.KEY_C] = SDL_SCANCODE_C
+        key_map[meltygui_imgui.KEY_V] = SDL_SCANCODE_V
+        key_map[meltygui_imgui.KEY_X] = SDL_SCANCODE_X
+        key_map[meltygui_imgui.KEY_Y] = SDL_SCANCODE_Y
+        key_map[meltygui_imgui.KEY_Z] = SDL_SCANCODE_Z
+
+    def process_event(self, event):
+        io = self.io
+
+        if event.type == SDL_MOUSEWHEEL:
+            self._mouse_wheel = event.wheel.y * self.MOUSE_WHEEL_OFFSET_SCALE
+            return True
+
+        if event.type == SDL_MOUSEBUTTONDOWN:
+            if event.button.button == SDL_BUTTON_LEFT:
+                self._mouse_pressed[0] = True
+            if event.button.button == SDL_BUTTON_RIGHT:
+                self._mouse_pressed[1] = True
+            if event.button.button == SDL_BUTTON_MIDDLE:
+                self._mouse_pressed[2] = True
+            return True
+
+        if event.type == SDL_KEYUP or event.type == SDL_KEYDOWN:
+            key = event.key.keysym.scancode
+
+            if key < SDL_NUM_SCANCODES:
+                io.keys_down[key] = event.type == SDL_KEYDOWN
+
+            io.key_shift = ((SDL_GetModState() & KMOD_SHIFT) != 0)
+            io.key_ctrl = ((SDL_GetModState() & KMOD_CTRL) != 0)
+            io.key_alt = ((SDL_GetModState() & KMOD_ALT) != 0)
+            io.key_super = ((SDL_GetModState() & KMOD_GUI) != 0)
+
+            return True
+
+        if event.type == SDL_TEXTINPUT:
+            for char in event.text.text.decode('utf-8'):
+                io.add_input_character(ord(char))
+            return True
+
+    def process_inputs(self):
+        io = meltygui_imgui.get_io()
+
+        s_w = ctypes.pointer(ctypes.c_int(0))
+        s_h = ctypes.pointer(ctypes.c_int(0))
+        SDL_GetWindowSize(self.window, s_w, s_h)
+        w = s_w.contents.value
+        h = s_h.contents.value
+
+        io.display_size = w, h
+        io.display_fb_scale = 1, 1
+
+        current_time = SDL_GetTicks() / 1000.0
+
+        if self._gui_time:
+            io.delta_time = current_time - self._gui_time
+        else:
+            io.delta_time = 1. / 60.
+        if(io.delta_time <= 0.0): io.delta_time = 1./ 1000.
+        self._gui_time = current_time
+
+        mx = ctypes.pointer(ctypes.c_int(0))
+        my = ctypes.pointer(ctypes.c_int(0))
+        mouse_mask = SDL_GetMouseState(mx, my)
+
+        if SDL_GetWindowFlags(self.window) & SDL_WINDOW_MOUSE_FOCUS:
+            io.mouse_pos = mx.contents.value, my.contents.value
+        else:
+            io.mouse_pos = -1, -1
+
+        io.mouse_down[0] = self._mouse_pressed[0] or (mouse_mask & SDL_BUTTON(SDL_BUTTON_LEFT)) != 0
+        io.mouse_down[1] = self._mouse_pressed[1] or (mouse_mask & SDL_BUTTON(SDL_BUTTON_RIGHT)) != 0
+        io.mouse_down[2] = self._mouse_pressed[2] or (mouse_mask & SDL_BUTTON(SDL_BUTTON_MIDDLE)) != 0
+        self._mouse_pressed = [False, False, False]
+
+        io.mouse_wheel = self._mouse_wheel
+        self._mouse_wheel = 0