win32more-appsdk 0.7.0__tar.gz

win32more_appsdk-0.7.0/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

win32more_appsdk-0.7.0/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: win32more-appsdk
+Version: 0.7.0
+Requires-Dist: win32more-core==0.7.*

win32more_appsdk-0.7.0/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "win32more-appsdk"
+version = "0.7.0"
+dependencies = ["win32more-core==0.7.*"]
+
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/win32more"]

win32more_appsdk-0.7.0/src/win32more/Microsoft/__init__.py

@@ -0,0 +1,3 @@
+import win32more.appsdk
+
+win32more.appsdk.initialize()

win32more_appsdk-0.7.0/src/win32more/appsdk/__init__.py

@@ -0,0 +1,10 @@
+# ruff: noqa: F401
+
+# versioninfo.py will be installed by win32more-Microsoft.WindowsAppSDK
+from .versioninfo import (  # noqa
+    WINDOWSAPPSDK_RELEASE_MAJORMINOR,
+    WINDOWSAPPSDK_RELEASE_VERSION_SHORTTAG_W,
+    WINDOWSAPPSDK_RUNTIME_VERSION_UINT64,
+)
+
+from ._runtime import initialize, is_self_contained, get_loaded_appsdk_info, RuntimeNotFoundError

win32more_appsdk-0.7.0/src/win32more/appsdk/_packaging.py

@@ -0,0 +1,114 @@
+from ctypes import pointer
+
+from win32more import FAILED, Byte, Char, String, UInt32, WinError
+from win32more._win32 import ARCH
+from win32more.Windows.Win32.Foundation import (
+    APPMODEL_ERROR_NO_PACKAGE,
+    ERROR_INSUFFICIENT_BUFFER,
+    ERROR_SUCCESS,
+)
+from win32more.Windows.Win32.Storage.Packaging.Appx import (
+    PACKAGE_FILTER_DYNAMIC,
+    PACKAGE_FILTER_STATIC,
+    PACKAGE_INFO,
+    PACKAGE_VERSION,
+    GetCurrentPackageFullName,
+)
+from win32more.Windows.Win32.Storage.Packaging.Appx import GetCurrentPackageInfo as _GetCurrentPackageInfo
+from win32more.Windows.Win32.Storage.Packaging.Appx import GetPackagePathByFullName as _GetPackagePathByFullName
+from win32more.Windows.Win32.Storage.Packaging.Appx import GetPackagesByPackageFamily as _GetPackagesByPackageFamily
+
+
+def IsPackagedProcess() -> bool:
+    return GetCurrentPackageFullName(UInt32(), None) != APPMODEL_ERROR_NO_PACKAGE
+
+
+# https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/package-identity-overview
+def GetFrameworkPackageFamilyName(major_minor_version: int, version_tag: PACKAGE_VERSION) -> str:
+    major_version = major_minor_version >> 16
+    minor_version = major_minor_version & 0xFFFF
+    version_tag_delimiter = "" if version_tag == "" else "-"
+    name = f"Microsoft.WindowsAppRuntime.{major_version}.{minor_version}{version_tag_delimiter}{version_tag}"
+    publisher_id = "8wekyb3d8bbwe"
+    return f"{name}_{publisher_id}"
+
+
+def GetFrameworkPackageDirectory(
+    major_minor_version: int, version_tag: str, min_version: PACKAGE_VERSION
+) -> str | None:
+    family_name = GetFrameworkPackageFamilyName(major_minor_version, version_tag)
+    full_name = ResolvePackageDependency(family_name, min_version, ARCH)
+    if full_name is None:
+        return None
+    return GetPackagePathByFullName(full_name)
+
+
+def ResolvePackageDependency(family_name: str, min_version: PACKAGE_VERSION, arch: str) -> str | None:
+    bestfit = None
+    latest_version = None
+
+    for full_name in GetPackagesByPackageFamily(family_name):
+        name, version, architecture, resource_id, publisher_id = full_name.split("_")
+        major, minor, build, revision = [int(x) for x in version.split(".")]
+        if architecture.upper() != arch:
+            continue
+        if (major, minor, build, revision) < (
+            min_version.Major,
+            min_version.Minor,
+            min_version.Build,
+            min_version.Revision,
+        ):
+            continue
+        if latest_version is None or latest_version < (major, minor, build, revision):
+            bestfit = full_name
+            latest_version = (major, minor, build, revision)
+
+    return bestfit
+
+
+def GetPackagesByPackageFamily(family_name: str) -> list[str]:
+    count = UInt32()
+    buffer_length = UInt32()
+    r = _GetPackagesByPackageFamily(family_name, count, None, buffer_length, None)
+    if r == ERROR_SUCCESS:
+        return []  # not found
+    elif r != ERROR_INSUFFICIENT_BUFFER:
+        raise WinError(r)
+
+    full_names = (String * count.value)()
+    buffer = (Char * buffer_length.value)()
+    r = _GetPackagesByPackageFamily(family_name, count, full_names, buffer_length, buffer)
+    if r != ERROR_SUCCESS:
+        raise WinError(r)
+
+    return full_names[: count.value]
+
+
+def GetPackagePathByFullName(full_name: str) -> str:
+    path_length = UInt32()
+    r = _GetPackagePathByFullName(full_name, path_length, None)
+    if r != ERROR_INSUFFICIENT_BUFFER:
+        raise WinError(r)
+
+    path = (Char * path_length.value)()
+    r = _GetPackagePathByFullName(full_name, path_length, path)
+    if r != ERROR_SUCCESS:
+        raise WinError(r)
+
+    return path.value
+
+
+def GetCurrentPackageInfo(flags=PACKAGE_FILTER_DYNAMIC | PACKAGE_FILTER_STATIC) -> list[PACKAGE_INFO]:
+    size = UInt32()
+    r = _GetCurrentPackageInfo(flags, size, None, None)
+    if r != ERROR_INSUFFICIENT_BUFFER:
+        raise WinError(r)
+
+    buf = bytearray(size.value)
+    pinfo = pointer(PACKAGE_INFO.from_buffer(buf))
+    count = UInt32()
+    r = _GetCurrentPackageInfo(flags, size, Byte.from_buffer(buf), count)
+    if FAILED(r):
+        raise WinError(r)
+
+    return pinfo[0 : count.value]

