split text drawing interface into multiple methods.

bdf.py

 
             # center vertically, in case of
             # multiple stacked panels
-            # TODO hard-coded offsets assume 32x32 panels
-            if self.gui.height > 32:
-                offset += 16
+            if self.gui.height > self.gui.panelH:
+                offset += int(self.gui.panelH / 2)
 
             font = Font(os.path.join(fontDir, filename))
             data = (font, offset, {}, spacing)
             self.fonts[filename[:-4]] = data
 
+    # internal
     def getGlyph(self, c, font):
         if not isinstance(font, str):
             # fall-back to first available font
 
         return (cache[c], offset, spacing)
 
+    # internal
     def drawGlyph(self, g, xOff, yOff, spacing):
-        if xOff >= self.gui.width:
-            return
-
-        for x in range(0, g.width):
+        for x in range(0, g.width + spacing):
             for y in range(0, g.height):
-                xTarget = xOff + x
-                if (xTarget < 0) or (xTarget >= self.gui.width):
-                    continue
-
-                p = g.getpixel((x, y))
-                self.gui.set_pixel(xTarget, yOff + y, p)
+                pos = (xOff + x, yOff + y)
+                if x >= g.width:
+                    self.image.putpixel(pos, self.bg)
+                else:
+                    p = g.getpixel((x, y))
+                    self.image.putpixel(pos, p)
+
+    # text drawing API
+    def setText(self, s, f):
+        # calculate length of whole text
+        w = 0
+        h = 0
+        for c in s:
+            g, y, spacing = self.getGlyph(c, f)
+            w += g.width + spacing
+            if h < g.height:
+                h = g.height
 
-        for x in range(0, spacing):
-            for y in range(0, g.height):
-                self.gui.set_pixel(xOff + x + g.width, yOff + y, self.bg)
+        # create new blank image buffer
+        self.image = Image.new('RGBA', (w, h))
 
-    def text(self, s, f, offset = 0, earlyAbort = True, yOff = 0):
+        # render glyphs into image
         w = 0
         for c in s:
-            xOff = -offset + w
-            if earlyAbort:
-                if xOff >= self.gui.width:
-                    break
-
             g, y, spacing = self.getGlyph(c, f)
+            self.drawGlyph(g, w, 0, spacing)
             w += g.width + spacing
+            self.yOffset = y
+
+    # text drawing API
+    def getDimensions(self):
+        return (self.image.width, self.image.height)
+
+    # text drawing API
+    def draw(self, xOff = 0, yOff = 0):
+        for x in range(0, self.image.width):
+            xTarget = -xOff + x
+            if xTarget < 0:
+                continue
+            if xTarget >= self.gui.width:
+                break
+
+            for y in range(0, self.image.height):
+                yTarget = yOff + y + self.yOffset
+                if yTarget < 0:
+                    continue
+                if yTarget >= self.gui.height:
+                    break
 
-            if xOff >= -16: # some wiggle room so chars dont disappear
-                self.drawGlyph(g, xOff, y + yOff, spacing)
-        return w
+                p = self.image.getpixel((x, y))
+                self.gui.set_pixel(xTarget, yTarget, p)

pico.py

         self.bg = bg
         self.color = c
 
-    def text(self, s, f, offset = 0, earlyAbort = True, yOff = 0, compat = True):
-        if not earlyAbort:
-            self.gui.matrix.display.set_font(f)
-            return self.gui.matrix.display.measure_text(s, scale=1)
-
+    # text drawing API
+    def setText(self, s, f):
+        self.text = s
+        self.font = f
+
+    # text drawing API
+    def getDimensions(self):
+        self.gui.matrix.display.set_font(self.font)
+        w = self.gui.matrix.display.measure_text(self.text, scale=1)
+        return (w, 42) # TODO wrong height
+
+    # text drawing API
+    def draw(self, xOff = 0, yOff = 0, compat = True):
         color = self.fg
         if isinstance(self.gui, MapperReduceBrightness):
             color = self.gui.adjust(color)
         pen = self.gui.matrix.display.create_pen(color[0], color[1], color[2])
         self.gui.matrix.display.set_pen(pen)
 
