more fonts. more instructions. added images and colors from cccamp23 style guide. text rendering now possible with colors. custom font spacing. images automatically scaled and cropped. fixed qr text and colors. allow exiting test gui with q or esc. better target check.

README.md

 
 ## Quick Start
 
-Just run
+Just run:
 
     ./manager.py
 
 
 ## Dependencies
 
-You always need
+You always need:
 
     pip install pil
     pip install bdfparser
     pip install "qrcode[pil]"
 
 The rest depends on the output device chosen.
+For debugging on your host PC you can use the TestGUI interface with pygame:
+
+    pip install pygame
+
+The other currently supported option is using a Raspberry Pi with the [Adafruit RGB Matrix Bonnet](https://shop.pimoroni.com/products/adafruit-rgb-matrix-bonnet-for-raspberry-pi?variant=2257849155594) and a matching [LED Matrix](https://shop.pimoroni.com/products/rgb-led-matrix-panel?variant=35962488650).
+The [tutorial](https://learn.adafruit.com/adafruit-rgb-matrix-bonnet-for-raspberry-pi/driving-matrices) suggests using the [Adafruit Raspberry Pi Installer Script for the RGB matrix](https://github.com/adafruit/Raspberry-Pi-Installer-Scripts/blob/339cccfbdd8b503b53186176ff96bead9a13a2f5/rgb-matrix.sh).
+This will give you the [hzeller/rpi-rgb-led-matrix](https://github.com/hzeller/rpi-rgb-led-matrix) project which includes the Python bindings used in this project.
+
+## Adding your own visualizations
+
+Take a look how others are implemented.
+You can chain the different screens together using `Manager` and also check for conditions, as seen in `CheckHTTP`.
+This should enable you to quickly create something usable.
+
+One goal is to run this project on public events.
+If this is the case, and you want your own message to appear, simply open up a PR or send an email with a patch.
+Because of different versions between host PCs and the Raspbian OS, things may look slightly different, especially regarding stuff like animated GIF viewing.
 
 ## Licensing
 
     think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
     ----------------------------------------------------------------------------
 
-The included font from [farsil/ibmfonts](https://github.com/farsil/ibmfonts) is licensed as `CC-BY-SA-4.0`.
+The included fonts from [farsil/ibmfonts](https://github.com/farsil/ibmfonts) are licensed as `CC-BY-SA-4.0`.
+
+The fonts from [cmvnd/fonts](https://github.com/cmvnd/fonts) are licensed as GPLv3.
+
+The tiny font is from [robey](https://robey.lag.net/2010/01/23/tiny-monospace-font.html) and licensed as CC0.
 
-The included GIFs are from [GifCities](https://gifcities.org/?q=32)
+The included GIFs are from [GifCities](https://gifcities.org/?q=32).

camp_small.py

 # think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
 # ----------------------------------------------------------------------------
 
+camp_pink = (251, 72, 196)
+camp_green = (63, 255, 33)
+
 if __name__ == "__main__":
     from splash import SplashScreen
     from draw import ScrollText
     success = Manager(t)
     success.add(ImageScreen(t, "drinka.gif", 0.2, 2, 20.0))
     success.add(Solid(t, 1.0))
-    success.add(QRScreen(t, url, 30.0, "Order:"))
+    success.add(QRScreen(t, url, 30.0, "Drinks:", "tom-thumb", (255, 255, 255), (0, 0, 0)))
     success.add(Solid(t, 1.0))
 
     fail = Manager(t)
     fail.add(ImageScreen(t, "attention.gif", 0.2, 2, 20.0, (0, 0, 0)))
     fail.add(ScrollText(t, "The UbaBot Cocktail machine is currently closed. Please come back later for more drinks!", "ib8x8u", 2))
-    fail.add(Solid(t, 2.0))
+    fail.add(Solid(t, 1.0))
     fail.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), None, 2.0))
-    fail.add(Solid(t, 2.0))
+    fail.add(Solid(t, 1.0))
 
     d = CheckHTTP(url)
     d.success(success)
     d.fail(fail)
 
-    t.debug_loop(d.draw)
+    m = Manager(t)
+    m.add(ScrollText(t, "#CCCAMP23", "lemon", 1, 75, camp_green))
+    m.add(Solid(t, 1.0))
+    m.add(ImageScreen(t, "Favicon.png", 0, 1, 10.0))
+    m.add(Solid(t, 1.0))
+    m.add(ScrollText(t, "#CCCAMP23", "lemon", 1, 75, camp_pink))
+    m.add(Solid(t, 1.0))
+    m.add(d)
+    m.add(Solid(t, 1.0))
+
+    m.restart()
+    t.debug_loop(m.draw)

draw.py

 #!/usr/bin/env python3
 
+# Uses the Python BDF format bitmap font parser:
+# https://github.com/tomchen/bdfparser
+#
+# And the pillow Python Imaging Library:
+# https://github.com/python-pillow/Pillow
+#
 # ----------------------------------------------------------------------------
 # "THE BEER-WARE LICENSE" (Revision 42):
 # <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
 import time
 
 class DrawText:
-    def __init__(self, g):
+    def __init__(self, g, fg = (255, 255, 255), bg = (0, 0, 0), c = (0, 255, 0)):
         self.gui = g
+        self.fg = fg
+        self.bg = bg
+        self.color = c
 
         scriptDir = os.path.dirname(os.path.realpath(__file__))
         fontDir = os.path.join(scriptDir, "fonts")
             if not filename.lower().endswith(".bdf"):
                 continue
 
-            font = Font(os.path.join(fontDir, filename))
-            #print(f"{filename} global size is "
-            #    f"{font.headers['fbbx']} x {font.headers['fbby']} (pixel), "
-            #    f"it contains {len(font)} glyphs.")
-
-            # TODO hard-coded per-font offsets
+            # TODO hard-coded per-font offsets and spacing adjustment
             offset = 0
+            spacing = 0
             if filename == "iv18x16u.bdf":
                 offset = 6
             elif filename == "ib8x8u.bdf":
                 offset = 10
+            elif filename == "lemon.bdf":
+                offset = 8
+                spacing = -3
+            elif filename == "antidote.bdf":
+                offset = 9
+                spacing = -1
+            elif filename == "uushi.bdf":
+                offset = 8
+                spacing = -2
+            elif filename == "tom-thumb.bdf":
+                offset = 12
+                spacing = 2
 
-            data = (font, offset, {})
+            font = Font(os.path.join(fontDir, filename))
+            data = (font, offset, {}, spacing)
             self.fonts[filename[:-4]] = data
 
     def getGlyph(self, c, font):
-        f, o, cache = self.fonts[font]
+        if not isinstance(font, str):
+            # fall-back to first available font
+            f, offset, cache, spacing = next(iter(self.fonts))
+        else:
+            # users font choice
+            f, offset, cache, spacing = self.fonts[font]
 
         # only render glyphs once, cache resulting image data
         if not c in cache:
             g = g.replace(1, 2).replace(0, 1).replace(2, 0)
 
             # render to pixel data
+            bytesdict = {
+                0: int(self.fg[2] << 16 | self.fg[1] << 8 | self.fg[0]).to_bytes(4, byteorder = "little"),
+                1: int(self.bg[2] << 16 | self.bg[1] << 8 | self.bg[0]).to_bytes(4, byteorder = "little"),
+                2: int(self.color[2] << 16 | self.color[1] << 8 | self.color[0]).to_bytes(4, byteorder = "little"),
+            }
             img = Image.frombytes('RGBA',
                                 (g.width(), g.height()),
-                                g.tobytes('RGBA'))
-
+                                g.tobytes('RGBA', bytesdict))
             cache[c] = img
 
-        return (cache[c], o)
+        return (cache[c], offset, spacing)
 
-    def drawGlyph(self, g, xOff, yOff):
+    def drawGlyph(self, g, xOff, yOff, spacing):
         if xOff >= self.gui.width:
             return
 
                 p = g.getpixel((x, y))
                 self.gui.set_pixel(xTarget, yOff + y, p)
 
+        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)
+
     def text(self, s, f, offset = 0, earlyAbort = True, yOff = 0):
         w = 0
         for c in s:
                 if xOff >= self.gui.width:
                     break
 
-            g, y = self.getGlyph(c, f)
-            w += g.width
+            g, y, spacing = self.getGlyph(c, f)
+            w += g.width + spacing
 
-            if xOff >= -10: # some wiggle room so chars dont disappear
-                self.drawGlyph(g, xOff, y + yOff)
+            if xOff >= -16: # some wiggle room so chars dont disappear
+                self.drawGlyph(g, xOff, y + yOff, spacing)
         return w
 
 class ScrollText:
-    def __init__(self, g, t, f, i = 1, s = 75):
+    def __init__(self, g, t, f, i = 1, s = 75, fg = (255, 255, 255), bg = (0, 0, 0)):
         self.gui = g
-        self.drawer = DrawText(self.gui)
+        self.drawer = DrawText(self.gui, fg, bg)
         self.text = t
         self.font = f
         self.iterations = i
     import util
     t = util.getTarget()
 
-    #d = ScrollText(t, "This is a long scrolling text. Is it too fast or maybe too slow?", "iv18x16u")
-    d = ScrollText(t, "This is a long scrolling text. Is it too fast or maybe too slow?", "ib8x8u")
-    t.debug_loop(d.draw)
+    from splash import SplashScreen
+    splash = SplashScreen(t)
+    t.loop_start()
+    splash.draw()
+    t.loop_end()
+
+    from manager import Manager
+    m = Manager(t)
+
+    m.add(ScrollText(t, "tom-thumb Abcdefgh tom-thumb", "tom-thumb",
+                     1, 75, (0, 255, 0), (0, 0, 255)))
+    m.add(ScrollText(t, "antidote Abcdefgh antidote", "antidote",
+                     1, 75, (0, 255, 0), (0, 0, 255)))
+    m.add(ScrollText(t, "uushi Abcdefgh uushi", "uushi",
+                     1, 75, (0, 255, 0), (0, 0, 255)))
+    m.add(ScrollText(t, "lemon Abcdefgh lemon", "lemon",
+                     1, 75, (0, 255, 0), (0, 0, 255)))
+    m.add(ScrollText(t, "ib8x8u Abcdefgh ib8x8u", "ib8x8u",
+                     1, 75, (0, 255, 0), (0, 0, 255)))
+    m.add(ScrollText(t, "iv18x16u Abcdefgh iv18x16u", "iv18x16u",
+                     1, 75, (0, 255, 0), (0, 0, 255)))
+
+    m.restart()
+    t.debug_loop(m.draw)

image.py

 #!/usr/bin/env python3
 
+# Uses the pillow Python Imaging Library:
+# https://github.com/python-pillow/Pillow
+#
 # ----------------------------------------------------------------------------
 # "THE BEER-WARE LICENSE" (Revision 42):
 # <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
 import os
 
 class ImageScreen:
-    def __init__(self, g, p, t = 0.2, i = 1, to = 20.0, bg = None):
+    def __init__(self, g, p, t = 0.2, i = 1, to = 10.0, bg = None):
         self.gui = g
         self.time = t
         self.iterations = i
         scriptDir = os.path.dirname(os.path.realpath(__file__))
         self.path = os.path.join(scriptDir, "images", p)
         self.image = Image.open(self.path)
+
+        # for some reason non-animated images don't even have this attribute
+        if not hasattr(self.image, "is_animated"):
+            self.image.is_animated = False
+            self.image.n_frames = 1
+
+        # automatically crop and scale large images
+        if not self.image.is_animated and ((self.image.width > self.gui.width) or (self.image.height > self.gui.height)):
+            self.image = self.image.crop(self.image.getbbox())
+            self.image = self.image.resize((self.gui.width, self.gui.height),
+                                           Image.Resampling.NEAREST)
+
+            # new image object is also missing these
+            self.image.is_animated = False
+            self.image.n_frames = 1
+
         print(p, self.image.width, self.image.height, self.image.is_animated, self.image.n_frames)
 
         self.xOff = int((self.gui.width - self.image.width) / 2)

pi.py

 #!/usr/bin/env python3
 
+# Uses the Python bindings for the Raspberry Pi RGB LED Matrix library:
+# https://github.com/hzeller/rpi-rgb-led-matrix
+#
+# And the pillow Python Imaging Library:
+# https://github.com/python-pillow/Pillow
+#
 # ----------------------------------------------------------------------------
 # "THE BEER-WARE LICENSE" (Revision 42):
 # <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice

qr.py

 #!/usr/bin/env python3
 
+# Uses the Python QR code image generator:
+# https://github.com/lincolnloop/python-qrcode
+#
 # ----------------------------------------------------------------------------
 # "THE BEER-WARE LICENSE" (Revision 42):
 # <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
 from draw import DrawText
 
 class QRScreen:
-    def __init__(self, g, d, t = 10.0, h = None, c1 = (0, 0, 0), c2 = (255, 255, 255)):
+    def __init__(self, g, d, t = 10.0, h = None, f = None, c1 = (0, 0, 0), c2 = (255, 255, 255)):
         self.gui = g
         self.time = t
         self.heading = h
+        self.font = f
         self.c1 = c1
         self.c2 = c2
 
 
         if util.isPi():
             # work-around for weird bug in old qrcode lib?
-            self.image = qr.make_image(fill_color = "black", back_color = "white")
-            self.c1 = (0, 0, 0)
-            self.c2 = (255, 255, 255)
+            if (self.c1 == (0, 0, 0)) and (self.c2 == (255, 255, 255)):
+                self.image = qr.make_image(fill_color = "black", back_color = "white")
+                self.c1 = (0, 0, 0)
+                self.c2 = (255, 255, 255)
+            elif (self.c1 == (255, 255, 255)) and (self.c2 == (0, 0, 0)):
+                self.image = qr.make_image(fill_color = "white", back_color = "black")
+                self.c1 = (255, 255, 255)
+                self.c2 = (0, 0, 0)
+            else:
+                raise RuntimeError("QR colors other than black/white not supported on Pi")
         else:
             self.image = qr.make_image(fill_color = self.c1, back_color = self.c2)
 
         if self.heading != None:
-            self.text = DrawText(self.gui)
+            self.text = DrawText(self.gui, self.c1, self.c2)
+            self.yOff = self.gui.height - self.image.height
+        else:
+            self.yOff = int((self.gui.height - self.image.height) / 2)
 
         self.xOff = int((self.gui.width - self.image.width) / 2)
-        self.yOff = int((self.gui.height - self.image.height) / 2)
 
         self.restart()
 
                 for x in range(0, self.gui.width - self.image.width - self.xOff):
                     self.gui.set_pixel(x + self.xOff + self.image.width, y + self.yOff, self.c2)
 
+        if self.heading != None:
+            self.text.text(self.heading, self.font, 0, True, -10)
+
         for x in range(0, self.image.width):
             for y in range(0, self.image.height):
                 v = self.image.getpixel((x, y))
                     v = (v, v, v)
                 self.gui.set_pixel(x + self.xOff, y + self.yOff, v)
 
-        if self.heading != None:
-            self.text.text(self.heading, "ib8x8u", 0, True, -10)
-
 if __name__ == "__main__":
     import util
     t = util.getTarget()
 
-    d = QRScreen(t, "Hello World", 10.0, "Test")
+    d = QRScreen(t, "Hello World", 10.0, "Drinks:", "tom-thumb", (255, 255, 255), (0, 0, 0))
     t.debug_loop(d.draw)

test.py

 #!/usr/bin/env python3
 
+# Uses the pygame SDL wrapper:
+# https://github.com/pygame/pygame
+#
 # ----------------------------------------------------------------------------
 # "THE BEER-WARE LICENSE" (Revision 42):
 # <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 return True
+            elif event.type == pygame.KEYUP:
+                if (event.key == pygame.K_q) or (event.key == pygame.K_ESCAPE):
+                    return True
 
         self.screen.fill("black")
         return False

util.py

 # think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
 # ----------------------------------------------------------------------------
 
-import platform
+targetIsPi = None
 
 def isPi():
-    return platform.machine() == "armv7l"
+    global targetIsPi
+
+    if targetIsPi == None:
+        getTarget()
+    return targetIsPi
 
 def getTarget():
-    t = None
-    if isPi():
+    global targetIsPi
+
+    target = None
+    try:
         from pi import PiMatrix
-        t = PiMatrix()
-    else:
+        target = PiMatrix()
+
+        if targetIsPi == None:
+            # only print once
+            print("Raspberry Pi Adafruit RGB LED Matrix detected")
+
+        targetIsPi = True
+    except ModuleNotFoundError:
         from test import TestGUI
-        t = TestGUI()
-    return t
+        target = TestGUI()
+
+        if targetIsPi == None:
+            # only print once
+            print("Falling back to GUI debug interface")
+
+        targetIsPi = False
+    return target