toga-winforms 0.5.4__py3-none-win_arm64.whl

toga_winforms/__init__.py

@@ -0,0 +1,106 @@
+import os
+import platform
+from pathlib import Path
+
+import clr_loader
+from pythonnet import set_runtime
+
+try:
+    ####################################################################################
+    # Toga Winforms requires the use of .NET; either .NET Framework 4.x, or .NET Core.
+    #
+    # .NET Framework 4.x is available by default on Windows 10 and 11. However, on
+    # Windows on ARM64, it is an x86-64 binary, so it can't be used by a native ARM64
+    # Python interpreter.
+    #
+    # However, it *can* be used on ARM64 if you have an x86-64 Python interpreter -
+    # which is what you get if you run `py install -3.13` or `py install -3.14`. This
+    # will apparently change in Python 3.15.
+    #
+    # Using .NET Core requires a separate install - but it will be present on a lot of
+    # systems.
+    #
+    # So - try to load .NET Core; if it succeeds, use it. If the load fails, fall back
+    # to .NET Framework. If we're on ARM64, check to see if the interpreter is running
+    # in emulation mode. If it is, we're OK; if we're not, stop the interpreter; the
+    # .NET gives instructions on how to install .NET.
+    #
+    # But: If TOGA_WINFORMS_USE_NETFX is defined in the environment, ignore .NET Core
+    # and prefer .NET Framework 4.x
+    ####################################################################################
+    if os.environ.get("TOGA_WINFORMS_USE_NETFX", ""):  # pragma: no-cover-if-netcore
+        raise RuntimeError("Explicitly requesting .NET Framework 4.x")
+    else:  # pragma: no-cover-if-netfx
+        # runtime.json defines the .NET version. .NET 10 is the current LTS release.
+        set_runtime(
+            clr_loader.get_coreclr(
+                runtime_config=Path(__file__).parent / "resources/runtime.json"
+            )
+        )
+
+        # .NET Core load succeeded
+        _use_dotnet_core = True
+except (clr_loader.util.clr_error.ClrError, RuntimeError):  # pragma: no cover
+    # .NET Core load failed. This whole branch is no-cover because we can't
+    # easily describe no-cover conditions for the failure modes.
+    if platform.machine() == "ARM64" and "ARM64" in platform.python_compiler():
+        # If you're on a native ARM64 machine running an ARM64 Python, .NET Framework
+        # 4.x isn't an option. On Python 3.10 and 3.11, an x86-64 Python running on
+        # ARM64 will return `platform.machine() == "AMD64"`, so it fails the first
+        # part of the test.
+        raise RuntimeError("""
+
+On Windows, Toga requires .NET Core 10. Please visit:
+
+    https://dotnet.microsoft.com/en-us/download/dotnet/10.0
+
+and install the .NET Desktop Runtime.""") from None
+    else:
+        # Either a native x86_64 machine, or an ARM64 machine with and x86_64 Python
+        # interpreter in emulation mode. We can use .NET Framework 4.x
+        _use_dotnet_core = False
+
+
+import clr
+import travertino
+
+from .libs.user32 import SetProcessDpiAwarenessContext
+from .libs.win32constants import DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
+
+# Add a reference to the Winforms assembly
+clr.AddReference("System.Windows.Forms")
+
+# .NET Core requires some other explicit assemblies
+if _use_dotnet_core:  # pragma: no-cover-if-netfx
+    clr.AddReference("Microsoft.Win32.SystemEvents")
+    clr.AddReference("System.Windows.Extensions")
+else:  # pragma: no-cover-if-netcore
+    # We can't do conditional branch coverage, so we need a no-op else
+    pass
+
+# Add a reference to the WindowsBase assembly. This is needed to access
+# System.Windows.Threading.Dispatcher.
+#
+# This assembly isn't exposed as a simple dot-path name; we have to extract it from the
+# Global Assembly Cache (GAC). The version number and public key doesn't appear to
+# change with Windows version or the underlying .NET, and has been available since
+# Windows 7.
+clr.AddReference(
+    "WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
+)
+
+
+# Enable DPI awareness. This must be done before calling any other UI-related code
+# (https://learn.microsoft.com/en-us/dotnet/desktop/winforms/high-dpi-support-in-windows-forms).
+import System.Windows.Forms as WinForms  # noqa: E402
+
+WinForms.Application.EnableVisualStyles()
+WinForms.Application.SetCompatibleTextRenderingDefault(False)
+
+if SetProcessDpiAwarenessContext is not None:
+    if not SetProcessDpiAwarenessContext(
+        DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
+    ):  # pragma: no cover
+        print("WARNING: Failed to set the DPI Awareness mode for the app.")
+
+__version__ = travertino._package_version(__file__, __name__)

