pyglet 3.0.dev5__py3-none-any.whl → 3.0.dev6__py3-none-any.whl

pyglet/__init__.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '3.0.dev5'
+version = '3.0.dev6'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8

pyglet/event.py

@@ -121,7 +121,6 @@ from __future__ import annotations
 import inspect
 import os.path
 
-from functools import partial
 from typing import TYPE_CHECKING, Literal, Union
 from weakref import WeakMethod
 
@@ -193,7 +192,7 @@ class EventDispatcher:
                     msg = f'Unknown event "{name}"'
                     raise EventException(msg)
                 if inspect.ismethod(obj):
-                    yield name, WeakMethod(obj, partial(self._remove_handler, name))
+                    yield name, WeakMethod(obj)
                 else:
                     yield name, obj
             else:
@@ -201,7 +200,7 @@ class EventDispatcher:
                 for name in dir(obj):
                     if name in self.event_types:
                         meth = getattr(obj, name)
-                        yield name, WeakMethod(meth, partial(self._remove_handler, name))
+                        yield name, WeakMethod(meth)
 
         for name, handler in kwargs.items():
             # Function for handling given event (no magic)
@@ -209,7 +208,7 @@ class EventDispatcher:
                 msg = f'Unknown event "{name}"'
                 raise EventException(msg)
             if inspect.ismethod(handler):
-                yield name, WeakMethod(handler, partial(self._remove_handler, name))
+                yield name, WeakMethod(handler)
             else:
                 yield name, handler
 
@@ -303,25 +302,6 @@ class EventDispatcher:
             except KeyError:
                 pass
 
