
    jjM                    h   d dl mZ d dlZd dlZd dlmZmZ d dlmZ d dl	m
Z
 ddlmZmZmZmZmZmZmZmZ ddlmZmZmZ ej0                  rd d	lmZ d d
lmZ  ej:                  d      Z G d de      Z G d de      Z  G d dee   ejB                  e         Z"	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddZ#y)    )annotationsN)CompositeCanvasSolidCanvas)remove_defaults)	int_scale   )RELATIVE_100AlignSizing
WHSettingsnormalize_alignnormalize_widthsimplify_alignsimplify_width)WidgetDecorationWidgetErrorWidgetWarning)Iterator)LiteralWrappedWidgetc                      e Zd ZdZy)PaddingErrorzPadding related errors.N__name__
__module____qualname____doc__     ]/home/ubuntu/.cache/pipx/cdb5059130eadca/lib/python3.12/site-packages/urwid/widget/padding.pyr   r      s    !r   r   c                      e Zd ZdZy)PaddingWarningzPadding related warnings.Nr   r   r   r    r"   r"   "   s    #r   r"   c                      e Zd Zej                  edddf	 	 	 	 	 	 	 	 	 	 	 	 	 d fdZddZd fdZddZ	e
	 	 dd       Zej                  	 	 	 	 dd       Ze
	 	 dd	       Zej                  	 	 	 	 dd
       Z	 	 d	 	 	 	 	 d fdZ	 d	 	 	 	 	 ddZ	 	 	 	 	 	 ddZdd dZd!dZd"dZ	 	 	 	 	 	 	 	 d#dZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 d$dZd%dZ xZS )&PaddingNr   c                   t         |   |       t        |t              r:|d   dv r3|d   dk(  r|d   }t        j
                  }n|d   }t        j                  }t        |t              r |d   dv r|d   dk(  r|d   }n|d   }t        }|t        j                  }|| _
        || _        t        |t              \  | _        | _        t!        |t              \  | _        | _        || _        y)u
  
        :param w: a box, flow or fixed widget to pad on the left and/or right
            this widget is stored as self.original_widget
        :type w: Widget

        :param align: one of: ``'left'``, ``'center'``, ``'right'``
            (``'relative'``, *percentage* 0=left 100=right)

        :param width: one of:

            *given width*
              integer number of columns for self.original_widget

            ``'pack'``
              try to pack self.original_widget to its ideal size

            (``'relative'``, *percentage of total width*)
              make width depend on the container's width

            ``'clip'``
              to enable clipping mode for a fixed widget

        :param min_width: the minimum number of columns for
            self.original_widget or ``None``
        :type min_width: int | None

        :param left: a fixed number of columns to pad on the left
        :type left: int

        :param right: a fixed number of columns to pad on the right
        :type right: int

        Clipping Mode: (width= ``'clip'``)
        In clipping mode this padding widget will behave as a flow
        widget and self.original_widget will be treated as a fixed widget.
        self.original_widget will be clipped to fit the available number of columns.
        For example if align is ``'left'`` then self.original_widget may be clipped on the right.

        Pack Mode: (width= ``'pack'``)
        In pack mode is supported FIXED operation if it is supported by the original widget.

        >>> from urwid import Divider, Text, BigText, FontRegistry
        >>> from urwid.util import set_temporary_encoding
        >>> size = (7,)
        >>> def pr(w):
        ...     with set_temporary_encoding("utf-8"):
        ...         for t in w.render(size).text:
        ...             print(f"|{t.decode('utf-8')}|")
        >>> pr(Padding(Text("Head"), ("relative", 20), "pack"))
        | Head  |
        >>> pr(Padding(Divider("-"), left=2, right=1))
        |  ---- |
        >>> pr(Padding(Divider("*"), "center", 3))
        |  ***  |
        >>> p = Padding(Text("1234"), "left", 2, None, 1, 1)
        >>> p
        <Padding fixed/flow widget <Text fixed/flow widget '1234'> left=1 right=1 width=2>
        >>> pr(p)  # align against left
        | 12    |
        | 34    |
        >>> p.align = "right"
        >>> pr(p)  # align against right
        |    12 |
        |    34 |
        >>> pr(Padding(Text("hi\nthere"), "right", "pack"))  # pack text first
        |  hi   |
        |  there|
        >>> pr(Padding(BigText("1,2,3", FontRegistry["Thin 3x3"]()), width="clip"))
        | ┐  ┌─┐|
        | │  ┌─┘|
        | ┴ ,└─ |
        r   >   fixed right
