code.vuplus.com Git - vuplus_dvbapp-plugin/blob - autotimer/src/AutoTimerEditor.py

   1 # -*- coding: UTF-8 -*-
   2 # for localized messages
   3 from . import _
   4
   5 # GUI (Screens)
   6 from Screens.Screen import Screen
   7 from Components.ConfigList import ConfigListScreen
   8 from Screens.ChannelSelection import SimpleChannelSelection
   9 from Screens.EpgSelection import EPGSelection
  10 from Screens.MessageBox import MessageBox
  11 from Screens.ChoiceBox import ChoiceBox
  12
  13 # GUI (Summary)
  14 from Screens.Setup import SetupSummary
  15
  16 # GUI (Components)
  17 from Components.ActionMap import ActionMap
  18 from Components.Button import Button
  19
  20 # Configuration
  21 from Components.config import getConfigListEntry, ConfigEnableDisable, \
  22         ConfigYesNo, ConfigText, ConfigClock, ConfigNumber, ConfigSelection, \
  23         config
  24
  25 # Timer
  26 from RecordTimer import AFTEREVENT
  27
  28 # Needed to convert our timestamp back and forth
  29 from time import localtime, mktime
  30
  31 # Show ServiceName instead of ServiceReference
  32 from ServiceReference import ServiceReference
  33
  34 # addAutotimerFromService
  35 from enigma import eServiceCenter, iServiceInformation
  36
  37 # Default Record Directory
  38 from Tools import Directories
  39
  40 # Tags
  41 from Screens.MovieSelection import getPreferredTagEditor
  42
  43 weekdays = [
  44         ("0", _("Monday")),
  45         ("1", _("Tuesday")),
  46         ("2", _("Wednesday")),
  47         ("3", _("Thursday")),
  48         ("4", _("Friday")),
  49         ("5", _("Saturday")),
  50         ("6", _("Sunday")),
  51         ("weekend", _("Weekend")),
  52         ("weekday", _("Weekday"))
  53 ]
  54
  55 class ExtendedConfigText(ConfigText):
  56         def __init__(self, default = "", fixed_size = True, visible_width = False):
  57                 ConfigText.__init__(self, default = default, fixed_size = fixed_size, visible_width = visible_width)
  58
  59                 # Workaround some characters currently not "typeable" using NumericalTextInput
  60                 mapping = self.mapping
  61                 if len(mapping):
  62                         if "&" not in mapping[0]:
  63                                 mapping[0] += "&"
  64                         if ";" not in mapping[0]:
  65                                 mapping[0] += ";"
  66                         if "%" not in mapping[0]:
  67                                 mapping[0] += "%"
  68
  69 class SimpleBouquetSelection(SimpleChannelSelection):
  70         def __init__(self, session, title):
  71                 SimpleChannelSelection.__init__(self, session, title)
  72                 self.skinName = "SimpleChannelSelection"
  73
  74         def channelSelected(self): # just return selected service
  75                 ref = self.getCurrentSelection()
  76                 if (ref.flags & 7) == 7:
  77                         self.close(ref)
  78                 else:
  79                         # We return the currently active path here
  80                         # Asking the user if this is what he wants might be better though
  81                         self.close(self.servicePath[-1])
  82
  83 class AutoTimerEPGSelection(EPGSelection):
  84         def __init__(self, *args):
  85                 EPGSelection.__init__(self, *args)
  86                 self.skinName = "EPGSelection"
  87
  88         def infoKeyPressed(self):
  89                 self.timerAdd()
  90
  91         def timerAdd(self):
  92                 cur = self["list"].getCurrent()
  93                 evt = cur[0]
  94                 sref = cur[1]
  95                 if not evt:
  96                         return
  97
  98                 addAutotimerFromEvent(self.session, evt = evt, service = sref)
  99
 100 class AutoTimerEditorBase:
 101         """ Base Class for all Editors """
 102         def __init__(self, timer, editingDefaults = False):
 103                 # Keep Timer
 104                 self.timer = timer
 105                 self.editingDefaults = editingDefaults
 106
 107                 # See if we are filtering some strings
 108                 self.excludes = (
 109                         timer.getExcludedTitle(),
 110                         timer.getExcludedShort(),
 111                         timer.getExcludedDescription(),
 112                         timer.getExcludedDays()
 113                 )
 114                 self.includes = (
 115                         timer.getIncludedTitle(),
 116                         timer.getIncludedShort(),
 117                         timer.getIncludedDescription(),
 118                         timer.getIncludedDays()
 119                 )
 120                 if len(self.excludes[0]) or len(self.excludes[1]) \
 121                                 or len(self.excludes[2]) or len(self.excludes[3]) \
 122                                 or len(self.includes[0]) or len(self.includes[1]) \
 123                                 or len(self.includes[2]) or len(self.includes[3]):
 124                         self.filterSet = True
 125                 else:
 126                         self.filterSet = False
 127
 128                 # See if services are restricted
 129                 self.services = timer.getServices()
 130                 self.bouquets = timer.getBouquets()
 131                 if len(self.services) or len(self.bouquets):
 132                         self.serviceRestriction = True
 133                 else:
 134                         self.serviceRestriction = False
 135
 136                 self.createSetup(timer)
 137
 138         def createSetup(self, timer):
 139                 # Name
 140                 self.name = ExtendedConfigText(default = timer.name, fixed_size = False)
 141
 142                 # Match
 143                 self.match = ExtendedConfigText(default = timer.match, fixed_size = False)
 144                 self.match.setUseableChars('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789-_?!.:;,&%()\'"+/$@') # XXX: what exactly is useable? :-)
 145
 146                 # Justplay
 147                 self.justplay = ConfigSelection(choices = [("zap", _("zap")), ("record", _("record"))], default = {0: "record", 1: "zap"}[int(timer.justplay)])
 148
 149                 # Timespan
 150                 now = [x for x in localtime()]
 151                 if timer.hasTimespan():
 152                         default = True
 153                         now[3] = timer.timespan[0][0]
 154                         now[4] = timer.timespan[0][1]
 155                         begin = mktime(now)
 156                         now[3] = timer.timespan[1][0]
 157                         now[4] = timer.timespan[1][1]
 158                         end = mktime(now)
 159                 else:
 160                         default = False
 161                         now[3] = 20
 162                         now[4] = 15
 163                         begin = mktime(now)
 164                         now[3] = 23
 165                         now[4] = 15
 166                         end = mktime(now)
 167                 self.timespan = ConfigEnableDisable(default = default)
 168                 self.timespanbegin = ConfigClock(default = begin)
 169                 self.timespanend = ConfigClock(default = end)
 170
 171                 # Services have their own Screen
 172
 173                 # Offset
 174                 if timer.hasOffset():
 175                         default = True
 176                         begin = timer.getOffsetBegin()
 177                         end = timer.getOffsetEnd()
 178                 else:
 179                         default = False
 180                         begin = 5
 181                         end = 5
 182                 self.offset = ConfigEnableDisable(default = default)
 183                 self.offsetbegin = ConfigNumber(default = begin)
 184                 self.offsetend = ConfigNumber(default = end)
 185
 186                 # AfterEvent
 187                 if timer.hasAfterEvent():
 188                         afterevent = {
 189                                 None: "default",
 190                                 AFTEREVENT.NONE: "nothing",
 191                                 AFTEREVENT.DEEPSTANDBY: "deepstandby",
 192                                 AFTEREVENT.STANDBY: "standby",
 193                                 AFTEREVENT.AUTO: "auto"
 194                         }[timer.afterevent[0][0]]
 195                 else:
 196                         afterevent = "default"
 197                 self.afterevent = ConfigSelection(choices = [("default", _("standard")), ("nothing", _("do nothing")), ("standby", _("go to standby")), ("deepstandby", _("go to deep standby")), ("auto", _("auto"))], default = afterevent)
 198
 199                 # AfterEvent (Timespan)
 200                 if timer.hasAfterEvent() and timer.afterevent[0][1][0] is not None:
 201                         default = True
 202                         now[3] = timer.afterevent[0][1][0][0]
 203                         now[4] = timer.afterevent[0][1][0][1]
 204                         begin = mktime(now)
 205                         now[3] = timer.afterevent[0][1][1][0]
 206                         now[4] = timer.afterevent[0][1][1][1]
 207                         end = mktime(now)
 208                 else:
 209                         default = False
 210                         now[3] = 23
 211                         now[4] = 15
 212                         begin = mktime(now)
 213                         now[3] = 7
 214                         now[4] = 0
 215                         end = mktime(now)
 216                 self.afterevent_timespan = ConfigEnableDisable(default = default)
 217                 self.afterevent_timespanbegin = ConfigClock(default = begin)
 218                 self.afterevent_timespanend = ConfigClock(default = end)
 219
 220                 # Enabled
 221                 self.enabled = ConfigYesNo(default = timer.enabled)
 222
 223                 # Maxduration
 224                 if timer.hasDuration():
 225                         default = True
 226                         duration = timer.getDuration()
 227                 else:
 228                         default = False
 229                         duration =70
 230                 self.duration = ConfigEnableDisable(default = default)
 231                 self.durationlength = ConfigNumber(default = duration)
 232
 233                 # Counter
 234                 if timer.hasCounter():
 235                         default = timer.matchCount
 236                 else:
 237                         default = 0
 238                 self.counter = ConfigNumber(default = default)
 239                 self.counterLeft = ConfigNumber(default = timer.matchLeft)
 240                 selection = [("", _("Never")), ("%m", _("Monthly")), ("%U", _("Weekly (Sunday)")), ("%W", _("Weekly (Monday)"))]
 241                 if timer.getCounterFormatString() not in ["", "%m", "%U", "%W"]:
 242                         selection.append((timer.getCounterFormatString(), _("Custom (%s)") % (timer.getCounterFormatString())))
 243                 self.counterFormatString = ConfigSelection(selection, default = timer.getCounterFormatString())
 244
 245                 # Avoid Duplicate Description
 246                 self.avoidDuplicateDescription = ConfigSelection([
 247                                 ("0", _("No")),
 248                                 ("1", _("On same service")),
 249                                 ("2", _("On any service")),
 250                         ],
 251                         default = str(timer.getAvoidDuplicateDescription())
 252                 )
 253
 254                 # Custom Location
 255                 if timer.hasDestination():
 256                         default = True
 257                 else:
 258                         default = False
 259
 260                 self.useDestination = ConfigYesNo(default = default)
 261
 262                 default = timer.destination or Directories.resolveFilename(Directories.SCOPE_HDD)
 263                 choices = config.movielist.videodirs.value
 264
 265                 if default not in choices:
 266                         choices.append(default)
 267                 self.destination = ConfigSelection(default = default, choices = choices)
 268
 269                 # Tags
 270                 self.timerentry_tags = timer.tags
 271                 self.tags = ConfigSelection(choices = [len(self.timerentry_tags) == 0 and _("None") or ' '.join(self.timerentry_tags)])
 272
 273         def pathSelected(self, res):
 274                 if res is not None:
 275                         if res not in self.destination.choices:
 276                                 self.destination.choices.append(res)
 277                                 self.destination.description[res] = res
 278                         self.destination.value = res
 279
 280         def chooseDestination(self):
 281                 from Screens.LocationBox import MovieLocationBox
 282
 283                 self.session.openWithCallback(
 284                         self.pathSelected,
 285                         MovieLocationBox,
 286                         _("Choose target folder"),
 287                         self.destination.value,
 288                         minFree = 100 # Same requirement as in Screens.TimerEntry
 289                 )
 290
 291         def tagEditFinished(self, ret):
 292                 if ret is not None:
 293                         self.timerentry_tags = ret
 294                         self.tags.setChoices([len(ret) == 0 and _("None") or ' '.join(ret)])
 295
 296         def chooseTags(self):
 297                 preferredTagEditor = getPreferredTagEditor()
 298                 if preferredTagEditor:
 299                         self.session.openWithCallback(
 300                                 self.tagEditFinished,
 301                                 preferredTagEditor,
 302                                 self.timerentry_tags
 303                         )
 304
 305 class AutoTimerEditor(Screen, ConfigListScreen, AutoTimerEditorBase):
 306         """Edit AutoTimer"""
 307
 308         skin = """<screen name="AutoTimerEdit" title="Edit AutoTimer" position="75,155" size="565,280">
 309                 <widget name="config" position="5,5" size="555,225" scrollbarMode="showOnDemand" />
 310                 <ePixmap position="0,235" zPosition="4" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" />
 311                 <ePixmap position="140,235" zPosition="4" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" />
 312                 <ePixmap position="280,235" zPosition="4" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" />
 313                 <ePixmap position="420,235" zPosition="4" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" />
 314                 <widget name="key_red" position="0,235" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 315                 <widget name="key_green" position="140,235" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 316                 <widget name="key_yellow" position="280,235" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 317                 <widget name="key_blue" position="420,235" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 318         </screen>"""
 319
 320         def __init__(self, session, timer, editingDefaults = False):
 321                 Screen.__init__(self, session)
 322
 323                 AutoTimerEditorBase.__init__(self, timer, editingDefaults)
 324
 325                 # Summary
 326                 self.setup_title = _("AutoTimer Editor")
 327                 self.onChangedEntry = []
 328
 329                 # We might need to change shown items, so add some notifiers
 330                 self.timespan.addNotifier(self.reloadList, initial_call = False)
 331                 self.offset.addNotifier(self.reloadList, initial_call = False)
 332                 self.duration.addNotifier(self.reloadList, initial_call = False)
 333                 self.afterevent.addNotifier(self.reloadList, initial_call = False)
 334                 self.afterevent_timespan.addNotifier(self.reloadList, initial_call = False)
 335                 self.counter.addNotifier(self.reloadList, initial_call = False)
 336                 self.useDestination.addNotifier(self.reloadList, initial_call = False)
 337
 338                 self.refresh()
 339
 340                 ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changed)
 341
 342                 # Initialize Buttons
 343                 self["key_red"] = Button(_("Cancel"))
 344                 self["key_green"] = Button(_("OK"))
 345                 self["key_yellow"] = Button()
 346                 self["key_blue"] = Button()
 347
 348                 # Set Button texts
 349                 self.renameServiceButton()
 350                 self.renameFilterButton()
 351
 352                 # Define Actions
 353                 self["actions"] = ActionMap(["SetupActions", "ColorActions"],
 354                         {
 355                                 "cancel": self.cancel,
 356                                 "save": self.maybeSave,
 357                                 "ok": self.ok,
 358                                 "yellow": self.editFilter,
 359                                 "blue": self.editServices
 360                         }, -2
 361                 )
 362
 363                 # Trigger change
 364                 self.changed()
 365
 366                 self.onLayoutFinish.append(self.setCustomTitle)
 367
 368         def setCustomTitle(self):
 369                 self.setTitle(_("Edit AutoTimer"))
 370
 371         def renameFilterButton(self):
 372                 if self.filterSet:
 373                         self["key_yellow"].setText(_("Edit Filters"))
 374                 else:
 375                         self["key_yellow"].setText(_("Add Filters"))
 376
 377         def renameServiceButton(self):
 378                 if self.serviceRestriction:
 379                         self["key_blue"].setText(_("Edit Services"))
 380                 else:
 381                         self["key_blue"].setText(_("Add Services"))
 382
 383         def changed(self):
 384                 for x in self.onChangedEntry:
 385                         try:
 386                                 x()
 387                         except:
 388                                 pass
 389
 390         def getCurrentEntry(self):
 391                 return self["config"].getCurrent()[0]
 392
 393         def getCurrentValue(self):
 394                 return str(self["config"].getCurrent()[1].getText())
 395
 396         def createSummary(self):
 397                 return SetupSummary
 398
 399         def refresh(self):
 400                 # First three entries are only showed when not editing defaults
 401                 self.list = []
 402                 if not self.editingDefaults:
 403                         self.list.extend([
 404                                 getConfigListEntry(_("Enabled"), self.enabled),
 405                                 getConfigListEntry(_("Description"), self.name),
 406                                 getConfigListEntry(_("Match Title"), self.match),
 407                         ])
 408
 409                 self.list.extend([
 410                         getConfigListEntry(_("Timer Type"), self.justplay),
 411                         getConfigListEntry(_("Only match during Timespan"), self.timespan)
 412                 ])
 413
 414                 # Only allow editing timespan when it's enabled
 415                 if self.timespan.value:
 416                         self.list.extend([
 417                                 getConfigListEntry(_("Begin of Timespan"), self.timespanbegin),
 418                                 getConfigListEntry(_("End of Timespan"), self.timespanend)
 419                         ])
 420
 421                 self.list.append(getConfigListEntry(_("Custom offset"), self.offset))
 422
 423                 # Only allow editing offsets when it's enabled
 424                 if self.offset.value:
 425                         self.list.extend([
 426                                 getConfigListEntry(_("Offset before recording (in m)"), self.offsetbegin),
 427                                 getConfigListEntry(_("Offset after recording (in m)"), self.offsetend)
 428                         ])
 429
 430                 self.list.append(getConfigListEntry(_("Set maximum Duration"), self.duration))
 431
 432                 # Only allow editing maxduration when it's enabled
 433                 if self.duration.value:
 434                         self.list.append(getConfigListEntry(_("Maximum Duration (in m)"), self.durationlength))
 435
 436                 self.list.append(getConfigListEntry(_("After event"), self.afterevent))
 437
 438                 # Only allow setting afterevent timespan when afterevent is active
 439                 if self.afterevent.value != "default":
 440                         self.list.append(getConfigListEntry(_("Execute after Event during Timespan"), self.afterevent_timespan))
 441
 442                         # Only allow editing timespan when it's enabled
 443                         if self.afterevent_timespan.value:
 444                                 self.list.extend([
 445                                         getConfigListEntry(_("Begin of after Event Timespan"), self.afterevent_timespanbegin),
 446                                         getConfigListEntry(_("End of after Event Timespan"), self.afterevent_timespanend)
 447                                 ])
 448
 449                 self.list.append(getConfigListEntry(_("Record a maximum of x times"), self.counter))
 450
 451                 # Only allow setting matchLeft when counting hits
 452                 if self.counter.value:
 453                         if not self.editingDefaults:
 454                                 self.list.append(getConfigListEntry(_("Ammount of recordings left"), self.counterLeft))
 455                         self.list.append(getConfigListEntry(_("Reset Count"), self.counterFormatString))
 456
 457                 self.list.append(getConfigListEntry(_("Require Description to be unique"), self.avoidDuplicateDescription))
 458
 459                 # We always add this option though its expert only in enigma2
 460                 self.list.append(getConfigListEntry(_("Use a custom location"), self.useDestination))
 461                 if self.useDestination.value:
 462                         self.list.append(getConfigListEntry(_("Custom Location"), self.destination))
 463
 464                 self.list.append(getConfigListEntry(_("Tags"), self.tags))
 465
 466         def reloadList(self, value):
 467                 self.refresh()
 468                 self["config"].setList(self.list)
 469
 470         def editFilter(self):
 471                 self.session.openWithCallback(
 472                         self.editFilterCallback,
 473                         AutoTimerFilterEditor,
 474                         self.filterSet,
 475                         self.excludes,
 476                         self.includes
 477                 )
 478
 479         def editFilterCallback(self, ret):
 480                 if ret:
 481                         self.filterSet = ret[0]
 482                         self.excludes = ret[1]
 483                         self.includes = ret[2]
 484                         self.renameFilterButton()
 485
 486         def editServices(self):
 487                 self.session.openWithCallback(
 488                         self.editServicesCallback,
 489                         AutoTimerServiceEditor,
 490                         self.serviceRestriction,
 491                         self.services,
 492                         self.bouquets
 493                 )
 494
 495         def editServicesCallback(self, ret):
 496                 if ret:
 497                         self.serviceRestriction = ret[0]
 498                         self.services = ret[1][0]
 499                         self.bouquets = ret[1][1]
 500                         self.renameServiceButton()
 501
 502         def ok(self):
 503                 cur = self["config"].getCurrent()
 504                 cur = cur and cur[1]
 505                 if cur == self.destination:
 506                         self.chooseDestination()
 507                 elif cur == self.tags:
 508                         self.chooseTags()
 509                 else:
 510                         ConfigListScreen.keyOK(self)
 511
 512         def cancel(self):
 513                 if self["config"].isChanged():
 514                         self.session.openWithCallback(
 515                                 self.cancelConfirm,
 516                                 MessageBox,
 517                                 _("Really close without saving settings?")
 518                         )
 519                 else:
 520                         self.close(None)
 521
 522         def cancelConfirm(self, ret):
 523                 if ret:
 524                         self.close(None)
 525
 526         def maybeSave(self):
 527                 # Check if any match is set
 528                 if not self.match.value.strip():
 529                         self.session.open(
 530                                         MessageBox,
 531                                         _("The match attribute is mandatory."),
 532                                         type = MessageBox.TYPE_ERROR,
 533                                         timeout = 5
 534                         )
 535                 # Check if we have a trailing whitespace
 536                 elif self.match.value[-1:] == " ":
 537                         self.session.openWithCallback(
 538                                 self.saveCallback,
 539                                 MessageBox,
 540                                 _('You entered "%s" as Text to match.\nDo you want to remove trailing whitespaces?') % (self.match.value)
 541                         )
 542                 # Just save else
 543                 else:
 544                         self.save()
 545
 546         def saveCallback(self, ret):
 547                 if ret is not None:
 548                         if ret:
 549                                 self.match.value = self.match.value.rstrip()
 550                         self.save()
 551                 # Don't to anything if MessageBox was canceled!
 552
 553         def save(self):
 554                 # Match
 555                 self.timer.match = self.match.value
 556
 557                 # Name
 558                 self.timer.name = self.name.value.strip() or self.timer.match
 559
 560                 # Enabled
 561                 self.timer.enabled = self.enabled.value
 562
 563                 # Justplay
 564                 self.timer.justplay = self.justplay.value == "zap"
 565
 566                 # Timespan
 567                 if self.timespan.value:
 568                         start = self.timespanbegin.value
 569                         end = self.timespanend.value
 570                         self.timer.timespan = (start, end)
 571                 else:
 572                         self.timer.timespan = None
 573
 574                 # Services
 575                 if self.serviceRestriction:
 576                         self.timer.services = self.services
 577                         self.timer.bouquets = self.bouquets
 578                 else:
 579                         self.timer.services = None
 580                         self.timer.bouquets = None
 581
 582                 # Offset
 583                 if self.offset.value:
 584                         self.timer.offset = (self.offsetbegin.value*60, self.offsetend.value*60)
 585                 else:
 586                         self.timer.offset = None
 587
 588                 # AfterEvent
 589                 if self.afterevent.value == "default":
 590                         self.timer.afterevent = []
 591                 else:
 592                         afterevent = {
 593                                 "nothing": AFTEREVENT.NONE,
 594                                 "deepstandby": AFTEREVENT.DEEPSTANDBY,
 595                                 "standby": AFTEREVENT.STANDBY,
 596                                 "auto": AFTEREVENT.AUTO
 597                         }[self.afterevent.value]
 598                         # AfterEvent Timespan
 599                         if self.afterevent_timespan.value:
 600                                 start = self.afterevent_timespanbegin.value
 601                                 end = self.afterevent_timespanend.value
 602                                 self.timer.afterevent = [(afterevent, (start, end))]
 603                         else:
 604                                 self.timer.afterevent = [(afterevent, None)]
 605
 606                 # Maxduration
 607                 if self.duration.value:
 608                         self.timer.maxduration = self.durationlength.value*60
 609                 else:
 610                         self.timer.maxduration = None
 611
 612                 # Ex-&Includes
 613                 if self.filterSet:
 614                         self.timer.exclude = self.excludes
 615                         self.timer.include = self.includes
 616                 else:
 617                         self.timer.exclude = None
 618                         self.timer.include = None
 619
 620                 # Counter
 621                 if self.counter.value:
 622                         self.timer.matchCount = self.counter.value
 623                         if self.counterLeft.value <= self.counter.value:
 624                                 self.timer.matchLeft = self.counterLeft.value
 625                         else:
 626                                 self.timer.matchLeft = self.counter.value
 627                         if self.counterFormatString.value:
 628                                 self.timer.matchFormatString = self.counterFormatString.value
 629                         else:
 630                                 self.timer.matchFormatString = ''
 631                 else:
 632                         self.timer.matchCount = 0
 633                         self.timer.matchLeft = 0
 634                         self.timer.matchFormatString = ''
 635
 636                 self.timer.avoidDuplicateDescription = int(self.avoidDuplicateDescription.value)
 637
 638                 if self.useDestination.value:
 639                         self.timer.destination = self.destination.value
 640                 else:
 641                         self.timer.destination = None
 642
 643                 self.timer.tags = self.timerentry_tags
 644
 645                 # Close
 646                 self.close(self.timer)
 647
 648 class AutoTimerFilterEditor(Screen, ConfigListScreen):
 649         """Edit AutoTimer Filter"""
 650
 651         skin = """<screen name="AutoFilterEditor" title="Edit AutoTimer Filters" position="75,150" size="565,245">
 652                 <widget name="config" position="5,5" size="555,200" scrollbarMode="showOnDemand" />
 653                 <ePixmap position="5,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" />
 654                 <ePixmap position="145,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" />
 655                 <ePixmap position="285,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" />
 656                 <ePixmap position="425,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" />
 657                 <widget name="key_red" position="5,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 658                 <widget name="key_green" position="145,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 659                 <widget name="key_yellow" position="285,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 660                 <widget name="key_blue" position="425,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 661         </screen>"""
 662
 663         def __init__(self, session, filterset, excludes, includes):
 664                 Screen.__init__(self, session)
 665
 666                 # Summary
 667                 self.setup_title = _("AutoTimer Filters")
 668                 self.onChangedEntry = []
 669
 670                 self.typeSelection = ConfigSelection(choices = [("title", _("in Title")), ("short", _("in Shortdescription")), ("desc", _("in Description")), ("day", _("on Weekday"))])
 671                 self.typeSelection.addNotifier(self.refresh, initial_call = False)
 672
 673                 self.enabled = ConfigEnableDisable(default = filterset)
 674
 675                 self.excludes = excludes
 676                 self.includes = includes
 677
 678                 self.reloadList()
 679
 680                 ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changed)
 681
 682                 # Initialize Buttons
 683                 self["key_red"] = Button(_("Cancel"))
 684                 self["key_green"] = Button(_("Save"))
 685                 self["key_yellow"] = Button(_("delete"))
 686                 self["key_blue"] = Button(_("New"))
 687
 688                 # Define Actions
 689                 self["actions"] = ActionMap(["SetupActions", "ColorActions"],
 690                         {
 691                                 "cancel": self.cancel,
 692                                 "save": self.save,
 693                                 "yellow": self.remove,
 694                                 "blue": self.new
 695                         }
 696                 )
 697
 698                 # Trigger change
 699                 self.changed()
 700
 701                 self.onLayoutFinish.append(self.setCustomTitle)
 702
 703         def setCustomTitle(self):
 704                 self.setTitle(_("Edit AutoTimer Filters"))
 705
 706
 707         def changed(self):
 708                 for x in self.onChangedEntry:
 709                         try:
 710                                 x()
 711                         except:
 712                                 pass
 713
 714         def getCurrentEntry(self):
 715                 return self["config"].getCurrent()[0]
 716
 717         def getCurrentValue(self):
 718                 return str(self["config"].getCurrent()[1].getText())
 719
 720         def createSummary(self):
 721                 return SetupSummary
 722
 723         def saveCurrent(self):
 724                 del self.excludes[self.idx][:]
 725                 del self.includes[self.idx][:]
 726
 727                 # Warning, accessing a ConfigListEntry directly might be considered evil!
 728
 729                 idx = -1
 730                 for item in self["config"].getList()[:]:
 731                         idx += 1
 732                         # Skip empty entries (and those which are no filters)
 733                         if item[1].value == "" or idx < 2:
 734                                 continue
 735                         elif idx < self.lenExcludes:
 736                                 self.excludes[self.idx].append(item[1].value.encode("UTF-8"))
 737                         else:
 738                                 self.includes[self.idx].append(item[1].value.encode("UTF-8"))
 739
 740         def refresh(self, *args, **kwargs):
 741                 self.saveCurrent()
 742
 743                 self.reloadList()
 744                 self["config"].setList(self.list)
 745
 746         def reloadList(self):
 747                 self.list = [
 748                         getConfigListEntry(_("Enable Filtering"), self.enabled),
 749                         getConfigListEntry(_("Filter"), self.typeSelection)
 750                 ]
 751
 752                 if self.typeSelection.value == "day":
 753                         self.idx = 3
 754
 755                         # Weekdays are presented as ConfigSelection
 756                         self.list.extend([
 757                                 getConfigListEntry(_("Exclude"), ConfigSelection(choices = weekdays, default = x))
 758                                         for x in self.excludes[3]
 759                         ])
 760                         self.lenExcludes = len(self.list)
 761                         self.list.extend([
 762                                 getConfigListEntry(_("Include"), ConfigSelection(choices = weekdays, default = x))
 763                                         for x in self.includes[3]
 764                         ])
 765                         return
 766                 elif self.typeSelection.value == "title":
 767                         self.idx = 0
 768                 elif self.typeSelection.value == "short":
 769                         self.idx = 1
 770                 else: # self.typeSelection.value == "desc":
 771                         self.idx = 2
 772
 773                 self.list.extend([
 774                         getConfigListEntry(_("Exclude"), ExtendedConfigText(default = x, fixed_size = False))
 775                                 for x in self.excludes[self.idx]
 776                 ])
 777                 self.lenExcludes = len(self.list)
 778                 self.list.extend([
 779                         getConfigListEntry(_("Include"), ExtendedConfigText(default = x, fixed_size = False))
 780                                 for x in self.includes[self.idx]
 781                 ])
 782
 783         def remove(self):
 784                 idx = self["config"].getCurrentIndex()
 785                 if idx and idx > 1:
 786                         if idx < self.lenExcludes:
 787                                 self.lenExcludes -= 1
 788
 789                         list = self["config"].getList()
 790                         list.remove(self["config"].getCurrent())
 791                         self["config"].setList(list)
 792
 793         def new(self):
 794                 self.session.openWithCallback(
 795                         self.typeSelected,
 796                         ChoiceBox,
 797                         _("Select type of Filter"),
 798                         [
 799                                 (_("Exclude"), 0),
 800                                 (_("Include"), 1),
 801                         ]
 802                 )
 803
 804         def typeSelected(self, ret):
 805                 if ret is not None:
 806                         list = self["config"].getList()
 807
 808                         if ret[1] == 0:
 809                                 pos = self.lenExcludes
 810                                 self.lenExcludes += 1
 811                                 text = ret[0]
 812                         else:
 813                                 pos = len(self.list)
 814                                 text = ret[0]
 815
 816                         if self.typeSelection.value == "day":
 817                                 entry = getConfigListEntry(text, ConfigSelection(choices = weekdays))
 818                         else:
 819                                 entry = getConfigListEntry(text, ExtendedConfigText(fixed_size = False))
 820
 821                         list.insert(pos, entry)
 822                         self["config"].setList(list)
 823
 824         def cancel(self):
 825                 if self["config"].isChanged():
 826                         self.session.openWithCallback(
 827                                 self.cancelConfirm,
 828                                 MessageBox,
 829                                 _("Really close without saving settings?")
 830                         )
 831                 else:
 832                         self.close(None)
 833
 834         def cancelConfirm(self, ret):
 835                 if ret:
 836                         self.close(None)
 837
 838         def save(self):
 839                 self.refresh()
 840
 841                 self.close((
 842                         self.enabled.value,
 843                         self.excludes,
 844                         self.includes
 845                 ))
 846
 847 class AutoTimerServiceEditor(Screen, ConfigListScreen):
 848         """Edit allowed Services of a AutoTimer"""
 849
 850         skin = """<screen name="AutoTimerServiceEditor" title="Edit AutoTimer Services" position="75,150" size="565,245">
 851                 <widget name="config" position="5,5" size="555,200" scrollbarMode="showOnDemand" />
 852                 <ePixmap position="5,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" />
 853                 <ePixmap position="145,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" />
 854                 <ePixmap position="285,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" />
 855                 <ePixmap position="425,205" zPosition="4" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" />
 856                 <widget name="key_red" position="5,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 857                 <widget name="key_green" position="145,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 858                 <widget name="key_yellow" position="285,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 859                 <widget name="key_blue" position="425,205" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
 860         </screen>"""
 861
 862         def __init__(self, session, servicerestriction, servicelist, bouquetlist):
 863                 Screen.__init__(self, session)
 864
 865                 # Summary
 866                 self.setup_title = _("AutoTimer Services")
 867                 self.onChangedEntry = []
 868
 869                 self.services = (
 870                         servicelist[:],
 871                         bouquetlist[:]
 872                 )
 873
 874                 self.enabled = ConfigEnableDisable(default = servicerestriction)
 875                 self.typeSelection = ConfigSelection(choices = [("channels", _("Channels")), ("bouquets", _("Bouquets"))])
 876                 self.typeSelection.addNotifier(self.refresh, initial_call = False)
 877
 878                 self.reloadList()
 879
 880                 ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changed)
 881
 882                 # Initialize Buttons
 883                 self["key_red"] = Button(_("Cancel"))
 884                 self["key_green"] = Button(_("OK"))
 885                 self["key_yellow"] = Button(_("delete"))
 886                 self["key_blue"] = Button(_("New"))
 887
 888                 # Define Actions
 889                 self["actions"] = ActionMap(["SetupActions", "ColorActions"],
 890                         {
 891                                 "cancel": self.cancel,
 892                                 "save": self.save,
 893                                 "yellow": self.remove,
 894                                 "blue": self.new
 895                         }
 896                 )
 897
 898                 # Trigger change
 899                 self.changed()
 900
 901                 self.onLayoutFinish.append(self.setCustomTitle)
 902
 903         def setCustomTitle(self):
 904                 self.setTitle(_("Edit AutoTimer Services"))
 905
 906         def saveCurrent(self):
 907                 del self.services[self.idx][:]
 908
 909                 # Warning, accessing a ConfigListEntry directly might be considered evil!
 910
 911                 myl = self["config"].getList()[:]
 912                 myl.pop(0) # Enabled
 913                 myl.pop(0) # Type
 914                 for item in myl:
 915                         self.services[self.idx].append(item[1].value)
 916
 917         def refresh(self, *args, **kwargs):
 918                 self.saveCurrent()
 919
 920                 self.reloadList()
 921                 self["config"].setList(self.list)
 922
 923         def reloadList(self):
 924                 self.list = [
 925                         getConfigListEntry(_("Enable Service Restriction"), self.enabled),
 926                         getConfigListEntry(_("Editing"), self.typeSelection)
 927                 ]
 928
 929                 if self.typeSelection.value == "channels":
 930                         self.idx = 0
 931                 else: # self.typeSelection.value == "bouquets":
 932                         self.idx = 1
 933
 934                 self.list.extend([
 935                         getConfigListEntry(_("Record on"), ConfigSelection(choices = [(str(x), ServiceReference(str(x)).getServiceName().replace('\xc2\x86', '').replace('\xc2\x87', ''))]))
 936                                 for x in self.services[self.idx]
 937                 ])
 938
 939         def changed(self):
 940                 for x in self.onChangedEntry:
 941                         try:
 942                                 x()
 943                         except:
 944                                 pass
 945
 946         def getCurrentEntry(self):
 947                 return self["config"].getCurrent()[0]
 948
 949         def getCurrentValue(self):
 950                 return str(self["config"].getCurrent()[1].getText())
 951
 952         def createSummary(self):
 953                 return SetupSummary
 954
 955         def remove(self):
 956                 if self["config"].getCurrentIndex() != 0:
 957                         list = self["config"].getList()
 958                         list.remove(self["config"].getCurrent())
 959                         self["config"].setList(list)
 960
 961         def new(self):
 962                 if self.typeSelection.value == "channels":
 963                         self.session.openWithCallback(
 964                                 self.finishedServiceSelection,
 965                                 SimpleChannelSelection,
 966                                 _("Select channel to record on")
 967                         )
 968                 else: # self.typeSelection.value == "bouquets":
 969                         self.session.openWithCallback(
 970                                 self.finishedServiceSelection,
 971                                 SimpleBouquetSelection,
 972                                 _("Select bouquet to record on")
 973                         )
 974
 975         def finishedServiceSelection(self, *args):
 976                 if len(args):
 977                         list = self["config"].getList()
 978                         sname = args[0].toString()
 979
 980                         if self.typeSelection.value == "channels":
 981                                 # strip all after last : when adding a channel
 982                                 pos = sname.rfind(':')
 983                                 if pos != -1:
 984                                         sname = sname[:pos+1]
 985
 986                         list.append(getConfigListEntry(_("Record on"), ConfigSelection(choices = [(sname, ServiceReference(args[0]).getServiceName().replace('\xc2\x86', '').replace('\xc2\x87', ''))])))
 987                         self["config"].setList(list)
 988
 989         def cancel(self):
 990                 if self["config"].isChanged():
 991                         self.session.openWithCallback(
 992                                 self.cancelConfirm,
 993                                 MessageBox,
 994                                 _("Really close without saving settings?")
 995                         )
 996                 else:
 997                         self.close(None)
 998
 999         def cancelConfirm(self, ret):