-        self.gui.matrix.display.set_font(f)
+        self.gui.matrix.display.set_font(self.font)
 
         if not compat:
             # absolute positioning
-            x = offset
+            x = xOff
             y = yOff
         else:
             # centered, like BDF DrawText implementation
             fontOff = 0
-            if f == "bitmap6":
+            if self.font == "bitmap6":
                 fontOff = 3
-            elif f == "bitmap8":
+            elif self.font == "bitmap8":
                 fontOff = 4
-            elif f == "bitmap14_outline":
+            elif self.font == "bitmap14_outline":
                 fontOff = 7
 
-            x = -offset
+            x = -xOff
             y = int(self.gui.height / 2 - fontOff + yOff)
 
-        self.gui.matrix.display.text(s, x, y, scale=1)
+        self.gui.matrix.display.text(self.text, x, y, scale=1)
 
 class PicoBatt:
     def __init__(self, g, ti = 5.0, tt = 5.0):
         c = batt_to_color(batt)
 
         self.text.fg = (255, 255, 255)
-        self.text.text(                  "Batt:", "bitmap8", 0, True, 8 * 0, False)
+        self.text.setText(                  "Batt:", "bitmap8")
+        self.text.draw(0, 8 * 0, False)
 
         self.text.fg = c
-        self.text.text("{:.2f}%".format(batt[0]), "bitmap8", 0, True, 8 * 1, False)
-        self.text.text("{:.2f}V".format(batt[1]), "bitmap8", 0, True, 8 * 2, False)
-        self.text.text("{:.2f}V".format(batt[2]), "bitmap8", 0, True, 8 * 3, False)
+        self.text.setText("{:.2f}%".format(batt[0]), "bitmap8")
+        self.text.draw(0, 8 * 1, False)
+        self.text.setText("{:.2f}V".format(batt[1]), "bitmap8")
+        self.text.draw(0, 8 * 2, False)
+        self.text.setText("{:.2f}V".format(batt[2]), "bitmap8")
+        self.text.draw(0, 8 * 3, False)
 
     def drawImage(self, refresh = False):
         x_off = const(1)
         fill_w = int(batt[0] / 100.0 * (w - nub_w))
 
         s = "{:.0f}%".format(batt[0])
-        s_w = self.text.text(s, "bitmap14_outline", 0, False)
+        self.text.setText(s, "bitmap14_outline")
+        s_w = self.text.getDimensions()[0]
         self.text.fg = (255, 255, 255)
-        self.text.text(s, "bitmap14_outline", int((self.gui.width - s_w) / 2), True, 1, False)
+        self.text.draw(int((self.gui.width - s_w) / 2), 1, False)
 
         for x in range(0, w - nub_w):
             for y in range(0, h):
 
 if __name__ == "__main__":
     import time
+    import util
 
     t = PicoMatrix(32, 32)
     s = PicoText(t)
             b.draw(True)
             time.sleep(1.0)
         elif i == 4:
-            s.text("Abgj6", "bitmap6", 0, True, 0, False)
-            s.text("Abdgj8", "bitmap8", 0, True, 6 + 2, False)
-            s.text("Ag14", "bitmap14_outline", 0, True, 6 + 2 + 8 + 1, False)
+            s.setText("Abgj6", "bitmap6")
+            s.draw(0, 0, False)
+            s.setText("Abdgj8", "bitmap8")
+            s.draw(0, 6 + 2, False)
+            s.setText("Ag14", "bitmap14_outline")
+            s.draw(0, 6 + 2 + 8 + 1, False)
         else:
-            s.text("Drinks:", "bitmap8", 0)
+            s.setText("Drinks:", "bitmap8")
+            s.draw()
 
     util.loop(t, helper)

