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