Refactor out changes to ProgressBarBase

ProgressBar fully refactored
VerticalProgressBar fully refactored

Author: hugodahl

adafruit_progressbar/__init__.py

@@ -25,6 +25,18 @@
 import displayio
 
 
+# pylint: disable=too-few-public-methods
+class FillDirection(enumerate):
+    """Enums to define the direction in which the progressbar
+    should fill"""
+
+    LEFT_TO_RIGHT = 0
+    DEFAULT = LEFT_TO_RIGHT
+    BOTTOM_UP = 1
+    TOP_DOWN = 2
+    RIGHT_TO_LEFT = 3
+
+
 class ProgressBarBase(displayio.TileGrid):
     """The base class for dynamic progress bar widgets.
 
@@ -181,7 +193,7 @@ def progress(self, value):
         :param float value: The new value which should be displayed by the progress
                             bar. Must be between 0.0-1.0
         """
-        _old_value = self._progress
+        _old_value = self.progress
         # If we're using floats, from 0.0 to 1.0, using 4 decimal places allows us to handle values
         # as precise as 0.23456, which evaluates to a percentage value of 23.45% (with rounding)
         self._progress = round(value, 4)

adafruit_progressbar/horizontalprogressbar.py

@@ -0,0 +1,66 @@
+# SPDX-FileCopyrightText: 2020 Brent Rubell for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+`horizontalprogressbar`
+================================================================================
+
+Dynamic progress bar widget for CircuitPython displays
+
+
+"""
+
+# import displayio
+from . import ProgressBarBase  # , FillDirection
+
+
+class HorizontalProgressBar(ProgressBarBase):
+    """
+    A progress bar that goes horizontally.
+    """
+
+    def __init__(self):
+        """
+        Get stuff, horizontally!
+        :param args:
+        :param kwargs:
+        """
+
+        super().__init__((0, 0), (100, 20), 0.0)
+
+    def render(self, _previous_value, _new_value, _progress_value) -> None:
+        """
+        The rendering mechanism to display the newly set value.
+
+        :param _previous_value:  The value from which we are updating
+        :type _previous_value: object
+        :param _new_value: The value to which we are updating
+        :type _new_value: object
+        :param _progress_value: The value of the progress, or ratio between the new value and the
+            maximum value
+        :type _progress_value: float
+        :rtype None:
+        """
+
+        if _previous_value == _new_value:
+            return  # Do nothing if there's nothing to update
+
+        if _previous_value > _new_value:
+            # Remove color in range from width*value+margin to width-margin
+            # from right to left
+            _prev_pixel = max(2, int(self.widget_width * self.progress - 2))
+            _new_pixel = max(int(self.widget_width * _new_value - 2), 2)
+            for _w in range(_prev_pixel, _new_pixel - 1, -1):
+                for _h in range(2, self.widget_height - 2):
+                    self._bitmap[_w, _h] = 0
+        else:
+            # fill from the previous x pixel to the new x pixel
+            _prev_pixel = max(2, int(self.widget_width * self.progress - 3))
+            _new_pixel = min(
+                int(self.widget_width * _new_value - 2),
+                int(self.widget_width * 1.0 - 3),
+            )
+            for _w in range(_prev_pixel, _new_pixel + 1):
+                for _h in range(2, self.widget_height - 2):
+                    self._bitmap[_w, _h] = 2

adafruit_progressbar/progressbar.py

@@ -22,11 +22,11 @@
 """
 
 # imports
-from . import ProgressBarBase
+from horizontalprogressbar import HorizontalProgressBar
 
 
 # pylint: disable=too-many-arguments, too-few-public-methods
-class ProgressBar(ProgressBarBase):
+class ProgressBar(HorizontalProgressBar):
     """A dynamic progress bar widget.
 
     :param x: The x-position of the top left corner.
@@ -61,7 +61,7 @@ def __init__(
         stroke=1,
     ):
 
-        # This needs to remain, since for backward compatibility, the default ProgressBar class
+        # This needs to remain for backward compatibility, the default ProgressBar class
         # should only be able to handle values of type "float"
         assert isinstance(progress, float), "Progress must be a floating point value."
 
@@ -79,31 +79,6 @@ def __init__(
 
     #     _outline_color: int  # The colour used for the border of the widget
 
-    @property
-    def outline_color(self):
-        """Returns the currently configured value for the color of the
-        outline (border) of the widget."""
-        return self._outline_color
-
-    @property
-    def fill(self):
-        """The fill of the progress bar. Can be a hex value for a color or ``None`` for
-        transparent.
-        """
-        return self._palette[0]
-
-    @fill.setter
-    def fill(self, color):
-        """Sets the fill of the progress bar. Can be a hex value for a color or ``None`` for
-        transparent.
-        """
-        if color is None:
-            self._palette[2] = 0
-            self._palette.make_transparent(0)
-        else:
-            self._palette[2] = color
-            self._palette.make_opaque(0)
-
     def render(self, _previous_value, _new_value, _progress_value) -> None:
         """
         The rendering mechanism to display the newly set value.

adafruit_progressbar/verticalprogressbar.py

@@ -24,19 +24,7 @@
 
 # imports
 import displayio