win32more_appsdk-0.7.0/src/win32more/appsdk/_runtime.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from win32more import FAILED, ComError, windll
+from win32more.Windows.Win32.Foundation import APPMODEL_ERROR_NO_PACKAGE, STATEREPOSITORY_E_DEPENDENCY_NOT_RESOLVED
+from win32more.Windows.Win32.Storage.Packaging.Appx import PACKAGE_INFO, PACKAGE_VERSION
+
+from . import (
+    WINDOWSAPPSDK_RELEASE_MAJORMINOR,
+    WINDOWSAPPSDK_RELEASE_VERSION_SHORTTAG_W,
+    WINDOWSAPPSDK_RUNTIME_VERSION_UINT64,
+)
+from ._packaging import GetCurrentPackageInfo, GetFrameworkPackageFamilyName
+from .mddbootstrap import MddBootstrapInitialize, _OnNoMatch_ShowUI
+
+
+class RuntimeNotFoundError(OSError):
+    def __init__(self) -> None:
+        major = WINDOWSAPPSDK_RELEASE_MAJORMINOR >> 16
+        minor = WINDOWSAPPSDK_RELEASE_MAJORMINOR & 0xFFFF
+        min_version = PACKAGE_VERSION(Version=WINDOWSAPPSDK_RUNTIME_VERSION_UINT64)
+        msg = f"This application requires the Windows App Runtime Version {major}.{minor} (MSIX package version >= {min_version.Major}.{min_version.Minor}.{min_version.Build}.{min_version.Revision})"
+        super().__init__(STATEREPOSITORY_E_DEPENDENCY_NOT_RESOLVED, msg)
+
+    def show_dialog(self) -> None:
+        _OnNoMatch_ShowUI(
+            WINDOWSAPPSDK_RELEASE_MAJORMINOR,
+            WINDOWSAPPSDK_RELEASE_VERSION_SHORTTAG_W,
+            PACKAGE_VERSION(Version=WINDOWSAPPSDK_RUNTIME_VERSION_UINT64),
+        )
+
+
+def initialize() -> None:
+    if _appsdk_runtime_dll_exists():
+        # case 1: This is packaged application and appsdk is statically loaded via AppxManifest.xml settings.
+        # case 2: Application is self-contained package.
+        return
+
+    hr = MddBootstrapInitialize(
+        WINDOWSAPPSDK_RELEASE_MAJORMINOR,
+        WINDOWSAPPSDK_RELEASE_VERSION_SHORTTAG_W,
+        PACKAGE_VERSION(Version=WINDOWSAPPSDK_RUNTIME_VERSION_UINT64),
+    )
+
+    if FAILED(hr):
+        if hr == STATEREPOSITORY_E_DEPENDENCY_NOT_RESOLVED:
+            raise RuntimeNotFoundError()
+        raise ComError(hr)
+
+
+def get_loaded_appsdk_info() -> PACKAGE_INFO:
+    family_name = GetFrameworkPackageFamilyName(
+        WINDOWSAPPSDK_RELEASE_MAJORMINOR, WINDOWSAPPSDK_RELEASE_VERSION_SHORTTAG_W
+    )
+    for info in GetCurrentPackageInfo():
+        if info.packageFamilyName == family_name:
+            return info
+    raise LookupError(f"{family_name} is not loaded")
+
+
+# WindowsAppRuntime_IsSelfContained()
+def is_self_contained() -> bool:
+    try:
+        get_loaded_appsdk_info()
+    except LookupError:
+        return True
+    except OSError as e:
+        if e.winerror == APPMODEL_ERROR_NO_PACKAGE:
+            # Process is not packaged process and appsdk is not loaded dynamically.
+            return True
+        raise
+    return False
+
+
+def _appsdk_runtime_dll_exists() -> bool:
+    try:
+        windll["Microsoft.WindowsAppRuntime.dll"]
+    except AttributeError:
+        return False
+    return True