-    def _remove_handler(self, name: str, handler: Callable) -> None:
-        """Used internally to remove all handler instances for the given event name.
-
-        This is normally called from a dead ``WeakMethod`` to remove itself from the
-        event stack.
-        """
-        # Iterate over a copy as we might mutate the list
-        for frame in list(self._event_stack):
-
-            if name in frame:
-                try:
-                    if frame[name] == handler:
-                        del frame[name]
-                        if not frame:
-                            self._event_stack.remove(frame)
-                except TypeError:
-                    # weakref is already dead
-                    pass
-
     def dispatch_event(self, event_type: str, *args: Any) -> bool | None:
         """Dispatch an event to the attached event handlers.
 

pyglet/graphics/__init__.py

@@ -37,6 +37,7 @@ if TYPE_CHECKING:
     from pyglet.graphics.shader import Shader, ShaderProgram, ComputeShaderProgram, TransformFeedbackShaderProgram  # noqa: F401
     from pyglet.graphics.state import State  # noqa: F401
     from pyglet.graphics.shader import get_default_shader  # noqa: F401
+    from pyglet.graphics.buffer import UniformBufferRegion  # noqa: F401
     from pyglet.graphics.draw import get_default_batch  # noqa: F401
     from pyglet.graphics.texture import Texture, TextureGrid, Texture3D, TextureArray  # noqa: F401
     from pyglet.graphics.atlas import TextureBin, TextureArrayBin, TextureAtlas  # noqa: F401
@@ -53,6 +54,7 @@ else:
     )
     from pyglet.graphics.state import State  # noqa: F401
     from pyglet.graphics.api import core  # noqa: F401
+    from pyglet.graphics.buffer import UniformBufferRegion  # noqa: F401
     from pyglet.graphics.texture import Texture, TextureGrid, Texture3D, TextureArray  # noqa: F401
     from pyglet.graphics.atlas import TextureBin, TextureArrayBin, TextureAtlas  # noqa: F401
     from pyglet.graphics.framebuffer import Framebuffer, Renderbuffer  # noqa: F401

pyglet/graphics/api/gl/state.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from pyglet.customtypes import ScissorProtocol
     from pyglet.graphics.draw import DrawContext
     from pyglet.graphics.api.gl.shader import ShaderProgram
+    from pyglet.graphics.buffer import UniformBufferRegion
     from pyglet.graphics.texture import Texture
 
 
@@ -50,8 +51,9 @@ class TextureState(State):  # noqa: D101
 
 @dataclass(frozen=True)
 class MultiTextureSamplerState(State):
-    """Static per-program sampler bindings for multi-texture draws."""
+    """Texture bindings and sampler uniforms for multi-texture draws."""
     program: ShaderProgram
+    textures: tuple[tuple[tuple[int, int], int, int], ...]
     uniforms: tuple[tuple[str, int], ...]
 
     sets_state: bool = True
@@ -61,10 +63,20 @@ class MultiTextureSamplerState(State):
             cls,
             program: ShaderProgram,
             textures: dict[str, Texture],
-            first_texture_unit: int = 0) -> MultiTextureSamplerState:
-        return cls(program, tuple((name, idx) for idx, name in enumerate(textures, first_texture_unit)))
+            first_texture_unit: int = 0,
+            set_id: int = 0) -> MultiTextureSamplerState:
+        texture_states = tuple(
+            ((texture.target, texture.id), texture_unit, set_id)
+            for texture_unit, texture in enumerate(textures.values(), first_texture_unit)
+        )
+        uniforms = tuple((name, idx) for idx, name in enumerate(textures, first_texture_unit))
+        return cls(program, texture_states, uniforms)
 
     def set_state(self, ctx: DrawContext) -> None:
+        for texture, texture_unit, _set_id in self.textures:
+            ctx.surface_ctx.glActiveTexture(GL_TEXTURE0 + texture_unit)
+            ctx.surface_ctx.glBindTexture(*texture)
+
         for uniform_name, texture_unit in self.uniforms:
             self.program[uniform_name] = texture_unit
 
@@ -216,8 +228,13 @@ class ViewportState(_BaseViewportState):
 
 @dataclass(frozen=True)
 class UniformBufferState(State):
-    name: str
-    binding: int
+    region: UniformBufferRegion
+    binding_index: int | None = None
+
+    sets_state: bool = True
+
+    def set_state(self, ctx: DrawContext) -> None:
+        self.region.bind(binding_index=self.binding_index)
 
 
 @dataclass(frozen=True)

pyglet/graphics/api/gl2/state.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from pyglet.graphics.state import State
 from typing import TYPE_CHECKING
 from pyglet.graphics.api.gl.state import (TextureState, MultiTextureSamplerState, BlendState, ShaderUniformState,   # noqa: F401
-                                          DepthBufferComparison, ScissorState, ViewportState)
+                                          DepthBufferComparison, ScissorState, UniformBufferState, ViewportState)
 
 
 if TYPE_CHECKING:
@@ -24,6 +24,6 @@ class ShaderProgramState(State):
         ctx.active_shader_program = self.program
 
         if ctx.active_camera and ctx.active_camera.view.storage:
-            ctx.active_camera.view.storage.bind(ctx)
+            ctx.active_camera.view.storage.bind_camera(ctx)
 
 

pyglet/graphics/api/webgl/state.py

@@ -10,6 +10,7 @@ from pyglet.graphics.state import State, _BaseScissorState, _BaseViewportState
 
 if TYPE_CHECKING:
     from pyglet.customtypes import ScissorProtocol
+    from pyglet.graphics.buffer import UniformBufferRegion
     from pyglet.graphics.api.webgl.shader import ShaderProgram
     from pyglet.graphics.draw import DrawContext
     from pyglet.graphics.texture import Texture
@@ -53,9 +54,11 @@ class TextureState(State):  # noqa: D101
 
 @dataclass(frozen=True)
 class MultiTextureSamplerState(State):
-    """Static per-program sampler bindings for multi-texture draws."""
+    """Texture bindings and sampler uniforms for multi-texture draws."""
     program: ShaderProgram
+    textures: tuple[tuple[tuple[int, int], int, int], ...]
     uniforms: tuple[tuple[str, int], ...]
+    webgl_textures: tuple[Any, ...] = field(hash=False, compare=False)
 
     sets_state: bool = True
 
@@ -64,10 +67,21 @@ class MultiTextureSamplerState(State):
             cls,
             program: ShaderProgram,
             textures: dict[str, Texture],
-            first_texture_unit: int = 0) -> MultiTextureSamplerState:
-        return cls(program, tuple((name, idx) for idx, name in enumerate(textures, first_texture_unit)))
+            first_texture_unit: int = 0,
+            set_id: int = 0) -> MultiTextureSamplerState:
+        texture_states = tuple(
+            ((texture.target, id(texture.id)), texture_unit, set_id)
+            for texture_unit, texture in enumerate(textures.values(), first_texture_unit)
+        )
+        uniforms = tuple((name, idx) for idx, name in enumerate(textures, first_texture_unit))
+        webgl_textures = tuple(texture.id for texture in textures.values())
+        return cls(program, texture_states, uniforms, webgl_textures)
 
     def set_state(self, ctx: DrawContext) -> None:
+        for (texture, texture_unit, _set_id), webgl_texture in zip(self.textures, self.webgl_textures):
+            ctx.surface_ctx.gl.activeTexture(GL_TEXTURE0 + texture_unit)
+            ctx.surface_ctx.gl.bindTexture(texture[0], webgl_texture)
+
         for uniform_name, texture_unit in self.uniforms:
             self.program[uniform_name] = texture_unit
 
@@ -203,8 +217,13 @@ class ViewportState(_BaseViewportState):
 
 @dataclass(frozen=True)
 class UniformBufferState(State):
-    name: str
-    binding: int
+    region: UniformBufferRegion
+    binding_index: int | None = None
+
+    sets_state: bool = True
+
+    def set_state(self, ctx: DrawContext) -> None:
+        self.region.bind(binding_index=self.binding_index)
 
 
 @dataclass(frozen=True)

pyglet/graphics/buffer.py

@@ -464,6 +464,89 @@ class UniformBufferObject(RingBuffer):
         )
 
 
+class UniformBufferRegion:
+    """UBO region that uploads through a ring-buffered ``UniformBufferObject``.
+
+    The region owns one CPU-side data structure and a set of GPU ranges.
+
+    General practice is to update the data structure, mark it dirty, and then commit when you are done updating
+    for that frame.
+
+    .. warning:: Do not make the CPU-side data dirty after binding/committing during the same frame (for example,
+                 during the ``on_draw`` call), or GPU stalls may occur.
+
+    .. versionadded:: 3.0
+    """
+
+    __slots__ = (
+        "_current_binding",
+        "_current_range",
+        "_dirty",
+        "_next_range_index",
+        "_ranges",
+        "_ubo",
+        "data",
+    )
+
+    def __init__(
+        self,
+        ubo: UniformBufferObject,
+        *,
+        copies_per_resource: int | None = None,
+    ) -> None:
+        self._ubo = ubo
+        self.data = ubo.get_data_structure()
+        self._current_binding: BufferBindingSlice | None = None
+        self._current_range: BufferRange | None = None
+        self._ranges = ubo.reserve_resource_range(copies_per_resource=copies_per_resource)
+        self._next_range_index = 0
+        self._dirty = True
+
+    @property
+    def ubo(self) -> UniformBufferObject:
+        """The underlying ``UniformBufferObject``."""
+        return self._ubo
+
+    @property
+    def dirty(self) -> bool:
+        """Whether the CPU-side data needs to be uploaded before drawing."""
+        return self._dirty
+
+    def __enter__(self) -> ctypes.Structure:
+        return self.data
+
+    def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:
+        self.mark_dirty()
+
+    def mark_dirty(self) -> None:
+        """Mark the CPU-side data for upload on the next ``bind`` call."""
+        self._dirty = True
+
+    def commit(self) -> None:
+        """Upload dirty CPU-side data to the next writable GPU range."""
+        if not self._dirty:
+            return
+
+        self._current_binding, self._current_range, self._next_range_index = (
+            self._ubo.upload_to_available_binding_from_ranges(
+                self.data,
+                self._ranges,
+                self._next_range_index,
+            )
+        )
+        self._dirty = False
+
+    def bind(self, *, binding_index: int | None = None) -> None:
+        """Upload dirty data if needed, then bind the current GPU range."""
+        self.commit()
+
+        if self._current_binding is None or self._current_range is None:
+            return
+
+        self._ubo.use_range(self._current_range)
+        self._ubo.bind_slice(self._current_binding, binding_index=binding_index)
+
+
 class MappedBufferObject(AbstractBuffer):
     """A GPU buffer that supports map/unmap and range mapping."""
 

pyglet/graphics/draw.py

@@ -23,10 +23,12 @@ from pyglet.graphics.state import (
     ShaderUniformState,
     State,
     TextureState,
+    UniformBufferState,
     ViewportState,
     _expand_states_in_order,
 )
 if TYPE_CHECKING:
+    from pyglet.graphics.buffer import UniformBufferRegion
     from pyglet.window.camera.base import BaseCamera, CameraScissor
     from pyglet.customtypes import ScissorProtocol
     from pyglet.graphics.shader import ShaderProgram
@@ -99,6 +101,7 @@ class Group:
 
         If the state is an enforced state, setting a new state will not update any children.
         """