toga_winforms/app.py

@@ -0,0 +1,275 @@
+import asyncio
+import re
+import sys
+import threading
+
+import System.Windows.Forms as WinForms
+from Microsoft.Win32 import SystemEvents
+from System import Threading
+from System.Media import SystemSounds
+from System.Net import SecurityProtocolType, ServicePointManager
+from System.Windows.Threading import Dispatcher
+
+from toga.dialogs import InfoDialog
+from toga.handlers import WeakrefCallable
+
+from .libs.proactor import WinformsProactorEventLoop
+from .screens import Screen as ScreenImpl
+
+
+def winforms_thread_exception(sender, winforms_exc):  # pragma: no cover
+    # The PythonException returned by Winforms doesn't give us
+    # easy access to the underlying Python stacktrace; so we
+    # reconstruct it from the string message.
+    # The Python message is helpfully included in square brackets,
+    # as the context for the first line in the .net stack trace.
+    # So, look for the closing bracket and the start of the Python.net
+    # stack trace. Then, reconstruct the line breaks internal to the
+    # remaining string.
+    print("Traceback (most recent call last):")
+    py_exc = winforms_exc.get_Exception()
+    full_stack_trace = py_exc.StackTrace
+    regex = re.compile(
+        r"^\[(?:'(.*?)', )*(?:'(.*?)')\]   (?:.*?) Python\.Runtime",
+        re.DOTALL | re.UNICODE,
+    )
+
+    def print_stack_trace(stack_trace_line):  # pragma: no cover
+        for level in stack_trace_line.split("', '"):
+            for line in level.split("\\n"):
+                if line:
+                    print(line)
+
+    stacktrace_relevant_lines = regex.findall(full_stack_trace)
+    if len(stacktrace_relevant_lines) == 0:
+        print_stack_trace(full_stack_trace)
+    else:
+        for lines in stacktrace_relevant_lines:
+            for line in lines:
+                print_stack_trace(line)
+
+    print(py_exc.Message)
+
+
+class App:
+    # Winforms apps exit when the last window is closed
+    CLOSE_ON_LAST_WINDOW = True
+    # Winforms apps use default command line handling
+    HANDLES_COMMAND_LINE = False
+
+    def __init__(self, interface):
+        self.interface = interface
+        self.interface._impl = self
+
+        # Track whether the app is exiting. This is used to stop the event loop,
+        # and shortcut close handling on any open windows when the app exits.
+        self._is_exiting = False
+        self._exiting_presentation = False
+
+        # Winforms cursor visibility is a stack; If you call hide N times, you
+        # need to call Show N times to make the cursor re-appear. Store a local
+        # boolean to allow us to avoid building a deep stack.
+        self._cursor_visible = True
+
+        self.loop = WinformsProactorEventLoop()
+        asyncio.set_event_loop(self.loop)
+
+    def create(self):
+        self.native = WinForms.Application
+        self.app_context = WinForms.ApplicationContext()
+        self.app_dispatcher = Dispatcher.CurrentDispatcher
+
+        # We would prefer to detect DPI changes directly, using the DpiChanged,
+        # DpiChangedBeforeParent or DpiChangedAfterParent events on the window. But none
+        # of these events ever fire, possibly because we're missing some app metadata
+        # (https://github.com/beeware/toga/pull/2155#issuecomment-2460374101). So
+        # instead we need to listen to all events which could cause a DPI change:
+        #   * DisplaySettingsChanged
+        #   * Form.LocationChanged and Form.Resize, since a window's DPI is determined
+        #     by which screen most of its area is on.
+        SystemEvents.DisplaySettingsChanged += WeakrefCallable(
+            self.winforms_DisplaySettingsChanged
+        )
+
+        # Ensure that TLS1.2 and TLS1.3 are enabled for HTTPS connections.
+        # For some reason, some Windows installs have these protocols
+        # turned off by default. SSL3, TLS1.0 and TLS1.1 are *not* enabled
+        # as they are deprecated protocols and their use should *not* be
+        # encouraged.
+        try:
+            ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12
+        except AttributeError:  # pragma: no cover
+            print(
+                "WARNING: Your Windows .NET install does not support TLS1.2. "
+                "You may experience difficulties accessing some web server content."
+            )
+        try:
+            ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls13
+        except AttributeError:  # pragma: no cover
+            print(
+                "WARNING: Your Windows .NET install does not support TLS1.3. "
+                "You may experience difficulties accessing some web server content."
+            )
+
+        # Populate the main window as soon as the event loop is running.
+        self.loop.call_soon_threadsafe(self.interface._startup)
+
+    ######################################################################
+    # Native event handlers
+    ######################################################################
+
+    def winforms_DisplaySettingsChanged(self, sender, event):
+        # This event is NOT called on the UI thread, so it's not safe for it to access
+        # the UI directly.
+        self.interface.loop.call_soon_threadsafe(self.update_dpi)
+
+    def update_dpi(self):
+        for window in self.interface.windows:
+            window._impl.update_dpi()
+
+    ######################################################################
+    # Commands and menus
+    ######################################################################
+
+    def create_standard_commands(self):
+        pass
+
+    def create_menus(self):
+        # Winforms menus are created on the Window.
+        for window in self.interface.windows:
+            # It's difficult to trigger this on a simple window, because we can't easily
+            # modify the set of app-level commands that are registered, and a simple
+            # window doesn't exist when the app starts up. Therefore, no-branch the else
+            # case.
+            if hasattr(window._impl, "create_menus"):  # pragma: no branch
+                window._impl.create_menus()
+
+    ######################################################################
+    # App lifecycle
+    ######################################################################
+
+    def exit(self):  # pragma: no cover
+        self._is_exiting = True
+        self.native.Exit()
+
+    def _run_app(self):  # pragma: no cover
+        # Enable coverage tracing on this non-Python-created thread
+        # (https://github.com/nedbat/coveragepy/issues/686).
+        if threading._trace_hook:
+            sys.settrace(threading._trace_hook)
+
+        try:
+            self.create()
+
+            # This catches errors in handlers, and prints them
+            # in a usable form.
+            self.native.ThreadException += WeakrefCallable(winforms_thread_exception)
+
+            self.loop.run_forever(self)
+        except Exception as e:
+            # In case of an unhandled error at the level of the app,
+            # preserve the Python stacktrace
+            self._exception = e
+        else:
+            # Ensure the event loop is fully closed.
+            self.loop.close()
+            self._exception = None
+
+    def main_loop(self):
+        thread = Threading.Thread(Threading.ThreadStart(self._run_app))
+        thread.SetApartmentState(Threading.ApartmentState.STA)
+        thread.Start()
+        thread.Join()
+
+        # If the thread has exited, the _exception attribute will exist.
+        # If it's non-None, raise it, as it indicates the underlying
+        # app thread had a problem; this is effectibely a re-raise over
+        # a thread boundary.
+        if self._exception:  # pragma: no cover
+            raise self._exception
+
+    def set_icon(self, icon):
+        for window in self.interface.windows:
+            window._impl.native.Icon = icon._impl.native
+
+    def set_main_window(self, window):
+        pass
+
+    ######################################################################
+    # App resources
+    ######################################################################
+
+    def get_primary_screen(self):
+        return ScreenImpl(WinForms.Screen.PrimaryScreen)
+
+    def get_screens(self):
+        primary_screen = self.get_primary_screen()
+        screen_list = [primary_screen] + [
+            ScreenImpl(native=screen)
+            for screen in WinForms.Screen.AllScreens
+            if screen != primary_screen.native
+        ]
+        return screen_list
+
+    ######################################################################
+    # App state
+    ######################################################################
+
+    def get_dark_mode_state(self):
+        self.interface.factory.not_implemented("dark mode state")
+        return None
+
+    ######################################################################
+    # App capabilities
+    ######################################################################
+
+    def beep(self):
+        SystemSounds.Beep.Play()
+
+    def show_about_dialog(self):
+        message_parts = []
+        if self.interface.version is not None:
+            message_parts.append(
+                f"{self.interface.formal_name} v{self.interface.version}"
+            )
+        else:
+            message_parts.append(self.interface.formal_name)
+
+        if self.interface.author is not None:
+            message_parts.append(f"Author: {self.interface.author}")
+        if self.interface.description is not None:
+            message_parts.append(f"\n{self.interface.description}")
+        asyncio.create_task(
+            self.interface.dialog(
+                InfoDialog(
+                    f"About {self.interface.formal_name}", "\n".join(message_parts)
+                )
+            )
+        )
+
+    ######################################################################
+    # Cursor control
+    ######################################################################
+
+    def hide_cursor(self):
+        if self._cursor_visible:
+            WinForms.Cursor.Hide()
+        self._cursor_visible = False
+
+    def show_cursor(self):
+        if not self._cursor_visible:
+            WinForms.Cursor.Show()
+        self._cursor_visible = True
+
+    ######################################################################
+    # Window control
+    ######################################################################
+
+    def get_current_window(self):
+        for window in self.interface.windows:
+            if WinForms.Form.ActiveForm == window._impl.native:
+                return window._impl
+        return None
+
+    def set_current_window(self, window):
+        window._impl.native.Activate()

