Merge pull request #745 from dastels/pypaint

Add a second brush size

Author: ladyada

CircuitPython_PyPaint/code.py

@@ -72,17 +72,17 @@ def __init__(self, splash, cursor_bmp):
         self._y_offset = cursor_bmp.height // 2
 
 
-
     def poll(self):
-        """Check for input. Returns contact (a bool) and it's location ((x,y) or None)"""
+        """Check for input. Returns contact (a bool), False (no button B),
+        and it's location ((x,y) or None)"""
 
         p = self._touchscreen.touch_point
         if p is not None:
             self._cursor_grp.x = p[0] - self._x_offset
             self._cursor_grp.y = p[1] - self._y_offset
-            return True, p
+            return True, False, p
         else:
-            return False, None
+            return False, False, None
 
     def poke(self, location=None):
         """Force a bitmap refresh."""
@@ -92,6 +92,17 @@ def poke(self, location=None):
             self._cursor_grp.y = location[1] - self._y_offset
         self._display_grp.append(self._cursor_grp)
 
+    def set_cursor_bitmap(self, bmp):
+        """Update the cursor bitmap.
+
+        :param bmp: the new cursor bitmap
+        """
+        self._cursor_grp.remove(self._cur_sprite)
+        self._cur_sprite = displayio.TileGrid(bmp,
+                                              pixel_shader=self._cur_palette)
+        self._cursor_grp.append(self._cur_sprite)
+        self.poke()
+
 ################################################################################
 
 class CursorPoller(object):
@@ -109,14 +120,15 @@ def __init__(self, splash, cursor_bmp):
         self._logger = logging.getLogger('Paint')
 
     def poll(self):
-        """Check for input. Returns press (a bool) and it's location ((x,y) or None)"""
+        """Check for input. Returns press of A (a bool), B,
+        and the cursor location ((x,y) or None)"""
         location = None
         self._cursor.update()
-        button = self._cursor.held
-        if button:
+        a_button = self._cursor.held
+        if a_button:
             location = (self._mouse_cursor.x + self._x_offset,
                         self._mouse_cursor.y + self._y_offset)
-        return button, location
+        return a_button, location
 
     #pylint:disable=unused-argument
     def poke(self, x=None, y=None):
@@ -125,6 +137,14 @@ def poke(self, x=None, y=None):
         self._mouse_cursor.show()
     #pylint:enable=unused-argument
 
+    def set_cursor_bitmap(self, bmp):
+        """Update the cursor bitmap.
+
+        :param bmp: the new cursor bitmap
+        """
+        self._mouse_cursor.cursor_bitmap = bmp
+        self.poke()
+
 ################################################################################
 
 class Paint(object):
@@ -166,61 +186,109 @@ def __init__(self, display=board.DISPLAY):
                                              x=0, y=0)
         self._splash.append(self._fg_sprite)
 
-        self._color_palette = self._make_color_palette()
-        self._splash.append(self._color_palette)
+        self._number_of_palette_options = len(Color.colors) + 2
+        self._swatch_height = self._h // self._number_of_palette_options
+        self._swatch_width = self._w // 10
+        self._logger.debug('Height: %d', self._h)
+        self._logger.debug('Swatch height: %d', self._swatch_height)
+
+        self._palette = self._make_palette()
+        self._splash.append(self._palette)
 
         self._display.show(self._splash)
         self._display.refresh_soon()
         gc.collect()
         self._display.wait_for_frame()
 
+        self._brush = 0
+        self._cursor_bitmaps = [self._cursor_bitmap_1(), self._cursor_bitmap_3()]
         if hasattr(board, 'TOUCH_XL'):
-            self._poller = TouchscreenPoller(self._splash, self._cursor_bitmap())
+            self._poller = TouchscreenPoller(self._splash, self._cursor_bitmaps[0])
         elif hasattr(board, 'BUTTON_CLOCK'):
-            self._poller = CursorPoller(self._splash, self._cursor_bitmap())
+            self._poller = CursorPoller(self._splash, self._cursor_bitmaps[0])
         else:
-            raise AttributeError('PYOA requires a touchscreen or cursor.')
+            raise AttributeError('PyPaint requires a touchscreen or cursor.')
 
-        self._pressed = False
-        self._last_pressed = False
+        self._a_pressed = False
+        self._last_a_pressed = False
         self._location = None
         self._last_location = None
 
         self._pencolor = 7
 