fixed leftr'   r   N)super__init__
isinstancetupler
   LEFTRIGHTr	   r   CLIPleftrightr   r   _align_type_align_amountr   _width_type_width_amount	min_width)selfwalignwidthr5   r/   r0   	__class__s          r    r)   zPadding.__init__'   s    r 	 eU#a4Q(QQx<'Qx

aeU#a4Q(QQx<'Qxa E =OOE	
/>ul/S,$,/>ul/S,$,"r   c                   | j                   t        j                  k(  rt        t        j
                  f      S t        | j                  j                               }| j                   t        j                  k(  rwt        j
                  |v r*|j                  t        j                         t        |      S t        j                  |vr)t        j                  d| j                   t        d       t        |      S )a  Widget sizing.

        Rules:
        * width == CLIP: only FLOW is supported, and wrapped widget should support FIXED
        * width == GIVEN: FIXED is supported, and wrapped widget should support FLOW
        * All other cases: use sizing of target widget
        zDWHSettings.GIVEN expect BOX or FLOW widget to be used, but received    
stacklevel)r3   r   r.   	frozensetr   FLOWsetoriginal_widgetsizingGIVENaddFIXEDBOXwarningswarnr"   )r6   rC   s     r    rC   zPadding.sizing   s     z.fkk^,,T))0023z///{{f$

6<<(    6)Z[_[o[oZpq"    r   c                    i t         |          | j                  | j                  | j                  | j
                  | j                  d}t        |t        j                        S )N)r8   r9   r/   r0   r5   )