toga_winforms/colors.py

@@ -0,0 +1,24 @@
+from System.Drawing import Color
+
+from toga.colors import TRANSPARENT, rgb
+
+CACHE = {TRANSPARENT: Color.Transparent}
+
+
+def native_color(c):
+    try:
+        color = CACHE[c]
+    except KeyError:
+        color = Color.FromArgb(
+            int(c.rgb.a * 255),
+            int(c.rgb.r),
+            int(c.rgb.g),
+            int(c.rgb.b),
+        )
+        CACHE[c] = color
+
+    return color
+
+
+def toga_color(c):
+    return rgb(c.R, c.G, c.B, c.A / 255)

toga_winforms/command.py

@@ -0,0 +1,121 @@
+import sys
+
+from System.ComponentModel import InvalidEnumArgumentException
+
+from toga import Command as StandardCommand, Group, Key
+from toga.handlers import WeakrefCallable
+from toga_winforms.keys import toga_to_winforms_key, toga_to_winforms_shortcut
+
+
+class Command:
+    def __init__(self, interface):
+        self.interface = interface
+        self.native = []
+
+    @classmethod
+    def standard(self, app, id):
+        # ---- File menu -----------------------------------
+        if id == StandardCommand.NEW:
+            return {
+                "text": "New",
+                "shortcut": Key.MOD_1 + "n",
+                "group": Group.FILE,
+                "section": 0,
+                "order": 0,
+            }
+        elif id == StandardCommand.OPEN:
+            return {
+                "text": "Open...",
+                "shortcut": Key.MOD_1 + "o",
+                "group": Group.FILE,
+                "section": 0,
+                "order": 10,
+            }
+        elif id == StandardCommand.SAVE:
+            return {
+                "text": "Save",
+                "shortcut": Key.MOD_1 + "s",
+                "group": Group.FILE,
+                "section": 0,
+                "order": 20,
+            }
+        elif id == StandardCommand.SAVE_AS:
+            return {
+                "text": "Save As...",
+                "shortcut": Key.MOD_1 + "S",
+                "group": Group.FILE,
+                "section": 0,
+                "order": 21,
+            }
+        elif id == StandardCommand.SAVE_ALL:
+            return {
+                "text": "Save All",
+                "shortcut": Key.MOD_1 + Key.MOD_2 + "s",
+                "group": Group.FILE,
+                "section": 0,
+                "order": 22,
+            }
+        elif id == StandardCommand.PREFERENCES:
+            # Preferences should be towards the end of the File menu.
+            return {
+                "text": "Preferences",
+                "group": Group.FILE,
+                "section": sys.maxsize - 1,
+            }
+        elif id == StandardCommand.EXIT:
+            # Quit should always be the last item, in a section on its own.
+            return {
+                "text": "Exit",
+                "group": Group.FILE,
+                "section": sys.maxsize,
+            }
+        # ---- Help menu -----------------------------------
+        elif id == StandardCommand.VISIT_HOMEPAGE:
+            return {
+                "text": "Visit homepage",
+                "enabled": app.home_page is not None,
+                "group": Group.HELP,
+            }
+        elif id == StandardCommand.ABOUT:
+            return {
+                "text": f"About {app.formal_name}",
+                "group": Group.HELP,
+                "section": sys.maxsize,
+            }
+
+        raise ValueError(f"Unknown standard command {id!r}")
+
+    def winforms_Click(self, sender, event):
+        return self.interface.action()
+
+    def set_enabled(self, value):
+        if self.native:
+            for widget in self.native:
+                widget.Enabled = self.interface.enabled
+
+    def create_menu_item(self, WinformsClass):
+        item = WinformsClass(self.interface.text)
+
+        item.Click += WeakrefCallable(self.winforms_Click)
+        if self.interface.shortcut is not None:
+            try:
+                item.ShortcutKeys = toga_to_winforms_key(self.interface.shortcut)
+                # The Winforms key enum is... daft. The "oem" key
+                # values render as "Oem" or "Oemcomma", so we need to
+                # *manually* set the display text for the key shortcut.
+                item.ShortcutKeyDisplayString = toga_to_winforms_shortcut(
+                    self.interface.shortcut
+                )
+            except (
+                ValueError,
+                InvalidEnumArgumentException,
+            ) as e:  # pragma: no cover
+                # Make this a non-fatal warning, because different backends may
+                # accept different shortcuts.
+                print(f"WARNING: invalid shortcut {self.interface.shortcut!r}: {e}")
+
+        item.Enabled = self.interface.enabled
+
+        self.native.append(item)
+
+        return item

