urwid 2.6.0.post0__py3-none-any.whl

urwid/widget/popup.py

@@ -0,0 +1,170 @@
+# Urwid Window-Icon-Menu-Pointer-style widget classes
+#    Copyright (C) 2004-2011  Ian Ward
+#
+#    This library is free software; you can redistribute it and/or
+#    modify it under the terms of the GNU Lesser General Public
+#    License as published by the Free Software Foundation; either
+#    version 2.1 of the License, or (at your option) any later version.
+#
+#    This library is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public
+#    License along with this library; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# Urwid web site: https://urwid.org/
+
+
+from __future__ import annotations
+
+import typing
+
+from urwid.canvas import CompositeCanvas
+
+from .constants import Sizing
+from .overlay import Overlay
+from .widget import delegate_to_widget_mixin
+from .widget_decoration import WidgetDecoration
+
+if typing.TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    from urwid.canvas import Canvas
+
+    from .widget import Widget
+
+    class PopUpParametersModel(TypedDict):
+        left: int
+        top: int
+        overlay_width: int
+        overlay_height: int
+
+
+WrappedWidget = typing.TypeVar("WrappedWidget")
+
+
+class PopUpLauncher(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[WrappedWidget]):
+    def __init__(self, original_widget: [WrappedWidget]) -> None:
+        super().__init__(original_widget)
+        self._pop_up_widget = None
+
+    def create_pop_up(self) -> Widget:
+        """
+        Subclass must override this method and return a widget
+        to be used for the pop-up.  This method is called once each time
+        the pop-up is opened.
+        """
+        raise NotImplementedError("Subclass must override this method")
+
+    def get_pop_up_parameters(self) -> PopUpParametersModel:
+        """
+        Subclass must override this method and have it return a dict, eg:
+
+        {'left':0, 'top':1, 'overlay_width':30, 'overlay_height':4}
+
+        This method is called each time this widget is rendered.
+        """
+        raise NotImplementedError("Subclass must override this method")
+
+    def open_pop_up(self) -> None:
+        self._pop_up_widget = self.create_pop_up()
+        self._invalidate()
+
+    def close_pop_up(self) -> None:
+        self._pop_up_widget = None
+        self._invalidate()
+
+    def render(self, size, focus: bool = False) -> CompositeCanvas | Canvas:
+        canv = super().render(size, focus)
+        if self._pop_up_widget:
+            canv = CompositeCanvas(canv)
+            canv.set_pop_up(self._pop_up_widget, **self.get_pop_up_parameters())
+        return canv
+
+
+class PopUpTarget(WidgetDecoration[WrappedWidget]):
+    # FIXME: this whole class is a terrible hack and must be fixed
+    # when layout and rendering are separated
+    _sizing = frozenset((Sizing.BOX,))
+    _selectable = True
+
+    def __init__(self, original_widget: WrappedWidget) -> None:
+        super().__init__(original_widget)
+        self._pop_up = None
+        self._current_widget = self._original_widget
+
+    def _update_overlay(self, size: tuple[int, int], focus: bool) -> None:
+        canv = self._original_widget.render(size, focus=focus)
+        self._cache_original_canvas = canv  # imperfect performance hack
+        pop_up = canv.get_pop_up()
+        if pop_up:
+            left, top, (w, overlay_width, overlay_height) = pop_up
+            if self._pop_up != w:
+                self._pop_up = w
+                self._current_widget = Overlay(
+                    w,
+                    self._original_widget,
+                    ("fixed left", left),
+                    overlay_width,
+                    ("fixed top", top),
+                    overlay_height,
+                )
+            else:
+                self._current_widget.set_overlay_parameters(
+                    ("fixed left", left),
+                    overlay_width,
+                    ("fixed top", top),
+                    overlay_height,
+                )
+        else:
+            self._pop_up = None
+            self._current_widget = self._original_widget
+
+    def render(self, size: tuple[int, int], focus: bool = False) -> Canvas:
+        self._update_overlay(size, focus)
+        return self._current_widget.render(size, focus=focus)
+
+    def get_cursor_coords(self, size: tuple[int, int]) -> tuple[int, int] | None:
+        self._update_overlay(size, True)
+        return self._current_widget.get_cursor_coords(size)
+
+    def get_pref_col(self, size: tuple[int, int]) -> int:
+        self._update_overlay(size, True)
+        return self._current_widget.get_pref_col(size)
+
+    def keypress(self, size: tuple[int, int], key: str) -> str | None:
+        self._update_overlay(size, True)
+        return self._current_widget.keypress(size, key)
+
+    def move_cursor_to_coords(self, size: tuple[int, int], x: int, y: int):
+        self._update_overlay(size, True)
+        return self._current_widget.move_cursor_to_coords(size, x, y)
+
+    def mouse_event(
+        self,
+        size: tuple[int, int],
+        event: str,
+        button: int,
+        col: int,
+        row: int,
+        focus: bool,
+    ) -> bool | None:
+        self._update_overlay(size, focus)
+        return self._current_widget.mouse_event(size, event, button, col, row, focus)
+
+    def pack(self, size: tuple[int, int] | None = None, focus: bool = False) -> tuple[int, int]:
+        self._update_overlay(size, focus)
+        return self._current_widget.pack(size)
+
+
+def _test():
+    import doctest
+
+    doctest.testmod()
+
+
+if __name__ == "__main__":
+    _test()

