change brightness with controller. tweak tetris.

camp_pico.py

 m.add(Solid(t, 1.0))
 
 m.restart()
-t.loop(m.draw)
+util.loop(t, m.draw)

camp_small.py

 #url = "http://ubabot.frubar.net"
 url = "http://www.xythobuz.de"
 
+scroll_speed = 15
+
 # Need to import InputWrapper before initializing RGB Matrix on Pi
 i = InputWrapper()
 
-t = util.getTarget()
+t = util.getTarget(i)
 
 # Loading fonts and graphics takes a while.
 # So show a splash screen while the user waits.
 success = Manager(t)
 success.add(ImageScreen(t, "drinka.gif", 0.2, 2, 20.0, (0, 0, 0)))
 success.add(Solid(t, 1.0))
-success.add(QRScreen(t, url, 30.0, "Drinks:", "tom-thumb", (255, 255, 255), (0, 0, 0)))
+success.add(ScrollText(t, "Visit the UbaBot Cocktail machine at FruBar village for drinks!", "lemon", 2, scroll_speed, camp_green))
+success.add(Solid(t, 1.0))
+success.add(QRScreen(t, url, 30.0, "Drinks:", "tom-thumb", camp_pink, (0, 0, 0)))
 success.add(Solid(t, 1.0))
 
 # UbaBot is offline
 fail = Manager(t)
 fail.add(ImageScreen(t, "attention.gif", 0.2, 2, 20.0, (0, 0, 0)))
 fail.add(Solid(t, 1.0))
-fail.add(ScrollText(t, "The UbaBot Cocktail machine is currently closed. Please come back later for more drinks!", "lemon", 2, 75, camp_pink))
+fail.add(ScrollText(t, "The UbaBot Cocktail machine is currently closed. Please come back later for more drinks!", "lemon", 2, scroll_speed, camp_pink))
 fail.add(Solid(t, 1.0))
 fail.add(GameOfLife(t, 20, (0, 255, 0), (0, 0, 0), None, 2.0))
 fail.add(Solid(t, 1.0))
 
 # Main "Menu"
 m = Manager(t, i)