r(   _repr_attrsr8   r9   r/   r0   r5   r   r$   r)   )r6   attrsr:   s     r    rK   zPadding._repr_attrs   sW    
g!#
ZZZZIIZZ
 ug&6&677r   c              #     K   d| j                   f d| j                  f d| j                  f d| j                  f d| j                  f d| j
                  f y w)Nr7   r8   r9   r5   r/   r0   )rB   r8   r9   r5   r/   r0   r6   s    r    __rich_repr__zPadding.__rich_repr__   sb     4''''tzz!!tzz!!4>>))diitzz!!s   A"A$c                B    t        | j                  | j                        S )z7
        Return the padding alignment setting.
        )r   r1   r2   rN   s    r    r8   zPadding.align   s     d..0B0BCCr   c                ^    t        |t              \  | _        | _        | j	                          y)z,
        Set the padding alignment.
        N)r   r   r1   r2   _invalidate)r6   r8   s     r    r8   zPadding.align   s'     0?ul/S,$,r   c                B    t        | j                  | j                        S )z+
        Return the padding width.
        )r   r3   r4   rN   s    r    r9   zPadding.width   s     d..0B0BCCr   c                ^    t        |t              \  | _        | _        | j	                          y)z(
        Set the padding width.
        N)r   r   r3   r4   rR   )r6   r9   s     r    r9   zPadding.width   s'     0?ul/S,$,r   c                T   |rt         |   ||      S | j                  t        j                  k(  rt        d      | j                  | j                  z   }| j                  j                         }| j                  t        j                  k(  rt        j                  |vr)t        j                  d| j                   t        d       t!        | j"                  | j$                  xs d      |z   | j                  j'                  | j"                  f|      fS t        j(                  |vr)t        j                  d| j                   t        d       | j                  j                  ||      \  }}| j                  t        j*                  k(  rt!        || j$                  xs d      |z   |fS | j                  t        j,                  k(  r;t!        t/        |dz  | j"                  z  dz         | j$                  xs d      |z   |fS t        d	| j                  j1                          d
      )N.WHSettings.CLIP makes Padding FLOW-only widgetzSWHSettings.GIVEN expect FLOW widget to be used for FIXED pack/render, but received r<   r=   r   zIPadded widget should support FIXED sizing for FIXED render, but received d         ?zUnexpected width type: ))r(   packr3   r   r.   r   r/   r0   rB   rC   rD   r   r@   rH   rI   r"   maxr4   r5   rowsrF   PACKRELATIVEintupper)r6   sizefocusexpandw_sizingr9   heightr:   s          r    rZ   zPadding.pack   s   
 7<e,,z.OPPTZZ'''..0z///{{(*$$($8$8#9;" 	 D&&(;!<vE$$))4+=+=*?G 
 <<x'MM[\`\p\p[qr
 ,,11$>vz.udnn12V;VCCz222s53;););;cABDNNDWVWX[aaciii4T5E5E5K5K5M4NaPQQr   c                   | j                  ||      \  }}| j                  t        j                  k(  r| j                  j                  d|      }n|r|d   ||z   z
  }| j                  t        j                  k(  rD|| j                  k  r5t        j                  |  d| d| d|d| j                  d
t        d	       | j                  j                  |g|d
d  |      }ng| j                  t        j                  k(  r.| j                  j                  | j                  g|d
d  |      }n| j                  j                  d|      }|j                         dk(  rGt        d|d   |j                               }t        |      }|j                  | j                  g       |S t        |      }|j                  | j                  g       |dk7  s|dk7  r|j!                  ||       |S )Nr   r   z.render(size=z, focus=z): too narrow size (z < rY   r<   r=   r    )padding_valuesr3   r   r.   _original_widgetrenderrD   r4   rH   rI   r"   colsr   r\   r   set_dependspad_trim_left_right)r6   ra   rb   r/   r0   canvmaxcols          r    rj   zPadding.render!  s   
 ))$6ez.((//E:D!Wu-F:#3#33ASAS8SfM$xw>RSYR\\_`d`r`r_uuvw" 
 ((//0C$qr(0CUKD!1!11((//1C1C0Od12h0OQVWD((//E:D99;!sDGTYY[9D"4(Dd3345Kt$$//0119
$$T51r   c           
     H   | j                   t        j                  k(  rx| j                  j	                  d|      \  }}|st        d      t        |d   | j                  | j                  t        j                  |d| j                  | j                        S | j                   t        j                  k(  r|r[|d   }t        || j                  z
  | j                  z
  | j                  xs d      }| j                  j	                  |f|      \  }}n<| j                  j	                  d|      \  }}|| j                  z   | j                  z   }t        || j                  | j                  t        j                  || j                  | j                  | j                        S |r|d   }n| j                   t        j                  k(  r'| j                  | j                  z   | j                  z   }nbt        | j                  j	                  d|      d   dz  | j                  z  | j                  xs d      | j                  z   | j                  z   }t        || j                  | j                  | j                   | j                  | j                  | j                  | j                        S )z|Return the number of columns to pad on the left and right.

        Override this method to define custom padding behaviour.r   rb   rV   r   NrW   r   )r3   r   r.   ri   rZ   r   calculate_left_right_paddingr1   r2   r/   r0   r]   r[   r5   rD   r4   )r6   ra   rb   r9   _ignorero   maxwidths          r    rh   zPadding.padding_valuesE  sU    z.!2277%7HNE7"#STT/Q  ""		

	 	 z.av		1DJJ>@SRST#'#8#8#=#=xkQV#=#W #'#8#8#=#=b#=#N *TZZ7/  ""  		

	 	 !WF!1!11''$))3djj@F D))..r.?BSHDL^L^^`d`n`n`srst))**  ,NNIIJJ	
 		
r   c                   |\  }| j                  ||      \  }}| j                  t        j                  k(  r(| j                  j                  ||z
  |z
  f|      \  }}|S | j                  t        j                  k(  r!| j                  j                  d|      \  }}	|	S | j                  j                  ||z
  |z
  f|      S )z0Return the rows needed for self.original_widget.r   rq   )rh   r3   r   r]   ri   rZ   r.   r\   )
