winrt-Microsoft.Web.WebView2.Interop 4!1.0.4314.35.1__tar.gz

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/LICENSE

@@ -0,0 +1,22 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Copyright (c) 2021-2026 David Lechner <david@pybricks.com>
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/MANIFEST.in

@@ -0,0 +1,3 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+include interop.h

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: winrt-Microsoft.Web.WebView2.Interop
+Version: 4!1.0.4314.35.1
+Summary: Lets a visually hosted WebView2 take the files dropped on its window, as an OLE drop target.
+License-Expression: MIT
+Project-URL: Documentation, https://pywinrt.readthedocs.io
+Project-URL: Repository, https://github.com/pywinrt/pywinrt
+Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/projection/webview2/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: winrt-runtime<5,>=4.0.0
+Requires-Dist: winrt-Microsoft.Web.WebView2>=4!1.0.4314.35
+Dynamic: license-file
+
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Microsoft.Web.WebView2.Interop
+
+Lets a visually hosted WebView2 take the files dropped on its window, as an OLE drop target.
+
+This package provides the `winrt.microsoft.web.webview2.interop` module.
+
+It is built against version 1.0.4314.35 of the `Microsoft.Web.WebView2`
+NuGet package.
+
+```
+pip install winrt-Microsoft.Web.WebView2.Interop
+```
+
+installs it with `winrt-Microsoft.Web.WebView2`.

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/README.md

@@ -0,0 +1,16 @@
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Microsoft.Web.WebView2.Interop
+
+Lets a visually hosted WebView2 take the files dropped on its window, as an OLE drop target.
+
+This package provides the `winrt.microsoft.web.webview2.interop` module.
+
+It is built against version 1.0.4314.35 of the `Microsoft.Web.WebView2`
+NuGet package.
+
+```
+pip install winrt-Microsoft.Web.WebView2.Interop
+```
+
+installs it with `winrt-Microsoft.Web.WebView2`.

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/interop.h

