Fix indexed bitmaps by correcting argument order at call

[hackapet/Adafruit_Blinka_Displayio.git] / displayio / _group.py

diff --git a/displayio/_group.py b/displayio/_group.py
index 903d7218380bfb84f145907081df9adc978e3cdf..2d858e6af9d85c690b38cefe66f1092fda75abeb 100644 (file)
--- a/displayio/_group.py
+++ b/displayio/_group.py
@@ -19,6 +19,8 @@ displayio for Blinka
 
 from __future__ import annotations
 from typing import Union, Callable
 
 from __future__ import annotations
 from typing import Union, Callable

+from circuitpython_typing import WriteableBuffer
+from vectorio._rectangle import _VectorShape

 from ._structs import TransformStruct
 from ._tilegrid import TileGrid
 from ._colorspace import Colorspace
 from ._structs import TransformStruct
 from ._tilegrid import TileGrid
 from ._colorspace import Colorspace


@@ -29,6 +31,7 @@ __repo__ = "https://github.com/adafruit/Adafruit_Blinka_displayio.git"
 
 
 class Group:
 
 
 class Group:

+    # pylint: disable=too-many-instance-attributes

     """
     Manage a group of sprites and groups and how they are inter-related.
 
     """
     Manage a group of sprites and groups and how they are inter-related.
 


@@ -46,11 +49,13 @@ class Group:
         if not isinstance(scale, int) or scale < 1:
             raise ValueError("Scale must be >= 1")
         self._scale = 1  # Use the setter below to actually set the scale
         if not isinstance(scale, int) or scale < 1:
             raise ValueError("Scale must be >= 1")
         self._scale = 1  # Use the setter below to actually set the scale

+        self._name = "Group"

         self._group_x = x
         self._group_y = y
         self._hidden_group = False
         self._group_x = x
         self._group_y = y
         self._hidden_group = False

+        self._hidden_by_parent = False

         self._layers = []
         self._layers = []

-        self._supported_types = (TileGrid, Group)
+        self._supported_types = (TileGrid, Group, _VectorShape)

         self._in_group = False
         self._item_removed = False
         self._absolute_transform = TransformStruct(0, 0, 1, 1, 1, False, False, False)
         self._in_group = False
         self._item_removed = False
         self._absolute_transform = TransformStruct(0, 0, 1, 1, 1, False, False, False)


@@ -64,8 +69,12 @@ class Group:
             y = self._group_y
             if parent_transform.transpose_xy:
                 x, y = y, x
             y = self._group_y
             if parent_transform.transpose_xy:
                 x, y = y, x

-            self._absolute_transform.x = parent_transform.x + parent_transform.dx * x
-            self._absolute_transform.y = parent_transform.y + parent_transform.dy * y
+            self._absolute_transform.x = int(
+                parent_transform.x + parent_transform.dx * x
+            )
+            self._absolute_transform.y = int(
+                parent_transform.y + parent_transform.dy * y
+            )

             self._absolute_transform.dx = parent_transform.dx * self._scale
             self._absolute_transform.dy = parent_transform.dy * self._scale
             self._absolute_transform.transpose_xy = parent_transform.transpose_xy
             self._absolute_transform.dx = parent_transform.dx * self._scale
             self._absolute_transform.dy = parent_transform.dy * self._scale
             self._absolute_transform.transpose_xy = parent_transform.transpose_xy


@@ -90,33 +99,34 @@ class Group:
         layer = self._layers[index]
         layer._update_transform(self._absolute_transform)
 
         layer = self._layers[index]
         layer._update_transform(self._absolute_transform)
 

-    def append(self, layer: Union[Group, TileGrid]) -> None:
+    def append(self, layer: Union[Group, TileGrid, _VectorShape]) -> None:

         """Append a layer to the group. It will be drawn
         above other layers.
         """
         self.insert(len(self._layers), layer)
 
         """Append a layer to the group. It will be drawn
         above other layers.
         """
         self.insert(len(self._layers), layer)
 

-    def insert(self, index: int, layer: Union[Group, TileGrid]) -> None:
+    def insert(self, index: int, layer: Union[Group, TileGrid, _VectorShape]) -> None:

         """Insert a layer into the group."""
         if not isinstance(layer, self._supported_types):
             raise ValueError("Invalid Group Member")
         """Insert a layer into the group."""
         if not isinstance(layer, self._supported_types):
             raise ValueError("Invalid Group Member")

-        if layer._in_group:  # pylint: disable=protected-access
-            raise ValueError("Layer already in a group.")
+        if isinstance(layer, (Group, TileGrid)):
+            if layer._in_group:  # pylint: disable=protected-access
+                raise ValueError("Layer already in a group.")

         self._layers.insert(index, layer)
         self._layer_update(index)
 
         self._layers.insert(index, layer)
         self._layer_update(index)
 