-    def _make_color_palette(self):
+    def _make_palette(self):
         self._palette_bitmap = displayio.Bitmap(self._w // 10, self._h, 5)
         self._palette_palette = displayio.Palette(len(Color.colors))
-        swatch_height = self._h // len(Color.colors)
         for i, c in enumerate(Color.colors):
             self._palette_palette[i] = c
-            for y in range(swatch_height):
-                for x in range(self._w // 10):
-                    self._palette_bitmap[x, swatch_height * i + y] = i
-                self._palette_bitmap[self._w // 10 - 1, swatch_height * i + y] = 7
+            for y in range(self._swatch_height):
+                for x in range(self._swatch_width):
+                    self._palette_bitmap[x, self._swatch_height * i + y] = i
 
+        swatch_x_offset = (self._swatch_width - 9) // 2
+        swatch_y_offset = (self._swatch_height - 9) // 2
+        swatch_y = self._swatch_height * len(Color.colors) + swatch_y_offset
+        for i in range(9):
+            self._palette_bitmap[swatch_x_offset + 4, swatch_y + i] = 1
+            self._palette_bitmap[swatch_x_offset + i, swatch_y + 4] = 1
+            self._palette_bitmap[swatch_x_offset + 4, swatch_y + 4] = 0
+
+        swatch_y += self._swatch_height
+        for i in range(9):
+            self._palette_bitmap[swatch_x_offset + 3, swatch_y + i] = 1
+            self._palette_bitmap[swatch_x_offset + 4, swatch_y + i] = 1
+            self._palette_bitmap[swatch_x_offset + 5, swatch_y + i] = 1
+            self._palette_bitmap[swatch_x_offset + i, swatch_y + 3] = 1
+            self._palette_bitmap[swatch_x_offset + i, swatch_y + 4] = 1
+            self._palette_bitmap[swatch_x_offset + i, swatch_y + 5] = 1
+        for i in range(swatch_x_offset + 3, swatch_x_offset + 6):
+            for j in range(swatch_y + 3, swatch_y + 6):
+                self._palette_bitmap[i, j] = 0
+
+        for i in range(self._h):
+            self._palette_bitmap[self._swatch_width - 1, i] = 7
 
         return displayio.TileGrid(self._palette_bitmap,
                                   pixel_shader=self._palette_palette,
                                   x=0, y=0)
 
-    def _cursor_bitmap(self):
+    def _cursor_bitmap_1(self):
         bmp = displayio.Bitmap(9, 9, 3)
         for i in range(9):
             bmp[4, i] = 1
             bmp[i, 4] = 1
         bmp[4, 4] = 0
         return bmp
 
+    def _cursor_bitmap_3(self):
+        bmp = displayio.Bitmap(9, 9, 3)
+        for i in range(9):
+            bmp[3, i] = 1
+            bmp[4, i] = 1
+            bmp[5, i] = 1
+            bmp[i, 3] = 1
+            bmp[i, 4] = 1
+            bmp[i, 5] = 1
+        for i in range(3, 6):
+            for j in range(3, 6):
+                bmp[i, j] = 0
+        return bmp
+
     def _plot(self, x, y, c):
-        try:
-            self._fg_bitmap[int(x), int(y)] = c
-        except IndexError:
-            pass
+        if self._brush == 0:
+            r = [0]
+        else:
+            r = [-1, 0, 1]
+        for i in r:
+            for j in r:
+                try:
+                    self._fg_bitmap[int(x + i), int(y + j)] = c
+                except IndexError:
+                    pass
 
     #pylint:disable=too-many-branches,too-many-statements
 
-    def _goto(self, start, end):
+    def _draw_line(self, start, end):
         """Draw a line from the previous position to the current one.
 
         :param start: a tuple of (x, y) coordinatess to fram from
@@ -280,36 +348,41 @@ def _goto(self, start, end):
 
     #pylint:enable=too-many-branches,too-many-statements
 
-
-    def _pick_color(self, location):
-        swatch_height = self._h // len(Color.colors)
-        picked = location[1] // swatch_height
-        self._pencolor = picked
+    def _handle_palette_selection(self, location):
+        selected = location[1] // self._swatch_height
+        if selected >= self._number_of_palette_options:
+            return
+        self._logger.debug('Palette selection: %d', selected)
+        if selected < len(Color.colors):
+            self._pencolor = selected
+        else:
+            self._brush = selected - len(Color.colors)
+            self._poller.set_cursor_bitmap(self._cursor_bitmaps[self._brush])
 
     def _handle_motion(self, start, end):
         self._logger.debug('Moved: (%d, %d) -> (%d, %d)', start[0], start[1], end[0], end[1])
-        self._goto(start, end)
+        self._draw_line(start, end)
 
-    def _handle_press(self, location):
-        self._logger.debug('Pressed!')
+    def _handle_a_press(self, location):
+        self._logger.debug('A Pressed!')
         if location[0] < self._w // 10:   # in color picker
-            self._pick_color(location)
+            self._handle_palette_selection(location)
         else:
             self._plot(location[0], location[1], self._pencolor)
             self._poller.poke()
 
     #pylint:disable=unused-argument
-    def _handle_release(self, location):
-        self._logger.debug('Released!')
+    def _handle_a_release(self, location):
+        self._logger.debug('A Released!')
     #pylint:enable=unused-argument
 
     @property
-    def _was_just_pressed(self):
-        return self._pressed and not self._last_pressed
+    def _was_a_just_pressed(self):
+        return self._a_pressed and not self._last_a_pressed
 
     @property
-    def _was_just_released(self):
-        return not self._pressed and self._last_pressed
+    def _was_a_just_released(self):
+        return not self._a_pressed and self._last_a_pressed
 
     @property
     def _did_move(self):
@@ -321,19 +394,19 @@ def _did_move(self):
             return False
 
     def _update(self):
-        self._last_pressed, self._last_location = self._pressed, self._location
-        self._pressed, self._location = self._poller.poll()
+        self._last_a_pressed, self._last_location = self._a_pressed, self._location
+        self._a_pressed, self._location = self._poller.poll()
 
 
     def run(self):
         """Run the painting program."""
         while True:
             self._update()
-            if self._was_just_pressed:
-                self._handle_press(self._location)
-            elif self._was_just_released:
-                self._handle_release(self._location)
-            if self._did_move and self._pressed:
+            if self._was_a_just_pressed:
+                self._handle_a_press(self._location)
+            elif self._was_a_just_released:
+                self._handle_a_release(self._location)
+            if self._did_move and self._a_pressed:
                 self._handle_motion(self._last_location, self._location)
             time.sleep(0.1)