lib/python/Screens/ChannelSelection.py

   1 from Screen import Screen
   2 from Components.Button import Button
   3 from Components.ServiceList import ServiceList
   4 from Components.ActionMap import NumberActionMap, ActionMap
   5 from Components.MenuList import MenuList
   6 from EpgSelection import EPGSelection
   7 from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
   8 from Components.config import config, configElement, ConfigSubsection, configText, currentConfigSelectionElement
   9 from Screens.FixedMenu import FixedMenu
  10 from Tools.NumericalTextInput import NumericalTextInput
  11 from Components.NimManager import nimmanager
  12 from Components.ServiceName import ServiceName
  13 from Components.Clock import Clock
  14 from Components.EventInfo import EventInfo
  15 from Components.Input import Input
  16 from Screens.InputBox import InputBox
  17 from ServiceReference import ServiceReference
  18 from re import *
  19 from os import remove
  20
  21 FLAG_SERVICE_NEW_FOUND = 64 #define in lib/dvb/idvb.h as dxNewFound = 64
  22
  23 import xml.dom.minidom
  24
  25 class BouquetSelector(Screen):
  26         def __init__(self, session, bouquets, selectedFunc, enableWrapAround=False):
  27                 Screen.__init__(self, session)
  28
  29                 self.selectedFunc=selectedFunc
  30
  31                 self["actions"] = ActionMap(["OkCancelActions"],
  32                         {
  33                                 "ok": self.okbuttonClick,
  34                                 "cancel": self.cancelClick
  35                         })
  36                 entrys = [ ]
  37                 for x in bouquets:
  38                         entrys.append((x[0], x[1]))
  39                 self["menu"] = MenuList(entrys, enableWrapAround)
  40
  41         def getCurrent(self):
  42                 cur = self["menu"].getCurrent()
  43                 return cur and cur[1]
  44
  45         def okbuttonClick(self):
  46                 self.selectedFunc(self.getCurrent())
  47
  48         def up(self):
  49                 self["menu"].up()
  50
  51         def down(self):
  52                 self["menu"].down()
  53
  54         def cancelClick(self):
  55                 self.close(False)
  56
  57 class ChannelContextMenu(Screen):
  58         def __init__(self, session, csel):
  59                 Screen.__init__(self, session)
  60                 self.csel = csel
  61                 self.bsel = None
  62
  63                 self["actions"] = ActionMap(["OkCancelActions"],
  64                         {
  65                                 "ok": self.okbuttonClick,
  66                                 "cancel": self.cancelClick
  67                         })
  68                 menu = [ ]
  69
  70                 current_root = csel.getRoot()
  71                 current_sel_path = csel.getCurrentSelection().getPath()
  72                 current_sel_flags = csel.getCurrentSelection().flags
  73                 inBouquetRootList = current_root and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
  74                 inBouquet = csel.getMutableList() is not None
  75                 haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1
  76
  77                 if not csel.bouquet_mark_edit and not csel.movemode:
  78                         if not inBouquetRootList:
  79                                 if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
  80                                         if haveBouquets:
  81                                                 menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
  82                                         else:
  83                                                 menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
  84                                 else:
  85                                         if haveBouquets:
  86                                                 if not inBouquet and current_sel_path.find("PROVIDERS") == -1:
  87                                                         menu.append((_("copy to favourites"), self.copyCurrentToBouquetList))
  88                                         if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
  89                                                 menu.append((_("remove all new found flags"), self.removeAllNewFoundFlags))
  90                                 if inBouquet:
  91                                         menu.append((_("remove service"), self.removeCurrentService))
  92                                 if current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
  93                                         menu.append((_("remove new found flag"), self.removeNewFoundFlag))
  94                         elif haveBouquets:
  95                                 menu.append((_("remove bouquet"), self.removeBouquet))
  96
  97                 if inBouquet: # current list is editable?
  98                         if not csel.bouquet_mark_edit:
  99                                 if not csel.movemode:
 100                                         menu.append((_("enable move mode"), self.toggleMoveMode))
 101                                         menu.append((_("add bouquet..."), self.showBouquetInputBox))
 102                                         if not inBouquetRootList:
 103                                                 if haveBouquets:
 104                                                         menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
 105                                                 else:
 106                                                         menu.append((_("enable favourite edit"), self.bouquetMarkStart))
 107                                 else:
 108                                         menu.append((_("disable move mode"), self.toggleMoveMode))
 109                         elif not inBouquetRootList:
 110                                 if haveBouquets:
 111                                         menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
 112                                         menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
 113                                 else:
 114                                         menu.append((_("end favourites edit"), self.bouquetMarkEnd))
 115                                         menu.append((_("abort favourites edit"), self.bouquetMarkAbort))
 116
 117                 menu.append((_("back"), self.cancelClick))
 118                 self["menu"] = MenuList(menu)
 119
 120         def okbuttonClick(self):
 121                 self["menu"].getCurrent()[1]()
 122
 123         def cancelClick(self):
 124                 self.close(False)
 125
 126         def showBouquetInputBox(self):
 127                 self.session.openWithCallback(self.bouquetInputCallback, InputBox, title=_("Please enter a name for the new bouquet"), text="bouquetname", maxSize=False, type=Input.TEXT)
 128
 129         def bouquetInputCallback(self, bouquet):
 130                 if bouquet is not None:
 131                         self.csel.addBouquet(bouquet, True)
 132
 133         def addServiceToBouquetSelected(self):
 134                 bouquets = self.csel.getBouquetList()
 135                 if bouquets is None:
 136                         cnt = 0
 137                 else:
 138                         cnt = len(bouquets)
 139                 if cnt > 1: # show bouquet list
 140                         self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
 141                 elif cnt == 1: # add to only one existing bouquet
 142                         self.addCurrentServiceToBouquet(bouquets[0][1])
 143                 else: #no bouquets in root.. so assume only one favourite list is used
 144                         self.addCurrentServiceToBouquet(self.csel.bouquet_root)
 145
 146         def bouquetSelClosed(self, recursive):
 147                 self.bsel = None
 148                 if recursive:
 149                         self.close(False)
 150
 151         def copyCurrentToBouquetList(self):
 152                 self.csel.copyCurrentToBouquetList()
 153                 self.close()
 154
 155         def removeBouquet(self):
 156                 self.csel.removeBouquet()
 157                 self.close()
 158
 159         def addCurrentServiceToBouquet(self, dest):
 160                 self.csel.addCurrentServiceToBouquet(dest)
 161                 if self.bsel is not None:
 162                         self.bsel.close(True)
 163                 else:
 164                         self.close(True) # close bouquet selection
 165
 166         def removeCurrentService(self):
 167                 self.csel.removeCurrentService()
 168                 self.close()
 169
 170         def toggleMoveMode(self):
 171                 self.csel.toggleMoveMode()
 172                 self.close()
 173
 174         def bouquetMarkStart(self):
 175                 self.csel.startMarkedEdit()
 176                 self.close()
 177
 178         def bouquetMarkEnd(self):
 179                 self.csel.endMarkedEdit(abort=False)
 180                 self.close()
 181
 182         def bouquetMarkAbort(self):
 183                 self.csel.endMarkedEdit(abort=True)
 184                 self.close()
 185
 186         def removeNewFoundFlag(self):
 187                 eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
 188                 self.close()
 189
 190         def removeAllNewFoundFlags(self):
 191                 curpath = self.csel.getCurrentSelection().getPath()
 192                 idx = curpath.find("satellitePosition == ")
 193                 if idx != -1:
 194                         tmp = curpath[idx+21:]
 195                         idx = tmp.find(')')
 196                         if idx != -1:
 197                                 satpos = int(tmp[:idx])
 198                                 eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
 199                 self.close()
 200
 201 class ChannelSelectionEPG:
 202         def __init__(self):
 203                 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
 204                         {
 205                                 "showEPGList": self.showEPGList,
 206                         })
 207
 208         def showEPGList(self):
 209                 ref=self.getCurrentSelection()
 210                 ptr=eEPGCache.getInstance()
 211                 if ptr.startTimeQuery(ref) != -1:
 212                         self.session.open(EPGSelection, ref)
 213                 else:
 214                         print 'no epg for service', ref.toString()
 215
 216 class ChannelSelectionEdit:
 217         def __init__(self):
 218                 self.entry_marked = False
 219                 self.movemode = False
 220                 self.bouquet_mark_edit = False
 221                 self.mutableList = None
 222                 self.__marked = [ ]
 223                 self.saved_title = None
 224                 self.saved_root = None
 225
 226                 class ChannelSelectionEditActionMap(ActionMap):
 227                         def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
 228                                 ActionMap.__init__(self, contexts, actions, prio)
 229                                 self.csel = csel
 230
 231                         def action(self, contexts, action):
 232                                 if action == "cancel":
 233                                         self.csel.handleEditCancel()
 234                                         return 0 # fall-trough
 235                                 elif action == "ok":
 236                                         return 0 # fall-trough
 237                                 else:
 238                                         return ActionMap.action(self, contexts, action)
 239
 240                 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
 241                         {
 242                                 "contextMenu": self.doContext,
 243                         })
 244
 245         def getMutableList(self, root=eServiceReference()):
 246                 if not self.mutableList is None:
 247                         return self.mutableList
 248                 serviceHandler = eServiceCenter.getInstance()
 249                 if not root.valid():
 250                         root=self.getRoot()
 251                 list = root and serviceHandler.list(root)
 252                 if list is not None:
 253                         return list.startEdit()
 254                 return None
 255
 256         def buildBouquetID(self, str):
 257                 tmp = str.lower()
 258                 name = ''
 259                 for c in tmp:
 260                         if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
 261                                 name += c
 262                         else:
 263                                 name += '_'
 264                 return name
 265
 266         def addBouquet(self, bName, services, refresh=False):
 267                 serviceHandler = eServiceCenter.getInstance()
 268                 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
 269                 if mutableBouquetList:
 270                         if self.mode == MODE_TV:
 271                                 bName += " (TV)"
 272                                 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
 273                         else:
 274                                 bName += " (Radio)"
 275                                 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
 276                         new_bouquet_ref = eServiceReference(str)
 277                         if not mutableBouquetList.addService(new_bouquet_ref):
 278                                 self.bouquetNumOffsetCache = { }
 279                                 mutableBouquetList.flushChanges()
 280                                 eDVBDB.getInstance().reloadBouquets()
 281                                 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
 282                                 if mutableBouquet:
 283                                         mutableBouquet.setListName(bName)
 284                                         if services is not None:
 285                                                 for service in services:
 286                                                         if mutableBouquet.addService(service):
 287                                                                 print "add", service.toString(), "to new bouquet failed"
 288                                         mutableBouquet.flushChanges()
 289                                         if refresh:
 290                                                 self.setRoot(self.getRoot())
 291                                 else:
 292                                         print "get mutable list for new created bouquet failed"
 293                         else:
 294                                 print "add", str, "to bouquets failed"
 295                 else:
 296                         print "bouquetlist is not editable"
 297
 298         def copyCurrentToBouquetList(self):
 299                 provider = ServiceReference(self.getCurrentSelection())
 300                 providerName = provider.getServiceName()
 301                 serviceHandler = eServiceCenter.getInstance()
 302                 services = serviceHandler.list(provider.ref)
 303                 self.addBouquet(providerName, services and services.getContent('R', True))
 304
 305         def removeBouquet(self):
 306                 refstr = self.getCurrentSelection().toString()
 307                 self.bouquetNumOffsetCache = { }
 308                 pos = refstr.find('FROM BOUQUET "')
 309                 if pos != -1:
 310                         refstr = refstr[pos+14:]
 311                         pos = refstr.find('"')
 312                         if pos != -1:
 313                                 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
 314                 self.removeCurrentService()
 315                 try:
 316                         remove(filename)
 317                 except OSError:
 318                         print "error during remove of", filename
 319                 eDVBDB.getInstance().reloadBouquets()
 320
 321 #  multiple marked entry stuff ( edit mode, later multiepg selection )
 322         def startMarkedEdit(self):
 323                 self.mutableList = self.getMutableList()
 324                 # add all services from the current list to internal marked set in listboxservicecontent
 325                 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
 326                 self.saved_title = self.instance.getTitle()
 327                 pos = self.saved_title.find(')')
 328                 new_title = self.saved_title[:pos+1]
 329                 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
 330                         new_title += ' ' + _("[bouquet edit]")
 331                 else:
 332                         new_title += ' ' + _("[favourite edit]")
 333                 self.setTitle(new_title)
 334                 self.bouquet_mark_edit = True
 335                 self.__marked = self.servicelist.getRootServices()
 336                 for x in self.__marked:
 337                         self.servicelist.addMarked(eServiceReference(x))
 338                 self.savedPath = self.servicePath[:]
 339                 self.showAllServices()
 340
 341         def endMarkedEdit(self, abort):
 342                 if not abort and self.mutableList is not None:
 343                         self.bouquetNumOffsetCache = { }
 344                         new_marked = set(self.servicelist.getMarked())
 345                         old_marked = set(self.__marked)
 346                         removed = old_marked - new_marked
 347                         added = new_marked - old_marked
 348                         changed = False
 349                         for x in removed:
 350                                 changed = True
 351                                 self.mutableList.removeService(eServiceReference(x))
 352                         for x in added:
 353                                 changed = True
 354                                 self.mutableList.addService(eServiceReference(x))
 355                         if changed:
 356                                 self.mutableList.flushChanges()
 357                 self.__marked = []
 358                 self.clearMarks()
 359                 self.bouquet_mark_edit = False
 360                 self.mutableList = None
 361                 self.setTitle(self.saved_title)
 362                 self.saved_title = None
 363                 # self.servicePath is just a reference to servicePathTv or Radio...
 364                 # so we never ever do use the asignment operator in self.servicePath
 365                 del self.servicePath[:] # remove all elements
 366                 self.servicePath += self.savedPath # add saved elements
 367                 del self.savedPath
 368                 self.setRoot(self.servicePath[len(self.servicePath)-1])
 369
 370         def clearMarks(self):
 371                 self.servicelist.clearMarks()
 372
 373         def doMark(self):
 374                 ref = self.servicelist.getCurrent()
 375                 if self.servicelist.isMarked(ref):
 376                         self.servicelist.removeMarked(ref)
 377                 else:
 378                         self.servicelist.addMarked(ref)
 379
 380         def removeCurrentService(self):
 381                 ref = self.servicelist.getCurrent()
 382                 mutableList = self.getMutableList()
 383                 if ref.valid() and mutableList is not None:
 384                         if not mutableList.removeService(ref):
 385                                 self.bouquetNumOffsetCache = { }
 386                                 mutableList.flushChanges() #FIXME dont flush on each single removed service
 387                                 self.setRoot(self.getRoot())
 388
 389         def addCurrentServiceToBouquet(self, dest):
 390                 mutableList = self.getMutableList(dest)
 391                 if not mutableList is None:
 392                         if not mutableList.addService(self.servicelist.getCurrent()):
 393                                 self.bouquetNumOffsetCache = { }
 394                                 mutableList.flushChanges()
 395
 396         def toggleMoveMode(self):
 397                 if self.movemode:
 398                         if self.entry_marked:
 399                                 self.toggleMoveMarked() # unmark current entry
 400                         self.movemode = False
 401                         self.pathChangedDisabled = False # re-enable path change
 402                         self.mutableList.flushChanges() # FIXME add check if changes was made
 403                         self.mutableList = None
 404                         self.setTitle(self.saved_title)
 405                         self.saved_title = None
 406                         if self.getRoot() == self.bouquet_root:
 407                                 self.bouquetNumOffsetCache = { }
 408                 else:
 409                         self.mutableList = self.getMutableList()
 410                         self.movemode = True
 411                         self.pathChangedDisabled = True # no path change allowed in movemode
 412                         self.saved_title = self.instance.getTitle()
 413                         new_title = self.saved_title
 414                         pos = self.saved_title.find(')')
 415                         new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
 416                         self.setTitle(new_title);
 417
 418         def handleEditCancel(self):
 419                 if self.movemode: #movemode active?
 420                         self.channelSelected() # unmark
 421                         self.toggleMoveMode() # disable move mode
 422                 elif self.bouquet_mark_edit:
 423                         self.endMarkedEdit(True) # abort edit mode
 424
 425         def toggleMoveMarked(self):
 426                 if self.entry_marked:
 427                         self.servicelist.setCurrentMarked(False)
 428                         self.entry_marked = False
 429                 else:
 430                         self.servicelist.setCurrentMarked(True)
 431                         self.entry_marked = True
 432
 433         def doContext(self):
 434                 self.session.open(ChannelContextMenu, self)
 435
 436 MODE_TV = 0
 437 MODE_RADIO = 1
 438
 439 class ChannelSelectionBase(Screen):
 440         def __init__(self, session):
 441                 Screen.__init__(self, session)
 442
 443                 # this makes it much simple to implement a selectable radio or tv mode :)
 444                 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25)'
 445                 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
 446
 447                 self["key_red"] = Button(_("All"))
 448                 self["key_green"] = Button(_("Satellites"))
 449                 self["key_yellow"] = Button(_("Provider"))
 450                 self["key_blue"] = Button(_("Favourites"))
 451
 452                 self["list"] = ServiceList()
 453                 self.servicelist = self["list"]
 454
 455                 self.numericalTextInput = NumericalTextInput()
 456
 457                 self.servicePathTV = [ ]
 458                 self.servicePathRadio = [ ]
 459                 self.servicePath = [ ]
 460
 461                 self.mode = MODE_TV
 462
 463                 self.pathChangedDisabled = False
 464
 465                 self.bouquetNumOffsetCache = { }
 466
 467                 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
 468                         {
 469                                 "showFavourites": self.showFavourites,
 470                                 "showAllServices": self.showAllServices,
 471                                 "showProviders": self.showProviders,
 472                                 "showSatellites": self.showSatellites,
 473                                 "nextBouquet": self.nextBouquet,
 474                                 "prevBouquet": self.prevBouquet,
 475                                 "1": self.keyNumberGlobal,
 476                                 "2": self.keyNumberGlobal,
 477                                 "3": self.keyNumberGlobal,
 478                                 "4": self.keyNumberGlobal,
 479                                 "5": self.keyNumberGlobal,
 480                                 "6": self.keyNumberGlobal,
 481                                 "7": self.keyNumberGlobal,
 482                                 "8": self.keyNumberGlobal,
 483                                 "9": self.keyNumberGlobal,
 484                                 "0": self.keyNumber0
 485                         })
 486
 487         def appendDVBTypes(self, ref):
 488                 path = ref.getPath()
 489                 pos = path.find(' FROM BOUQUET')
 490                 if pos != -1:
 491                         return eServiceReference(self.service_types + path[pos:])
 492                 return ref
 493
 494         def getBouquetNumOffset(self, bouquet):
 495                 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
 496                         return 0
 497                 bouquet = self.appendDVBTypes(bouquet)
 498                 try:
 499                         return self.bouquetNumOffsetCache[bouquet.toString()]
 500                 except:
 501                         offsetCount = 0
 502                         serviceHandler = eServiceCenter.getInstance()
 503                         bouquetlist = serviceHandler.list(self.bouquet_root)
 504                         if not bouquetlist is None:
 505                                 while True:
 506                                         bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
 507                                         if not bouquetIterator.valid(): #end of list
 508                                                 break
 509                                         self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
 510                                         if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
 511                                                 continue
 512                                         servicelist = serviceHandler.list(bouquetIterator)
 513                                         if not servicelist is None:
 514                                                 while True:
 515                                                         serviceIterator = servicelist.getNext()
 516                                                         if not serviceIterator.valid(): #check if end of list
 517                                                                 break
 518                                                         if serviceIterator.flags: #playable services have no flags
 519                                                                 continue
 520                                                         offsetCount += 1
 521                 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
 522
 523         def recallBouquetMode(self):
 524                 if self.mode == MODE_TV:
 525                         self.service_types = self.service_types_tv
 526                         if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
 527                                 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
 528                         else:
 529                                 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
 530                 else:
 531                         self.service_types = self.service_types_radio
 532                         if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
 533                                 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
 534                         else:
 535                                 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
 536                 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
 537
 538         def setTvMode(self):
 539                 self.mode = MODE_TV
 540                 self.servicePath = self.servicePathTV
 541                 self.recallBouquetMode()
 542                 title = self.instance.getTitle()
 543                 pos = title.find(" (")
 544                 if pos != -1:
 545                         title = title[:pos]
 546                 title += " (TV)"
 547                 self.setTitle(title)
 548
 549         def setRadioMode(self):
 550                 self.mode = MODE_RADIO
 551                 self.servicePath = self.servicePathRadio
 552                 self.recallBouquetMode()
 553                 title = self.instance.getTitle()
 554                 pos = title.find(" (")
 555                 if pos != -1:
 556                         title = title[:pos]
 557                 title += " (Radio)"
 558                 self.setTitle(title)
 559
 560         def setRoot(self, root, justSet=False):
 561                 path = root.getPath()
 562                 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
 563                 pos = path.find(' FROM BOUQUET')
 564                 isBouquet = pos != -1
 565                 if not inBouquetRootList and isBouquet:
 566                         self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
 567                         self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
 568                         refstr = self.service_types + path[pos:]
 569                         root = eServiceReference(refstr)
 570                 else:
 571                         self.servicelist.setMode(ServiceList.MODE_NORMAL)
 572                 self.servicelist.setRoot(root, justSet)
 573                 self.buildTitleString()
 574
 575         def removeModeStr(self, str):
 576                 if self.mode == MODE_TV:
 577                         pos = str.find(' (TV)')
 578                 else:
 579                         pos = str.find(' (Radio)')
 580                 if pos != -1:
 581                         return str[:pos]
 582                 return str
 583
 584         def getServiceName(self, ref):
 585                 str = self.removeModeStr(ServiceReference(ref).getServiceName())
 586                 if not len(str):
 587                         pathstr = ref.getPath()
 588                         if pathstr.find('FROM PROVIDERS') != -1:
 589                                 return _("Provider")
 590                         if pathstr.find('FROM SATELLITES') != -1:
 591                                 return _("Satellites")
 592                         if pathstr.find(') ORDER BY name') != -1:
 593                                 return _("All")
 594                 return str
 595
 596         def buildTitleString(self):
 597                 titleStr = self.instance.getTitle()
 598                 pos = titleStr.find(']')
 599                 if pos == -1:
 600                         pos = titleStr.find(')')
 601                 if pos != -1:
 602                         titleStr = titleStr[:pos+1]
 603                         Len = len(self.servicePath)
 604                         if Len > 0:
 605                                 base_ref = self.servicePath[0]
 606                                 if Len > 1:
 607                                         end_ref = self.servicePath[Len-1]
 608                                 else:
 609                                         end_ref = None
 610                                 nameStr = self.getServiceName(base_ref)
 611                                 titleStr += ' ' + nameStr
 612                                 if end_ref is not None:
 613                                         if Len > 2:
 614                                                 titleStr += '/../'
 615                                         else:
 616                                                 titleStr += '/'
 617                                         nameStr = self.getServiceName(end_ref)
 618                                         titleStr += nameStr
 619                                 self.setTitle(titleStr)
 620
 621         def moveUp(self):
 622                 self.servicelist.moveUp()
 623
 624         def moveDown(self):
 625                 self.servicelist.moveDown()
 626
 627         def clearPath(self):
 628                 del self.servicePath[:]
 629
 630         def enterPath(self, ref, justSet=False):
 631                 self.servicePath.append(ref)
 632                 self.setRoot(ref, justSet)
 633
 634         def pathUp(self, justSet=False):
 635                 prev = self.servicePath.pop()
 636                 length = len(self.servicePath)
 637                 if length:
 638                         current = self.servicePath[length-1]
 639                         self.setRoot(current, justSet)
 640                         if not justSet:
 641                                 self.setCurrentSelection(prev)
 642                 return prev
 643
 644         def isBasePathEqual(self, ref):
 645                 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
 646                         return True
 647                 return False
 648
 649         def isPrevPathEqual(self, ref):
 650                 length = len(self.servicePath)
 651                 if length > 1 and self.servicePath[length-2] == ref:
 652                         return True
 653                 return False
 654
 655         def preEnterPath(self, refstr):
 656                 return False
 657
 658         def showAllServices(self):
 659                 if not self.pathChangedDisabled:
 660                         refstr = '%s ORDER BY name'%(self.service_types)
 661                         if not self.preEnterPath(refstr):
 662                                 ref = eServiceReference(refstr)
 663                                 currentRoot = self.getRoot()
 664                                 if currentRoot is None or currentRoot != ref:
 665                                         self.clearPath()
 666                                         self.enterPath(ref)
 667
 668         def showSatellites(self):
 669                 if not self.pathChangedDisabled:
 670                         refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
 671                         if not self.preEnterPath(refstr):
 672                                 ref = eServiceReference(refstr)
 673                                 justSet=False
 674                                 prev = None
 675
 676                                 if self.isBasePathEqual(ref):
 677                                         if self.isPrevPathEqual(ref):
 678                                                 justSet=True
 679                                         prev = self.pathUp(justSet)
 680                                 else:
 681                                         currentRoot = self.getRoot()
 682                                         if currentRoot is None or currentRoot != ref:
 683                                                 justSet=True
 684                                                 self.clearPath()
 685                                                 self.enterPath(ref, True)
 686                                 if justSet:
 687                                         serviceHandler = eServiceCenter.getInstance()
 688                                         servicelist = serviceHandler.list(ref)
 689                                         if not servicelist is None:
 690                                                 while True:
 691                                                         service = servicelist.getNext()
 692                                                         if not service.valid(): #check if end of list
 693                                                                 break
 694                                                         orbpos = service.getUnsignedData(4) >> 16
 695                                                         if service.getPath().find("FROM PROVIDER") != -1:
 696                                                                 service_name = _("Providers")
 697                                                         elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
 698                                                                 service_name = _("New")
 699                                                         else:
 700                                                                 service_name = _("Services")
 701                                                         try:
 702                                                                 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
 703                                                                 service.setName(service_name) # why we need this cast?
 704                                                         except:
 705                                                                 if orbpos == 0xFFFF: #Cable
 706                                                                         n = ("%s (%s)") % (service_name, _("Cable"))
 707                                                                 elif orbpos == 0xEEEE: #Terrestrial
 708                                                                         n = ("%s (%s)") % (service_name, _("Terrestrial"))
 709                                                                 else:
 710                                                                         if orbpos > 1800: # west
 711                                                                                 orbpos = 3600 - orbpos
 712                                                                                 h = _("W")
 713                                                                         else:
 714                                                                                 h = _("E")
 715                                                                         n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
 716                                                                 service.setName(n)
 717                                                         self.servicelist.addService(service)
 718                                                         self.servicelist.finishFill()
 719                                                         if prev is not None:
 720                                                                 self.setCurrentSelection(prev)
 721
 722         def showProviders(self):
 723                 if not self.pathChangedDisabled:
 724                         refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
 725                         if not self.preEnterPath(refstr):
 726                                 ref = eServiceReference(refstr)
 727                                 if self.isBasePathEqual(ref):
 728                                         self.pathUp()
 729                                 else:
 730                                         currentRoot = self.getRoot()
 731                                         if currentRoot is None or currentRoot != ref:
 732                                                 self.clearPath()
 733                                                 self.enterPath(ref)
 734
 735         def changeBouquet(self, direction):
 736                 if not self.pathChangedDisabled:
 737                         if self.isBasePathEqual(self.bouquet_root):
 738                                 self.pathUp()
 739                                 if direction < 0:
 740                                         self.moveUp()
 741                                 else:
 742                                         self.moveDown()
 743                                 ref = self.getCurrentSelection()
 744                                 self.enterPath(ref)
 745
 746         def inBouquet(self):
 747                 return self.isBasePathEqual(self.bouquet_root)
 748
 749         def atBegin(self):
 750                 return self.servicelist.atBegin()
 751
 752         def atEnd(self):
 753                 return self.servicelist.atEnd()
 754
 755         def nextBouquet(self):
 756                 self.changeBouquet(+1)
 757
 758         def prevBouquet(self):
 759                 self.changeBouquet(-1)
 760
 761         def showFavourites(self):
 762                 if not self.pathChangedDisabled:
 763                         if not self.preEnterPath(self.bouquet_rootstr):
 764                                 if self.isBasePathEqual(self.bouquet_root):
 765                                         self.pathUp()
 766                                 else:
 767                                         currentRoot = self.getRoot()
 768                                         if currentRoot is None or currentRoot != self.bouquet_root:
 769                                                 self.clearPath()
 770                                                 self.enterPath(self.bouquet_root)
 771
 772         def keyNumberGlobal(self, number):
 773                 char = self.numericalTextInput.getKey(number)
 774                 self.servicelist.moveToChar(char)
 775
 776         def getRoot(self):
 777                 return self.servicelist.getRoot()
 778
 779         def getCurrentSelection(self):
 780                 return self.servicelist.getCurrent()
 781
 782         def setCurrentSelection(self, service):
 783                 servicepath = service.getPath()
 784                 pos = servicepath.find(" FROM BOUQUET")
 785                 if pos != -1:
 786                         if self.mode == MODE_TV:
 787                                 servicepath = '(type == 1)' + servicepath[pos:]
 788                         else:
 789                                 servicepath = '(type == 2)' + servicepath[pos:]
 790                         service.setPath(servicepath)
 791                 self.servicelist.setCurrent(service)
 792
 793         def getBouquetList(self):
 794                 serviceCount=0
 795                 bouquets = [ ]
 796                 serviceHandler = eServiceCenter.getInstance()
 797                 list = serviceHandler.list(self.bouquet_root)
 798                 if not list is None:
 799                         while True:
 800                                 s = list.getNext()
 801                                 if not s.valid():
 802                                         break
 803                                 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
 804                                         info = serviceHandler.info(s)
 805                                         if not info is None:
 806                                                 bouquets.append((info.getName(s), s))
 807                                 else:
 808                                         serviceCount += 1
 809                         if len(bouquets) == 0 and serviceCount > 0:
 810                                 info = serviceHandler.info(self.bouquet_root)
 811                                 if not info is None:
 812                                         bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
 813                         return bouquets
 814                 return None
 815
 816         def keyNumber0(self, num):
 817                 if len(self.servicePath) > 1:
 818                         self.keyGoUp()
 819                 else:
 820                         self.keyNumberGlobal(num)
 821
 822         def keyGoUp(self):
 823                 if len(self.servicePath) > 1:
 824                         if self.isBasePathEqual(self.bouquet_root):
 825                                 self.showFavourites()
 826                         else:
 827                                 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
 828                                 if self.isBasePathEqual(ref):
 829                                         self.showSatellites()
 830                                 else:
 831                                         ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
 832                                         if self.isBasePathEqual(ref):
 833                                                 self.showProviders()
 834                                         else:
 835                                                 self.showAllServices()
 836
 837 HISTORYSIZE = 20
 838
 839 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
 840         def __init__(self, session):
 841                 ChannelSelectionBase.__init__(self,session)
 842                 ChannelSelectionEdit.__init__(self)
 843                 ChannelSelectionEPG.__init__(self)
 844
 845                 #config for lastservice
 846                 config.tv = ConfigSubsection();
 847                 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
 848                 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
 849
 850                 self["actions"] = ActionMap(["OkCancelActions"],
 851                         {
 852                                 "cancel": self.cancel,
 853                                 "ok": self.channelSelected,
 854                         })
 855                 self.onShown.append(self.__onShown)
 856
 857                 self.lastChannelRootTimer = eTimer()
 858                 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
 859                 self.lastChannelRootTimer.start(100,True)
 860
 861                 self.history = [ ]
 862                 self.history_pos = 0
 863
 864         def __onCreate(self):
 865                 self.setTvMode()
 866                 self.restoreRoot()
 867                 lastservice=eServiceReference(config.tv.lastservice.value)
 868                 if lastservice.valid():
 869                         self.setCurrentSelection(lastservice)
 870                         self.zap()
 871
 872         def __onShown(self):
 873                 self.recallBouquetMode()
 874                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
 875                 if ref is not None and ref.valid() and ref.getPath() == "":
 876                         self.servicelist.setPlayableIgnoreService(ref)
 877                 else:
 878                         self.servicelist.setPlayableIgnoreService(eServiceReference())
 879
 880         def channelSelected(self):
 881                 ref = self.getCurrentSelection()
 882                 if self.movemode:
 883                         self.toggleMoveMarked()
 884                 elif (ref.flags & 7) == 7:
 885                         self.enterPath(ref)
 886                 elif self.bouquet_mark_edit:
 887                         self.doMark()
 888                 else:
 889                         self.zap()
 890                         self.close(ref)
 891
 892         #called from infoBar and channelSelected
 893         def zap(self):
 894                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
 895                 nref = self.getCurrentSelection()
 896                 if ref is None or ref != nref:
 897                         self.session.nav.playService(nref)
 898                 self.saveRoot()
 899                 self.saveChannel()
 900                 self.addToHistory(nref)
 901
 902         def addToHistory(self, ref):
 903                 if self.servicePath is not None:
 904                         tmp=self.servicePath[:]
 905                         tmp.append(ref)
 906                         try:
 907                                 del self.history[self.history_pos+1:]
 908                         except:
 909                                 pass
 910                         self.history.append(tmp)
 911                         hlen = len(self.history)
 912                         if hlen > HISTORYSIZE:
 913                                 del self.history[0]
 914                                 hlen -= 1
 915                         self.history_pos = hlen-1
 916
 917         def historyBack(self):
 918                 hlen = len(self.history)
 919                 if hlen > 1 and self.history_pos > 0:
 920                         self.history_pos -= 1
 921                         self.setHistoryPath()
 922
 923         def historyNext(self):
 924                 hlen = len(self.history)
 925                 if hlen > 1 and self.history_pos < (hlen-1):
 926                         self.history_pos += 1
 927                         self.setHistoryPath()
 928
 929         def setHistoryPath(self):
 930                 path = self.history[self.history_pos][:]
 931                 ref = path.pop()
 932                 del self.servicePath[:]
 933                 self.servicePath += path
 934                 self.saveRoot()
 935                 plen = len(path)
 936                 root = path[plen-1]
 937                 if self.getRoot() != root:
 938                         self.setRoot(root)
 939                 self.session.nav.playService(ref)
 940                 self.setCurrentSelection(ref)
 941                 self.saveChannel()
 942
 943         def saveRoot(self):
 944                 path = ''
 945                 for i in self.servicePathTV:
 946                         path += i.toString()
 947                         path += ';'
 948                 if len(path) and path != config.tv.lastroot.value:
 949                         config.tv.lastroot.value = path
 950                         config.tv.lastroot.save()
 951
 952         def restoreRoot(self):
 953                 self.clearPath()
 954                 re = compile('.+?;')
 955                 tmp = re.findall(config.tv.lastroot.value)
 956                 cnt = 0
 957                 for i in tmp:
 958                         self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
 959                         cnt += 1
 960                 if cnt:
 961                         path = self.servicePathTV.pop()
 962                         self.enterPath(path)
 963                 else:
 964                         self.showFavourites()
 965                         self.saveRoot()
 966
 967         def preEnterPath(self, refstr):
 968                 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
 969                         pathstr = config.tv.lastroot.value
 970                         if pathstr is not None and pathstr.find(refstr) == 0:
 971                                 self.restoreRoot()
 972                                 lastservice=eServiceReference(config.tv.lastservice.value)
 973                                 if lastservice.valid():
 974                                         self.setCurrentSelection(lastservice)
 975                                 return True
 976                 return False
 977
 978         def saveChannel(self):
 979                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
 980                 if ref is not None:
 981                         refstr = ref.toString()
 982                 else:
 983                         refstr = ""
 984                 if refstr != config.tv.lastservice.value:
 985                         config.tv.lastservice.value = refstr
 986                         config.tv.lastservice.save()
 987
 988         def recallPrevService(self):
 989                 hlen = len(self.history)
 990                 if hlen > 1:
 991                         if self.history_pos == hlen-1:
 992                                 tmp = self.history[self.history_pos]
 993                                 self.history[self.history_pos] = self.history[self.history_pos-1]
 994                                 self.history[self.history_pos-1] = tmp
 995                         else:
 996                                 tmp = self.history[self.history_pos+1]
 997                                 self.history[self.history_pos+1] = self.history[self.history_pos]
 998                                 self.history[self.history_pos] = tmp
 999                         self.setHistoryPath()