-    def index(self, layer: Union[Group, TileGrid]) -> int:
+    def index(self, layer: Union[Group, TileGrid, _VectorShape]) -> int:

         """Returns the index of the first copy of layer.
         Raises ValueError if not found.
         """
         return self._layers.index(layer)
 
         """Returns the index of the first copy of layer.
         Raises ValueError if not found.
         """
         return self._layers.index(layer)
 

-    def pop(self, index: int = -1) -> Union[Group, TileGrid]:
+    def pop(self, index: int = -1) -> Union[Group, TileGrid, _VectorShape]:

         """Remove the ith item and return it."""
         self._removal_cleanup(index)
         return self._layers.pop(index)
 
         """Remove the ith item and return it."""
         self._removal_cleanup(index)
         return self._layers.pop(index)
 

-    def remove(self, layer: Union[Group, TileGrid]) -> None:
+    def remove(self, layer: Union[Group, TileGrid, _VectorShape]) -> None:

         """Remove the first copy of layer. Raises ValueError
         if it is not present."""
         index = self.index(layer)
         """Remove the first copy of layer. Raises ValueError
         if it is not present."""
         index = self.index(layer)


@@ -130,11 +140,13 @@ class Group:
         """Returns the number of layers in a Group"""
         return len(self._layers)
 
         """Returns the number of layers in a Group"""
         return len(self._layers)
 

-    def __getitem__(self, index: int) -> Union[Group, TileGrid]:
+    def __getitem__(self, index: int) -> Union[Group, TileGrid, _VectorShape]:

         """Returns the value at the given index."""
         return self._layers[index]
 
         """Returns the value at the given index."""
         return self._layers[index]
 

-    def __setitem__(self, index: int, value: Union[Group, TileGrid]) -> None:
+    def __setitem__(
+        self, index: int, value: Union[Group, TileGrid, _VectorShape]
+    ) -> None:

         """Sets the value at the given index."""
         self._removal_cleanup(index)
         self._layers[index] = value
         """Sets the value at the given index."""
         self._removal_cleanup(index)
         self._layers[index] = value


@@ -145,17 +157,19 @@ class Group:
         del self._layers[index]
 
     def _fill_area(
         del self._layers[index]
 
     def _fill_area(

-        self, colorspace: Colorspace, area: Area, mask: int, buffer: bytearray
+        self,
+        colorspace: Colorspace,
+        area: Area,
+        mask: WriteableBuffer,
+        buffer: WriteableBuffer,

     ) -> bool:
     ) -> bool:

-        if self._hidden_group:
-            return False
-
-        for layer in self._layers:
-            if isinstance(layer, (Group, TileGrid)):
-                if layer._fill_area(  # pylint: disable=protected-access
-                    colorspace, area, mask, buffer
-                ):
-                    return True
+        if not self._hidden_group:
+            for layer in reversed(self._layers):
+                if isinstance(layer, (Group, TileGrid, _VectorShape)):
+                    if layer._fill_area(  # pylint: disable=protected-access
+                        colorspace, area, mask, buffer
+                    ):
+                        return True

         return False
 
     def sort(self, key: Callable, reverse: bool) -> None:
         return False
 
     def sort(self, key: Callable, reverse: bool) -> None:


@@ -163,15 +177,42 @@ class Group:
         self._layers.sort(key=key, reverse=reverse)
 
     def _finish_refresh(self):
         self._layers.sort(key=key, reverse=reverse)
 
     def _finish_refresh(self):

-        for layer in self._layers:
-            if isinstance(layer, (Group, TileGrid)):
+        for layer in reversed(self._layers):
+            if isinstance(layer, (Group, TileGrid, _VectorShape)):

                 layer._finish_refresh()  # pylint: disable=protected-access
 
     def _get_refresh_areas(self, areas: list[Area]) -> None:
                 layer._finish_refresh()  # pylint: disable=protected-access
 
     def _get_refresh_areas(self, areas: list[Area]) -> None:

+        # pylint: disable=protected-access
+        for layer in reversed(self._layers):
+            if isinstance(layer, (Group, _VectorShape)):
+                layer._get_refresh_areas(areas)
+            elif isinstance(layer, TileGrid):
+                if not layer._get_rendered_hidden():
+                    layer._get_refresh_areas(areas)
+
+    def _set_hidden(self, hidden: bool) -> None:
+        if self._hidden_group == hidden:
+            return
+        self._hidden_group = hidden
+        if self._hidden_by_parent:
+            return

         for layer in self._layers:
             if isinstance(layer, (Group, TileGrid)):
         for layer in self._layers:
             if isinstance(layer, (Group, TileGrid)):

