Some refactoring. Getting negative values working

Author: hugodahl

adafruit_progressbar/__init__.py

@@ -44,10 +44,6 @@ class ProgressBarBase(displayio.TileGrid):
     :type position: Tuple[int, int]
     :param size: The size (width, height) of the progress bar
     :type size: Tuple[int, int]
-    :param start_value: The beginning value of the progress bar. This value
-                              is displayed when the progress bar is first visible,
-                              if it hasn't been updated.
-    :type start_value: float
     :param bar_color: The color of the bar representing the value. This can
                             be a hexadecimal value for color (0x224466).
                             Default: 0x00FF00 (Solid green)
@@ -74,12 +70,11 @@ class ProgressBarBase(displayio.TileGrid):
     :type value_range: Tuple[int, int] or Tuple[float, float]
     """
 
-    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-arguments, too-many-instance-attributes
     def __init__(
         self,
         position,
         size,
-        start_value=0.0,
         value=0,
         bar_color=0x00FF00,
         outline_color=0xFFFFFF,
@@ -91,8 +86,7 @@ def __init__(
 
         self._widget_size = size
         self._position = position
-        self._progress = start_value
-        print(f"Size: {size} - WS: {self.widget_size}")
+
         self._bitmap = displayio.Bitmap(size[0], size[1], 3)
         self._palette = displayio.Palette(3)
         self._palette[0] = fill_color
@@ -101,7 +95,17 @@ def __init__(
         self._border_thickness = border_thickness
         self._show_margin = show_margin
         self._range = value_range
-        self._value = value
+        self._progress = 0.0
+
+        # Setup value and old_value to handle the change to the new
+        # initial value later.
+        self._value = self.minimum
+        self._old_value = self.minimum
+
+        self._margin = 0
+
+        if self._show_margin:
+            self._margin = 1
 
         super().__init__(
             self._bitmap,
@@ -111,6 +115,8 @@ def __init__(
         )
 
         self._draw_outline()
+        self.render(self.minimum, self.minimum + 1, 0)
+        self.value = value
 
     #     _bitmap: displayio.Bitmap  # The bitmap used for the bar/value
     #     _position: (int, int)  # The (x,y) coordinates of the top-left corner
@@ -138,11 +144,6 @@ def widget_height(self):
         """The total height of the widget, in pixels. Includes the border and margin."""
         return self.widget_size[1]
 
-    @property
-    def _outline_color(self):
-        """The colour of the border/outline of the widget"""
-        return self._palette[1]
-
     @property
     def x(self):
         """The horizontal (x) position of the top-left corner of the widget."""
@@ -188,6 +189,15 @@ def value(self):
 
     @value.setter
     def value(self, value):
+        """Sets the current value of the progress within the min-max range
+
+        :param value: The new value for the progress status
+        :type value: int/float
+        """
+        # Save off the previous value, so we can pass it in the
+        # call to "Render"
+        print(f"Updating value from {self._value} to {value}")
+        self._old_value = self._value
         self._value = value
         # Convert value to float since we may be dealing with
         # integer types, and we can't work with integer division
@@ -210,15 +220,17 @@ def border_thickness(self):
     def progress(self, value):
         """The current displayed value of the widget.
 
-        :param float value: The new value which should be displayed by the progress
+        :param value: The new value which should be displayed by the progress
                             bar. Must be between 0.0-1.0
+        :type value: float
         """
-        _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)
-        print(f"Calling render() with ({_old_value}, {self.progress}, {self.progress})")
-        self.render(_old_value, self.progress, self.progress)
+        print(
+            f"Calling render() with ({self._old_value}, {self.value}, {self.progress})"
+        )
+        self.render(self._old_value, self.value, self.progress)
 
     @property
     def range(self):

adafruit_progressbar/horizontalprogressbar.py

@@ -48,8 +48,6 @@ class HorizontalProgressBar(ProgressBarBase):
     :type anchor_position: Tuple[int, int]
     :param size: The size in (width, height) of the progress bar
     :type size: Tuple[int, int]
-    :param progress: The percentage of the progress bar.
-    :type progress: float
     :param bar_color: The color of the progress bar. Can be a hex
         value for color.
     :param outline_color: The outline of the progress bar. Can be a hex
@@ -85,16 +83,16 @@ def __init__(
         super().__init__(
             anchor_position,
             size,
-            progress,
+            value,
             bar_color,
             outline_color,
             fill_color,
-            value,
-            border_thickness=border_thickness,
-            show_margin=show_margin,
-            value_range=(min_value, max_value),
+            border_thickness,
+            show_margin,
+            (min_value, max_value),
         )
 
+    # pylint: disable=too-many-locals
     def render(self, _previous_value, _new_value, _progress_value) -> None:
         """
         The rendering mechanism to display the newly set value.
