def __init__(self, list, session=None, on_change=None, fullUI=False):
self.entryChanged = on_change if on_change is not None else lambda: None
if fullUI:
if "key_red" not in self:
self["key_red"] = StaticText(_("Cancel"))
if "key_green" not in self:
self["key_green"] = StaticText(_("Save"))
self["fullUIActions"] = HelpableActionMap(self, ["ConfigListActions"], {
"cancel": (self.keyCancel, _("Cancel any changed settings and exit")),
"close": (self.closeRecursive, _("Cancel any changed settings and exit all menus")),
"save": (self.keySave, _("Save all changed settings and exit"))
}, prio=1, description=_("Common Setup Actions"))
if "key_menu" not in self:
self["key_menu"] = StaticText(_("MENU"))
if "HelpWindow" not in self:
self["HelpWindow"] = Pixmap()
self["HelpWindow"].hide()
if "VKeyIcon" not in self:
self["VKeyIcon"] = Boolean(False)
self["configActions"] = HelpableActionMap(self, ["ConfigListActions"], {
"select": (self.keySelect, _("Select, toggle, process or edit the current entry"))
}, prio=1, description=_("Common Setup Actions"))
self["navigationActions"] = HelpableActionMap(self, ["NavigationActions"], {
"top": (self.keyTop, _("Move to first line / screen")),
"pageUp": (self.keyPageUp, _("Move up a screen")),
"up": (self.keyUp, _("Move up a line")),
"first": (self.keyFirst, _("Jump to first item in list or the start of text")),
"left": (self.keyLeft, _("Select the previous item in list or move cursor left")),
"right": (self.keyRight, _("Select the next item in list or move cursor right")),
"last": (self.keyLast, _("Jump to last item in list or the end of text")),
"down": (self.keyDown, _("Move down a line")),
"pageDown": (self.keyPageDown, _("Move down a screen")),
"bottom": (self.keyBottom, _("Move to last line / screen"))
}, prio=1, description=_("Common Setup Actions"))
self["menuConfigActions"] = HelpableActionMap(self, "ConfigListActions", {
"menu": (self.keyMenu, _("Display selection list as a selection menu")),
}, prio=1, description=_("Common Setup Actions"))
self["menuConfigActions"].setEnabled(False if fullUI else True)
self["editConfigActions"] = HelpableNumberActionMap(self, ["NumberActions", "TextEditActions"], {
"backspace": (self.keyBackspace, _("Delete character to left of cursor or select AM times")),
"delete": (self.keyDelete, _("Delete character under cursor or select PM times")),
"erase": (self.keyErase, _("Delete all the text")),
"toggleOverwrite": (self.keyToggle, _("Toggle new text inserts before or overwrites existing text")),
"1": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"2": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"3": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"4": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"5": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"6": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"7": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"8": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"9": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"0": (self.keyNumberGlobal, _("Number or SMS style data entry")),
"gotAsciiCode": (self.keyGotAscii, _("Keyboard data entry"))
}, prio=1, description=_("Common Setup Actions"))
self["editConfigActions"].setEnabled(False if fullUI else True)
self["VirtualKB"] = HelpableActionMap(self, "VirtualKeyboardActions", {
"showVirtualKeyboard": (self.keyText, _("Display the virtual keyboard for data entry"))
}, prio=1, description=_("Common Setup Actions"))
self["VirtualKB"].setEnabled(False)
self["config"] = ConfigList(list, session=session)
self.setCancelMessage(None)
self.setRestartMessage(None)
self.onChangedEntry = []
if self.noNativeKeys not in self.onLayoutFinish:
self.onLayoutFinish.append(self.noNativeKeys)
if self.handleInputHelpers not in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.handleInputHelpers)
if self.showHelpWindow not in self.onExecBegin:
self.onExecBegin.append(self.showHelpWindow)
if self.hideHelpWindow not in self.onExecEnd:
self.onExecEnd.append(self.hideHelpWindow)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.cfglist = []
ConfigListScreen.__init__(self,
self.cfglist,
session,
on_change=self._changed)
self._session = session
self._hasChanged = False
self.version = getVersion()
self.controller = None
self.selected = None
self.sampleUse = False
self.aspect = getAspect()
self.old_service = self.session.nav.getCurrentlyPlayingServiceReference(
)
self["txt_green"] = Label()
self["btn_green"] = Pixmap()
self["statusbar"] = Pixmap()
self["txt_arrows"] = Label()
self["txt_statusbar"] = Label()
self["txt_statusbar_info"] = Label()
self["version"] = StaticText()
self["txt_green"].setText(_("Save"))
self["txt_arrows"].setText(_("Use < > to jump with 10 in slider"))
self["version"].text = self.version
# Disable OSD Transparency
try:
self.can_osd_alpha = open("/proc/stb/video/alpha",
"r") and True or False
except:
self.can_osd_alpha = False
if config.plugins.enigmalight.sampleBackground.getValue() == True:
self.showBackground()
self["setupActions"] = ActionMap(
["SetupActions", "ColorActions", "EL_Settings"], {
"green": self.keySave,
"cancel": self.exitTuning,
"ok": self.ok,
"left": self.keyLeft,
"right": self.keyRight,
"bouquet_up": self.keyBouquetUp,
"bouquet_down": self.keyBouquetDown,
"jumpNextMark": self.keyNext,
"jumpPreviousMark": self.keyPrev,
}, -2)
self.createSetup()
log("", self, "Finisch layout..")
#self["config"].onSelectionChanged.append(self.updateHelp)
self.onLayoutFinish.append(self.finishLayout)
def __init__(self, session, piclist, lastindex, path):
self.textcolor = config.pic.textcolor.value
self.color = config.pic.bgcolor.value
textsize = 20
self.spaceX = 35
self.picX = 190
self.spaceY = 30
self.picY = 200
size_w = getDesktop(0).size().width()
size_h = getDesktop(0).size().height()
self.thumbsX = size_w / (self.spaceX + self.picX) # thumbnails in X
self.thumbsY = size_h / (self.spaceY + self.picY) # thumbnails in Y
self.thumbsC = self.thumbsX * self.thumbsY # all thumbnails
self.positionlist = []
skincontent = ""
posX = -1
for x in range(self.thumbsC):
posY = x / self.thumbsX
posX += 1
if posX >= self.thumbsX:
posX = 0
absX = self.spaceX + (posX * (self.spaceX + self.picX))
absY = self.spaceY + (posY * (self.spaceY + self.picY))
self.positionlist.append((absX, absY))
skincontent += "<widget source=\"label" + str(
x
) + "\" render=\"Label\" position=\"" + str(absX + 5) + "," + str(
absY + self.picY - textsize
) + "\" size=\"" + str(self.picX - 10) + "," + str(
textsize
) + "\" font=\"Regular;14\" zPosition=\"2\" transparent=\"1\" noWrap=\"1\" foregroundColor=\"" + self.textcolor + "\" />"
skincontent += "<widget name=\"thumb" + str(
x) + "\" position=\"" + str(absX + 5) + "," + str(
absY + 5
) + "\" size=\"" + str(self.picX - 10) + "," + str(
self.picY - (textsize * 2)
) + "\" zPosition=\"2\" transparent=\"1\" alphatest=\"on\" />"
# Screen, backgroundlabel and MovingPixmap
self.skin = "<screen position=\"0,0\" size=\"" + str(
size_w
) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
<eLabel position=\"0,0\" zPosition=\"0\" size=\"" + str(size_w) + "," + str(
size_h
) + "\" backgroundColor=\"" + self.color + "\" /><widget name=\"frame\" position=\"35,30\" size=\"190,200\" pixmap=\"pic_frame.png\" zPosition=\"1\" alphatest=\"on\" />" + skincontent + "</screen>"
Screen.__init__(self, session)
self["actions"] = ActionMap(
[
"OkCancelActions", "ColorActions", "DirectionActions",
"MovieSelectionActions"
], {
"cancel": self.Exit,
"ok": self.KeyOk,
"left": self.key_left,
"right": self.key_right,
"up": self.key_up,
"down": self.key_down,
"showEventInfo": self.StartExif,
}, -1)
self["frame"] = MovingPixmap()
for x in range(self.thumbsC):
self["label" + str(x)] = StaticText()
self["thumb" + str(x)] = Pixmap()
self.Thumbnaillist = []
self.filelist = []
self.currPage = -1
self.dirlistcount = 0
self.path = path
index = 0
framePos = 0
Page = 0
for x in piclist:
if x[0][1] == False:
self.filelist.append(
(index, framePos, Page, x[0][0], path + x[0][0]))
index += 1
framePos += 1
if framePos > (self.thumbsC - 1):
framePos = 0
Page += 1
else:
self.dirlistcount += 1
self.maxentry = len(self.filelist) - 1
self.index = lastindex - self.dirlistcount
if self.index < 0:
self.index = 0
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.showPic)
self.onLayoutFinish.append(self.setPicloadConf)
self.ThumbTimer = eTimer()
self.ThumbTimer.callback.append(self.showPic)
def __init__(self, session, EIB_objects):
skin = """
<screen position="center,center" size="550,450" title="E.I.B.ox" >
<widget name="config" position="10,420" size="530,26" zPosition="1" transparent="1" scrollbarMode="showNever" />
<ePixmap pixmap="%s" position="0,0" size="550,400" zPosition="-1" alphatest="on" />\n""" % (
img_prefix + EIB_objects.zone_img)
offset = [12, 10] # fix up browser css spacing
iconsize = [32, 32]
self.setup_title = "E.I.B.ox"
self.EIB_objects = EIB_objects
for EIB_object in self.EIB_objects:
if EIB_object.object_type == EIB_GOTO:
pixmap_src = (img_prefix + 'goto' +
EIB_object.img.capitalize() + '.png')
skin += '\t\t\t<widget name="%s" pixmap="%s" position="%s" size="32,32" transparent="1" alphatest="on" borderColor="#004679" zPosition="1" />\n' % (
EIB_object.object_id, pixmap_src,
EIB_object.getPos(offset))
self[EIB_object.object_id] = Pixmap()
elif EIB_object.object_type in (EIB_SWITCH, EIB_MULTISWITCH,
EIB_DIMMER):
if EIB_object.object_type == EIB_DIMMER or EIB_object.img == "light":
pixmaps_sources = ['light_off.png', 'light_on.png']
elif EIB_object.img == "blinds":
pixmaps_sources = ['blinds_up.png', 'blinds_down.png']
elif EIB_object.img == "outlet":
pixmaps_sources = ['outlet_off.png', 'outlet_on.png']
elif EIB_object.img == "fan":
pixmaps_sources = ['fan_off.png', 'fan_on.png']
elif EIB_object.img == "pump":
pixmaps_sources = ['pump_off.png', 'pump_on.png']
else:
pixmaps_sources = list(EIB_object.custom_img)
for idx, filename in enumerate(pixmaps_sources):
pixmaps_sources[idx] = img_prefix + filename
pixmaps_string = ','.join(pixmaps_sources)
skin += '\t\t\t<widget name="%s" pixmaps="%s" position="%s" size="32,32" transparent="1" alphatest="on" borderColor="#004679" zPosition="1" />\n' % (
EIB_object.object_id, pixmaps_string,
EIB_object.getPos(offset))
self[EIB_object.object_id] = MultiPixmap()
if EIB_object.object_type == EIB_DIMMER:
skin += '\t\t\t<widget source="%s_progress" render="Progress" pixmap="progress_small.png" position="%s" size="32,5" backgroundColor="#4f74BB" zPosition="1" />\n' % (
EIB_object.object_id,
EIB_object.getPos([offset[0], offset[1] - iconsize[1]
]))
self[EIB_object.object_id + "_progress"] = Progress()
self[EIB_object.object_id + "_progress"].range = 255
elif EIB_object.object_type in (EIB_THERMO, EIB_TEXT):
skin += '\t\t\t<widget name="%s" position="%s" size="120,20" font="Regular;14" halign="left" valign="center" foregroundColors="#000000,#0000FF" transparent="1" zPosition="1" />\n' % (
EIB_object.object_id, EIB_object.getPos(offset))
self[EIB_object.object_id] = MultiColorLabel()
skin += """
</screen>"""
if config.eib.debug.value:
print skin
self.skin = skin
Screen.__init__(self, session)
self.initConfigList()
ConfigListScreen.__init__(self,
self.list,
session=self.session,
on_change=self.changedEntry)
self.onChangedEntry = []
self["actions"] = ActionMap(
[
"SetupActions", "OkCancelActions", "ColorActions",
"DirectionActions"
], {
"up": self.keyUp,
"upUp": self.keyPass,
"upRepeated": self.keyUp,
"down": self.keyDown,
"downUp": self.keyPass,
"downRepeated": self.keyDown,
"leftRepeated": self.keyLeftRepeated,
"rightRepeated": self.keyRightRepeated,
"cancel": self.keyCancel,
"red": self.keyCancel,
"green": self.keyOk,
"ok": self.keyOk
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session, selectedmovie=None):
# print("[SF-Plugin] SF:MovieSelection.init, PWD=%s; selmv=%s" % (config.movielist.last_videodir.value, str(selectedmovie)))
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.tags = []
if selectedmovie:
self.selected_tags = config.movielist.last_selected_tags.value
else:
self.selected_tags = None
self.selected_tags_ele = None
self.toggletype = 0
self.movemode = False
self.bouquet_mark_edit = False
self.delayTimer = eTimer()
self.delayTimer.callback.append(self.updateHDDData)
self["waitingtext"] = Label(_("Please wait... Loading list..."))
# create optional description border and hide immediately
self["DescriptionBorder"] = Pixmap()
self["DescriptionBorder"].hide()
if not fileExists(config.movielist.last_videodir.value):
config.movielist.last_videodir.value = defaultMoviePath()
config.movielist.last_videodir.save()
# print("[SF-Plugin] MovieSelection.MovieSelection: save" + config.movielist.last_videodir.value)
self.current_ref = eServiceReference(
"2:0:1:0:0:0:0:0:0:0:" + config.movielist.last_videodir.value)
self["list"] = MovieList(
None, config.movielist.sflisttype.value,
config.movielist.sfmoviesort.value, config.movielist.sftimes.value,
config.movielist.sftitle_episode_separator.value, self)
self.list = self["list"]
self.selectedmovie = selectedmovie
# Need list for init
SelectionEventInfo.__init__(self)
self["key_red"] = Button(_("All"))
self["key_green"] = Button("")
self["key_yellow"] = Button("")
self["key_blue"] = Button("")
self["freeDiskSpace"] = self.diskinfo = DiskInfo(
config.movielist.last_videodir.value, DiskInfo.FREE, update=False)
if config.usage.setup_level.index >= 2: # expert+
self["InfobarActions"] = HelpableActionMap(
self, "InfobarActions", {
"showMovies":
(self.doPathSelect, _("select the movie path")),
})
self["MovieSelectionActions"] = HelpableActionMap(
self, "MovieSelectionActions", {
"contextMenu": (self.doContext, _("menu")),
"showEventInfo":
(self.showEventInformation, _("show event details")),
})
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.showAll, _("show all")),
"green": (self.showTagsFirst, _("show first selected tag")),
"yellow": (self.showTagsSecond, _("show second selected tag")),
"blue": (self.showTagsSelect, _("show tag menu")),
})
self["OkCancelActions"] = HelpableActionMap(
self, "OkCancelActions", {
"cancel": (self.abort, _("exit movielist")),
"ok": (self.movieSelected, _("select movie")),
})
self["NumberActions"] = HelpableActionMap(
self, "SetupActions", {
"0":
(self.toggleSort, _x("Toggle date / alphabetic sort mode")),
"deleteBackward":
(self.moveToIndexStrt, _x("Jump to listbegin")),
"deleteForward": (self.moveToIndexEnd, _x("Jump to listend")),
"5":
(self.toggleMinimal, _x("Toggle style minimal / compact")),
"8":
(self.toggleTags, _x("Toggle description / tags display")),
})
self.onShown.append(self.go)
self.onLayoutFinish.append(self.saveListsize)
self.inited = False
def __init__(self, session, parent, menuID=None, default=0, update=0, overrides=1, endtext='>', sort='sort', findmenu=0):
Screen.__init__(self, session)
self.currentlist = self.MENU_LIST
self.parent = parent
self.menuID = menuID
self.findmenu = findmenu
self.default = str(default)
self.update = update
self.overrides = overrides
self.endtext = endtext
self.sort = sort
self.menu_title = ''
self['charframe'] = Pixmap()
self['charframe'].hide()
self.charlist = {}
self['charlist'] = CharList([])
self['charlist'].selectionEnabled(0)
self['menu'] = List()
self['title'] = StaticText('')
self.reloadMenu()
self.skinName = []
if self.menuID is not None:
self.skinName.append('menu_' + self.menuID)
self.skinName.append('Menu')
self.id_mainmenu = False
if self.menuID is not None:
if self.menuID == 'id_mainmenu':
self.id_mainmenu = True
self.setTitle("Main Menu")
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
})
if self.parent is not None:
a = self.parent.get('title', '').encode('UTF-8') or None
a = a and _(a) or _(self.parent.get("text", "").encode("UTF-8"))
self.menu_title = a
global menu_path
self.menu_path_compressed = menu_path
if menu_path == "":
menu_path += a
elif not menu_path.endswith(a):
menu_path += " / " + a
global full_menu_path
full_menu_path = menu_path + ' / '
if config.usage.show_menupath.value == 'large':
Screen.setTitle(self, menu_path)
self["title"] = StaticText(menu_path)
self["menu_path_compressed"] = StaticText("")
elif config.usage.show_menupath.value == 'small':
Screen.setTitle(self, a)
self["title"] = StaticText(a)
self["menu_path_compressed"] = StaticText(self.menu_path_compressed and self.menu_path_compressed + " >" or "")
else:
Screen.setTitle(self, a)
self["title"] = StaticText(a)
self["menu_path_compressed"] = StaticText("")
self.number = 0
self.nextNumberTimer = eTimer()
self.nextNumberTimer.callback.append(self.okbuttonClick)
ProtectedScreen.__init__(self)
self.onFirstExecBegin.append(self.setDefault)
def __init__(self, session, ScreenFile = ''):
Screen.__init__(self, session)
self.session = session
#valid ScreenFile is mandatory
if ScreenFile == '':
self.close()
return
elif not path.exists(ScreenFile):
self.close()
return
self.ScreenFile = ScreenFile
try:
self.root = ET.parse(self.ScreenFile).getroot()
self.myScreenName = self.root.find('screen').attrib['name']
self.NumberOfScreens = len(self.root.findall('screen'))
self.NumberOfChilds = len(self.root.findall('*'))
except:
printDEBUG("%s -Is NOT proper xml file - END!!!" % self.ScreenFile)
self.close()
return
printDEBUG("%s has been loaded successfully. :)" % self.ScreenFile)
if self.NumberOfChilds != self.NumberOfScreens:
iindex = 0
for child in self.root.findall('*'):
if child.tag == 'screen':
break
iindex+= 1
self.currentScreenID = iindex
if self.myScreenName == None:
myTitle=_("SphereFHD %s - EditScreens") % AtileHDInfo
else:
if self.NumberOfScreens == 1:
myTitle=_("SphereFHD %s - Edit %s screen") % (AtileHDInfo,self.myScreenName)
else:
myTitle=_("SphereFHD %s - Edit %s screen (1/%d)") % (AtileHDInfo,self.myScreenName,self.NumberOfScreens)
self.setTitle(myTitle)
self["key_red"] = StaticText(_("Exit"))
self["key_green"] = StaticText("")
if self.NumberOfScreens == 1:
self["key_yellow"] = StaticText("")
else:
self["key_yellow"] = StaticText(_("Switch screen"))
self['key_blue'] = StaticText(_('Actions'))
self["PreviewFont"] = Label()
self["widgetDetailsTXT"] = Label()
self["PixMapPreview"] = Pixmap()
self["SkinPicture"] = Pixmap()
self["ScreenPixMapPictureInScale"] = Pixmap()
self["WigetPixMapPictureInScale"] = Pixmap()
self["WigetPixMapPictureInScale1"] = Pixmap()
self["WigetPixMapPictureInScale2"] = Pixmap()
menu_list = []
self["menu"] = List(menu_list)
self["shortcuts"] = ActionMap(["AtileHDActions"],
{
"ok": self.keyOK,
"cancel": self.keyExit,
"red": self.keyExit,
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"keyup": self.channelup,
"keydown": self.channeldown,
}, -2)
self.skin_base_dir = SkinPath
#self.screen_dir = "allScreens"
self.allScreens_dir = "allScreens"
#check if we have preview files
isPreview=0
for xpreview in listdir(SkinPath + "allPreviews/"):
if len(xpreview) > 4 and xpreview[-4:] == ".png":
isPreview += 1
if isPreview >= 2:
break
self.elabel_png = LoadPixmap(cached=True, path= self.getPicFileNameWithPath("elabel.png"))
self.epixmap_png = LoadPixmap(cached=True, path= self.getPicFileNameWithPath("epixmap.png"))
self.label_png = LoadPixmap(cached=True, path= self.getPicFileNameWithPath("label.png"))
self.pixmap_png = LoadPixmap(cached=True, path= self.getPicFileNameWithPath("pixmap.png"))
self.widget_png = LoadPixmap(cached=True, path= self.getPicFileNameWithPath("widget.png"))
if not self.selectionChanged in self["menu"].onSelectionChanged:
self["menu"].onSelectionChanged.append(self.selectionChanged)
self.onLayoutFinish.append(self.LayoutFinished)
def __init__(self, session, archivCZSK):
provider = ArchivCZSKContentProvider(
archivCZSK, os.path.join(settings.PLUGIN_PATH, 'categories'))
provider.start()
contentHandler = ArchivCZSKContentHandler(session, self, provider)
defaultCategory = config.plugins.archivCZSK.defaultCategory.value
categoryItem = categoryAddons = None
if defaultCategory != 'categories':
categoryItem = provider.get_content({'category': defaultCategory})
categoryAddons = provider.get_content(
{'category_addons': defaultCategory})
# dont add PExit() if default category is user created cat.
gotParrent = True
try:
gotParrent = self.getParent() is not None
except:
pass
if gotParrent and (defaultCategory == 'all_addons'
or defaultCategory == 'tv_addons'
or defaultCategory == 'video_addons'):
categoryAddons is not None and categoryAddons.insert(
0, PExit())
categoryItems = provider.get_content()
BaseContentScreen.__init__(self, session, contentHandler,
categoryItems)
if categoryItem is not None and categoryAddons is not None:
self.save()
self.load({
'lst_items': categoryAddons,
'parent_it': categoryItem,
'refresh': False
})
self.ctx_items.append((_("Add Category"), None, self.addCategory))
self.provider = provider
self.updateGUITimer = eTimer()
self.updateGUITimer_conn = eConnectCallback(
self.updateGUITimer.timeout, self.updateAddonGUI)
# include DownloadList
DownloadList.__init__(self)
# include TipList
TipBar.__init__(self, [self.CONTEXT_TIP], startOnShown=True)
self.onUpdateGUI.append(self.changeAddon)
self.onClose.append(self.__onClose)
from Plugins.Extensions.archivCZSK.version import version
self.setTitle("ArchivCZSK (" + toString(version) + ")")
self["image"] = Pixmap()
self["title"] = Label("")
self["author"] = Label("")
self["version"] = Label("")
self["about"] = Label("")
self["key_red"] = Label(_("Manager"))
self["key_green"] = Label(_("Support us"))
self["key_yellow"] = Label("")
self["key_blue"] = Label(_("Settings"))
self["actions"] = ActionMap(
["archivCZSKActions"], {
"ok": self.ok,
"cancel": self.cancel,
"up": self.up,
"down": self.down,
"blue": self.openSettings,
"green": self.showIconD,
"red": self.openAddonManagement,
"menu": self.menu
}, -2)
# after layout show update item "GUI" - edit: shamann
self.onLayoutFinish.append(self.updateAddonGUI)
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", {
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down,
"ok": (self.ok, _("select")),
"back": (self.cancel, _("Cancel")),
}, -2)
self["ColorActions"] = LocationBoxActionMap(
self, "ColorActions", {
"red": self.cancel,
"green": self.select,
"yellow": self.changeName,
"blue": self.addRemoveBookmark,
}, -2)
self["EPGSelectActions"] = LocationBoxActionMap(
self, "EPGSelectActions", {
"prevBouquet":
(self.switchToBookList, _("switch to bookmarks")),
"nextBouquet":
(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 __init__(self, session, playlist, playall=None, lastservice=None):
# The CutList must be initialized very first
CutList.__init__(self)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
InfoBarSupport.__init__(self)
# Skin
self.skinName = "EMCMediaCenter"
skin = None
CoolWide = getDesktop(0).size().width()
if CoolWide == 720:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/EnhancedMovieCenter/CoolSkin/EMCMediaCenter_720.xml"
elif CoolWide == 1024:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/EnhancedMovieCenter/CoolSkin/EMCMediaCenter_1024.xml"
elif CoolWide == 1280:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/EnhancedMovieCenter/CoolSkin/EMCMediaCenter_1280.xml"
if skin:
Cool = open(skin)
self.skin = Cool.read()
Cool.close()
self.serviceHandler = ServiceCenter.getInstance()
# EMC Source
self["Service"] = EMCCurrentService(session.nav, self)
# Events
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
# Disabled for tests
# If we enable them, the sound will be delayed for about 2 seconds ?
iPlayableService.evStart:
self.__serviceStarted,
iPlayableService.evStopped:
self.__serviceStopped,
#iPlayableService.evEnd: self.__evEnd,
#iPlayableService.evEOF: self.__evEOF,
#iPlayableService.evUser: self.__timeUpdated,
#iPlayableService.evUser+1: self.__statePlay,
#iPlayableService.evUser+2: self.__statePause,
iPlayableService.evUser + 3:
self.__osdFFwdInfoAvail,
iPlayableService.evUser + 4:
self.__osdFBwdInfoAvail,
#iPlayableService.evUser+5: self.__osdStringAvail,
iPlayableService.evUser + 6:
self.__osdAudioInfoAvail,
iPlayableService.evUser + 7:
self.__osdSubtitleInfoAvail,
iPlayableService.evUser + 8:
self.__chapterUpdated,
iPlayableService.evUser + 9:
self.__titleUpdated,
iPlayableService.evUser + 11:
self.__menuOpened,
iPlayableService.evUser + 12:
self.__menuClosed,
iPlayableService.evUser + 13:
self.__osdAngleInfoAvail
})
# Keymap
# self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions", -1 higher priority
# self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", 0
# self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] , 0
# self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 0
# self["CueSheetActions"] = HelpableActionMap(self, actionmap, 1 lower priority
# self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions", 1 lower priority
# self["NumberActions"] = NumberActionMap( [ "NumberActions"], 0 Set by EMC to 2 very lower priority
# self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions", 0 Set by EMC to 2 very lower priority
# self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 0 Set by EMC to 2 very lower priority
if config.EMC.movie_exit.value:
self["actions"] = HelpableActionMap(self, "CoolPlayerActions", {
"leavePlayer": (self.leavePlayer, _("Stop playback")),
}) # default priority
else:
self["actions"] = HelpableActionMap(self, "CoolPlayerActions2", {
"leavePlayer": (self.leavePlayer, _("Stop playback")),
}) # default priority
self["DVDPlayerPlaybackActions"] = HelpableActionMap(
self,
"EMCDVDPlayerActions",
{
"dvdMenu": (self.enterDVDMenu, _("show DVD main menu")),
#"showInfo": (self.showInfo, _("toggle time, chapter, audio, subtitle info")),
"nextChapter":
(self.nextChapter, _("forward to the next chapter")),
"prevChapter":
(self.prevChapter, _("rewind to the previous chapter")),
"nextTitle":
(self.nextTitle, _("jump forward to the next title")),
"prevTitle":
(self.prevTitle, _("jump back to the previous title")),
"dvdAudioMenu":
(self.enterDVDAudioMenu, _("(show optional DVD audio menu)")),
"nextAudioTrack":
(self.nextAudioTrack, _("switch to the next audio track")),
"nextSubtitleTrack":
(self.nextSubtitleTrack,
_("switch to the next subtitle language")),
"nextAngle": (self.nextAngle, _("switch to the next angle")),
},
1) # lower priority
# Only enabled if playing a dvd
self["DVDPlayerPlaybackActions"].setEnabled(False)
self["DVDMenuActions"] = ActionMap(
["WizardActions"], {
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
"ok": self.keyOk,
"back": self.keyBack,
}, 2) # lower priority
# Only enabled during DVD Menu
self["DVDMenuActions"].setEnabled(False)
self["GeneralPlayerPlaybackActions"] = HelpableActionMap(
self, "EMCGeneralPlayerActions", {
"showExtensions":
(self.openExtensions, _("view extensions...")),
"EMCGreen": (self.CoolAVSwitch, _("Format AVSwitch")),
"seekFwd": (self.seekFwd, _("Seek forward")),
"seekBack": (self.seekBack, _("Seek backward")),
"movieInfo": (self.infoMovie, _("Movie information")),
}) # default priority
self["MenuActions"].prio = 2
if "TeletextActions" in self:
self["TeletextActions"].prio = 2
self["NumberActions"].prio = 2
# Cover Anzeige
self["Cover"] = Pixmap()
# DVD Player
self["audioLabel"] = Label("")
self["subtitleLabel"] = Label("")
self["angleLabel"] = Label("")
self["chapterLabel"] = Label("")
self["anglePix"] = Pixmap()
self["anglePix"].hide()
self.last_audioTuple = None
self.last_subtitleTuple = None
self.last_angleTuple = None
self.totalChapters = 0
self.currentChapter = 0
self.totalTitles = 0
self.currentTitle = 0
self.in_menu = None
self.dvdScreen = None
# Further initialization
self.firstStart = True
self.stopped = False
self.closedByDelete = False
self.closeAll = False
self.lastservice = lastservice or self.session.nav.getCurrentlyPlayingServiceReference(
)
if not self.lastservice:
self.lastservice = InfoBar.instance.servicelist.servicelist.getCurrent(
)
self.playlist = playlist
self.playall = playall
self.playcount = -1
self.service = None
self.allowPiP = True
self.allowPiPSwap = False # this is needed for vti-image
self.realSeekLength = None
self.servicelist = InfoBar.instance.servicelist
self.picload = ePicLoad()
try:
self.picload_conn = self.picload.PictureData.connect(
self.showCoverCallback)
except:
self.picload.PictureData.get().append(self.showCoverCallback)
# Record events
try:
NavigationInstance.instance.RecordTimer.on_state_change.append(
self.recEvent)
except Exception, e:
emcDebugOut("[EMCMediaCenter] Record observer add exception:\n" +
str(e))
def __init__(self, session, libraryName, loadLibrary, playEntry, viewName, select=None, sort=None, filter=None):
'''
'''
printl("", self , "S")
self.session = session
DP_View.__init__(self, session, libraryName, loadLibrary, playEntry, viewName, select, sort, filter)
# get needed config parameters
self.mediaPath = config.plugins.dreamplex.mediafolderpath.value
self.playTheme = config.plugins.dreamplex.playTheme.value
self.fastScroll = config.plugins.dreamplex.fastScroll.value
# get data from plex library
self.image_prefix = Singleton().getPlexInstance().getServerName().lower()
# init skin elements
self["functionsContainer"] = Label()
self["btn_red"] = Pixmap()
self["btn_blue"] = Pixmap()
self["btn_yellow"] = Pixmap()
self["btn_zero"] = Pixmap()
self["btn_nine"] = Pixmap()
self["btn_pvr"] = Pixmap()
self["btn_menu"] = Pixmap()
self["txt_red"] = Label()
self["txt_filter"] = Label()
self["txt_blue"] = Label()
self["txt_blue"].setText(_("toogle View ") + _("(current 'Default')"))
self["txt_yellow"] = Label()
if self.fastScroll == True:
self["txt_yellow"].setText("fastScroll = On")
else:
self["txt_yellow"].setText("fastScroll = Off")
self["txt_pvr"] = Label()
self["txt_pvr"].setText("load additional data")
self["txt_menu"] = Label()
self["txt_menu"].setText("show media functions")
self["poster"] = Pixmap()
self["mybackdrop"] = Pixmap()
self["audio"] = MultiPixmap()
self["resolution"] = MultiPixmap()
self["aspect"] = MultiPixmap()
self["codec"] = MultiPixmap()
self["rated"] = MultiPixmap()
self["title"] = Label()
self["tag"] = Label()
self["shortDescription"] = ScrollLabel()
self["genre"] = Label()
self["year"] = Label()
self["runtime"] = Label()
self["total"] = Label()
self["current"] = Label()
self["backdroptext"] = Label()
self["postertext"] = Label()
self["rating_stars"] = ProgressBar()
self.skinName = self.viewName[2]
self.EXscale = (AVSwitch().getFramebufferScale())
self.EXpicloadPoster = ePicLoad()
self.EXpicloadBackdrop = ePicLoad()
self.onLayoutFinish.append(self.setPara)
printl("", self, "C")
def __init__(self, isAutostart, session, args=0):
Screen.__init__(self, session)
self.session = session
self.Console = Console()
self.current_service = self.session.nav.getCurrentlyPlayingServiceReference(
)
selectable_nims = []
for nim in nimmanager.nim_slots:
if nim.config_mode == 'nothing':
continue
if nim.config_mode == 'advanced' and len(
nimmanager.getSatListForNim(nim.slot)) < 1:
continue
if nim.config_mode in ('loopthrough', 'satposdepends'):
root_id = nimmanager.sec.getRoot(
nim.slot_id, int(nim.config.connectedTo.value))
if nim.type == nimmanager.nim_slots[root_id].type:
continue
if nim.isCompatible('DVB-S'):
selectable_nims.append(
(str(nim.slot), nim.friendly_full_description))
self.select_nim = ConfigSelection(choices=selectable_nims)
self.feid = 0
if self.select_nim.value != '':
self.feid = int(self.select_nim.value)
self.frontend = self.OpenFrontend()
if self.frontend is None:
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
if not self.frontend:
if session.pipshown:
session.pipshown = False
del session.pip
if not self.openFrontend():
self.frontend = None
self.session.nav.playService(None)
self.switchmode = 0
self.showhide = 0
self['menu'] = List([])
self['actions'] = NumberActionMap(
['MediaPlayerActions', 'SetupActions', 'DirectionActions'], {
'menu': self.Konfig,
'ok': self.ok,
'cancel': self.sakri,
'up': self.keyUp,
'down': self.keyDown,
'left': self.keyLeft,
'right': self.keyRight,
'nextBouquet': self.ZapUp,
'prevBouquet': self.ZapDown,
'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['text2'] = Label(_('Loading...Please Wait'))
self['start_progress'] = ProgressBar()
self['infoM0'] = Label()
self['infoM1'] = Label()
self['infoM2'] = Label()
self['l001'] = Pixmap()
self['l002'] = Pixmap()
self['l003'] = Pixmap()
self['l004'] = Pixmap()
self['l005'] = Pixmap()
self['l006'] = Pixmap()
self['l007'] = Pixmap()
self['l008'] = Pixmap()
self['picon'] = Pixmap()
self.TestCounter = 0
self.playstarted = False
self.DVBCATimer = eTimer()
self.DVBCATimer.callback.append(self.Prepare)
buffersize = 512
try:
myfile = file(
'/usr/lib/enigma2/python/Plugins/Extensions/AzIPTV/config')
for line in myfile.readlines():
if line[0:1] != '#':
ipos = ipos1 = 0
ipos = line.find('<buffersize>')
ipos1 = line.find('</buffersize>')
if ipos != '' and ipos1 != '' and ipos1 > ipos:
buffersize = int(line[ipos + 12:ipos1])
except:
print 'Error reading cfg file.'
if buffersize < 128:
buffersize = 128
hw_type = HardwareInfo().get_device_name()
if hw_type == 'minime' or hw_type == 'me':
self.cmd0 = 'rmfp_player -dram 0 -ve 0 -vd 0 -ae 0 -no_disp -prebuf '
if hw_type == 'elite' or hw_type == 'premium' or hw_type == 'premium+' or hw_type == 'ultra':
self.cmd0 = 'rmfp_player -dram 1 -ve 1 -vd 0 -ae 0 -no_disp -prebuf '
self.cmd0 = self.cmd0 + str(
buffersize
) + ' -detect_limit 100 -resetvcxo -no_close -oscaler spu -nosubs '
self.showhide = 0
self['menu1'] = MenuList([])
self['menu'] = List([])
self.onLayoutFinish.append(self.startup)
def __init__(self,
session,
text,
type=TYPE_YESNO,
timeout=-1,
close_on_any_key=False,
default=True,
enable_input=True,
msgBoxID=None,
picon=True,
simple=False,
wizard=False,
list=None,
skin_name=None,
timeout_default=None,
windowTitle=None,
title='Message'):
if not windowTitle:
windowTitle = title
if not list:
list = []
if not skin_name:
skin_name = []
self.type = type
Screen.__init__(self, session)
self.skinName = ['MessageBox']
if self.type == self.TYPE_YESNO:
self.setTitle(_('Question'))
elif self.type == self.TYPE_INFO:
self.setTitle(_('Information'))
elif self.type == self.TYPE_WARNING:
self.setTitle(_('Warning'))
elif self.type == self.TYPE_ERROR:
self.setTitle(_('Error'))
else:
self.setTitle(_(windowTitle))
if wizard:
from Components.config import config
from Components.Pixmap import MultiPixmap
self['rc'] = MultiPixmap()
self['rc'].setPixmapNum(config.misc.rcused.value)
self.skinName = ['MessageBoxWizard']
if simple:
self.skinName = ['MessageBoxSimple']
if isinstance(skin_name, str):
self.skinName = [skin_name] + self.skinName
self.msgBoxID = msgBoxID
self['text'] = Label(_(text))
self['Text'] = StaticText(_(text))
self['selectedChoice'] = StaticText()
self.text = _(text)
self.close_on_any_key = close_on_any_key
self.timeout_default = timeout_default
self['ErrorPixmap'] = Pixmap()
self['ErrorPixmap'].hide()
self['QuestionPixmap'] = Pixmap()
self['QuestionPixmap'].hide()
self['InfoPixmap'] = Pixmap()
self['InfoPixmap'].hide()
self['WarningPixmap'] = Pixmap()
self['WarningPixmap'].hide()
self.timerRunning = False
self.initTimeout(timeout)
if picon:
picon = type
if picon == self.TYPE_ERROR:
self['ErrorPixmap'].show()
elif picon == self.TYPE_YESNO:
self['QuestionPixmap'].show()
elif picon == self.TYPE_INFO or picon == self.TYPE_WARNING:
self['InfoPixmap'].show()
if picon != self.TYPE_WARNING:
self['WarningPixmap'].hide()
self.setTitle(
self.type < self.TYPE_MESSAGE
and [_('Question'),
_('Information'),
_('Warning'),
_('Error')][self.type] or 'Message')
if type == self.TYPE_YESNO:
if list:
self.list = list
elif default:
self.list = [(_('yes'), True), (_('no'), False)]
else:
self.list = [(_('no'), False), (_('yes'), True)]
else:
self.list = []
self['list'] = MenuList(self.list)
if self.list:
self['selectedChoice'].setText(self.list[0][0])
else:
self['list'].hide()
if enable_input:
self['actions'] = ActionMap(
['MsgBoxActions', 'DirectionActions'], {
'cancel': self.cancel,
'ok': self.ok,
'alwaysOK': self.alwaysOK,
'up': self.up,
'down': self.down,
'left': self.left,
'right': self.right,
'upRepeated': self.up,
'downRepeated': self.down,
'leftRepeated': self.left,
'rightRepeated': self.right
}, -1)
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Panel"))
skin = """
<screen name="SoftwarePanel" position="center,center" size="650,605" title="Software Panel">
<widget name="a_off" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/aoff.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_red" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/ared.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_yellow" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/ayellow.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_green" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/agreen.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="feedstatusRED" position="60,14" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusYELLOW" position="60,46" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusGREEN" position="60,78" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="packagetext" position="180,50" size="350,30" zPosition="1" font="Regular;25" halign="right" transparent="1" />
<widget name="packagenr" position="511,50" size="50,30" zPosition="1" font="Regular;25" halign="right" transparent="1" />
<widget source="list" render="Listbox" position="10,120" size="630,365" scrollbarMode="showOnDemand">
<convert type="TemplatedMultiContent">
{"template": [
MultiContentEntryText(pos = (5, 1), size = (540, 28), font=0, flags = RT_HALIGN_LEFT, text = 0), # index 0 is the name
MultiContentEntryText(pos = (5, 26), size = (540, 20), font=1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is the description
MultiContentEntryPixmapAlphaBlend(pos = (545, 2), size = (48, 48), png = 4), # index 4 is the status pixmap
MultiContentEntryPixmapAlphaBlend(pos = (5, 50), size = (610, 2), png = 5), # index 4 is the div pixmap
],
"fonts": [gFont("Regular", 22),gFont("Regular", 14)],
"itemHeight": 52
}
</convert>
</widget>
<ePixmap pixmap="skin_default/buttons/red.png" position=" 30,570" size="35,27" alphatest="blend" />
<widget name="key_green_pic" pixmap="skin_default/buttons/green.png" position="290,570" size="35,27" alphatest="blend" />
<widget name="key_red" position=" 80,573" size="200,26" zPosition="1" font="Regular;22" halign="left" transparent="1" />
<widget name="key_green" position="340,573" size="200,26" zPosition="1" font="Regular;22" halign="left" transparent="1" />
</screen> """
self.skin = skin
self.list = []
self.statuslist = []
self["list"] = List(self.list)
self['a_off'] = Pixmap()
self['a_red'] = Pixmap()
self['a_yellow'] = Pixmap()
self['a_green'] = Pixmap()
self['key_green_pic'] = Pixmap()
self['key_red_pic'] = Pixmap()
self['key_red'] = Label(_("Cancel"))
self['key_green'] = Label(_("Update"))
self['packagetext'] = Label(_("Updates Available:"))
self['packagenr'] = Label("0")
self['feedstatusRED'] = Label("< " + _("feed status"))
self['feedstatusYELLOW'] = Label("< " + _("feed status"))
self['feedstatusGREEN'] = Label("< " + _("feed status"))
self['key_green'].hide()
self['key_green_pic'].hide()
self.update = False
self.packages = 0
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self["actions"] = ActionMap([
"OkCancelActions", "DirectionActions", "ColorActions",
"SetupActions"
], {
"cancel": self.Exit,
"green": self.Green,
"red": self.Exit,
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session, moviename, spath=None):
Screen.__init__(self, session)
#self.session = session
self.moviename = getMovieNameWithoutExt(moviename)
moviename = getMovieNameWithoutPhrases(self.moviename)
self.movielist = None
self.spath = spath
self["previewcover"] = Pixmap()
self.picload = ePicLoad()
try:
self.picload_conn = self.picload.PictureData.connect(
self.showPreviewCoverCB)
except:
self.picload.PictureData.get().append(self.showPreviewCoverCB)
self.previewTimer = eTimer()
try:
self.previewTimer_conn = self.previewTimer.timeout.connect(
self.showPreviewCover)
except:
self.previewTimer.callback.append(self.showPreviewCover)
self.selectionTimer = eTimer()
try:
self.selectionTimer_conn = self.selectionTimer.timeout.connect(
self.updateSelection)
except:
self.selectionTimer.callback.append(self.updateSelection)
self["previewlist"] = MenuList([])
self.page = 0
self.id = None
self.cat = None
self["contenttxt"] = ScrollLabel()
self["runtime"] = Label("")
self["runtimetxt"] = Label("")
self["genre"] = Label("")
self["genretxt"] = Label("")
self["country"] = Label("")
self["countrytxt"] = Label("")
self["release"] = Label("")
self["releasetxt"] = Label("")
self["rating"] = Label("")
self["ratingtxt"] = Label("")
self["stars"] = ProgressBar()
self["starsbg"] = Pixmap()
self["stars"].hide()
self["starsbg"].hide()
self["setup"] = Label(_("Setup"))
self["key_menu"] = Pixmap()
self["save"] = Label(_("Save"))
self["key_green"] = Pixmap()
self.ratingstars = -1
self.movielist = getMovieList(moviename)
if self.movielist is not None:
self["previewlist"] = MenuList(self.movielist[0])
if self.movielist[1] > 1:
self.page = 1
self["movie_name"] = Label(
_("Search results for:") + " " + moviename)
else:
self.page = 0
sel = self["previewlist"].l.getCurrentSelection()
if sel is not None:
preview = getMovieInfo(sel[1], sel[2])
if preview is not None:
self.id = sel[1]
self.cat = sel[2]
self["previewlist"].hide()
self["movie_name"] = Label(
_("Movie Information Preview for:") + " " + moviename)
else:
self["movie_name"] = Label(
_("Search results for:") + " " + moviename)
self["contenttxt"].setText(_("Nothing was found !"))
self.file_format = "(\.ts|\.avi|\.mkv|\.divx|\.f4v|\.flv|\.img|\.iso|\.m2ts|\.m4v|\.mov|\.mp4|\.mpeg|\.mpg|\.mts|\.vob|\.asf|\.wmv|.\stream|.\webm)"
# for file-operations
self.txtsaved = False
self.jpgsaved = False
self.mpath = None
self.onLayoutFinish.append(self.layoutFinished)
self["actions"] = HelpableActionMap(
self,
"EMCMovieInfo",
{
"EMCEXIT": self.exit,
"EMCUp": self.pageUp,
"EMCDown": self.pageDown,
"EMCOK": self.ok,
"EMCGreen": self.save,
"EMCMenu": self.setup,
#"EMCINFO": self.info,
#"EMCRed": self.red,
},
-1)
self["previewlist"].onSelectionChanged.append(self.selectionChanged)
def __init__(self, session, dvd_device=None, dvd_filelist=None, args=None):
if not dvd_filelist:
dvd_filelist = []
Screen.__init__(self, session)
InfoBarBase.__init__(self)
InfoBarNotifications.__init__(self)
InfoBarCueSheetSupport.__init__(self, actionmap="MediaPlayerCueSheetActions")
InfoBarShowHide.__init__(self)
InfoBarAudioSelection.__init__(self)
InfoBarSubtitleSupport.__init__(self)
HelpableScreen.__init__(self)
self.save_infobar_seek_config()
self.change_infobar_seek_config()
InfoBarSeek.__init__(self)
InfoBarPVRState.__init__(self)
InfoBarLongKeyDetection.__init__(self)
self.oldService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.session.nav.stopService()
self["audioLabel"] = Label("n/a")
self["subtitleLabel"] = Label("")
self["angleLabel"] = Label("")
self["chapterLabel"] = Label("")
self["anglePix"] = Pixmap()
self["anglePix"].hide()
self.last_audioTuple = None
self.last_subtitleTuple = None
self.last_angleTuple = None
self.totalChapters = 0
self.currentChapter = 0
self.totalTitles = 0
self.currentTitle = 0
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evStopped: self.__serviceStopped,
iPlayableService.evUser: self.__timeUpdated,
iPlayableService.evUser + 1: self.__statePlay,
iPlayableService.evUser + 2: self.__statePause,
iPlayableService.evUser + 3: self.__osdFFwdInfoAvail,
iPlayableService.evUser + 4: self.__osdFBwdInfoAvail,
iPlayableService.evUser + 5: self.__osdStringAvail,
iPlayableService.evUser + 6: self.__osdAudioInfoAvail,
iPlayableService.evUser + 7: self.__osdSubtitleInfoAvail,
iPlayableService.evUser + 8: self.__chapterUpdated,
iPlayableService.evUser + 9: self.__titleUpdated,
iPlayableService.evUser + 11: self.__menuOpened,
iPlayableService.evUser + 12: self.__menuClosed,
iPlayableService.evUser + 13: self.__osdAngleInfoAvail
})
self["DVDPlayerDirectionActions"] = ActionMap(["DirectionActions"],
{
#MENU KEY DOWN ACTIONS
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
#MENU KEY REPEATED ACTIONS
"leftRepeated": self.doNothing,
"rightRepeated": self.doNothing,
"upRepeated": self.doNothing,
"downRepeated": self.doNothing,
#MENU KEY UP ACTIONS
"leftUp": self.doNothing,
"rightUp": self.doNothing,
"upUp": self.doNothing,
"downUp": self.doNothing,
})
self["OkCancelActions"] = ActionMap(["OkCancelActions"],
{
"ok": self.keyOk,
"cancel": self.keyCancel,
})
self["DVDPlayerPlaybackActions"] = HelpableActionMap(self, "DVDPlayerActions",
{
#PLAYER ACTIONS
"dvdMenu": (self.enterDVDMenu, _("show DVD main menu")),
"toggleInfo": (self.toggleInfo, _("toggle time, chapter, audio, subtitle info")),
"nextChapter": (self.nextChapter, _("forward to the next chapter")),
"prevChapter": (self.prevChapter, _("rewind to the previous chapter")),
"nextTitle": (self.nextTitle, _("jump forward to the next title")),
"prevTitle": (self.prevTitle, _("jump back to the previous title")),
"tv": (self.askLeavePlayer, _("exit DVD player or return to file browser")),
"dvdAudioMenu": (self.enterDVDAudioMenu, _("(show optional DVD audio menu)")),
"AudioSelection": (self.enterAudioSelection, _("Select audio track")),
"nextAudioTrack": (self.nextAudioTrack, _("switch to the next audio track")),
"nextSubtitleTrack": (self.nextSubtitleTrack, _("switch to the next subtitle language")),
"nextAngle": (self.nextAngle, _("switch to the next angle")),
"seekBeginning": self.seekBeginning,
}, -2)
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,
})
self.onClose.append(self.__onClose)
try:
from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
hotplugNotifier.append(self.hotplugCB)
except:
pass
self.autoplay = dvd_device or dvd_filelist
if dvd_device:
self.physicalDVD = True
else:
self.scanHotplug()
self.dvd_filelist = dvd_filelist
self.onFirstExecBegin.append(self.opened)
self.service = None
self.in_menu = False
if fileExists("/proc/stb/fb/dst_left"):
self.left = open("/proc/stb/fb/dst_left", "r").read()
self.width = open("/proc/stb/fb/dst_width", "r").read()
self.top = open("/proc/stb/fb/dst_top", "r").read()
self.height = open("/proc/stb/fb/dst_height", "r").read()
if self.left != "00000000" or self.top != "00000000" or self.width != "000002d0" or self.height != "0000000240":
open("/proc/stb/fb/dst_left", "w").write("00000000")
open("/proc/stb/fb/dst_width", "w").write("000002d0")
open("/proc/stb/fb/dst_top", "w").write("00000000")
open("/proc/stb/fb/dst_height", "w").write("0000000240")
self.onClose.append(self.__restoreOSDSize)
def __init__(self, session, selectedEntry, addEntry=False):
self.skin = fstabEditorScreen.skin
self.session = session
self.selectedEntry = selectedEntry
self.addEntry = addEntry
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["ButtonRed"] = Pixmap()
self["ButtonRedText"] = Label(_("Remove entry"))
if self.addEntry:
self["ButtonRed"].hide()
self["ButtonRedText"].hide()
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"green": (self.checkEntry, _("Return with saving")),
"red": (self.removeEntry, _("Remove entry")),
}, -1)
self["OkCancelActions"] = HelpableActionMap(
self, "OkCancelActions", {
"cancel": (self.cancelEntry, _("Return without saving")),
"ok": (self.ok, _("Open selector")),
}, -1)
self.list = []
ConfigListScreen.__init__(self, self.list)
if self.addEntry:
self.devicename = NoSave(ConfigText(default=""))
self.mountpoint = NoSave(ConfigText(default=""))
self.fstype = NoSave(
ConfigSelection([("auto", "auto"), ("ext2", "ext2"),
("ext3", "ext3"), ("ext4", "ext4"),
("swap", "swap"), ("tmpfs", "tmpfs"),
("proc", "proc"), ("cifs", "cifs"),
("nfs", "nfs"), ("jffs2", "jffs2"),
("usbfs", "usbfs"), ("devpts", "devpts"),
("vfat", "vfat"), ("fat", "fat"),
("ntfs", "ntfs"), ("noauto", "no auto"),
("xfs", "xfs")],
default="auto"))
self.options = NoSave(ConfigText(default="defaults"))
self.dumpfreq = NoSave(ConfigNumber(default=0))
self.passnum = NoSave(
ConfigSelection([("0", "0"), ("1", "1"), ("2", "2")],
default="0"))
else:
self.devicename = NoSave(
ConfigText(default=entryList[self.selectedEntry][0]))
self.mountpoint = NoSave(
ConfigText(default=entryList[self.selectedEntry][1]))
self.fstype = NoSave(
ConfigSelection([("auto", "auto"), ("ext2", "ext2"),
("ext3", "ext3"), ("ext4", "ext4"),
("swap", "swap"), ("tmpfs", "tmpfs"),
("proc", "proc"), ("cifs", "cifs"),
("nfs", "nfs"), ("jffs2", "jffs2"),
("usbfs", "usbfs"), ("devpts", "devpts"),
("vfat", "vfat"), ("fat", "fat"),
("ntfs", "ntfs"), ("noauto", "no auto"),
("xfs", "xfs")],
default=entryList[self.selectedEntry][2]))
self.options = NoSave(
ConfigText(default=entryList[self.selectedEntry][3]))
self.dumpfreq = NoSave(
ConfigNumber(default=int(entryList[self.selectedEntry][4])))
self.passnum = NoSave(
ConfigSelection([("0", "0"), ("1", "1"), ("2", "2")],
default=entryList[self.selectedEntry][5]))
self.list.append(
getConfigListEntry(_("device name: "), self.devicename))
self.list.append(
getConfigListEntry(_("mount point: "), self.mountpoint))
self.list.append(
getConfigListEntry(_("file system type: "), self.fstype))
self.list.append(getConfigListEntry(_("options: "), self.options))
self.list.append(
getConfigListEntry(_("dump frequency (in days): "), self.dumpfreq))
self.list.append(getConfigListEntry(_("pass num: "), self.passnum))
self["config"].setList(self.list)
def __init__(self, session, eventName, callbackNeeded=False, save=False, savepath=None, localpath=None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
for tag in config.plugins.imdb.ignore_tags.getValue().split(','):
eventName = eventName.replace(tag, '')
eventName = ' '.join(eventName.split()).strip()
self.eventName = eventName
self.callbackNeeded = callbackNeeded
self.callbackData = ""
self.callbackGenre = ""
self.saving = save
self.savingpath = savepath
self.localpath = localpath
self.fetchurl = None
self.dictionary_init()
self["poster"] = Pixmap()
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.paintPosterPixmapCB)
self["stars"] = ProgressBar()
self["starsbg"] = Pixmap()
self["stars"].hide()
self["starsbg"].hide()
self.ratingstars = -1
self["title"] = StaticText(_("The Internet Movie Database"))
# map new source -> old component
def setText(txt):
StaticText.setText(self["title"], txt)
self["titellabel"].setText(txt)
self["title"].setText = setText
self["titellabel"] = Label()
self["detailslabel"] = ScrollLabel("")
self["castlabel"] = ScrollLabel("")
self["extralabel"] = ScrollLabel("")
self["statusbar"] = Label("")
self["ratinglabel"] = Label("")
self.resultlist = []
self["menu"] = MenuList(self.resultlist)
self["menu"].hide()
self["key_red"] = Button(_("Exit"))
self["key_green"] = Button("")
self["key_yellow"] = Button("")
self["key_blue"] = Button("")
# 0 = multiple query selection menu page
# 1 = movie info page
# 2 = extra infos page
self.Page = 0
self["actionsOk"] = HelpableActionMap(self, "OkCancelActions",
{
"ok": (self.showDetails, _("Show movie and series basic details")),
"cancel": (self.exit, _("Exit IMDb search")),
}, -1)
self["actionsColor"] = HelpableActionMap(self, "ColorActions",
{
"red": (self.exit, _("Exit IMDb search")),
"green": (self.showMenu, _("Show list of matched movies an series")),
"yellow": (self.showDetails, _("Show movie and series basic details")),
"blue": (self.showExtras, _("Show movie and series extra details")),
}, -1)
self["actionsMovieSel"] = HelpableActionMap(self, "MovieSelectionActions",
{
"contextMenu": (self.contextMenuPressed, _("Menu")),
"showEventInfo": (self.showDetails, _("Show movie and series basic details")),
}, -1)
self["actionsDir"] = HelpableActionMap(self, "DirectionActions",
{
"down": (self.pageDown, _("Page down")),
"up": (self.pageUp, _("Page up")),
}, -1)
self.getIMDB()
if self.localpath is not None: # otherwise the stars are not correctly shown if we call details directly
self.onLayoutFinish.append(self._layoutFinished)
def __init__(self, session):
Screen.__init__(self, session)
self['UnhandledKeyPixmap'] = Pixmap()
def __init__(self, session, key, args=None):
Screen.__init__(self, session)
self.key = key
getHotkeyFunctions()
self.setTitle(_("Hotkey Setup") + " " + key[0][0])
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
self["key_yellow"] = StaticText("")
self["h_prev"] = Pixmap()
self["h_next"] = Pixmap()
self["description"] = Label()
self.mode = "list"
self.config = getattr(config.misc.hotkey, key[0][1])
self.expanded = []
self.selected = []
for x in self.config.value.split(','):
if x.startswith("ZapPanic"):
self.selected.append(
ChoiceEntryComponent(
'', ((_("Panic to") + " " + ServiceReference(
eServiceReference(x.split(
"/", 1)[1]).toString()).getServiceName()), x)))
elif x.startswith("Zap"):
self.selected.append(
ChoiceEntryComponent(
'', ((_("Zap to") + " " + ServiceReference(
eServiceReference(x.split(
"/", 1)[1]).toString()).getServiceName()), x)))
else:
function = next(
(function
for function in hotkey.functions if function[1] == x),
None)
if function:
self.selected.append(
ChoiceEntryComponent('', ((function[0]), function[1])))
text = _(
"Press 'OK' for attach next function or 'CH+/-' for edit attached."
) if len(self.selected) else _("Press 'OK' for attach function.")
self.prevselected = self.selected[:]
if self.prevselected:
self["key_yellow"].setText(_("Edit selection"))
self["choosen"] = ChoiceList(list=self.selected, selection=0)
self["list"] = ChoiceList(list=self.getFunctionList(), selection=0)
self["actions"] = ActionMap(
[
"OkCancelActions", "ColorActions", "DirectionActions",
"KeyboardInputActions", "MenuActions"
], {
"ok": self.keyOk,
"cancel": self.cancel,
"red": self.cancel,
"green": self.save,
"yellow": self.toggleMode,
"up": self.keyUp,
"down": self.keyDown,
"left": self.keyLeft,
"right": self.keyRight,
"upRepeated": self.keyUp,
"downRepeated": self.keyDown,
"leftRepeated": self.keyLeft,
"rightRepeated": self.keyRight,
"pageUp": self.toggleMode,
"pageDown": self.toggleMode,
"moveUp": self.moveUp,
"moveDown": self.moveDown,
"menu": boundFunction(self.close, True),
}, -1)
self.description(text)
self.showPrevNext()
self.onLayoutFinish.append(self.__layoutFinished)
def __init__(self, session, selectedmovie=None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.tags = []
if selectedmovie:
self.selected_tags = config.movielist.last_selected_tags.value
else:
self.selected_tags = None
self.selected_tags_ele = None
self.movemode = False
self.bouquet_mark_edit = False
self.delayTimer = eTimer()
self.delayTimer_conn = self.delayTimer.timeout.connect(
self.updateHDDData)
self["waitingtext"] = Label(_("Please wait... Loading list..."))
# create optional description border and hide immediately
self["DescriptionBorder"] = Pixmap()
self["DescriptionBorder"].hide()
if not fileExists(config.movielist.last_videodir.value):
config.movielist.last_videodir.value = defaultMoviePath()
config.movielist.last_videodir.save()
self.current_ref = eServiceReference(
"2:0:1:0:0:0:0:0:0:0:" + config.movielist.last_videodir.value)
ML = MovieList
if config.media_database.readmeta.value:
ML = MovieListDB
self["list"] = ML(None, config.movielist.listtype.value,
config.movielist.moviesort.value,
config.movielist.description.value)
self.list = self["list"]
self.selectedmovie = selectedmovie
# Need list for init
SelectionEventInfo.__init__(self)
self["key_red"] = Button(_("All"))
self["key_green"] = Button("")
self["key_yellow"] = Button("")
self["key_blue"] = Button("")
self["freeDiskSpace"] = self.diskinfo = DiskInfo(
config.movielist.last_videodir.value, DiskInfo.FREE, update=False)
if config.usage.setup_level.index >= 2: # expert+
self["InfobarActions"] = HelpableActionMap(
self, "InfobarActions", {
"showMovies":
(self.doPathSelect, _("select the movie path")),
})
self["MovieSelectionActions"] = HelpableActionMap(
self, "MovieSelectionActions", {
"contextMenu": (self.doContext, _("menu")),
"showEventInfo":
(self.showEventInformation, _("show event details")),
})
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.showAll, _("show all")),
"green": (self.showTagsFirst, _("show first selected tag")),
"yellow": (self.showTagsSecond, _("show second selected tag")),
"blue": (self.showTagsSelect, _("show tag menu")),
})
self["OkCancelActions"] = HelpableActionMap(
self, "OkCancelActions", {
"cancel": (self.abort, _("exit movielist")),
"ok": (self.movieSelected, _("select movie")),
})
self.onShown.append(self.go)
self.onLayoutFinish.append(self.saveListsize)
self.inited = False
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
screentitle = _("Software update")
self.menu_path = args[0]
if config.usage.show_menupath.value == 'large':
self.menu_path += screentitle
self.title = self.menu_path
self.menu_path_compressed = ""
self.menu_path += ' / '
elif config.usage.show_menupath.value == 'small':
self.title = screentitle
condtext = ""
if self.menu_path and not self.menu_path.endswith(' / '):
condtext = self.menu_path + " >"
elif self.menu_path:
condtext = self.menu_path[:-3] + " >"
self.menu_path_compressed = condtext
self.menu_path += screentitle + ' / '
else:
self.title = screentitle
self.menu_path_compressed = ""
self["menu_path_compressed"] = StaticText(self.menu_path_compressed)
Screen.setTitle(self, self.title)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self['actions'].csel = self
self["actions"].setEnabled(False)
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self['tl_off'] = Pixmap()
self['tl_red'] = Pixmap()
self['tl_yellow'] = Pixmap()
self['tl_green'] = Pixmap()
self['feedStatusMSG'] = Label()
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.updating = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.onFirstExecBegin.append(self.checkNetworkState)
def __init__(self, session):
Screen.__init__(self, session)
self['hddtempg'] = Gauge()
self['ramg'] = Gauge()
self['swapg'] = Gauge()
self['memtg'] = Gauge()
self['spacetg'] = Gauge()
self['cffg'] = Gauge()
self['usbg'] = Gauge()
self['hddg'] = Gauge()
self['flashg'] = Gauge()
self['spy1'] = Pixmap()
self['spy2'] = Pixmap()
self['spy3'] = Pixmap()
self['spy4'] = Pixmap()
self['spy5'] = Pixmap()
self['spy6'] = Pixmap()
self['spy7'] = Pixmap()
self['spy8'] = Pixmap()
self['spy9'] = Pixmap()
self['spy10'] = Pixmap()
self['spy11'] = Pixmap()
self['smallmon'] = Label('')
self['moni'] = Label('')
self['moni2'] = Label('')
self['monipix'] = Pixmap()
self['smallmon'].hide()
self['monipix'].hide()
self['moni2'].hide()
self['actions'] = ActionMap(['WizardActions', 'ColorActions', 'NumberActions'], {'ok': self.KeyOk,
'back': self.KeyOk,
'red': self.KeyRed,
'green': self.KeyGreen,
'yellow': self.KeyYellow,
'blue': self.KeyBlue,
'1': self.KeyOne,
'2': self.KeyTwo,
'3': self.KeyThree})
self.extendedFlash = False
self.activityTimer = eTimer()
self.activityTimer.timeout.get().append(self.updateList)
self.moni_state = 0
self.moniTimer = eTimer()
self.moniTimer.timeout.get().append(self.moveON)
self.onShow.append(self.startShow)
self.onClose.append(self.delTimer)
def __init__(self, session):
Screen.__init__(self, session)
self.skin = SKIN
self["background"] = Label("")
self["preview"] = Pixmap()
self.onShow.append(self.movePosition)
def __init__(self,
session,
service,
zapFunc=None,
eventid=None,
bouquetChangeCB=None,
serviceChangeCB=None):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
self.ask_time = -1 #now
self["key_red"] = Button("")
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.session = session
if isinstance(service, str) and eventid != None:
self.type = EPG_TYPE_SIMILAR
self.setTitle(_("Similar EPG"))
self["key_yellow"] = Button()
self["key_blue"] = Button()
self["key_red"] = Button()
self.currentService = service
self.eventid = eventid
self.zapFunc = None
elif isinstance(service, eServiceReference) or isinstance(
service, str):
self.setTitle(_("Single EPG"))
self.type = EPG_TYPE_SINGLE
self["key_yellow"] = Button()
self["key_blue"] = Button(_("Select Channel"))
self.currentService = ServiceReference(service)
self.zapFunc = zapFunc
self.sort_type = 0
self.setSortDescription()
else:
self.setTitle(_("Multi EPG"))
self.skinName = "EPGSelectionMulti"
self.type = EPG_TYPE_MULTI
self["key_yellow"] = Button(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = Button(
pgettext("button label, 'next screen'", "Next"))
self["now_button"] = Pixmap()
self["next_button"] = Pixmap()
self["more_button"] = Pixmap()
self["now_button_sel"] = Pixmap()
self["next_button_sel"] = Pixmap()
self["more_button_sel"] = Pixmap()
self["now_text"] = Label()
self["next_text"] = Label()
self["more_text"] = Label()
self["date"] = Label()
self.services = service
self.zapFunc = zapFunc
self["key_green"] = Button(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self["actions"] = ActionMap(
["EPGSelectActions", "OkCancelActions"],
{
"cancel": self.closeScreen,
"ok": self.eventSelected,
"timerAdd": self.timerAdd,
"yellow": self.yellowButtonPressed,
"blue": self.blueButtonPressed,
"info": self.infoKeyPressed,
"red": self.zapTo,
"menu": self.furtherOptions,
"nextBouquet": self.nextBouquet, # just used in multi epg yet
"prevBouquet": self.prevBouquet, # just used in multi epg yet
"nextService": self.nextService, # just used in single epg yet
"prevService": self.prevService, # just used in single epg yet
"preview": self.eventPreview,
})
self["actions"].csel = self
self.onLayoutFinish.append(self.onCreate)
def __init__(self, session, piclist, lastindex, path):
self["key_red"] = Button("")
self["key_green"] = Button("Slide Show")
self["key_yellow"] = Button("File View")
self["key_blue"] = Button(_("Settings"))
self.textcolor = config.plugins.mc_pp.textcolor.value
self.color = config.plugins.mc_pp.bgcolor.value
textsize = 28
self.spaceX = 20
self.spaceY = 28
self.picX = config.plugins.mc_pp.ThumbWidth.value
self.picY = config.plugins.mc_pp.ThumbHeight.value
size_w = getDesktop(0).size().width()
size_h = getDesktop(0).size().height()
if size_w == 1280:
self.spaceTop = 130
self.spaceLeft = 50
self.ButtonPosY = 95
else:
self.spaceTop = 120
self.spaceLeft = 25
self.ButtonPosY = 72
self.thumbsX = size_w / (self.spaceX + self.picX) # thumbnails in X
self.thumbsY = size_h / (self.spaceY + self.picY) # thumbnails in Y
self.thumbsC = self.thumbsX * self.thumbsY # all thumbnails
self.positionlist = []
skincontent = ""
posX = -1
for x in range(self.thumbsC):
posY = x / self.thumbsX
posX += 1
if posX >= self.thumbsX:
posX = 0
absX = self.spaceLeft + self.spaceX + (posX *
(self.spaceX + self.picX))
absY = self.spaceTop + self.spaceY + (posY *
(self.spaceY + self.picY))
self.positionlist.append((absX, absY))
skincontent += "<widget name=\"label" + str(
x
) + "\" position=\"" + str(absX + 5) + "," + str(
absY + self.picY - textsize
) + "\" size=\"" + str(self.picX - 10) + "," + str(
textsize
) + "\" font=\"Regular;14\" zPosition=\"2\" transparent=\"1\" noWrap=\"1\" foregroundColor=\"" + self.textcolor + "\" />"
skincontent += "<widget name=\"thumb" + str(
x) + "\" position=\"" + str(absX + 5) + "," + str(
absY + 5
) + "\" size=\"" + str(self.picX - 10) + "," + str(
self.picY - (textsize * 2)
) + "\" zPosition=\"2\" transparent=\"1\" alphatest=\"on\" />"
# Screen, buttons, backgroundlabel and MovingPixmap
self.skin = "<screen position=\"0,0\" size=\"" + str(
size_w
) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
<ePixmap name=\"mb_bg\" position=\"0,0\" zPosition=\"1\" size=\"" + str(
size_w
) + "," + str(
size_h
) + "\" pixmap=\"" + mcpath + "skins/defaultHD/images/frame_base-fs8.png\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-red.png\" position=\"60," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-green.png\" position=\"210," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-yellow.png\" position=\"360," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-blue.png\" position=\"510," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<widget name=\"key_red\" position=\"60," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#9f1313\" transparent=\"1\" /> \
<widget name=\"key_green\" position=\"210," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#1f771f\" transparent=\"1\" /> \
<widget name=\"key_yellow\" position=\"360," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#a08500\" transparent=\"1\" /> \
<widget name=\"key_blue\" position=\"510," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#18188b\" transparent=\"1\" /> \
<eLabel position=\"0,0\" zPosition=\"0\" size=\"" + str(size_w) + "," + str(
size_h
) + "\" backgroundColor=\"" + self.color + "\" /> \
<widget name=\"frame\" position=\"35,30\" size=\"" + str(
self.picX + 1
) + "," + str(
self.picY +
10
) + "\" pixmap=\"pic_frame.png\" zPosition=\"3\" alphatest=\"on\" />" + skincontent + "</screen>"
Screen.__init__(self, session)
self["actions"] = HelpableActionMap(
self, "MC_PictureViewerActions", {
"ok": (self.KeyOk, "Show Picture"),
"cancel": (self.Exit, "Exit Picture Viewer"),
"left": (self.key_left, "List Top"),
"right": (self.key_right, "List Bottom"),
"up": (self.key_up, "List up"),
"down": (self.key_down, "List down"),
"info": (self.StartExif, "Show File Info"),
"green": (self.startslideshow, "Start Slideshow"),
"yellow": (self.close, "File View"),
"blue": (self.Settings, "Settings"),
}, -2)
self["frame"] = MovingPixmap()
for x in range(self.thumbsC):
self["label" + str(x)] = Label()
self["thumb" + str(x)] = Pixmap()
self.Thumbnaillist = []
self.filelist = []
self.currPage = -1
self.dirlistcount = 0
self.path = path
index = 0
framePos = 0
Page = 0
for x in piclist:
if x[0][1] == False:
self.filelist.append(
(index, framePos, Page, x[0][0], path + x[0][0]))
index += 1
framePos += 1
if framePos > (self.thumbsC - 1):
framePos = 0
Page += 1
else:
self.dirlistcount += 1
self.maxentry = len(self.filelist) - 1
self.index = lastindex - self.dirlistcount
if self.index < 0:
self.index = 0
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.showPic)
self.onLayoutFinish.append(self.setPicloadConf)
self.ThumbTimer = eTimer()
self.ThumbTimer.callback.append(self.showPic)
def __init__(self, session, args=0):
self.session = session
Screen.__init__(self, session)
self.skinName = "RCUSelect"
self.index = 0
self.rcuval = []
self.rcuvalOSD = []
self["actions"] = ActionMap(
["OkCancelActions", "ColorActions"], {
"ok": self.action,
"cancel": self.close,
"red": self.close,
"green": self.action,
}, -1)
self["key_green"] = Button(_("Apply"))
self["key_red"] = Button(_("Cancel"))
self.testlist = []
self["info"] = Label()
self["list"] = MenuList(self.rcuvalOSD)
title = _("RCU Select")
self.setTitle(title)
self["pixmap"] = Pixmap()
self.rcuval = [
_("A400 NEC remote"),
_("Alien 1 Old HOF54B1-4 remote"),
_("Alien 2 New HOF55D remote"),
_("Alien 5 amlogic NEC remote"),
_("Factory amlogic NEC remote"),
_("GigaBlue 800 UE Plus remote"),
_("Golden Interstar LX3 remote"),
_("K1 Plus amlogic NEC remote"),
_("K1 Pro amlogic NEC remote"),
_("M8S ZAP-A10 NEC remote"),
_("M8S Plus amlogic NEC remote"),
_("MB2 amlogic M8B remote"),
_("MX3G amlogic MXIII-G remote"),
_("MX Pro 2 amlogic MXproII remote"),
_("MXQV20 ZAP-A10 NEC remote"),
_("MXQV31 amlogic NEC remote"),
_("Octagon SF8 remote"),
_("Qintex Q812 remote"),
_("CVT RC5 remote"),
_("RCMM amlogic NEC remote"),
_("TX1 amlogic NEC remote"),
_("TX3 Pro amlogic NEC remote"),
_("TX5 Pro amlogic NEC remote"),
_("Vander amlogic remote"),
_("Wechip V5 amlogic remote"),
_("WeTek Play NEC remote"),
_("WeTek Play (Classic) remote"),
_("WeTek Play Enigma2 remote"),
_("WeTek OpenELEC NEC remote"),
_("Xtrend ET10000 remote"),
_("Mutant HD2400 remote"),
_("AB IPBox 9900/99/55HD remote"),
_("WeTek Play 2 NEC remote"),
_("Technomate Nano remote"),
_("X96 amlogic remote"),
_("X98 amlogic remote"),
_("Zgemma Star remote")
]
self.SetOSDList()
self.MakeKeymapBckUp()
def __init__(self, session, filelist, index, path, startslide):
self.textcolor = config.plugins.mc_pp.textcolor.value
self.bgcolor = config.plugins.mc_pp.bgcolor.value
space = config.plugins.mc_pp.framesize.value
size_w = getDesktop(0).size().width()
size_h = getDesktop(0).size().height()
self.skin = "<screen position=\"0,0\" size=\"" + str(
size_w
) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
<eLabel position=\"0,0\" zPosition=\"0\" size=\"" + str(size_w) + "," + str(
size_h
) + "\" backgroundColor=\"" + self.bgcolor + "\" /><widget name=\"pic\" position=\"" + str(
space) + "," + str(space) + "\" size=\"" + str(
size_w - (space * 2)) + "," + str(
size_h - (space * 2)
) + "\" zPosition=\"1\" alphatest=\"on\" /> \
<widget name=\"point\" position=\"" + str(space + 5) + "," + str(
space + 2
) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"skin_default/icons/record.png\" alphatest=\"on\" /> \
<widget name=\"play_icon\" position=\"" + str(space + 25) + "," + str(
space + 2
) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"skin_default/icons/ico_mp_play.png\" alphatest=\"on\" /> \
<widget name=\"file\" position=\"" + str(space + 45) + "," + str(
space
) + "\" size=\"" + str(
size_w - (space * 2) - 50
) + ",25\" font=\"Regular;20\" halign=\"left\" foregroundColor=\"" + self.textcolor + "\" zPosition=\"2\" noWrap=\"1\" transparent=\"1\" /></screen>"
Screen.__init__(self, session)
InfoBarBase.__init__(self)
InfoBarSeek.__init__(self, actionmap="MediaPlayerSeekActions")
self["actions"] = ActionMap(
[
"OkCancelActions", "ColorActions", "DirectionActions",
"MovieSelectionActions"
], {
"cancel": self.Exit,
"green": self.PlayPause,
"yellow": self.PlayPause,
"blue": self.nextPic,
"red": self.prevPic,
"left": self.prevPic,
"right": self.nextPic,
"showEventInfo": self.StartExif,
}, -1)
self["point"] = Pixmap()
self["pic"] = Pixmap()
self["play_icon"] = Pixmap()
self["file"] = Label(_("please wait, loading picture..."))
self.old_index = 0
self.filelist = []
self.lastindex = index
self.currPic = []
self.shownow = True
self.dirlistcount = 0
for x in filelist:
if len(filelist[0]) == 3: #orig. filelist
if x[0][1] == False:
self.filelist.append(path + x[0][0])
else:
self.dirlistcount += 1
else: # thumbnaillist
self.filelist.append(x[T_FULL])
self.maxentry = len(self.filelist) - 1
self.index = index - self.dirlistcount
if self.index < 0:
self.index = 0
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.finish_decode)
self.slideTimer = eTimer()
self.slideTimer.callback.append(self.slidePic)
if self.maxentry >= 0:
self.onLayoutFinish.append(self.setPicloadConf)
self.__event_tracker = ServiceEventTracker(screen=self,
eventmap={
iPlayableService.evEOF:
self.doEOF,
})
if startslide == True:
self.PlayPause()
if config.plugins.mc_pp.musicenable.value == True and config.plugins.mc_pp.music.value != "none":
if pathExists(config.plugins.mc_pp.music.value):
self.session.nav.playService(
eServiceReference(4097, 0,
config.plugins.mc_pp.music.value))
def __init__(self, session, filelist, index, path):
self.textcolor = config.pic.textcolor.value
self.bgcolor = config.pic.bgcolor.value
space = config.pic.framesize.value
self.size_w = size_w = getDesktop(0).size().width()
self.size_h = size_h = getDesktop(0).size().height()
if config.pic.fullview_resolution.value and (size_w, size_h) != eval(
config.pic.fullview_resolution.value):
(size_w, size_h) = eval(config.pic.fullview_resolution.value)
gMainDC.getInstance().setResolution(size_w, size_h)
getDesktop(0).resize(eSize(size_w, size_h))
self.skin = "<screen position=\"0,0\" size=\"" + str(
size_w
) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
<eLabel position=\"0,0\" zPosition=\"0\" size=\"" + str(size_w) + "," + str(
size_h
) + "\" backgroundColor=\"" + self.bgcolor + "\" /><widget name=\"pic\" position=\"" + str(
space) + "," + str(space) + "\" size=\"" + str(
size_w - (space * 2)) + "," + str(
size_h - (space * 2)
) + "\" zPosition=\"1\" alphatest=\"on\" /> \
<widget name=\"point\" position=\"" + str(space + 5) + "," + str(
space + 2
) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"skin_default/icons/record.png\" alphatest=\"on\" /> \
<widget name=\"play_icon\" position=\"" + str(space + 25) + "," + str(
space + 2
) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"skin_default/icons/ico_mp_play.png\" alphatest=\"on\" /> \
<widget source=\"file\" render=\"Label\" position=\"" + str(
space + 45
) + "," + str(space) + "\" size=\"" + str(
size_w - (space * 2) - 50
) + ",25\" font=\"Regular;20\" borderWidth=\"1\" borderColor=\"#000000\" halign=\"left\" foregroundColor=\"" + self.textcolor + "\" zPosition=\"2\" noWrap=\"1\" transparent=\"1\" /></screen>"
Screen.__init__(self, session)
self["actions"] = ActionMap(
[
"OkCancelActions", "ColorActions", "DirectionActions",
"MovieSelectionActions"
], {
"cancel": self.Exit,
"green": self.PlayPause,
"yellow": self.PlayPause,
"blue": self.nextPic,
"red": self.prevPic,
"left": self.prevPic,
"right": self.nextPic,
"showEventInfo": self.StartExif,
}, -1)
self["point"] = Pixmap()
self["pic"] = Pixmap()
self["play_icon"] = Pixmap()
self["file"] = StaticText(_("please wait, loading picture..."))
self.old_index = 0
self.filelist = []
self.lastindex = index
self.currPic = []
self.shownow = True
self.dirlistcount = 0
for x in filelist:
if len(filelist[0]) == 3: #orig. filelist
if x[0][1] == False:
self.filelist.append(path + x[0][0])
else:
self.dirlistcount += 1
elif len(filelist[0]) == 2: #scanlist
if x[0][1] == False:
self.filelist.append(x[0][0])
else:
self.dirlistcount += 1
else: # thumbnaillist
self.filelist.append(x[T_FULL])
self.maxentry = len(self.filelist) - 1
self.index = index - self.dirlistcount
if self.index < 0:
self.index = 0
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.finish_decode)
self.slideTimer = eTimer()
self.slideTimer.callback.append(self.slidePic)
if self.maxentry >= 0:
self.onLayoutFinish.append(self.setPicloadConf)
def __init__(self, session, tlist, menuTitle):
Screen.__init__(self, session)
self.skinName = 'Iconmain'
self.tlist = tlist
ipage = 1
list = []
nopic = len(self.tlist)
self.pos = []
self.ipage = 1
self.index = 0
title = menuTitle
self['title'] = Button(title)
self.icons = []
self.indx = []
n1 = len(tlist)
self.picnum = n1
list = []
tlist = []
self['label1'] = StaticText()
self['label2'] = StaticText()
self['label3'] = StaticText()
self['label4'] = StaticText()
self['label5'] = StaticText()
self['label6'] = StaticText()
self['label1s'] = StaticText()
self['label2s'] = StaticText()
self['label3s'] = StaticText()
self['label4s'] = StaticText()
self['label5s'] = StaticText()
self['label6s'] = StaticText()
self['pointer'] = Pixmap()
self['pixmap1'] = Pixmap()
self['pixmap2'] = Pixmap()
self['pixmap3'] = Pixmap()
self['pixmap4'] = Pixmap()
self['pixmap5'] = Pixmap()
self['pixmap6'] = Pixmap()
self['red'] = Button(_('Exit'))
self['green'] = Button(_('Select'))
self['yellow'] = Button(_('Config'))
self['actions'] = NumberActionMap(['OkCancelActions',
'MenuActions',
'DirectionActions',
'NumberActions',
'ColorActions'], {'ok': self.okbuttonClick,
'cancel': self.closeNonRecursive,
'left': self.key_left,
'right': self.key_right,
'up': self.key_up,
'down': self.key_down,
'red': self.cancel,
'green': self.okbuttonClick,
'yellow': self.key_menu,
'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})
self.index = 0
i = 0
self.maxentry = 29
self.istart = 0
i = 0
self.onShown.append(self.openTest)