-m.add(ScrollText(t, "#CCCAMP23", "lemon", 1, 75, camp_green))
+m.add(ScrollText(t, "#CCCAMP23", "lemon", 1, scroll_speed, 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(Solid(t, 1.0))
 m.add(Snake(t, i, camp_pink, camp_green))
 m.add(Solid(t, 1.0))
-m.add(ScrollText(t, "Your advertisement could appear here. Open a Pull Request on git.xythobuz.de/thomas/rgb-matrix-visualizer or send an e-mail to thomas@xythobuz.de", "iv18x16u", 2, 70, camp_green))
+m.add(ScrollText(t, "Your advertisement could appear here. Open a Pull Request on git.xythobuz.de/thomas/rgb-matrix-visualizer or send an e-mail to thomas@xythobuz.de", "iv18x16u", 2, scroll_speed, camp_green))
 m.add(Solid(t, 1.0))
 
 m.restart()
-t.loop(m.draw)
+util.loop(t, m.draw)

gamepad.py

                         self.keys["r"] = v
                     elif (event.code == ecodes.BTN_TOP2) or (event.code == ecodes.KEY_A):
                         self.keys["l"] = v
-                    elif event.code == ecodes.BTN_BASE4:
+                    elif (event.code == ecodes.BTN_BASE4) or (event.code == ecodes.KEY_BACKSPACE):
                         self.keys["start"] = v
                     elif event.code == ecodes.BTN_BASE3:
                         self.keys["select"] = v

image.py

                 print()
 
     m.restart()
-    t.loop(m.draw)
+    util.loop(t, m.draw)

life.py

             g.restart()
         g.draw()
 
-    t.loop(helper)
+    util.loop(t, helper)

manager.py

 
     def switch_to(self, i, update_flag):
         self.lastTime = time.time()
-        self.index = int((int(self.index / self.step_size) + i) * self.step_size) % len(self.screens)
-
-        #print("Manager ", len(self.screens), " switch to ", self.index, update_flag)
 
         if update_flag:
             self.done = (self.index == 0)
 
+            # go through all for normal operation
+            self.index = (self.index + i) % len(self.screens)
+        else:
+            # use step_size for button presses
+            self.index = int((int(self.index / self.step_size) + i) * self.step_size) % len(self.screens)
+
+        #print("Manager ", len(self.screens), " switch to ", self.index, update_flag)
+
         self.screens[self.index][0].restart()
 
     def draw(self):
     m.add(Solid(t, 1.0))
 
     m.restart()
-    t.loop(m.draw)
+    util.loop(t, m.draw)

mapper.py

     def batteryCache(self, refresh = False):
         return self.gui.batteryCache(refresh)
 
+    def exit(self):
+        self.gui.exit()
+
     def loop_start(self):
         return self.gui.loop_start()
 
     def loop_end(self):
         self.gui.loop_end()
 
-    def loop(self, func = None):
-        self.gui.loop(func)
-
     def set_pixel(self, x, y, color):
         self.gui.set_pixel(x, y, color)
 
 # this needs to be the "first" element of the mapper chain.
 # Otherwise special handling for PicoText will not work.
 class MapperReduceBrightness(MapperNull):
-    def __init__(self, g):
+    def __init__(self, g, i = None):
         super().__init__(g)
+        self.input = i
         self.last = None
         self.connected = False
         self.refresh = 60 * 60 * 6
         self.factor = 1.0
+        self.user_mod = None
+        self.old_keys = {
+            "left": False,
+            "right": False,
+            "up": False,
+            "down": False,
+            "a": False,
+            "b": False,
+            "x": False,
+            "y": False,
+            "l": False,
+            "r": False,
+            "start": False,
+            "select": False,
+        }
 
     def fetch(self):
-        self.factor = 1.0
-
-        if not useNTP:
-            return
-
-        if not self.connected:
-            self.connected = util.connectToWiFi()
-
-        if self.connected:
-            now = time.time()
-            if (self.last == None) or ((now - self.last) >= self.refresh) or (now < self.last):
-                self.last = now
-
-                try:
-                    print("Before sync： " + str(time.localtime()))
-                    ntptime.settime()
-                    print("After sync： "  + str(time.localtime()))
-                except Exception as e:
-                    print()
-                    if hasattr(sys, "print_exception"):
-                        sys.print_exception(e)
-                    else:
-                        print(e)
-                    print()
-
-                    return
+        if useNTP:
+            if not self.connected:
+                self.connected = util.connectToWiFi()
+            if self.connected:
+                now = time.time()
+                if (self.last == None) or ((now - self.last) >= self.refresh) or (now < self.last):
+                    self.last = now
+                    try:
+                        print("Before sync： " + str(time.localtime()))
+                        ntptime.settime()
+                        print("After sync： "  + str(time.localtime()))
+                    except Exception as e:
+                        print()
+                        if hasattr(sys, "print_exception"):
+                            sys.print_exception(e)
+                        else:
+                            print(e)
+                        print()
+                        return
+        else:
+            if self.last == None:
+                self.last = time.time()
+                print("Time: " + str(time.localtime()))
 
         # (year, month, day, hour, minute, second, ?, ?)
         now = time.localtime()
 
-        # 8pm utc == 22pm dst germany
-        night = (now[0], now[1], now[2], 20, 0, 0, 0, 0)
+        # TODO ntptime is setting to UTC, host is on proper timezone
+        if useNTP:
+            # 8pm utc == 10pm cest germany
+            night = (now[0], now[1], now[2], 20, 0, 0, 0, 0)
 
-        # 5am utc == 7am dst germany
-        morning = (now[0], now[1], now[2], 5, 0, 0, 0, 0)
+            # 5am utc == 7am cest germany
+            morning = (now[0], now[1], now[2], 5, 0, 0, 0, 0)
+        else:
+            # 10pm cest germany
+            night = (now[0], now[1], now[2], 22, 0, 0, 0, 0)
+
+            # 7am cest germany
+            morning = (now[0], now[1], now[2], 7, 0, 0, 0, 0)
 
         if (now > morning) and (now < night):
             self.factor = 1.0
         else:
             self.factor = 0.42
 
+    def buttons(self):
+        keys = self.input.get()
+
+        if (keys["select"] and keys["up"] and (not self.old_keys["up"])) or (keys["up"] and keys["select"] and (not self.old_keys["select"])):
+            self.factor += 0.05
+            self.factor = min(self.factor, 0.95)
+            self.user_mod = time.time()
+        elif (keys["select"] and keys["down"] and (not self.old_keys["down"])) or (keys["down"] and keys["select"] and (not self.old_keys["select"])):
+            self.factor -= 0.05
+            self.factor = max(self.factor, 0.05)
+            self.user_mod = time.time()
+
+        self.old_keys = keys.copy()
+
     def adjust(self, color):
         return (int(color[0] * self.factor), int(color[1] * self.factor), int(color[2] * self.factor))
 
+    def loop_start(self):
+        if self.input != None:
+            self.buttons()
+
+        return super().loop_start()
+
     def loop_end(self):
         super().loop_end()
-        self.fetch()
+
+        if self.user_mod == None:
+            self.fetch()
+        elif (time.time() - self.user_mod) > self.refresh:
+            # fall back from user-modified factor after 6h
+            self.user_mod = None
 
     def set_pixel(self, x, y, color):
         color = self.adjust(color)

net.py

     d.success(Solid(t, 1.0, (0, 255, 0)))
     d.fail(Solid(t, 1.0, (255, 0, 0)))
 
-    t.loop(d.draw)
+    util.loop(t, d.draw)

pi.py

 
         self.loop_start() # initialize with blank image for ScrollText constructor
 
+    def exit(self):
+        pass
+
     def loop_start(self):
         self.image = Image.new('RGB', (self.width, self.height))
         return False # no input, never quit on our own
     def loop_end(self):
         self.matrix.SetImage(self.image.convert('RGB'))
 
-    def loop(self, func = None):
-        while True:
-            if self.loop_start():
-                break
-            if func != None:
-                func()
-            self.loop_end()
-
     def set_pixel(self, x, y, color):
         if (x < 0) or (y < 0) or (x >= self.width) or (y >= self.height):
             return
 
 if __name__ == "__main__":
     t = PiMatrix(32, 32)
-    t.loop(lambda: t.set_pixel(15, 15, (255, 255, 255)))
+    util.loop(t, lambda: t.set_pixel(15, 15, (255, 255, 255)))

pico.py

 
         self.loop_start() # initialize with blank image for ScrollText constructor
 
+    def exit(self):
+        self.matrix.stop()
+
     def battery(self):
         n = const(10)
         bits = const(10)
         # update battery if necessary
         self.batteryCache(False)
 
-    def loop(self, func = None):
-        while True:
-            if self.loop_start():
-                break
-
-            if func != None:
-                func()
-
-            self.loop_end()
-
-        self.matrix.stop()
-
     def set_pixel(self, x, y, color):
         if (x < 0) or (y < 0) or (x >= self.width) or (y >= self.height):
             return
         else:
             s.text("Drinks:", "bitmap8", 0)
 
-    t.loop(helper)
+    util.loop(t, helper)

qr.py

                     self.c1 = (255, 255, 255)
                     self.c2 = (0, 0, 0)
                 else:
-                    raise RuntimeError("QR colors other than black/white not supported on Pi")
+                    # Use default colors for QR code, and colors for text
+                    self.image = qr.make_image(fill_color = "white", back_color = "black")
             else:
                 self.image = qr.make_image(fill_color = self.c1, back_color = self.c2)
         else:
                     self.gui.set_pixel(x + self.xOff + self.image.width, y + self.yOff, self.c2)
 
         if self.heading != None:
-            off = -10
+            off = 0
             if self.font == "bitmap6":
-                off -= 3
+                off = -14
+            elif self.font == "tom-thumb":
+                off = -11
 
             self.text.text(self.heading, self.font, 0, True, off)
 
             print(e)
             print()
 
-    t.loop(d.draw)
+    util.loop(t, d.draw)

scroll.py

         m.add(ScrollText(t, s, fontName, 1, 75, (0, 255, 0), (0, 0, 25)))
 
     m.restart()
-    t.loop(m.draw)
+    util.loop(t, m.draw)

snake.py

         self.speedup = su
 
         self.winText = ScrollText(self.gui, "You Won!", "uushi",
-                                  2, 75, (0, 255, 0))
+                                  2, 50, (0, 255, 0))
         self.loseText = ScrollText(self.gui, "Game Over!", "uushi",
-                                   2, 75, (255, 0, 0))
+                                   2, 50, (255, 0, 0))
         self.scoreText = ScrollText(self.gui, "Score:", "uushi",
-                                    2, 75, sc)
+                                    2, 50, sc)
 
         random.seed()
         self.restart()
             "right": False,
             "up": False,
             "down": False,