+        assert not self.batches, "New states cannot be set once a group is in a batch."
         state_type = type(state)
         self._state_names[state_type.__name__] = state
         group_states = self._state_names.values()
@@ -145,9 +148,21 @@ class Group:
     def set_shader_program(self, program: ShaderProgram):
         self.set_state(ShaderProgramState(program))
 
-    def set_shader_uniforms(self, program: ShaderProgram, uniforms: dict[str, Any]):
+    def set_shader_uniforms(self, program: ShaderProgram, uniforms: dict[str, Any]) -> None:
         self.set_state(ShaderUniformState(program, uniforms))
 
+    def set_uniform_buffer(self, region: UniformBufferRegion, binding_index: int | None = None) -> None:
+        """Set a Uniform Buffer Object region state.
+
+        Args:
+            region:
+                A region created by ``UniformBlock.create_ubo_region``.
+            binding_index:
+                Optional binding point override. By default, the region uses
+                the binding point assigned to its source uniform block.
+        """
+        self.set_state(UniformBufferState(region, binding_index))
+
     def set_texture(self, texture: Texture, texture_unit: int=0, set_id: int=0) -> None:
         """Set the texture state.
 
@@ -161,6 +176,7 @@ class Group:
             set_id:
                 The set that the sampler belongs to. Only applicable in Vulkan.
         """