win32more_appsdk-0.7.0/src/win32more/appsdk/mddbootstrap.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import os
+import sys
+import webbrowser
+from pathlib import Path
+
+import win32more
+from win32more import FAILED, Int32, String, UInt32, Void
+from win32more._win32 import ARCH, winfunctype
+from win32more.Windows.Win32.Foundation import (
+    HRESULT,
+    S_OK,
+    STATEREPOSITORY_E_DEPENDENCY_NOT_RESOLVED,
+)
+from win32more.Windows.Win32.Storage.Packaging.Appx import (
+    PACKAGE_DEPENDENCY_RANK_DEFAULT,
+    PACKAGE_VERSION,
+    PACKAGEDEPENDENCY_CONTEXT,
+    AddPackageDependency,
+    AddPackageDependencyOptions_None,
+    CreatePackageDependencyOptions_None,
+    PackageDependencyLifetimeKind_Process,
+    PackageDependencyProcessorArchitectures_Arm64,
+    PackageDependencyProcessorArchitectures_X64,
+    PackageDependencyProcessorArchitectures_X86,
+    TryCreatePackageDependency,
+)
+from win32more.Windows.Win32.UI.WindowsAndMessaging import IDYES, MB_ICONERROR, MB_YESNO, MessageBox
+
+from . import WINDOWSAPPSDK_RUNTIME_VERSION_UINT64
+from ._packaging import GetFrameworkPackageFamilyName, IsPackagedProcess
+
+if ARCH == "ARM64":
+    PackageDependencyProcessorArchitectures_Current = PackageDependencyProcessorArchitectures_Arm64
+    os.add_dll_directory(os.path.dirname(win32more.__file__) + "\\dll\\arm64")
+elif ARCH == "X64":
+    PackageDependencyProcessorArchitectures_Current = PackageDependencyProcessorArchitectures_X64
+    os.add_dll_directory(os.path.dirname(win32more.__file__) + "\\dll\\x64")
+elif ARCH == "X86":
+    PackageDependencyProcessorArchitectures_Current = PackageDependencyProcessorArchitectures_X86
+    os.add_dll_directory(os.path.dirname(win32more.__file__) + "\\dll\\x86")
+else:
+    assert False
+
+MddBootstrapInitializeOptions = Int32
+MddBootstrapInitializeOptions_None = 0
+MddBootstrapInitializeOptions_OnError_DebugBreak = 1
+MddBootstrapInitializeOptions_OnError_DebugBreak_IfDebuggerAttached = 2
+MddBootstrapInitializeOptions_OnError_FailFast = 4
+MddBootstrapInitializeOptions_OnNoMatch_ShowUI = 8
+MddBootstrapInitializeOptions_OnPackageIdentity_NOOP = 16
+
+
+@winfunctype("Microsoft.WindowsAppRuntime.Bootstrap.dll", entry_point="MddBootstrapInitialize")
+def _MddBootstrapInitialize(majorMinorVersion: UInt32, versionTag: String, minVersion: PACKAGE_VERSION) -> HRESULT: ...
+
+
+@winfunctype("Microsoft.WindowsAppRuntime.Bootstrap.dll", entry_point="MddBootstrapInitialize2")
+def _MddBootstrapInitialize2(
+    majorMinorVersion: UInt32, versionTag: String, minVersion: PACKAGE_VERSION, options: MddBootstrapInitializeOptions
+) -> HRESULT: ...
+
+
+@winfunctype("Microsoft.WindowsAppRuntime.Bootstrap.dll", entry_point="MddBootstrapShutdown")
+def _MddBootstrapShutdown() -> Void: ...
+
+
+def MddBootstrapInitialize(major_minor_version: int, version_tag: str, min_version: PACKAGE_VERSION) -> int:
+    return MddBootstrapInitialize2(major_minor_version, version_tag, min_version, MddBootstrapInitializeOptions_None)
+
+
+def MddBootstrapInitialize2(
+    major_minor_version: int, version_tag: str, min_version: PACKAGE_VERSION, options: int
+) -> int:
+    if IsPackagedProcess():
+        # FIXME: Mddbootstrap API doesn't support packaged process.
+        # Since 1.6.5, WindowsAppSDK seems to work with Win11's package dependency API.
+        # I'm not sure if it is offically supported.  It might have a problem.
+        VERSION_1_6_5 = 0x1770019109300000
+        if not _IsWin11() or WINDOWSAPPSDK_RUNTIME_VERSION_UINT64 < VERSION_1_6_5:
+            raise RuntimeError("Packaged process is not supported before Windows 11")
+        hr = _Initialize_Win11(GetFrameworkPackageFamilyName(major_minor_version, version_tag), min_version)
+        if FAILED(hr):
+            if hr == STATEREPOSITORY_E_DEPENDENCY_NOT_RESOLVED:
+                if options & MddBootstrapInitializeOptions_OnNoMatch_ShowUI:
+                    _OnNoMatch_ShowUI(major_minor_version, version_tag, min_version)
+            return hr
+        return S_OK
+    else:
+        return _MddBootstrapInitialize2(major_minor_version, version_tag, min_version, options)
+
+
+def MddBootstrapShutdown() -> None:
+    if IsPackagedProcess() and not _IsWin11():
+        raise RuntimeError("Packaged process is not supported before Windows 11")
+    elif _IsWin11():
+        pass
+    else:
+        _MddBootstrapShutdown()
+
+
+def _IsWin11() -> bool:
+    return sys.getwindowsversion() >= (10, 0, 22000)
+
+
+def _Initialize_Win11(family_name: str, min_version: PACKAGE_VERSION) -> int:
+    package_dependency_id = String()
+    hr = TryCreatePackageDependency(
+        None,
+        family_name,
+        min_version,
+        PackageDependencyProcessorArchitectures_Current,
+        PackageDependencyLifetimeKind_Process,
+        None,
+        CreatePackageDependencyOptions_None,
+        package_dependency_id,
+    )
+    if FAILED(hr):
+        return hr
+
+    package_dependency_context = PACKAGEDEPENDENCY_CONTEXT()
+    hr = AddPackageDependency(
+        package_dependency_id,
+        PACKAGE_DEPENDENCY_RANK_DEFAULT,
+        AddPackageDependencyOptions_None,
+        package_dependency_context,
+        None,
+    )
+    if FAILED(hr):
+        return hr
+
+    return S_OK
+
+
+def _OnNoMatch_ShowUI(major_minor_version: int, version_tag: str, min_version: PACKAGE_VERSION) -> None:
+    caption = f"{Path(sys.executable).name} - This application could not be started"
+    text = f"""This application requires the Windows App Runtime
+Version {major_minor_version >> 16}.{major_minor_version & 0xFFFF}
+(MSIX package version >= {min_version.Major}.{min_version.Minor}.{min_version.Build}.{min_version.Revision})
+
+Do you want to install a compatible Windows App Runtime now?"""
+    r = MessageBox(0, text, caption, MB_YESNO | MB_ICONERROR)
+    if r == IDYES:
+        webbrowser.open("https://docs.microsoft.com/windows/apps/windows-app-sdk/downloads")