1000
1001         def cancel(self):
1002                 self.close(None)
1003                 self.restoreRoot()
1004                 lastservice=eServiceReference(config.tv.lastservice.value)
1005                 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1006                         self.setCurrentSelection(lastservice)
1007
1008 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
1009
1010 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
1011         def __init__(self, session):
1012                 Screen.__init__(self, session)
1013                 InfoBarEvent.__init__(self)
1014                 InfoBarServiceName.__init__(self)
1015                 InfoBarInstantRecord.__init__(self)
1016                 self["Clock"] = Clock()
1017
1018 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
1019         def __init__(self, session):
1020                 ChannelSelectionBase.__init__(self, session)
1021                 ChannelSelectionEdit.__init__(self)
1022                 ChannelSelectionEPG.__init__(self)
1023
1024                 config.radio = ConfigSubsection();
1025                 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
1026                 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
1027                 self.onLayoutFinish.append(self.onCreate)
1028
1029                 self.info = session.instantiateDialog(RadioInfoBar)
1030
1031                 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1032                         {
1033                                 "keyTV": self.closeRadio,
1034                                 "keyRadio": self.closeRadio,
1035                                 "cancel": self.closeRadio,
1036                                 "ok": self.channelSelected,
1037                         })
1038
1039         def saveRoot(self):
1040                 path = ''
1041                 for i in self.servicePathRadio:
1042                         path += i.toString()
1043                         path += ';'
1044                 if len(path) and path != config.radio.lastroot.value:
1045                         config.radio.lastroot.value = path
1046                         config.radio.lastroot.save()
1047
1048         def restoreRoot(self):
1049                 self.clearPath()
1050                 re = compile('.+?;')
1051                 tmp = re.findall(config.radio.lastroot.value)
1052                 cnt = 0
1053                 for i in tmp:
1054                         self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1055                         cnt += 1
1056                 if cnt:
1057                         path = self.servicePathRadio.pop()
1058                         self.enterPath(path)
1059                 else:
1060                         self.showFavourites()
1061                         self.saveRoot()
1062
1063         def preEnterPath(self, refstr):
1064                 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1065                         pathstr = config.radio.lastroot.value
1066                         if pathstr is not None and pathstr.find(refstr) == 0:
1067                                 self.restoreRoot()
1068                                 lastservice=eServiceReference(config.radio.lastservice.value)
1069                                 if lastservice.valid():
1070                                         self.setCurrentSelection(lastservice)
1071                                 return True
1072                 return False
1073
1074         def onCreate(self):
1075                 self.setRadioMode()
1076                 self.restoreRoot()
1077                 lastservice=eServiceReference(config.radio.lastservice.value)
1078                 if lastservice.valid():
1079                         self.servicelist.setCurrent(lastservice)
1080                         self.session.nav.playService(lastservice)
1081                         self.servicelist.setPlayableIgnoreService(lastservice)
1082                 self.info.show()
1083
1084         def channelSelected(self): # just return selected service
1085                 ref = self.getCurrentSelection()
1086                 if self.movemode:
1087                         self.toggleMoveMarked()
1088                 elif (ref.flags & 7) == 7:
1089                         self.enterPath(ref)
1090                 elif self.bouquet_mark_edit:
1091                         self.doMark()
1092                 else:
1093                         playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1094                         if playingref is None or playingref != ref:
1095                                 self.session.nav.playService(ref)
1096                                 self.servicelist.setPlayableIgnoreService(ref)
1097                                 config.radio.lastservice.value = ref.toString()
1098                                 config.radio.lastservice.save()
1099                         self.saveRoot()
1100
1101         def closeRadio(self):
1102                 self.info.hide()
1103                 #set previous tv service
1104                 lastservice=eServiceReference(config.tv.lastservice.value)
1105                 self.session.nav.playService(lastservice)
1106                 self.close(None)
1107
1108 class SimpleChannelSelection(ChannelSelectionBase):
1109         def __init__(self, session, title):
1110                 ChannelSelectionBase.__init__(self, session)
1111                 self.title = title
1112                 self.onShown.append(self.__onExecCallback)
1113
1114                 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1115                         {
1116                                 "cancel": self.close,
1117                                 "ok": self.channelSelected,
1118                                 "keyRadio": self.setModeRadio,
1119                                 "keyTV": self.setModeTv,
1120                         })
1121
1122         def __onExecCallback(self):
1123                 self.setTitle(self.title)
1124                 self.setModeTv()
1125
1126         def channelSelected(self): # just return selected service
1127                 ref = self.getCurrentSelection()
1128                 if (ref.flags & 7) == 7:
1129                         self.enterPath(ref)
1130                 else:
1131                         ref = self.getCurrentSelection()
1132                         self.close(ref)
1133
1134         def setModeTv(self):
1135                 self.setTvMode()
1136                 self.showFavourites()
1137
1138         def setModeRadio(self):
1139                 self.setRadioMode()
1140                 self.showFavourites()