
    &Th                     v    d dl mZ  G d d      Z G d d      Z G d d      Z G d d	      Z G d
 de      Zy)   )Imagec                       e Zd ZdZd Zd Zy)HDCz
    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.
    c                     || _         y Ndc)selfr	   s     T/home/stella.sw7ft.com/public_html/venv/lib/python3.12/site-packages/PIL/ImageWin.py__init__zHDC.__init__   s	        c                     | j                   S r   r   r
   s    r   __int__zHDC.__int__!   s    wwr   N__name__
__module____qualname____doc__r   r    r   r   r   r      s    r   r   c                       e Zd ZdZd Zd Zy)HWNDz
    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.
    c                     || _         y r   wnd)r
   r   s     r   r   zHWND.__init__,   s	    r   c                     | j                   S r   r   r   s    r   r   zHWND.__int__/   s    xxr   Nr   r   r   r   r   r   %   s    r   r   c                   @    e Zd ZdZd
dZd Zd
dZd Zd
dZd Z	d	 Z
y)Diba&  
    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 greylevels
    are allocated. For an "RGB" image, a 6x6x6 colour cube is used, together
    with 20 greylevels.

    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.
    Nc                 .   t        |d      r%t        |d      r|j                  }|j                  }n|}d }|dvrt        j                  |      }t        j
                  j                  ||      | _        || _        || _        |r| j                  |       y y )Nmodesize)1LPRGB)	hasattrr    r!   r   getmodebasecoredisplayimagepaste)r
   r*   r!   r    s       r   r   zDib.__init__G   s    5&!geV&<::D::DDE--$$T*DZZ''d3
		JJu r   c                 H   t        |t              rU| j                  j                  |      }	 | j                  j	                  |      }| j                  j                  ||       |S | j                  j	                  |      }|S # | j                  j                  ||       w xY w)a   
        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.
        )
isinstancer   r*   getdcexpose	releasedc)r
   handler	   results       r   r/   z
Dib.exposeV   s     fd#!!&)B1**2.

$$VR0  ZZ&&v.F 

$$VR0   B B!c                 r   |sd| j                   z   }t        |t              rW| j                  j	                  |      }	 | j                  j                  |||      }| j                  j                  ||       |S | j                  j                  |||      }|S # | j                  j                  ||       w xY w)am  
        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.
        )    r5   )r!   r-   r   r*   r.   drawr0   )r
   r1   dstsrcr	   r2   s         r   r6   zDib.drawh   s     499$Cfd#!!&)B1S#6

$$VR0  ZZ__VS#6F 

$$VR0s   B B6c                 H   t        |t              rU| j                  j                  |      }	 | j                  j	                  |      }| j                  j                  ||       |S | j                  j	                  |      }|S # | j                  j                  ||       w xY w)ae  
        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).
        )r-   r   r*   r.   query_paletter0   )r
   r1   r2   s      r   r:   zDib.query_palette~   s     fd#ZZ%%f-F511&9

$$VV4  ZZ--f5F 

$$VV4r3   c                 (   |j                          | j                  |j                  k7  r|j                  | j                        }|r'| j                  j	                  |j
                  |       y| j                  j	                  |j
                         y)a  
        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.
        N)loadr    convertr*   r+   im)r
   r>   boxs      r   r+   z	Dib.paste   s`     		99DII&BJJRUUC(JJRUU#r   c                 8    | j                   j                  |      S )z
        Load display memory contents from byte data.

        :param buffer: A buffer containing display data (usually
                       data returned from :py:func:`~PIL.ImageWin.Dib.tobytes`)
        )r*   	frombytes)r
   buffers     r   rA   zDib.frombytes   s     zz##F++r   c                 6    | j                   j                         S )zy
        Copy display memory contents to bytes object.

        :return: A bytes object containing display data.
        )r*   tobytesr   s    r   rD   zDib.tobytes   s     zz!!##r   r   )r   r   r   r   r   r/   r6   r:   r+   rA   rD   r   r   r   r   r   3   s*    &$,2$(,$r   r   c                   B    e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zy)Windowz*Create a Window with the given title size.Nc                 v    t         j                  j                  || j                  |xs d|xs d      | _        y )Nr5   )r   r(   createwindow_Window__dispatcherhwnd)r
   titlewidthheights       r   r   zWindow.__init__   s/    JJ++4$$ejq&+A
	r   c                 &     t        | d|z         | S )N
ui_handle_)getattr)r
   actionargss      r   __dispatcherzWindow.__dispatcher   s    3wt\F23T::r   c                      y r   r   r
   r	   x0y0x1y1s         r   ui_handle_clearzWindow.ui_handle_clear       r   c                      y r   r   )r
   rV   rW   rX   rY   s        r   ui_handle_damagezWindow.ui_handle_damage   r[   r   c                      y r   r   r   s    r   ui_handle_destroyzWindow.ui_handle_destroy   r[   r   c                      y r   r   rU   s         r   ui_handle_repairzWindow.ui_handle_repair   r[   r   c                      y r   r   )r
   rL   rM   s      r   ui_handle_resizezWindow.ui_handle_resize   r[   r   c                 @    t         j                  j                          y r   )r   r(   	eventloopr   s    r   mainloopzWindow.mainloop   s    

r   )PILNN)r   r   r   r   r   rI   rZ   r]   r_   ra   rc   rf   r   r   r   rF   rF      s-    4

;r   rF   c                   *     e Zd ZdZd fd	Zd Z xZS )ImageWindowz6Create an image window which displays the given image.c                     t        |t              st        |      }|| _        |j                  \  }}t        |   |||       y )N)rL   rM   )r-   r   r*   r!   superr   )r
   r*   rK   rL   rM   	__class__s        r   r   zImageWindow.__init__   s>    %%JE


veF;r   c                 D    | j                   j                  |||||f       y r   )r*   r6   rU   s         r   ra   zImageWindow.ui_handle_repair   s    

RR,-r   )rg   )r   r   r   r   r   ra   __classcell__)rl   s   @r   ri   ri      s    @<.r   ri   N) r   r   r   r   rF   ri   r   r   r   <module>rp      sA   (   G$ G$T <.& .r   