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