lib/python/Screens/InfoBarGenerics.py

   1 from Screen import Screen
   2 from Components.ActionMap import ActionMap
   3 from Components.ActionMap import NumberActionMap
   4 from Components.Label import Label
   5 from Components.config import configfile
   6 from ChannelSelection import ChannelSelection
   7
   8
   9 from Components.ServiceName import ServiceName
  10 from Components.EventInfo import EventInfo
  11 from Components.ServicePosition import ServicePosition
  12
  13 from EpgSelection import EPGSelection
  14
  15 from Screens.MessageBox import MessageBox
  16 from Screens.MovieSelection import MovieSelection
  17 from Screens.Volume import Volume
  18 from Screens.Mute import Mute
  19 from Screens.Standby import Standby
  20
  21 from enigma import eTimer, eDVBVolumecontrol, quitMainloop
  22
  23 # hack alert!
  24 from Menu import MainMenu, mdom
  25
  26 class InfoBarVolumeControl:
  27         """Volume control, handles volUp, volDown, volMute actions and display
  28         a corresponding dialog"""
  29
  30         def __init__(self):
  31                 self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] ,
  32                         {
  33                                 "volumeUp": self.volUp,
  34                                 "volumeDown": self.volDown,
  35                                 "volumeMute": self.volMute,
  36                         })
  37
  38                 self.volumeDialog = self.session.instantiateDialog(Volume)
  39                 self.muteDialog = self.session.instantiateDialog(Mute)
  40
  41                 self.hideVolTimer = eTimer()
  42                 self.hideVolTimer.timeout.get().append(self.volHide)
  43
  44         def     volUp(self):
  45                 eDVBVolumecontrol.getInstance().volumeUp()
  46                 self.volumeDialog.instance.show()
  47                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
  48                 self.hideVolTimer.start(3000)
  49
  50         def     volDown(self):
  51                 eDVBVolumecontrol.getInstance().volumeDown()
  52                 self.volumeDialog.instance.show()
  53                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
  54                 self.hideVolTimer.start(3000)
  55
  56         def volHide(self):
  57                 self.volumeDialog.instance.hide()
  58
  59         def     volMute(self):
  60                 eDVBVolumecontrol.getInstance().volumeToggleMute()
  61                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
  62
  63                 if (eDVBVolumecontrol.getInstance().isMuted()):
  64                         self.muteDialog.instance.show()
  65                 else:
  66                         self.muteDialog.instance.hide()
  67
  68 class InfoBarShowHide:
  69         """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
  70         fancy animations. """
  71         STATE_HIDDEN = 0
  72         STATE_HIDING = 1
  73         STATE_SHOWING = 2
  74         STATE_SHOWN = 3
  75
  76         def __init__(self):
  77                 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
  78                         {
  79                                 "toggleShow": self.toggleShow,
  80                                 "hide": self.hide,
  81                         })
  82
  83                 self.state = self.STATE_HIDDEN
  84
  85                 self.hideTimer = eTimer()
  86                 self.hideTimer.timeout.get().append(self.doTimerHide)
  87                 #self.hideTimer.start(1000)
  88
  89         def hide(self):
  90                 self.instance.hide()
  91
  92         def doTimerHide(self):
  93                 if self.state == self.STATE_SHOWN:
  94                         self.instance.hide()
  95                         self.state = self.STATE_HIDDEN
  96
  97         def toggleShow(self):
  98                 if self.state == self.STATE_SHOWN:
  99                         self.instance.hide()
 100                         #pls check animation support, sorry
 101 #                       self.startHide()
 102                         self.state = self.STATE_HIDDEN
 103                 else:
 104                         self.instance.show()
 105 #                       self.startShow()
 106                         self.state = self.STATE_SHOWN
 107                         #TODO: make it customizable
 108                         self.hideTimer.start(5000)
 109
 110         def startShow(self):
 111                 self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
 112                 self.state = self.STATE_SHOWN
 113
 114         def startHide(self):
 115                 self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
 116                 self.state = self.STATE_HIDDEN
 117
 118 class NumberZap(Screen):
 119         def quit(self):
 120                 self.Timer.stop()
 121                 self.close()
 122
 123         def keyOK(self):
 124                 self.Timer.stop()
 125                 print "do the action here"
 126                 self.close()
 127
 128         def keyNumberGlobal(self, number):
 129                 self.Timer.start(3000)          #reset timer
 130                 self.field = self.field + str(number)
 131                 self["number"].setText(self.field)
 132                 if len(self.field) >= 4:
 133                         self.keyOK()
 134
 135         def __init__(self, number):
 136                 Screen.__init__(self)
 137                 self.field = str(number)
 138
 139                 self["number"] = Label(self.field)
 140
 141                 self["actions"] = NumberActionMap( [ "SetupActions" ],
 142                         {
 143                                 "cancel": self.quit,
 144                                 "ok": self.keyOK,
 145                                 "1": self.keyNumberGlobal,
 146                                 "2": self.keyNumberGlobal,
 147                                 "3": self.keyNumberGlobal,
 148                                 "4": self.keyNumberGlobal,
 149                                 "5": self.keyNumberGlobal,
 150                                 "6": self.keyNumberGlobal,
 151                                 "7": self.keyNumberGlobal,
 152                                 "8": self.keyNumberGlobal,
 153                                 "9": self.keyNumberGlobal,
 154                                 "0": self.keyNumberGlobal
 155                         })
 156
 157                 self.Timer = eTimer()
 158                 self.Timer.timeout.get().append(self.keyOK)
 159                 self.Timer.start(3000)
 160
 161 class InfoBarPowerKey:
 162         """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
 163
 164         def __init__(self):
 165                 self.powerKeyTimer = eTimer()
 166                 self.powerKeyTimer.timeout.get().append(self.powertimer)
 167                 self["PowerKeyActions"] = ActionMap( ["PowerKeyActions"],
 168                         {
 169                                 "powerdown": self.powerdown,
 170                                 "powerup": self.powerup,
 171                         })
 172
 173         def powertimer(self):
 174                 print "PowerOff - Now!"
 175                 self.quit()
 176
 177         def powerdown(self):
 178                 self.standbyblocked = 0
 179                 self.powerKeyTimer.start(3000)
 180
 181         def powerup(self):
 182                 self.powerKeyTimer.stop()
 183                 if self.standbyblocked == 0:
 184                         self.standbyblocked = 1
 185                         self.session.open(Standby, self)
 186
 187         def quit(self):
 188                 #       self.session.open(Standby, self)
 189                 configfile.save()
 190                 quitMainloop(0)
 191
 192
 193 class InfoBarNumberZap:
 194         """ Handles an initial number for NumberZapping """
 195         def __init__(self):
 196                 self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"],
 197                         {
 198                                 "1": self.keyNumberGlobal,
 199                                 "2": self.keyNumberGlobal,
 200                                 "3": self.keyNumberGlobal,
 201                                 "4": self.keyNumberGlobal,
 202                                 "5": self.keyNumberGlobal,
 203                                 "6": self.keyNumberGlobal,
 204                                 "7": self.keyNumberGlobal,
 205                                 "8": self.keyNumberGlobal,
 206                                 "9": self.keyNumberGlobal,
 207                                 "0": self.keyNumberGlobal,
 208                         })
 209
 210         def keyNumberGlobal(self, number):
 211                 print "You pressed number " + str(number)
 212                 self.session.open(NumberZap, number)
 213
 214 class InfoBarChannelSelection:
 215         """ ChannelSelection - handles the channelSelection dialog and the initial
 216         channelChange actions which open the channelSelection dialog """
 217         def __init__(self):
 218                 #instantiate forever
 219                 self.servicelist = self.session.instantiateDialog(ChannelSelection)
 220
 221                 self["ChannelSelectActions"] = ActionMap( ["InfoBarChannelSelection"],
 222                         {
 223                                 "switchChannelUp": self.switchChannelUp,
 224                                 "switchChannelDown": self.switchChannelDown,
 225                                 "zapUp": self.zapUp,
 226                                 "zapDown": self.zapDown,
 227                         })
 228
 229         def switchChannelUp(self):
 230                 self.servicelist.moveUp()
 231                 self.session.execDialog(self.servicelist)
 232
 233         def switchChannelDown(self):
 234                 self.servicelist.moveDown()
 235                 self.session.execDialog(self.servicelist)
 236
 237         def     zapUp(self):
 238                 self.servicelist.moveUp()
 239                 self.servicelist.zap()
 240
 241         def     zapDown(self):
 242                 self.servicelist.moveDown()
 243                 self.servicelist.zap()
 244
 245 class InfoBarMenu:
 246         """ Handles a menu action, to open the (main) menu """
 247         def __init__(self):
 248                 self["MenuActions"] = ActionMap( [ "InfoBarMenuActions" ],
 249                         {
 250                                 "mainMenu": self.mainMenu,
 251                         })
 252
 253         def mainMenu(self):
 254                 print "loading mainmenu XML..."
 255                 menu = mdom.childNodes[0]
 256                 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
 257                 self.session.open(MainMenu, menu, menu.childNodes)
 258
 259 class InfoBarEPG:
 260         """ EPG - Opens an EPG list when the showEPGList action fires """
 261         def __init__(self):
 262                 self["EPGActions"] = ActionMap( [ "InfobarEPGActions" ],
 263                         {
 264                                 "showEPGList": self.showEPGList,
 265                         })
 266
 267         def showEPGList(self):
 268                 ref=self.session.nav.getCurrentlyPlayingServiceReference()
 269                 ptr=eEPGCache.getInstance()
 270                 if ptr.startTimeQuery(ref) != -1:
 271                         self.session.open(EPGSelection, ref)
 272                 else:
 273                         print 'no epg for service', ref.toString()
 274
 275 class InfoBarEvent:
 276         """provides a current/next event info display"""
 277         def __init__(self):
 278                 self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
 279                 self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
 280
 281                 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
 282                 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
 283
 284                 self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
 285                 self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
 286
 287 class InfoBarServiceName:
 288         def __init__(self):
 289                 self["ServiceName"] = ServiceName(self.session.nav)
 290
 291 class InfoBarPVR:
 292         """handles PVR specific actions like seeking, pause"""
 293         def __init__(self):
 294                 self["PVRActions"] = ActionMap( [ "InfobarPVRActions" ],
 295                         {
 296                                 "pauseService": self.pauseService,
 297                                 "unPauseService": self.unPauseService,
 298
 299                                 "seekFwd": self.seekFwd,
 300                                 "seekBack": self.seekBack,
 301                         })
 302
 303         def pauseService(self):
 304                 self.session.nav.pause(1)
 305
 306         def unPauseService(self):
 307                 self.session.nav.pause(0)
 308
 309         def doSeek(self, dir, seektime):
 310                 service = self.session.nav.getCurrentService()
 311                 if service is None:
 312                         return
 313
 314                 seekable = service.seek()
 315                 if seekable is None:
 316                         return
 317                 seekable.seekRelative(dir, 90 * seektime)
 318
 319         def seekFwd(self):
 320                 self.doSeek(+1, 10000)
 321
 322         def seekBack(self):
 323                 self.doSeek(-1, 10000)
 324
 325 class InfoBarInstantRecord:
 326         """Instant Record - handles the instantRecord action in order to
 327         start/stop instant records"""
 328         def __init__(self):
 329                 self["InstnantRecordActions"] = ActionMap( [ "InfoBarInstantRecord" ],
 330                         {
 331                                 "instantRecord": self.instantRecord,
 332                         })
 333                 self.recording = None
 334
 335         def stopCurrentRecording(self):
 336                 self.session.nav.RecordTimer.removeEntry(self.recording)
 337                 self.recording = None
 338
 339         def startInstantRecording(self):
 340                 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
 341
 342                 # try to get event info
 343                 epg = None
 344                 try:
 345                         service = self.session.nav.getCurrentService()
 346                         info = service.info()
 347                         ev = info.getEvent(0)
 348                         epg = ev
 349                 except:
 350                         pass
 351
 352                 # fix me, description.
 353                 self.recording = self.session.nav.recordWithTimer(time.time(), time.time() + 3600, serviceref, epg, "instant record")
 354
 355         def recordQuestionCallback(self, answer):
 356                 if answer == False:
 357                         return
 358
 359                 if self.recording != None:
 360                         self.stopCurrentRecording()
 361                 else:
 362                         self.startInstantRecording()
 363
 364         def instantRecord(self):
 365                 if self.recording != None:
 366                         self.session.openWithCallback(self.recordQuestionCallback, MessageBox, "Do you want to stop the current\n(instant) recording?")
 367                 else:
 368                         self.session.openWithCallback(self.recordQuestionCallback, MessageBox, "Start recording?")