return rgba888 value from palette getitem

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

diff --git a/displayio/group.py b/displayio/group.py
index d28d83baef7fdeb242c0db3567027c08e171aceb..e84a487e62711085353643a549b841ddd18aab4a 100644 (file)
--- a/displayio/group.py
+++ b/displayio/group.py
@@ -1,24 +1,6 @@
-# The MIT License (MIT)
+# SPDX-FileCopyrightText: 2020 Melissa LeBlanc-Williams for Adafruit Industries

 #
 #

-# Copyright (c) 2020 Melissa LeBlanc-Williams for Adafruit Industries
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+# SPDX-License-Identifier: MIT

 
 """
 `displayio.group`
 
 """
 `displayio.group`


@@ -46,34 +28,46 @@ Transform = recordclass("Transform", "x y dx dy scale transpose_xy mirror_x mirr
 
 
 class Group:
 
 
 class Group:

-    """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.

 
 

-    def __init__(self, *, max_size=4, scale=1, x=0, y=0):
-        """Create a Group of a given size and scale. Scale is in
-        one dimension. For example, scale=2 leads to a layer’s
-        pixel being 2x2 pixels when in the group.
+    Create a Group of a given scale. Scale is in one dimension. For example, scale=2
+    leads to a layer's pixel being 2x2 pixels when in the group.
+    """
+
+    def __init__(self, *, max_size=None, scale=1, x=0, y=0):
+        """
+        :param Optional(int) max_size: *DEPRECATED* This has been removed in CircuitPython 7 and
+            will be removed in a future version of ``Adafruit_Blinka_Displayio``
+        :param int scale: Scale of layer pixels in one dimension.
+        :param int x: Initial x position within the parent.
+        :param int y: Initial y position within the parent.

         """
         """

-        if not isinstance(max_size, int) or max_size < 1:
-            raise ValueError("Max Size must be >= 1")
-        self._max_size = max_size
+
+        if max_size is not None:
+            print(
+                "The max_size parameter displayio.Group() has been deprecated. "
+                "Please remove max_size from your code."
+            )
+

         if not isinstance(scale, int) or scale < 1:
             raise ValueError("Scale must be >= 1")
         if not isinstance(scale, int) or scale < 1:
             raise ValueError("Scale must be >= 1")

-        self._scale = scale
-        self._x = x
-        self._y = y
-        self._hidden = False
+        self._scale = 1  # Use the setter below to actually set the scale
+        self._group_x = x
+        self._group_y = y
+        self._hidden_group = False

         self._layers = []
         self._supported_types = (TileGrid, Group)
         self._layers = []
         self._supported_types = (TileGrid, Group)

-        self._absolute_transform = None

         self.in_group = False
         self._absolute_transform = Transform(0, 0, 1, 1, 1, False, False, False)
         self.in_group = False
         self._absolute_transform = Transform(0, 0, 1, 1, 1, False, False, False)

+        self._set_scale(scale)  # Set the scale via the setter

 
     def update_transform(self, parent_transform):
         """Update the parent transform and child transforms"""
         self.in_group = parent_transform is not None
         if self.in_group:
 
     def update_transform(self, parent_transform):
         """Update the parent transform and child transforms"""
         self.in_group = parent_transform is not None
         if self.in_group:

-            x = self._x
-            y = self._y
+            x = self._group_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
             if parent_transform.transpose_xy:
                 x, y = y, x
             self._absolute_transform.x = parent_transform.x + parent_transform.dx * x


@@ -111,8 +105,6 @@ class Group:
             raise ValueError("Invalid Group Member")
         if layer.in_group:
             raise ValueError("Layer already in a group.")
             raise ValueError("Invalid Group Member")
         if layer.in_group:
             raise ValueError("Layer already in a group.")

-        if len(self._layers) == self._max_size:
-            raise RuntimeError("Group full")

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


@@ -152,7 +144,7 @@ class Group:
         del self._layers[index]
 
     def _fill_area(self, buffer):
         del self._layers[index]
 
     def _fill_area(self, buffer):

-        if self._hidden:
+        if self._hidden_group:

             return
 
         for layer in self._layers:
             return
 
         for layer in self._layers:


@@ -164,13 +156,13 @@ class Group:
         """True when the Group and all of it’s layers are not visible. When False, the
         Group’s layers are visible if they haven’t been hidden.
         """
         """True when the Group and all of it’s layers are not visible. When False, the
         Group’s layers are visible if they haven’t been hidden.
         """

-        return self._hidden
+        return self._hidden_group

 
     @hidden.setter
     def hidden(self, value):
         if not isinstance(value, (bool, int)):
             raise ValueError("Expecting a boolean or integer value")
 
     @hidden.setter
     def hidden(self, value):
         if not isinstance(value, (bool, int)):
             raise ValueError("Expecting a boolean or integer value")

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

 
     @property
     def scale(self):
 
     @property
     def scale(self):


@@ -181,6 +173,11 @@ class Group:
 
     @scale.setter
     def scale(self, value):
 
     @scale.setter
     def scale(self, value):

+        self._set_scale(value)
+
+    def _set_scale(self, value):
+        # This is method allows the scale to be set by this class even when
+        # the scale property is over-ridden by a subclass.

         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:


@@ -199,37 +196,37 @@ class Group:
     @property
     def x(self):
         """X position of the Group in the parent."""
     @property
     def x(self):
         """X position of the Group in the parent."""

-        return self._x
+        return self._group_x

 
     @x.setter
     def x(self, value):
         if not isinstance(value, int):
             raise ValueError("x must be an integer")
 
     @x.setter
     def x(self, value):
         if not isinstance(value, int):
             raise ValueError("x must be an integer")

-        if self._x != value:
+        if self._group_x != value:

             if self._absolute_transform.transpose_xy:
                 dy_value = self._absolute_transform.dy / self._scale
             if self._absolute_transform.transpose_xy:
                 dy_value = self._absolute_transform.dy / self._scale

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

             else:
                 dx_value = self._absolute_transform.dx / self._scale
             else:
                 dx_value = self._absolute_transform.dx / self._scale

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

             self._update_child_transforms()
 
     @property
     def y(self):
         """Y position of the Group in the parent."""
             self._update_child_transforms()
 
     @property
     def y(self):
         """Y position of the Group in the parent."""

-        return self._y
+        return self._group_y

 
     @y.setter
     def y(self, value):
         if not isinstance(value, int):
             raise ValueError("y must be an integer")
 
     @y.setter
     def y(self, value):
         if not isinstance(value, int):
             raise ValueError("y must be an integer")

-        if self._y != value:
+        if self._group_y != value:

             if self._absolute_transform.transpose_xy:
                 dx_value = self._absolute_transform.dx / self._scale
             if self._absolute_transform.transpose_xy:
                 dx_value = self._absolute_transform.dx / self._scale

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

             else:
                 dy_value = self._absolute_transform.dy / self._scale
             else:
                 dy_value = self._absolute_transform.dy / self._scale

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

             self._update_child_transforms()
             self._update_child_transforms()