pyglet 2.1.13__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/window/dialog/darwin.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pyglet.libs.darwin import ObjCClass, ns_to_py, nsstr_to_py, AutoReleasePool, pystr_to_ns, py_to_ns
+from pyglet.libs.darwin.cocoapy.runtime import get_callback_block, ObjCBlock
+from pyglet.window.dialog.base import FileOpenDialogBase, FileSaveDialogBase
+
+NSOpenPanel = ObjCClass('NSOpenPanel')
+NSSavePanel = ObjCClass('NSSavePanel')
+NSURL = ObjCClass('NSURL')
+
+
+class MacOSFileOpenDialog(FileOpenDialogBase):
+    _cb_block: ObjCBlock | None = None
+    def __init__(
+        self, title: str="Open File", initial_dir: str | Path=Path.cwd(), initial_file: str | None=None,
+            filetypes: list[tuple[str, str]] | None=None, multiple: bool=False) -> None:
+        super().__init__(title, initial_dir, initial_file, filetypes, multiple)
+        self.blocking = False
+
+    def _dispatch_event(self, files):
+        self.dispatch_event("on_dialog_open", files)
+
+    def open(self):
+        """Initial_file is not supported on Mac."""
+        with AutoReleasePool():
+            url = Path(self.initial_dir).as_posix()
+            nsurl_path = NSURL.fileURLWithPath_(pystr_to_ns(url))
+            panel = NSOpenPanel.openPanel()
+            panel.setAllowsMultipleSelection_(self.multiple)
+            panel.setDirectoryURL_(nsurl_path)
+            panel.setMessage_(pystr_to_ns(self.title))
+
+            if self.filetypes:
+                allowed = []
+                for name, exts in self.filetypes:
+                    for ext in exts.split(" "):
+                        strip_endings = ext.lstrip("*").lstrip(".")
+                        allowed.append(pystr_to_ns(strip_endings))  # mac wants extension without "."
+                panel.setAllowedFileTypes_(py_to_ns(allowed))
+
+            if self.blocking:
+                result = panel.runModal()
+
+                if result == 1:
+                    files = [nsstr_to_py(_url.path()) for _url in ns_to_py(panel.URLs())]
+                else:
+                    files = []
+                self._dispatch_event(files)
+            else:
+                if MacOSFileOpenDialog._cb_block is not None:
+                    raise Exception("An existing dialog is already open.")
+
+                def handler(_result: int):
+                    try:
+                        if _result == 1:
+                            files = [nsstr_to_py(_url.path()) for _url in ns_to_py(panel.URLs())]
+                        else:
+                            files = []
+                        self._dispatch_event(files)
+                    finally:
+                        MacOSFileOpenDialog._cb_block = None
+
+                MacOSFileOpenDialog._cb_block = get_callback_block(handler, encoding=[b"v", b"l"])
+                panel.beginWithCompletionHandler_(MacOSFileOpenDialog._cb_block)
+
+
+class MacOSFileSaveDialog(FileSaveDialogBase):
+    _cb_block = None
+    def __init__(self, title="Save As", initial_dir=Path.cwd(), initial_file=None, filetypes=None, default_ext=""):
+        super().__init__(title, initial_dir, initial_file, filetypes, default_ext)
+        self.blocking = False
+
+    def open(self):
+        """Initial_file is not supported on Mac."""
+        with AutoReleasePool():
+            url = Path(self.initial_dir).as_posix()
+            nsurl_path = NSURL.fileURLWithPath_(pystr_to_ns(url))
+            panel = NSSavePanel.savePanel()
+            panel.setDirectoryURL_(nsurl_path)
+            panel.setMessage_(pystr_to_ns(self.title))
+            if self.initial_file:
+                panel.setNameFieldStringValue_(pystr_to_ns(self.initial_file))
+
+            if self.filetypes:
+                allowed = []
+                for name, exts in self.filetypes:
+                    for ext in exts.split(" "):
+                        strip_endings = ext.lstrip("*").lstrip(".")
+                        allowed.append(pystr_to_ns(strip_endings))  # mac wants extension without "."
+                panel.setAllowedFileTypes_(py_to_ns(allowed))
+            else:
+                panel.setAllowedFileTypes_(py_to_ns([pystr_to_ns(self.default_ext)]))
+            panel.setAllowsOtherFileTypes_(True)
+            panel.setShowsContentTypes_(True)
+            if self.blocking:
+                result = panel.runModal()
+
+                if result == 1:
+                    self._dispatch_event(nsstr_to_py(panel.URL().path()))
+                else:  # cancelled
+                    self._dispatch_event("")
+            else:
+                if MacOSFileSaveDialog._cb_block is not None:
+                    raise Exception("An existing dialog is already open.")
+
+                def handler(_result: int):
+                    try:
+                        if _result == 1:
+                            self._dispatch_event(nsstr_to_py(panel.URL().path()))
+                        else:  # cancelled
+                            self._dispatch_event([])
+                    finally:
+                        MacOSFileSaveDialog._cb_block = None
+
+                MacOSFileSaveDialog._cb_block = get_callback_block(handler, encoding=[b"v", b"l"])
+                panel.beginWithCompletionHandler_(MacOSFileSaveDialog._cb_block)
+
+    def _dispatch_event(self, filename: str):
+        self.dispatch_event("on_dialog_save", filename)