win32more_appsdk-0.7.0/src/win32more/winui3/__init__.py

@@ -0,0 +1,601 @@
+import importlib
+import sys
+import weakref
+import xml.etree.ElementTree as ET
+from functools import partial
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+from win32more import FAILED, ComClass, WinError, asyncui
+from win32more._winrt import ISelf, hstr
+from win32more.Microsoft.UI.Xaml import Application, FrameworkElement, IApplicationOverrides
+from win32more.Microsoft.UI.Xaml.Markup import IComponentConnector, IXamlMetadataProvider, IXamlType, XamlReader
+from win32more.Microsoft.UI.Xaml.XamlTypeInfo import XamlControlsXamlMetaDataProvider
+from win32more.Microsoft.Windows.ApplicationModel.Resources import ResourceManager
+from win32more.Windows.Foundation import Uri
+from win32more.Windows.UI.Xaml.Interop import TypeName
+from win32more.Windows.Win32.System.Com import COINIT_APARTMENTTHREADED, CoInitializeEx, CoUninitialize
+from win32more.Windows.Win32.UI.HiDpi import DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2, SetProcessDpiAwarenessContext
+from win32more.Windows.Win32.UI.WindowsAndMessaging import SetTimer
+
+XMLNS_XAML = "http://schemas.microsoft.com/winfx/2006/xaml"
+XMLNS_XAML_PRESENTATION = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+
+# FIXME: register_namespace() is global.
+# This is required to prevent "ns0:" prefix for default namespace.
+ET.register_namespace("", XMLNS_XAML_PRESENTATION)
+
+
+class XamlApplication(ComClass, Application, IApplicationOverrides, IXamlMetadataProvider):
+    def __init__(self):
+        XamlApplication.__current = self
+        self._provider = None
+        super().__init__(own=True)
+        self.InitializeComponent()
+        self.ResourceManagerRequested += self.OnResourceManagerRequested
+
+    def OnResourceManagerRequested(self, sender, e):
+        resources_pri = Path(sys.executable).with_name("resources.pri")
+        if not resources_pri.exists():
+            resources_pri = Path(__file__).parent / "resources.pri"
+        e.CustomResourceManager = ResourceManager(str(resources_pri))
+
+    def InitializeComponent(self):
+        xaml_path = Path(__file__).with_name("app.xaml").as_posix()
+        resource_locator = Uri(f"ms-appx:///{xaml_path}")
+        Application.LoadComponent(self, resource_locator)
+
+    def OnLaunched(self, args):
+        # You should override this in your derived class
+        ...
+
+    def GetXamlType(self, type):
+        return self.AppProvider().GetXamlType(type)
+
+    # TODO: Is it needed to provide information for primitive or winui type?
+    def GetXamlTypeByFullName(self, fullName):
+        return self.AppProvider().GetXamlTypeByFullName(fullName)
+
+    def GetXmlnsDefinitions(self):
+        return self.AppProvider().GetXmlnsDefinitions()
+
+    def AppProvider(self):
+        if self._provider is None:
+            self._provider = XamlControlsXamlMetaDataProvider()
+        return self._provider
+
+    __current = None
+
+    @classmethod
+    def Start(cls, init):
+        r = SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2)
+        if not r:
+            raise WinError()
+
+        hr = CoInitializeEx(None, COINIT_APARTMENTTHREADED)
+        if FAILED(hr):
+            raise WinError(hr)
+
+        with asyncui.HandCrankRunner() as runner:
+            SetTimer(0, 0, 100, lambda *_: runner.update())
+            Application.Start(lambda params: init())
+
+        # FIXME: force Release() to avoid exit with error code.
+        if XamlApplication.__current is not None:
+            XamlApplication.__current.Release()
+
+        CoUninitialize()
+
+
+class XamlClass(ComClass, IComponentConnector):
+    def __init__(self, *args, own=True, **kwargs):
+        super().__init__(*args, own=own, **kwargs)
+        self.__component_connector = None
+
+    def Connect(self, connectionId, target):
+        self.__component_connector.Connect(connectionId, target)
+
+    def GetBindingConnector(self, connectionId, target):
+        return self.__component_connector.GetBindingConnector(connectionId, target)
+
+    def LoadComponentFromFile(self, xaml_path, encoding: str | None = None):
+        self.LoadComponentFromString(Path(xaml_path).read_text(encoding=encoding), xaml_path)
+
+    def LoadComponentFromString(self, xaml_str, xaml_path=None):
+        self.__component_connector = XamlComponentConnector()
+        self.__component_connector.Load(self, xaml_str, xaml_path)
+
+
+class XamlComponentConnector:
+    def __init__(self):
+        self._connectors = {}
+
+    def Connect(self, connectionId, target):
+        for connect in self._connectors[connectionId]:
+            connect(target)
+
+    def GetBindingConnector(self, connectionId, target):
+        return None
+
+    def Load(self, component, xaml_str, xaml_path):
+        xaml_preprocessed = self._preprocess(component, xaml_str, xaml_path)
+        with NamedTemporaryFile(delete=False) as f:
+            f.write(xaml_preprocessed.encode("utf-8"))
+            f.close()
+            tmp_xaml_path = Path(f.name).as_posix()
+            resource_locator = Uri(f"ms-appx:///{tmp_xaml_path}")
+            Application.LoadComponent(component, resource_locator)
+            Path(f.name).unlink()
+
+    def _preprocess(self, component, xaml_str, xaml_path):
+        root = ET.fromstring(xaml_str)
+        for i, e in enumerate(root.iter()):
+            self._connectors[i] = []
+            for k, v in list(e.attrib.items()):
+                if k == f"{{{XMLNS_XAML}}}Name":
+                    self._connectors[i].append(partial(self._connect_name, component, v))
+                elif k in _known_events:
+                    if e == root:
+                        self._connectors[i].append(partial(self._connect_event_root, component, k, v))
+                    else:
+                        self._connectors[i].append(partial(self._connect_event, component, k, v))
+                    del e.attrib[k]
+                elif k in _path_names and xaml_path is not None:
+                    # FIXME: Workaround for relative path.
+                    src_path = Path(xaml_path).parent / v
+                    if src_path.exists():
+                        e.attrib[k] = src_path.absolute().as_posix()
+            if self._connectors[i]:
+                e.attrib[f"{{{XMLNS_XAML}}}ConnectionId"] = str(i)
+        return ET.tostring(root, encoding="unicode")
+
+    def _connect_name(self, component, bind_name, target):
+        setattr(component, bind_name, as_runtime_class(target))
+
+    def _connect_event(self, component, event_name, method_name, target):
+        event_setter = getattr(as_runtime_class(target), event_name)
+        event_setter += getattr(component, method_name)
+
+    def _connect_event_root(self, component, event_name, method_name, target):
+        event_setter = getattr(component, event_name)
+        event_setter += getattr(component, method_name)
+
+
+# Load xaml and connect element and event handler to view object.
+#
+# <Button x:Name="Button1" Click="Button1_Click" />
+#
+# to be
+#
+# view.Button1 = Button()
+# view.Button1.Click += view.Button1_Click
+class XamlLoader:
+    @classmethod
+    def Load(cls, view: object, xaml_str: str) -> object:
+        return cls().execute(view, xaml_str)
+
+    def __init__(self):
+        self._connectors = {}
+
+    def execute(self, view, xaml_str):
+        xaml_preprocessed = self._preprocess(view, xaml_str)
+        uiroot = as_runtime_class(XamlReader.Load(xaml_preprocessed))
+        self._connect(uiroot)
+        return uiroot
+
+    def _preprocess(self, view, xaml_str):
+        root = ET.fromstring(xaml_str)
+        for i, e in enumerate(root.iter()):
+            if e is root:
+                name = ""
+            elif f"{{{XMLNS_XAML}}}Name" in e.attrib:
+                name = e.attrib[f"{{{XMLNS_XAML}}}Name"]
+            else:
+                name = f"__dummy{i}"
+            self._connectors[name] = []
+            for k, v in list(e.attrib.items()):
+                if k == f"{{{XMLNS_XAML}}}Name" and e is not root:
+                    self._connectors[name].append(partial(self._connect_name, view, name))
+                elif k in _known_events:
+                    self._connectors[name].append(partial(self._connect_event, view, k, v))
+                    del e.attrib[k]
+            if self._connectors[name] and f"{{{XMLNS_XAML}}}Name" not in e.attrib and e is not root:
+                e.attrib[f"{{{XMLNS_XAML}}}Name"] = name
+        return ET.tostring(root, encoding="unicode")
+
+    def _connect(self, uiroot):
+        try:
+            framework_element = uiroot.as_(FrameworkElement)
+        except OSError:
+            framework_element = uiroot.Content.as_(FrameworkElement)
+
+        for name, connectors in self._connectors.items():
+            for connect in connectors:
+                if name == "":
+                    target = uiroot
+                else:
+                    target = framework_element.FindName(name)
+                connect(target)
+
+    def _connect_name(self, view, bind_name, target):
+        setattr(view, bind_name, as_runtime_class(target))
+
+    def _connect_event(self, view, event_name, method_name, target):
+        event_setter = getattr(as_runtime_class(target), event_name)
+        event_setter += getattr(view, method_name)
+
+
+class XamlType(ComClass, IXamlType):
+    def __init__(
+        self,
+        full_name,
+        type_kind,
+        *,
+        base_type=None,
+        boxed_type=None,
+        content_property=None,
+        is_array=False,
+        is_bindable=False,
+        is_collection=False,
+        is_dictionary=False,
+        is_markup_extension=False,
+        item_type=None,
+        key_type=None,
+        activate_instance=None,
+        add_to_map=None,
+        add_to_vector=None,
+        create_from_string=None,
+    ):
+        super().__init__(own=True)
+        self._full_name = full_name
+        self._type_kind = type_kind
+        self._base_type = base_type
+        self._boxed_type = boxed_type
+        self._content_property = content_property
+        self._is_array = is_array
+        self._is_bindable = is_bindable
+        self._is_collection = is_collection
+        self._is_constructible = bool(activate_instance)
+        self._is_dictionary = is_dictionary
+        self._is_markup_extension = is_markup_extension
+        self._item_type = item_type
+        self._key_type = key_type
+        self._activate_instance = activate_instance
+        self._add_to_map = add_to_map
+        self._add_to_vector = add_to_vector
+        self._create_from_string = create_from_string
+
+    def get_BaseType(self):
+        return self._base_type
+
+    def get_BoxedType(self):
+        return self._boxed_type
+
+    def get_ContentProperty(self):
+        return self._content_property
+
+    def get_FullName(self):
+        return self._full_name
+
+    def get_IsArray(self):
+        return self._is_array
+
+    def get_IsBindable(self):
+        return self._is_bindable
+
+    def get_IsCollection(self):
+        return self._is_collection
+
+    def get_IsConstructible(self):
+        return self._is_constructible
+
+    def get_IsDictionary(self):
+        return self._is_dictionary
+
+    def get_IsMarkupExtension(self):
+        return self._is_markup_extension
+
+    def get_ItemType(self):
+        return self._item_type
+
+    def get_KeyType(self):
+        return self._key_type
+
+    def get_UnderlyingType(self):
+        return TypeName(hstr(self._full_name), self._type_kind)
+
+    def ActivateInstance(self):
+        if self._activate_instance is None:
+            raise NotImplementedError()
+        return self._activate_instance()
+
+    def AddToMap(self, instance, key, value):
+        if self._add_to_map is None:
+            raise NotImplementedError()
+        self._add_to_map(instance, key, value)
+
+    def AddToVector(self, instance, value):
+        if self._add_to_vector is None:
+            raise NotImplementedError()
+        self._add_to_vector(instance, value)
+
+    def CreateFromString(self, value):
+        if self._boxed_type is not None:
+            return self._boxed_type.CreateFromString(value)
+        if self._create_from_string is not None:
+            return self._create_from_string(value)
+        # TODO:
+        # return fromStringConverter()
+        raise NotImplementedError()
+
+    def GetMember(self, name):
+        # TODO:
+        raise NotImplementedError()
+
+    def RunInitializer(self):
+        pass
+
+
+def xaml_typename(name, kind):
+    hs = hstr(name)
+    tn = TypeName(hs, kind)
+    weakref.finalize(tn, hs.clear)
+    return tn
+
+
+def as_runtime_class(uielement):
+    try:
+        return uielement.as_(ISelf).GetSelf()
+    except OSError:
+        return uielement.as_(_get_runtime_class(uielement))
+
+
+def _get_runtime_class(uielement):
+    namespace, name = _get_runtime_class_name(uielement).rsplit(".", 1)
+    module = importlib.import_module(f"win32more.{namespace}")
+    return getattr(module, name)
+
+
+def _get_runtime_class_name(uielement):
+    hs = hstr(own=True)
+    hr = uielement.GetRuntimeClassName(hs)
+    if FAILED(hr):
+        raise WinError(hr)
+    return str(hs)
+
+
+_known_events = {
+    "AccessKeyDisplayDismissed",
+    "AccessKeyDisplayRequested",
+    "AccessKeyInvoked",
+    "ActionButtonClick",
+    "Activated",
+    "ActualPlacementChanged",
+    "ActualThemeChanged",
+    "AddPages",
+    "AddScrollVelocityRequested",
+    "AddTabButtonClick",
+    "AnchorRequested",
+    "AnimatedVisualInvalidated",
+    "ArrangeInvalidated",
+    "BackRequested",
+    "BeforeTextChanging",
+    "BindingFailed",
+    "BringIntoViewRequested",
+    "BringingIntoView",
+    "CalendarViewDayItemChanging",
+    "CanExecuteChanged",
+    "CanExecuteRequested",
+    "CanScrollChanged",
+    "CandidateWindowBoundsChanged",
+    "Changed",
+    "CharacterReceived",
+    "Checked",
+    "ChoosingGroupHeaderContainer",
+    "ChoosingItemContainer",
+    "CleanUpVirtualizedItemEvent",
+    "Click",
+    "CloseButtonClick",
+    "CloseRequested",
+    "Closed",
+    "Closing",
+    "Collapsed",
+    "CollectionChanged",
+    "ColorChanged",
+    "Completed",
+    "CompositionScaleChanged",
+    "Confirmed",
+    "ContainerContentChanging",
+    "ContextCanceled",
+    "ContextMenuOpening",
+    "ContextRequested",
+    "CopyingToClipboard",
+    "CoreProcessFailed",
+    "CoreWebView2Initialized",
+    "CurrentChanged",
+    "CurrentChanging",
+    "CurrentStateChanged",
+    "CurrentStateChanging",
+    "CuttingToClipboard",
+    "DataContextChanged",
+    "DateChanged",
+    "DatePicked",
+    "DetailLabelRequested",
+    "DirectManipulationCompleted",
+    "DirectManipulationStarted",
+    "DisplayModeChanged",
+    "DoubleTapped",
+    "DownloadProgress",
+    "DragCompleted",
+    "DragDelta",
+    "DragEnter",
+    "DragItemsCompleted",
+    "DragItemsStarting",
+    "DragLeave",
+    "DragOver",
+    "DragStarted",
+    "DragStarting",
+    "Drop",
+    "DropCompleted",
+    "DropDownClosed",
+    "DropDownOpened",
+    "DynamicOverflowItemsChanging",
+    "EffectiveViewportChanged",
+    "ElementClearing",
+    "ElementIndexChanged",
+    "ElementPrepared",
+    "ErrorsChanged",
+    "ExecuteRequested",
+    "Expanding",
+    "ExtentChanged",
+    "ExternalTornOutTabsDropped",
+    "ExternalTornOutTabsDropping",
+    "FocusDisengaged",
+    "FocusEngaged",
+    "GetPreviewPage",
+    "GettingFocus",
+    "GotFocus",
+    "Holding",
+    "HorizontalSnapPointsChanged",
+    "ImageFailed",
+    "ImageOpened",
+    "Indeterminate",
+    "Invoked",
+    "IsCheckedChanged",
+    "IsDisplayModeEnabledChanged",
+    "IsEnabledChanged",
+    "IsScrollingWithMouseChanged",
+    "IsTextTrimmedChanged",
+    "ItemClick",
+    "ItemClicked",
+    "ItemInvoked",
+    "ItemsChanged",
+    "ItemsInfoRequested",
+    "ItemsPicked",
+    "ItemsUnlocked",
+    "KeyDown",
+    "KeyUp",
+    "LayoutUpdated",
+    "LoadCompleted",
+    "Loaded",
+    "Loading",
+    "LosingFocus",
+    "LostFocus",
+    "ManipulationCompleted",
+    "ManipulationDelta",
+    "ManipulationInertiaStarting",
+    "ManipulationStarted",
+    "ManipulationStarting",
+    "MapElementClick",
+    "MapServiceErrorOccurred",
+    "MeasureInvalidated",
+    "ModeChanged",
+    "Navigated",
+    "Navigating",
+    "NavigationCompleted",
+    "NavigationFailed",
+    "NavigationStarting",
+    "NavigationStopped",
+    "NoFocusCandidateFound",
+    "OpenFailed",
+    "Opened",
+    "Opening",
+    "Paginate",
+    "PanRequested",
+    "PaneClosed",
+    "PaneClosing",
+    "PaneOpened",
+    "PaneOpening",
+    "PaneToggleRequested",
+    "PasswordChanged",
+    "PasswordChanging",
+    "Paste",
+    "PivotItemLoaded",
+    "PivotItemLoading",
+    "PivotItemUnloaded",
+    "PivotItemUnloading",
+    "PointerCanceled",
+    "PointerCaptureLost",
+    "PointerEntered",
+    "PointerExited",
+    "PointerMoved",
+    "PointerPressed",
+    "PointerReleased",
+    "PointerWheelChanged",
+    "PreviewKeyDown",
+    "PreviewKeyUp",
+    "PrimaryButtonClick",
+    "ProcessKeyboardAccelerators",
+    "PropertyChanged",
+    "QuerySubmitted",
+    "RefreshRequested",
+    "RefreshStateChanged",
+    "Rendered",
+    "Rendering",
+    "ResourceManagerRequested",
+    "RightTapped",
+    "Scroll",
+    "ScrollAnimationStarting",
+    "ScrollByRequested",
+    "ScrollCompleted",
+    "ScrollToRequested",
+    "Scrolling",
+    "SecondaryButtonClick",
+    "SectionHeaderClick",
+    "SectionsInViewChanged",
+    "SelectedDateChanged",
+    "SelectedDatesChanged",
+    "SelectedIndexChanged",
+    "SelectedTimeChanged",
+    "SelectionChanged",
+    "SelectionChanging",
+    "SizeChanged",
+    "StateChanged",
+    "SuggestionChosen",
+    "SurfaceContentsLost",
+    "TabCloseRequested",
+    "TabDragCompleted",
+    "TabDragStarting",
+    "TabDroppedOutside",
+    "TabItemsChanged",
+    "TabStripDragOver",
+    "TabStripDrop",
+    "TabTearOutRequested",
+    "TabTearOutWindowRequested",
+    "TakeFocusRequested",
+    "Tapped",
+    "TextChanged",
+    "TextChanging",
+    "TextCompositionChanged",
+    "TextCompositionEnded",
+    "TextCompositionStarted",
+    "TextSubmitted",
+    "ThumbnailRequested",
+    "Tick",
+    "TimeChanged",
+    "TimePicked",
+    "Toggled",
+    "TransitionCompleted",
+    "Unchecked",
+    "UnhandledException",
+    "Unloaded",
+    "ValueChanged",
+    "VectorChanged",
+    "VerticalSnapPointsChanged",
+    "ViewChangeCompleted",
+    "ViewChangeStarted",
+    "ViewChanged",
+    "ViewChanging",
+    "VisibilityChanged",
+    "WebMessageReceived",
+    "XamlResourceReferenceFailed",
+    "XamlShutdownCompletedOnThread",
+    "ZoomAnimationStarting",
+    "ZoomCompleted",
+}
+
+
+_path_names = {
+    "Source",
+    "ProfilePicture",
+}

win32more_appsdk-0.7.0/src/win32more/winui3/app.xaml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Application
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>