lib/python/Plugins/Extensions/ZappingAlternatives/plugin.py

   1 from enigma import *
   2 from Screens.Screen import Screen
   3 from Screens.MessageBox import MessageBox
   4 from Components.ActionMap import ActionMap
   5 from Components.Label import Label
   6 from Components.Input import Input
   7 from Components.GUIComponent import *
   8 from Components.Pixmap import Pixmap
   9 from Components.MenuList import MenuList
  10 from Components.FileList import FileEntryComponent, FileList
  11 from Navigation import Navigation
  12 import NavigationInstance
  13 from Screens.ChannelSelection import SimpleChannelSelection
  14 from ServiceReference import ServiceReference
  15 from Plugins.Plugin import PluginDescriptor
  16 from Tools.Directories import resolveFilename, SCOPE_CONFIG
  17 import xml.dom.minidom
  18 from Tools.XMLTools import elementsWithTag
  19
  20 import os
  21
  22 alternatives = {}
  23
  24 def addAlternative(service1, service2):
  25         if not alternatives.has_key(service1):
  26                 alternatives[service1] = []
  27         alternatives[service1].append(service2)
  28         if not alternatives.has_key(service2):
  29                 alternatives[service2] = []
  30         alternatives[service2].append(service1)
  31
  32 def removeAlternative(service1, service2):
  33         alternatives[service1].remove(service2)
  34         alternatives[service2].remove(service1)
  35         if len(alternatives[service1]) == 0:
  36                 del alternatives[service1]
  37         if len(alternatives[service2]) == 0:
  38                 del alternatives[service2]
  39
  40 class AlternativeZapping(Screen):
  41         skin = """
  42                 <screen position="100,100" size="560,400" title="Services alternatives setup..." >
  43                         <widget name="red" position="0,0" size="140,40" backgroundColor="red" halign="center" valign="center" font="Regular;21" />
  44                         <widget name="green" position="140,0" size="140,40" backgroundColor="green" halign="center" valign="center" font="Regular;21" />
  45                         <widget name="yellow" position="280,0" size="140,40" backgroundColor="yellow" halign="center" valign="center" font="Regular;21" />
  46                         <widget name="blue" position="420,0" size="140,40" backgroundColor="blue" halign="center" valign="center" font="Regular;21" />
  47                         <widget name="serviceslist" position="0,40" size="280,360" />
  48                         <widget name="alternativeslist" position="280,40" size="280,360" selectionDisabled="1" />
  49                 </screen>"""
  50         def __init__(self, session):
  51                 self.skin = AlternativeZapping.skin
  52                 Screen.__init__(self, session)
  53
  54                 self.filename = resolveFilename(SCOPE_CONFIG, "alternatives.xml")
  55
  56                 self.red = Label("")
  57                 self["red"] = self.red
  58                 self.green = Label(_("Add service"))
  59                 self["green"] = self.green
  60                 self.yellow = Label("")
  61                 self["yellow"] = self.yellow
  62                 self.blue = Label("")
  63                 self["blue"] = self.blue
  64
  65                 self.alternatives = {}
  66
  67                 self.serviceslist = []
  68                 self.alternativeslist = []
  69
  70                 try:
  71                         self.loadAlternatives()
  72                 except:
  73                         pass
  74                 self["serviceslist"] = MenuList(self.serviceslist)
  75                 self["alternativeslist"] = MenuList(self.alternativeslist)
  76
  77                 self.onShown.append(self.updateServices)
  78                 self.onShown.append(self.updateAlternatives)
  79
  80                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions", "ColorActions"],
  81                 {
  82                         "ok": self.go,
  83                         "cancel": self.go,
  84                         "up": self.up,
  85                         "down": self.down,
  86                         "left": self.left,
  87                         "right": self.right,
  88                         "red": self.redKey,
  89                         "green": self.greenKey,
  90                         "yellow": self.yellowKey,
  91                         "blue": self.blueKey,
  92                 }, -1)
  93
  94         def saveAlternatives(self):
  95                 doc = xml.dom.minidom.Document()
  96                 root_element = doc.createElement('alternatives')
  97                 doc.appendChild(root_element)
  98                 root_element.appendChild(doc.createTextNode("\n"))
  99
 100                 for alternative in self.alternatives.keys():
 101                         t = doc.createTextNode("\t")
 102                         root_element.appendChild(t)
 103                         t = doc.createElement('service')
 104                         t.setAttribute("ref", alternative)
 105                         root_element.appendChild(t)
 106                         t.appendChild(doc.createTextNode("\n"))
 107                         for x in self.alternatives[alternative]:
 108                                 t.appendChild(doc.createTextNode("\t\t"))
 109                                 l = doc.createElement('alternative')
 110                                 l.setAttribute("ref", str(x))
 111                                 t.appendChild(l)
 112                                 t.appendChild(doc.createTextNode("\n"))
 113                         t.appendChild(doc.createTextNode("\t"))
 114                         root_element.appendChild(t)
 115                         t = doc.createTextNode("\n")
 116                         root_element.appendChild(t)
 117                 file = open(self.filename, "w")
 118                 doc.writexml(file)
 119                 file.write("\n")
 120                 file.close()
 121
 122         def loadAlternatives(self):
 123                 self.alternatives = {}
 124                 alternatives = {}
 125                 doc = xml.dom.minidom.parse(self.filename)
 126
 127                 root = doc.childNodes[0]
 128                 for service in elementsWithTag(root.childNodes, 'service'):
 129                         newService = str(service.getAttribute('ref'))
 130                         if not self.alternatives.has_key(newService):
 131                                 self.alternatives[newService] = []
 132                         for alternative in elementsWithTag(service.childNodes, 'alternative'):
 133                                 newAlternative = str(alternative.getAttribute('ref'))
 134                                 self.alternatives[newService].append(newAlternative)
 135                                 addAlternative(newService, newAlternative)
 136
 137         def go(self):
 138                 self.saveAlternatives()
 139                 self.close()
 140
 141         def up(self):
 142                 self["serviceslist"].instance.moveSelection(self["serviceslist"].instance.moveUp)
 143                 self.updateAlternatives()
 144
 145         def down(self):
 146                 self["serviceslist"].instance.moveSelection(self["serviceslist"].instance.moveDown)
 147                 self.updateAlternatives()
 148
 149         def left(self):
 150                 pass
 151
 152         def right(self):
 153                 pass
 154
 155         def redKey(self):
 156                 for x in self.alternatives[self["serviceslist"].getCurrent()[1]]:
 157                         removeAlternative(self["serviceslist"].getCurrent()[1], x)
 158                 if len(self.serviceslist) > 0:
 159                         del self.alternatives[self["serviceslist"].getCurrent()[1]]
 160                 self.updateServices()
 161                 self.updateAlternatives()
 162
 163         def finishedAlternativeSelection(self, args):
 164                 self.alternatives[self["serviceslist"].getCurrent()[1]].append(str(ServiceReference(args)))
 165                 addAlternative(self["serviceslist"].getCurrent()[1], str(ServiceReference(args)))
 166                 self.updateAlternatives()
 167
 168         def updateServices(self):
 169                 self.serviceslist = []
 170
 171                 for x in self.alternatives.keys():
 172                         self.serviceslist.append((ServiceReference(x).getServiceName(), x))
 173
 174                 self["serviceslist"].l.setList(self.serviceslist)
 175                 if len(self.serviceslist) > 0:
 176                         self.yellow.setText(_("Add alternative"))
 177                         self.red.setText(_("Remove service"))
 178                 else:
 179                         self.yellow.setText("")
 180                         self.red.setText("")
 181
 182         def updateAlternatives(self):
 183                 self.alternativeslist = []
 184
 185                 if len(self.serviceslist) > 0:
 186                         alternativelist = self.alternatives[self["serviceslist"].getCurrent()[1]]
 187
 188                         for x in alternativelist:
 189                                 self.alternativeslist.append((ServiceReference(x).getServiceName(), x))
 190
 191                 self["alternativeslist"].l.setList(self.alternativeslist)
 192
 193         def greenKey(self):
 194                 self.session.openWithCallback(self.finishedChannelSelection, SimpleChannelSelection, _("Select reference service"))
 195
 196         def finishedChannelSelection(self, args):
 197                 if not self.alternatives.has_key(str(ServiceReference(args))):
 198                         self.alternatives[str(ServiceReference(args))] = []
 199                 print "alternatives:", self.alternatives
 200                 self.updateServices()
 201                 self.updateAlternatives()
 202
 203         def yellowKey(self):
 204                 if len(self.serviceslist) > 0:
 205                         self.session.openWithCallback(self.finishedAlternativeSelection, SimpleChannelSelection, _("Select alternative service"))
 206
 207         def blueKey(self):
 208                 pass
 209
 210
 211 oldPlayService = NavigationInstance.instance.playService
 212
 213 def playService(self, ref):
 214         if not oldPlayService(ref):
 215                 if alternatives.has_key(str(ServiceReference(ref))):
 216                         for x in alternatives[str(ServiceReference(ref))]:
 217                                 if oldPlayService(ServiceReference(x).ref):
 218                                         return 1
 219                 return 0
 220         return 1
 221
 222 def autostart(reason):
 223         if reason == 0:
 224                 NavigationInstance.instance.playService = type(NavigationInstance.instance.playService)(playService, NavigationInstance, Navigation)
 225
 226 def AlternativeZappingSetup(session):
 227         session.open(AlternativeZapping)
 228
 229 def Plugins():
 230         return [PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart),
 231                         PluginDescriptor(name="Alternative services setup" , description="Defines alternatives for services.", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=AlternativeZappingSetup)]