@@ -109,20 +107,63 @@ def render(self, _previous_value, _new_value, _progress_value) -> None:
         :rtype None:
         """
 
-        if _previous_value == _new_value:
-            return  # Do nothing if there's nothing to update
+        _padding = self.border_thickness
+
+        if self._margin:
+            _padding += 1
+
+        _border_thickness = self.border_thickness
+        _border_size = (
+            _border_thickness * 2
+        )  # Size of the border on both sides of the control (1),
+        # in both directions (left-to-right and top-to-bottom)
+
+        _fill_width = (
+            self.widget_width - (2 * _padding) - _border_size
+        )  # Count padding on left and right
+        _fill_height = (
+            self.widget_height - (2 * _padding) - _border_size
+        )  # Count padding on the top and bottom
+
+        _prev_prog = float(_previous_value - self.minimum) / (
+            abs(self.minimum) + abs(self.maximum)
+        )
+
+        print(f"Progress: from {_prev_prog} to {_progress_value}")
+        _prev_value_size = int(_prev_prog * _fill_height)
+        _new_value_size = int(_progress_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.minimum:
+            _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.maximum:
+            _new_value_size -= 1
+
+        # Default values for increasing value
+        _color = 2
+        _incr = 1
+        _start_offset = _padding + _border_thickness
+        _start = max(_prev_value_size, _start_offset)
+        _end = max(_new_value_size, 0) + _start_offset
 
         if _previous_value > _new_value:
+            print("prev > new")
             # 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)
+            _prev_pixel = max(2, int(self.widget_width * _previous_value - _padding))
+            _new_pixel = max(int(self.widget_width * _new_value - _padding), 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:
+            print("prev <= new")
             # fill from the previous x pixel to the new x pixel
-            _prev_pixel = max(2, int(self.widget_width * self.progress - 3))
+            _prev_pixel = max(2, int(self.widget_width * _previous_value - 3))
             _new_pixel = min(
                 int(self.widget_width * _new_value - 2),
                 int(self.widget_width * 1.0 - 3),

adafruit_progressbar/progressbar.py

@@ -37,8 +37,6 @@ class ProgressBar(HorizontalProgressBar):
     :type width: int
     :param height: The height of the progress bar.
     :type height: int
-    :param progress: The percentage of the progress bar.
-    :type progress: float
     :param bar_color: The color of the progress bar. Can be a hex
         value for color.
     :param outline_color: The outline of the progress bar. Can be a hex
@@ -70,8 +68,7 @@ def __init__(
             (width, height),
             0,
             100,
-            progress,
-            0,
+            (progress * 100),  # Progress vs. max above
             bar_color,
             outline_color,
             0x000000,

adafruit_progressbar/verticalprogressbar.py

@@ -84,7 +84,6 @@ def __init__(
         size,
         min_value=0,
         max_value=100,
-        progress=0.0,
         value=0,
         bar_color=0x00FF00,
         outline_color=0xFFFFFF,
@@ -129,7 +128,6 @@ def __init__(
         super().__init__(
             anchor_position,
             size,
-            progress,
             value,
             bar_color,
             outline_color,
@@ -155,14 +153,12 @@ def render(self, _old_value, _new_value, _progress_value):
         :return: None
         :rtype: None
         """
-        _padding = 0
-
-        print(f"Drawing a visual of progress value {_progress_value}")
+        _padding = self._border_thickness
 
         if self._margin:
-            _padding = 1
+            _padding += 1
 
-        _border_thickness = 1
+        _border_thickness = self.border_thickness
         _border_size = (
             _border_thickness * 2
         )  # Size of the border on both sides of the control (1),