@@ -0,0 +1,191 @@
+// WARNING: Please don't edit this file. It was copied from interop/interop.h
+// by scripts/generate-pyproject.py.
+
+// What an interop module needs to exchange WinRT objects and errors with
+// winrt-runtime.
+//
+// An interop module shares no C ABI with the runtime and includes none of its
+// headers. A WinRT object crosses as an interface pointer capsule, which
+// winrt.runtime.interop.as_interface() makes from a projected object and
+// winrt.runtime.interop.wrap_interface() makes a projected object from, and a
+// failed call raises the exception that winrt.runtime.interop.hresult_error()
+// builds. The capsule's name and those three functions are the whole
+// contract, so this header can change freely.
+//
+// scripts/generate-pyproject.py copies this file into each interop package,
+// so that its source distribution builds on its own.
+
+#pragma once
+
+#include <Python.h>
+
+#include <windows.h>
+
+#include <oleauto.h>
+
+#include <cstddef>
+
+// The version of the Python C API a module is compiled against: the stable
+// ABI's where it is built for that, and otherwise that of the Python it is
+// built for. Nothing newer is there to call.
+#ifdef Py_LIMITED_API
+#define INTEROP_PY_API_VERSION Py_LIMITED_API
+#else
+#define INTEROP_PY_API_VERSION PY_VERSION_HEX
+#endif
+
+namespace interop
+{
+    /// The name every interface pointer capsule carries, in the runtime and in
+    /// every interop module alike. One holds a reference to a COM interface,
+    /// which its destructor releases.
+    inline constexpr char interface_capsule_name[] = "winrt.interface";
+
+    /// Releases the GIL for as long as it is in scope.
+    ///
+    /// A call into an object in another apartment, or one that sends a window
+    /// on another thread a message, waits for that thread, which may itself
+    /// be waiting for the GIL to run a Python handler.
+    class gil_released
+    {
+      public:
+        gil_released() noexcept : state{PyEval_SaveThread()}
+        {
+        }
+
+        gil_released(gil_released const&) = delete;
+        gil_released& operator=(gil_released const&) = delete;
+
+        ~gil_released() noexcept
+        {
+            PyEval_RestoreThread(state);
+        }
+
+      private:
+        PyThreadState* state;
+    };
+
+    /// The destructor of an interface pointer capsule this module made, which
+    /// may hold the last reference to the object.
+    inline void release_interface(PyObject* capsule) noexcept
+    {
+        auto const abi = PyCapsule_GetPointer(capsule, interface_capsule_name);
+        if (!abi)
+        {
+            PyErr_WriteUnraisable(capsule);
+            return;
+        }
+
+        gil_released const guard;
+        static_cast<IUnknown*>(abi)->Release();
+    }
+
+    /// Hands @p abi, and the reference that comes with it, to a new interface
+    /// pointer capsule. The reference is released if that fails.
+    inline PyObject* new_interface_capsule(IUnknown* abi) noexcept
+    {
+        auto const capsule
+            = PyCapsule_New(abi, interface_capsule_name, release_interface);
+        if (!capsule)
+        {
+            abi->Release();
+        }
+
+        return capsule;
+    }
+
+    /// Raises what winrt.runtime.interop.hresult_error() makes of @p hr and
+    /// @p info, the error info of the call that failed with it, which may be
+    /// @c nullptr. The reference to @p info moves in.
+    /// @returns nullptr, for the caller to return.
+    inline PyObject* set_hresult_error(HRESULT hr, IErrorInfo* info) noexcept
+    {
+        auto const capsule = info ? new_interface_capsule(info) : Py_NewRef(Py_None);
+        if (!capsule)
+        {
+            return nullptr;
+        }
+
+        auto const runtime = PyImport_ImportModule("winrt.runtime.interop");
+        if (!runtime)
+        {
+            Py_DECREF(capsule);
+            return nullptr;
+        }
+
+        auto const error = PyObject_CallMethod(
+            runtime, "hresult_error", "lO", static_cast<long>(hr), capsule);
+        Py_DECREF(runtime);
+        Py_DECREF(capsule);
+        if (!error)
+        {
+            return nullptr;
+        }
+
+        PyErr_SetObject(reinterpret_cast<PyObject*>(Py_TYPE(error)), error);
+        Py_DECREF(error);
+
+        return nullptr;
+    }
+
+    /// Raises what winrt.runtime.interop.hresult_error() makes of @p hr and of
+    /// the error info that the call that just failed with it left on this
+    /// thread.
+    /// @returns nullptr, for the caller to return.
+    inline PyObject* set_hresult_error(HRESULT hr) noexcept
+    {
+        // The error info belongs to the thread and the next failure replaces
+        // it, so it is taken before anything else can fail.
+        IErrorInfo* info{};
+        if (GetErrorInfo(0, &info) != S_OK)
+        {
+            info = nullptr;
+        }
+
+        return set_hresult_error(hr, info);
+    }
+
+    /// The @p I interface of what the interface pointer capsule @p capsule
+    /// holds, which the caller owns a reference to.
+    /// @returns false with a Python exception set when @p capsule is not one
+    /// or what it holds does not implement @p I.
+    template<typename I>
+    bool query_capsule(PyObject* capsule, I** result) noexcept
+    {
+        auto const abi = PyCapsule_GetPointer(capsule, interface_capsule_name);
+        if (!abi)
+        {
+            return false;
+        }
+
+        auto const hr = static_cast<IUnknown*>(abi)->QueryInterface(
+            __uuidof(I), reinterpret_cast<void**>(result));
+        if (FAILED(hr))
+        {
+            set_hresult_error(hr);
+            return false;
+        }
+
+        return true;
+    }
+
+    /// The slots of an interop module that has nothing to set up when it is
+    /// executed. It keeps no state, but it exchanges objects and errors with
+    /// winrt-runtime, which refuses any interpreter but the main one, so it
+    /// says the same where it can. The stable ABI of Python 3.11, which its
+    /// wheels are built for, has neither slot: there CPython refuses the
+    /// module in an interpreter with a GIL of its own anyway, winrt-runtime
+    /// refuses the rest, and a free-threaded build, which is what Py_mod_gil
+    /// is for, is never a stable ABI one.
+    ///
+    /// Each slot is looked for by its value: from 3.15 the headers name every
+    /// slot whatever the API, but give the values only to an API that has it.
+    inline PyModuleDef_Slot module_slots[]{
+#ifdef Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED
+        {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},
+#endif
+#ifdef Py_MOD_GIL_NOT_USED
+        {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+        {}};
+} // namespace interop

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/py.Microsoft.Web.WebView2.Interop.cpp

@@ -0,0 +1,271 @@
+#include "interop.h"
+
+#include <ole2.h>
+
+#include <WebView2Interop.h>
+
+#include <atomic>
+#include <new>
+
+// The WebView2 headers are made by MIDL, whose MIDL_INTERFACE names the IID
+// with __declspec(uuid), which GCC does not have.
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(
+    ICoreWebView2CompositionControllerInterop2,
+    // clang-format off
+    0x6b47bbe1, 0x2480, 0x4ff8, 0xa5, 0xba, 0x69, 0xc2, 0xf0, 0xb8, 0x68, 0xb3
+    // clang-format on
+)
+#endif
+
+// https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/winrt/interop/
+
+namespace
+{
+    /// An OLE drop target for a window that shows a visually hosted WebView2.
+    /// It hands each call to the WebView's composition controller, with the
+    /// point in the window's client coordinates, which is where the WebView
+    /// is drawn from.
+    ///
+    /// OLE calls it on the thread that registered it, from that thread's
+    /// message loop, and it calls nothing but the controller, so it needs no
+    /// GIL.
+    class drop_target final : public IDropTarget
+    {
+      public:
+        /// The reference to @p controller moves in.
+        drop_target(
+            ICoreWebView2CompositionControllerInterop2* controller, HWND hwnd) noexcept
+            : controller{controller}, hwnd{hwnd}
+        {
+        }
+
+        drop_target(drop_target const&) = delete;
+        drop_target& operator=(drop_target const&) = delete;
+
+        HRESULT STDMETHODCALLTYPE
+        QueryInterface(REFIID iid, void** result) noexcept override
+        {
+            if (!result)
+            {
+                return E_POINTER;
+            }
+
+            if (iid != __uuidof(IUnknown) && iid != __uuidof(IDropTarget))
+            {
+                *result = nullptr;
+                return E_NOINTERFACE;
+            }
+
+            AddRef();
+            *result = static_cast<IDropTarget*>(this);
+
+            return S_OK;
+        }
+
+        ULONG STDMETHODCALLTYPE AddRef() noexcept override
+        {
+            return ++references;
+        }
+
+        ULONG STDMETHODCALLTYPE Release() noexcept override
+        {
+            auto const remaining = --references;
+            if (remaining == 0)
+            {
+                delete this;
+            }
+
+            return remaining;
+        }
+
+        HRESULT STDMETHODCALLTYPE DragEnter(
+            IDataObject* data_object,
+            DWORD key_state,
+            POINTL point,
+            DWORD* effect) noexcept override
+        {
+            return controller->DragEnter(
+                data_object, key_state, to_client(point), effect);
+        }
+
+        HRESULT STDMETHODCALLTYPE
+        DragOver(DWORD key_state, POINTL point, DWORD* effect) noexcept override
+        {
+            return controller->DragOver(key_state, to_client(point), effect);
+        }
+
+        HRESULT STDMETHODCALLTYPE DragLeave() noexcept override
+        {
+            return controller->DragLeave();
+        }
+
+        HRESULT STDMETHODCALLTYPE Drop(
+            IDataObject* data_object,
+            DWORD key_state,
+            POINTL point,
+            DWORD* effect) noexcept override
+        {
+            return controller->Drop(data_object, key_state, to_client(point), effect);
+        }
+
+      private:
+        ~drop_target()
+        {
+            controller->Release();
+        }
+
+        /// OLE gives the point in screen coordinates.
+        POINT to_client(POINTL point) const noexcept
+        {
+            POINT client{point.x, point.y};
+            ScreenToClient(hwnd, &client);
+
+            return client;
+        }
+
+        std::atomic<ULONG> references{1};
+        ICoreWebView2CompositionControllerInterop2* const controller;
+        HWND const hwnd;
+    };
+
+    /// Parses a window handle.
+    /// @returns false with a Python exception set when @p obj is not one.
+    bool parse_hwnd(PyObject* obj, HWND* hwnd) noexcept
+    {
+        auto const handle = PyLong_AsVoidPtr(obj);
+        if (!handle && PyErr_Occurred())
+        {
+            return false;
+        }
+
+        *hwnd = static_cast<HWND>(handle);
+
+        return true;
+    }
+
+    /// OLE registers and revokes a window's drop target on the thread that
+    /// owns the window, and calls it there.
+    /// @returns false with a Python exception set when @p hwnd is not a
+    /// window of the calling thread.
+    bool check_window_thread(HWND hwnd) noexcept
+    {
+        if (GetWindowThreadProcessId(hwnd, nullptr) != GetCurrentThreadId())
+        {
+            PyErr_SetString(PyExc_ValueError, "hwnd is not a window of this thread");
+            return false;
+        }
+
+        return true;
+    }
+
+    PyObject* register_drop_target(PyObject* /*unused*/, PyObject* args) noexcept
+    {
+        PyObject* controller_capsule;
+        PyObject* hwnd_obj;
+
+        if (!PyArg_ParseTuple(args, "OO", &controller_capsule, &hwnd_obj))
+        {
+            return nullptr;
+        }
+
+        HWND hwnd;
+        if (!parse_hwnd(hwnd_obj, &hwnd))
+        {
+            return nullptr;
+        }
+
+        if (!check_window_thread(hwnd))
+        {
+            return nullptr;
+        }
+
+        ICoreWebView2CompositionControllerInterop2* controller{};
+        if (!interop::query_capsule(controller_capsule, &controller))
+        {
+            return nullptr;
+        }
+
+        // RegisterDragDrop needs OLE, not only COM, and revoke_drop_target()
+        // balances this.
+        auto hr = OleInitialize(nullptr);
+        if (FAILED(hr))
+        {
+            controller->Release();
+            return interop::set_hresult_error(hr);
+        }
+
+        auto const target = new (std::nothrow) drop_target{controller, hwnd};
+        if (!target)
+        {
+            controller->Release();
+            OleUninitialize();
+            return PyErr_NoMemory();
+        }
+
+        // On success, OLE holds a reference of its own until the window's
+        // drop target is revoked.
+        hr = RegisterDragDrop(hwnd, target);
+        target->Release();
+        if (FAILED(hr))
+        {
+            auto const error = interop::set_hresult_error(hr);
+            OleUninitialize();
+            return error;
+        }
+
+        Py_RETURN_NONE;
+    }
+
+    PyObject* revoke_drop_target(PyObject* /*unused*/, PyObject* hwnd_obj) noexcept
+    {
+        HWND hwnd;
+        if (!parse_hwnd(hwnd_obj, &hwnd))
+        {
+            return nullptr;
+        }
+
+        if (!check_window_thread(hwnd))
+        {
+            return nullptr;
+        }
+
+        HRESULT hr;
+        {
+            // OLE's reference may be the last one to the drop target, which
+            // holds the controller.
+            interop::gil_released const guard;
+            hr = RevokeDragDrop(hwnd);
+        }
+
+        if (FAILED(hr))
+        {
+            return interop::set_hresult_error(hr);
+        }
+
+        OleUninitialize();
+
+        Py_RETURN_NONE;
+    }
+
+    PyMethodDef module_methods[]{
+        {"register_drop_target", register_drop_target, METH_VARARGS, nullptr},
+        {"revoke_drop_target", revoke_drop_target, METH_O, nullptr},
+        {}};
+
+    PyModuleDef module_def
+        = {PyModuleDef_HEAD_INIT,
+           "_winrt_microsoft_web_webview2_interop",
+           nullptr,
+           0,
+           module_methods,
+           interop::module_slots,
+           nullptr,
+           nullptr,
+           nullptr};
+} // namespace
+
+PyMODINIT_FUNC PyInit__winrt_microsoft_web_webview2_interop(void) noexcept
+{
+    return PyModuleDef_Init(&module_def);
+}

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/pyproject.toml

@@ -0,0 +1,54 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+[build-system]
+requires = ["setuptools>=78"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "winrt-Microsoft.Web.WebView2.Interop"
+version = "4!1.0.4314.35.1"
+description = "Lets a visually hosted WebView2 take the files dropped on its window, as an OLE drop target."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: Free Threading :: 2 - Beta",
+    "Typing :: Typed",
+]
+dynamic = ["dependencies"]
+requires-python = ">=3.11"
+
+[project.urls]
+Documentation = "https://pywinrt.readthedocs.io"
+Repository = "https://github.com/pywinrt/pywinrt"
+Changelog = "https://github.com/pywinrt/pywinrt/blob/main/projection/webview2/CHANGELOG.md"
+
+[tool.setuptools.dynamic]
+dependencies = { file = "requirements.txt" }
+
+[tool.setuptools.packages.find]
+include = ["winrt*"]
+
+[tool.setuptools.package-data]
+"*" = ["*.pyi", "py.typed"]
+
+[tool.cibuildwheel]
+# don't build for PyPy
+skip = "pp*"
+# suppress warnings about ARM64 testing
+test-skip = "*-win_arm64"
+test-command = "python -c \"import winrt._winrt_microsoft_web_webview2_interop\""
+
+[tool.cibuildwheel.windows]
+archs = ["x86", "AMD64", "ARM64"]
+# nothing here is copied in after the build, so there is no repair step
+repair-wheel-command = ""

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/requirements.txt

@@ -0,0 +1,4 @@
+# This file is generated by scripts/generate-pyproject.py
+
+winrt-runtime>=4.0.0,<5
+winrt-Microsoft.Web.WebView2>=4!1.0.4314.35

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/setup.py

@@ -0,0 +1,123 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+# setuptools does not annotate the build_ext methods this file overrides.
+# pyright: reportUnknownMemberType=false
+
+import hashlib
+import io
+import os
+import pathlib
+import shutil
+import sysconfig
+import urllib.request
+import zipfile
+
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+
+INCLUDE_DIRS: list[str] = []
+
+# Each NuGet package the module compiles against, named by the environment
+# variable that points at an unpacked copy of it: what it is unpacked as, where
+# nuget.org serves it, what it has to hash to and where in it the headers are.
+NUGET_PACKAGES = {
+    "WEBVIEW2_PATH": (
+        "Microsoft.Web.WebView2.1.0.4314.35",
+        "https://api.nuget.org/v3-flatcontainer/microsoft.web.webview2/1.0.4314.35/microsoft.web.webview2.1.0.4314.35.nupkg",
+        "90778deb1b77e36292828b4b5833c9255c27533f40e0ddd55891ae718944edc4",
+        ["build/native/include", "build/native/include-winrt"],
+    ),
+}
+
+
+def unpack_nuget_package(env: str) -> pathlib.Path:
+    """
+    Where the package named by @p env is unpacked: the copy the environment
+    variable points at, or else one downloaded from nuget.org into build/.
+    """
+    if env in os.environ:
+        return pathlib.Path(os.environ[env]).resolve()
+
+    name, url, sha256, _ = NUGET_PACKAGES[env]
+    path = pathlib.Path(__file__).parent.resolve() / "build" / "nuget" / name
+
+    if path.is_dir():
+        return path
+
+    try:
+        with urllib.request.urlopen(url, timeout=120) as response:
+            data = response.read()
+    except OSError as error:
+        raise RuntimeError(
+            f"could not download {url}: {error}. Set {env} to an unpacked"
+            f" copy of {name} to build without reaching the network."
+        ) from error
+
+    digest = hashlib.sha256(data).hexdigest()
+
+    if digest != sha256:
+        raise RuntimeError(f"{url} hashes to {digest} and not to {sha256}")
+
+    # Unpacked beside where it goes and then moved there, so that a build
+    # stopped halfway leaves nothing the next one would take for unpacked.
+    partial = path.with_name(path.name + ".partial")
+    shutil.rmtree(partial, ignore_errors=True)
+
+    with zipfile.ZipFile(io.BytesIO(data)) as package:
+        package.extractall(partial)
+
+    partial.rename(path)
+
+    return path
+
+
+NUGET_PATHS: dict[str, pathlib.Path] = {}
+
+for name, (_, _, _, include_dirs) in NUGET_PACKAGES.items():
+    NUGET_PATHS[name] = unpack_nuget_package(name)
+    print(f"Using {name} from {NUGET_PATHS[name]}")
+    INCLUDE_DIRS.extend(os.fspath(NUGET_PATHS[name] / d) for d in include_dirs)
+
+# compiled against the stable ABI of Python 3.11, except where the interpreter
+# is free-threaded, which has none, or MSYS2's, whose modules link against the
+# version's own DLL
+STABLE_ABI = not (
+    sysconfig.get_config_var("Py_GIL_DISABLED")
+    or sysconfig.get_platform().startswith("mingw")
+)
+
+
+class build_ext_ex(build_ext):
+    def build_extension(self, ext: Extension) -> None:
+        # nothing in the projection uses dynamic_cast or typeid, so disabling
+        # RTTI costs nothing and makes the module about 15% smaller
+        if self.compiler.compiler_type == "msvc":
+            ext.extra_compile_args = ["/std:c++20", "/permissive-", "/GR-"]
+        elif self.compiler.compiler_type == "mingw32":
+            ext.extra_compile_args = [
+                "-std=c++20",
+                "-fno-rtti",
+                "-D_WIN32_WINNT=_WIN32_WINNT_WIN10",
+            ]
+            # GCC 15 complains about some things that it didn't in the past
+            ext.extra_compile_args += ["-Wno-strict-aliasing", "-Wno-template-body"]
+            ext.extra_link_args = ["-loleaut32"]
+        else:
+            raise ValueError(f"Unsupported compiler: {self.compiler.compiler_type}")
+
+        build_ext.build_extension(self, ext)
+
+
+setup(
+    cmdclass={"build_ext": build_ext_ex},
+    ext_modules=[
+        Extension(
+            "winrt._winrt_microsoft_web_webview2_interop",
+            sources=["py.Microsoft.Web.WebView2.Interop.cpp"],
+            include_dirs=INCLUDE_DIRS,
+            libraries=["windowsapp", "ole32", "user32"],
+            define_macros=[("Py_LIMITED_API", "0x030B0000")] if STABLE_ABI else [],
+            py_limited_api=STABLE_ABI,
+        )
+    ],
+    options={"bdist_wheel": {"py_limited_api": "cp311"}} if STABLE_ABI else {},
+)

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/winrt/_winrt_microsoft_web_webview2_interop.pyi

@@ -0,0 +1,4 @@
+from winrt.runtime.interop import InterfaceCapsule
+
+def register_drop_target(controller: InterfaceCapsule, hwnd: int, /) -> None: ...
+def revoke_drop_target(hwnd: int, /) -> None: ...

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/winrt/microsoft/web/webview2/interop/__init__.py

@@ -0,0 +1,62 @@
+import typing as _typing
+
+import winrt.runtime.interop as _runtime
+import winrt._winrt_microsoft_web_webview2_interop as _native
+import winrt.microsoft.web.webview2.core as _core
+
+__all__ = ["DropTarget", "register_drop_target"]
+
+
+@_typing.final
+class DropTarget:
+    """
+    A window registered as the OLE drop target of a visually hosted WebView2,
+    which register_drop_target() returns.
+    """
+
+    __slots__ = ("_hwnd",)
+
+    _hwnd: int | None
+
+    def __init__(self) -> None:
+        raise TypeError("DropTarget is made by register_drop_target()")
+
+    def close(self) -> None:
+        """
+        Revokes the registration, on the thread that owns the window and before
+        the window is destroyed. Calling it again does nothing.
+        """
+        if self._hwnd is None:
+            return
+
+        _native.revoke_drop_target(self._hwnd)
+        self._hwnd = None
+
+    def __enter__(self) -> _typing.Self:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+
+def register_drop_target(
+    controller: _core.CoreWebView2CompositionController, hwnd: int, /
+) -> DropTarget:
+    """
+    Registers the window hwnd as an OLE drop target that hands what is dragged
+    over it to the WebView that controller controls, which is drawn from the
+    top left corner of the window's client area.
+
+    It has to be called on the thread that owns the window, which it
+    initializes OLE on. The WebView takes a drop only while the controller's
+    allow_external_drop is true.
+    """
+    _native.register_drop_target(
+        _runtime.as_interface(controller, _core.CoreWebView2CompositionController),
+        hwnd,
+    )
+
+    target = object.__new__(DropTarget)
+    target._hwnd = hwnd  # pyright: ignore[reportPrivateUsage]
+
+    return target

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/winrt_Microsoft.Web.WebView2.Interop.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: winrt-Microsoft.Web.WebView2.Interop
+Version: 4!1.0.4314.35.1
+Summary: Lets a visually hosted WebView2 take the files dropped on its window, as an OLE drop target.
+License-Expression: MIT
+Project-URL: Documentation, https://pywinrt.readthedocs.io
+Project-URL: Repository, https://github.com/pywinrt/pywinrt
+Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/projection/webview2/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: winrt-runtime<5,>=4.0.0
+Requires-Dist: winrt-Microsoft.Web.WebView2>=4!1.0.4314.35
+Dynamic: license-file
+
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Microsoft.Web.WebView2.Interop
+
+Lets a visually hosted WebView2 take the files dropped on its window, as an OLE drop target.
+
+This package provides the `winrt.microsoft.web.webview2.interop` module.
+
+It is built against version 1.0.4314.35 of the `Microsoft.Web.WebView2`
+NuGet package.
+
+```
+pip install winrt-Microsoft.Web.WebView2.Interop
+```
+
+installs it with `winrt-Microsoft.Web.WebView2`.

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/winrt_Microsoft.Web.WebView2.Interop.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+interop.h
+py.Microsoft.Web.WebView2.Interop.cpp
+pyproject.toml
+requirements.txt
+setup.py
+winrt/_winrt_microsoft_web_webview2_interop.pyi
+winrt/microsoft/web/webview2/interop/__init__.py
+winrt/microsoft/web/webview2/interop/py.typed
+winrt_Microsoft.Web.WebView2.Interop.egg-info/PKG-INFO
+winrt_Microsoft.Web.WebView2.Interop.egg-info/SOURCES.txt
+winrt_Microsoft.Web.WebView2.Interop.egg-info/dependency_links.txt
+winrt_Microsoft.Web.WebView2.Interop.egg-info/requires.txt
+winrt_Microsoft.Web.WebView2.Interop.egg-info/top_level.txt

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/winrt_Microsoft.Web.WebView2.Interop.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/winrt_Microsoft.Web.WebView2.Interop.egg-info/requires.txt

@@ -0,0 +1,2 @@
+winrt-runtime<5,>=4.0.0
+winrt-Microsoft.Web.WebView2>=4!1.0.4314.35

winrt_microsoft_web_webview2_interop-4!1.0.4314.35.1/winrt_Microsoft.Web.WebView2.Interop.egg-info/top_level.txt

@@ -0,0 +1 @@
+winrt