class GrowleeConfiguration(Screen, ConfigListScreen):
skin = """
<screen name="GrowleeConfiguration" position="center,center" size="560,400" title="Growlee Setup" >
<ePixmap position="0,0" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" />
<ePixmap position="140,0" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" />
<ePixmap position="280,0" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" />
<ePixmap position="420,0" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" />
<widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget source="key_yellow" render="Label" position="280,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget source="key_blue" render="Label" position="420,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget name="config" position="5,45" size="550,350" scrollbarMode="showOnDemand" />
</screen>"""
def __init__(self, session):
Screen.__init__(self, session)
# Buttons
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self["key_yellow"] = StaticText(_("New"))
self["key_blue"] = StaticText(_("Delete"))
# Summary
self.setup_title = "Growlee Configuration"
self.onChangedEntry = []
# Define Actions
self["setupActions"] = ActionMap(
["SetupActions", "ColorActions"],
{"blue": self.delete, "yellow": self.new, "cancel": self.keyCancel, "save": self.keySave},
)
self.hostElement = NoSave(ConfigSelection(choices=[(x, x.name.value) for x in config.plugins.growlee.hosts]))
self.hostElement.addNotifier(self.setupList, initial_call=False)
ConfigListScreen.__init__(self, [], session=session, on_change=self.changed)
self.cur = self.hostElement.value
# Trigger change
self.setupList()
self.changed()
def delete(self):
from Screens.MessageBox import MessageBox
self.session.openWithCallback(
self.deleteConfirm, MessageBox, _("Really delete this entry?\nIt cannot be recovered!")
)
def deleteConfirm(self, result):
if result and config.plugins.growlee.hostcount.value > 0:
config.plugins.growlee.hostcount.value -= 1
config.plugins.growlee.hosts.remove(self.cur)
self.hostElement.setChoices([(x, x.name.value) for x in config.plugins.growlee.hosts])
self.cur = self.hostElement.value
def new(self):
self.cur = addHost(_("New connection"))
config.plugins.growlee.hostcount.value += 1
self.hostElement.setChoices([(x, x.name.value) for x in config.plugins.growlee.hosts])
self.hostElement.setValue(self.cur)
def changed(self):
for x in self.onChangedEntry:
x()
def setupList(self, *args):
last = self.cur
if self.setupList in last.protocol.notifiers:
last.protocol.removeNotifier(self.setupList)
cur = self.hostElement.value
self.cur = cur
cur.protocol.addNotifier(self.setupList, initial_call=False)
l = [
getConfigListEntry(_("Host"), self.hostElement),
getConfigListEntry(_("Name"), cur.name),
getConfigListEntry(_("Type"), cur.protocol),
getConfigListEntry(_("Minimum Priority"), cur.level),
getConfigListEntry(_("Send Notifications?"), cur.enable_outgoing),
]
proto = cur.protocol.value
if proto == "prowl":
l.append(getConfigListEntry(_("API Key"), cur.password))
else:
if proto != "gntp":
l.append(getConfigListEntry(_("Receive Notifications?"), cur.enable_incoming))
l.append(getConfigListEntry(_("Address"), cur.address))
if proto == "growl" or proto == "gntp":
l.append(getConfigListEntry(_("Password"), cur.password))
self["config"].list = l
def getCurrentEntry(self):
cur = self["config"].getCurrent()
return cur and cur[0]
def getCurrentValue(self):
cur = self["config"].getCurrent()
return cur and str(cur[1].getText())
def createSummary(self):
return SetupSummary
def keySave(self):
config.plugins.growlee.save()
if self["config"].isChanged():
def doConnect(*args, **kwargs):
growleeConnection.listen()
d = growleeConnection.stop()
if d is not None:
d.addCallback(doConnect).addErrback(emergencyDisable)
else:
maybeConnect()
self.saveAll()
self.close()
def close(self):
if self.setupList in self.cur.protocol.notifiers:
self.cur.protocol.removeNotifier(self.setupList)
Screen.close(self)
class GrowleeConfiguration(Screen, ConfigListScreen):
skin = """
<screen name="GrowleeConfiguration" position="center,center" size="560,400" title="Growlee Setup" >
<ePixmap position="0,0" size="140,40" pixmap="buttons/red.png" transparent="1" alphatest="on" />
<ePixmap position="140,0" size="140,40" pixmap="buttons/green.png" transparent="1" alphatest="on" />
<ePixmap position="280,0" size="140,40" pixmap="buttons/yellow.png" transparent="1" alphatest="on" />
<ePixmap position="420,0" size="140,40" pixmap="buttons/blue.png" transparent="1" alphatest="on" />
<widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget source="key_yellow" render="Label" position="280,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget source="key_blue" render="Label" position="420,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
<widget name="config" position="5,45" size="550,350" scrollbarMode="showOnDemand" />
</screen>"""
def __init__(self, session):
Screen.__init__(self, session)
# Buttons
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self["key_yellow"] = StaticText(_("New"))
self["key_blue"] = StaticText(_("Delete"))
# Summary
self.setup_title = "Growlee Configuration"
self.onChangedEntry = []
# Define Actions
self["setupActions"] = ActionMap(
["SetupActions", "ColorActions"], {
"blue": self.delete,
"yellow": self.new,
"cancel": self.keyCancel,
"save": self.keySave,
})
self.hostElement = NoSave(
ConfigSelection(choices=[(x, x.name.value)
for x in config.plugins.growlee.hosts]))
self.hostElement.addNotifier(self.setupList, initial_call=False)
ConfigListScreen.__init__(self, [],
session=session,
on_change=self.changed)
self.cur = self.hostElement.value
# Trigger change
self.setupList()
self.changed()
def delete(self):
from Screens.MessageBox import MessageBox
self.session.openWithCallback(
self.deleteConfirm, MessageBox,
_("Really delete this entry?\nIt cannot be recovered!"))
def deleteConfirm(self, result):
if result and config.plugins.growlee.hostcount.value > 0:
config.plugins.growlee.hostcount.value -= 1
config.plugins.growlee.hosts.remove(self.cur)
self.hostElement.setChoices([
(x, x.name.value) for x in config.plugins.growlee.hosts
])
self.cur = self.hostElement.value
def new(self):
self.cur = addHost(_("New connection"))
config.plugins.growlee.hostcount.value += 1
self.hostElement.setChoices([(x, x.name.value)
for x in config.plugins.growlee.hosts])
self.hostElement.setValue(self.cur)
def changed(self):
for x in self.onChangedEntry:
x()
def setupList(self, *args):
last = self.cur
if self.setupList in last.protocol.notifiers:
last.protocol.removeNotifier(self.setupList)
cur = self.hostElement.value
self.cur = cur
cur.protocol.addNotifier(self.setupList, initial_call=False)
l = [
getConfigListEntry(_("Host"), self.hostElement),
getConfigListEntry(_("Name"), cur.name),
getConfigListEntry(_("Type"), cur.protocol),
getConfigListEntry(_("Minimum Priority"), cur.level),
getConfigListEntry(_("Send Notifications?"), cur.enable_outgoing),
]
proto = cur.protocol.value
if proto == "prowl":
l.append(getConfigListEntry(_("API Key"), cur.password))
else:
if proto != "gntp":
l.append(
getConfigListEntry(_("Receive Notifications?"),
cur.enable_incoming))
l.append(getConfigListEntry(_("Address"), cur.address))
if proto == "growl" or proto == "gntp":
l.append(getConfigListEntry(_("Password"), cur.password))
self["config"].list = l
def getCurrentEntry(self):
cur = self["config"].getCurrent()
return cur and cur[0]
def getCurrentValue(self):
cur = self["config"].getCurrent()
return cur and str(cur[1].getText())
def createSummary(self):
return SetupSummary
def keySave(self):
config.plugins.growlee.save()
if self["config"].isChanged():
def doConnect(*args, **kwargs):
growleeConnection.listen()
d = growleeConnection.stop()
if d is not None:
d.addCallback(doConnect).addErrback(emergencyDisable)
else:
maybeConnect()
self.saveAll()
self.close()
def close(self):
if self.setupList in self.cur.protocol.notifiers:
self.cur.protocol.removeNotifier(self.setupList)
Screen.close(self)
class AutoTimerEditorBase:
""" Base Class for all Editors """
def __init__(self, timer, editingDefaults = False):
# Keep Timer
self.timer = timer
self.editingDefaults = editingDefaults
# See if we are filtering some strings
excludes = (
timer.getExcludedTitle(),
timer.getExcludedShort(),
timer.getExcludedDescription(),
timer.getExcludedDays()
)
includes = (
timer.getIncludedTitle(),
timer.getIncludedShort(),
timer.getIncludedDescription(),
timer.getIncludedDays()
)
if excludes[0] or excludes[1] \
or excludes[2] or excludes[3] \
or includes[0] or includes[1] \
or includes[2] or includes[3]:
self.filterSet = True
else:
self.filterSet = False
self.excludes = excludes
self.includes = includes
# See if services are restricted
self.services = timer.services
self.bouquets = timer.bouquets
if self.services or self.bouquets:
self.serviceRestriction = True
else:
self.serviceRestriction = False
self.createSetup(timer)
def createSetup(self, timer):
# Name
self.name = NoSave(ConfigText(default = timer.name, fixed_size = False))
# Match
self.match = NoSave(ConfigText(default = timer.match, fixed_size = False))
# Encoding
default = timer.encoding
selection = ['UTF-8', 'ISO8859-15']
if default not in selection:
selection.append(default)
self.encoding = NoSave(ConfigSelection(choices = selection, default = default))
# ...
self.searchType = NoSave(ConfigSelection(choices = [("partial", _("partial match")), ("exact", _("exact match")), ("start", _("title starts with")), ("description", _("description match"))], default = timer.searchType))
self.searchCase = NoSave(ConfigSelection(choices = [("sensitive", _("case-sensitive search")), ("insensitive", _("case-insensitive search"))], default = timer.searchCase))
# Alternatives override
self.overrideAlternatives = NoSave(ConfigYesNo(default = timer.overrideAlternatives))
# Justplay
self.justplay = NoSave(ConfigSelection(choices = [("zap", _("zap")), ("record", _("record"))], default = {0: "record", 1: "zap"}[int(timer.justplay)]))
self.setEndtime = NoSave(ConfigYesNo(default=timer.setEndtime))
# Timespan
now = [x for x in localtime()]
if timer.hasTimespan():
default = True
now[3] = timer.timespan[0][0]
now[4] = timer.timespan[0][1]
begin = mktime(now)
now[3] = timer.timespan[1][0]
now[4] = timer.timespan[1][1]
end = mktime(now)
else:
default = False
now[3] = 20
now[4] = 15
begin = mktime(now)
now[3] = 23
now[4] = 15
end = mktime(now)
self.timespan = NoSave(ConfigEnableDisable(default = default))
self.timespanbegin = NoSave(ConfigClock(default = begin))
self.timespanend = NoSave(ConfigClock(default = end))
# Timeframe
if timer.hasTimeframe():
default = True
begin = timer.getTimeframeBegin()
end = timer.getTimeframeEnd()
else:
default = False
now = [x for x in localtime()]
now[3] = 0
now[4] = 0
begin = mktime(now)
end = begin + 604800 # today + 7d
self.timeframe = NoSave(ConfigEnableDisable(default = default))
self.timeframebegin = NoSave(ConfigDateTime(begin, _("%d.%B %Y"), increment = 86400))
self.timeframeend = NoSave(ConfigDateTime(end, _("%d.%B %Y"), increment = 86400))
# Services have their own Screen
# Offset
if timer.hasOffset():
default = True
begin = timer.getOffsetBegin()
end = timer.getOffsetEnd()
else:
default = False
begin = 5
end = 5
self.offset = NoSave(ConfigEnableDisable(default = default))
self.offsetbegin = NoSave(ConfigNumber(default = begin))
self.offsetend = NoSave(ConfigNumber(default = end))
# AfterEvent
if timer.hasAfterEvent():
default = {
None: "default",
AFTEREVENT.NONE: "nothing",
AFTEREVENT.DEEPSTANDBY: "deepstandby",
AFTEREVENT.STANDBY: "standby",
AFTEREVENT.AUTO: "auto"
}[timer.afterevent[0][0]]
else:
default = "default"
self.afterevent = NoSave(ConfigSelection(choices = [
("default", _("standard")), ("nothing", _("do nothing")),
("standby", _("go to standby")),
("deepstandby", _("go to deep standby")),
("auto", _("auto"))], default = default))
# AfterEvent (Timespan)
if timer.hasAfterEvent() and timer.afterevent[0][1][0] is not None:
default = True
now[3] = timer.afterevent[0][1][0][0]
now[4] = timer.afterevent[0][1][0][1]
begin = mktime(now)
now[3] = timer.afterevent[0][1][1][0]
now[4] = timer.afterevent[0][1][1][1]
end = mktime(now)
else:
default = False
now[3] = 23
now[4] = 15
begin = mktime(now)
now[3] = 7
now[4] = 0
end = mktime(now)
self.afterevent_timespan = NoSave(ConfigEnableDisable(default = default))
self.afterevent_timespanbegin = NoSave(ConfigClock(default = begin))
self.afterevent_timespanend = NoSave(ConfigClock(default = end))
# Enabled
self.enabled = NoSave(ConfigYesNo(default = timer.enabled))
# Maxduration
if timer.hasDuration():
default = True
duration = timer.getDuration()
else:
default = False
duration =70
self.duration = NoSave(ConfigEnableDisable(default = default))
self.durationlength = NoSave(ConfigNumber(default = duration))
# Counter
if timer.hasCounter():
default = timer.matchCount
else:
default = 0
self.counter = NoSave(ConfigNumber(default = default))
self.counterLeft = NoSave(ConfigNumber(default = timer.matchLeft))
default = timer.getCounterFormatString()
selection = [("", _("Never")), ("%m", _("Monthly")), ("%U", _("Weekly (Sunday)")), ("%W", _("Weekly (Monday)"))]
if default not in ('', '%m', '%U', '%W'):
selection.append((default, _("Custom (%s)") % (default)))
self.counterFormatString = NoSave(ConfigSelection(selection, default = default))
# Avoid Duplicate Description
self.avoidDuplicateDescription = NoSave(ConfigSelection([
("0", _("No")),
("1", _("On same service")),
("2", _("On any service")),
("3", _("Any service/recording")),
],
default = str(timer.getAvoidDuplicateDescription())
))
# Search for Duplicate Desciption in...
self.searchForDuplicateDescription = NoSave(ConfigSelection([
("0", _("Title")),
("1", _("Title and Short description")),
("2", _("Title and all descriptions")),
],
default = str(timer.searchForDuplicateDescription)
))
# Custom Location
if timer.hasDestination():
default = True
else:
default = False
self.useDestination = NoSave(ConfigYesNo(default = default))
default = timer.destination or Directories.resolveFilename(Directories.SCOPE_HDD)
choices = config.movielist.videodirs.value
if default not in choices:
choices.append(default)
self.destination = NoSave(ConfigSelection(default = default, choices = choices))
# Tags
self.timerentry_tags = timer.tags
self.tags = NoSave(ConfigSelection(choices = [len(self.timerentry_tags) == 0 and _("None") or ' '.join(self.timerentry_tags)]))
# Vps
self.vps_enabled = NoSave(ConfigYesNo(default = timer.vps_enabled))
self.vps_overwrite = NoSave(ConfigYesNo(default = timer.vps_overwrite))
# SeriesPlugin
self.series_labeling = NoSave(ConfigYesNo(default = timer.series_labeling))
def pathSelected(self, res):
if res is not None:
# I'm pretty sure this will always fail
if config.movielist.videodirs.value != self.destination.choices:
self.destination.setChoices(config.movielist.videodirs.value, default = res)
self.destination.value = res
def chooseDestination(self):
from Screens.LocationBox import MovieLocationBox
self.session.openWithCallback(
self.pathSelected,
MovieLocationBox,
_("Choose target folder"),
self.destination.value,
minFree = 100 # Same requirement as in Screens.TimerEntry
)
def tagEditFinished(self, ret):
if ret is not None:
self.timerentry_tags = ret
self.tags.setChoices([len(ret) == 0 and _("None") or ' '.join(ret)])
def chooseTags(self):
preferredTagEditor = getPreferredTagEditor()
if preferredTagEditor:
self.session.openWithCallback(
self.tagEditFinished,
preferredTagEditor,
self.timerentry_tags
)
class serienRecMarkerSetup(serienRecBaseScreen, Screen, ConfigListScreen, HelpableScreen):
def __init__(self, session, serien_name, serien_wlid, serien_id, serien_fsid):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.list = []
self.session = session
self.serien_name = serien_name
self.serien_id = serien_id
self.serien_wlid = serien_wlid
self.serien_fsid = serien_fsid
self.database = SRDatabase(serienRecDataBaseFilePath)
self.HilfeTexte = {}
self.fromTime_index = 1
self.toTime_index = 1
self.margin_before_index = 1
self.margin_after_index = 1
self.NoOfRecords_index = 1
self["actions"] = HelpableActionMap(self, "SerienRecorderActions", {
"red": (self.cancel, "Änderungen verwerfen und zurück zur Serien-Marker-Ansicht"),
"green": (self.save, "Einstellungen speichern und zurück zur Serien-Marker-Ansicht"),
"blue": (self.resetCover, "Cover zurücksetzen"),
"cancel": (self.cancel, "Änderungen verwerfen und zurück zur Serien-Marker-Ansicht"),
"ok": (self.ok, "Fenster für Verzeichnisauswahl öffnen"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"startTeletext": (self.showAbout, "Über dieses Plugin"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["SerienRecorderActions", ], {
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
if config.plugins.serienRec.showAllButtons.value:
setMenuTexts(self)
(AufnahmeVerzeichnis, Staffelverzeichnis, Vorlaufzeit, Nachlaufzeit, AnzahlWiederholungen, AufnahmezeitVon,
AufnahmezeitBis, preferredChannel, useAlternativeChannel, vps, excludedWeekdays, tags, addToDatabase, updateFromEPG, skipSeriesServer, autoAdjust, epgSeriesName) = self.database.getMarkerSettings(self.serien_id)
if not AufnahmeVerzeichnis:
AufnahmeVerzeichnis = ""
self.savetopath = ConfigText(default=AufnahmeVerzeichnis, fixed_size=False, visible_width=50)
self.seasonsubdir = ConfigSelection(choices=[("-1", "Gemäß Setup (dzt. %s)" % str(
config.plugins.serienRec.seasonsubdir.value).replace("True", "Ja").replace("False", "Nein")), ("0", "Nein"),
("1", "Ja")], default=str(Staffelverzeichnis))
if str(Vorlaufzeit).isdigit():
self.margin_before = ConfigInteger(Vorlaufzeit, (0, 999))
self.enable_margin_before = ConfigYesNo(default=True)
else:
self.margin_before = ConfigInteger(config.plugins.serienRec.margin_before.value, (0, 999))
self.enable_margin_before = ConfigYesNo(default=False)
if str(Nachlaufzeit).isdigit():
self.margin_after = ConfigInteger(Nachlaufzeit, (0, 999))
self.enable_margin_after = ConfigYesNo(default=True)
else:
self.margin_after = ConfigInteger(config.plugins.serienRec.margin_after.value, (0, 999))
self.enable_margin_after = ConfigYesNo(default=False)
if str(AnzahlWiederholungen).isdigit():
self.NoOfRecords = ConfigInteger(AnzahlWiederholungen, (1, 9))
self.enable_NoOfRecords = ConfigYesNo(default=True)
else:
self.NoOfRecords = ConfigInteger(config.plugins.serienRec.NoOfRecords.value, (1, 9))
self.enable_NoOfRecords = ConfigYesNo(default=False)
if str(AufnahmezeitVon).isdigit():
self.fromTime = ConfigClock(default=int(AufnahmezeitVon) * 60 + time.timezone)
self.enable_fromTime = ConfigYesNo(default=True)
else:
self.fromTime = ConfigClock(default=((config.plugins.serienRec.globalFromTime.value[0] * 60) +
config.plugins.serienRec.globalFromTime.value[1]) * 60 + time.timezone)
self.enable_fromTime = ConfigYesNo(default=False)
if str(AufnahmezeitBis).isdigit():
self.toTime = ConfigClock(default=int(AufnahmezeitBis) * 60 + time.timezone)
self.enable_toTime = ConfigYesNo(default=True)
else:
self.toTime = ConfigClock(default=((config.plugins.serienRec.globalToTime.value[0] * 60) +
config.plugins.serienRec.globalToTime.value[1]) * 60 + time.timezone)
self.enable_toTime = ConfigYesNo(default=False)
if str(vps).isdigit():
self.override_vps = ConfigYesNo(default=True)
self.enable_vps = ConfigYesNo(default=bool(vps & 0x1))
self.enable_vps_savemode = ConfigYesNo(default=bool(vps & 0x2))
else:
self.override_vps = ConfigYesNo(default=False)
self.enable_vps = ConfigYesNo(default=False)
self.enable_vps_savemode = ConfigYesNo(default=False)
if str(addToDatabase).isdigit():
self.addToDatabase = ConfigYesNo(default=bool(addToDatabase))
else:
self.addToDatabase = ConfigYesNo(default=True)
if str(updateFromEPG).isdigit():
self.updateFromEPG = ConfigYesNo(default=bool(updateFromEPG))
self.enable_updateFromEPG = ConfigYesNo(default=True)
else:
self.updateFromEPG = ConfigYesNo(default=config.plugins.serienRec.eventid.value)
self.enable_updateFromEPG = ConfigYesNo(default=False)
if str(skipSeriesServer).isdigit():
self.skipSeriesServer = ConfigYesNo(default=bool(skipSeriesServer))
self.enable_skipSeriesServer = ConfigYesNo(default=True)
else:
self.skipSeriesServer = ConfigYesNo(default=config.plugins.serienRec.tvplaner_skipSerienServer.value)
self.enable_skipSeriesServer = ConfigYesNo(default=False)
if str(autoAdjust).isdigit():
self.autoAdjust = ConfigYesNo(default=bool(autoAdjust))
self.enable_autoAdjust = ConfigYesNo(default=True)
else:
self.autoAdjust = ConfigYesNo(default=False)
self.enable_autoAdjust = ConfigYesNo(default=False)
self.preferredChannel = ConfigSelection(choices=[("1", "Standard"), ("0", "Alternativ")], default=str(preferredChannel))
self.useAlternativeChannel = ConfigSelection(choices=[("-1", "Gemäß Setup (dzt. %s)" % str(
config.plugins.serienRec.useAlternativeChannel.value).replace("True", "Ja").replace("False", "Nein")),
("0", "Nein"), ("1", "Ja")],
default=str(useAlternativeChannel))
# excluded weekdays
# each weekday is represented by a bit in the database field
# 0 = Monday to 6 = Sunday, so if all weekdays are excluded we got 1111111 = 127
if str(excludedWeekdays).isdigit():
self.enable_excludedWeekdays = ConfigYesNo(default=True)
self.excludeMonday = ConfigYesNo(default=bool(excludedWeekdays & (1 << 0)))
self.excludeTuesday = ConfigYesNo(default=bool(excludedWeekdays & (1 << 1)))
self.excludeWednesday = ConfigYesNo(default=bool(excludedWeekdays & (1 << 2)))
self.excludeThursday = ConfigYesNo(default=bool(excludedWeekdays & (1 << 3)))
self.excludeFriday = ConfigYesNo(default=bool(excludedWeekdays & (1 << 4)))
self.excludeSaturday = ConfigYesNo(default=bool(excludedWeekdays & (1 << 5)))
self.excludeSunday = ConfigYesNo(default=bool(excludedWeekdays & (1 << 6)))
else:
self.enable_excludedWeekdays = ConfigYesNo(default=False)
self.excludeMonday = ConfigYesNo(default=False)
self.excludeTuesday = ConfigYesNo(default=False)
self.excludeWednesday = ConfigYesNo(default=False)
self.excludeThursday = ConfigYesNo(default=False)
self.excludeFriday = ConfigYesNo(default=False)
self.excludeSaturday = ConfigYesNo(default=False)
self.excludeSunday = ConfigYesNo(default=False)
# tags
if tags is None or len(tags) == 0:
self.serienmarker_tags = []
else:
self.serienmarker_tags = pickle.loads(tags)
self.tags = NoSave(
ConfigSelection(choices=[len(self.serienmarker_tags) == 0 and "Keine" or ' '.join(self.serienmarker_tags)]))
# EPG series name
if epgSeriesName is None:
epgSeriesName = ""
self.epgSeriesName = ConfigText(default=epgSeriesName, fixed_size=False, visible_width=50)
self.changedEntry()
ConfigListScreen.__init__(self, self.list)
self.setInfoText()
self['config_information_text'].setText(self.HilfeTexte[self.savetopath])
self.onLayoutFinish.append(self.setSkinProperties)
def callHelpAction(self, *args):
HelpableScreen.callHelpAction(self, *args)
def setSkinProperties(self):
super(self.__class__, self).setSkinProperties()
self.num_bt_text = ([buttonText_na, buttonText_na, "Abbrechen"],
[buttonText_na, buttonText_na, buttonText_na],
[buttonText_na, buttonText_na, buttonText_na],
[buttonText_na, buttonText_na, "Hilfe"],
[buttonText_na, buttonText_na, buttonText_na])
self['text_red'].setText("Abbrechen")
self['text_green'].setText("Speichern")
if config.plugins.serienRec.downloadCover.value:
self['text_blue'].setText("Cover auswählen")
self['text_ok'].setText("Ordner auswählen")
super(self.__class__, self).startDisplayTimer()
def setupSkin(self):
self.skin = None
InitSkin(self)
self['config'] = ConfigList([])
self['config'].show()
self['config_information'].show()
self['config_information_text'].show()
self['title'].setText("Serien-Marker - Einstellungen für '%s':" % self.serien_name)
if not config.plugins.serienRec.showAllButtons.value:
self['text_0'].setText("Abbrechen")
self['text_1'].setText("About")
self['bt_red'].show()
self['bt_green'].show()
if config.plugins.serienRec.downloadCover.value:
self['bt_blue'].show()
self['bt_ok'].show()
self['bt_exit'].show()
self['bt_text'].show()
self['text_red'].show()
self['text_green'].show()
if config.plugins.serienRec.downloadCover.value:
self['text_blue'].show()
self['text_ok'].show()
self['text_0'].show()
self['text_1'].show()
self['text_2'].show()
self['text_3'].show()
self['text_4'].show()
else:
self['text_0'].hide()
self['text_1'].hide()
self['text_2'].hide()
self['text_3'].hide()
self['text_4'].hide()
self['text_5'].hide()
self['text_6'].hide()
self['text_7'].hide()
self['text_8'].hide()
self['text_9'].hide()
self['bt_0'].hide()
self['bt_1'].hide()
self['bt_2'].hide()
self['bt_3'].hide()
self['bt_4'].hide()
self['bt_5'].hide()
self['bt_6'].hide()
self['bt_7'].hide()
self['bt_8'].hide()
self['bt_9'].hide()
def createConfigList(self):
self.list = []
self.list.append(getConfigListEntry("Abweichender Speicherort der Aufnahmen:", self.savetopath))
if self.savetopath.value:
self.list.append(getConfigListEntry("Staffel-Verzeichnis anlegen:", self.seasonsubdir))
self.margin_before_index += 1
self.list.append(getConfigListEntry("Alternativer Serienname im EPG:", self.epgSeriesName))
self.margin_after_index = self.margin_before_index + 1
self.list.append(getConfigListEntry("Aktiviere abweichenden Timervorlauf:", self.enable_margin_before))
if self.enable_margin_before.value:
self.list.append(getConfigListEntry(" Timervorlauf (in Min.):", self.margin_before))
self.margin_after_index += 1
self.NoOfRecords_index = self.margin_after_index + 1
self.list.append(getConfigListEntry("Aktiviere abweichenden Timernachlauf:", self.enable_margin_after))
if self.enable_margin_after.value:
self.list.append(getConfigListEntry(" Timernachlauf (in Min.):", self.margin_after))
self.NoOfRecords_index += 1
self.fromTime_index = self.NoOfRecords_index + 1
self.list.append(getConfigListEntry("Aktiviere abweichende Anzahl der Aufnahmen:", self.enable_NoOfRecords))
if self.enable_NoOfRecords.value:
self.list.append(getConfigListEntry(" Anzahl der Aufnahmen:", self.NoOfRecords))
self.fromTime_index += 1
self.toTime_index = self.fromTime_index + 1
self.list.append(getConfigListEntry("Aktiviere abweichende Früheste Zeit für Timer:", self.enable_fromTime))
if self.enable_fromTime.value:
self.list.append(getConfigListEntry(" Früheste Zeit für Timer:", self.fromTime))
self.toTime_index += 1
self.list.append(getConfigListEntry("Aktiviere abweichende Späteste Zeit für Timer:", self.enable_toTime))
if self.enable_toTime.value:
self.list.append(getConfigListEntry(" Späteste Zeit für Timer:", self.toTime))
self.list.append(getConfigListEntry("Aktiviere abweichende Timeraktualisierung aus dem EPG:", self.enable_updateFromEPG))
if self.enable_updateFromEPG.value:
self.list.append(getConfigListEntry(" Versuche Timer aus dem EPG zu aktualisieren:", self.updateFromEPG))
if config.plugins.serienRec.tvplaner.value:
self.list.append(getConfigListEntry("Aktiviere abweichende Timererstellung nur aus der TV-Planer E-Mail:", self.enable_skipSeriesServer))
if self.enable_skipSeriesServer.value:
self.list.append(getConfigListEntry(" Timer nur aus der TV-Planer E-Mail anlegen:", self.skipSeriesServer))
from .SerienRecorder import VPSPluginAvailable
if VPSPluginAvailable:
self.list.append(getConfigListEntry("Aktiviere abweichende VPS Einstellungen:", self.override_vps))
if self.override_vps.value:
self.list.append(getConfigListEntry(" VPS für diesen Serien-Marker aktivieren:", self.enable_vps))
if self.enable_vps.value:
self.list.append(
getConfigListEntry(" Sicherheitsmodus aktivieren:", self.enable_vps_savemode))
if hasAutoAdjust():
self.list.append(getConfigListEntry("Aktiviere abweichende Aufnahmezeitenanpassung aus den EPG Daten:", self.enable_autoAdjust))
if self.enable_autoAdjust.value:
self.list.append(getConfigListEntry(" Aufnahmezeiten automatisch an EPG Daten anpassen:", self.autoAdjust))
self.list.append(getConfigListEntry("Timer in Timer-Liste speichern:", self.addToDatabase))
self.list.append(getConfigListEntry("Bevorzugte Sender-Liste:", self.preferredChannel))
self.list.append(getConfigListEntry("Verwende alternative Sender bei Konflikten:", self.useAlternativeChannel))
self.list.append(getConfigListEntry("Wochentage von der Timererstellung ausschließen:", self.enable_excludedWeekdays))
if self.enable_excludedWeekdays.value:
self.list.append(getConfigListEntry(" Montag:", self.excludeMonday))
self.list.append(getConfigListEntry(" Dienstag:", self.excludeTuesday))
self.list.append(getConfigListEntry(" Mittwoch:", self.excludeWednesday))
self.list.append(getConfigListEntry(" Donnerstag:", self.excludeThursday))
self.list.append(getConfigListEntry(" Freitag:", self.excludeFriday))
self.list.append(getConfigListEntry(" Samstag:", self.excludeSaturday))
self.list.append(getConfigListEntry(" Sonntag:", self.excludeSunday))
self.list.append(getConfigListEntry("Tags:", self.tags))
def updateMenuValues(self):
if self['config'].instance.getCurrentIndex() == self.margin_before_index:
if self.enable_margin_before.value and not self.margin_before.value:
self.margin_before.value = config.plugins.serienRec.margin_before.value
elif self['config'].instance.getCurrentIndex() == self.margin_after_index:
if self.enable_margin_after.value and not self.margin_after.value:
self.margin_after.value = config.plugins.serienRec.margin_after.value
elif self['config'].instance.getCurrentIndex() == self.NoOfRecords_index:
if self.enable_NoOfRecords.value and not self.NoOfRecords.value:
self.NoOfRecords.value = config.plugins.serienRec.NoOfRecords.value
elif self['config'].instance.getCurrentIndex() == self.fromTime_index:
if self.enable_fromTime.value and not self.fromTime.value:
self.fromTime.value = config.plugins.serienRec.globalFromTime.value
elif self['config'].instance.getCurrentIndex() == self.toTime_index:
if self.enable_toTime.value and not self.toTime.value:
self.toTime.value = config.plugins.serienRec.globalToTime.value
self.changedEntry()
def changedEntry(self):
self.createConfigList()
self['config'].setList(self.list)
def keyLeft(self):
if self['config'].getCurrent()[1] == self.tags:
self.chooseTags()
else:
ConfigListScreen.keyLeft(self)
self.updateMenuValues()
def keyRight(self):
if self['config'].getCurrent()[1] == self.tags:
self.chooseTags()
else:
ConfigListScreen.keyRight(self)
self.updateMenuValues()
def keyDown(self):
# self.changedEntry()
if self['config'].instance.getCurrentIndex() >= (len(self.list) - 1):
self['config'].instance.moveSelectionTo(0)
else:
self['config'].instance.moveSelection(self['config'].instance.moveDown)
# self.setInfoText()
try:
text = self.HilfeTexte[self['config'].getCurrent()[1]]
except:
text = "Keine Information verfügbar."
self["config_information_text"].setText(text)
if self['config'].getCurrent()[1] == self.savetopath:
self['bt_ok'].show()
self['text_ok'].show()
else:
self['bt_ok'].hide()
self['text_ok'].hide()
def keyUp(self):
# self.changedEntry()
if self['config'].instance.getCurrentIndex() < 1:
self['config'].instance.moveSelectionTo(len(self.list) - 1)
else:
self['config'].instance.moveSelection(self['config'].instance.moveUp)
# self.setInfoText()
try:
text = self.HilfeTexte[self['config'].getCurrent()[1]]
except:
text = "Keine Information verfügbar."
self["config_information_text"].setText(text)
if self['config'].getCurrent()[1] == self.savetopath:
self['bt_ok'].show()
self['text_ok'].show()
else:
self['bt_ok'].hide()
self['text_ok'].hide()
def ok(self):
if self['config'].getCurrent()[1] == self.tags:
self.chooseTags()
elif self['config'].getCurrent()[1] == self.epgSeriesName:
value = self.serien_name if len(self.epgSeriesName.value) == 0 else self.epgSeriesName.value
self.session.openWithCallback(self.epgSeriesNameEditFinished, NTIVirtualKeyBoard, title="Serien Titel eingeben:", text=value)
else:
if self['config'].getCurrent()[1] == self.savetopath:
if config.plugins.serienRec.seriensubdir.value:
self.session.openWithCallback(self.openFileSelector, MessageBox,
"Hier wird das direkte Aufnahme-Verzeichnis für die Serie ausgewählt, es wird nicht automatisch ein Serien-Ordner angelegt.\n\nMit der blauen Taste kann ein Serien-Ordner manuell angelegt werden.",
MessageBox.TYPE_INFO, timeout=15)
else:
self.openFileSelector(True)
def openFileSelector(self, answer):
if not self.savetopath.value:
start_dir = config.plugins.serienRec.savetopath.value
else:
start_dir = self.savetopath.value
from .SerienRecorderFileListScreen import serienRecFileListScreen
self.session.openWithCallback(self.selectedMediaFile, serienRecFileListScreen, start_dir, "Aufnahme-Verzeichnis auswählen", self.serien_name)
def selectedMediaFile(self, res):
if res is not None:
if self['config'].instance.getCurrentIndex() == 0:
#print(res)
self.savetopath.value = res
self.changedEntry()
def epgSeriesNameEditFinished(self, res):
if res is not None:
self.epgSeriesName.value = res
self.changedEntry()
def tagEditFinished(self, res):
if res is not None:
self.serienmarker_tags = res
self.tags.setChoices([len(res) == 0 and "Keine" or ' '.join(res)])
def chooseTags(self):
preferredTagEditor = getPreferredTagEditor()
if preferredTagEditor:
self.session.openWithCallback(
self.tagEditFinished,
preferredTagEditor,
self.serienmarker_tags
)
def resetCover(self):
if not config.plugins.serienRec.downloadCover.value:
return
from .SerienRecorderCoverSelectorScreen import CoverSelectorScreen
self.session.open(CoverSelectorScreen, self.serien_wlid, self.serien_name, self.serien_fsid)
def setInfoText(self):
self.HilfeTexte = {
self.savetopath: "Das Verzeichnis auswählen und/oder erstellen, in dem die Aufnahmen von '%s' gespeichert werden." % self.serien_name,
self.seasonsubdir: "Bei 'ja' wird für jede Staffel ein eigenes Unterverzeichnis im Serien-Verzeichnis für '%s' (z.B.\n'%sSeason 001') erstellt." % (
self.serien_name, self.savetopath.value),
self.epgSeriesName: ("Eingabe des Seriennamens wie er im EPG erscheint.\n\n"
"Manchmal kommt es vor, dass eine Serie bei Wunschliste anders heißt als im EPG (z.B. 'Die 2' vs. 'Die Zwei') das führt dazu, dass der SerienRecorder die Sendung nicht im EPG finden und aktualisieren kann.\n"
"Wenn sich der Serienname unterscheidet, kann der Name hier eingegeben werden, um darüber die Sendung im EPG zu finden."),
self.enable_margin_before: ("Bei 'ja' kann die Vorlaufzeit für Timer von '%s' eingestellt werden.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Vorlaufzeit.\n"
"Ist auch beim aufzunehmenden Sender eine Vorlaufzeit eingestellt, so hat der HÖHERE Wert Vorrang.\n"
"Bei 'nein' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.margin_before: ("Die Vorlaufzeit für Timer von '%s' in Minuten.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Vorlaufzeit.\n"
"Ist auch beim aufzunehmenden Sender eine Vorlaufzeit eingestellt, so hat der HÖHERE Wert Vorrang.") % self.serien_name,
self.enable_margin_after: ("Bei 'ja' kann die Nachlaufzeit für Timer von '%s' eingestellt werden.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Nachlaufzeit.\n"
"Ist auch beim aufzunehmenden Sender eine Nachlaufzeit eingestellt, so hat der HÖHERE Wert Vorrang.\n"
"Bei 'nein' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.margin_after: ("Die Nachlaufzeit für Timer von '%s' in Minuten.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Nachlaufzeit.\n"
"Ist auch beim aufzunehmenden Sender eine Nachlaufzeit eingestellt, so hat der HÖHERE Wert Vorrang.") % self.serien_name,
self.enable_NoOfRecords: (
"Bei 'ja' kann die Anzahl der Aufnahmen, die von einer Folge von '%s' gemacht werden sollen, eingestellt werden.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Anzahl der Aufnahmen.\n"
"Bei 'nein' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.NoOfRecords: ("Die Anzahl der Aufnahmen, die von einer Folge von '%s' gemacht werden sollen.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Anzahl der Aufnahmen.") % self.serien_name,
self.enable_fromTime: (
"Bei 'ja' kann die erlaubte Zeitspanne (ab Uhrzeit) für Aufnahmen von '%s' eingestellt werden.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die früheste Zeit für Timer.\n"
"Bei 'nein' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.fromTime: ("Die Uhrzeit, ab wann Aufnahmen von '%s' erlaubt sind.\n"
"Die erlaubte Zeitspanne beginnt um %s:%s Uhr.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die früheste Zeit für Timer.") % (
self.serien_name, str(self.fromTime.value[0]).zfill(2), str(self.fromTime.value[1]).zfill(2)),
self.enable_toTime: (
"Bei 'ja' kann die erlaubte Zeitspanne (bis Uhrzeit) für Aufnahmen von '%s' eingestellt werden.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die späteste Zeit für Timer.\n"
"Bei 'nein' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.toTime: ("Die Uhrzeit, bis wann Aufnahmen von '%s' erlaubt sind.\n"
"Die erlaubte Zeitspanne endet um %s:%s Uhr.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die späteste Zeit für Timer.") % (
self.serien_name, str(self.toTime.value[0]).zfill(2), str(self.toTime.value[1]).zfill(2)),
self.enable_updateFromEPG: (
"Bei 'ja' kann für Timer von '%s' eingestellt werden, ob versucht werden soll diesen aus dem EPG zu aktualisieren.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Timeraktualisierung aus dem EPG.\n"
"Bei 'nein' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.updateFromEPG: ("Bei 'ja' wird für Timer von '%s' versucht diese aus dem EPG zu aktualisieren.\n"
"Bei 'nein' werden die Timer dieser Serie nicht aus dem EPG aktualisiert.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Timeraktualisierung aus dem EPG.") % self.serien_name,
self.enable_skipSeriesServer: (
"Bei 'ja' kann für Timer von '%s' eingestellt werden, ob Timer nur aus der TV-Planer E-Mail angelegt werden sollen.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Timererstellung nur aus der TV-Planer E-Mail.\n"
"Bei 'nein' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.skipSeriesServer: ("Bei 'ja' werden Timer von '%s' nur aus der TV-Planer E-Mail erstellt.\n"
"Bei 'nein' werden die Timer aus den Daten des SerienServer angelegt.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Timererstellung nur aus der TV-Planer E-Mail.") % self.serien_name,
self.override_vps: ("Bei 'ja' kann VPS für Timer von '%s' eingestellt werden.\n"
"Diese Einstellung hat Vorrang gegenüber der Einstellung des Senders für VPS.\n"
"Bei 'nein' gilt die Einstellung vom Sender.") % self.serien_name,
self.enable_vps: (
"Bei 'ja' wird VPS für '%s' aktiviert. Die Aufnahme startet erst, wenn der Sender den Beginn der Ausstrahlung angibt, "
"und endet, wenn der Sender das Ende der Ausstrahlung angibt.\n"
"Diese Einstellung hat Vorrang gegenüber der Sender Einstellung für VPS.") % self.serien_name,
self.enable_vps_savemode: (
"Bei 'ja' wird der Sicherheitsmodus bei '%s' verwendet. Die programmierten Start- und Endzeiten werden eingehalten.\n"
"Die Aufnahme wird nur ggf. früher starten bzw. länger dauern, aber niemals kürzer.\n"
"Diese Einstellung hat Vorrang gegenüber der Sender Einstellung für VPS.") % self.serien_name,
self.enable_autoAdjust: ("Bei 'ja' kann für Timer von '%s' eingestellt werden, ob die Aufnahmezeit automatisch an die EPG Daten angepasst werden soll.\n"
"Diese Einstellung hat Vorrang gegenüber der Einstellung für die automatische Anpassung der Aufnahmezeit an EPG Daten am Sender.\n"
"Bei 'nein' gilt die Einstellung am Sender.") % self.serien_name,
self.autoAdjust: ("Bei 'ja' wird 'Aufnahmezeit automatisch an EPG Daten anpassen' für Timer von '%s' aktiviert.\n"
"Diese Einstellung hat Vorrang gegenüber der Einstellung für die automatische Anpassung der Aufnahmezeit an EPG Daten am Sender.") % self.serien_name,
self.addToDatabase: "Bei 'nein' werden für die Timer von '%s' keine Einträge in die Timer-Liste gemacht, sodass die Episoden beliebig oft getimert werden können." % self.serien_name,
self.preferredChannel: "Auswahl, ob die Standard-Sender oder die alternativen Sender für die Timer von '%s' verwendet werden sollen." % self.serien_name,
self.useAlternativeChannel: (
"Mit 'ja' oder 'nein' kann ausgewählt werden, ob versucht werden soll, einen Timer auf dem jeweils anderen Sender (Standard oder alternativ) zu erstellen, "
"falls der Timer für '%s' auf dem bevorzugten Sender nicht angelegt werden kann.\n"
"Diese Einstellung hat Vorrang gegenüber der globalen Einstellung für die Verwendung von alternativen Sendern.\n"
"Bei 'gemäß Setup' gilt die Einstellung vom globalen Setup.") % self.serien_name,
self.enable_excludedWeekdays: (
"Bei 'ja' können bestimmte Wochentage für die Erstellung von Timern für '%s' ausgenommen werden.\n"
"Es werden also an diesen Wochentage für diese Serie keine Timer erstellt.\n"
"Bei 'nein' werden alle Wochentage berücksichtigt.") % self.serien_name,
self.tags: ("Verwaltet die Tags für die Timer, die für %s angelegt werden.\n\n"
"Um diese Option nutzen zu können, muss das Tageditor Plugin installiert sein.") % self.serien_name
}
try:
text = self.HilfeTexte[self['config'].getCurrent()[1]]
except:
text = "Keine Information verfügbar."
self["config_information_text"].setText(text)
def save(self):
if not self.enable_margin_before.value:
Vorlaufzeit = None
else:
Vorlaufzeit = self.margin_before.value
if not self.enable_margin_after.value:
Nachlaufzeit = None
else:
Nachlaufzeit = self.margin_after.value
if not self.enable_NoOfRecords.value:
AnzahlWiederholungen = None
else:
AnzahlWiederholungen = self.NoOfRecords.value
if not self.enable_fromTime.value:
AufnahmezeitVon = None
else:
AufnahmezeitVon = (self.fromTime.value[0] * 60) + self.fromTime.value[1]
if not self.enable_toTime.value:
AufnahmezeitBis = None
else:
AufnahmezeitBis = (self.toTime.value[0] * 60) + self.toTime.value[1]
if not self.enable_updateFromEPG.value:
updateFromEPG = None
else:
updateFromEPG = self.updateFromEPG.value
if not self.enable_skipSeriesServer.value:
skipSeriesServer = None
else:
skipSeriesServer = self.skipSeriesServer.value
if not self.override_vps.value:
vpsSettings = None
else:
vpsSettings = (int(self.enable_vps_savemode.value) << 1) + int(self.enable_vps.value)
if not self.enable_autoAdjust.value:
autoAdjust = None
else:
autoAdjust = self.autoAdjust.value
if (not self.savetopath.value) or (self.savetopath.value == ""):
Staffelverzeichnis = -1
else:
Staffelverzeichnis = self.seasonsubdir.value
if not self.enable_excludedWeekdays.value:
excludedWeekdays = None
else:
excludedWeekdays = 0
excludedWeekdays |= (self.excludeMonday.value << 0)
excludedWeekdays |= (self.excludeTuesday.value << 1)
excludedWeekdays |= (self.excludeWednesday.value << 2)
excludedWeekdays |= (self.excludeThursday.value << 3)
excludedWeekdays |= (self.excludeFriday.value << 4)
excludedWeekdays |= (self.excludeSaturday.value << 5)
excludedWeekdays |= (self.excludeSunday.value << 6)
if len(self.serienmarker_tags) == 0:
tags = ""
else:
tags = pickle.dumps(self.serienmarker_tags)
self.database.setMarkerSettings(self.serien_id, (self.savetopath.value, int(Staffelverzeichnis), Vorlaufzeit, Nachlaufzeit, AnzahlWiederholungen,
AufnahmezeitVon, AufnahmezeitBis, int(self.preferredChannel.value), int(self.useAlternativeChannel.value),
vpsSettings, excludedWeekdays, tags, int(self.addToDatabase.value), updateFromEPG, skipSeriesServer, autoAdjust, self.epgSeriesName.value))
self.close(True)
def cancel(self):
self.close(False)
