lib/python/Screens/EpgSelection.py

   1 from Screen import Screen
   2 from Components.config import config, ConfigClock
   3 from Components.Button import Button
   4 from Components.Pixmap import Pixmap
   5 from Components.Label import Label
   6 from Components.EpgList import EPGList, EPG_TYPE_SINGLE, EPG_TYPE_SIMILAR, EPG_TYPE_MULTI
   7 from Components.ActionMap import ActionMap
   8 from Components.TimerSanityCheck import TimerSanityCheck
   9 from Screens.TimerEdit import TimerSanityConflict
  10 from Screens.EventView import EventViewSimple
  11 from Screens.MessageBox import MessageBox
  12 from TimeDateInput import TimeDateInput
  13 from enigma import eServiceReference
  14 from RecordTimer import RecordTimerEntry, parseEvent, AFTEREVENT
  15 from TimerEntry import TimerEntry
  16 from ServiceReference import ServiceReference
  17 from time import localtime, time
  18
  19 mepg_config_initialized = False
  20
  21 class EPGSelection(Screen):
  22         ADD_TIMER = 0
  23         REMOVE_TIMER = 1
  24
  25         def __init__(self, session, service, zapFunc=None, eventid=None, bouquetChangeCB=None):
  26                 Screen.__init__(self, session)
  27                 self.bouquetChangeCB = bouquetChangeCB
  28                 self.ask_time = -1 #now
  29                 self["key_red"] = Button("")
  30                 self.closeRecursive = False
  31                 if isinstance(service, str) and eventid != None:
  32                         self.type = EPG_TYPE_SIMILAR
  33                         self["key_yellow"] = Button()
  34                         self["key_blue"] = Button()
  35                         self["key_red"] = Button()
  36                         self.currentService=service
  37                         self.eventid = eventid
  38                         self.zapFunc = None
  39                 elif isinstance(service, eServiceReference) or isinstance(service, str):
  40                         self.type = EPG_TYPE_SINGLE
  41                         self["key_yellow"] = Button()
  42                         self["key_blue"] = Button()
  43                         self.currentService=ServiceReference(service)
  44                         self.zapFunc = None
  45                         self.sort_type = 0
  46                         self.setSortDescription()
  47                 else:
  48                         self.skinName = "EPGSelectionMulti"
  49                         self.type = EPG_TYPE_MULTI
  50                         self["key_yellow"] = Button(_("Prev"))
  51                         self["key_blue"] = Button(_("Next"))
  52                         self["now_button"] = Pixmap()
  53                         self["next_button"] = Pixmap()
  54                         self["more_button"] = Pixmap()
  55                         self["now_button_sel"] = Pixmap()
  56                         self["next_button_sel"] = Pixmap()
  57                         self["more_button_sel"] = Pixmap()
  58                         self["now_text"] = Label()
  59                         self["next_text"] = Label()
  60                         self["more_text"] = Label()
  61                         self["date"] = Label()
  62                         self.services = service
  63                         self.zapFunc = zapFunc
  64
  65                 self["key_green"] = Button(_("Add timer"))
  66                 self.key_green_choice = self.ADD_TIMER
  67                 self["list"] = EPGList(type = self.type, selChangedCB = self.onSelectionChanged, timer = self.session.nav.RecordTimer)
  68
  69                 self["actions"] = ActionMap(["EPGSelectActions", "OkCancelActions"],
  70                         {
  71                                 "cancel": self.closeScreen,
  72                                 "ok": self.eventSelected,
  73                                 "timerAdd": self.timerAdd,
  74                                 "yellow": self.yellowButtonPressed,
  75                                 "blue": self.blueButtonPressed,
  76                                 "info": self.infoKeyPressed,
  77                                 "red": self.zapTo,
  78                                 "input_date_time": self.enterDateTime,
  79                                 "nextBouquet": self.nextBouquet,
  80                                 "prevBouquet": self.prevBouquet
  81                         })
  82                 self["actions"].csel = self
  83
  84                 self.onLayoutFinish.append(self.onCreate)
  85
  86         def nextBouquet(self):
  87                 if self.bouquetChangeCB:
  88                         self.bouquetChangeCB(1, self)
  89
  90         def prevBouquet(self):
  91                 if self.bouquetChangeCB:
  92                         self.bouquetChangeCB(-1, self)
  93
  94         def enterDateTime(self):
  95                 if self.type == EPG_TYPE_MULTI:
  96                         global mepg_config_initialized
  97                         if not mepg_config_initialized:
  98                                 config.misc.prev_mepg_time=ConfigClock(default = time())
  99                                 mepg_config_initialized = True
 100                         self.session.openWithCallback(self.onDateTimeInputClosed, TimeDateInput, config.misc.prev_mepg_time )
 101
 102         def onDateTimeInputClosed(self, ret):
 103                 if len(ret) > 1:
 104                         if ret[0]:
 105                                 self.ask_time=ret[1]
 106                                 self["list"].fillMultiEPG(self.services, ret[1])
 107
 108         def closeScreen(self):
 109                 self.close(self.closeRecursive)
 110
 111         def infoKeyPressed(self):
 112                 cur = self["list"].getCurrent()
 113                 event = cur[0]
 114                 service = cur[1]
 115                 if event is not None:
 116                         if self.type != EPG_TYPE_SIMILAR:
 117                                 self.session.open(EventViewSimple, event, service, self.eventViewCallback, self.openSimilarList)
 118                         else:
 119                                 self.session.open(EventViewSimple, event, service, self.eventViewCallback)
 120
 121         def openSimilarList(self, eventid, refstr):
 122                 self.session.open(EPGSelection, refstr, None, eventid)
 123
 124         def setServices(self, services):
 125                 self.services = services
 126                 self.onCreate()
 127
 128         #just used in multipeg
 129         def onCreate(self):
 130                 l = self["list"]
 131                 l.recalcEntrySize()
 132                 if self.type == EPG_TYPE_MULTI:
 133                         l.fillMultiEPG(self.services, self.ask_time)
 134                 elif self.type == EPG_TYPE_SINGLE:
 135                         l.fillSingleEPG(self.currentService)
 136                 else:
 137                         l.fillSimilarList(self.currentService, self.eventid)
 138
 139         def eventViewCallback(self, setEvent, setService, val):
 140                 l = self["list"]
 141                 old = l.getCurrent()
 142                 if val == -1:
 143                         self.moveUp()
 144                 elif val == +1:
 145                         self.moveDown()
 146                 cur = l.getCurrent()
 147                 if self.type == EPG_TYPE_MULTI and cur[0] is None and cur[1].ref != old[1].ref:
 148                         self.eventViewCallback(setEvent, setService, val)
 149                 else:
 150                         setService(cur[1])
 151                         setEvent(cur[0])
 152
 153         def zapTo(self): # just used in multiepg
 154                 if self.zapFunc and self["key_red"].getText() == "Zap":
 155                         lst = self["list"]
 156                         count = lst.getCurrentChangeCount()
 157                         if count == 0:
 158                                 self.closeRecursive = True
 159                                 ref = lst.getCurrent()[1]
 160                                 self.zapFunc(ref.ref)
 161
 162         def eventSelected(self):
 163                 self.infoKeyPressed()
 164
 165         def yellowButtonPressed(self):
 166                 if self.type == EPG_TYPE_MULTI:
 167                         self["list"].updateMultiEPG(-1)
 168                 elif self.type == EPG_TYPE_SINGLE:
 169                         if self.sort_type == 0:
 170                                 self.sort_type = 1
 171                         else:
 172                                 self.sort_type = 0
 173                         self["list"].sortSingleEPG(self.sort_type)
 174                         self.setSortDescription()
 175
 176         def setSortDescription(self):
 177                 if self.sort_type == 1:
 178                         # TRANSLATORS: This must fit into the header button in the EPG-List
 179                         self["key_yellow"].setText(_("Sort Time"))
 180                 else:
 181                         # TRANSLATORS: This must fit into the header button in the EPG-List
 182                         self["key_yellow"].setText(_("Sort A-Z"))
 183
 184         def blueButtonPressed(self):
 185                 if self.type == EPG_TYPE_MULTI:
 186                         self["list"].updateMultiEPG(1)
 187
 188         def removeTimer(self, timer):
 189                 timer.afterEvent = AFTEREVENT.NONE
 190                 self.session.nav.RecordTimer.removeEntry(timer)
 191                 self["key_green"].setText(_("Add timer"))
 192                 self.key_green_choice = self.ADD_TIMER
 193
 194         def timerAdd(self):
 195                 cur = self["list"].getCurrent()
 196                 event = cur[0]
 197                 serviceref = cur[1]
 198                 if event is None:
 199                         return
 200                 eventid = event.getEventId()
 201                 refstr = serviceref.ref.toString()
 202                 for timer in self.session.nav.RecordTimer.timer_list:
 203                         if timer.eit == eventid and timer.service_ref.ref.toString() == refstr:
 204                                 cb_func = lambda ret : not ret or self.removeTimer(timer)
 205                                 self.session.openWithCallback(cb_func, MessageBox, _("Do you really want to delete %s?") % event.getEventName())
 206                                 break
 207                 else:
 208                         newEntry = RecordTimerEntry(serviceref, checkOldTimers = True, *parseEvent(event))
 209                         self.session.openWithCallback(self.finishedAdd, TimerEntry, newEntry)
 210
 211         def finishedAdd(self, answer):
 212                 print "finished add"
 213                 if answer[0]:
 214                         entry = answer[1]
 215                         simulTimerList = self.session.nav.RecordTimer.record(entry)
 216                         if simulTimerList is not None:
 217                                 if (len(simulTimerList) == 2) and (simulTimerList[1].dontSave) and (simulTimerList[1].autoincrease):
 218                                         simulTimerList[1].end = entry.begin - 30
 219                                         self.session.nav.RecordTimer.timeChanged(simulTimerList[1])
 220                                         self.session.nav.RecordTimer.record(entry)
 221                                 else:
 222                                         self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
 223                         self["key_green"].setText(_("Remove timer"))
 224                         self.key_green_choice = self.REMOVE_TIMER
 225                 else:
 226                         self["key_green"].setText(_("Add timer"))
 227                         self.key_green_choice = self.ADD_TIMER
 228                         print "Timeredit aborted"
 229
 230         def finishSanityCorrection(self, answer):
 231                 self.finishedAdd(answer)
 232
 233         def moveUp(self):
 234                 self["list"].moveUp()
 235
 236         def moveDown(self):
 237                 self["list"].moveDown()
 238
 239         def applyButtonState(self, state):
 240                 if state == 0:
 241                         self["now_button"].hide()
 242                         self["now_button_sel"].hide()
 243                         self["next_button"].hide()
 244                         self["next_button_sel"].hide()
 245                         self["more_button"].hide()
 246                         self["more_button_sel"].hide()
 247                         self["now_text"].hide()
 248                         self["next_text"].hide()
 249                         self["more_text"].hide()
 250                         self["key_red"].setText("")
 251                 else:
 252                         if state == 1:
 253                                 self["key_red"].setText("Zap")
 254                                 self["now_button_sel"].show()
 255                                 self["now_button"].hide()
 256                         else:
 257                                 self["now_button"].show()
 258                                 self["now_button_sel"].hide()
 259                                 self["key_red"].setText("")
 260
 261                         if state == 2:
 262                                 self["next_button_sel"].show()
 263                                 self["next_button"].hide()
 264                         else:
 265                                 self["next_button"].show()
 266                                 self["next_button_sel"].hide()
 267
 268                         if state == 3:
 269                                 self["more_button_sel"].show()
 270                                 self["more_button"].hide()
 271                         else:
 272                                 self["more_button"].show()
 273                                 self["more_button_sel"].hide()
 274
 275         def onSelectionChanged(self):
 276                 cur = self["list"].getCurrent()
 277                 if self.type == EPG_TYPE_MULTI:
 278                         count = self["list"].getCurrentChangeCount()
 279                         if self.ask_time != -1:
 280                                 self.applyButtonState(0)
 281                         elif count > 1:
 282                                 self.applyButtonState(3)
 283                         elif count > 0:
 284                                 self.applyButtonState(2)
 285                         else:
 286                                 self.applyButtonState(1)
 287                         days = [ _("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun") ]
 288                         datestr = ""
 289                         event = cur[0]
 290                         if event is not None:
 291                                 now = time()
 292                                 beg = event.getBeginTime()
 293                                 nowTime = localtime(now)
 294                                 begTime = localtime(beg)
 295                                 if nowTime[2] != begTime[2]:
 296                                         datestr = '%s %d.%d.'%(days[begTime[6]], begTime[2], begTime[1])
 297                                 else:
 298                                         datestr = '%s %d.%d.'%(_("Today"), begTime[2], begTime[1])
 299                         self["date"].setText(datestr)
 300                 else:
 301                         event = cur[0]
 302
 303                 if event is None:
 304                         return
 305
 306                 serviceref = cur[1]
 307                 eventid = event.getEventId()
 308                 refstr = serviceref.ref.toString()
 309                 isRecordEvent = False
 310                 for timer in self.session.nav.RecordTimer.timer_list:
 311                         if timer.eit == eventid and timer.service_ref.ref.toString() == refstr:
 312                                 isRecordEvent = True
 313                                 break
 314                 if isRecordEvent and self.key_green_choice != self.REMOVE_TIMER:
 315                         self["key_green"].setText(_("Remove timer"))
 316                         self.key_green_choice = self.REMOVE_TIMER
 317                 elif not isRecordEvent and self.key_green_choice != self.ADD_TIMER:
 318                         self["key_green"].setText(_("Add timer"))
 319                         self.key_green_choice = self.ADD_TIMER