displayio/_displaycore.py

   1 # SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
   2 # SPDX-FileCopyrightText: 2021 James Carr
   3 #
   4 # SPDX-License-Identifier: MIT
   5
   6 """
   7 `displayio._displaycore`
   8 ================================================================================
   9
  10 Super class of the display classes
  11
  12 **Software and Dependencies:**
  13
  14 * Adafruit Blinka:
  15   https://github.com/adafruit/Adafruit_Blinka/releases
  16
  17 * Author(s): James Carr, Melissa LeBlanc-Williams
  18
  19 """
  20
  21 __version__ = "0.0.0+auto.0"
  22 __repo__ = "https://github.com/adafruit/Adafruit_Blinka_Displayio.git"
  23
  24
  25 from typing import Union
  26 import circuitpython_typing
  27 from paralleldisplay import ParallelBus
  28 from ._fourwire import FourWire
  29 from ._group import Group
  30 from ._i2cdisplay import I2CDisplay
  31 from ._structs import ColorspaceStruct, TransformStruct, RectangleStruct
  32 from ._area import Area
  33
  34 displays = []
  35
  36
  37 class _DisplayCore:
  38     # pylint: disable=too-many-arguments, too-many-instance-attributes
  39
  40     def __init__(
  41         self,
  42         bus,
  43         width: int,
  44         height: int,
  45         ram_width: int,
  46         ram_height: int,
  47         colstart: int,
  48         rowstart: int,
  49         rotation: int,
  50         color_depth: int,
  51         grayscale: bool,
  52         pixels_in_byte_share_row: bool,
  53         bytes_per_cell: int,
  54         reverse_pixels_in_byte: bool,
  55         reverse_bytes_in_word: bool,
  56     ):
  57         self._colorspace = ColorspaceStruct(
  58             depth=color_depth,
  59             grayscale=grayscale,
  60             grayscale_bit=8 - color_depth,
  61             pixels_in_byte_share_row=pixels_in_byte_share_row,
  62             bytes_per_cell=bytes_per_cell,
  63             reverse_pixels_in_byte=reverse_pixels_in_byte,
  64             reverse_bytes_in_word=reverse_bytes_in_word,
  65             dither=False,
  66         )
  67         self._current_group = None
  68         self._colstart = colstart
  69         self._rowstart = rowstart
  70         self._last_refresh = 0
  71         self._refresh_in_progress = False
  72         self._full_refresh = False
  73
  74         if bus:
  75             if isinstance(bus, (FourWire, I2CDisplay, ParallelBus)):
  76                 self._bus_reset = bus.reset
  77                 self._begin_transaction = bus._begin_transaction
  78                 self._send = bus._send
  79                 self._end_transaction = bus._end_transaction
  80             else:
  81                 raise ValueError("Unsupported display bus type")
  82
  83         self._bus = bus
  84         self._area = Area(0, 0, width, height)
  85
  86         self._width = width
  87         self._height = height
  88         self._ram_width = ram_width
  89         self._ram_height = ram_height
  90         self._rotation = rotation
  91         self._transform = TransformStruct()
  92
  93     def set_rotation(self, rotation: int) -> None:
  94         """
  95         Sets the rotation of the display as an int in degrees.
  96         """
  97         # pylint: disable=protected-access, too-many-branches
  98         transposed = self._rotation in (90, 270)
  99         will_be_transposed = rotation in (90, 270)
 100         if transposed != will_be_transposed:
 101             self._width, self._height = self._height, self._width
 102
 103         height = self._height
 104         width = self._width
 105
 106         rotation %= 360
 107         self._rotation = rotation
 108         self._transform.x = 0
 109         self._transform.y = 0
 110         self._transform.scale = 1
 111         self._transform.mirror_x = False
 112         self._transform.mirror_y = False
 113         self._transform.transpose_xy = False
 114
 115         if rotation in (0, 180):
 116             if rotation == 180:
 117                 self._transform.mirror_x = True
 118                 self._transform.mirror_y = True
 119         else:
 120             self._transform.transpose_xy = True
 121             if rotation == 270:
 122                 self._transform.mirror_y = True
 123             else:
 124                 self._transform.mirror_x = True
 125
 126         self._area.x1 = 0
 127         self._area.y1 = 0
 128         self._area.next = None
 129
 130         self._transform.dx = 1
 131         self._transform.dy = 1
 132         if self._transform.transpose_xy:
 133             self._area.x2 = height
 134             self._area.y2 = width
 135             if self._transform.mirror_x:
 136                 self._transform.x = height
 137                 self._transform.dx = -1
 138             if self._transform.mirror_y:
 139                 self._transform.y = width
 140                 self._transform.dy = -1
 141         else:
 142             self._area.x2 = width
 143             self._area.y2 = height
 144             if self._transform.mirror_x:
 145                 self._transform.x = width
 146                 self._transform.dx = -1
 147             if self._transform.mirror_y:
 148                 self._transform.y = height
 149                 self._transform.dy = -1
 150
 151         if self._current_group is not None:
 152             self._current_group._update_transform(self._transform)
 153
 154     def show(self, root_group: Group) -> bool:
 155         # pylint: disable=protected-access
 156
 157         """
 158         Switches to displaying the given group of layers. When group is `None`, the
 159         default CircuitPython terminal will be shown.
 160
 161         :param Optional[displayio.Group] root_group: The group to show.
 162         """
 163
 164         """
 165         # TODO: Implement Supervisor
 166         if root_group is None:
 167             circuitpython_splash = _Supervisor().circuitpython_splash
 168             if not circuitpython_splash._in_group:
 169                 root_group = circuitpython_splash
 170             elif self._current_group == circuitpython_splash:
 171                 return True
 172         """
 173
 174         if root_group == self._current_group:
 175             return True
 176
 177         if root_group is not None and root_group._in_group:
 178             return False
 179
 180         if self._current_group is not None:
 181             self._current_group._in_group = False
 182
 183         if root_group is not None:
 184             root_group._update_transform(self._transform)
 185             root_group._in_group = True
 186
 187         self._current_group = root_group
 188         self._full_refresh = True
 189
 190         print(f"end of show: {root_group}")
 191         return True
 192
 193     def set_root_group(self, root_group: Group) -> bool:
 194         # pylint: disable=protected-access
 195
 196         """
 197         Switches to displaying the given group of layers. When group is `None`, the
 198         default CircuitPython terminal will be shown.
 199
 200         :param Optional[displayio.Group] root_group: The group to show.
 201         """
 202
 203         """
 204         # TODO: Implement Supervisor
 205         if root_group is None:
 206             circuitpython_splash = _Supervisor().circuitpython_splash
 207             if not circuitpython_splash._in_group:
 208                 root_group = circuitpython_splash
 209             elif self._current_group == circuitpython_splash:
 210                 return True
 211         """
 212
 213         if root_group == self._current_group:
 214             return True
 215
 216         if root_group is not None and root_group._in_group:
 217             return False
 218
 219         if self._current_group is not None:
 220             self._current_group._in_group = False
 221
 222         if root_group is not None:
 223             root_group._update_transform(self._transform)
 224             root_group._in_group = True
 225
 226         self._current_group = root_group
 227         self._full_refresh = True
 228
 229         return True
 230
 231     def start_refresh(self) -> bool:
 232         # pylint: disable=protected-access
 233         """Mark the display core as currently being refreshed"""
 234
 235         if self._refresh_in_progress:
 236             return False
 237
 238         self._refresh_in_progress = True
 239         # self._last_refresh = _Supervisor()._ticks_ms64()
 240         return True
 241
 242     def finish_refresh(self) -> None:
 243         # pylint: disable=protected-access
 244         """Unmark the display core as currently being refreshed"""
 245
 246         if self._current_group is not None:
 247             self._current_group._finish_refresh()
 248
 249         self._full_refresh = False
 250         self._refresh_in_progress = False
 251         # self._last_refresh = _Supervisor()._ticks_ms64()
 252
 253     def get_refresh_areas(self) -> list:
 254         """Get a list of areas to be refreshed"""
 255         subrectangles = []
 256         if self._current_group is not None:
 257             # Eventually calculate dirty rectangles here
 258             subrectangles.append(RectangleStruct(0, 0, self._width, self._height))
 259         return subrectangles
 260
 261     def release(self) -> None:
 262         """Release the display from the current group"""
 263         # pylint: disable=protected-access
 264
 265         if self._current_group is not None:
 266             self._current_group._in_group = False
 267
 268     def fill_area(
 269         self,
 270         area: Area,
 271         mask: circuitpython_typing.WriteableBuffer,
 272         buffer: circuitpython_typing.WriteableBuffer,
 273     ) -> bool:
 274         # pylint: disable=protected-access
 275         """Call the current group's fill area function"""
 276
 277         return self._current_group._fill_area(self._colorspace, area, mask, buffer)
 278
 279     def clip_area(self, area: Area, clipped: Area) -> bool:
 280         """Shrink the area to the region shared by the two areas"""
 281         # pylint: disable=protected-access
 282
 283         overlaps = self._area._compute_overlap(area, clipped)
 284         if not overlaps:
 285             return False
 286
 287         # Expand the area if we have multiple pixels per byte and we need to byte align the bounds
 288         if self._colorspace.depth < 8:
 289             pixels_per_byte = (
 290                 8 // self._colorspace.depth * self._colorspace.bytes_per_cell
 291             )
 292             if self._colorspace.pixels_in_byte_share_row:
 293                 if clipped.x1 % pixels_per_byte != 0:
 294                     clipped.x1 -= clipped.x1 % pixels_per_byte
 295                 if clipped.x2 % pixels_per_byte != 0:
 296                     clipped.x2 += pixels_per_byte - clipped.x2 % pixels_per_byte
 297             else:
 298                 if clipped.y1 % pixels_per_byte != 0:
 299                     clipped.y1 -= clipped.y1 % pixels_per_byte
 300                 if clipped.y2 % pixels_per_byte != 0:
 301                     clipped.y2 += pixels_per_byte - clipped.y2 % pixels_per_byte
 302
 303         return True
 304
 305     def send(
 306         self,
 307         data_type: int,
 308         chip_select: int,
 309         data: circuitpython_typing.ReadableBuffer,
 310     ) -> None:
 311         """
 312         Send the data to the current bus
 313         """
 314         self._send(data_type, chip_select, data)
 315
 316     def begin_transaction(self) -> None:
 317         """
 318         Begin Bus Transaction
 319         """
 320         self._begin_transaction()
 321
 322     def end_transaction(self) -> None:
 323         """
 324         End Bus Transaction
 325         """
 326         self._end_transaction()
 327
 328     def get_width(self) -> int:
 329         """
 330         Gets the width of the display in pixels.
 331         """
 332         return self._width
 333
 334     def get_height(self) -> int:
 335         """
 336         Gets the height of the display in pixels.
 337         """
 338         return self._height
 339
 340     def get_rotation(self) -> int:
 341         """
 342         Gets the rotation of the display as an int in degrees.
 343         """
 344         return self._rotation
 345
 346     def get_bus(self) -> Union[FourWire, ParallelBus, I2CDisplay]:
 347         """
 348         The bus being used by the display. [readonly]
 349         """
 350         return self._bus