+        self._state_names.pop(MultiTextureSamplerState.__name__, None)
         self.set_state(TextureState.from_texture(texture, texture_unit, set_id))
 
     def set_textures(
@@ -181,10 +197,8 @@ class Group:
             set_id:
                 The set that the sampler belongs to. Only applicable in Vulkan.
         """
-        for texture_unit, texture in enumerate(textures.values(), first_texture_unit):
-            self.set_texture(texture, texture_unit, set_id)
-
-        self.set_state(MultiTextureSamplerState.from_textures(program, textures, first_texture_unit))
+        self._state_names.pop(TextureState.__name__, None)
+        self.set_state(MultiTextureSamplerState.from_textures(program, textures, first_texture_unit, set_id))
 
     @property
     def order(self) -> int:

pyglet/graphics/shader.py

@@ -9,21 +9,26 @@ import weakref
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Literal, Sequence, Any, TYPE_CHECKING, Callable, Protocol, overload
+from typing import TYPE_CHECKING, Any, Callable, Literal, Protocol, Sequence, overload
 
 import pyglet
 from pyglet.enums import GraphicsAPI
+from pyglet.graphics.buffer import UniformBufferRegion
 
 if TYPE_CHECKING:
-    from pyglet.graphics.buffer import (
-        UniformBufferObject,
-    )
-    from pyglet.customtypes import DataTypes, CType
-    from pyglet.graphics.vertexdomain import IndexedVertexList, VertexList, InstanceIndexedVertexList, InstanceVertexList
-    from pyglet.graphics import Batch, Group
-    from pyglet.enums import GeometryMode
     from _weakref import CallableProxyType
 
+    from pyglet.customtypes import CType, DataTypes
+    from pyglet.enums import GeometryMode
+    from pyglet.graphics import Batch, Group
+    from pyglet.graphics.buffer import UniformBufferObject
+    from pyglet.graphics.vertexdomain import (
+        IndexedVertexList,
+        InstanceIndexedVertexList,
+        InstanceVertexList,
+        VertexList,
+    )
+
 
 class ShaderException(BaseException):
     pass
@@ -967,6 +972,22 @@ class UniformBlock:
             strict,
         )
 
+    def create_ubo_region(
+        self,
+        *,
+        copies_per_resource: int = 3,
+        alignment: int | None = None,
+        strict: bool = False,
+    ) -> UniformBufferRegion:
+        """Create a ring-buffered region for updating and binding this uniform block."""
+
+        ubo = self.create_ubo(
+            copies_per_resource=copies_per_resource,
+            alignment=alignment,
+            strict=strict,
+        )
+        return UniformBufferRegion(ubo, copies_per_resource=copies_per_resource)
+
     def set_binding(self, binding: int) -> None:
         """Rebind the Uniform Block to a new binding index number.
 

pyglet/graphics/state.py

@@ -8,8 +8,8 @@ import pyglet
 
 from pyglet.enums import GraphicsAPI
 
-
 if TYPE_CHECKING:
+    from pyglet.window.camera.base import _CameraViewBase
     from pyglet.customtypes import ScissorProtocol
     from pyglet.graphics.draw import DrawContext
     from pyglet.window.camera import ViewportType
@@ -62,6 +62,7 @@ class State:
 @runtime_checkable
 class CameraScopeProtocol(Protocol):
     """Protocol for camera objects used by camera scope states."""
+    view: _CameraViewBase
 
     @property
     def viewport(self) -> ViewportType:
@@ -180,6 +181,7 @@ MultiTextureSamplerState: type[State] = _backend_state.MultiTextureSamplerState
 ShaderProgramState: type[State] = _backend_state.ShaderProgramState
 BlendState: type[State] = _backend_state.BlendState
 ShaderUniformState: type[State] = _backend_state.ShaderUniformState
+UniformBufferState: type[State] = _backend_state.UniformBufferState
 DepthBufferComparison: type[State] = _backend_state.DepthBufferComparison
 ScissorState: type[State] = _backend_state.ScissorState
 ViewportState: type[State] = _backend_state.ViewportState

pyglet/libs/win32/__init__.py

@@ -288,6 +288,10 @@ _ole32.CoInitialize.restype = HRESULT
 _ole32.CoInitialize.argtypes = [LPVOID]
 _ole32.CoInitializeEx.restype = HRESULT
 _ole32.CoInitializeEx.argtypes = [LPVOID, DWORD]
+_ole32.OleInitialize.restype = HRESULT
+_ole32.OleInitialize.argtypes = [LPVOID]
+_ole32.OleUninitialize.restype = c_void
+_ole32.OleUninitialize.argtypes = []
 _ole32.CoUninitialize.restype = HRESULT
 _ole32.CoUninitialize.argtypes = []
 _ole32.PropVariantClear.restype = HRESULT
@@ -296,6 +300,12 @@ _ole32.CoCreateInstance.restype = HRESULT
 _ole32.CoCreateInstance.argtypes = [com.REFIID, c_void_p, DWORD, com.REFIID, c_void_p]
 _ole32.CoSetProxyBlanket.restype = HRESULT
 _ole32.CoSetProxyBlanket.argtypes = (c_void_p, DWORD, DWORD, c_void_p, DWORD, DWORD, c_void_p, DWORD)
+_ole32.RegisterDragDrop.restype = HRESULT
+_ole32.RegisterDragDrop.argtypes = [HWND, c_void_p]
+_ole32.RevokeDragDrop.restype = HRESULT
+_ole32.RevokeDragDrop.argtypes = [HWND]
+_ole32.ReleaseStgMedium.restype = c_void
+_ole32.ReleaseStgMedium.argtypes = [POINTER(STGMEDIUM)]
 
 # oleaut32
 _oleaut32.VariantInit.restype = c_void_p

pyglet/libs/win32/constants.py

@@ -4159,6 +4159,19 @@ CF_PRIVATEFIRST = 512
 CF_PRIVATELAST = 767
 CF_GDIOBJFIRST = 768
 CF_GDIOBJLAST = 1023
+DVASPECT_CONTENT = 1
+TYMED_HGLOBAL = 1
+TYMED_FILE = 2
+TYMED_ISTREAM = 4
+TYMED_ISTORAGE = 8
+TYMED_GDI = 16
+TYMED_MFPICT = 32
+TYMED_ENHMF = 64
+TYMED_NULL = 0
+DROPEFFECT_NONE = 0
+DROPEFFECT_COPY = 1
+DROPEFFECT_MOVE = 2
+DROPEFFECT_LINK = 4
 FVIRTKEY =1
 FNOINVERT = 2
 FSHIFT = 4

pyglet/libs/win32/context_managers.py

@@ -30,7 +30,7 @@ After::
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Generator, TYPE_CHECKING
+from typing import Any, Callable, Generator, TYPE_CHECKING
 from ctypes import WinError
 from pyglet.libs.win32 import _user32 as user32
 
@@ -72,3 +72,68 @@ def com_context(com_object: COMObject) -> Generator[COMObject, None, None]:
         yield com_object
     finally:
         com_object.Release()
+
+
+class _HResultManager:
+    """Helper for managing multiple HRESULT ctypes calls.
+
+    Typically, ctypes will output an ``OSError`` when the result < 0.
+    """
+    error: OSError | None
+    last_result: int | None
+
+    def __init__(self) -> None:
+        self.last_result = None
+        self.error = None
+
+    def call(self, callback: Callable[..., int], *args: Any) -> int | None:
+        """Invoke a ctypes callback and capture `OSError` as manager state."""
+        self.error = None
+        try:
+            self.last_result = callback(*args)
+            return self.last_result
+        except OSError as err:
+            self.error = err
+            self.last_result = None
+            return None
+
+    @staticmethod
+    def succeeded(result: int | None, acceptable: tuple[int, ...] = ()) -> bool:
+        """Return success for a HRESULT value.
+
+        Args:
+            result:
+                The value returned from a HRESULT-style API call.
+            acceptable:
+                Extra HRESULT values treated as acceptable for this call.
+        """
+        return result is not None and (result >= 0 or result in acceptable)
+
+    def call_succeeded(self, callback: Callable[..., int], *args: Any, acceptable: tuple[int, ...] = ()) -> bool:
+        """Call and check success in one step.
+
+        Use `self.error` to inspect the captured `OSError` when this returns `False`.
+        """
+        return self.succeeded(self.call(callback, *args), acceptable=acceptable)
+
+    def raise_if_failed(self, result: int | None, acceptable: tuple[int, ...] = ()) -> int:
+        """Raise exception if the result is not successful.
+
+        Raises:
+            OSError:
+                Re-raises captured ctypes `OSError`.
+        """
+        if self.succeeded(result, acceptable=acceptable):
+            return int(result)
+
+        if self.error is not None:
+            raise self.error
+
+        msg = f"HRESULT call failed with result {result}"
+        raise OSError(msg)
+
+
+@contextmanager
+def hresult_context() -> Generator[_HResultManager, None, None]:
+    """Context manager for grouped HRESULT checks."""
+    yield _HResultManager()

pyglet/libs/win32/types.py

@@ -606,6 +606,38 @@ class VARIANT(Structure):
     ]
 
 