urwid/widget/progress_bar.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import typing
+import warnings
+
+from .constants import BAR_SYMBOLS, Align, Sizing, WrapMode
+from .text import Text
+from .widget import Widget
+
+if typing.TYPE_CHECKING:
+    from urwid.canvas import TextCanvas
+
+
+class ProgressBar(Widget):
+    _sizing = frozenset([Sizing.FLOW])
+
+    eighths = BAR_SYMBOLS.HORISONTAL[:8]  # Full width line is made by style
+
+    text_align = Align.CENTER
+
+    def __init__(self, normal, complete, current: int = 0, done: int = 100, satt=None):
+        """
+        :param normal: display attribute for incomplete part of progress bar
+        :param complete: display attribute for complete part of progress bar
+        :param current: current progress
+        :param done: progress amount at 100%
+        :param satt: display attribute for smoothed part of bar where the
+                     foreground of satt corresponds to the normal part and the
+                     background corresponds to the complete part.
+                     If satt is ``None`` then no smoothing will be done.
+
+        >>> from urwid import LineBox
+        >>> pb = ProgressBar('a', 'b')
+        >>> pb
+        <ProgressBar flow widget>
+        >>> print(pb.get_text())
+        0 %
+        >>> pb.set_completion(34.42)
+        >>> print(pb.get_text())
+        34 %
+        >>> class CustomProgressBar(ProgressBar):
+        ...     def get_text(self):
+        ...         return u'Foobar'
+        >>> cpb = CustomProgressBar('a', 'b')
+        >>> print(cpb.get_text())
+        Foobar
+        >>> for x in range(101):
+        ...     cpb.set_completion(x)
+        ...     s = cpb.render((10, ))
+        >>> cpb2 = CustomProgressBar('a', 'b', satt='c')
+        >>> for x in range(101):
+        ...     cpb2.set_completion(x)
+        ...     s = cpb2.render((10, ))
+        >>> pb = ProgressBar('a', 'b', satt='c')
+        >>> pb.set_completion(34.56)
+        >>> print(LineBox(pb).render((20,)))
+        ┌──────────────────┐
+        │      ▏34 %       │
+        └──────────────────┘
+        """
+        super().__init__()
+        self.normal = normal
+        self.complete = complete
+        self._current = current
+        self._done = done
+        self.satt = satt
+
+    def set_completion(self, current: int) -> None:
+        """
+        current -- current progress
+        """
+        self._current = current
+        self._invalidate()
+
+    current = property(lambda self: self._current, set_completion)
+
+    @property
+    def done(self):
+        return self._done
+
+    @done.setter
+    def done(self, done):
+        """
+        done -- progress amount at 100%
+        """
+        self._done = done
+        self._invalidate()
+
+    def _set_done(self, done):
+        warnings.warn(
+            f"Method `{self.__class__.__name__}._set_done` is deprecated, "
+            f"please use property `{self.__class__.__name__}.done`",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.done = done
+
+    def rows(self, size: tuple[int], focus: bool = False) -> int:
+        return 1
+
+    def get_text(self) -> str:
+        """
+        Return the progress bar percentage text.
+        You can override this method to display custom text.
+        """
+        percent = min(100, max(0, int(self.current * 100 / self.done)))
+        return f"{percent!s} %"
+
+    def render(self, size: tuple[int], focus: bool = False) -> TextCanvas:
+        """
+        Render the progress bar.
+        """
+        # pylint: disable=protected-access
+        (maxcol,) = size
+        c = Text(self.get_text(), self.text_align, WrapMode.CLIP).render((maxcol,))
+
+        cf = float(self.current) * maxcol / self.done
+        ccol_dirty = int(cf)
+        ccol = len(c._text[0][:ccol_dirty].decode("utf-8", "ignore").encode("utf-8"))
+        cs = 0
+        if self.satt is not None:
+            cs = int((cf - ccol) * 8)
+        if ccol < 0 or (ccol == cs == 0):
+            c._attr = [[(self.normal, maxcol)]]
+        elif ccol >= maxcol:
+            c._attr = [[(self.complete, maxcol)]]
+        elif cs and c._text[0][ccol] == 32:
+            t = c._text[0]
+            cenc = self.eighths[cs].encode("utf-8")
+            c._text[0] = t[:ccol] + cenc + t[ccol + 1 :]
+            a = []
+            if ccol > 0:
+                a.append((self.complete, ccol))
+            a.append((self.satt, len(cenc)))
+            if maxcol - ccol - 1 > 0:
+                a.append((self.normal, maxcol - ccol - 1))
+            c._attr = [a]
+            c._cs = [[(None, len(c._text[0]))]]
+        else:
+            c._attr = [[(self.complete, ccol), (self.normal, maxcol - ccol)]]
+        return c