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

pyglet/window/cocoa/__init__.py

@@ -4,7 +4,6 @@ from ctypes import c_void_p
 from typing import TYPE_CHECKING, Sequence
 
 import pyglet
-from pyglet.display.cocoa import CocoaCanvas
 from pyglet.event import EventDispatcher
 from pyglet.libs.darwin import AutoReleasePool, CGPoint, cocoapy
 from pyglet.window import BaseWindow, DefaultMouseCursor, MouseCursor
@@ -17,7 +16,7 @@ from .pyglet_window import PygletToolWindow, PygletWindow
 from .systemcursor import SystemCursor
 
 if TYPE_CHECKING:
-    from pyglet.gl.cocoa import CocoaContext
+    from pyglet.graphics.api.gl.cocoa.context import CocoaContext
 
 NSApplication = cocoapy.ObjCClass('NSApplication')
 NSCursor = cocoapy.ObjCClass('NSCursor')
@@ -30,9 +29,11 @@ NSPasteboard = cocoapy.ObjCClass('NSPasteboard')
 quartz = cocoapy.quartz
 cf = cocoapy.cf
 
+CAMetalLayer = cocoapy.ObjCClass('CAMetalLayer')
+
 
 class CocoaMouseCursor(MouseCursor):
-    gl_drawable = False
+    api_drawable = False
 
     def __init__(self, cursorName: str) -> None:
         # cursorName is a string identifying one of the named default NSCursors
@@ -93,26 +94,20 @@ class CocoaWindow(BaseWindow):
     def _create(self) -> None:
         with AutoReleasePool():
             if self._nswindow:
-                # The window is about the be recreated so destroy everything
+                # The window is about to be recreated so destroy everything
                 # associated with the old window, then destroy the window itself.
-                nsview = self.canvas.nsview
-                self.canvas = None
                 self._nswindow.orderOut_(None)
                 self._nswindow.close()
                 self.context.detach()
                 self._nswindow.release()
                 self._nswindow = None
-                nsview.release()
+                self._nsview.release()
+                self._nsview = None
                 self._delegate.release()
                 self._delegate = None
 
             # Determine window parameters.
-            if pyglet.options.dpi_scaling == "real":
-                screen_scale = self.screen.get_scale()
-                w, h = self.get_requested_size()
-                width, height = w / screen_scale, h / screen_scale
-            else:
-                width, height = self._width, self._height
+            width, height = self._width, self._height
 
             content_rect = cocoapy.NSMakeRect(0, 0, width, height)
             WindowClass = PygletWindow
@@ -165,25 +160,29 @@ class CocoaWindow(BaseWindow):
 
             # Then create a view and set it as our NSWindow's content view.
             self._nsview = PygletView.alloc().initWithFrame_cocoaWindow_(content_rect, self)
-            self._nsview.setWantsBestResolutionOpenGLSurface_(True)
-
-            if not self._fullscreen:
-                if self._style in ("transparent", "overlay"):
-                    self._nswindow.setOpaque_(False)
-                    self._nswindow.setBackgroundColor_(NSColor.clearColor())
-                    self._nswindow.setHasShadow_(False)
-
-                    if self._style == "overlay":
-                        self.set_mouse_passthrough(True)
-                        self._nswindow.setLevel_(cocoapy.NSStatusWindowLevel)
-
+            self._metal_layer = None
+            if not self._shadow:
+                if "gl" in pyglet.options.backend:
+                    self._nsview.setWantsBestResolutionOpenGLSurface_(True)
+                elif pyglet.options.backend == "vulkan":
+                    self._metal_layer = CAMetalLayer.alloc().init()
+                    #self._metal_layer.setFramebufferOnly_(True)  # Layer can only be used as a FB. More performant?
+                    transparent = self.style == 'transparent' or self.style == 'overlay'
+                    self._metal_layer.setOpaque_(not transparent)
+
+                    # Attach the CAMetalLayer to the NSView
+                    self._nsview.setLayer_(self._metal_layer)
+                    self._nsview.setWantsLayer_(True)
+                else:
+                    print(f"Unsupported backend found. '{pyglet.options.backend}'")
+
+                self._assign_config()
+                self.context.attach(self)
+                if self._metal_layer:
+                    self.context._nscontext = self._metal_layer  # noqa: SLF001
             self._nswindow.setContentView_(self._nsview)
             self._nswindow.makeFirstResponder_(self._nsview)
 