+            "a": False,
+            "b": False,
+            "x": False,
+            "y": False,
+            "l": False,
+            "r": False,
+            "start": False,
+            "select": False,
         }
 
         self.placeDot()
     def buttons(self):
         keys = self.input.get()
 
-        if keys["left"] and (not self.old_keys["left"]):
+        if keys["left"] and (not self.old_keys["left"]) and (not self.old_keys["select"]):
             self.directionTmp = "l"
-        elif keys["right"] and (not self.old_keys["right"]):
+        elif keys["right"] and (not self.old_keys["right"]) and (not self.old_keys["select"]):
             self.directionTmp = "r"
-        elif keys["up"] and (not self.old_keys["up"]):
+        elif keys["up"] and (not self.old_keys["up"]) and (not self.old_keys["select"]):
             self.directionTmp = "u"
-        elif keys["down"] and (not self.old_keys["down"]):
+        elif keys["down"] and (not self.old_keys["down"]) and (not self.old_keys["select"]):
             self.directionTmp = "d"
         elif (keys["select"] and keys["start"] and (not self.old_keys["start"])) or (keys["start"] and keys["select"] and (not self.old_keys["select"])):
             self.restart()
     i = InputWrapper()
 
     import util
-    t = util.getTarget()
+    t = util.getTarget(i)
 
     d = Snake(t, i)
