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