r6   ra   rb   ro   r/   r0   _pcolsprows_fcolsfrowss
             r    r\   zPadding.rows  s    	))$6ez. 11668M7OQVWMFELz. 1166r5AMFEL$$))6D=5+@*B%)PPr   c                    | j                  |d      \  }}|r.|d   |z
  |z
  g|dd }| j                  j                  ||      S | j                  j                  d|      S )z'Pass keypress to self._original_widget.Tr   r   Nr   )rh   ri   keypress)r6   ra   keyr/   r0   maxvalss         r    r{   zPadding.keypress  sm    ))$5eAw~-9QR9G((11'3??$$--b#66r   c                    t        | j                  d      sy| j                  |d      \  }}|r|d   |z
  |z
  g|dd }|d   dk(  ryd}| j                  j                  |      x}|\  }}||z   |fS y)zDReturn the (x,y) coordinates of cursor within self._original_widget.get_cursor_coordsNTr   r   r   )hasattrri   rh   r   )r6   ra   r/   r0   r}   coordsxys           r    r   zPadding.get_cursor_coords  s    t,,.AB))$5eAw~-9QR9GqzQG++==gFFFSDAqt8Q;r   c                J   t        | j                  d      sy| j                  |d      \  }}|r|d   }||z
  |z
  g|dd }n| j                  dd      d   }d}t	        |t
              r||k  r|}n|||z
  k\  r||z
  dz
  }||z  }| j                  j                  |||      S )zSet the cursor position with (x,y) coordinates of self._original_widget.

        Returns True if move succeeded, False otherwise.
        move_cursor_to_coordsTr   r   Nr   )r   ri   rh   rZ   r*   r_   r   )r6   ra   r   r   r/   r0   ro   r}   s           r    r   zPadding.move_cursor_to_coords  s     t,,.EF))$5e!WF}u,8tABx8GYYr4(+FGa4xfun$UNQ&IA$$::7AqIIr   c                    t        | j                  d      sy| j                  ||      \  }}|r#|d   }	||k  s||	|z
  k\  ry|	|z
  |z
  g|dd }
nd}
| j                  j                  |
||||z
  ||      S )z=Send mouse event if position is within self._original_widget.mouse_eventFr   r   Nr   )r   ri   rh   r   )r6   ra   eventbuttoncolrowrb   r/   r0   ro   r}   s              r    r   zPadding.mouse_event  s     t,,m<))$6e!WFTzSFUN2}u,8tABx8GG$$00%tUXZ_``r   c                    t        | j                  d      sy| j                  |d      \  }}|r|d   |z
  |z
  g|dd }nd}| j                  j                  |      }t	        |t
              r||z   S |S )z@Return the preferred column from self._original_widget, or None.get_pref_colNTr   r   r   )r   ri   rh   r   r*   r_   )r6   ra   r/   r0   r}   r   s         r    r   zPadding.get_pref_col  s    t,,n=))$5eAw~-9QR9GG!!..w7at8Or   )r7   r   r8   z~Literal['left', 'center', 'right'] | Align | tuple[Literal['relative', WHSettings.RELATIVE, 'fixed left', 'fixed right'], int]r9   zint | Literal['pack', 'clip', WHSettings.PACK, WHSettings.CLIP] | tuple[Literal['relative', WHSettings.RELATIVE, 'fixed left', 'fixed right'], int]r5   
int | Noner/   r_   r0   r_   returnNone)r   zfrozenset[Sizing])r   zdict[str, typing.Any])r   z4Iterator[tuple[str | None, typing.Any] | typing.Any])r   aLiteral['left', 'center', 'right'] | Align | tuple[Literal['relative', WHSettings.RELATIVE], int])r8   r   r   r   )r   vLiteral['clip', 'pack', WHSettings.CLIP, WHSettings.PACK] | int | tuple[Literal['relative', WHSettings.RELATIVE], int])r9   r   r   r   )r   F)ra   (tuple[()] | tuple[int] | tuple[int, int]rb   boolr   tuple[int, int])F)ra   r   rb   r   r   r   )ra   z
tuple[int]rb   r   r   r_   )ra   r   r|   strr   z
str | None)ra   r   r   ztuple[int, int] | None)ra   r   r   r_   r   r_   r   r   )ra   r   r   r   r   r_   r   r_   r   r_   rb   r   r   zbool | None)ra   r   r   r   )r   r   r   r
   r,   r	   r)   rC   rK   rO   propertyr8   setterr9   rZ   rj   rh   r\   r{   r   r   r   r   __classcell__)r:   s   @r    r$   r$   &   s    JJ
  $r#r#`	r#`r# r# r# r#  