qr.py

         if self.heading != None:
             DrawText = util.getTextDrawer()
             self.text = DrawText(self.gui, self.c1, self.c2)
+            self.text.setText(self.heading, self.font)
             self.yOff = self.gui.height - self.image.height
         else:
             self.yOff = int((self.gui.height - self.image.height) / 2)
             elif self.font == "tom-thumb":
                 off = -11
 
-            self.text.text(self.heading, self.font, 0, True, off)
+            self.text.draw(0, off)
 
         for x in range(0, self.image.width):
             for y in range(0, self.image.height):

scroll.py

     def setText(self, t, f):
         self.text = t
         self.font = f
-        self.width = self.drawer.text(self.text, self.font, 0, False)
+        self.drawer.setText(t, f)
+        self.width, height = self.drawer.getDimensions()
 
     def restart(self):
         self.offset = -self.gui.width
                 self.offset = -self.gui.width
                 self.count += 1
 
-        self.drawer.text(self.text, self.font, self.offset, True)
+        self.drawer.draw(self.offset)
 
 if __name__ == "__main__":
     import util

tetris.py

 
         DrawText = util.getTextDrawer()
         self.text = []
-        self.text.append(DrawText(self.gui, self.colors[1]))
-        self.text.append(DrawText(self.gui, self.colors[0]))
-        self.text.append(DrawText(self.gui, self.colors[4]))
-        self.text.append(DrawText(self.gui, self.colors[5]))
+        self.text.append(DrawText(self.gui, self.colors[1])) # Green, "Score"
+        self.text.append(DrawText(self.gui, self.colors[0])) # Pink, Score Number
+        self.text.append(DrawText(self.gui, self.colors[4])) # Yellow, "Paused"
+        self.text.append(DrawText(self.gui, self.colors[5])) # Blue, "next"
+        self.text.append(DrawText(self.gui, self.colors[0])) # Pink, "Tetris"
+        self.text.append(DrawText(self.gui, self.colors[5])) # Blue, "up"
+        self.text[0].setText("Score:", "tom-thumb")
+        self.text[1].setText("0", "tom-thumb")
+        self.text[2].setText("Paused", "tom-thumb")
+        self.text[3].setText("next", "tom-thumb")
+        self.text[4].setText("Tetris", "tom-thumb")
+        self.text[5].setText("up", "tom-thumb")
 
         # all [y][x] sub-lists must be the same length
         self.pieces = [
         self.last = time.time()
         self.button = None
         self.score = 0
+        self.text[1].setText(str(self.score), "tom-thumb")
         self.done = False
         self.data = [[self.bg for y in range(self.height)] for x in range(self.width)]
         self.piece = None
 
             if had_data and line_full:
                 self.score += 1
+                self.text[1].setText(str(self.score), "tom-thumb")
 
                 # move stuff above into this line
                 for y2 in reversed(range(1, y + 1)):
     def draw_stats(self, off):
         x_off, y_off = off
 
-        self.text[0].text("Score:", "tom-thumb", -x_off - 2, True, y_off - 11)
-        self.text[1].text(str(self.score), "tom-thumb", -x_off - 2, True, y_off - 5)
+        self.text[0].draw(-x_off - 2, y_off - 11)
+        self.text[1].draw(-x_off - 2, y_off - 5)
 
         if self.pause:
-            self.text[2].text("Paused", "tom-thumb", -x_off - 2, True, -y_off + 11)
+            self.text[2].draw(-x_off - 2, -y_off + 11)
 
     def draw(self):
         if self.input != None:
                 self.endText.restart()
 
         # static text
-        self.text[1].text("Tetris", "tom-thumb", -2, True, -11)
-        self.text[3].text("next", "tom-thumb", -14, True, 5)
-        self.text[3].text("up", "tom-thumb", -14, True, 12)
+        self.text[4].draw(-2, -11)
+        self.text[3].draw(-14, 5)
+        self.text[5].draw(-14, 12)
 
         # draw play area and border
         for x in range(-1, self.width + 1):