-    t.loop(d.draw)
+    util.loop(t, d.draw)

solid.py

 
         d.draw()
 
-    t.loop(helper)
+    util.loop(t, helper)

splash.py

     import util
     t = util.getTarget()
     s = SplashScreen(t)
-    t.loop(s.draw)
+    util.loop(t, s.draw)

test.py

 import pygame
 
 class TestGUI:
-    def __init__(self, width = 32, height = 32, multiplier = 16):
+    def __init__(self, width = 32 * 2, height = 32, multiplier = 16):
         self.width = width
         self.height = height
         self.multiplier = multiplier
 
         # compatibility to PiMatrix
-        self.panelW = self.width
-        self.panelH = self.height
+        self.panelW = 32
+        self.panelH = 32
 
         pygame.display.init()
         self.screen = pygame.display.set_mode((self.width * self.multiplier, self.height * self.multiplier))
         pygame.display.flip()
         self.clock.tick(30)
 
-    def loop(self, func = None):
-        while True:
-            if self.loop_start():
-                break
-            if func != None:
-                func()
-            self.loop_end()
-        self.exit()
-
     def set_pixel(self, x, y, color):
         if (x < 0) or (y < 0) or (x >= self.width) or (y >= self.height):
             return
 
 if __name__ == "__main__":
     t = TestGUI(32, 32)
-    t.loop(lambda: t.set_pixel(15, 15, (255, 255, 255)))
+    util.loop(t, lambda: t.set_pixel(15, 15, (255, 255, 255)))

tetris.py

 from scroll import ScrollText
 import time
 import random
+import util
 
 class Tetris:
     def __init__(self, g, i, ts = 0.5, to = 60.0, w = 10, h = 22):
         self.width = min(w, self.gui.width)
         self.height = min(h, self.gui.height)
 
-        self.x_off = int((self.gui.panelW - self.width - 2) / 2)
-        self.y_off = int((self.gui.panelH - self.height - 2) / 2)
-
         self.endText = ScrollText(self.gui, "Game Over!", "uushi",
-                                   2, 75, (251, 72, 196))
+                                   2, 50, (251, 72, 196))
         self.scoreText = ScrollText(self.gui, "Score:", "uushi",
-                                    2, 75, (63, 255, 33))
+                                    2, 50, (63, 255, 33))
 
         self.bg = (0, 0, 0)
         self.colors = [
             #(255, 255, 255),
         ]
 
