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