-                if not layer.hidden:
-                    layer._get_refresh_areas(areas)  # pylint: disable=protected-access
+                layer._set_hidden_by_parent(hidden)  # pylint: disable=protected-access
+            elif isinstance(layer, _VectorShape):
+                layer._shape_set_dirty()  # pylint: disable=protected-access
+
+    def _set_hidden_by_parent(self, hidden: bool) -> None:
+        if self._hidden_by_parent == hidden:
+            return
+        self._hidden_by_parent = hidden
+        if self._hidden_group:
+            return
+        for layer in self._layers:
+            if isinstance(layer, (Group, TileGrid)):
+                layer._set_hidden_by_parent(hidden)  # pylint: disable=protected-access
+            elif isinstance(layer, _VectorShape):
+                layer._shape_set_dirty()  # pylint: disable=protected-access

 
     @property
     def hidden(self) -> bool:
 
     @property
     def hidden(self) -> bool:


@@ -181,10 +222,11 @@ class Group:
         return self._hidden_group
 
     @hidden.setter
         return self._hidden_group
 
     @hidden.setter

-    def hidden(self, value: bool):
+    def hidden(self, value: bool) -> None:

         if not isinstance(value, (bool, int)):
             raise ValueError("Expecting a boolean or integer value")
         if not isinstance(value, (bool, int)):
             raise ValueError("Expecting a boolean or integer value")

-        self._hidden_group = bool(value)
+        value = bool(value)
+        self._set_hidden(value)

 
     @property
     def scale(self) -> int:
 
     @property
     def scale(self) -> int:


@@ -203,12 +245,12 @@ class Group:
         if not isinstance(value, int) or value < 1:
             raise ValueError("Scale must be >= 1")
         if self._scale != value:
         if not isinstance(value, int) or value < 1:
             raise ValueError("Scale must be >= 1")
         if self._scale != value:

-            parent_scale = self._absolute_transform.scale / self._scale
+            parent_scale = self._absolute_transform.scale // self._scale

             self._absolute_transform.dx = (
             self._absolute_transform.dx = (

-                self._absolute_transform.dx / self._scale * value
+                self._absolute_transform.dx // self._scale * value

             )
             self._absolute_transform.dy = (
             )
             self._absolute_transform.dy = (

-                self._absolute_transform.dy / self._scale * value
+                self._absolute_transform.dy // self._scale * value

             )
             self._absolute_transform.scale = parent_scale * value
 
             )
             self._absolute_transform.scale = parent_scale * value
 


@@ -226,10 +268,10 @@ class Group:
             raise ValueError("x must be an integer")
         if self._group_x != value:
             if self._absolute_transform.transpose_xy:
             raise ValueError("x must be an integer")
         if self._group_x != value:
             if self._absolute_transform.transpose_xy:

-                dy_value = self._absolute_transform.dy / self._scale
+                dy_value = self._absolute_transform.dy // self._scale

                 self._absolute_transform.y += dy_value * (value - self._group_x)
             else:
                 self._absolute_transform.y += dy_value * (value - self._group_x)
             else:

-                dx_value = self._absolute_transform.dx / self._scale
+                dx_value = self._absolute_transform.dx // self._scale

                 self._absolute_transform.x += dx_value * (value - self._group_x)
             self._group_x = value
             self._update_child_transforms()
                 self._absolute_transform.x += dx_value * (value - self._group_x)
             self._group_x = value
             self._update_child_transforms()


@@ -245,10 +287,13 @@ class Group:
             raise ValueError("y must be an integer")
         if self._group_y != value:
             if self._absolute_transform.transpose_xy:
             raise ValueError("y must be an integer")
         if self._group_y != value:
             if self._absolute_transform.transpose_xy:

-                dx_value = self._absolute_transform.dx / self._scale
+                dx_value = self._absolute_transform.dx // self._scale

                 self._absolute_transform.x += dx_value * (value - self._group_y)
             else:
                 self._absolute_transform.x += dx_value * (value - self._group_y)
             else:

-                dy_value = self._absolute_transform.dy / self._scale
+                dy_value = self._absolute_transform.dy // self._scale

                 self._absolute_transform.y += dy_value * (value - self._group_y)
             self._group_y = value
             self._update_child_transforms()
                 self._absolute_transform.y += dy_value * (value - self._group_y)
             self._group_y = value
             self._update_child_transforms()

+
+
+circuitpython_splash = Group(scale=2, x=0, y=0)