toga_winforms/container.py

@@ -0,0 +1,70 @@
+import System.Windows.Forms as WinForms
+from System.Drawing import Size
+
+from .widgets.base import Scalable
+
+
+class Container(Scalable):
+    def __init__(self, native_parent):
+        self.native_parent = native_parent
+        self.native_width = self.native_height = 0
+        self.content = None
+
+        self.native_content = WinForms.Panel()
+        native_parent.Controls.Add(self.native_content)
+
+        # See comment in Widget.__init__.
+        self.native_content.CreateGraphics().Dispose()
+
+    @property
+    def dpi_scale(self):
+        window = self.content.interface.window if self.content else None
+        if window:
+            return window._impl.dpi_scale
+        else:
+            return 1
+
+    @property
+    def width(self):
+        return self.scale_out(self.native_width)
+
+    @property
+    def height(self):
+        return self.scale_out(self.native_height)
+
+    def set_content(self, widget):
+        self.clear_content()
+        if widget:
+            widget.container = self
+            self.content = widget
+
+    def clear_content(self):
+        if self.content:
+            self.content.container = None
+            self.content = None
+
+    def resize_content(self, width, height, *, force_refresh=False):
+        if (self.native_width, self.native_height) != (width, height):
+            self.native_width, self.native_height = (width, height)
+            force_refresh = True
+
+        if force_refresh and self.content:
+            self.content.interface.refresh()
+
+    def refreshed(self):
+        layout = self.content.interface.layout
+        self.apply_layout(layout.width, layout.height)
+
+    def apply_layout(self, layout_width, layout_height):
+        self.native_content.Size = Size(
+            self.scale_in(max(self.width, layout_width)),
+            self.scale_in(max(self.height, layout_height)),
+        )
+
+    def add_content(self, widget):
+        # The default is to add new controls to the back of the Z-order.
+        self.native_content.Controls.Add(widget.native)
+        widget.native.BringToFront()
+
+    def remove_content(self, widget):
+        self.native_content.Controls.Remove(widget.native)