-from . import ProgressBarBase
-
-
-# pylint: disable=too-few-public-methods
-class FillDirection(enumerate):
-    """Enums to define the direction in which the progressbar
-    should fill"""
-
-    LEFT_TO_RIGHT = 0
-    DEFAULT = LEFT_TO_RIGHT
-    BOTTOM_UP = 1
-    TOP_DOWN = 2
-    RIGHT_TO_LEFT = 3
+from . import ProgressBarBase, FillDirection
 
 
 # pylint: disable=too-many-arguments, too-few-public-methods, too-many-instance-attributes
@@ -100,6 +88,7 @@ def __init__(
         progress=0.0,
         bar_color=0x00FF00,
         outline_color=0xFFFFFF,
+        fill_color=None,
         stroke=1,
         margin=False,
         direction=FillDirection.DEFAULT,
@@ -132,10 +121,6 @@ def __init__(
         self._bar_width = self._width
         self._bar_height = self._height
 
-        self._progress_val = 0.0
-        self.progress = self._progress_val
-        self.progress = progress
-
         self._x = anchor_position[0]
         self._y = anchor_position[1]
 
@@ -147,70 +132,31 @@ def __init__(
             progress,
             bar_color,
             outline_color,
-            0x444444,
+            fill_color,
             border_thickness=stroke,
             show_margin=True,
             value_range=(0.0, 1.0),
         )
 
-        self._draw_outline()
-
-    def _draw_outline(self):
-        """
-        Draws the outline (border) of the widget.
-        """
-
-        # draw outline rectangle
-        for _w in range(self._width):
-            for line in range(self._stroke):
-                self._bitmap[_w, line] = 1
-                self._bitmap[_w, self._height - 1 - line] = 1
-        for _h in range(self._height):
-            for line in range(self._stroke):
-                self._bitmap[line, _h] = 1
-                self._bitmap[self._width - 1 - line, _h] = 1
-
-    @property
-    def progress(self):
-        """The percentage of the progress bar expressed as a
-        floating point number.
-        """
-        return self._progress_val
-
     # pylint: disable=too-many-locals
-    @progress.setter
-    def progress(self, value):
-        """Draws the progress bar
-
-        :param value: Progress bar value.
-        :type value: float
-        """
-        assert value <= self._max, "Progress value may not be > maximum value"
-        assert value >= self._min, "Progress value may not be < minimum value"
-
-        _old_value = self._progress_val
-        _new_value = round(value / self._max, 2)
-        self._progress_val = _new_value
-        self.render(_old_value, _new_value, value)
-
-    def render(self, old_value, new_value, progress):
+    def render(self, _old_value, _new_value, _progress_value):
         """
         Does the work of actually creating the graphical representation of
             the value (percentage, aka "progress") to be displayed.
 
-        :param old_value: The previously displayed value
-        :type old_value: float
-        :param new_value: The new value to display
-        :type new_value: float
-        :param progress: The value to display, as a percentage, represented
+        :param _old_value: The previously displayed value
+        :type _old_value: float
+        :param _new_value: The new value to display
+        :type _new_value: float
+        :param _progress_value: The value to display, as a percentage, represented
             by a float from 0.0 to 1.0 (0% to 100%)
-        :type progress: float
+        :type _progress_value: float
         :return: None
         :rtype: None
         """
         _padding = 0
 
-        print(f"Drawing a visual of progress value {progress}")
+        print(f"Drawing a visual of progress value {_progress_value}")
 
         if self._margin:
             _padding = 1
@@ -222,24 +168,24 @@ def render(self, old_value, new_value, progress):
         # in both directions (left-to-right and top-to-bottom)
 
         _fill_width = (
-            self.width - (2 * _padding) - _border_size
+            self.widget_width - (2 * _padding) - _border_size
         )  # Count padding on left and right
         _fill_height = (
-            self.height - (2 * _padding) - _border_size
+            self.widget_height - (2 * _padding) - _border_size
         )  # Count padding on the top and bottom
 
-        _prev_value_size = int(old_value * _fill_height)
-        _new_value_size = int(new_value * _fill_height)
+        _prev_value_size = int(_old_value * _fill_height)
+        _new_value_size = int(_new_value * _fill_height)
 
         # If we have *ANY* value other than "zero" (minimum), we should
         #   have at least one element showing
-        if _new_value_size == 0 and new_value > self._min:
+        if _new_value_size == 0 and _new_value > self._min:
             _new_value_size = 1
 
         # Conversely, if we have *ANY* value other than 100% (maximum),
         #   we should NOT show a full bar.
 
-        if _new_value_size == _fill_height and new_value < self._max:
+        if _new_value_size == _fill_height and _new_value < self._max:
             _new_value_size -= 1
 
         # Default values for increasing value
@@ -269,32 +215,3 @@ def render(self, old_value, new_value, progress):
         for h in range(_start, _end, _incr):
             for w in range(_start_offset, _fill_width):
                 self._bitmap[w, h] = _color
-
-    @property
-    def fill(self):
-        """The fill of the progress bar. Can be a hex value for a color or
-        ``None`` for transparent.
-        """
-        return self._palette[0]
-
-    @property
-    def width(self):
-        """The width of the progress bar. In pixels, includes the border."""
-        return self._bar_width
-
-    @property
-    def height(self):
-        """The height of the progress bar. In pixels, includes the border."""
-        return self._bar_height
-
-    @fill.setter
-    def fill(self, color):
-        """Sets the fill of the progress bar. Can be a hex value for a color or
-        ``None`` for transparent.
-        """
-        if color is None:
-            self._palette[2] = 0
-            self._palette.make_transparent(0)
-        else:
-            self._palette[2] = color
-            self._palette.make_opaque(0)