pyglet/window/dialog/linux.py

@@ -0,0 +1,72 @@
+"""Loads a file dialog utilizing TKinter.
+
+Linux does not have any unified dialog API or utility across distros.
+
+While many support a GTK or KDialog, it's not guaranteed. Because of this, TKinter is utilized
+as the main caller. When Tkinter cannot create a system dialog, it will create a custom
+created file explorer, thus guaranteeing a dialog on any Linux system.
+
+This is done in a separate process as Tk has its own event loop.
+"""
+from __future__ import annotations
+
+from concurrent.futures import ProcessPoolExecutor as _ProcessPoolExecutor
+from pathlib import Path
+
+import pyglet
+from pyglet.window.dialog.base import FileOpenDialogBase, FileSaveDialogBase
+
+
+class _TkFileDialogBackend:
+
+    executor = _ProcessPoolExecutor(max_workers=1)
+    _dialog = None
+
+    @staticmethod
+    def _open_dialog(dialog):
+        import tkinter as tk
+        root = tk.Tk()
+        root.withdraw()
+        try:
+            return dialog.show()
+        finally:
+            root.destroy()
+
+    def open(self):
+        future = self.executor.submit(self._open_dialog, self._dialog)
+        future.add_done_callback(self._dispatch_event)
+
+    def _dispatch_event(self, future):
+        raise NotImplementedError
+
+class TkFileOpenDialog(_TkFileDialogBackend, FileOpenDialogBase):
+    def __init__(
+        self, title: str="Open File", initial_dir: str | Path=Path.cwd(), initial_file: str | None=None,
+            filetypes: list[tuple[str, str]] | None=None, multiple: bool=False) -> None:
+        super().__init__(title, initial_dir, initial_file, filetypes, multiple)
+        from tkinter import filedialog
+        self._dialog = filedialog.Open(title=title,
+                                       initialdir=initial_dir,
+                                       initialfile=initial_file,
+                                       filetypes=filetypes or (),
+                                       multiple=multiple)
+
+    def _dispatch_event(self, future):
+        pyglet.app.platform_event_loop.post_event(self, "on_dialog_open", future.result())
+
+
+class TkFileSaveDialog(_TkFileDialogBackend, FileSaveDialogBase):
+    def __init__(self, title="Save As", initial_dir=Path.cwd(), initial_file=None, filetypes=None, default_ext=""):
+        super().__init__(title, initial_dir, initial_file, filetypes, default_ext)
+        from tkinter import filedialog
+
+        self._dialog = filedialog.SaveAs(
+            title=title,
+            initialdir=initial_dir,
+            initialfile=initial_file or (),
+            filetypes=filetypes or (),
+            defaultextension=default_ext,
+        )
+
+    def _dispatch_event(self, future):
+        pyglet.app.platform_event_loop.post_event(self, "on_dialog_save", future.result())