-            # Create a canvas with the view as its drawable and attach context to it.
-            self.canvas = CocoaCanvas(self.display, self.screen, self._nsview)
-            self.context.attach(self.canvas)
-
             # Configure the window.
             self._nswindow.setAcceptsMouseMovedEvents_(True)
 
@@ -208,13 +207,29 @@ class CocoaWindow(BaseWindow):
                 array = NSArray.arrayWithObject_(cocoapy.NSPasteboardTypeURL)
                 self._nsview.registerForDraggedTypes_(array)
 
-            self.context.update_geometry()
+            self._update_geometry()
             self.switch_to()
             self.set_vsync(self._vsync)
             self.set_visible(self._visible)
 
+        if not self._fullscreen:
+            if self._style in ("transparent", "overlay"):
+                self._nswindow.setOpaque_(False)
+                self._nswindow.setBackgroundColor_(NSColor.clearColor())
+                self._nswindow.setHasShadow_(False)
+
+                if self._style == "overlay":
+                    self.set_mouse_passthrough(True)
+                    self._nswindow.setLevel_(cocoapy.NSStatusWindowLevel)
+
+    def _update_geometry(self):
+        if self._metal_layer:
+            pass
+        else:
+            self.context.update_geometry()
+
     def _get_dpi_desc(self) -> int:
-        if pyglet.options.dpi_scaling in ("scaled", "stretch", "platform") and self._nswindow:
+        if self._nswindow:
             desc = self._nswindow.deviceDescription()
             rsize = desc.objectForKey_(darwin.NSDeviceResolution).sizeValue()
             return int(rsize.width)