!r#h!2	8" D	jD D \\v	  
D	?
D 
D \\C 
   :<)R6)R )R 
	)R\ "6" " 
	"H?
6?
 ?
 
	?
B
Q7&J6J J 	J
 
J<a6a a 	a
 a a a 
a0r   r$   c                t   |t         j                  k(  r5t        | |z
  |z
  d      }t        ||z  dz  dz         }	|t        |	|      }	n|}	t        j
                  dt        j                  dt        j                  dij                  ||      }
| |	z
  |z
  |z
  }|t        d|
z
  d|dz         z  }| |	z
  |z
  }|dcxk  r|k  rn nt        ||       }||z  }||z  }n%|dcxk  r|k  rn nt        ||       }||z  }||z  }|t         j                  k7  r"|dk  s|dk  rt        |d      }t        |d      }||fS )a  
    Return the amount of padding (or clipping) on the left and
    right part of maxcol columns to satisfy the following:

    align_type -- 'left', 'center', 'right', 'relative'
    align_amount -- a percentage when align_type=='relative'
    width_type -- 'fixed', 'relative', 'clip'
    width_amount -- a percentage when width_type=='relative'
        otherwise equal to the width of the widget
    min_width -- a desired minimum width for the widget or None
    left -- a fixed number of columns to pad on the left
    right -- a fixed number of columns to pad on the right

    >>> clrp = calculate_left_right_padding
    >>> clrp(15, "left", 0, "given", 10, None, 2, 0)
    (2, 3)
    >>> clrp(15, "relative", 0, "given", 10, None, 2, 0)
    (2, 3)
    >>> clrp(15, "relative", 100, "given", 10, None, 2, 0)
    (5, 0)
    >>> clrp(15, "center", 0, "given", 4, None, 2, 0)
    (6, 5)
    >>> clrp(15, "left", 0, "clip", 18, None, 0, 0)
    (0, -3)
    >>> clrp(15, "right", 0, "clip", 18, None, 0, -1)
    (-2, -1)
    >>> clrp(15, "center", 0, "given", 18, None, 2, 0)
    (0, 0)
    >>> clrp(20, "left", 0, "relative", 60, None, 0, 0)
    (0, 8)
    >>> clrp(20, "relative", 30, "relative", 60, None, 0, 0)
    (2, 6)
    >>> clrp(20, "relative", 30, "relative", 60, 14, 0, 0)
    (2, 4)
    r   rW   rX   2   e   r   )r   r^   r[   r_   r
   r,   CENTERr-   getr   minr.   )ro   
align_typealign_amount
width_typewidth_amountr5   r/   r0   rt   r9   r8   paddingshifts                r    rr   rr     sX   Z Z(((v}u,a0H|+c1C78 y)EZZELL"ekk3?CCJP\]E unt#e+G	YsU{C155EE>E!D q4D5&!		E	ED5! Z__$$(eai4|E1;r   )ro   r_   r   z*Literal['left', 'center', 'right'] | Alignr   r_   r   zeLiteral['fixed', 'relative', 'clip', 'given', WHSettings.RELATIVE, WHSettings.CLIP, WHSettings.GIVEN]r   r_   r5   r   r/   r_   r0   r_   r   r   )$
__future__r   typingrH   urwid.canvasr   r   urwid.split_reprr   
urwid.utilr   	constantsr	   r
   r   r   r   r   r   r   widget_decorationr   r   r   TYPE_CHECKINGcollections.abcr   typing_extensionsr   TypeVarr   r   r"   Genericr$   rr   r   r   r    <module>r      s    "   5 ,  	 	 	 L K	()/"; "$] $K}-v~~m/L K\KK:K K v	K
 K K K K Kr   