+        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]))
+
         # all [y][x] sub-lists must be the same length
         self.pieces = [
             # "I"
             ],
         ]
 
+        self.max_width = 0
+        self.max_height = 0
+        for piece in self.pieces:
+            if len(piece) > self.max_height:
+                self.max_height = len(piece)
+            if len(piece[0]) > self.max_width:
+                self.max_width = len(piece[0])
+        self.max_width += 2
+        self.max_height += 2
+
+        self.x_off = 1
+        self.y_off = self.gui.height - self.height - 3
+
+        self.next_x_off = self.gui.panelW - self.max_width - 3
+        self.next_y_off = self.gui.panelH - self.max_height - 3
+
         random.seed()
         self.restart()
 
         self.done = False
         self.data = [[self.bg for y in range(self.height)] for x in range(self.width)]
         self.piece = None
+        self.next_piece = None
         self.old_keys = {
             "left": False,
             "right": False,
             "up": False,
             "down": False,
+            "a": False,
+            "b": False,
+            "x": False,
+            "y": False,
+            "l": False,
+            "r": False,
+            "start": False,
+            "select": False,
         }
+        self.pause = False
 
     def finished(self):
         if self.input == None:
         return board_clear
 
     def step(self):
-        if self.piece == None:
-            justPlaced = True
-
+        if self.next_piece == None:
             # select a new piece type and color
-            self.piece = [
+            self.next_piece = [
                 self.pieces[random.randrange(0, len(self.pieces))], # piece
                 self.colors[random.randrange(0, len(self.colors))], # color
                 0, # x
             ]
 
             # center the piece on top of the playing board
-            self.piece[2] = int((self.width - len(self.piece[0][0])) / 2)
+            self.next_piece[2] = int((self.width - len(self.next_piece[0][0])) / 2)
+
+            # offsets for drawing the next piece
+            self.piece_x_off = int((self.max_width - len(self.next_piece[0][0])) / 2)
+            self.piece_y_off = int((self.max_height - len(self.next_piece[0])) / 2)
+
+        if self.piece == None:
+            justPlaced = True
+            self.piece = self.next_piece
+            self.next_piece = None
 
             if self.collision():
                 # new piece immediately collided. game over!
     def buttons(self):
         keys = self.input.get()
 
-        if keys["left"] and (not self.old_keys["left"]):
+        if keys["left"] and (not self.old_keys["left"]) and (not self.old_keys["select"]):
             self.button = "l"
-        elif keys["right"] and (not self.old_keys["right"]):
+        elif keys["right"] and (not self.old_keys["right"]) and (not self.old_keys["select"]):
             self.button = "r"
-        elif keys["up"] and (not self.old_keys["up"]):
+        elif keys["up"] and (not self.old_keys["up"]) and (not self.old_keys["select"]):
             self.button = "u"
-        elif keys["down"]:
+        elif keys["down"] and (not self.old_keys["select"]):
             self.button = "d"
         elif (keys["select"] and keys["start"] and (not self.old_keys["start"])) or (keys["start"] and keys["select"] and (not self.old_keys["select"])):
             self.restart()
+        elif keys["start"] and (not self.old_keys["start"]) and (not self.old_keys["select"]):
+            self.pause = not self.pause
+        elif self.done and keys["start"] and (not self.old_keys["start"]):
+            self.restart()
+        elif self.done and keys["a"] and (not self.old_keys["a"]):
+            self.restart()
+        elif self.done and keys["b"] and (not self.old_keys["b"]):
+            self.restart()
+        elif self.done and keys["x"] and (not self.old_keys["x"]):
+            self.restart()
+        elif self.done and keys["y"] and (not self.old_keys["y"]):
+            self.restart()
 
         self.old_keys = keys.copy()
 
+    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)
+
+        if self.pause:
+            self.text[2].text("Paused", "tom-thumb", -x_off - 2, True, -y_off + 11)
+
     def draw(self):
