Initial NodeBehavior implementation

signage/browser.py

@@ -1,18 +1,14 @@
 from cefbrowser.cefbrowser import CEFBrowser
-from signage.fader import Node
+from signage.fader import NodeBehavior
 
 
-class BrowserNode(Node, CEFBrowser):
+class BrowserNode(NodeBehavior, 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

signage/clock.py

@@ -5,10 +5,10 @@ from kivy.properties import NumericProperty, StringProperty, \
     ObjectProperty, AliasProperty
 from kivy.clock import Clock
 
-from signage.fader import Screen
+from signage.fader import NodeBehavior
 
 
-class ClockNode(Label, Screen):
+class ClockNode(NodeBehavior, Label):
     update_interval = NumericProperty(1.0)
     format = StringProperty("%H:%M")
     now = ObjectProperty(None)

signage/fader.py

@@ -4,12 +4,90 @@ 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, BooleanProperty
+from kivy.uix.relativelayout import RelativeLayout
+import kivy.uix.screenmanager
 
+from kivy.properties import StringProperty, NumericProperty, BooleanProperty, ObjectProperty, OptionProperty
+
+class NodeBehavior(object):
+    '''Screen is an element intended to be used with a :class:`ScreenManager`.
+    Check module documentation for more information.
+    :Events:
+        `on_pre_enter`: ()
+            Event fired when the screen is about to be used: the entering
+            animation is started.
+        `on_enter`: ()
+            Event fired when the screen is displayed: the entering animation is
+            complete.
+        `on_pre_leave`: ()
+            Event fired when the screen is about to be removed: the leaving
+            animation is started.
+        `on_leave`: ()
+            Event fired when the screen is removed: the leaving animation is
+            finished.
+    .. versionchanged:: 1.6.0
+        Events `on_pre_enter`, `on_enter`, `on_pre_leave` and `on_leave` were
+        added.
+    '''
+
+    name = StringProperty('')
+    '''
+    Name of the screen which must be unique within a :class:`ScreenManager`.
+    This is the name used for :attr:`ScreenManager.current`.
+    :attr:`name` is a :class:`~kivy.properties.StringProperty` and defaults to
+    ''.
+    '''
+
+    manager = ObjectProperty(None, allownone=True)
+    ''':class:`ScreenManager` object, set when the screen is added to a
+    manager.
+    :attr:`manager` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None, read-only.
+    '''
+
+    transition_progress = NumericProperty(0.)
+    '''Value that represents the completion of the current transition, if any
+    is occurring.
+    If a transition is in progress, whatever the mode, the value will change
+    from 0 to 1. If you want to know if it's an entering or leaving animation,
+    check the :attr:`transition_state`.
+    :attr:`transition_progress` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    transition_state = OptionProperty('out', options=('in', 'out'))
+    '''Value that represents the state of the transition:
+    - 'in' if the transition is going to show your screen
+    - 'out' if the transition is going to hide your screen
+    After the transition is complete, the state will retain it's last value (in
+    or out).
+    :attr:`transition_state` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'out'.
+    '''
+
+    __events__ = ('on_pre_enter', 'on_enter', 'on_pre_leave', 'on_leave')
 
-class Node(BaseScreen):
     interval = NumericProperty(0.0)
 
+    def on_pre_enter(self, *args):
+        pass
+
+    def on_enter(self, *args):
+        pass
+
+    def on_pre_leave(self, *args):
+        pass
+
+    def on_leave(self, *args):
+        pass
+
+    def __repr__(self):
+        return '<Screen name=%r>' % self.name
+
+class Node(NodeBehavior, RelativeLayout):
+    pass
+
+kivy.uix.screenmanager.Screen = NodeBehavior
 Screen = Node
 
 class Fader(ScreenManager):
@@ -59,18 +137,18 @@ class Fader(ScreenManager):
 
     def add_widget(self, screen):
         """Just wrap everything in Screen"""
-        if not isinstance(screen, Screen):
-            print ('Wrapping!')
-            s = Screen()
+        if not isinstance(screen, NodeBehavior):
+            print ('Wrapping!', screen)
+            s = Node()
             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:
+        for i, c in enumerate(self.screens):
             if not c.name:
-                c.name = 'screen_%.4f' % (random.random())
+                c.name = 'screen_%i_%s' % (i, type(c))
 
     def rotate_screens(self, dt):
         self.generate_ids()