Initial signage-ng commit

.gitignore

@@ -0,0 +1,2 @@
+*.py[co]
+.ropeproject

signage.kv

@@ -0,0 +1,15 @@
+#: include force signage/base.kv
+
+<MainContainer>:
+    BoxLayout:
+        orientation: 'vertical'
+
+        Fader:
+            interval: 2
+            ClockNode:
+                interval: 1.0
+                update_interval: 1.0
+                format: "%H:%M:%S"
+            BrowserNode:
+                interval: 3.0
+                url: "https://monitoring.hackerspace.pl"

signage.py

@@ -0,0 +1,33 @@
+
+from kivy.app import App
+from kivy.uix.boxlayout import BoxLayout
+
+from signage.browser import CEFBrowser
+from signage.fader import Fader
+from signage.clock import ClockNode
+
+
+class MainContainer(BoxLayout):
+    pass
+
+
+class SignageApp(App):
+    def build(self):
+        return MainContainer()
+
+
+FONTS = [
+    {
+        'name': 'Lato',
+        'fn_regular': 'fonts/Lato-Light.ttf',
+        'fn_bold': 'fonts/Lato-Regular.ttf'
+    },
+]
+
+if __name__ == '__main__':
+    from kivy.core.text import Label as CoreLabel
+
+    for font in FONTS:
+        CoreLabel.register(**font)
+
+    SignageApp().run()

signage/base.kv

@@ -0,0 +1,5 @@
+#: import Node signage.fader.Node
+
+<Label>:
+    font_name: 'Lato'
+    font_size: '48dp'

signage/browser.py

@@ -0,0 +1,27 @@
+from cefbrowser.cefbrowser import CEFBrowser
+from signage.fader import Node
+
+
+class BrowserNode(Node, CEFBrowser):
+    hidden = False
+
+    def on_pre_enter(self):
+        self._browser.WasHidden(False)
+        self.hidden = False
+
+    def on_enter(self):
+        pass
+        #self._browser.WasResized()
+
+    def on_leave(self):
+        self._browser.WasHidden(True)
+        self.hidden = True
+
+    def _realign(self, *largs):
+        if self.hidden:
+            self._browser.WasHidden(False)
+
+        super(BrowserNode, self)._realign(*largs)
+
+        if self.hidden:
+            self._browser.WasHidden(True)

signage/clock.py

@@ -0,0 +1,36 @@
+import datetime
+
+from kivy.uix.label import Label
+from kivy.properties import NumericProperty, StringProperty, \
+    ObjectProperty, AliasProperty
+from kivy.clock import Clock
+
+from signage.fader import Screen
+
+
+class ClockNode(Label, Screen):
+    update_interval = NumericProperty(1.0)
+    format = StringProperty("%H:%M")
+    now = ObjectProperty(None)
+
+    def get_text(self):
+        if self.now and self.format:
+            return self.now.strftime(self.format)
+        return ''
+
+    text = AliasProperty(get_text, bind=['now', 'format'])
+
+    _interval = None
+
+    def __init__(self, **kwargs):
+        super(ClockNode, self).__init__(**kwargs)
+        self.on_update_interval(None, self.update_interval)
+        self.update_clock()
+
+    def on_update_interval(self, instance, value):
+        if self._interval:
+            self._interval.cancel()
+        self._interval = Clock.schedule_interval(self.update_clock, value)
+
+    def update_clock(self, dt=None):
+        self.now = datetime.datetime.now()

signage/fader.py

@@ -0,0 +1,75 @@
+import time
+import random
+
+from kivy.clock import Clock
+from kivy.uix.screenmanager import ScreenManager, FadeTransition
+from kivy.uix.screenmanager import Screen as BaseScreen
+from kivy.properties import NumericProperty
+
+
+class Node(BaseScreen):
+    interval = NumericProperty(0.0)
+
+Screen = Node
+
+class Fader(ScreenManager):
+    interval = NumericProperty(5.0)
+    view_start = NumericProperty(5.0)
+
+    _interval = None
+
+    def __init__(self, **kwargs):
+        super(Fader, self).__init__(**kwargs)
+        if 'transition' not in kwargs:
+            self.transition = FadeTransition()
+
+        from kivy.graphics import Color, Rectangle
+        with self.canvas.after:
+            Color(1., 1., 1., 0.2)
+            self.progress_rect = Rectangle(pos=self.pos, size=self.size)
+        self.bind(pos=self.update_rect)
+        self.bind(size=self.update_rect)
+
+        self.progress_interval = Clock.schedule_interval(self.update_rect, 0)
+        self.rotate_screens(0)
+
+    def update_rect(self, *args):
+        progress = ((time.time() - self.view_start)/self.current_interval)
+
+        self.progress_rect.pos = self.pos
+        self.progress_rect.size = (self.size[0] * progress, 10)
+
+    def on_interval(self, instance, value):
+        if self._interval:
+            self._interval.cancel()
+        self._interval = Clock.schedule_once(
+            self.rotate_screens, self.current_interval)
+
+    def add_widget(self, screen):
+        """Just wrap everything in Screen"""
+        if not isinstance(screen, Screen):
+            print ('Wrapping!')
+            s = Screen()
+            s.add_widget(screen)
+            screen = s
+        return super(Fader, self).add_widget(screen)
+
+    def generate_ids(self):
+        """Generates random IDs for all screens without set name"""
+        for c in self.screens:
+            if not c.name:
+                c.name = 'screen_%.4f' % (random.random())
+
+    def rotate_screens(self, dt):
+        self.generate_ids()
+        self.current = self.next()
+        self.view_start = time.time()
+
+        self._interval = Clock.schedule_once(
+            self.rotate_screens, self.current_interval)
+
+    @property
+    def current_interval(self):
+        if self.current_screen and self.current_screen.interval:
+            return self.current_screen.interval
+        return self.interval