@@ -227,7 +242,7 @@ class CocoaWindow(BaseWindow):
 
         Read only.
         """
-        if pyglet.options.dpi_scaling in ("scaled", "stretch", "platform") and self._nswindow:
+        if self._nswindow:
             return self._nswindow.backingScaleFactor()
 
         return 1.0
@@ -271,7 +286,7 @@ class CocoaWindow(BaseWindow):
 
         with AutoReleasePool():
             # Restore cursor visibility
-            self.set_mouse_platform_visible(True)
+            self.set_mouse_cursor_platform_visible(True)
             self.set_exclusive_mouse(False)
             self.set_exclusive_keyboard(False)
 
@@ -288,11 +303,7 @@ class CocoaWindow(BaseWindow):
                 self._delegate.release()
                 self._delegate = None
 
-            # Remove view from canvas and then remove canvas.
-            if self.canvas:
-                self.canvas.nsview = None
-                self.canvas = None
-
+            # Remove view.
             if self._nsview:
                 self._nswindow.setContentView_(None)
                 self._nsview.release()
@@ -314,6 +325,10 @@ class CocoaWindow(BaseWindow):
         if self.context:
             self.context.set_current()
 
+    def before_draw(self) -> None:
+        if self.context:
+            self.context.before_draw()
+
     def flip(self) -> None:
         self.draw_mouse_cursor()
         if self.context:
@@ -381,7 +396,7 @@ class CocoaWindow(BaseWindow):
         image = max_image.get_image_data()
         fmt = 'ARGB'
         bytesPerRow = len(fmt) * image.width
-        data = image.get_data(fmt, -bytesPerRow)
+        data = image.get_bytes(fmt, -bytesPerRow)
 
         # Use image data to create a data provider.
         # Using CGDataProviderCreateWithData crashes PyObjC 2.2b3, so we create
@@ -444,7 +459,7 @@ class CocoaWindow(BaseWindow):
         return self._width, self._height
 
     def get_framebuffer_size(self) -> tuple[int, int]:
-        view = self.context._nscontext.view()
+        view = self._nsview
         bounds = view.bounds()
         bounds = view.convertRectToBacking_(bounds)
         return int(bounds.size.width), int(bounds.size.height)
@@ -452,11 +467,7 @@ class CocoaWindow(BaseWindow):
     def set_size(self, width: int, height: int) -> None:
         super().set_size(width, height)
 
-        if pyglet.options.dpi_scaling == "real":
-            screen_scale = self._nswindow.backingScaleFactor()
-            frame_width, frame_height = width // screen_scale, height // screen_scale
-        else:
-            frame_width, frame_height = width, height
+        frame_width, frame_height = width, height
 
         self._set_frame_size(frame_width, frame_height)
         self.dispatch_event('_on_internal_resize', width, height)
@@ -516,8 +527,8 @@ class CocoaWindow(BaseWindow):
             self._nswindow.zoom_(None)
 
     def set_vsync(self, vsync: bool) -> None:
-        if pyglet.options['vsync'] is not None:
-            vsync = pyglet.options['vsync']
+        if pyglet.options.vsync is not None:
+            vsync = pyglet.options.vsync
 
         super().set_vsync(vsync)
         self.context.set_vsync(vsync)
@@ -531,7 +542,7 @@ class CocoaWindow(BaseWindow):
         rect = self._nswindow.contentRectForFrameRect_(window_frame)
         return cocoapy.foundation.NSMouseInRect(point, rect, False)
 
-    def set_mouse_platform_visible(self, platform_visible: int | None = None) -> None:
+    def set_mouse_cursor_platform_visible(self, platform_visible: int | None = None) -> None:
         # When the platform_visible argument is supplied with a boolean, then this
         # method simply sets whether or not the platform mouse cursor is visible.
         if platform_visible is not None:
@@ -555,7 +566,7 @@ class CocoaWindow(BaseWindow):
             # If we are in the window, then what we do depends on both
             # the current pyglet-set visibility setting for the mouse and
             # the type of the mouse cursor.  If the cursor has been hidden
-            # in the window with set_mouse_visible() then don't show it.
+            # in the window with set_mouse_cursor_visible() then don't show it.
             elif not self._mouse_visible:
                 SystemCursor.hide()
             # If the mouse is set as a system-defined cursor, then we
@@ -566,7 +577,7 @@ class CocoaWindow(BaseWindow):
                 SystemCursor.unhide()
             # If the mouse cursor is OpenGL drawable, then it we need to hide
             # the system mouse cursor, so that the cursor can draw itself.
-            elif self._mouse_cursor.gl_drawable:
+            elif self._mouse_cursor.api_drawable:
                 SystemCursor.hide()
             # Otherwise, show the default cursor.
             else:
@@ -639,7 +650,7 @@ class CocoaWindow(BaseWindow):
             quartz.CGAssociateMouseAndMouseCursorPosition(True)
 
         # Update visibility of mouse cursor.
-        self.set_mouse_platform_visible()
+        self.set_mouse_cursor_platform_visible()
 
     def set_exclusive_keyboard(self, exclusive: bool = True) -> None:
         # http://developer.apple.com/mac/library/technotes/tn2002/tn2062.html

pyglet/window/cocoa/pyglet_delegate.py

@@ -3,11 +3,9 @@ from __future__ import annotations
 from ctypes import c_void_p
 from typing import TYPE_CHECKING
 
-import pyglet
 from pyglet.libs.darwin.cocoapy import (
     NSApplicationDidHideNotification,
     NSApplicationDidUnhideNotification,
-    NSMakeRect,
     ObjCClass,
     ObjCInstance,
     ObjCSubclass,
@@ -101,7 +99,7 @@ class PygletDelegate_Implementation:
             self.did_pause_exclusive_mouse = False
             self._window._nswindow.setMovable_(True)  # Mac OS 10.6  # noqa: SLF001
         # Restore previous mouse visibility settings.
-        self._window.set_mouse_platform_visible()
+        self._window.set_mouse_cursor_platform_visible()
         self._window.dispatch_event('on_activate')
 
     @PygletDelegate.method('v@')
@@ -115,7 +113,7 @@ class PygletDelegate_Implementation:
             # the window is reactivated by clicking on its title bar.
             self._window._nswindow.setMovable_(False)  # Mac OS X 10.6  # noqa: SLF001
         # Make sure that cursor is visible.
-        self._window.set_mouse_platform_visible(True)
+        self._window.set_mouse_cursor_platform_visible(True)
         self._window.dispatch_event('on_deactivate')
 
     @PygletDelegate.method('v@')
@@ -157,27 +155,6 @@ class PygletDelegate_Implementation:
             new_scale = self._window._nswindow.backingScaleFactor()
             if old_scale != new_scale:
                 self._window.switch_to()
-
-                currentFrame = self._window._nswindow.frame()
-
-                if pyglet.options.dpi_scaling == "real":
-                    screen_scale = new_scale
-                    w, h = self._window.get_requested_size()
-                    width, height = int(w / screen_scale), int(h / screen_scale)
-
-                    # Force Window back to correct size.
-                    self._window._set_frame_size(width, height)
-                else:
-                    # MacOS seems to cache the state of the window size, even between different DPI scales/monitors.
-                    # This means that the screen will refuse to refresh until we resize the window to a different size.
-                    # Force a refresh by setting a temporary frame, then forcing it back.
-                    if pyglet.options.dpi_scaling == "scaled":
-                        tempRect = NSMakeRect(currentFrame.origin.x, currentFrame.origin.y,
-                                              currentFrame.size.width + 1, currentFrame.size.height + 1)
-                        # TODO: Add variable to ignore the next two on-resize events?
-                        self._window._nswindow.setFrame_display_(tempRect, True)
-                        self._window._nswindow.setFrame_display_(currentFrame, True)
-
                 self._window.context.update_geometry()
                 self._window.dispatch_event("_on_internal_scale", new_scale, self._window._get_dpi_desc())
 

pyglet/window/cocoa/pyglet_view.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import ctypes
 from typing import TYPE_CHECKING
 
 import pyglet
@@ -11,12 +10,13 @@ from pyglet.libs.darwin import (
     NSLeftCommandKeyMask,
     NSLeftControlKeyMask,
     NSLeftShiftKeyMask,
+    NSMakeRect,
     NSPasteboardURLReadingFileURLsOnlyKey,
     NSRightAlternateKeyMask,
     NSRightCommandKeyMask,
     NSRightControlKeyMask,
     NSRightShiftKeyMask,
-    cocoapy, NSMakeRect,
+    cocoapy,
 )
 from pyglet.libs.darwin.quartzkey import charmap, keymap
 from pyglet.window import key, mouse
@@ -24,6 +24,7 @@ from pyglet.window import key, mouse
 from .pyglet_textview import PygletTextView
 
 if TYPE_CHECKING:
+    import ctypes
     from . import CocoaWindow
 
 NSTrackingArea = cocoapy.ObjCClass('NSTrackingArea')
@@ -193,18 +194,18 @@ class PygletView_Implementation:
         # This method is called when view is first installed as the
         # contentView of window.  Don't do anything on first call.
         # This also helps ensure correct window creation event ordering.
-        if not self._window.context.canvas or self._window._shadow:
+        if not self._window.context.window or self._window._shadow:  # noqa: SLF001
             return
 
         width, height = int(size.width), int(size.height)
         self._window.switch_to()
-        self._window.context.update_geometry()
+        self._window._update_geometry()
         self._window._width, self._window._height = width, height  # noqa: SLF001
         self._window.dispatch_event('_on_internal_resize', width, height)
         self._window.dispatch_event('on_expose')
         # Can't get app.event_loop.enter_blocking() working with Cocoa, because
         # when mouse clicks on the window's resize control, Cocoa enters into a
-        # mini-event loop that only responds to mouseDragged and mouseUp events.
+        # mini-event loop that only responds to mouseDragged and  mouseUp events.
         # This means that using NSTimer to call idle() won't work.  Our kludge
         # is to override NSWindow's nextEventMatchingMask_etc method and call
         # idle() from there.
@@ -340,7 +341,7 @@ class PygletView_Implementation:
     def mouseEntered_(self, nsevent: cocoapy.ObjCInstance) -> None:
         x, y = getMousePosition(self, nsevent)
         self._window._mouse_in_window = True  # noqa: SLF001
-        # Don't call self._window.set_mouse_platform_visible() from here.
+        # Don't call self._window.set_mouse_cursor_platform_visible() from here.
         # Better to do it from cursorUpdate:
         self._window.dispatch_event('on_mouse_enter', x, y)
 
@@ -349,7 +350,7 @@ class PygletView_Implementation:
         x, y = getMousePosition(self, nsevent)
         self._window._mouse_in_window = False  # noqa: SLF001
         if not self._window._mouse_exclusive:  # noqa: SLF001
-            self._window.set_mouse_platform_visible()
+            self._window.set_mouse_cursor_platform_visible()
         self._window.dispatch_event('on_mouse_leave', x, y)
 
     @PygletView.method('v@')
@@ -363,7 +364,7 @@ class PygletView_Implementation:
         # to the default arrow and screw up our cursor tracking.
         self._window._mouse_in_window = True  # noqa: SLF001
         if not self._window._mouse_exclusive:  # noqa: SLF001
-            self._window.set_mouse_platform_visible()
+            self._window.set_mouse_cursor_platform_visible()
 
     @PygletView.method('Q@')
     def draggingEntered_(self, draginfo: cocoapy.ObjCInstance) -> int:

pyglet/window/dialog/__init__.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+import sys
+from pathlib import Path
+
+import pyglet
+from pyglet.event import EventDispatcher as _EventDispatcher, EVENT_HANDLE_STATE
+
+"""File dialog classes for opening and saving files.
+
+This module provides example Dialog Windows for opening and
+saving files. These are made using the `tkinter` module, which
+is part of the Python standard library. Dialog Windows run in a
+background process to prevent any interference with your main
+application, and integrate using the standard pyglet Event
+framework.
+
+Note that these dialogs do not actually open or save any data
+to disk. They simply return one or more strings, which contain
+the final file paths that were selected or entered. You can
+then use this information in your main application to handle
+the disk IO. This is done by attaching an event handler to the
+dialog, which will receive the file path(s) as an argument.
+
+Create a `FileOpenDialog` instance, and attach a handler to it::
+
+    # Restrict to only showing ".png" and ".bmp" file types,
+    # and allow selecting more than one file
+    open_dialog = FileOpenDialog(filetypes=[("PNG", ".png"), ("24-bit Bitmap", ".bmp")], multiple=True)
+
+    # Multiple filetypes can be specified in the same string as long as a space is used. Wildcards are also accepted.
+    open_dialog = FileOpenDialog(filetypes=[("Images", "*.png *.bmp *.jpg")], multiple=True)
+
+    @open_dialog.event
+    def on_dialog_open(filenames):
+        print("list of selected filenames:", filenames)
+        # Your own code here to handle loading the file name(s).
+
+    # Show the Dialog whenever you need. This is non-blocking:
+    open_dialog.show()
+
+
+The `FileSaveDialog` works similarly::
+
+    # Add a default file extension ".sav" to the file
+    save_as = FileSaveDialog(default_ext='.sav')
+
+    @save_as.event
+    def on_dialog_save(filename):
+        print("FILENAMES ON SAVE!", filename)
+        # Your own code here to handle saving the file name(s).
+
+    # Show the Dialog whenever you need. This is non-blocking:
+    open_dialog.show()
+"""
+
+_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
+
+class _OpenDialogMeta(type):
+    def __new__(cls, name: str, bases: tuple, attrs: dict) -> type:
+        if _is_pyglet_doc_run:
+            return super().__new__(cls, name, bases, attrs)
+
+        if pyglet.compat_platform == "win32":
+            from pyglet.window.dialog.windows import WindowsFileOpenDialog  # noqa: PLC0415
+            return WindowsFileOpenDialog
+        if pyglet.compat_platform == "darwin":
+             from pyglet.window.dialog.darwin import MacOSFileOpenDialog  # noqa: PLC0415
+             return MacOSFileOpenDialog
+        if pyglet.compat_platform == "linux":
+            from pyglet.window.dialog.linux import TkFileOpenDialog  # noqa: PLC0415
+            return TkFileOpenDialog
+
+        return super().__new__(cls, name, bases, attrs)
+
+
+class FileOpenDialog(_EventDispatcher, metaclass=_OpenDialogMeta):
+    """Opens a system file dialog window for opening files.
+
+    .. versionadded:: 3.0
+    """
+    def __init__(
+        self, title: str="Open File", initial_dir: str | Path | None= None, initial_file: str | None=None,
+            filetypes: list[tuple[str, str]] | None=None, multiple: bool=False) -> None:
+        """Establish how the open file dialog will behave.
+
+        Args:
+            title:
+                The Dialog Window name. Defaults to "Open File".
+            initial_dir:
+                The directory to start in. If a path is not given, it is up the OS to determine behavior.
+                On Windows, if None is passed, it will open to the last used directory.
+            initial_file:
+                The filename to prepopulate with when opening. Not supported on Mac OS.
+            filetypes:
+                An optional list of tuples containing (name, extension) to filter by.
+                If none are given, all files will be shown and selectable.
+                For example: `[("PNG", ".png"), ("24-bit Bitmap", ".bmp")]`
+                For multiple file types in the same selection, separate by a semicolon.
+                For example: [("Images", ".png;.bmp")]`
+            multiple: bool
+                True if multiple files can be selected. Defaults to False.
+        """
+        self.title = title
+        self.initial_dir = initial_dir
+        self.filetypes = filetypes
+        self.multiple = multiple
+        self.initial_file = initial_file
+
+    def open(self) -> None:
+        """Open a file dialog window to select files according to the configuration."""
+        raise NotImplementedError
+
+    def on_dialog_open(self, filenames: list[str]) -> EVENT_HANDLE_STATE:
+        """Event for filename choice.
+
+        Args:
+            filenames:
+                The selected filename paths chosen by the user. May be empty if nothing is chosen.
+        """
+
+class _SaveDialogMeta(type):
+    def __new__(cls, name: str, bases: tuple, attrs: dict) -> type:
+        if _is_pyglet_doc_run:
+            return super().__new__(cls, name, bases, attrs)
+
+        if pyglet.compat_platform == "win32":
+            from pyglet.window.dialog.windows import WindowsFileSaveDialog  # noqa: PLC0415
+            return WindowsFileSaveDialog
+        if pyglet.compat_platform == "darwin":
+            from pyglet.window.dialog.darwin import MacOSFileSaveDialog  # noqa: PLC0415
+            return MacOSFileSaveDialog
+        if pyglet.compat_platform == "linux":
+            from pyglet.window.dialog.linux import TkFileSaveDialog  # noqa: PLC0415
+            return TkFileSaveDialog
+
+        return super().__new__(cls, name, bases, attrs)
+
+class FileSaveDialog(_EventDispatcher, metaclass=_SaveDialogMeta):
+    """Opens a system file dialog window for saving files.
+
+    .. versionadded:: 3.0
+    """
+    def __init__(self, title: str="Save As", initial_dir: str | Path | None=None, initial_file: str | None=None,
+                 filetypes: list[tuple[str, str]] | None=None, default_ext: str="") -> None:
+        """Establish how the save file dialog will behave.
+
+        Args:
+            title:
+                The Dialog Window name. Defaults to "Save As".
+            initial_dir:
+                The directory to start in. If a path is not given, it is up the OS to determine behavior.
+                On Windows, if None is passed, it will open to the last used directory.
+            initial_file:
+                A default file name to be filled in. Defaults to None.
+            filetypes:
+                An optional list of tuples containing (name, extension) to
+                filter to. If the `default_ext` argument is not given, this list
+                also dictates the extension that will be added to the entered
+                file name. If a list of `filetypes` are not give, you can enter
+                any file name to save as.
+                For example: `[("PNG", ".png"), ("24-bit Bitmap", ".bmp")]`
+            default_ext:
+                A default file extension to add to the file. This will override
+                the `filetypes` list if given, but will not override a manually
+                entered extension.
+        """
+        self.title = title
+        self.initial_dir = initial_dir or Path.cwd()
+        self.filetypes = filetypes
+        self.initial_file = initial_file
+        self.default_ext = default_ext
+
+    def open(self) -> None:
+        """Open the file dialog window to save files according to the configuration."""
+        raise NotImplementedError
+
+    def on_dialog_save(self, filename: str) -> EVENT_HANDLE_STATE:
+        """Event for filename choice.
+
+        Args:
+            filename:
+                The resulting filename a user input. The string may be empty if user input nothing or cancelled
+                the operation.
+        """

pyglet/window/dialog/base.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+
+from pyglet.event import EventDispatcher as _EventDispatcher
+from pathlib import Path
+
+
+class _Dialog(_EventDispatcher):
+    """Dialog base class
+
+    This base class sets up a ProcessPoolExecutor with a single
+    background Process. This allows the Dialog to display in
+    the background without blocking or interfering with the main
+    application Process. This also limits to a single open Dialog
+    at a time.
+    """
+    _dialog = None
+
+    @abstractmethod
+    def open(self):
+        ...
+
+    def _dispatch_event(self, future):
+        raise NotImplementedError
+
+
+class FileOpenDialogBase(_Dialog):
+    def __init__(
+        self, title: str="Open File", initial_dir: str | Path | None = None, initial_file: str | None=None,
+            filetypes: list[tuple[str, str]] | None=None, multiple: bool=False,
+    ):
+        """Establish how the file dialog will behave.
+
+        title:
+            The Dialog Window name. Defaults to "Open File".
+        initial_dir:
+            The directory to start in. If a path is not given, it is up the OS to determine behavior.
+            On Windows, if None is passed, it will open to the last used directory.
+        initial_file:
+            The filename to prepopulate with when opening. Not supported on Mac OS.
+        filetypes:
+            An optional list of tuples containing (name, extension) to filter by.
+            If none are given, all files will be shown and selectable.
+            For example: `[("PNG", ".png"), ("24-bit Bitmap", ".bmp")]`
+            For multiple file types in the same selection, separate by a semicolon.
+            For example: [("Images", ".png;.bmp")]`
+        multiple: bool
+            True if multiple files can be selected. Defaults to False.
+        """
+        self.title = title
+        self.initial_dir = initial_dir
+        self.filetypes = filetypes
+        self.multiple = multiple
+        self.initial_file = initial_file
+
+    def open(self):
+        raise NotImplementedError
+
+FileOpenDialogBase.register_event_type('on_dialog_open')
+
+class FileSaveDialogBase(_Dialog):
+
+    def __init__(self, title="Save As", initial_dir: str | Path | None=None, initial_file=None, filetypes=None, default_ext=""):
+        """Establish how the save file dialog will behave.
+
+        title:
+            The Dialog Window name. Defaults to "Save As".
+        initial_dir:
+            The directory to start in. If a path is not given, it is up the OS to determine behavior.
+            On Windows, if None is passed, it will open to the last used directory.
+        initial_file:
+            A default file name to be filled in. Defaults to None.
+        filetypes:
+            An optional list of tuples containing (name, extension) to
+            filter to. If the `default_ext` argument is not given, this list
+            also dictates the extension that will be added to the entered
+            file name. If a list of `filetypes` are not give, you can enter
+            any file name to save as.
+            For example: `[("PNG", ".png"), ("24-bit Bitmap", ".bmp")]`
+        default_ext:
+            A default file extension to add to the file. This will override
+            the `filetypes` list if given, but will not override a manually
+            entered extension.
+        """
+        self.title = title
+        self.initial_dir = initial_dir
+        self.filetypes = filetypes
+        self.initial_file = initial_file
+        self.default_ext = default_ext
+
+    def open(self) -> None:
+        raise NotImplementedError
+
+    def on_dialog_save(self, filename):
+        """Event for filename choice"""
+
+
+FileSaveDialogBase.register_event_type('on_dialog_save')