+class FORMATETC(Structure):
+    _fields_ = [
+        ('cfFormat', WORD),
+        ('ptd', c_void_p),
+        ('dwAspect', DWORD),
+        ('lindex', LONG),
+        ('tymed', DWORD),
+    ]
+
+
+class _STGMEDIUM_UNION(Union):
+    _fields_ = [
+        ('hBitmap', HANDLE),
+        ('hMetaFilePict', HANDLE),
+        ('hEnhMetaFile', HANDLE),
+        ('hGlobal', HANDLE),
+        ('lpszFileName', LPOLESTR),
+        ('pstm', LPSTREAM),
+        ('pstg', c_void_p),
+    ]
+
+
+class STGMEDIUM(Structure):
+    _anonymous_ = ['union']
+
+    _fields_ = [
+        ('tymed', DWORD),
+        ('union', _STGMEDIUM_UNION),
+        ('pUnkForRelease', com.pIUnknown),
+    ]
+
+
 class DWM_BLURBEHIND(Structure):
     _fields_ = [
         ("dwFlags", DWORD),
@@ -663,6 +695,45 @@ class IStream(com.pIUnknown):
     ]
 
 
+class IDataObject(com.pIUnknown):
+    _methods_ = [
+        ('GetData',
+         com.STDMETHOD(POINTER(FORMATETC), POINTER(STGMEDIUM))),
+        ('GetDataHere',
+         com.STDMETHOD(POINTER(FORMATETC), POINTER(STGMEDIUM))),
+        ('QueryGetData',
+         com.STDMETHOD(POINTER(FORMATETC))),
+        ('GetCanonicalFormatEtc',
+         com.STDMETHOD(POINTER(FORMATETC), POINTER(FORMATETC))),
+        ('SetData',
+         com.STDMETHOD(POINTER(FORMATETC), POINTER(STGMEDIUM), BOOL)),
+        ('EnumFormatEtc',
+         com.STDMETHOD(DWORD, c_void_p)),
+        ('DAdvise',
+         com.STDMETHOD(POINTER(FORMATETC), DWORD, c_void_p, POINTER(DWORD))),
+        ('DUnadvise',
+         com.STDMETHOD(DWORD)),
+        ('EnumDAdvise',
+         com.STDMETHOD(c_void_p)),
+    ]
+
+
+IID_IUNKNOWN = com.GUID(0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
+IID_IDROPTARGET = com.GUID(0x00000122, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
+
+class IDropTarget(com.IUnknown):
+    _methods_ = [
+        ('DragEnter',
+         com.STDMETHOD(IDataObject, DWORD, POINT, POINTER(DWORD))),
+        ('DragOver',
+         com.STDMETHOD(DWORD, POINT, POINTER(DWORD))),
+        ('DragLeave',
+         com.STDMETHOD()),
+        ('Drop',
+         com.STDMETHOD(IDataObject, DWORD, POINT, POINTER(DWORD))),
+    ]
+
+
 class DEV_BROADCAST_HDR(Structure):
     _fields_ = (
         ('dbch_size', DWORD),