pyglet/window/dialog/windows.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import ctypes
+import threading
+from pathlib import Path
+
+from _ctypes import sizeof
+from ctypes import create_unicode_buffer
+
+import pyglet
+from pyglet.libs.win32 import OPENFILENAMEW, _comdlg32
+from pyglet.libs.win32.constants import (
+    OFN_EXPLORER,
+    OFN_PATHMUSTEXIST,
+    OFN_OVERWRITEPROMPT,
+    OFN_FILEMUSTEXIST,
+    OFN_ALLOWMULTISELECT,
+)
+from pyglet.window.dialog.base import FileOpenDialogBase, FileSaveDialogBase
+
+
+def _build_filter_string(filetypes: list[tuple[str, str]]) -> str:
+    """Create filter string for filetypes.
+
+    Args:
+        filetypes:
+            e.g. [("PNG", "*.png"), ("24-bit Bitmap", "*.bmp"), ("Images", "*.png;*.bmp"]
+    """
+    parts: list[str] = []
+
+    for label, exts in filetypes:
+        # Normalize to a list
+        if isinstance(exts, str):
+            exts = [exts]
+
+        norm_patterns: list[str] = []
+        for ext in exts:
+            ext = ext.strip()
+            if not ext:
+                continue
+            if ext.startswith("*."):
+                pass  # already "*.png"
+            elif ext.startswith("."):  # Just incase, add * if someone didn't add.
+                ext = "*" + ext  # ".png" -> "*.png"
+            else:
+                ext = "*." + ext  # "png"  -> "*.png"
+            norm_patterns.append(ext)
+
+        if not norm_patterns:
+            pattern_str = "*.*"
+        else:
+            pattern_str = ";".join(norm_patterns)
+
+        # Add pattern to the label.
+        display_label = f"{label} ({pattern_str})"
+
+        parts.append(display_label)
+        parts.append(pattern_str)
+
+    # Join pairs with single nulls and end with double null
+    return "\0".join(parts) + "\0\0"
+
+
+def _parse_multiselect(buffer) -> list[str]:
+    text = buffer[:]
+
+    # Split on nulls
+    parts = text.split("\0")
+
+    # Remove empty entries
+    parts = [p for p in parts if p]
+
+    if not parts:
+        return []
+
+    # If only 1 part → it's a single file
+    if len(parts) == 1:
+        return [parts[0]]
+
+    # otherwise:
+    folder = parts[0]
+    files = parts[1:]
+
+    return [folder + "\\" + f for f in files]
+
+
+def _build_ofn(hwnd, title, initialdir, initial_file, filetypes, multiple, for_save=False, buffer_chars=65536, default_ext=None,
+    ):
+        file_buffer = create_unicode_buffer(buffer_chars)
+
+        if initial_file:
+            file_buffer.value = initial_file
+
+        filter_str = _build_filter_string(filetypes) if filetypes else None
+
+        ofn = OPENFILENAMEW()
+        ofn.lStructSize = sizeof(ofn)
+        ofn.hwndOwner = hwnd
+        ofn.lpstrFilter = filter_str
+        ofn.nFilterIndex = 1
+
+        ofn.lpstrFile = ctypes.cast(file_buffer, ctypes.c_wchar_p)
+        ofn.nMaxFile = buffer_chars
+
+        # Optional fields
+        ofn.lpstrFileTitle = None
+        ofn.nMaxFileTitle = 0
+        if isinstance(initialdir, Path):
+            initialdir = initialdir.absolute()
+        ofn.lpstrInitialDir = str(initialdir)
+        ofn.lpstrTitle = title
+
+        # Base flags
+        flags = OFN_EXPLORER
+
+        if for_save:
+            flags |= OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT
+        else:
+            flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST
+
+        if multiple and not for_save:
+            flags |= OFN_ALLOWMULTISELECT
+
+        ofn.Flags = flags
+
+        # Default extension for save dialog (optional)
+        if for_save and default_ext:
+            # strip leading dot
+            if default_ext.startswith("."):
+                default_ext = default_ext[1:]
+            ofn.lpstrDefExt = default_ext
+
+        return ofn, file_buffer
+
+
+class WindowsFileOpenDialog(FileOpenDialogBase):
+
+    def _open_dialog(self) -> list[str] | None:
+        ofn, file_buffer = _build_ofn(
+            hwnd=None,
+            title=self.title,
+            initialdir=self.initial_dir,
+            initial_file=self.initial_file,
+            filetypes=self.filetypes,
+            multiple=self.multiple,
+            for_save=False,
+            buffer_chars=65536,
+        )
+
+        if not _comdlg32.GetOpenFileNameW(ctypes.byref(ofn)):
+            return None
+
+        if self.multiple:
+            return _parse_multiselect(file_buffer.value)
+
+        return file_buffer.value
+
+    def open(self) -> None:
+        def run() -> None:
+            result = self._open_dialog()
+            if result is None:
+                result = []
+            assert isinstance(result, list)
+            pyglet.app.platform_event_loop.post_event(self, "on_dialog_open", result)
+
+        threading.Thread(target=run, daemon=True).start()
+
+
+
+class WindowsFileSaveDialog(FileSaveDialogBase):
+    def _open_dialog(self) -> str:
+        ofn, file_buffer = _build_ofn(
+            hwnd=None,
+            title=self.title,
+            initialdir=self.initial_dir,
+            initial_file=self.initial_file,
+            filetypes=self.filetypes,
+            multiple=False,
+            for_save=True,
+            buffer_chars=65536,
+            default_ext=self.default_ext,
+        )
+
+        if not _comdlg32.GetSaveFileNameW(ctypes.byref(ofn)):
+            return ""
+
+        return file_buffer.value
+
+    def open(self) -> None:
+        def run() -> None:
+            result = self._open_dialog()
+            pyglet.app.platform_event_loop.post_event(self, "on_dialog_save", result)
+
+        threading.Thread(target=run, daemon=True).start()