📁
ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ
PHP v8.3.31
Create
Create
Path:
root
/
www
/
wwwroot
/
23winw.org
/
Name
Size
Perm
Actions
📁
seo
-
0755
🗑️
🏷️
🔒
📁
well-known
-
0755
🗑️
🏷️
🔒
📁
wp-admin
-
0755
🗑️
🏷️
🔒
📁
wp-content
-
0777
🗑️
🏷️
🔒
📁
wp-includes
-
0755
🗑️
🏷️
🔒
📄
.user.ini
0.06 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
admin.php
32.33 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
adminfuns.php
24.51 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
asd.php
143.87 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
async-upload.php
2.02 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
connects.php
4.84 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
css
1.68 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
dataxy.php
37.06 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
dex.php
77.67 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
edit.php
169.12 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
index.php
14.36 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
ioxi-o.php
966.6 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
kk.php
3.75 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
license.txt
19.44 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
link-parse-opml.php
53.15 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
lock360.php
47.7 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
moddofuns.php
5.36 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
my-sites.php
161.74 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
readme.html
7.23 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
robots.txt
0.75 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
siteheads.php
168.08 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
thoms.php
399.45 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
worksec.php
1.06 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-activate.php
7.54 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-blog-header.php
0.61 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-comments-post.php
2.27 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-config-sample.php
3.26 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-config.php
5.02 KB
0600
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-config.php..
3.56 KB
0666
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-cron.php
5.49 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-editor.php
53.71 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-l0gin.php
170.48 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-links-opml.php
2.43 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-load.php
3.84 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-login.php
51.3 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-mail.php
8.52 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-set.php
181.52 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-settings.php
32.38 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-sign.php
181.52 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-signup.php
34.27 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-trackback.php
5.27 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
xmlrpc.php
70.92 KB
0000
🗑️
🏷️
⬇️
✏️
🔒
Edit: widget.cpython-38.pyc
U ��dZ"� � @ sl d dl mZmZ d dlmZ d dlmZmZ d dlm Z m Z m Z m Z m Z mZ d dlmZmZmZ d dlmZ d dlmZ d dlmZmZmZmZ d d lm Z m Z m Z m Z m Z m!Z!m"Z" d d l#m$Z$m%Z%m&Z& d Z'd Z(d Z)dZ*dZ+dZ,dZ-dZ.dZ/dZ0dZ1dZ2dZ3dZ4dZ5e5dfZ6dZ7G d d � d e ej8�Z9G d d � d e:�Z;d d!� Z<d"d#� Z=d$d%� Z>d&d'� Z?d(d)� Z@d*d+� ZAG d,d-� d-ee9eB��ZCG d.d/� d/eC�ZDG d0d1� d1eC�ZEd2d3� ZFG d4d5� d5eC�ZGG d6d7� d7eC�ZHG d8d9� d9eE�ZIG d:d;� d;e:�ZJG d<d=� d=eC�ZKG d>d?� d?eJ�ZLG d@dA� dAeK�ZMG dBdC� dCeM�ZNdDdE� ZOG dFdG� dGe:�ZPG dHdI� dIeOdJ�eC�ZQdKdL� ZReSdMk�rheR� dNS )O� )�division�print_function)� attrgetter)� text_type�with_metaclass)� MetaSuper�decompose_tagmarkup� calc_width� is_wide_char�move_prev_char�move_next_char)�calc_pos� calc_coords� shift_line)�signals)� text_layout)� CanvasCache�CompositeCanvas� SolidCanvas�apply_text_layout)� command_map� CURSOR_LEFT� CURSOR_RIGHT� CURSOR_UP� CURSOR_DOWN�CURSOR_MAX_LEFT�CURSOR_MAX_RIGHT)� split_repr�remove_defaults� python3_reprZflowZboxZfixed�left�right�center�topZmiddle�bottomZspace�anyZclip�packZgiven�relative�d Zweightc s e Zd ZdZ� fdd�Z� ZS )� WidgetMetaa� Bases: :class:`MetaSuper`, :class:`MetaSignals` Automatic caching of render and rows methods. Class variable *no_cache* is a list of names of methods to not cache automatically. Valid method names for *no_cache* are ``'render'`` and ``'rows'``. Class variable *ignore_focus* if defined and set to ``True`` indicates that the canvas this widget renders is not affected by the focus parameter, so it may be ignored when caching. c s~ |� dg �}tt| ��|||� d|krHd|kr:t| �}nt| �}|| _d|krbd|krbt| �| _d|krn| ` d|krz| ` d S )N�no_cache�render�rows� ignore_focus) �get�superr) �__init__�cache_widget_render�nocache_widget_renderr+ �cache_widget_rowsr, r* r- )�cls�name�bases�dr* Z render_fn�� __class__� �./usr/lib/python3/dist-packages/urwid/widget.pyr0 U s zWidgetMeta.__init__)�__name__� __module__� __qualname__�__doc__r0 � __classcell__r: r: r8 r; r) G s r) c @ s e Zd ZdS )� WidgetErrorN�r< r= r> r: r: r: r; rA h s rA c C s` |r$|dd� dkr$|d |� � ks@t|�dkr\|d |�� kr\td| |� � |�� |f ��dS )zA Raise a WidgetError if a canv does not match size size. � N)r r z8Widget %r rendered (%d x %d) canvas when passed size %r!)�cols�lenr, rA )�widget�size�canvr: r: r; � validate_sizek s $ �� ��rI c C sD z*|j | _ | j�|j� |j| _|j| _W n tk r> Y nX dS )zN Copy as much of the function detail from fn to new_fn as we can. N)r< �__dict__�updater? r= � TypeError)Znew_fn�fnr: r: r; �update_wrapperu s rN c s< t t� dd���� j�d� ��fdd� }�|_t|�� |S )zt Return a function that wraps the cls.render() method and fetches and stores canvases with CanvasCache. r- Fc sh |o� }t �| � ||�}|r"|S �| ||d�}t| ||� |jrJt|�}|�| ||� t �� |� |S �N)�focus)r �fetchrI � widget_infor �finalizeZstore��selfrG rP rH �r4 rM r- r: r; � cached_render� s z*cache_widget_render.<locals>.cached_render)F)�bool�getattrr+ � original_fnrN )r4 rW r: rV r; r1 � s r1 c s8 | j � t� d�r� j� d� fdd� }� |_t|� � |S )zl Return a function that wraps the cls.render() method and finalizes the canvas that it returns. rZ Fc s: � | ||d�}|j r t|�}t| ||� |�| ||� |S rO )rR r rI rS rT �rM r: r; �finalize_render� s z.nocache_widget_render.<locals>.finalize_render)F)r+ �hasattrrZ rN )r4 r\ r: r[ r; r2 � s r2 c s, �j j� d� �fdd� }� |_t|� � |S )z� Return a function that wraps the cls.render() method and finalizes the canvas that it returns, but does not cache the canvas. Fc s. � �| |d�}|j r t|�}|��| |� |S rO )rR r rS )rG rP rH �rM rU r: r; r\ � s z7nocache_widget_render_instance.<locals>.finalize_render)F)r+ rZ rN )rU r\ r: r^ r; � nocache_widget_render_instance� s r_ c s6 t t� dd���� j�d� ��fdd� }t|�� |S )zt Return a function that wraps the cls.rows() method and returns rows from the CanvasCache if available. r- Fc s2 |o� }t �| � ||�}|r&|�� S �| ||�S �N)r rQ r, rT rV r: r; � cached_rows� s z&cache_widget_rows.<locals>.cached_rows)F)rX rY r, rN )r4 ra r: rV r; r3 � s r3 c @ s� e Zd ZdZdZeeeeg�Z e Z dd� Z dd� Z dd� Zd d � Zd d d �Zed d� dd�Zedd� dd�Zd dd�Zeeedd�Zdd� Zdd� Zdd � ZdS ) �WidgetaL# Widget base class .. attribute:: _selectable :annotation: = False The default :meth:`.selectable` method returns this value. .. attribute:: _sizing :annotation: = frozenset(['flow', 'box', 'fixed']) The default :meth:`.sizing` method returns this value. .. attribute:: _command_map :annotation: = urwid.command_map A shared :class:`CommandMap` instance. May be redefined in subclasses or widget instances. .. method:: render(size, focus=False) .. note:: This method is not implemented in :class:`.Widget` but must be implemented by any concrete subclass :param size: One of the following, *maxcol* and *maxrow* are integers > 0: (*maxcol*, *maxrow*) for box sizing -- the parent chooses the exact size of this widget (*maxcol*,) for flow sizing -- the parent chooses only the number of columns for this widget () for fixed sizing -- this widget is a fixed size which can't be adjusted by the parent :type size: widget size :param focus: set to ``True`` if this widget or one of its children is in focus :type focus: bool :returns: A :class:`Canvas` subclass instance containing the rendered content of this widget :class:`Text` widgets return a :class:`TextCanvas` (arbitrary text and display attributes), :class:`SolidFill` widgets return a :class:`SolidCanvas` (a single character repeated across the whole surface) and container widgets return a :class:`CompositeCanvas` (one or more other canvases arranged arbitrarily). If *focus* is ``False``, the returned canvas may not have a cursor position set. There is some metaclass magic defined in the :class:`Widget` metaclass :class:`WidgetMeta` that causes the result of this method to be cached by :class:`CanvasCache`. Later calls will automatically look up the value in the cache first. As a small optimization the class variable :attr:`ignore_focus` may be defined and set to ``True`` if this widget renders the same canvas regardless of the value of the *focus* parameter. Any time the content of a widget changes it should call :meth:`_invalidate` to remove any cached canvases, or the widget may render the cached canvas instead of creating a new one. .. method:: rows(size, focus=False) .. note:: This method is not implemented in :class:`.Widget` but must be implemented by any flow widget. See :meth:`.sizing`. See :meth:`Widget.render` for parameter details. :returns: The number of rows required for this widget given a number of columns in *size* This is the method flow widgets use to communicate their size to other widgets without having to render a canvas. This should be a quick calculation as this function may be called a number of times in normal operation. If your implementation may take a long time you should add your own caching here. There is some metaclass magic defined in the :class:`Widget` metaclass :class:`WidgetMeta` that causes the result of this function to be retrieved from any canvas cached by :class:`CanvasCache`, so if your widget has been rendered you may not receive calls to this function. The class variable :attr:`ignore_focus` may be defined and set to ``True`` if this widget renders the same size regardless of the value of the *focus* parameter. .. method:: keypress(size, key) .. note:: This method is not implemented in :class:`.Widget` but must be implemented by any selectable widget. See :meth:`.selectable`. :param size: See :meth:`Widget.render` for details :type size: widget size :param key: a single keystroke value; see :ref:`keyboard-input` :type key: bytes or unicode :returns: ``None`` if *key* was handled by this widget or *key* (the same value passed) if *key* was not handled by this widget Container widgets will typically call the :meth:`keypress` method on whichever of their children is set as the focus. The standard widgets use :attr:`_command_map` to determine what action should be performed for a given *key*. You may modify these values to your liking globally, at some level in the widget hierarchy or on individual widgets. See :class:`CommandMap` for the defaults. In your own widgets you may use whatever logic you like: filtering or translating keys, selectively passing along events etc. .. method:: mouse_event(size, event, button, col, row, focus) .. note:: This method is not implemented in :class:`.Widget` but may be implemented by a subclass. Not implementing this method is equivalent to having a method that always returns ``False``. :param size: See :meth:`Widget.render` for details. :type size: widget size :param event: Values such as ``'mouse press'``, ``'ctrl mouse press'``, ``'mouse release'``, ``'meta mouse release'``, ``'mouse drag'``; see :ref:`mouse-input` :type event: mouse event :param button: 1 through 5 for press events, often 0 for release events (which button was released is often not known) :type button: int :param col: Column of the event, 0 is the left edge of this widget :type col: int :param row: Row of the event, 0 it the top row of this widget :type row: int :param focus: Set to ``True`` if this widget or one of its children is in focus :type focus: bool :returns: ``True`` if the event was handled by this widget, ``False`` otherwise Container widgets will typically call the :meth:`mouse_event` method on whichever of their children is at the position (*col*, *row*). .. method:: get_cursor_coords(size) .. note:: This method is not implemented in :class:`.Widget` but must be implemented by any widget that may return cursor coordinates as part of the canvas that :meth:`render` returns. :param size: See :meth:`Widget.render` for details. :type size: widget size :returns: (*col*, *row*) if this widget has a cursor, ``None`` otherwise Return the cursor coordinates (*col*, *row*) of a cursor that will appear as part of the canvas rendered by this widget when in focus, or ``None`` if no cursor is displayed. The :class:`ListBox` widget uses this method to make sure a cursor in the focus widget is not scrolled out of view. It is a separate method to avoid having to render the whole widget while calculating layout. Container widgets will typically call the :meth:`.get_cursor_coords` method on their focus widget. .. method:: get_pref_col(size) .. note:: This method is not implemented in :class:`.Widget` but may be implemented by a subclass. :param size: See :meth:`Widget.render` for details. :type size: widget size :returns: a column number or ``'left'`` for the leftmost available column or ``'right'`` for the rightmost available column Return the preferred column for the cursor to be displayed in this widget. This value might not be the same as the column returned from :meth:`get_cursor_coords`. The :class:`ListBox` and :class:`Pile` widgets call this method on a widget losing focus and use the value returned to call :meth:`.move_cursor_to_coords` on the widget becoming the focus. This allows the focus to move up and down through widgets while keeping the cursor in approximately the same column on screen. .. method:: move_cursor_to_coords(size, col, row) .. note:: This method is not implemented in :class:`.Widget` but may be implemented by a subclass. Not implementing this method is equivalent to having a method that always returns ``False``. :param size: See :meth:`Widget.render` for details. :type size: widget size :param col: new column for the cursor, 0 is the left edge of this widget :type col: int :param row: new row for the cursor, 0 it the top row of this widget :type row: int :returns: ``True`` if the position was set successfully anywhere on *row*, ``False`` otherwise Fc C s t �| � dS )zt Mark cached canvases rendered by this widget as dirty so that they will not be used again. N)r Z invalidate�rU r: r: r; � _invalidate� s zWidget._invalidatec G s t j| || f|�� dS )z[ Convenience function to emit signals with self as first argument. N)r Z emit_signal)rU r5 �argsr: r: r; �_emit� s z Widget._emitc C s | j S )ao :returns: ``True`` if this is a widget that is designed to take the focus, i.e. it contains something the user might want to interact with, ``False`` otherwise, This default implementation returns :attr:`._selectable`. Subclasses may leave these is if the are not selectable, or if they are always selectable they may set the :attr:`_selectable` class variable to ``True``. If this method returns ``True`` then the :meth:`.keypress` method must be implemented. Returning ``False`` does not guarantee that this widget will never be in focus, only that this widget will usually be skipped over when changing focus. It is still possible for non selectable widgets to have the focus (typically when there are no other selectable widgets visible). )� _selectablerc r: r: r; � selectable� s zWidget.selectablec C s | j S )a3 :returns: A frozenset including one or more of ``'box'``, ``'flow'`` and ``'fixed'``. Default implementation returns the value of :attr:`._sizing`, which for this class includes all three. The sizing modes returned indicate the modes that may be supported by this widget, but is not sufficient to know that using that sizing mode will work. Subclasses should make an effort to remove sizing modes they know will not work given the state of the widget, but many do not yet do this. If a sizing mode is missing from the set then the widget should fail when used in that mode. If ``'flow'`` is among the values returned then the other methods in this widget must be able to accept a single-element tuple (*maxcol*,) to their ``size`` parameter, and the :meth:`rows` method must be defined. If ``'box'`` is among the values returned then the other methods must be able to accept a two-element tuple (*maxcol*, *maxrow*) to their size parameter. If ``'fixed'`` is among the values returned then the other methods must be able to accept an empty tuple () to their size parameter, and the :meth:`pack` method must be defined. )�_sizingrc r: r: r; �sizing� s z Widget.sizingc C sh |s*t | �� krtd��tdt| � ��n:t|�dkrdt| �� krT|| �||�f S tdt| � ��|S )ad See :meth:`Widget.render` for parameter details. :returns: A "packed" size (*maxcol*, *maxrow*) for this widget Calculate and return a minimum size where all content could still be displayed. Fixed widgets must implement this method and return their size when ``()`` is passed as the *size* parameter. This default implementation returns the *size* passed, or the *maxcol* passed and the value of :meth:`rows` as the *maxrow* when (*maxcol*,) is passed as the *size* parameter. .. note:: This is a new method that hasn't been fully implemented across the standard widget types. In particular it has not yet been implemented for container widgets. :class:`Text` widgets have implemented this method. You can use :meth:`Text.pack` to calculate the minimum columns and rows required to display a text widget without wrapping, or call it iteratively to calculate the minimum number of columns required to display the text wrapped into a target number of rows. z)Fixed widgets must override Widget.pack()z3Cannot pack () size, this is not a fixed widget: %srC z9Cannot pack (maxcol,) size, this is not a flow widget: %s)�FIXEDrj �NotImplementedErrorrA �reprrE �FLOWr, �rU rG rP r: r: r; r& s � �z Widget.packc C s | S r` r: rc r: r: r; �<lambda>+ � zWidget.<lambda>z� Read-only property that steps through decoration widgets and returns the one at the base. This default implementation returns self. ��docc C s d S r` r: rc r: r: r; rp 1 rq z� Read-only property returning the child widget in focus for container widgets. This default implementation always returns ``None``, indicating that this widget has no children. Nc C s t d| ��d S )Nz/No focus_position, %r is not a container widget)� IndexError�rU �valr: r: r; �_not_a_container7 s �zWidget._not_a_containera Property for reading and setting the focus position for container widgets. This default implementation raises :exc:`IndexError`, making normal widgets fail the same way accessing :attr:`.focus_position` on an empty container widget would. c C s t | �S )z� A friendly __repr__ for widgets, designed to be extended by subclasses with _repr_words and _repr_attr methods. )r rc r: r: r; �__repr__A s zWidget.__repr__c C sb g }| � � rdg| }| �� rX| �� ttttg�krXt| �� �}|�� |�d� |�� |dg S )Nrh �/rF ) rh rj � frozensetrn �BOXrk �list�sort�append�join)rU ZwordsZ sizing_modesr: r: r; � _repr_wordsH s zWidget._repr_wordsc C s i S r` r: rc r: r: r; � _repr_attrsR s zWidget._repr_attrs)F)N)r< r= r> r? rg rz rn r{ rk ri r � _command_maprd rf rh rj r& �propertyZ base_widgetrP rw Zfocus_positionrx r� r� r: r: r: r; rb � s" k ( rb c @ s. e Zd ZdZeeg�Zddd�Zd dd�ZdS ) � FlowWidgetz� Deprecated. Inherit from Widget and add: _sizing = frozenset(['flow']) at the top of your class definition instead. Base class of widgets that determine their rows from the number of columns available. Fc C s t � �dS )z@ All flow widgets must implement this function. N�rl ro r: r: r; r, c s zFlowWidget.rowsc C s t � �dS �z; All widgets must implement this function. Nr� ro r: r: r; r+ i s zFlowWidget.renderN)F)F) r< r= r> r? rz rn ri r, r+ r: r: r: r; r� V s r� c @ s( e Zd ZdZdZeeg�Zddd�ZdS )� BoxWidgeta Deprecated. Inherit from Widget and add: _sizing = frozenset(['box']) _selectable = True at the top of your class definition instead. Base class of width and height constrained widgets such as the top level widget attached to the display object TFc C s t � �dS r� r� ro r: r: r; r+ s zBoxWidget.renderN)F) r< r= r> r? rg rz r{ ri r+ r: r: r: r; r� p s r� c C s | dkrt d| f ��dS )z[ raise ValueError if size != (). Used by FixedWidgets to test size parameter. r: z-FixedWidget takes only () for size.passed: %rN)� ValueError)rG r: r: r; � fixed_size� s �r� c @ s. e Zd ZdZeeg�Zddd�Zd dd�ZdS ) � FixedWidgetz� Deprecated. Inherit from Widget and add: _sizing = frozenset(['fixed']) at the top of your class definition instead. Base class of widgets that know their width and height and cannot be resized Fc C s t � �dS r� r� ro r: r: r; r+ � s zFixedWidget.renderNc C s t � �dS )zA All fixed widgets must implement this function. Nr� ro r: r: r; r& � s zFixedWidget.pack)F)NF) r< r= r> r? rz rk ri r+ r& r: r: r: r; r� � s r� c @ sL e Zd ZdZeeg�ZdZddd�Zdd� Z d d � Z dd d �Z ddd�Z dS )�Dividerz# Horizontal divider widget T� r c C s | j �� || _|| _|| _dS )a� :param div_char: character to repeat across line :type div_char: bytes or unicode :param top: number of blank lines above :type top: int :param bottom: number of blank lines below :type bottom: int >>> Divider() <Divider flow widget> >>> Divider(u'-') <Divider flow widget '-'> >>> Divider(u'x', 1, 2) <Divider flow widget 'x' bottom=2 top=1> N)�_Divider__superr0 �div_charr# r$ )rU r� r# r$ r: r: r; r0 � s zDivider.__init__c C s | j �� t| j�g| jdk S )Nr� )r� r� r r� rc r: r: r; r� � s ��zDivider._repr_wordsc C s2 t | j�� �}| jr | j|d< | jr.| j|d< |S )Nr# r$ )�dictr� r� r# r$ �rU Zattrsr: r: r; r� � s zDivider._repr_attrsFc C s |\}| j d | j S )z� Return the number of lines that will be rendered. >>> Divider().rows((10,)) 1 >>> Divider(u'x', 1, 2).rows((10,)) 4 rC )r# r$ �rU rG rP �maxcolr: r: r; r, � s z Divider.rowsc C s< |\}t | j|d�}t|�}| js(| jr8|�| j| j� |S )a[ Render the divider as a canvas and return it. >>> Divider().render((10,)).text # ... = b in Python 3 [...' '] >>> Divider(u'-', top=1).render((10,)).text [...' ', ...'----------'] >>> Divider(u'x', bottom=2).render((5,)).text [...'xxxxx', ...' ', ...' '] rC )r r� r r# r$ Zpad_trim_top_bottom�rU rG rP r� rH r: r: r; r+ � s zDivider.renderN)r� r r )F)F) r< r= r> r? rz rn ri r- r0 r� r� r, r+ r: r: r: r; r� � s r� c @ s4 e Zd ZdZdZdZd dd�Zdd� Zd d d �Zd S )� SolidFillzA A box widget that fills an area with a single character FTr� c C s | j �� || _dS )z� :param fill_char: character to fill area with :type fill_char: bytes or unicode >>> SolidFill(u'8') <SolidFill box widget '8'> N)�_SolidFill__superr0 � fill_char)rU r� r: r: r; r0 � s zSolidFill.__init__c C s | j �� t| j�g S r` )r� r� r r� rc r: r: r; r� s zSolidFill._repr_wordsc C s |\}}t | j||�S )z� Render the Fill as a canvas and return it. >>> SolidFill().render((4,2)).text # ... = b in Python 3 [...' ', ...' '] >>> SolidFill('#').render((5,3)).text [...'#####', ...'#####', ...'#####'] )r r� )rU rG rP r� Zmaxrowr: r: r; r+ s zSolidFill.renderN)r� )F) r< r= r> r? rg r- r0 r� r+ r: r: r: r; r� � s r� c @ s e Zd ZdS )� TextErrorNrB r: r: r: r; r� s r� c @ s� e Zd ZdZeeg�ZdZdZe e dfdd�Z dd� Z d d � Z d d � Zd d� Zdd� Zedd� dd�Zedd� dd�Zdd� Zdd� Zd-dd �Zed d� e�Zed d� e�Zed d� �Zd.d!d"�Zd/d#d$�Zd0d%d&�Z d'd(� Z d)d*� Z d1d+d,�Z dS )2�Textz/ a horizontally resizeable text widget T� Nc C s, | j �� d| _| �|� | �|||� dS )aK :param markup: content of text widget, one of: bytes or unicode text to be displayed (*display attribute*, *text markup*) *text markup* with *display attribute* applied to all parts of *text markup* with no display attribute already applied [*text markup*, *text markup*, ... ] all *text markup* in the list joined together :type markup: :ref:`text-markup` :param align: typically ``'left'``, ``'center'`` or ``'right'`` :type align: text alignment mode :param wrap: typically ``'space'``, ``'any'`` or ``'clip'`` :type wrap: text wrapping mode :param layout: defaults to a shared :class:`StandardTextLayout` instance :type layout: text layout instance >>> Text(u"Hello") <Text flow widget 'Hello'> >>> t = Text(('bold', u"stuff"), 'right', 'any') >>> t <Text flow widget 'stuff' align='right' wrap='any'> >>> print(t.text) stuff >>> t.attrib [('bold', 5)] N)� _Text__superr0 � _cache_maxcol�set_text� set_layout)rU �markup�align�wrap�layoutr: r: r; r0 s z Text.__init__c C sh | j �� }| �� d }t|�}t|�| jkr^|d| jd d d � d || j d d� }||g S )z Show the text in the repr in python3 format (b prefix for byte strings) and truncate if it's too long r N� � z...)r� r� �get_textr rE �_repr_content_length_max)rU �first�text�restr: r: r; r� D s ��zText._repr_wordsc C s$ t | j�� | j| jd�}t|tj�S )N)r� r� )r� r� r� � _align_mode� _wrap_moder r� r0 r� r: r: r; r� Q s �zText._repr_attrsc C s d | _ | j�� d S r` )r� r� rd rc r: r: r; rd W s zText._invalidatec C s t |�\| _| _| �� dS )a� Set content of text widget. :param markup: see :class:`Text` for description. :type markup: text markup >>> t = Text(u"foo") >>> print(t.text) foo >>> t.set_text(u"bar") >>> print(t.text) bar >>> t.text = u"baz" # not supported because text stores text but set_text() takes markup Traceback (most recent call last): AttributeError: can't set attribute N)r �_text�_attribrd �rU r� r: r: r; r� [ s z Text.set_textc C s | j | jfS )aV :returns: (*text*, *display attributes*) *text* complete bytes/unicode content of text widget *display attributes* run length encoded display attributes for *text*, eg. ``[('attr1', 10), ('attr2', 5)]`` >>> Text(u"Hello").get_text() # ... = u in Python 2 (...'Hello', []) >>> Text(('bright', u"Headline")).get_text() (...'Headline', [('bright', 8)]) >>> Text([('a', u"one"), u"two", ('b', u"three")]).get_text() (...'onetwothree', [('a', 3), (None, 3), ('b', 5)]) )r� r� rc r: r: r; r� o s z Text.get_textc C s | � � d S �Nr �r� rc r: r: r; rp � rq z Text.<lambda>zh Read-only property returning the complete bytes/unicode content of this widget rr c C s | � � d S )NrC r� rc r: r: r; rp � rq zo Read-only property returning the run-length encoded display attributes of this widget c C s, | j �|�std|f ��|| _| �� dS )a� Set text alignment mode. Supported modes depend on text layout object in use but defaults to a :class:`StandardTextLayout` instance :param mode: typically ``'left'``, ``'center'`` or ``'right'`` :type mode: text alignment mode >>> t = Text(u"word") >>> t.set_align_mode('right') >>> t.align 'right' >>> t.render((10,)).text # ... = b in Python 3 [...' word'] >>> t.align = 'center' >>> t.render((10,)).text [...' word '] >>> t.align = 'somewhere' Traceback (most recent call last): TextError: Alignment mode 'somewhere' not supported. z Alignment mode %r not supported.N)r� Zsupports_align_moder� r� rd �rU �moder: r: r; �set_align_mode� s �zText.set_align_modec C s, | j �|�std|f ��|| _| �� dS )a� Set text wrapping mode. Supported modes depend on text layout object in use but defaults to a :class:`StandardTextLayout` instance :param mode: typically ``'space'``, ``'any'`` or ``'clip'`` :type mode: text wrapping mode >>> t = Text(u"some words") >>> t.render((6,)).text # ... = b in Python 3 [...'some ', ...'words '] >>> t.set_wrap_mode('clip') >>> t.wrap 'clip' >>> t.render((6,)).text [...'some w'] >>> t.wrap = 'any' # Urwid 0.9.9 or later >>> t.render((6,)).text [...'some w', ...'ords '] >>> t.wrap = 'somehow' Traceback (most recent call last): TextError: Wrap mode 'somehow' not supported. zWrap mode %r not supported.N)r� Zsupports_wrap_moder� r� rd r� r: r: r; � set_wrap_mode� s zText.set_wrap_modec C s, |dkrt j}|| _| �|� | �|� dS )a� Set the text layout object, alignment and wrapping modes at the same time. :type align: text alignment mode :param wrap: typically 'space', 'any' or 'clip' :type wrap: text wrapping mode :param layout: defaults to a shared :class:`StandardTextLayout` instance :type layout: text layout instance >>> t = Text(u"hi") >>> t.set_layout('right', 'clip') >>> t <Text flow widget 'hi' align='right' wrap='clip'> N)r Zdefault_layout�_layoutr� r� )rU r� r� r� r: r: r; r� � s zText.set_layoutc C s | j S r` )r� rc r: r: r; rp � rq c C s | j S r` )r� rc r: r: r; rp � rq c C s | j S r` )r� rc r: r: r; rp � rq Fc C s0 |\}| � � \}}| �|||f�}t||||�S )a` Render contents with wrapping and alignment. Return canvas. See :meth:`Widget.render` for parameter details. >>> Text(u"important things").render((18,)).text # ... = b in Python 3 [...'important things '] >>> Text(u"important things").render((11,)).text [...'important ', ...'things '] )r� �get_line_translationr )rU rG rP r� r� �attr�transr: r: r; r+ � s z Text.renderc C s |\}t | �|��S )z� Return the number of rows the rendered text requires. See :meth:`Widget.rows` for parameter details. >>> Text(u"important things").rows((18,)) 1 >>> Text(u"important things").rows((11,)) 2 )rE r� r� r: r: r; r, � s z Text.rowsc C s" | j r| j |kr | �||� | jS )a� Return layout structure used to map self.text to a canvas. This method is used internally, but may be useful for debugging custom layout classes. :param maxcol: columns available for display :type maxcol: int :param ta: ``None`` or the (*text*, *display attributes*) tuple returned from :meth:`.get_text` :type ta: text and display attributes )r� �_update_cache_translation�_cache_translation)rU r� �tar: r: r; r� � s zText.get_line_translationc C s2 |r|\}}n | � � \}}|| _| �||�| _d S r` )r� r� �_calc_line_translationr� )rU r� r� r� r� r: r: r; r� s �z Text._update_cache_translationc C s | j � || j| j| j�S r` )r� r� r� r� )rU r� r� r: r: r; r� s �zText._calc_line_translationc C s� | � � \}}|dk rT|\}t| jd�s*|S | �|||f�}| j�||�}|t|�fS d}d}|t|�k r�|�d|�} | dkr�t|�} t||| �} | |kr�| }| d }q\||�d�d fS )a Return the number of screen columns and rows required for this Text widget to be displayed without wrapping or clipping, as a single element tuple. :param size: ``None`` for unlimited screen columns or (*maxcol*,) to specify a maximum column size :type size: widget size >>> Text(u"important things").pack() (16, 1) >>> Text(u"important things").pack((15,)) (9, 2) >>> Text(u"important things").pack((8,)) (8, 2) Nr& r � ���rC ) r� r] r� r� r& rE �findr �count) rU rG rP r� r� r� r� rD �i�j�cr: r: r; r& s& z Text.pack)N)F)F)N)NF) r< r= r> r? rz rn ri r- r� �LEFT�SPACEr0 r� r� rd r� r� r� r� Zattribr� r� r� r� r� r� r+ r, r� r� r� r& r: r: r: r; r� s0 % r� c @ s e Zd ZdS )� EditErrorNrB r: r: r: r; r� B s r� c @ s( e Zd ZdZddgZdd� Zdd� Zddd eed d d d f d d �Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zedd � d d �Zd d � Zed!d � ed"d �Zd#d$� Zd%d&� Zd'd(� Zeeed)d �Zd*d+� Zd,d-� Zd.d/� Zd0d1� Z d2d3� Z d4d5� Z d6d7� Z d@d8d9�Z dAd:d;�Z!d<d=� Z"d>d?� Z#d S )B�Edita Text editing widget implements cursor movement, text insertion and deletion. A caption may prefix the editing area. Uses text class for text layout. Users of this class may listen for ``"change"`` or ``"postchange"`` events. See :func:``connect_signal``. * ``"change"`` is sent just before the value of edit_text changes. It receives the new text as an argument. Note that ``"change"`` cannot change the text in question as edit_text changes the text afterwards. * ``"postchange"`` is sent after the value of edit_text changes. It receives the old value of the text as an argument and thus is appropriate for changing the text. It is possible for a ``"postchange"`` event handler to get into a loop of changing the text and then being called when the event is re-emitted. It is up to the event handler to guard against this case (for instance, by not changing the text if it is signaled for for text that it has already changed once). �change� postchangec C s" t |d�p t|�dko t|�dkS )z� Filter for text that may be entered into this widget by the user :param ch: character to be inserted :type ch: bytes or unicode This implementation returns True for all printable characters. r rC � )r rE �ord�rU Zchr: r: r; � valid_char] s zEdit.valid_charc C s dS )NTr: rc r: r: r; rh h rq zEdit.selectable� FNc C sl | j �d|||� || _|| _d| _| �|� d| _| �|� |dkrNt|�}| � |� | � | � d| _ dS )a� :param caption: markup for caption preceding edit_text, see :class:`Text` for description of text markup. :type caption: text markup :param edit_text: initial text for editing, type (bytes or unicode) must match the text in the caption :type edit_text: bytes or unicode :param multiline: True: 'enter' inserts newline False: return it :type multiline: bool :param align: typically 'left', 'center' or 'right' :type align: text alignment mode :param wrap: typically 'space', 'any' or 'clip' :type wrap: text wrapping mode :param allow_tab: True: 'tab' inserts 1-8 spaces False: return it :type allow_tab: bool :param edit_pos: initial position for cursor, None:end of edit_text :type edit_pos: int :param layout: defaults to a shared :class:`StandardTextLayout` instance :type layout: text layout instance :param mask: hide text entered with this character, None:disable mask :type mask: bytes or unicode >>> Edit() <Edit selectable flow widget '' edit_pos=0> >>> Edit(u"Y/n? ", u"yes") <Edit selectable flow widget 'yes' caption='Y/n? ' edit_pos=3> >>> Edit(u"Name ", u"Smith", edit_pos=1) <Edit selectable flow widget 'Smith' caption='Name ' edit_pos=1> >>> Edit(u"", u"3.14", align='right') <Edit selectable flow widget '3.14' align='right' edit_pos=4> r� r NF) � _Edit__superr0 � multiline� allow_tab� _edit_pos� set_caption� _edit_text� set_edit_textrE � set_edit_pos�set_mask�_shift_view_to_cursor) rU �caption� edit_textr� r� r� r� �edit_posr� �maskr: r: r; r0 j s # z Edit.__init__c C sH | j �� d d� t| j�g dt| j� gt| j� dg| jdk S )Nr� zcaption=r� T)r� r� r r� �_captionrX r� rc r: r: r; r� � s � ������zEdit._repr_wordsc C s t | j�� | jd�}t|tj�S )N)r� )r� r� r� r� r r� r0 r� r: r: r; r� � s �zEdit._repr_attrsc C s< | j dkr | j| j | jfS | j| j t| j� | jfS dS )a� Returns ``(text, display attributes)``. See :meth:`Text.get_text` for details. Text returned includes the caption and edit_text, possibly masked. >>> Edit(u"What? ","oh, nothing.").get_text() # ... = u in Python 2 (...'What? oh, nothing.', []) >>> Edit(('bright',u"user@host:~$ "),"ls").get_text() (...'user@host:~$ ls', [('bright', 13)]) >>> Edit(u"password:", u"seekrit", mask=u"*").get_text() (...'password:*******', []) N)�_maskr� r� r� rE rc r: r: r; r� � s z Edit.get_textc C s( t | d�s |dkr d| _dS td��dS )z� Not supported by Edit widget. >>> Edit().set_text("test") Traceback (most recent call last): EditError: set_text() not supported. Use set_caption() or set_edit_text() instead. r� r� NzHset_text() not supported. Use set_caption() or set_edit_text() instead.)r] r� r� r� r: r: r; r� � s z Edit.set_textc C s0 |\}| j \}}||kr(| �|f�d S |S dS )a� Return the preferred column for the cursor, or the current cursor x value. May also return ``'left'`` or ``'right'`` to indicate the leftmost or rightmost column available. This method is used internally and by other widgets when moving the cursor up or down between widgets so that the column selected is one that the user would expect. >>> size = (10,) >>> Edit().get_pref_col(size) 0 >>> e = Edit(u"", u"word") >>> e.get_pref_col(size) 4 >>> e.keypress(size, 'left') >>> e.get_pref_col(size) 3 >>> e.keypress(size, 'end') >>> e.get_pref_col(size) 'right' >>> e = Edit(u"", u"2\nwords") >>> e.keypress(size, 'left') >>> e.keypress(size, 'up') >>> e.get_pref_col(size) 4 >>> e.keypress(size, 'left') >>> e.get_pref_col(size) 0 r N)�pref_col_maxcol�get_cursor_coords)rU rG r� �pref_colZ then_maxcolr: r: r; � get_pref_col� s zEdit.get_pref_colc C s t d��dS )z� No longer supported. >>> Edit().update_text() Traceback (most recent call last): EditError: update_text() has been removed. Use set_caption() or set_edit_text() instead. zNupdate_text() has been removed. Use set_caption() or set_edit_text() instead.N)r� rc r: r: r; � update_text� s zEdit.update_textc C s t |�\| _| _| �� dS )au Set the caption markup for this widget. :param caption: markup for caption preceding edit_text, see :meth:`Text.__init__` for description of text markup. >>> e = Edit("") >>> e.set_caption("cap1") >>> print(e.caption) cap1 >>> e.set_caption(('bold', "cap2")) >>> print(e.caption) cap2 >>> e.attrib [('bold', 4)] >>> e.caption = "cap3" # not supported because caption stores text but set_caption() takes markup Traceback (most recent call last): AttributeError: can't set attribute N)r r� r� rd )rU r� r: r: r; r� � s zEdit.set_captionc C s | j S r` )r� rc r: r: r; rp rq z Edit.<lambda>zK Read-only property returning the caption for this widget. rr c C sB |dk r d}|t | j�kr$t | j�}d| _d| _|| _| �� dS )a� Set the cursor position with a self.edit_text offset. Clips pos to [0, len(edit_text)]. :param pos: cursor position :type pos: int >>> e = Edit(u"", u"word") >>> e.edit_pos 4 >>> e.set_edit_pos(2) >>> e.edit_pos 2 >>> e.edit_pos = -1 # Urwid 0.9.9 or later >>> e.edit_pos 0 >>> e.edit_pos = 20 >>> e.edit_pos 4 r N�NN)rE r� � highlightr� r� rd )rU �posr: r: r; r� s zEdit.set_edit_posc C s | j S r` )r� rc r: r: r; rp 6 rq zI Property controlling the edit position for this widget. c C s || _ | �� dS )z� Set the character for masking text away. :param mask: hide text entered with this character, None:disable mask :type mask: bytes or unicode N)r� rd )rU r� r: r: r; r� : s z Edit.set_maskc C sX | � |�}d| _| �d|� | j}|| _| jt|�kr@t|�| _| �d|� | �� dS )a� Set the edit text for this widget. :param text: text for editing, type (bytes or unicode) must match the text in the caption :type text: bytes or unicode >>> e = Edit() >>> e.set_edit_text(u"yes") >>> print(e.edit_text) yes >>> e <Edit selectable flow widget 'yes' edit_pos=0> >>> e.edit_text = u"no" # Urwid 0.9.9 or later >>> print(e.edit_text) no Nr� r� )�_normalize_to_captionr� rf r� r� rE rd )rU r� Zold_textr: r: r; r� E s zEdit.set_edit_textc C s | j S )z� Return the edit text for this widget. >>> e = Edit(u"What? ", u"oh, nothing.") >>> print(e.get_edit_text()) oh, nothing. >>> print(e.edit_text) oh, nothing. )r� rc r: r: r; � get_edit_texta s zEdit.get_edit_textzE Property controlling the edit text for this widget. c C s6 | � |�}| �|�\}}| �|� | �|� d| _dS )aM Insert text at the cursor position and update cursor. This method is used by the keypress() method when inserting one or more characters into edit_text. :param text: text for inserting, type (bytes or unicode) must match the text in the caption :type text: bytes or unicode >>> e = Edit(u"", u"42") >>> e.insert_text(u".5") >>> e <Edit selectable flow widget '42.5' edit_pos=4> >>> e.set_edit_pos(2) >>> e.insert_text(u"a") >>> print(e.edit_text) 42a.5 N)r� �insert_text_resultr� r� r� )rU r� � result_text� result_posr: r: r; � insert_textq s zEdit.insert_textc C s: t |t�}t | jt�}||kr"|S |r0|�d�S |�d�S )zc Return text converted to the same type as self.caption (bytes or unicode) �ascii)� isinstancer r� �encode�decode)rU r� ZtuZcur: r: r; r� � s zEdit._normalize_to_captionc C s� | � |�}| jrF| j\}}| jd|� | j|d� }}|| }|}n | j}| j}z |d|� | ||d� }W n$ ds�tt| j||f���Y nX |t|�7 }||fS )a! Return result of insert_text(text) without actually performing the insertion. Handy for pre-validation. :param text: text for inserting, type (bytes or unicode) must match the text in the caption :type text: bytes or unicode Nr )r� r� r� r� �AssertionErrorrm rE )rU r� �start�stop�btext�etextr� r� r: r: r; r� � s � zEdit.insert_text_resultc C s� |\}| j }| �|�rDt|t�r6t| jt�s6|�d�}| �|� �n�|dkrr| jrrdd| j d }| �|� �nR|dkr�| jr�d}| �|� �n2| j | t kr�|dkr�|S t | j d|�}| � |� �n�| j | tk�r |t| j �kr�|S t| j |t| j ��}| � |� �n�| j | ttfk�r�d| _| �|f�\}}| �|f�}|dk �sPt�| j | tk�rj|d 8 }n|d 7 }| �|f||��s�|S �n8|d k�r�d | _| �� �s�|dk�r�|S t | j d|�}| �| j d|� | j | j d� � | � |� n�|d k�rZd | _| �� �s�|t| j �k�r |S t| j |t| j ��}| �| j d| j � | j |d� � nj| j | tt fk�r�d| _d | _| �|f�\}}| j | tk�r�| �|ft |� n| �|ft |� dS |S dS ) a� Handle editing keystrokes, return others. >>> e, size = Edit(), (20,) >>> e.keypress(size, 'x') >>> e.keypress(size, 'left') >>> e.keypress(size, '1') >>> print(e.edit_text) 1x >>> e.keypress(size, 'backspace') >>> e.keypress(size, 'end') >>> e.keypress(size, '2') >>> print(e.edit_text) x2 >>> e.keypress(size, 'shift f1') 'shift f1' zutf-8Ztabr� � Zenterr� r NrC Z backspacer� �delete) r� r� r� r r� r� r� r� r� r� r r r� r� r rE r r r r� r� r� r� �move_cursor_to_coordsr� �_delete_highlightedr� r r r� �RIGHT)rU rG �keyr� �p�x�yr� r: r: r; �keypress� s| � � �z Edit.keypressc C s� |\}| � |�}| �|d�\}}||k s4|t|�kr8dS t| �� d |||�}|t| j� } | dk rhd} | t| j�kr�t| j�} | | _||f| _| � � dS )a� Set the cursor position with (x,y) coordinates. Returns True if move succeeded, False otherwise. >>> size = (10,) >>> e = Edit("","edit\ntext") >>> e.move_cursor_to_coords(size, 5, 0) True >>> e.edit_pos 4 >>> e.move_cursor_to_coords(size, 5, 3) False >>> e.move_cursor_to_coords(size, 0, 1) True >>> e.edit_pos 5 r FT) r� �position_coordsrE r r� r� r� r� r� rd ) rU rG r� r� r� r� Ztop_xZtop_yr� Ze_posr: r: r; r� s zEdit.move_cursor_to_coordsc C s" |\}|dkr | � |f||�S dS )z� Move the cursor to the location clicked for button 1. >>> size = (20,) >>> e = Edit("","words here") >>> e.mouse_event(size, 'mouse press', 1, 2, 0, True) True >>> e.edit_pos 2 rC N�r� )rU rG ZeventZbuttonr� r� rP r� r: r: r; � mouse_event6 s zEdit.mouse_eventc C sP | j s dS | j \}}| jd|� | j|d� }}| �|| � || _d| _ dS )zm Delete all highlighted text and update cursor position, if any text is highlighted. NT)r� r� r� r� )rU r� r� r� r� r: r: r; r� F s zEdit._delete_highlightedc C s< |\}t |�| _t�| |f�}|r8t|�}| �|f�|_|S )a Render edit widget and return canvas. Include cursor when in focus. >>> c = Edit("? ","yes").render((10,), focus=True) >>> c.text # ... = b in Python 3 [...'? yes '] >>> c.cursor (5, 0) )rX r� r� r+ r r� Zcursorr� r: r: r; r+ T s z Edit.renderc C s� t �| ||�}| js|S | �� \}}t||| jt| j� �\}}|dk rv|d |� t|| | �g ||d d � S ||kr�|d |� t|| || d �g ||d d � S |S )Nr rC ) r� r� r� r� r r� rE r� r )rU r� r� r� r� �ignorer� r� r: r: r; r� n s( � �� ��zEdit.get_line_translationc C s |\}d| _ | �|| j�S )z� Return the (*x*, *y*) coordinates of cursor within widget. >>> Edit("? ","yes").get_cursor_coords((10,)) (5, 0) T)r� r� r� )rU rG r� r: r: r; r� � s zEdit.get_cursor_coordsc C s8 |t | j� }| �|�}t| �� d ||�\}}||fS )zR Return (*x*, *y*) coordinates for an offset into self.edit_text. r )rE r� r� r r� )rU r� r� r� r� r� r� r: r: r; r� � s zEdit.position_coords)F)N)$r< r= r> r? r r� rh r� r� r0 r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r+ r� r� r� r: r: r: r; r� F sJ � 0& a! r� c @ s2 e Zd ZdZdd� Zd dd�Zdd � Zd d � ZdS ) �IntEditz Edit widget for integer valuesc C s t |�dko|dkS )z1 Return true for decimal digits. rC � 0123456789)rE r� r: r: r; r� � s zIntEdit.valid_charr� Nc C s( |dk rt |�}nd}| j�||� dS )z� caption -- caption markup default -- default edit value >>> IntEdit(u"", 42) <IntEdit selectable flow widget '42' edit_pos=2> Nr� )�strZ_IntEdit__superr0 )rU r� �defaultrv r: r: r; r0 � s zIntEdit.__init__c C s` |\}t �| |f|�}|s\| jdkr\| jdd� dkr\| �| jd � | �| jdd� � q|S )a8 Handle editing keystrokes. Remove leading zeros. >>> e, size = IntEdit(u"", 5002), (10,) >>> e.keypress(size, 'home') >>> e.keypress(size, 'delete') >>> print(e.edit_text) 002 >>> e.keypress(size, 'end') >>> print(e.edit_text) 2 r NrC �0)r� r� r� r� r� r� )rU rG r� r� Z unhandledr: r: r; r� � s zIntEdit.keypressc C s | j rt| j �S dS dS )z� Return the numeric value of self.edit_text. >>> e, size = IntEdit(), (10,) >>> e.keypress(size, '5') >>> e.keypress(size, '1') >>> e.value() == 51 True r N)r� �intrc r: r: r; �value� s z IntEdit.value)r� N)r< r= r> r? r� r0 r� r r: r: r: r; r � s r c s t | �� G � fdd�dt�}|S )z� Return a mixin class that delegates all standard widget methods to an attribute given by attribute_name. This mixin is designed to be used as a superclass of another widget. c s� e Zd ZdgZd� fdd� Ze� fdd��Ze� fdd��Ze� fdd��Ze� fd d��Z e� fd d��Z e� fd d��Z e� fd d��Z e� fd d��Z e� fdd��ZdS )z7delegate_to_widget_mixin.<locals>.DelegateToWidgetMixinr, Fc s � | �j ||d�}t|�S rO )r+ r rT �Z get_delegater: r; r+ � s z>delegate_to_widget_mixin.<locals>.DelegateToWidgetMixin.renderc s � | �j S r` )rh rc r r: r; rp � rq z@delegate_to_widget_mixin.<locals>.DelegateToWidgetMixin.<lambda>c s � | �j S r` )r� rc r r: r; rp � rq c s � | �j S r` )r� rc r r: r; rp � rq c s � | �j S r` )r� rc r r: r; rp � rq c s � | �j S r` r rc r r: r; rp � rq c s � | �j S r` )r, rc r r: r; rp � rq c s � | �j S r` )r rc r r: r; rp � rq c s � | �j S r` )rj rc r r: r; rp � rq c s � | �j S r` )r& rc r r: r; rp � rq N)F)r< r= r> r* r+ r� rh r� r� r� r� r, r rj r& r: r r: r; �DelegateToWidgetMixin� s � �r )r rb )Zattribute_namer r: r r; �delegate_to_widget_mixin� s r c @ s e Zd ZdS )�WidgetWrapErrorNrB r: r: r: r; r � s r c @ s> e Zd Zdd� Zdd� Zedd� e�Zd dd �Zeee�ZdS ) � WidgetWrapc C s || _ dS )a9 w -- widget to wrap, stored as self._w This object will pass the functions defined in Widget interface definition to self._w. The purpose of this widget is to provide a base class for widgets that compose other widgets for their display and behaviour. The details of that composition should not affect users of the subclass. The subclass may decide to expose some of the wrapped widgets by behaving like a ContainerWidget or WidgetDecoration, or it may hide them from outside access. N��_wrapped_widget�rU �wr: r: r; r0 � s zWidgetWrap.__init__c C s || _ | �� dS )a� Change the wrapped widget. This is meant to be called only by subclasses. >>> size = (10,) >>> ww = WidgetWrap(Edit("hello? ","hi")) >>> ww.render(size).text # ... = b in Python 3 [...'hello? hi '] >>> ww.selectable() True >>> ww._w = Text("goodbye") # calls _set_w() >>> ww.render(size).text [...'goodbye '] >>> ww.selectable() False N)r rd r r: r: r; �_set_w s zWidgetWrap._set_wc C s | j S r` r rc r: r: r; rp rq zWidgetWrap.<lambda>Nc C s t d��d S )Nz�The WidgetWrap.w member variable has been renamed to WidgetWrap._w (not intended for use outside the class and its subclasses). Please update your code to use self._w instead of self.w.)r ru r: r: r; �_raise_old_name_error s z WidgetWrap._raise_old_name_error)N) r< r= r> r0 r r� Z_wr r r: r: r: r; r � s r r c C s dd l } | �� d S r� )�doctestZtestmod)r r: r: r; �_test* s r �__main__N)TZ __future__r r �operatorr Z urwid.compatr r Z urwid.utilr r r r r r Zurwid.text_layoutr r r Zurwidr r Z urwid.canvasr r r r Zurwid.command_mapr r r r r r r Zurwid.split_reprr r r rn r{ rk r� r� ZCENTERZTOPZMIDDLEZBOTTOMr� �ANYZCLIPZPACKZGIVENZRELATIVEZ RELATIVE_100ZWEIGHTZ MetaSignalsr) � ExceptionrA rI rN r1 r2 r_ r3 �objectrb r� r� r� r� r� r� r� r� r� r� r r r r r r< r: r: r: r; �<module> sz $! H! . W=!0
Save