def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
elif answer[1] == "commits":
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), CommitInfo)
elif answer[1] == "disclaimer":
self.showDisclaimer(justShow=True)
elif answer[1] == "showlist":
text = ""
for i in [x[0] for x in sorted(self.ipkg.getFetchedList(), key=lambda d: d[0])]:
text = text and text + "\n" + i or i
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages to update"))
elif answer[1] == "log":
text = ""
for i in open("/hdd/ipkgupgrade.log", "r").readlines():
text += i
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages to update"))
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = {'test_only': False})
def push(self, controller, subject, text="", attachments=[]):
print "push"
services = self.services
if not services:
# Fallback to PopUp
module = self.servicemodules.get("PopUp", None)
popup = self.instantiateModule(module)
# Missing but not necessary: popup.begin() -> popup.push(...) -> popup.end()
services = [popup]
if services:
for service in services:
if service and service.getEnable():
try:
service.push(
boundFunction(self.pushcallback, service, controller),
boundFunction(self.pusherrback, service, controller),
controller.getName(),
subject,
text,
attachments,
)
except Exception, e:
print _("PushService Service push() exception")
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback, file=sys.stdout)
def addMenu(self, destList, node):
requires = node.get('requires')
if requires:
if requires[0] == '!':
if SystemInfo.get(requires[1:], False):
return
elif not SystemInfo.get(requires, False):
return
MenuTitle = _(node.get('text', '??').encode('UTF-8'))
entryID = node.get('entryID', 'undefined')
weight = node.get('weight', 50)
description = node.get('description', '').encode('UTF-8') or None
description = description and _(description)
menupng = MenuEntryPixmap(entryID, self.png_cache, lastMenuID)
x = node.get('flushConfigOnClose')
if x:
a = boundFunction(self.session.openWithCallback, self.menuClosedWithConfigFlush, Menu, node)
else:
a = boundFunction(self.session.openWithCallback, self.menuClosed, Menu, node)
destList.append((MenuTitle,
a,
entryID,
weight,
description,
menupng))
def __init__(self, session, pin, pin_slot):
Screen.__init__(self, session)
self.skinName = ["ParentalControlChangePin", "Setup" ]
self.setup_title = _("Enter pin code")
self.onChangedEntry = [ ]
self.slot = pin_slot
self.pin = pin
self.list = []
self.pin1 = ConfigPIN(default = 0, censor = "*")
self.pin2 = ConfigPIN(default = 0, censor = "*")
self.pin1.addEndNotifier(boundFunction(self.valueChanged, 1))
self.pin2.addEndNotifier(boundFunction(self.valueChanged, 2))
self.list.append(getConfigListEntry(_("Enter PIN"), NoSave(self.pin1)))
self.list.append(getConfigListEntry(_("Reenter PIN"), NoSave(self.pin2)))
ConfigListScreen.__init__(self, self.list)
self["actions"] = NumberActionMap(["DirectionActions", "ColorActions", "OkCancelActions"],
{
"cancel": self.cancel,
"red": self.cancel,
"save": self.keyOK,
}, -1)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self.onLayoutFinish.append(self.layoutFinished)
def filescan_open(items, session, **kwargs):
if createSingleton(session) and ftpbrowser.ftpclient:
from Screens.MessageBox import MessageBox
from Tools.BoundFunction import boundFunction
session.openWithCallback(
boundFunction(filescan_open_connected, items, session, **kwargs),
MessageBox,
_("There already is an active connection.\nDo you want to abort it?"),
type = MessageBox.TYPE_YESNO
)
return
Len = len(items)
if Len > 1:
from Screens.ChoiceBox import ChoiceBox
from Tools.BoundFunction import boundFunction
session.openWithCallback(
boundFunction(filescan_chosen, session),
ChoiceBox,
_("Which server do you want to connect to?"),
[(item, item) for item in items]
)
elif Len:
filescan_chosen(items[0])
def __init__(self, *args, **kwargs):
baseMethods.Menu__init__(self, *args, **kwargs) # using the base initializer saves us a few cycles
HelpableScreen.__init__(self)
self.skinName = "SortableMenu"
self.setTitle(_("Main menu"))
# XXX: not nice, but makes our life a little easier
l = [(x[0], x[1], x[2], menuWeights.get(x, supportHiding=False), menuWeights.isHidden(x)) for x in self["menu"].list]
l.sort(key=itemgetter(3))
self["menu"] = SortableMenuList(l)
self["key_blue"] = StaticText(_("hide entry"))
self["DirectionActions"] = ActionMap(["DirectionActions"],
{
"left": boundFunction(self.doMove, self["menu"].pageUp),
"right": boundFunction(self.doMove, self["menu"].pageDown),
"up": boundFunction(self.doMove, self["menu"].up),
"down": boundFunction(self.doMove, self["menu"].down),
}, -1
)
self["MenuSortActions"] = HelpableActionMap(self, "MenuSortActions",
{
"ignore": lambda: None, # we need to overwrite some regular actions :-)
"toggleSelection": (self.toggleSelection, _("toggle selection")),
"selectEntry": (self.okbuttonClick, _("enter menu")),
"hideEntry": (self.hideEntry, _("hide entry")),
}, -1
)
self.selected = -1
def __init__(self, session, *args):
Screen.__init__(self, session)
self.skinName = "SelectImage"
self.session = session
self.imagesList = None
self.expanded = []
self.setTitle(_("Select Multiboot"))
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Reboot"))
self["list"] = ChoiceList(list=[ChoiceEntryComponent('',((_("Retreiving image slots - Please wait...")), "Waiter"))])
self["actions"] = ActionMap(["OkCancelActions", "ColorActions", "DirectionActions", "KeyboardInputActions", "MenuActions"],
{
"ok": self.keyOk,
"cancel": boundFunction(self.close, None),
"red": boundFunction(self.close, None),
"green": self.keyOk,
"up": self.keyUp,
"down": self.keyDown,
"left": self.keyLeft,
"right": self.keyRight,
"upRepeated": self.keyUp,
"downRepeated": self.keyDown,
"leftRepeated": self.keyLeft,
"rightRepeated": self.keyRight,
"menu": boundFunction(self.close, True),
}, -1)
self.delay = eTimer()
self.delay.callback.append(self.getImagesList)
self.delay.start(0, True)
def __init__(self, session):
Screen.__init__(self, session)
for btn in ("red","green","yellow","blue"):
self["key_" + btn] = Button(" ")
ConfigListScreen.__init__(self, [])
self.defprofile = ConfigSelection([])
self.updateConfigList()
self.pfsList = []
self["profiles"] = List(self.pfsList)
self.updateProfileList()
self["actions"] = ActionMap(["OkCancelActions", "ColorActions", "DirectionActions", "ChannelSelectEPGActions"],
{
"cancel": self.keyExit,
"ok": self.keyOk,
"showEPGList": self.showExamples,
"red": self.keyRed,
"green": self.keyGreen,
"yellow": boundFunction(self.moveEntry, -1),
"blue": boundFunction(self.moveEntry, +1),
"up": self.keyUp,
"down": self.keyDown,
}, -1)
self.onClose.append(self.__closed)
self.onLayoutFinish.append(self.__layoutFinished)
self.onShown.append(self.updateButtonState)
self.prev_ext_menu = config.plugins.VCS.ext_menu.value
def isServicePlayable(self, ref, callback, session=None):
if not config.ParentalControl.configured.value or not config.ParentalControl.servicepinactive.value:
return True
#Check if configuration has already been read or if the significant values have changed.
#If true: read the configuration
if self.configInitialized == False or self.storeServicePin != config.ParentalControl.storeservicepin.value:
self.getConfigValues()
service = ref.toCompareString()
if (config.ParentalControl.type.value == LIST_WHITELIST and not self.whitelist.has_key(service)) or (config.ParentalControl.type.value == LIST_BLACKLIST and self.blacklist.has_key(service)):
#Check if the session pin is cached
if self.sessionPinCached == True:
return True
self.callback = callback
#Someone started to implement different levels of protection. Seems they were never completed
#I did not throw out this code, although it is of no use at the moment
levelNeeded = 0
if self.serviceLevel.has_key(service):
levelNeeded = self.serviceLevel[service]
pinList = self.getPinList()[:levelNeeded + 1]
if not session:
Notifications.AddNotificationParentalControl(boundFunction(self.servicePinEntered, ref), PinInput, triesEntry = config.ParentalControl.retries.servicepin, pinList = pinList, service = ServiceReference(ref).getServiceName(), title = _("this service is protected by a parental control pin"), windowTitle = _("Parental control"))
else:
Notifications.RemovePopup("Parental control")
if self.PinDlg:
self.PinDlg.close()
self.PinDlg = session.openWithCallback(boundFunction(self.servicePinEntered, ref), PinInput, triesEntry = config.ParentalControl.retries.servicepin, pinList = pinList, service = ServiceReference(ref).getServiceName(), title = _("this service is protected by a parental control pin"), windowTitle = _("Parental control"))
return False
else:
return True
def isServicePlayable(self, ref, callback, session=None):
self.session = session
if not config.ParentalControl.servicepinactive.value:
return True
#Check if configuration has already been read or if the significant values have changed.
#If true: read the configuration
if self.storeServicePin != config.ParentalControl.storeservicepin.value:
self.getConfigValues()
service = ref.toCompareString()
info = eServiceCenter.getInstance().info(ref)
age = 0
if service.startswith("1:") and service.rsplit(":", 1)[1].startswith("/"):
refstr = info and info.getInfoString(ref, iServiceInformation.sServiceref)
service = refstr and eServiceReference(refstr).toCompareString()
elif int(config.ParentalControl.age.value):
event = info and info.getEvent(ref)
rating = event and event.getParentalData()
age = rating and rating.getRating()
age = age and age <= 15 and age + 3 or 0
if (age and age >= int(config.ParentalControl.age.value)) or service and self.blacklist.has_key(service):
#Check if the session pin is cached
if self.sessionPinCached:
return True
self.callback = callback
title = 'FROM BOUQUET "userbouquet.' in service and _("this bouquet is protected by a parental control pin") or _("this service is protected by a parental control pin")
if session:
Notifications.RemovePopup("Parental control")
if self.PinDlg:
self.PinDlg.close()
self.PinDlg = session.openWithCallback(boundFunction(self.servicePinEntered, ref), PinInput, triesEntry=config.ParentalControl.retries.servicepin, pinList=self.getPinList(), service=ServiceReference(ref).getServiceName(), title=title, windowTitle=_("Parental control"), simple=False)
else:
Notifications.AddNotificationParentalControl(boundFunction(self.servicePinEntered, ref), PinInput, triesEntry=config.ParentalControl.retries.servicepin, pinList=self.getPinList(), service=ServiceReference(ref).getServiceName(), title=title, windowTitle=_("Parental control"))
return False
else:
return True
def finishedEdit(self, answer): if answer[0]: entry = answer[1] if entry.external_prev != entry.external: def removeEditTimer(): entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev self.removeTimer(entry) def moveEditTimerError(): entry.external = entry.external_prev self.onSelectionChanged() if entry.external: self.fallbackTimer.addTimer(entry, removeEditTimer, moveEditTimerError) else: newentry = createRecordTimerEntry(entry) entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev self.fallbackTimer.removeTimer(entry, boundFunction(self.finishedAdd, (True, newentry)), moveEditTimerError) elif entry.external: self.fallbackTimer.editTimer(entry, self.onSelectionChanged) else: simulTimerList = self.session.nav.RecordTimer.record(entry) if simulTimerList is not None: for x in simulTimerList: if x.setAutoincreaseEnd(entry): self.session.nav.RecordTimer.timeChanged(x) simulTimerList = self.session.nav.RecordTimer.record(entry) if simulTimerList is not None: self.session.openWithCallback(boundFunction(self.finishedEdit, service_ref, begin, end), TimerSanityConflict, simulTimerList) return else: self.session.nav.RecordTimer.timeChanged(entry) self.onSelectionChanged()
def __init__(self, session, pin, pinname):
Screen.__init__(self, session)
# for the skin: first try ParentalControlChangePin, then Setup, this allows individual skinning
self.skinName = ["ParentalControlChangePin", "Setup" ]
self.setup_title = _("Change pin code")
self.onChangedEntry = [ ]
self.pin = pin
self.list = []
self.pin1 = ConfigPIN(default = 1111, censor = "*")
self.pin2 = ConfigPIN(default = 1112, censor = "*")
self.pin1.addEndNotifier(boundFunction(self.valueChanged, 1))
self.pin2.addEndNotifier(boundFunction(self.valueChanged, 2))
self.list.append(getConfigListEntry(_("New PIN"), NoSave(self.pin1)))
self.list.append(getConfigListEntry(_("Re-enter new PIN"), NoSave(self.pin2)))
ConfigListScreen.__init__(self, self.list)
ProtectedScreen.__init__(self)
self["actions"] = NumberActionMap(["DirectionActions", "ColorActions", "OkCancelActions", "MenuActions"],
{
"cancel": self.keyCancel,
"red": self.keyCancel,
"save": self.keyOK,
"menu": self.closeRecursive,
}, -1)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self.onLayoutFinish.append(self.layoutFinished)
def openMenu(self):
if self.movemode:
# TRANSLATORS: there is no need to translate this string, as it was reused from e2 core
moveString = _("disable move mode")
else:
# TRANSLATORS: there is no need to translate this string, as it was reused from e2 core
moveString = _("enable move mode")
list = [
(moveString, self.toggleMoveMode),
(_("move extensions"), boundFunction(self.openMover, PluginDescriptor.WHERE_EXTENSIONSMENU)),
(_("move movie extensions"), boundFunction(self.openMover, PluginDescriptor.WHERE_MOVIELIST)),
(_("move event extensions"), boundFunction(self.openMover, PluginDescriptor.WHERE_EVENTINFO)),
]
if fileExists(resolveFilename(SCOPE_PLUGINS, "Extensions/PluginHider/plugin.py")):
list.insert(0, (_("hide selected plugin"), self.hidePlugin))
if pluginSortHelp:
list.insert(0, (_("Help"), boundFunction(pluginSortHelp.open, self.session)))
self.session.openWithCallback(
self.menuCallback,
ChoiceBox,
list = list,
)
def __init__(self, session):
menu = [(_("General Help"), boundFunction(self.close, self.HELP_RETURN_MAINHELP)),
(_("Key Help"), boundFunction(self.close, self.HELP_RETURN_KEYHELP)),
(_("Cancel"), self.close)]
FixedMenu.__init__(self, session, _("EPGRefresh Configuration Help"), menu)
self.skinName = ["EPGRefreshConfigurationHelpContextMenu", "Menu" ]
def __init__(self, *args, **kwargs):
baseMethods.Menu__init__(self, *args, **kwargs) # using the base initializer saves us a few cycles
HelpableScreen.__init__(self)
self.skinName = "SortableMenu"
# XXX: not nice, but makes our life a little easier
l = [(x[0], x[1], x[2], menuWeights.get(x)) for x in self["menu"].list]
l.sort(key=lambda x:x[3])
self["menu"] = SortableMenuList(l)
self["WizardActions"] = ActionMap(["WizardActions"],
{
"left": boundFunction(self.doMove, self["menu"].pageUp),
"right": boundFunction(self.doMove, self["menu"].pageDown),
"up": boundFunction(self.doMove, self["menu"].up),
"down": boundFunction(self.doMove, self["menu"].down),
}, -1
)
self["MenuSortActions"] = HelpableActionMap(self, "MenuSortActions",
{
"ignore": lambda: None, # we need to overwrite some regular actions :-)
"toggleSelection": (self.toggleSelection, _("toggle selection")),
"selectEntry": (self.okbuttonClick, _("enter menu")),
}, -1
)
self.selected = -1
def __init__(self, session, pin, pinname):
Screen.__init__(self, session)
# for the skin: first try ParentalControlChangePin, then Setup, this allows individual skinning
self.skinName = ["ParentalControlChangePin", "Setup"]
self.setup_title = _("Change pin code")
self.onChangedEntry = []
self.pin = pin
self.list = []
self.pin1 = ConfigPIN(default=1111, censor="*")
self.pin2 = ConfigPIN(default=1112, censor="*")
self.pin1.addEndNotifier(boundFunction(self.valueChanged, 1))
self.pin2.addEndNotifier(boundFunction(self.valueChanged, 2))
self.list.append(getConfigListEntry(_("New PIN"), NoSave(self.pin1)))
self.list.append(getConfigListEntry(_("Reenter new PIN"), NoSave(self.pin2)))
ConfigListScreen.__init__(self, self.list)
# print "old pin:", pin
# if pin.value != "aaaa":
# self.onFirstExecBegin.append(boundFunction(self.session.openWithCallback, self.pinEntered, PinInput, pinList = [self.pin.value], title = _("please enter the old pin"), windowTitle = _("Change pin code")))
ProtectedScreen.__init__(self)
self["actions"] = NumberActionMap(
["DirectionActions", "ColorActions", "OkCancelActions"],
{"cancel": self.cancel, "red": self.cancel, "save": self.keyOK},
-1,
)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self.onLayoutFinish.append(self.layoutFinished)
def getPluginList(self):
list = []
for p in plugins.getPlugins(where=PluginDescriptor.WHERE_EXTENSIONSMENU):
if p.name != "ORF.at IPTV":
list.append(
((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None)
)
return list
def getPluginList(self):
list = []
for p in plugins.getPlugins(where=PluginDescriptor.WHERE_EXTENSIONSMENU):
if (p.name != _("P**n Center")) and (p.name != config.plugins.PornCenter.name.value):
list.append(
((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None)
)
return list
def getPluginList(self):
from Components.PluginComponent import plugins
list = []
for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
if p.name != _('YouTube'):
list.append(((boundFunction(self.getPluginName, p.name),
boundFunction(self.runPlugin, p), lambda: True), None))
return list
def keyOk(self): if self["config"].getCurrent() == self.advancedSelectSatsEntry: conf = self.nimConfig.advanced.sat[int(self.nimConfig.advanced.sats.value)].userSatellitesList self.session.openWithCallback(boundFunction(self.updateConfUserSatellitesList, conf), SelectSatsEntryScreen, userSatlist=conf.value) elif self["config"].getCurrent() == self.selectSatsEntry: conf = self.nimConfig.userSatellitesList self.session.openWithCallback(boundFunction(self.updateConfUserSatellitesList, conf), SelectSatsEntryScreen, userSatlist=conf.value) else: self.keySave()
def Ok(self):
sel = self["list"].getCurrent()
if sel and sel[1]:
if len(sel[1])==3:#Device
tstr = _("Are you sure want to create FlashExpander on\n%s\nPartition %d") % (sel[1][0].model(), sel[1][1])
self.session.openWithCallback(boundFunction(self.__startFE_device,sel[1]), MessageBox, tstr)
if len(sel[1])==2:#Server
tstr = _("Are you sure want to create FlashExpander on \nServer: %s\nPath: %s") % (sel[1][0], sel[1][1])
self.session.openWithCallback(boundFunction(self.__startFE_server,sel[1]), MessageBox, tstr)
def createPictures(self, content):
for entry in content:
if entry[1]:
image = entry[1].rsplit('/', 1)[1]
if image not in self.pictures:
image = os.path.join('/tmp/', image)
downloadPage(entry[1], image)\
.addCallback(boundFunction(self.downloadFinished, image))\
.addErrback(boundFunction(self.downloadFailed, image))
def playService(self, ref, checkParentalControl=True, forceRestart=False, adjust=True):
oldref = self.currentlyPlayingServiceOrGroup
if ref and oldref and ref == oldref and not forceRestart:
print "ignore request to play already running service(1)"
return 1
print "playing", ref and ref.toString()
if ref is None:
self.stopService()
return 0
from Components.ServiceEventTracker import InfoBarCount
InfoBarInstance = InfoBarCount == 1 and InfoBar.instance
if not checkParentalControl or parentalControl.isServicePlayable(
ref, boundFunction(self.playService, checkParentalControl=False, forceRestart=forceRestart, adjust=adjust)
):
if ref.flags & eServiceReference.isGroup:
oldref = self.currentlyPlayingServiceReference or eServiceReference()
playref = getBestPlayableServiceReference(ref, oldref)
print "playref", playref
if playref and oldref and playref == oldref and not forceRestart:
print "ignore request to play already running service(2)"
return 1
if not playref:
alternativeref = getBestPlayableServiceReference(ref, eServiceReference(), True)
self.stopService()
if alternativeref and self.pnav and self.pnav.playService(alternativeref):
print "Failed to start", alternativeref
return 0
elif checkParentalControl and not parentalControl.isServicePlayable(
playref, boundFunction(self.playService, checkParentalControl=False)
):
if (
self.currentlyPlayingServiceOrGroup
and InfoBarInstance
and InfoBarInstance.servicelist.servicelist.setCurrent(
self.currentlyPlayingServiceOrGroup, adjust
)
):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent()
return 1
else:
playref = ref
if self.pnav:
self.pnav.stopService()
self.currentlyPlayingServiceReference = playref
self.currentlyPlayingServiceOrGroup = ref
if InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(ref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent()
if self.pnav.playService(playref):
print "Failed to start", playref
self.currentlyPlayingServiceReference = None
self.currentlyPlayingServiceOrGroup = None
return 0
elif oldref and InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(oldref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent()
return 1
def __init__(self, *args, **kwargs):
self.movemode = False
self.selected = -1
if 'where' in kwargs:
self.where = kwargs['where']
del kwargs['where']
else:
self.where = PluginDescriptor.WHERE_PLUGINMENU
OriginalPluginBrowser.__init__(self, *args, **kwargs)
self.skinName = ["SortingPluginBrowser", "PluginBrowser"] # XXX: fallback is evil because it makes moving more confusing :P
self["pluginlist"] = MyPluginList(self.list)
self["yellow"] = Label()
self["ColorActions"] = ActionMap(["ColorActions"],
{
"yellow": self.toggleMoveMode,
}, -2
)
self["WizardActions"] = ActionMap(["WizardActions"],
{
"left": boundFunction(self.doMove, self["pluginlist"].pageUp),
"right": boundFunction(self.doMove, self["pluginlist"].pageDown),
"up": boundFunction(self.doMove, self["pluginlist"].up),
"down": boundFunction(self.doMove, self["pluginlist"].down),
}, -2
)
if self.where != PluginDescriptor.WHERE_PLUGINMENU:
self.toggleMoveMode()
self.onShow.append(self.setCustomTitle)
else:
self["NumberActions"] = NumberActionMap(["NumberActions"],
{
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
}, -2
)
self["MenuActions"] = ActionMap(["MenuActions"],
{
"menu": self.openMenu,
}, -1
)
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session):
if epgrefresh.isRunning():
menu = [(_("Stop running refresh"), boundFunction(self.close, self.FUNCTION_RETURN_STOPREFRESH)),
(_("Pending Services"), boundFunction(self.close, self.FUNCTION_RETURN_SHOWPENDING))]
else:
menu = [(_("Refresh now"), boundFunction(self.close, self.FUNCTION_RETURN_FORCEREFRESH))]
menu.append((_("Cancel"), self.close))
FixedMenu.__init__(self, session, _("EPGRefresh Functions"), menu)
self.skinName = ["EPGRefreshConfigurationFunctionContextMenu", "Menu" ]
def __init__(self, session, csel, service):
Screen.__init__(self, session)
self.csel = csel
self.service = service
self["actions"] = ActionMap(["OkCancelActions"],
{
"ok": self.okbuttonClick,
"cancel": self.cancelClick
})
menu = [(_("delete..."), self.delete)]
menu.extend([(p.description, boundFunction(self.execPlugin, p)) for p in plugins.getPlugins(PluginDescriptor.WHERE_MOVIELIST)])
if config.movielist.moviesort.value == MovieList.SORT_ALPHANUMERIC:
menu.append((_("sort by date"), boundFunction(self.sortBy, MovieList.SORT_RECORDED)))
else:
menu.append((_("alphabetic sort"), boundFunction(self.sortBy, MovieList.SORT_ALPHANUMERIC)))
menu.extend((
(_("list style default"), boundFunction(self.listType, MovieList.LISTTYPE_ORIGINAL)),
(_("list style compact with description"), boundFunction(self.listType, MovieList.LISTTYPE_COMPACT_DESCRIPTION)),
(_("list style compact"), boundFunction(self.listType, MovieList.LISTTYPE_COMPACT)),
(_("list style single line"), boundFunction(self.listType, MovieList.LISTTYPE_MINIMAL))
))
if config.movielist.description.value == MovieList.SHOW_DESCRIPTION:
menu.append((_("hide extended description"), boundFunction(self.showDescription, MovieList.HIDE_DESCRIPTION)))
else:
menu.append((_("show extended description"), boundFunction(self.showDescription, MovieList.SHOW_DESCRIPTION)))
self["menu"] = MenuList(menu)
def __init__(self, session, playlistCallback, nextItemCallback, prevItemCallback, infoCallback, menuCallback):
Screen.__init__(self, session)
self.skinName = ['KodiVideoPlayer', 'MoviePlayer']
statusScreen = self.session.instantiateDialog(StatusScreen)
InfoBarBase.__init__(self, steal_current_service=True)
SubsSupport.__init__(self, searchSupport=True, embeddedSupport=True)
SubsSupportStatus.__init__(self)
InfoBarSeek.__init__(self)
InfoBarShowHide.__init__(self)
InfoBarSubservicesSupport.__init__(self)
InfoBarAspectChange.__init__(self)
InfoBarAudioSelection.__init__(self)
InfoBarNotifications.__init__(self)
HelpableScreen.__init__(self)
self.playlistCallback = playlistCallback
self.nextItemCallback = nextItemCallback
self.prevItemCallback = prevItemCallback
self.infoCallback = infoCallback
self.menuCallback = menuCallback
self.statusScreen = statusScreen
self.defaultImage = None
self.postAspectChange.append(self.showAspectChanged)
self.__timer = eTimer()
self.__timer.callback.append(self.__seekToPosition)
self.__image = None
self.__position = None
self.__firstStart = True
self["image"] = WebPixmap(self.defaultImage, caching=False)
self["directionActions"] = HelpableActionMap(self, "DirectionActions",
{
"downUp": (playlistCallback, _("Show playlist")),
"upUp": (playlistCallback, _("Show playlist")),
})
self["okCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": self.close
})
self["actions"] = HelpableActionMap(self, "KodiPlayerActions",
{
"menuPressed": (menuCallback, _("Show playback menu")),
"infoPressed": (infoCallback, _("Show playback info")),
"nextPressed": (nextItemCallback, _("Skip to next item in playlist")),
"prevPressed": (prevItemCallback, _("Skip to previous item in playlist"))
})
self.eventTracker = ServiceEventTracker(self,
{
iPlayableService.evStart : self.__evStart,
})
self.onClose.append(boundFunction(self.session.deleteDialog, self.statusScreen))
self.onClose.append(boundFunction(Notifications.RemovePopup, self.RESUME_POPUP_ID))
self.onClose.append(self.__timer.stop)
def keyOK(self): #openpliPC - F2 emuluje green
curIndex = self["config"].getCurrentIndex()
currItem = self["config"].list[curIndex][1]
if isinstance(currItem, ConfigDirectory):
def SetDirPathCallBack(curIndex, newPath):
if None != newPath:
self["config"].list[curIndex][1].value = newPath
self.runSetup()
if os_path.isdir(j00zekConfig.BouquetsOscamConfig.value):
self.session.openWithCallback(boundFunction(SetDirPathCallBack, curIndex), DirectorySelectorWidget, currDir=j00zekConfig.BouquetsOscamConfig.value, title='Wybierz katalog z konfiguracją OsCam-a')
else:
self.session.openWithCallback(boundFunction(SetDirPathCallBack, curIndex), DirectorySelectorWidget, currDir='/', title='Wybierz katalog z konfiguracją OsCam-a')
def startUpServiceContextMenuCallback(self, add):
if add:
options = [
(_("set as startup service after booting..."), boundFunction(self.setStartUpService, config.startupservice)),
(_("set as startup service after leaving standby mode..."), boundFunction(self.setStartUpService, config.startupserviceleavingstandbymode)),
]
else:
options = [
(_("reset startup service for booting..."), boundFunction(self.resetStartUpService, config.startupservice)),
(_("reset startup service for leaving standby mode..."), boundFunction(self.resetStartUpService, config.startupserviceleavingstandbymode)),
]
self.session.openWithCallback(self.startUpServiceMenuCallback, ChoiceBox,list = options)
def __init__(self, *args, **kwargs):
self.movemode = False
self.selected = -1
if 'where' in kwargs:
self.where = kwargs['where']
del kwargs['where']
else:
self.where = PluginDescriptor.WHERE_PLUGINMENU
OriginalPluginBrowser.__init__(self, *args, **kwargs)
self.skinName = ["SortingPluginBrowser", "PluginBrowser"]
self["ColorActions"] = ActionMap(["ColorActions"],
{
"green": self.toggleMoveMode,
}, -2
)
self["ColorActions"].setEnabled(False)
self["WizardActions"] = ActionMap(["WizardActions"],
{
"left": boundFunction(self.doMove, self["list"].pageUp),
"right": boundFunction(self.doMove, self["list"].pageDown),
"up": boundFunction(self.doMove, self["list"].up),
"down": boundFunction(self.doMove, self["list"].down),
}, -2
)
if self.where != PluginDescriptor.WHERE_PLUGINMENU:
self.toggleMoveMode()
self.onShow.append(self.setCustomTitle)
else:
self["NumberActions"] = NumberActionMap(["NumberActions"],
{
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
}, -2
)
self["MenuActions"] = ActionMap(["MenuActions"],
{
"menu": self.openMenu,
}, -1
)
self.onFirstExecBegin.append(self.firstExec)
def isWorkingCorrectly(self, callBackFun):
self.iptv_sys = iptv_system( DMHelper.GET_F4M_PATH() + " 2>&1 ", boundFunction(self._checkWorkingCallBack, callBackFun) )
def loadPlaylistFeed(self, playlist):
self.patientDialog = self.session.open(
PatientMessageBox, _("Loading playlist, be patient ..."))
self.patientDialog.processDelayed(
boundFunction(self.loadPlaylistFeedReal, playlist=playlist))
def requestApply(self):
if self.underClosing: return
self.doAction(
boundFunction(self._iptvDoClose, self.getCurrentDirectory()))
def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
for x in parent: #walk through the actual nodelist
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
self.addMenu(list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")), x[4]))
count += 1
if menuID is not None:
# plugins
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
list.append(
(l[0], boundFunction(l[1], self.session,
close=self.close), l[2], l[3] or 50))
# for the skin: first try a menu_<menuID>, then Menu
########################## pcd #################################
# self.skinName = [ ]
# if menuID is not None:
# self.skinName.append("menu_" + menuID)
# self.skinName.append("Menu")
# Sort by Weight
# list.sort(key=lambda x: int(x[3]))
self.skinName = []
self.menuID = menuID
skfile = "/usr/share/enigma2/" + config.skin.primary_skin.value
f1 = file(skfile, "r")
self.sktxt = f1.read()
f1.close()
if menuID is not None:
if ('<screen name="Animmain" '
in self.sktxt) and (config.usage.mainmenu_mode.value
== "horzanim"):
self.skinName.append("Animmain")
title = self.menuID
self.setTitle(title)
elif ('<screen name="Iconmain" '
in self.sktxt) and (config.usage.mainmenu_mode.value
== "horzicon"):
self.skinName.append("Iconmain")
title = self.menuID
self.setTitle(title)
else:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
ProtectedScreen.__init__(self)
# Sort by Weight
list.sort(key=lambda x: int(x[3]))
self.tlist = list
########################## pcd end #############################
self["menu"] = List(list)
self["actions"] = NumberActionMap(
["OkCancelActions", "MenuActions", "NumberActions"], {
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
a = parent.get("title", "").encode("UTF-8") or None
a = a and _(a)
if a is None:
a = _(parent.get("text", "").encode("UTF-8"))
self["title"] = StaticText(a)
self.menu_title = a
###################### pcd ###############
if ('<screen name="Animmain" '
in self.sktxt) and (config.usage.mainmenu_mode.value
== "horzanim"):
self.onShown.append(self.openTestA)
elif ('<screen name="Iconmain" '
in self.sktxt) and (config.usage.mainmenu_mode.value
== "horzicon"):
self.onShown.append(self.openTestB)
def addItem(self, destList, node):
requires = node.get("requires")
if requires:
if requires[0] == '!':
if SystemInfo.get(requires[1:], False):
return
elif not SystemInfo.get(requires, False):
return
conditional = node.get("conditional")
if conditional and not eval(conditional):
return
item_text = node.get("text", "").encode("UTF-8")
entryID = node.get("entryID", "undefined")
weight = node.get("weight", 50)
for x in node:
if x.tag == 'screen':
module = x.get("module")
screen = x.get("screen")
if screen is None:
screen = module
# print module, screen
if module:
module = "Screens." + module
else:
module = ""
# check for arguments. they will be appended to the
# openDialog call
args = x.text or ""
screen += ", " + args
destList.append(
(_(item_text or "??"),
boundFunction(self.runScreen,
(module, screen)), entryID, weight))
return
elif x.tag == 'plugin':
extensions = x.get("extensions")
system = x.get("system")
screen = x.get("screen")
if extensions:
module = extensions
elif system:
module = system
if screen is None:
screen = module
if extensions:
module = "Plugins.Extensions." + extensions + '.plugin'
elif system:
module = "Plugins.SystemPlugins." + system + '.plugin'
else:
module = ""
# check for arguments. they will be appended to the
# openDialog call
args = x.text or ""
screen += ", " + args
destList.append(
(_(item_text or "??"),
boundFunction(self.runScreen,
(module, screen)), entryID, weight))
return
elif x.tag == 'code':
destList.append(
(_(item_text
or "??"), boundFunction(self.execText,
x.text), entryID, weight))
return
elif x.tag == 'setup':
id = x.get("id")
if item_text == "":
item_text = _(getSetupTitle(id))
else:
item_text = _(item_text)
destList.append(
(item_text, boundFunction(self.openSetup,
id), entryID, weight))
return
destList.append((item_text, self.nothing, entryID, weight))
class InfoBarButtonSetup(): def __init__(self): self["ButtonSetupButtonActions"] = helpableButtonSetupActionMap(self, "ButtonSetupActions", dict((x[1],(self.ButtonSetupGlobal, boundFunction(self.getHelpText, x[1]))) for x in ButtonSetupKeys), -10)
def __init__(self):
if self.isProtected() and config.ParentalControl.servicepin[0].value:
self.onFirstExecBegin.append(boundFunction(self.session.openWithCallback, self.pinEntered, PinInput, pinList=[x.value for x in config.ParentalControl.servicepin], triesEntry=config.ParentalControl.retries.servicepin, title=_("Please enter the correct pin code"), windowTitle=_("Enter pin code")))
def playService(self,
ref,
checkParentalControl=True,
forceRestart=False,
adjust=True):
oldref = self.currentlyPlayingServiceOrGroup
if ref and oldref and ref == oldref and not forceRestart:
print "ignore request to play already running service(1)"
return 1
print "playing", ref and ref.toString()
if path.exists("/proc/stb/lcd/symbol_signal"
) and config.lcd.mode.value == '1':
try:
if '0:0:0:0:0:0:0:0:0' not in ref.toString():
signal = 1
else:
signal = 0
open("/proc/stb/lcd/symbol_signal", "w").write(str(signal))
except:
open("/proc/stb/lcd/symbol_signal", "w").write("0")
elif path.exists("/proc/stb/lcd/symbol_signal"
) and config.lcd.mode.value == '0':
open("/proc/stb/lcd/symbol_signal", "w").write("0")
if ref is None:
self.stopService()
return 0
from Components.ServiceEventTracker import InfoBarCount
InfoBarInstance = InfoBarCount == 1 and InfoBar.instance
if not checkParentalControl or parentalControl.isServicePlayable(
ref,
boundFunction(self.playService,
checkParentalControl=False,
forceRestart=forceRestart,
adjust=adjust)):
if ref.flags & eServiceReference.isGroup:
oldref = self.currentlyPlayingServiceReference or eServiceReference(
)
playref = getBestPlayableServiceReference(ref, oldref)
print "playref", playref
if playref and oldref and playref == oldref and not forceRestart:
print "ignore request to play already running service(2)"
return 1
if not playref:
alternativeref = getBestPlayableServiceReference(
ref, eServiceReference(), True)
self.stopService()
if alternativeref and self.pnav:
self.currentlyPlayingServiceReference = alternativeref
self.currentlyPlayingServiceOrGroup = ref
if self.pnav.playService(alternativeref):
print "Failed to start", alternativeref
self.currentlyPlayingServiceReference = None
self.currentlyPlayingServiceOrGroup = None
return 0
elif checkParentalControl and not parentalControl.isServicePlayable(
playref,
boundFunction(self.playService,
checkParentalControl=False)):
if self.currentlyPlayingServiceOrGroup and InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(
self.currentlyPlayingServiceOrGroup, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent(
)
return 1
else:
playref = ref
if self.pnav:
self.pnav.stopService()
self.currentlyPlayingServiceReference = playref
self.currentlyPlayingServiceOrGroup = ref
if InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(
ref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent(
)
setPriorityFrontend = False
if SystemInfo["DVB-T_priority_tuner_available"] or SystemInfo[
"DVB-C_priority_tuner_available"] or SystemInfo[
"DVB-S_priority_tuner_available"] or SystemInfo[
"ATSC_priority_tuner_available"]:
str_service = playref.toString()
if '%3a//' not in str_service and not str_service.rsplit(
":", 1)[1].startswith("/"):
type_service = playref.getUnsignedData(4) >> 16
if type_service == 0xEEEE:
if SystemInfo[
"DVB-T_priority_tuner_available"] and config.usage.frontend_priority_dvbt.value != "-2":
if config.usage.frontend_priority_dvbt.value != config.usage.frontend_priority.value:
setPreferredTuner(
int(config.usage.
frontend_priority_dvbt.value))
setPriorityFrontend = True
if SystemInfo[
"ATSC_priority_tuner_available"] and config.usage.frontend_priority_atsc.value != "-2":
if config.usage.frontend_priority_atsc.value != config.usage.frontend_priority.value:
setPreferredTuner(
int(config.usage.
frontend_priority_atsc.value))
setPriorityFrontend = True
elif type_service == 0xFFFF:
if SystemInfo[
"DVB-C_priority_tuner_available"] and config.usage.frontend_priority_dvbc.value != "-2":
if config.usage.frontend_priority_dvbc.value != config.usage.frontend_priority.value:
setPreferredTuner(
int(config.usage.
frontend_priority_dvbc.value))
setPriorityFrontend = True
if SystemInfo[
"ATSC_priority_tuner_available"] and config.usage.frontend_priority_atsc.value != "-2":
if config.usage.frontend_priority_atsc.value != config.usage.frontend_priority.value:
setPreferredTuner(
int(config.usage.
frontend_priority_atsc.value))
setPriorityFrontend = True
else:
if SystemInfo[
"DVB-S_priority_tuner_available"] and config.usage.frontend_priority_dvbs.value != "-2":
if config.usage.frontend_priority_dvbs.value != config.usage.frontend_priority.value:
setPreferredTuner(
int(config.usage.
frontend_priority_dvbs.value))
setPriorityFrontend = True
if self.pnav.playService(playref):
print "Failed to start", playref
self.currentlyPlayingServiceReference = None
self.currentlyPlayingServiceOrGroup = None
if setPriorityFrontend:
setPreferredTuner(int(
config.usage.frontend_priority.value))
return 0
elif oldref and InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(
oldref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent(
)
return 1
def playService(self,
ref,
checkParentalControl=True,
forceRestart=False,
adjust=True):
oldref = self.currentlyPlayingServiceOrGroup
if ref and oldref and ref == oldref and not forceRestart:
print "ignore request to play already running service(1)"
return 1
print "playing", ref and ref.toString()
if ref is None:
self.stopService()
return 0
from Components.ServiceEventTracker import InfoBarCount
InfoBarInstance = InfoBarCount == 1 and InfoBar.instance
if not checkParentalControl or parentalControl.isServicePlayable(
ref,
boundFunction(self.playService,
checkParentalControl=False,
forceRestart=forceRestart,
adjust=adjust)):
if ref.flags & eServiceReference.isGroup:
oldref = self.currentlyPlayingServiceReference or eServiceReference(
)
playref = getBestPlayableServiceReference(ref, oldref)
print "playref", playref
if playref and oldref and playref == oldref and not forceRestart:
print "ignore request to play already running service(2)"
return 1
if not playref:
alternativeref = getBestPlayableServiceReference(
ref, eServiceReference(), True)
self.stopService()
if alternativeref and self.pnav and self.pnav.playService(
alternativeref):
print "Failed to start", alternativeref
return 0
elif checkParentalControl and not parentalControl.isServicePlayable(
playref,
boundFunction(self.playService,
checkParentalControl=False)):
if self.currentlyPlayingServiceOrGroup and InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(
self.currentlyPlayingServiceOrGroup, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent(
)
return 1
else:
playref = ref
if self.pnav:
self.pnav.stopService()
self.currentlyPlayingServiceReference = playref
self.currentlyPlayingServiceOrGroup = ref
if InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(
ref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent(
)
if self.pnav.playService(playref):
print "Failed to start", playref
self.currentlyPlayingServiceReference = None
self.currentlyPlayingServiceOrGroup = None
return 0
elif oldref and InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(
oldref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent(
)
return 1
def __init__(self):
# TIMEREDITLIST
self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions", "YttrailerActions"],
{
"ok": self.openEdit,
"cancel": self.keyExit, # overwritten to use our own exit function
"green": self.addCurrentTimer,
"log": self.showLog,
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down,
"video": self.keyVideo,
}, -1)
# TAB NAVIGATION
self["tabNavigationActions"] = ActionMap(["TabNavigationActions"],
{
"nextTab": boundFunction(self.keyDirection, direction = 1),
"prevTab": boundFunction(self.keyDirection, direction = -1),
"1": boundFunction(self.keyNumber, number = 1),
"2": boundFunction(self.keyNumber, number = 2),
"3": boundFunction(self.keyNumber, number = 3),
"4": boundFunction(self.keyNumber, number = 4),
"5": boundFunction(self.keyNumber, number = 5),
"6": boundFunction(self.keyNumber, number = 6),
}, -1)
# EPG TABS
self["epgTabBaseActions"] = ActionMap(["EpgTabBaseActions"],
{
"exit": self.keyExit,
"moveUp": self.keyUp,
"moveDown": self.keyDown,
"pageUp": self.keyLeft,
"pageDown": self.keyRight,
"nextBouquet": self.keyBouquetUp,
"prevBouquet": self.keyBouquetDown,
"showRadio": self.keyRadio,
"showTv": self.keyTv,
"showEventInfo": self.keyInfo,
"ok": self.keyOk,
"video": self.keyVideo,
"text": self.keyText,
}, -1)
# EPG HISTORY ACTIONS
self["epgHistoryActions"] = ActionMap(["EpgHistoryActions"],
{
"exit": self.keyExit,
"ok": self.keyOk,
"moveUp": self.keyUp,
"moveDown": self.keyDown,
"pageUp": self.keyLeft,
"pageDown": self.keyRight,
}, -1)
# EPG MANUAL SEARCH ACTIONS
self["epgManualSearchActions"] = ActionMap(["EpgManualSearchActions"],
{
"exit": self.keyExit,
"ok": self.keyOk,
"left": self.keyLeft,
"right": self.keyRight,
"next": boundFunction(self.keyDirection, direction = 1),
"previous": boundFunction(self.keyDirection, direction = -1),
"1": boundFunction(self.keyNumber, number = 1),
"2": boundFunction(self.keyNumber, number = 2),
"3": boundFunction(self.keyNumber, number = 3),
"4": boundFunction(self.keyNumber, number = 4),
"5": boundFunction(self.keyNumber, number = 5),
"6": boundFunction(self.keyNumber, number = 6),
"7": boundFunction(self.keyNumber, number = 7),
"8": boundFunction(self.keyNumber, number = 8),
"9": boundFunction(self.keyNumber, number = 9),
"0": boundFunction(self.keyNumber, number = 0),
}, -1)
# EPG RED
self["epgRedActions"] = ActionMap(["EpgRedActions"],
{
"red": self.keyRed,
}, -1)
# EPG GREEN
self["epgGreenActions"] = ActionMap(["EpgGreenActions"],
{
"green": self.keyGreen,
}, -1)
# EPG BLUE
self["epgBlueActions"] = ActionMap(["EpgBlueActions"],
{
"blue": self.keyBlue,
}, -1)
# EPG YELLOW
self["epgYellowActions"] = ActionMap(["EpgYellowActions"],
{
"yellow": self.keyYellow,
}, -1)
# SETTINGS ACTIONS
self["settingsActions"] = ActionMap(["SettingsActions"],
{
"nextTab": boundFunction(self.keyDirection, direction = 1),
"prevTab": boundFunction(self.keyDirection, direction = -1),
"1": boundFunction(self.keyNumber, number = 1),
"2": boundFunction(self.keyNumber, number = 2),
"3": boundFunction(self.keyNumber, number = 3),
"4": boundFunction(self.keyNumber, number = 4),
"5": boundFunction(self.keyNumber, number = 5),
"6": boundFunction(self.keyNumber, number = 6),
"7": boundFunction(self.keyNumber, number = 7),
"8": boundFunction(self.keyNumber, number = 8),
"9": boundFunction(self.keyNumber, number = 9),
"0": boundFunction(self.keyNumber, number = 0),
"exit": self.keyExit,
"moveUp": self.keyUp,
"moveDown": self.keyDown,
"left": self.keyLeft,
"right": self.keyRight,
}, -1)
# TOGGLE CONFIG
self["toggleConfigActions"] = ActionMap(["ToggleConfigActions"],
{
"toggleConfig": self.keyMenu,
}, -1)
# disable several action maps on start
self["actions"].setEnabled(False)
self["epgHistoryActions"].setEnabled(False)
self["epgManualSearchActions"].setEnabled(False)
self["epgRedActions"].setEnabled(False)
self["epgYellowActions"].setEnabled(False)
self["epgBlueActions"].setEnabled(False)
self["settingsActions"].setEnabled(False)
self["toggleConfigActions"].setEnabled(True)
def restartGui(session=None):
if session and not session.nav.getRecordings():
session.openWithCallback(boundFunction(restartGuiNow, session), MessageBox, _("Restart the GUI now?"), MessageBox.TYPE_YESNO, default = False)
def __init__(self,
session,
text="",
filename="",
currDir=None,
bookmarks=None,
userMode=False,
windowTitle=_("Select location"),
minFree=None,
autoAdd=False,
editDir=False,
inhibitDirs=[],
inhibitMounts=[]):
# Init parents
Screen.__init__(self, session)
NumericalTextInput.__init__(self, handleTimeout=False)
HelpableScreen.__init__(self)
# Set useable chars
self.setUseableChars(u'1234567890abcdefghijklmnopqrstuvwxyz')
# Quickselect Timer
self.qs_timer = eTimer()
self.qs_timer.callback.append(self.timeout)
self.qs_timer_type = 0
# Initialize Quickselect
self.curr_pos = -1
self.quickselect = ""
# Set Text
self["text"] = Label(text)
self["textbook"] = Label(_("Bookmarks"))
# Save parameters locally
self.text = text
self.filename = filename
self.minFree = minFree
self.realBookmarks = bookmarks
self.bookmarks = bookmarks and bookmarks.value[:] or []
self.userMode = userMode
self.autoAdd = autoAdd
self.editDir = editDir
self.inhibitDirs = inhibitDirs
# Initialize FileList
self["filelist"] = FileList(currDir,
showDirectories=True,
showFiles=False,
inhibitMounts=inhibitMounts,
inhibitDirs=inhibitDirs)
# Initialize BookList
self["booklist"] = MenuList(self.bookmarks)
# Buttons
self["key_green"] = Button(_("OK"))
self["key_yellow"] = Button(_("Rename"))
self["key_blue"] = Button(_("Remove bookmark"))
self["key_red"] = Button(_("Cancel"))
# Background for Buttons
self["green"] = Pixmap()
self["yellow"] = Pixmap()
self["blue"] = Pixmap()
self["red"] = Pixmap()
# Initialize Target
self["target"] = Label()
if self.userMode:
self.usermodeOn()
# Custom Action Handler
class LocationBoxActionMap(HelpableActionMap):
def __init__(self, parent, context, actions={}, prio=0):
HelpableActionMap.__init__(self, parent, context, actions,
prio)
self.box = parent
def action(self, contexts, action):
# Reset Quickselect
self.box.timeout(force=True)
return HelpableActionMap.action(self, contexts, action)
# Actions that will reset quickselect
self["WizardActions"] = LocationBoxActionMap(self, "WizardActions", {
"ok": (self.ok, _("select")),
"back": (self.cancel, _("Cancel")),
}, -2)
self["DirectionActions"] = LocationBoxActionMap(
self, "DirectionActions", {
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down,
}, -2)
self["ColorActions"] = LocationBoxActionMap(
self, "ColorActions", {
"red": self.cancel,
"green": self.select,
"yellow": self.changeName,
"blue": self.addRemoveBookmark,
}, -2)
self["EPGSelectActions"] = LocationBoxActionMap(
self, "EPGSelectActions", {
"prevService":
(self.switchToBookList, _("switch to bookmarks")),
"nextService":
(self.switchToFileList, _("switch to filelist")),
}, -2)
self["MenuActions"] = LocationBoxActionMap(self, "MenuActions", {
"menu": (self.showMenu, _("menu")),
}, -2)
# Actions used by quickselect
self["NumberActions"] = NumberActionMap(
["NumberActions"], {
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
})
# Run some functions when shown
self.onShown.extend((
boundFunction(self.setTitle, windowTitle),
self.updateTarget,
self.showHideRename,
))
self.onLayoutFinish.append(self.switchToFileListOnStart)
# Make sure we remove our callback
self.onClose.append(self.disableTimer)
def isWorkingCorrectly(self, callBackFun):
self.iptv_sys = iptv_system(
"wget 2>&1 ", boundFunction(self._checkWorkingCallBack,
callBackFun))
def __init__(self, session):
self.modulation = config.plugins.SDGRadio.modulation
self.frequency = eval("config.plugins.SDGRadio.frequency_%s" %
self.modulation.value)
self.playbackFrequency = None # currently playing frequency
self.playbackPreset = None # currently playing preset
self.presets = [] # preset list for current modulation
self.log = [] # log messages
self.programs = [] # DAB program list
self.console = None
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.setTitle(_("Software defined radio"))
self.skin = SKIN
self.skin_path = resolveFilename(SCOPE_PLUGINS, "Extensions/SDGRadio")
for i in range(0, 10):
self["mem_%d" % i] = MultiPixmap()
self["modulation"] = Label()
self["freq"] = Label()
self["freq_off"] = Label()
self["freq_units"] = Label()
self["dab_channel"] = Label()
self["radiotext"] = Label()
self["prog_type"] = Label()
self["pi"] = Label()
self["traffic"] = Label()
self["af"] = Label()
self["ct"] = Label()
self["eon"] = Label()
self["rt+"] = Label()
self["pic"] = Pixmap()
self["rds_icon"] = Pixmap()
self["rt_icon"] = Pixmap()
self["ps_icon"] = Pixmap()
self["key_red"] = StaticText()
self["key_green"] = StaticText(_("Play"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["actions"] = HelpableActionMap(
self, "SDGRadioActions", {
"cancel": (self.cancel, _("Close plugin")),
"ok": (self.selectFreq, _("Play current frequency")),
"info": (self.showPrograms, _("Show DAB program list")),
"menu": (self.showMenu, _("Open advanced options menu")),
"red": (self.toggleModulation, _("Change modulation")),
"green": (self.togglePlayback, _("Start/stop playback")),
"yellow": (self.yellow, _("Switch RDS on/off")),
"blue": (self.showInput, _("Open frequency input screen")),
"blue_long": (self.showLog, _("Cmd execution log")),
"0": (boundFunction(self.selectPreset,
0), _("Play memory preset %d") % 0),
"1": (boundFunction(self.selectPreset,
1), _("Play memory preset %d") % 1),
"2": (boundFunction(self.selectPreset,
2), _("Play memory preset %d") % 2),
"3": (boundFunction(self.selectPreset,
3), _("Play memory preset %d") % 3),
"4": (boundFunction(self.selectPreset,
4), _("Play memory preset %d") % 4),
"5": (boundFunction(self.selectPreset,
5), _("Play memory preset %d") % 5),
"6": (boundFunction(self.selectPreset,
6), _("Play memory preset %d") % 6),
"7": (boundFunction(self.selectPreset,
7), _("Play memory preset %d") % 7),
"8": (boundFunction(self.selectPreset,
8), _("Play memory preset %d") % 8),
"9": (boundFunction(self.selectPreset,
9), _("Play memory preset %d") % 9),
"long0": (boundFunction(self.storePreset, 0),
_("Store frequency to memory preset %d") % 0),
"long1": (boundFunction(self.storePreset, 1),
_("Store frequency to memory preset %d") % 1),
"long2": (boundFunction(self.storePreset, 2),
_("Store frequency to memory preset %d") % 2),
"long3": (boundFunction(self.storePreset, 3),
_("Store frequency to memory preset %d") % 3),
"long4": (boundFunction(self.storePreset, 4),
_("Store frequency to memory preset %d") % 4),
"long5": (boundFunction(self.storePreset, 5),
_("Store frequency to memory preset %d") % 5),
"long6": (boundFunction(self.storePreset, 6),
_("Store frequency to memory preset %d") % 6),
"long7": (boundFunction(self.storePreset, 7),
_("Store frequency to memory preset %d") % 7),
"long8": (boundFunction(self.storePreset, 8),
_("Store frequency to memory preset %d") % 8),
"long9": (boundFunction(self.storePreset, 9),
_("Store frequency to memory preset %d") % 9),
"up": (boundFunction(
self.freqUp, "1"), _("Increase frequency by 1 MHz / KHz")),
"down":
(boundFunction(self.freqDown,
"1"), _("Decrease frequency by 1 MHz / KHz")),
"upRepeated":
(boundFunction(self.freqUp, "10"),
_("Increase frequency by 10 MHz / KHz (long press)")),
"downRepeated":
(boundFunction(self.freqDown, "10"),
_("Decrease frequency by 10 MHz / KHz (long press)")),
"right": (boundFunction(
self.freqUp, "0.05"), _("Increase frequency by 0.05 MHz")),
"left": (boundFunction(self.freqDown, "0.05"),
_("Decrease frequency by 0.05 MHz")),
"rightRepeated":
(boundFunction(self.freqUp, "0.1"),
_("Increase frequency by 0.1 MHz (long press)")),
"leftRepeated":
(boundFunction(self.freqDown, "0.1"),
_("Decrease frequency by 0.1 MHz (long press)")),
"nextBouquet": (boundFunction(self.freqUp, "0.0001"),
_("Increase frequency by 0.0001 MHz")),
"prevBouquet": (boundFunction(self.freqDown, "0.0001"),
_("Decrease frequency by 0.0001 MHz")),
}, -2)
self.onLayoutFinish.extend([
self.getConfigOptions, self.getPresets, self.updateFreqWidget,
self.updateExtraWidgets, self.redText, self.yellowText,
self.blueText
])
self.oldService = self.session.nav.getCurrentlyPlayingServiceReference(
) # get currently playing service
self.session.nav.stopService() # stop currently playing service
eConsoleAppContainer().execute(
"showiframe /usr/share/enigma2/radio.mvi") # display radio mvi
def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
for x in parent: #walk through the actual nodelist
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
self.addMenu(list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
list.append((x[0], boundFunction(self.runScreen, (x[2], x[3] + ", ")), x[4]))
count += 1
if menuID is not None:
# plugins
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
if len(l) > 4 and l[4]:
list.append((l[0], boundFunction(l[1], self.session, self.close), l[2], l[3] or 50))
else:
list.append((l[0], boundFunction(l[1], self.session), l[2], l[3] or 50))
# for the skin: first try a menu_<menuID>, then Menu
self.skinName = [ ]
if menuID is not None:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
# Sort by Weight
if config.usage.sort_menus.getValue():
list.sort()
else:
list.sort(key=lambda x: int(x[3]))
self["menu"] = List(list)
self["actions"] = NumberActionMap(["OkCancelActions", "MenuActions", "NumberActions"],
{
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
a = parent.get("title", "").encode("UTF-8") or None
a = a and _(a)
if a is None:
a = _(parent.get("text", "").encode("UTF-8"))
self["title"] = StaticText(a)
Screen.setTitle(self, a)
self.menu_title = a
def __init__(self,
session,
csel,
menu_mode,
current_dir,
list_styles,
service=None):
logger.info("current_dir: %s", current_dir)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.csel = csel
self.menu_mode = menu_mode
self.current_dir = current_dir
self.list_styles = list_styles
self.service = service
self.skinName = getSkinName("CockpitContextMenu")
self["title"] = StaticText()
self["menu"] = List()
self["actions"] = HelpableActionMap(
self, "CockpitActions", {
"EXIT": (self.close, _("Exit")),
"OK": (self.ok, _("Select function")),
"RED": (self.close, _("Cancel")),
"MENU": (self.csel.openConfigScreen, _("Open setup")),
}, -1)
menu = []
if self.menu_mode == MENU_FUNCTIONS:
self.setTitle(_("Select function"))
if self.current_dir not in MountCockpit.getInstance(
).getMountedBookmarks(ID):
menu.append((_("Home"), (boundFunction(
self.csel.changeDir,
MountCockpit.getInstance().getHomeDir(ID)), True)))
menu.append((_("Directory up"),
(boundFunction(self.csel.changeDir,
self.current_dir + "/.."), True)))
menu.append((_("Delete"), (self.csel.deleteMovies, True)))
menu.append((_("Move"), (self.csel.moveMovies, True)))
menu.append((_("Copy"), (self.csel.copyMovies, True)))
if config.plugins.moviecockpit.trashcan_enable.value:
menu.append(
(_("Empty trashcan"), (self.csel.emptyTrashcan, True)))
menu.append((_("Bookmarks"), (self.csel.openBookmarks, True)))
for i, _list_style in enumerate(self.list_styles):
menu.append((_(self.list_styles[i][1]),
(boundFunction(self.csel.movie_list.setListStyle,
i), True)))
if config.plugins.cachecockpit.archive_enable.value:
menu.append((_("Archive"), (self.csel.archiveFiles, True)))
menu.append((_("Reload cache"), (self.csel.reloadCache, False)))
menu.append((_("Remove all marks"),
(self.csel.removeCutListMarkers, True)))
menu.append((_("Setup"), (self.csel.openConfigScreen, True)))
menu.append((_("About"), (boundFunction(about,
self.session), True)))
elif self.menu_mode == MENU_PLUGINS:
self.setTitle(_("Select plugin"))
if self.service is not None:
for plugin in plugins.getPlugins(
PluginDescriptor.WHERE_MOVIELIST):
menu.append((plugin.description,
boundFunction(self.execPlugin, plugin)))
self["menu"].setList(menu)
def main(session, **kwargs): InfoBar.instance.checkTimeshiftRunning(boundFunction(mainCheckTimeshiftCallback, session))
def _isWgetWorkingCorrectly(self, callBackFun):
self.iptv_sys = iptv_system( DMHelper.GET_WGET_PATH() + " -V 2>&1 ", boundFunction(self._checkWgetWorkingCallBack, callBackFun) )
def newChannelContextMenu__init__(self, session, csel):
baseChannelContextMenu__init__(self, session, csel)
self["menu"].enableWrapAround = True
if config.BouquetProtect.enabled.value == 'none':
return
if csel.bouquet_mark_edit != 0 or csel.movemode:
return
idx = max(0, len(self["menu"].list) - 1)
current = csel.getCurrentSelection()
current_root = csel.getRoot()
if not (current_root
and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1):
inBouquet = csel.getMutableList() != None
if not (current.flags &
(eServiceReference.isMarker | eServiceReference.isDirectory)):
if inBouquet and config.BouquetProtect.enabled.value in ('bouq'):
if not csel.hidden_shown:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("unlock protected services"),
self.menuShowAllHiddenBouquetServices)))
self["menu"].list.insert(
idx,
ChoiceEntryComponent(text=(
_("add to bouquets protection"),
boundFunction(self.menuHideCurrentService, True))))
else:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("lock protected services"),
self.menuShowAllHiddenBouquetServices)))
if current.toString() in getHiddenList():
self["menu"].list.insert(
idx,
ChoiceEntryComponent(text=(
_("remove from bouquets protection"),
boundFunction(self.menuHideCurrentService,
False))))
else:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("add to bouquets protection"),
boundFunction(
self.menuHideCurrentService, True))))
elif not inBouquet and config.BouquetProtect.unwanted.enalbed.value:
if current_root and current_root.getPath().find(
"flags == 2") != -1:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("restore all hidden services"),
boundFunction(self.menuHideUnwantedServices,
False))))
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("restore hidden service"),
boundFunction(self.menuHideUnwantedService,
False))))
else:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("hide as unwanted service"),
boundFunction(self.menuHideUnwantedService,
True))))
else:
if config.BouquetProtect.unwanted.enalbed.value:
if not inBouquet and current.getPath().find("PROVIDERS") == -1:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("hide all as unwanted services"),
boundFunction(self.menuHideUnwantedServices,
True))))
else:
if not csel.hidden_shown:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("unlock protected services"),
self.menuShowAllHiddenBouquetServices)))
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("add to bouquets protection"),
boundFunction(self.menuHideCurrentBouquet, True))))
else:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(
text=(_("lock protected services"),
self.menuShowAllHiddenBouquetServices)))
if current.toString() in getHiddenList():
self["menu"].list.insert(
idx,
ChoiceEntryComponent(text=(
_("remove from bouquets protection"),
boundFunction(self.menuHideCurrentBouquet, False))))
else:
self["menu"].list.insert(
idx,
ChoiceEntryComponent(text=(
_("add to bouquets protection"),
boundFunction(self.menuHideCurrentBouquet, True))))
def okbuttonClick(self): nim = self["nimlist"].getCurrent() nim = nim and nim[3] if nim is not None and not nim.empty and nim.isSupported(): self.session.openWithCallback(boundFunction(self.updateList, self["nimlist"].getIndex()), self.resultclass, nim.slot)
def cancel(self, value=None):
self.container = Console()
self.container.ePopen('umount /tmp/startupmount',
boundFunction(self.unmountCallback, value))
def getEpisode(self, timer, block=False):
log.info("timername, service, begin, end:", timer.name,
str(timer.service_ref.ref), timer.begin, timer.end)
if hasattr(timer, 'sp_in_queue'):
if timer.sp_in_queue:
msg = _("Skipping timer because it is already in queue")
log.warning(msg, timer.name)
timer.log(601, "[SeriesPlugin]" + " " + msg)
return
# We have to compare the length,
# because of the E2 special chars handling for creating the filenames
#if timer.name == name:
# Mad Men != Mad_Men
if TAG in timer.tags:
msg = _("Skipping timer because it is already handled"
) + "\n\n" + _("Can be configured within the setup")
log.info(msg, timer.name)
timer.log(607, "[SeriesPlugin]" + " " + msg)
return
if timer.begin < time() + 60:
msg = _("Skipping timer because it starts in less than 60 seconds")
log.debug(msg, timer.name)
timer.log(604, "[SeriesPlugin]" + " " + msg)
return
if timer.isRunning():
msg = _("Skipping timer because it is already running")
log.debug(msg, timer.name)
timer.log(605, "[SeriesPlugin]" + " " + msg)
return
if timer.justplay:
msg = _("Skipping timer because it is a just play timer")
log.debug(msg, timer.name)
timer.log(606, "[SeriesPlugin]" + " " + msg)
return
event = None
epgcache = eEPGCache.getInstance()
if timer.eit:
event = epgcache.lookupEventId(timer.service_ref.ref, timer.eit)
log.debug("lookupEventId", timer.eit, event)
if not (event):
event = epgcache.lookupEventTime(
timer.service_ref.ref,
timer.begin + ((timer.end - timer.begin) / 2))
log.debug("lookupEventTime", event)
if event:
if not (len(timer.name) == len(event.getEventName())):
msg = _("Skipping timer because it is already modified %s" %
(timer.name))
log.info(msg)
timer.log(602, "[SeriesPlugin]" + " " + msg)
return
begin = event.getBeginTime() or 0
duration = event.getDuration() or 0
end = begin + duration
else:
if config.plugins.seriesplugin.timer_eit_check.value:
msg = _("Skipping timer because no event was found")
log.info(msg, timer.name)
timer.log(603, "[SeriesPlugin]" + " " + msg)
return
else:
# We don't know the exact margins, we will assume the E2 default margins
log.debug(
"We don't know the exact margins, we will assume the E2 default margins"
)
begin = timer.begin + (config.recording.margin_before.value *
60)
end = timer.end - (config.recording.margin_after.value * 60)
timer.log(
600, "[SeriesPlugin]" + " " + _("Try to find infos for %s" %
(timer.name)))
seriesPlugin = getInstance()
if timer.service_ref:
log.debug("getEpisode:", timer.name, timer.begin, timer.end, block)
timer.sp_in_queue = True
return seriesPlugin.getEpisode(boundFunction(
self.timerCallback, timer),
timer.name,
begin,
end,
timer.service_ref,
future=True,
block=block)
else:
msg = _("Skipping lookup because no channel is specified")
log.warning(msg)
self.timerCallback(timer, msg)
return None
def newPinEntered(self, answer):
if answer is not None:
self.session.openWithCallback(boundFunction(self.confirmNewPinEntered, answer), PinInput, title=_("Please re-enter the new PIN code"), windowTitle=_("Enter pin code"))
def searchFeed(self, searchContext):
self.patientDialog = self.session.open(PatientMessageBox,
_("Searching, be patient ..."))
self.patientDialog.processDelayed(
boundFunction(self.searchFeedReal, searchContext=searchContext))
self.isFavoritesFeed = False
def playService(self, ref, checkParentalControl=True, forceRestart=False, adjust=True):
oldref = self.currentlyPlayingServiceOrGroup
if ref and oldref and ref == oldref and not forceRestart:
print "ignore request to play already running service(1)"
return 1
print "playing", ref and ref.toString()
if path.exists("/proc/stb/lcd/symbol_signal") and config.lcd.mode.value == '1':
try:
if '0:0:0:0:0:0:0:0:0' not in ref.toString():
signal = 1
else:
signal = 0
f = open("/proc/stb/lcd/symbol_signal", "w")
f.write(str(signal))
f.close()
except:
f = open("/proc/stb/lcd/symbol_signal", "w")
f.write("0")
f.close()
elif path.exists("/proc/stb/lcd/symbol_signal") and config.lcd.mode.value == '0':
f = open("/proc/stb/lcd/symbol_signal", "w")
f.write("0")
f.close()
if ref is None:
self.stopService()
return 0
from Components.ServiceEventTracker import InfoBarCount
InfoBarInstance = InfoBarCount == 1 and InfoBar.instance
if not checkParentalControl or parentalControl.isServicePlayable(ref, boundFunction(self.playService, checkParentalControl=False, forceRestart=forceRestart, adjust=adjust)):
if ref.flags & eServiceReference.isGroup:
oldref = self.currentlyPlayingServiceReference or eServiceReference()
playref = getBestPlayableServiceReference(ref, oldref)
print "playref", playref
if playref and oldref and playref == oldref and not forceRestart:
print "ignore request to play already running service(2)"
return 1
if not playref:
alternativeref = getBestPlayableServiceReference(ref, eServiceReference(), True)
self.stopService()
if alternativeref and self.pnav:
self.currentlyPlayingServiceReference = alternativeref
self.currentlyPlayingServiceOrGroup = ref
if self.pnav.playService(alternativeref):
print "Failed to start", alternativeref
self.currentlyPlayingServiceReference = None
self.currentlyPlayingServiceOrGroup = None
return 0
elif checkParentalControl and not parentalControl.isServicePlayable(playref, boundFunction(self.playService, checkParentalControl = False)):
if self.currentlyPlayingServiceOrGroup and InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(self.currentlyPlayingServiceOrGroup, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent()
return 1
else:
playref = ref
if self.pnav:
self.pnav.stopService()
self.currentlyPlayingServiceReference = playref
self.currentlyPlayingServiceOrGroup = ref
if InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(ref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent()
if self.pnav.playService(playref):
print "Failed to start", playref
self.currentlyPlayingServiceReference = None
self.currentlyPlayingServiceOrGroup = None
return 0
elif oldref and InfoBarInstance and InfoBarInstance.servicelist.servicelist.setCurrent(oldref, adjust):
self.currentlyPlayingServiceOrGroup = InfoBarInstance.servicelist.servicelist.getCurrent()
return 1
def requestApply(self, fullPath):
if self.underClosing: return
self.doAction(boundFunction(self._iptvDoClose, fullPath))
def __copyFlash(self, mp, data):
if self.__checkMountPoint(mp):
cmd = "cp -af /usr/* %s/" % (mp)
self.Console.ePopen(cmd, self.__CopyFinished)
self.__message = self.session.openWithCallback(boundFunction(self.__EndCB, data), MessageBox, _("Please wait, Flash memory will be copied."), MessageBox.TYPE_INFO, enable_input=False)
def createMenuList(self, showNumericHelp=False):
self["key_blue"].text = _(
"Edit menu") if config.usage.menu_sort_mode.value == "user" else ""
self.list = []
self.menuID = None
for x in self.parentmenu: #walk through the actual nodelist
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(self.list, x)
count += 1
elif x.tag == 'menu':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addMenu(self.list, x)
count += 1
elif x.tag == "id":
self.menuID = x.get("val")
count = 0
if self.menuID:
# menuupdater?
if menuupdater.updatedMenuAvailable(self.menuID):
for x in menuupdater.getUpdatedMenu(self.menuID):
if x[1] == count:
self.list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")), x[4]))
count += 1
if self.menuID:
# plugins
for l in plugins.getPluginsForMenu(self.menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in self.list:
if x[2] == plugin_menuid:
self.list.remove(x)
break
self.list.append(
(l[0], boundFunction(l[1], self.session,
close=self.close), l[2], l[3] or 50))
if "user" in config.usage.menu_sort_mode.value and self.menuID == "mainmenu":
plugin_list = []
id_list = []
for l in plugins.getPlugins([
PluginDescriptor.WHERE_PLUGINMENU,
PluginDescriptor.WHERE_EXTENSIONSMENU,
PluginDescriptor.WHERE_EVENTINFO
]):
l.id = (l.name.lower()).replace(' ', '_')
if l.id not in id_list:
id_list.append(l.id)
plugin_list.append(
(l.name, boundFunction(l.__call__,
self.session), l.id, 200))
if self.menuID is not None and "user" in config.usage.menu_sort_mode.value:
self.sub_menu_sort = NoSave(ConfigDictionarySet())
self.sub_menu_sort.value = config.usage.menu_sort_weight.getConfigValue(
self.menuID, "submenu") or {}
idx = 0
for x in self.list:
entry = list(self.list.pop(idx))
m_weight = self.sub_menu_sort.getConfigValue(
entry[2], "sort") or entry[3]
entry.append(m_weight)
self.list.insert(idx, tuple(entry))
self.sub_menu_sort.changeConfigValue(entry[2], "sort",
m_weight)
idx += 1
self.full_list = list(self.list)
if config.usage.menu_sort_mode.value == "a_z":
# Sort by Name
self.list.sort(key=self.sortByName)
elif "user" in config.usage.menu_sort_mode.value:
self.hide_show_entries()
else:
# Sort by Weight
self.list.sort(key=lambda x: int(x[3]))
if config.usage.menu_show_numbers.value in ("menu&plugins",
"menu") or showNumericHelp:
self.list = [(str(x[0] + 1) + " " + x[1][0], x[1][1], x[1][2])
for x in enumerate(self.list)]
self["menu"].updateList(self.list)
def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
for x in parent: #walk through the actual nodelist
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
self.addMenu(list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")), x[4]))
count += 1
if menuID is not None:
# plugins
bhorder = []
if fileExists(resolveFilename(SCOPE_SKIN, 'menuorder.bh')):
file = open(resolveFilename(SCOPE_SKIN, 'menuorder.bh'), 'r')
for line in file.readlines():
parts = line.strip().split()
res = (parts[0], parts[1])
bhorder.append(res)
file.close()
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
weight = l[3]
for y in bhorder:
if y[0] == plugin_menuid:
weight = y[1]
if len(l) > 4 and l[4]:
list.append(
(l[0], boundFunction(l[1], self.session,
self.close), l[2], weight or 50))
else:
list.append(
(l[0], boundFunction(l[1], self.session), l[2], weight
or 50))
# for the skin: first try a menu_<menuID>, then Menu
self.skinName = []
if menuID is not None:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
self.menuID = menuID
ProtectedScreen.__init__(self)
# Sort by Weight
if config.usage.sort_menus.value:
list.sort()
else:
list.sort(key=lambda x: int(x[3]))
if config.usage.menu_show_numbers.value:
list = [(str(x[0] + 1) + " " + x[1][0], x[1][1], x[1][2])
for x in enumerate(list)]
self["menu"] = List(list)
self["actions"] = NumberActionMap(
["OkCancelActions", "MenuActions", "NumberActions"], {
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"0": self.keyNumberGlobal,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
a = parent.get("title", "").encode("UTF-8") or None
a = a and _(a) or _(parent.get("text", "").encode("UTF-8"))
self.setTitle(a)
self.number = 0
self.nextNumberTimer = eTimer()
self.nextNumberTimer.callback.append(self.okbuttonClick)
def mainSetup(session, **kwargs):
if config.plugins.iptvplayer.configProtectedByPin.value:
session.openWithCallback(boundFunction(pinCallback, session, runSetup), IPTVPinWidget, title=_("Enter pin"))
else:
runSetup(session)