+        if self.input != None:
+            self.buttons()
+        else:
+            # TODO "AI"
+            self.button = None
+
         if self.done:
             if self.endText.finished():
                 self.scoreText.draw()
                 self.scoreText.restart()
             return
 
-        if self.input != None:
-            self.buttons()
-        else:
-            # TODO "AI"
-            self.button = None
-
         now = time.time()
-        if (self.button != None) or ((now - self.last) >= self.timestep) or (now < self.last):
+        if (not self.pause) and ((self.button != None) or ((now - self.last) >= self.timestep) or (now < self.last)):
             # don't let user stop falling pieces by moving/rotating endlessly
             if (self.button != "l") and (self.button != "r") and (self.button != "u"):
                 self.last = now
                 self.scoreText.setText("Score: " + str(self.score), "uushi")
                 self.endText.restart()
 
-        # TODO placement of play area
+        # 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)
+
+        # draw play area and border
         for x in range(-1, self.width + 1):
             for y in range(-1, self.height + 1):
-                c = (255, 255, 255)
+                c = self.colors[1] # border color
                 if (x >= 0) and (y >= 0) and (x < self.width) and (y < self.height):
                     c = self.data[x][y]
-
                 self.gui.set_pixel(x + 1 + self.x_off, y + 1 + self.y_off, c)
 
+        # draw next piece and border
+        for x in range(-1, self.max_width + 1):
+            for y in range(-1, self.max_height + 1):
+                c = self.colors[0] # border color
+                if (x >= 0) and (y >= 0) and (x < self.max_width) and (y < self.max_height):
+                    if self.next_piece == None:
+                        c = (0, 0, 0)
+                    else:
+                        if (y >= self.piece_y_off) and (y < (len(self.next_piece[0]) + self.piece_y_off)) and (x >= self.piece_x_off) and (x < (len(self.next_piece[0][0]) + self.piece_x_off)):
+                            if self.next_piece[0][y - self.piece_y_off][x - self.piece_x_off] != 0:
+                                c = self.next_piece[1]
+                            else:
+                                c = (0, 0, 0)
+                        else:
+                            c = (0, 0, 0)
+                self.gui.set_pixel(x + 1 + self.next_x_off, y + 1 + self.next_y_off, c)
+
+        # find position for stats
+        stats_off = None
+        if self.gui.width > self.gui.panelW:
+            stats_off = (self.gui.panelW, 0)
+        elif self.gui.height > self.gui.panelH:
+            stats_off = (0, self.gui.panelH)
+
+        # second screen with stats
+        if stats_off != None:
+            self.draw_stats(stats_off)
+
 if __name__ == "__main__":
     # Need to import InputWrapper before initializing RGB Matrix on Pi
     from gamepad import InputWrapper
     i = InputWrapper()
 
-    import util
-    t = util.getTarget()
+    t = util.getTarget(i)
+
+    # show splash screen while initializing
+    from splash import SplashScreen
+    splash = SplashScreen(t)
+    t.loop_start()
+    splash.draw()
+    t.loop_end()
 
     d = Tetris(t, i)
-    t.loop(d.draw)
+    util.loop(t, d.draw)

util.py

 
     return targetPlatform == "pico"
 
-def getTarget():
+def getTarget(i = None):
     global targetPlatform, cachedTarget
 
     if cachedTarget != None:
         pi = PiMatrix()
 
         # TODO hard-coded adjustments
-        from mapper import MapperColorAdjust, MapperStripToRect
-        col = MapperColorAdjust(pi)
+        from mapper import MapperReduceBrightness, MapperColorAdjust, MapperStripToRect
+        bright = MapperReduceBrightness(pi, i)
+        col = MapperColorAdjust(bright)
         #target = MapperStripToRect(col)
         target = col
 
 
             # TODO hard-coded adjustments
             from mapper import MapperReduceBrightness
-            target = MapperReduceBrightness(pico)
+            target = MapperReduceBrightness(pico, i)
 
             if targetPlatform == None:
                 # only print once
         return PicoText
 
     return None
+
+def loop(gui, func = None):
+    while True:
+        if gui.loop_start():
+            break
+        if func != None:
+            func()
+        gui.loop_end()
+    gui.exit()