1000                 if ret:
1001                         self.close(None)
1002
1003         def save(self):
1004                 self.refresh()
1005
1006                 self.close((
1007                         self.enabled.value,
1008                         self.services
1009                 ))
1010
1011 def addAutotimerFromEvent(session, evt = None, service = None):
1012         from AutoTimerComponent import AutoTimerComponent
1013         from AutoTimerImporter import AutoTimerImporter
1014         from plugin import autotimer
1015
1016         # Create instance if needed
1017         if autotimer is None:
1018                 from AutoTimer import AutoTimer
1019                 autotimer = AutoTimer()
1020                 autotimer.readXml()
1021
1022         match = evt and evt.getEventName() or ""
1023         name = match or "New AutoTimer"
1024         sref = None
1025         if service is not None:
1026                 service = str(service)
1027                 # strip all after last :
1028                 pos = service.rfind(':')
1029                 if pos != -1:
1030                         service = service[:pos+1]
1031
1032                 sref = ServiceReference(service)
1033         if evt:
1034                 # timespan defaults to +- 1h
1035                 begin = evt.getBeginTime()-3600
1036                 end = begin + evt.getDuration()+7200
1037         else:
1038                 begin = end = 0
1039
1040         # XXX: we might want to make sure that we actually collected any data because the importer does not do so :-)
1041
1042         session.openWithCallback(
1043                 importerCallback,
1044                 AutoTimerImporter,
1045                 AutoTimerComponent(
1046                         autotimer.getUniqueId(),                # Id
1047                         name,                                                   # Name
1048                         "",                                                             # Match
1049                         True                                                    # Enabled
1050                 ),
1051                 match,                     # Proposed Match
1052                 begin,                     # Proposed Begin
1053                 end,                       # Proposed End
1054                 None,                      # Proposed Disabled
1055                 sref,                      # Proposed ServiceReference
1056                 None,                  # Proposed afterEvent
1057                 None,                      # Proposed justplay
1058                 None,                      # Proposed dirname, can we get anything useful here?
1059                 []                 #
1060         )
1061
1062 def addAutotimerFromService(session, service = None):
1063         from AutoTimerComponent import AutoTimerComponent
1064         from AutoTimerImporter import AutoTimerImporter
1065         from plugin import autotimer
1066
1067         # Create instance if needed
1068         if autotimer is None:
1069                 from AutoTimer import AutoTimer
1070                 autotimer = AutoTimer()
1071                 autotimer.readXml()
1072
1073         serviceHandler = eServiceCenter.getInstance()
1074         info = serviceHandler.info(service)
1075
1076         match = info and info.getName(service) or ""
1077         name = match or "New AutoTimer"
1078         sref = info and info.getInfoString(service, iServiceInformation.sServiceref)
1079         if sref:
1080                 # strip all after last :
1081                 pos = sref.rfind(':')
1082                 if pos != -1:
1083                         sref = sref[:pos+1]
1084
1085                 sref = ServiceReference(sref)
1086         if info:
1087                 begin = info.getInfo(service, iServiceInformation.sTimeCreate)
1088                 end = begin + info.getLength(service)
1089         else:
1090                 begin = end = 0
1091
1092         from os.path import dirname
1093         path = dirname(service.getPath())
1094         if not path == '/':
1095                 path += '/'
1096
1097         tags = info.getInfoString(service, iServiceInformation.sTags)
1098         tags = tags and tags.split(' ') or []
1099
1100         # XXX: we might want to make sure that we actually collected any data because the importer does not do so :-)
1101
1102         session.openWithCallback(
1103                 importerCallback,
1104                 AutoTimerImporter,
1105                 AutoTimerComponent(
1106                         autotimer.getUniqueId(),                # Id
1107                         name,                                                   # Name
1108                         "",                                                             # Match
1109                         True                                                    # Enabled
1110                 ),
1111                 match,                     # Proposed Match
1112                 begin,                     # Proposed Begin
1113                 end,                       # Proposed End
1114                 None,                      # Proposed Disabled
1115                 sref,                      # Proposed ServiceReference
1116                 None,                  # Proposed afterEvent
1117                 None,                      # Proposed justplay
1118                 path,                      # Proposed dirname
1119                 tags               # Proposed tags
1120         )
1121
1122 def importerCallback(ret):
1123         if ret:
1124                 ret, session = ret
1125
1126                 session.openWithCallback(
1127                         editorCallback,
1128                         AutoTimerEditor,
1129                         ret
1130                 )
1131         else:
1132                 # Remove instance if not running in background
1133                 if not config.plugins.autotimer.autopoll.value:
1134                         from plugin import autotimer
1135                         autotimer = None
1136
1137 def editorCallback(ret):
1138         if ret:
1139                 from plugin import autotimer
1140
1141                 # Create instance if needed (should have been created by addAutotimerFrom* above though)
1142                 if autotimer is None:
1143                         from AutoTimer import AutoTimer
1144                         autotimer = AutoTimer()
1145                         autotimer.readXml()
1146
1147                 autotimer.add(ret)
1148
1149                 # Save modified xml
1150                 autotimer.writeXml()
1151
1152         # Remove instance if not running in background
1153         if not config.plugins.autotimer.autopoll.value:
1154                 autotimer = None
1155