lib/python/Screens/Screen.py

   1 from Components.HTMLSkin import HTMLSkin
   2 from Components.GUISkin import GUISkin
   3 from Components.Sources.Source import Source
   4 from Components.GUIComponent import GUIComponent
   5
   6 class Screen(dict, HTMLSkin, GUISkin):
   7
   8         ALLOW_SUSPEND = False
   9
  10         def __init__(self, session):
  11                 self.skinName = self.__class__.__name__
  12                 self.session = session
  13                 GUISkin.__init__(self)
  14
  15                 self.onClose = [ ]
  16                 self.onFirstExecBegin = [ ]
  17                 self.onExecBegin = [ ]
  18                 self.onShown = [ ]
  19
  20                 self.onShow = [ ]
  21                 self.onHide = [ ]
  22
  23                 self.execing = False
  24
  25                 self.shown = True
  26                 # already shown is false until the screen is really shown (after creation)
  27                 self.already_shown = False
  28
  29                 self.renderer = [ ]
  30
  31                 # in order to support screens *without* a help,
  32                 # we need the list in every screen. how ironic.
  33                 self.helpList = [ ]
  34
  35                 self.close_on_next_exec = None
  36
  37                 # stand alone screens (for example web screens)
  38                 # don't care about having or not having focus.
  39                 self.stand_alone = False
  40
  41         def execBegin(self):
  42                 self.active_components = [ ]
  43                 if self.close_on_next_exec is not None:
  44                         tmp = self.close_on_next_exec
  45                         self.close_on_next_exec = None
  46                         self.execing = True
  47                         self.close(tmp)
  48                 else:
  49                         single = self.onFirstExecBegin
  50                         self.onFirstExecBegin = []
  51                         for x in self.onExecBegin + single:
  52                                 x()
  53                                 if not self.stand_alone and self.session.current_dialog != self:
  54                                         return
  55
  56 #                       assert self.session == None, "a screen can only exec once per time"
  57 #                       self.session = session
  58
  59                         for val in self.values() + self.renderer:
  60                                 val.execBegin()
  61                                 if not self.stand_alone and self.session.current_dialog != self:
  62                                         return
  63                                 self.active_components.append(val)
  64
  65                         self.execing = True
  66
  67                         for x in self.onShown:
  68                                 x()
  69
  70         def execEnd(self):
  71 #               for (name, val) in self.items():
  72                 for val in self.active_components:
  73                         val.execEnd()
  74                 del self.active_components
  75 #               assert self.session != None, "execEnd on non-execing screen!"
  76 #               self.session = None
  77                 self.execing = False
  78
  79         # never call this directly - it will be called from the session!
  80         def doClose(self):
  81                 self.hide()
  82                 for x in self.onClose:
  83                         x()
  84
  85                 # fixup circular references
  86                 del self.helpList
  87                 GUISkin.close(self)
  88
  89                 # first disconnect all render from their sources.
  90                 # we might split this out into a "unskin"-call,
  91                 # but currently we destroy the screen afterwards
  92                 # anyway.
  93                 for val in self.renderer:
  94                         val.disconnectAll()  # disconnected converter/sources and probably destroy them
  95
  96                 del self.session
  97                 for (name, val) in self.items():
  98                         val.destroy()
  99                         del self[name]
 100
 101                 for val in self.renderer:
 102                         val.destroy()
 103
 104                 self.renderer = [ ]
 105
 106                 # really delete all elements now
 107                 self.__dict__.clear()
 108
 109         def close(self, *retval):
 110                 if not self.execing:
 111                         self.close_on_next_exec = retval
 112                 else:
 113                         self.session.close(self, *retval)
 114
 115         def setFocus(self, o):
 116                 self.instance.setFocus(o.instance)
 117
 118         def show(self):
 119                 if (self.shown and self.already_shown) or not self.instance:
 120                         return
 121                 self.shown = True
 122                 self.already_shown = True
 123                 self.instance.show()
 124                 for x in self.onShow:
 125                         x()
 126                 for val in self.values() + self.renderer:
 127                         if isinstance(val, GUIComponent) or isinstance(val, Source):
 128                                 val.onShow()
 129
 130         def hide(self):
 131                 if not self.shown or not self.instance:
 132                         return
 133                 self.shown = False
 134                 self.instance.hide()
 135                 for x in self.onHide:
 136                         x()
 137                 for val in self.values() + self.renderer:
 138                         if isinstance(val, GUIComponent) or isinstance(val, Source):
 139                                 val.onHide()
 140
 141         def __repr__(self):
 142                 return str(type(self))