| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | from __future__ import annotations |
| |
|
| | from . import Image |
| |
|
| |
|
| | class HDC: |
| | """ |
| | Wraps an HDC integer. The resulting object can be passed to the |
| | :py:meth:`~PIL.ImageWin.Dib.draw` and :py:meth:`~PIL.ImageWin.Dib.expose` |
| | methods. |
| | """ |
| |
|
| | def __init__(self, dc: int) -> None: |
| | self.dc = dc |
| |
|
| | def __int__(self) -> int: |
| | return self.dc |
| |
|
| |
|
| | class HWND: |
| | """ |
| | Wraps an HWND integer. The resulting object can be passed to the |
| | :py:meth:`~PIL.ImageWin.Dib.draw` and :py:meth:`~PIL.ImageWin.Dib.expose` |
| | methods, instead of a DC. |
| | """ |
| |
|
| | def __init__(self, wnd: int) -> None: |
| | self.wnd = wnd |
| |
|
| | def __int__(self) -> int: |
| | return self.wnd |
| |
|
| |
|
| | class Dib: |
| | """ |
| | A Windows bitmap with the given mode and size. The mode can be one of "1", |
| | "L", "P", or "RGB". |
| | |
| | If the display requires a palette, this constructor creates a suitable |
| | palette and associates it with the image. For an "L" image, 128 graylevels |
| | are allocated. For an "RGB" image, a 6x6x6 colour cube is used, together |
| | with 20 graylevels. |
| | |
| | To make sure that palettes work properly under Windows, you must call the |
| | ``palette`` method upon certain events from Windows. |
| | |
| | :param image: Either a PIL image, or a mode string. If a mode string is |
| | used, a size must also be given. The mode can be one of "1", |
| | "L", "P", or "RGB". |
| | :param size: If the first argument is a mode string, this |
| | defines the size of the image. |
| | """ |
| |
|
| | def __init__( |
| | self, image: Image.Image | str, size: tuple[int, int] | list[int] | None = None |
| | ) -> None: |
| | if isinstance(image, str): |
| | mode = image |
| | image = "" |
| | else: |
| | mode = image.mode |
| | size = image.size |
| | if mode not in ["1", "L", "P", "RGB"]: |
| | mode = Image.getmodebase(mode) |
| | self.image = Image.core.display(mode, size) |
| | self.mode = mode |
| | self.size = size |
| | if image: |
| | assert not isinstance(image, str) |
| | self.paste(image) |
| |
|
| | def expose(self, handle): |
| | """ |
| | Copy the bitmap contents to a device context. |
| | |
| | :param handle: Device context (HDC), cast to a Python integer, or an |
| | HDC or HWND instance. In PythonWin, you can use |
| | ``CDC.GetHandleAttrib()`` to get a suitable handle. |
| | """ |
| | if isinstance(handle, HWND): |
| | dc = self.image.getdc(handle) |
| | try: |
| | result = self.image.expose(dc) |
| | finally: |
| | self.image.releasedc(handle, dc) |
| | else: |
| | result = self.image.expose(handle) |
| | return result |
| |
|
| | def draw(self, handle, dst, src=None): |
| | """ |
| | Same as expose, but allows you to specify where to draw the image, and |
| | what part of it to draw. |
| | |
| | The destination and source areas are given as 4-tuple rectangles. If |
| | the source is omitted, the entire image is copied. If the source and |
| | the destination have different sizes, the image is resized as |
| | necessary. |
| | """ |
| | if not src: |
| | src = (0, 0) + self.size |
| | if isinstance(handle, HWND): |
| | dc = self.image.getdc(handle) |
| | try: |
| | result = self.image.draw(dc, dst, src) |
| | finally: |
| | self.image.releasedc(handle, dc) |
| | else: |
| | result = self.image.draw(handle, dst, src) |
| | return result |
| |
|
| | def query_palette(self, handle): |
| | """ |
| | Installs the palette associated with the image in the given device |
| | context. |
| | |
| | This method should be called upon **QUERYNEWPALETTE** and |
| | **PALETTECHANGED** events from Windows. If this method returns a |
| | non-zero value, one or more display palette entries were changed, and |
| | the image should be redrawn. |
| | |
| | :param handle: Device context (HDC), cast to a Python integer, or an |
| | HDC or HWND instance. |
| | :return: A true value if one or more entries were changed (this |
| | indicates that the image should be redrawn). |
| | """ |
| | if isinstance(handle, HWND): |
| | handle = self.image.getdc(handle) |
| | try: |
| | result = self.image.query_palette(handle) |
| | finally: |
| | self.image.releasedc(handle, handle) |
| | else: |
| | result = self.image.query_palette(handle) |
| | return result |
| |
|
| | def paste( |
| | self, im: Image.Image, box: tuple[int, int, int, int] | None = None |
| | ) -> None: |
| | """ |
| | Paste a PIL image into the bitmap image. |
| | |
| | :param im: A PIL image. The size must match the target region. |
| | If the mode does not match, the image is converted to the |
| | mode of the bitmap image. |
| | :param box: A 4-tuple defining the left, upper, right, and |
| | lower pixel coordinate. See :ref:`coordinate-system`. If |
| | None is given instead of a tuple, all of the image is |
| | assumed. |
| | """ |
| | im.load() |
| | if self.mode != im.mode: |
| | im = im.convert(self.mode) |
| | if box: |
| | self.image.paste(im.im, box) |
| | else: |
| | self.image.paste(im.im) |
| |
|
| | def frombytes(self, buffer: bytes) -> None: |
| | """ |
| | Load display memory contents from byte data. |
| | |
| | :param buffer: A buffer containing display data (usually |
| | data returned from :py:func:`~PIL.ImageWin.Dib.tobytes`) |
| | """ |
| | self.image.frombytes(buffer) |
| |
|
| | def tobytes(self) -> bytes: |
| | """ |
| | Copy display memory contents to bytes object. |
| | |
| | :return: A bytes object containing display data. |
| | """ |
| | return self.image.tobytes() |
| |
|
| |
|
| | class Window: |
| | """Create a Window with the given title size.""" |
| |
|
| | def __init__( |
| | self, title: str = "PIL", width: int | None = None, height: int | None = None |
| | ) -> None: |
| | self.hwnd = Image.core.createwindow( |
| | title, self.__dispatcher, width or 0, height or 0 |
| | ) |
| |
|
| | def __dispatcher(self, action, *args): |
| | return getattr(self, f"ui_handle_{action}")(*args) |
| |
|
| | def ui_handle_clear(self, dc, x0, y0, x1, y1): |
| | pass |
| |
|
| | def ui_handle_damage(self, x0, y0, x1, y1): |
| | pass |
| |
|
| | def ui_handle_destroy(self) -> None: |
| | pass |
| |
|
| | def ui_handle_repair(self, dc, x0, y0, x1, y1): |
| | pass |
| |
|
| | def ui_handle_resize(self, width, height): |
| | pass |
| |
|
| | def mainloop(self) -> None: |
| | Image.core.eventloop() |
| |
|
| |
|
| | class ImageWindow(Window): |
| | """Create an image window which displays the given image.""" |
| |
|
| | def __init__(self, image, title="PIL"): |
| | if not isinstance(image, Dib): |
| | image = Dib(image) |
| | self.image = image |
| | width, height = image.size |
| | super().__init__(title, width=width, height=height) |
| |
|
| | def ui_handle_repair(self, dc, x0, y0, x1, y1): |
| | self.image.draw(dc, (x0, y0, x1, y1)) |
| |
|
