def getSkin(self):
if config.MVC.skinstyle.value == "right":
skin = getSkinPath("Selection_right.xml")
elif config.MVC.skinstyle.value == "rightpig":
skin = getSkinPath("Selection_right_pig.xml")
else:
skin = getSkinPath("Selection_myskin.xml")
return skin
def __init__(self, session, filelist, index, filelistsort=0):
print("MDC-I: Picture: MDCPicturePlayer: __init__")
self.slideshow_active = False
self.filelistsort = filelistsort
size_w = getDesktop(0).size().width()
size_h = getDesktop(0).size().height()
#print("MDC: Picture: __init__: size_w: %s, size_h: %s" % (size_w, size_h))
ico_mp_forward = getSkinPath('images/media-seek-forward.svg')
ico_mp_rewind = getSkinPath('images/media-seek-backward.svg')
self.skin =\
'<screen position="0,0" size="1920,1080" flags="wfNoBorder" >\
<widget name="BGlabel" position="0,0" zPosition="0" size="1920,1080" />\
<widget name="pic" position="0,0" size="1920,1080" zPosition="1" />\
<widget name="play_icon" position="5,3" size="25,25" zPosition="2" pixmaps="' + ico_mp_forward + ',' + ico_mp_rewind + '" alphatest="on" />\
<widget name="label" position="35,5" size="1885,25" font="Regular;18" halign="left" zPosition="2" noWrap="1" transparent="1" />\
</screen>'
PixmapDisplay.__init__(self)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["actions"] = HelpableActionMap(
self,
"MDCActions", {
'menu': (self.KeyMenu, _('Settings')),
'info': (self.KeyInfo, _('Information')),
'playpause':
(self.PlayPause, _('Pause / Resume') + ' ' + _('Slideshow')),
'stop': (self.stopSlideshow, _('Stop') + ' ' + _('Slideshow')),
'historyNext': (self.nextFile, _('Next picture')),
'right': (self.nextFile, _('Next picture')),
'historyBack': (self.prevFile, _('Previous picture')),
'left': (self.prevFile, _('Previous picture')),
'yellow': (self.rotateFile, _('Rotate picture')),
'blue': (self.toggleInfo, _('Toggle info')),
'exit': (self.KeyExit, _('Exit')),
'red': (self.KeyExit, _('Exit')),
},
prio=-1)
self['BGlabel'] = Label()
self['pic'] = Pixmap()
self['play_icon'] = MultiPixmap()
self['label'] = Label()
self['lcdinfo'] = StaticText()
self['title'] = StaticText()
self.filelist = filelist
self.fileindex = index
self.tempfile = None
self.direction = 1
self.slideTimer = eTimer()
self.slideTimer_conn = self.slideTimer.timeout.connect(self.nextSlide)
self.onLayoutFinish.append(self.LayoutFinish)
def applyPluginStyle():
logger.info("...")
layout_screen_path = resolveFilename(
SCOPE_SKIN, "Default-FHD/MovieCockpit/skin/layout_screen.xml")
if os.path.islink(layout_screen_path):
deleteFile(layout_screen_path)
createSymlink(getSkinPath(config.plugins.moviecockpit.layout_screen.value),
layout_screen_path)
layout_button_path = resolveFilename(
SCOPE_SKIN, "Default-FHD/MovieCockpit/skin/layout_button.xml")
if os.path.islink(layout_button_path):
deleteFile(layout_button_path)
createSymlink(getSkinPath(config.plugins.moviecockpit.layout_button.value),
layout_button_path)
def doActivityTimer(self):
path = getSkinPath("images/spinner/wait%s.png" % (self.pic_index + 1))
logger.debug("pic_index: %s", self.pic_index)
pixmap = LoadPixmap(path, cached=False)
self.pic_loading.instance.setPixmap(pixmap)
if self.summaries:
self.summaries[0]["lcd_pic_loading"].instance.setPixmap(pixmap)
self.pic_index = (self.pic_index + 1) % self.pics
def start(self):
logger.debug("...")
self.activity_timer.start(ACTIVITY_TIMER_DELAY, False)
self.pic_loading.instance.setShowHideAnimation("")
if self.summaries:
self.summaries[0]["background"].instance.setPixmap(
LoadPixmap(getSkinPath("skin_default/display_bg.png"),
cached=False))
self.summaries[0]["lcd_pic_loading"].setShowHideAnimation("")
self.summaries[0]["lcd_pic_loading"].show()
def getCover(self, path):
logger.info("path: %s", path)
cover = ""
path, ext = os.path.splitext(path)
# strip cut number
if path[-4] == "_" and path[-3:].isdigit():
path = path[:-4]
path += ext
afile = FileManager.getInstance().getFile("covers", path)
if afile:
cover = afile[COVER_IDX_COVER]
if not cover and config.plugins.moviecockpit.cover_fallback.value:
cover = readFile(getSkinPath("images/no_cover.png"))
return cover
def loadPluginSkin(skin_file):
default_skin = resolveFilename(SCOPE_SKIN, "Default-FHD/MediaCockpit")
current_skin = resolveFilename(SCOPE_CURRENT_SKIN, "MediaCockpit")
plugin_skin = resolveFilename(SCOPE_PLUGINS, "Extensions/MediaCockpit")
print("MDC-I: plugin: loadPluginSkin: current_skin: %s" % current_skin)
print("MDC-I: plugin: loadPluginSkin: default_skin: %s" % default_skin)
print("MDC-I: plugin: loadPluginSkin: plugin_skin: %s" % plugin_skin)
if not (os.path.islink(default_skin) or os.path.isdir(default_skin)):
print("MDC-I: plugin: loadPluginSkin: ln -s " + plugin_skin + " " +
resolveFilename(SCOPE_SKIN, "Default-FHD"))
os.system("ln -s " + plugin_skin + " " +
resolveFilename(SCOPE_SKIN, "Default-FHD"))
loadSkin(getSkinPath(skin_file), "")
path, dom_skin = dom_skins[-1:][0]
loadSingleSkinData(getDesktop(0), dom_skin, path)
def playStateChanged(self, state):
logger.info("state: %s", state)
play_state = state[3]
logger.debug("play_state: %s", play_state)
state_pic = "stop.svg"
factor = ""
if play_state == ">":
state_pic = "dvr_play.svg"
elif play_state == "||":
state_pic = "dvr_pause.svg"
elif play_state == "Stop":
state_pic = "dvr_stop.svg"
elif play_state == "End":
state_pic = "dvr_stop.svg"
factor = _("End")
elif play_state.startswith(">>"):
factor = play_state.split(" ")[1]
state_pic = "dvr_forward.svg"
elif play_state.startswith("<<"):
state_pic = "dvr_backward.svg"
factor = play_state.split(" ")[1]
elif play_state.startswith("/"):
state_pic = "dvr_play.svg"
factor = "1" + play_state + "x"
self.pvr_state_dialog["state_pic"].instance.setPixmap(
LoadPixmap(getSkinPath("images/dvr_controls/" + state_pic),
cached=False,
size=eSize(100, 100)))
self.pvr_state_dialog["state"].setText(factor)
logger.debug("seekstate: %s", self.seekstate)
if not config.usage.show_infobar_on_skip.value and self.seekstate in (
self.SEEK_STATE_PLAY, self.SEEK_STATE_STOP):
self.pvr_state_dialog.hide()
else:
self.mayShow()
def showCover(self, service=None):
if service:
jpgpath = self.getCoverPath(service.getPath())
if not os.path.exists(jpgpath):
jpgpath = None
if config.MVC.cover_fallback.value:
jpgpath = getSkinPath("img/no_cover.svg")
print("MVC: MovieSelectionEventInfo: showCover: jpgpath " +
str(jpgpath))
if jpgpath:
if config.MVC.cover.value:
if self.cover:
self["Cover"].show()
self["CoverBg"].show()
self["CoverBgLbl"].show()
if config.MVC.cover_hide_miniTV.value:
self.miniTV_off()
self.displayCover(jpgpath, self["Cover"])
else:
self.hideCover()
else:
self["Cover"].hide()
def showCover(self):
print("MVC: TMDBInfo: ShowCover")
self.displayCover(TEMP_COVER, self["previewcover"], getSkinPath("img/tmdb.svg"))
class MovieList(TemplatedMultiContentComponent):
COMPONENT_ID = ""
default_template = readFile(getSkinPath("MovieListTemplate.py"))
GUI_WIDGET = eListbox
def __init__(self, current_sort_mode):
logger.debug("...")
self.current_sort_mode = current_sort_mode
self.file_list = []
self.selection_list = []
self.lock_list = {}
self.list_styles = {}
self.file_list_index = {}
self.skinAttributes = None
TemplatedMultiContentComponent.__init__(self)
self.l.setBuildFunc(self.buildMovieListEntry)
self.color = parseColor(config.plugins.moviecockpit.color.value).argb()
self.color_sel = parseColor(
config.plugins.moviecockpit.color_sel.value).argb()
self.recording_color = parseColor(
config.plugins.moviecockpit.recording_color.value).argb()
self.recording_color_sel = parseColor(
config.plugins.moviecockpit.recording_color_sel.value).argb()
self.selection_color = parseColor(
config.plugins.moviecockpit.selection_color.value).argb()
self.selection_color_sel = parseColor(
config.plugins.moviecockpit.selection_color_sel.value).argb()
skin_path = getSkinPath("images/")
self.pic_back = LoadPixmap(skin_path + "back.svg",
cached=True,
size=eSize(24, 24))
self.pic_directory = LoadPixmap(skin_path + "dir.svg",
cached=True,
size=eSize(24, 24))
self.pic_link = LoadPixmap(skin_path + "link.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_default = LoadPixmap(skin_path + "movie_default.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_watching = LoadPixmap(skin_path + "movie_watching.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_finished = LoadPixmap(skin_path + "movie_finished.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_rec = LoadPixmap(skin_path + "movie_rec.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_cut = LoadPixmap(skin_path + "movie_cut.svg",
cached=True,
size=eSize(24, 24))
self.pic_bookmark = LoadPixmap(skin_path + "bookmark.svg",
cached=True,
size=eSize(24, 24))
self.pic_trashcan = LoadPixmap(skin_path + "trashcan.svg",
cached=True,
size=eSize(24, 24))
self.pic_progress_bar = LoadPixmap(skin_path + "progcl.svg",
cached=True)
self.pic_rec_progress_bar = LoadPixmap(skin_path + "rec_progcl.svg",
cached=True)
self.onSelectionChanged = []
def postWidgetCreate(self, instance):
instance.setWrapAround(True)
instance.setContent(self.l)
self.selectionChanged_conn = instance.selectionChanged.connect(
self.selectionChanged)
def preWidgetRemove(self, instance):
instance.setContent(None)
self.selectionChanged_conn = None
def setListStyle(self, list_style):
self.list_style = list_style
config.plugins.moviecockpit.list_style.value = list_style
config.plugins.moviecockpit.list_style.save()
self.setTemplate(self.list_styles[list_style][0])
self.invalidateList()
def toggleListStyle(self):
index = self.list_style
list_style = (index + 1) % len(self.list_styles)
self.setListStyle(list_style)
def getListStyles(self):
return self.list_styles
def selectionChanged(self):
logger.debug("...")
for function in self.onSelectionChanged:
function()
### move functions
def moveUp(self, n=1):
for _i in range(int(n)):
self.instance.moveSelection(self.instance.moveUp)
def moveDown(self, n=1):
for _i in range(int(n)):
self.instance.moveSelection(self.instance.moveDown)
def pageUp(self):
self.instance.moveSelection(self.instance.pageUp)
def pageDown(self):
self.instance.moveSelection(self.instance.pageDown)
def moveTop(self):
self.instance.moveSelection(self.instance.moveTop)
def moveEnd(self):
self.instance.moveSelection(self.instance.moveEnd)
def moveToIndex(self, index):
self.instance.moveSelectionTo(index)
def moveToPath(self, path):
index = self.getFileIndex(path)
self.moveToIndex(index)
def moveBouquetPlus(self):
if config.plugins.moviecockpit.list_bouquet_keys.value == "":
self.moveTop()
elif config.plugins.moviecockpit.list_bouquet_keys.value == "Skip":
self.moveUp(config.plugins.moviecockpit.list_skip_size.value)
def moveBouquetMinus(self):
if config.plugins.moviecockpit.list_bouquet_keys.value == "":
self.moveEnd()
elif config.plugins.moviecockpit.list_bouquet_keys.value == "Skip":
self.moveDown(config.plugins.moviecockpit.list_skip_size.value)
### selection functions
def getDirSelectionList(self, adir):
logger.info("adir: %s", adir)
file_list = FileManager.getInstance().getFileList([adir])
for afile in file_list:
self.selection_list.append(afile[FILE_IDX_PATH])
dir_list = FileManager.getInstance().getDirList([adir])
for adirfile in dir_list:
if adirfile[FILE_IDX_FILENAME] != "..":
self.getDirSelection(adirfile[FILE_IDX_PATH])
logger.debug("selection_list: %s", self.selection_list)
def getSelectionList(self):
if not self.selection_list:
# if no selections were made, add the current cursor position
path = self.getCurrentPath()
if path and not path.endswith("..") and path not in self.lock_list:
self.selectPath(path)
self.moveDown()
selection_list = self.selection_list[:]
for path in selection_list:
index = self.getFileIndex(path)
if index > -1:
if self.file_list[index][FILE_IDX_TYPE] == FILE_IDX_DIR:
self.getDirSelectionList(path)
selection_list = self.selection_list[:]
return selection_list
def selectPath(self, path):
logger.debug("path: %s", path)
if path and not path.endswith(
"..") and path not in self.selection_list:
self.selection_list.append(path)
index = self.getFileIndex(path)
if index > -1:
self.invalidateEntry(index)
def unselectPath(self, path):
logger.debug("path: %s", path)
if path in self.selection_list:
self.selection_list.remove(path)
index = self.getFileIndex(path)
if index > -1:
self.invalidateEntry(index)
def selectAll(self):
logger.debug("...")
for afile in self.file_list:
self.selectPath(afile[FILE_IDX_PATH])
def unselectAll(self):
logger.debug("...")
selection_list = self.selection_list[:]
for path in selection_list:
self.unselectPath(path)
def toggleSelection(self):
path = self.getCurrentPath()
logger.debug("path: %s", path)
logger.debug("selection_list: %s", self.selection_list)
if path in self.selection_list and path not in self.lock_list:
self.unselectPath(path)
else:
self.selectPath(path)
self.moveDown()
### sort functions
def toggleSortMode(self):
self.current_sort_mode = str(
(int(self.current_sort_mode) + 2) % len(sort_modes))
self.loadList()
return self.current_sort_mode
def toggleSortOrder(self):
mode, order = sort_modes[self.current_sort_mode][0]
order = not order
for mode_id, sort_mode in sort_modes.items():
if sort_mode[0] == (mode, order):
self.current_sort_mode = mode_id
break
self.loadList()
return self.current_sort_mode
### list functions
def getCurrentPath(self):
path = ""
current_selection = self.l.getCurrentSelection()
if current_selection:
path = current_selection[FILE_IDX_PATH]
return path
def getCurrentDir(self):
directory = ""
current_selection = self.l.getCurrentSelection()
if current_selection:
directory = current_selection[FILE_IDX_DIR]
return directory
def getFile(self, path):
afile = []
if not path:
path = self.getCurrentPath()
index = self.getFileIndex(path)
if index > -1:
afile = self.file_list[index]
return afile
def getFileIndex(self, path):
index = -1
if path in self.file_list_index:
index = self.file_list_index[path]
return index
def getCurrentIndex(self):
return self.instance.getCurrentIndex()
def getCurrentSelection(self):
return self.l.getCurrentSelection()
def invalidateList(self):
self.lock_list = FileManager.getInstance().getLockList()
self.l.invalidate()
def invalidateEntry(self, i):
if i > -1:
self.l.invalidateEntry(i)
def sortList(self, file_list, dir_list, sort_mode, sort_order):
logger.debug("list_dirs_inline: %s",
config.plugins.moviecockpit.list_dirs_inline.value)
dir_list.sort(key=lambda x: (x[FILE_IDX_NAME].lower()))
if config.plugins.moviecockpit.list_dirs_inline.value and sort_mode == "alpha":
file_list = file_list + dir_list
dir_list = []
if sort_mode == "date":
if not sort_order:
file_list.sort(
key=lambda x:
(x[FILE_IDX_EVENT_START_TIME], x[FILE_IDX_NAME].lower()),
reverse=True)
else:
file_list.sort(key=lambda x: (x[FILE_IDX_EVENT_START_TIME], x[
FILE_IDX_NAME].lower()))
elif sort_mode == "alpha":
if not sort_order:
file_list.sort(key=lambda x: (x[FILE_IDX_NAME].lower(), -x[
FILE_IDX_EVENT_START_TIME]))
else:
file_list.sort(
key=lambda x:
(x[FILE_IDX_NAME].lower(), x[FILE_IDX_EVENT_START_TIME]),
reverse=True)
if config.plugins.moviecockpit.list_dirs_inline.value and sort_mode == "date":
alist = file_list + dir_list
else:
alist = dir_list + file_list
return alist
def loadList(self, load_dir=None, selection_path=None):
logger.info("load_dir: %s, selection_path: %s", load_dir,
selection_path)
if load_dir is None:
load_dir = self.getCurrentDir()
if selection_path is None:
selection_path = self.getCurrentPath()
logger.info("load_dir: %s, selection_path: %s", load_dir,
selection_path)
self.lock_list = FileManager.getInstance().getLockList()
self.selection_list = []
header_list = []
file_list = []
dir_list = []
if load_dir in MountCockpit.getInstance().getMountedBookmarks(ID):
if config.plugins.moviecockpit.trashcan_enable.value and config.plugins.moviecockpit.trashcan_show.value:
trashcan_dir = os.path.join(load_dir, "trashcan")
trashcan = FileManager.getInstance().newDirData(trashcan_dir)
header_list.append(trashcan)
else:
up_dir = os.path.join(load_dir, "..")
up = FileManager.getInstance().newDirData(up_dir)
header_list.append(up)
all_load_dirs = MountCockpit.getInstance().getVirtualDirs(
ID, [load_dir])
if config.plugins.moviecockpit.directories_show.value:
dir_list = FileManager.getInstance().getDirList(all_load_dirs)
file_list = FileManager.getInstance().getFileList(all_load_dirs)
sort_mode, sort_order = sort_modes[self.current_sort_mode][0]
self.file_list = header_list + self.sortList(file_list, dir_list,
sort_mode, sort_order)
self.file_list_index = {}
for index, afile in enumerate(self.file_list):
if afile:
self.file_list_index[afile[FILE_IDX_PATH]] = index
self.l.setList(self.file_list)
logger.debug("moveToPath: %s", selection_path)
self.moveToPath(selection_path)
### skin functions
def applySkin(self, desktop, parent):
attribs = []
value_attributes = []
size_attributes = []
font_attributes = []
color_attributes = []
if self.skinAttributes:
for (attrib, value) in self.skinAttributes:
if attrib in value_attributes:
setattr(self, attrib, int(value))
elif attrib in size_attributes:
setattr(self, attrib, parseSize(value, ((1, 1), (1, 1))))
elif attrib in font_attributes:
setattr(self, attrib, parseFont(value, ((1, 1), (1, 1))))
elif attrib in color_attributes:
setattr(self, attrib, parseColor(value).argb())
else:
attribs.append((attrib, value))
self.skinAttributes = attribs
self.list_styles, template_attributes = parseTemplate(
MovieList.default_template)
self.setListStyle(config.plugins.moviecockpit.list_style.value)
logger.debug("self.skinAttributes: %s", str(self.skinAttributes))
GUIComponent.applySkin(self, desktop, parent)
template_attributes["width"] = self.l.getItemSize().width() - 15
self.applyTemplate(additional_locals=template_attributes)
### list build function
def buildMovieListEntry(self, _directory, file_type, path, _file_name,
_ext, name, event_start_time,
_recording_start_time, _recording_stop_time,
length, description, _extended_description,
service_reference, _size, cuts, tags):
def isCutting(path):
logger.debug("isCutting: path: %s", path)
file_name = os.path.splitext(path)[0]
return file_name.endswith("_") and not os.path.exists(file_name +
".eit")
def getPicon(service_reference):
pos = service_reference.rfind(':')
if pos != -1:
service_reference = service_reference[:pos].rstrip(
':').replace(':', '_')
picon_path = os.path.join(
config.usage.configselection_piconspath.value,
service_reference + '.png')
logger.debug("picon_path: %s", picon_path)
return loadPNG(picon_path)
def getDateText(path, file_type, date):
logger.debug("path: %s, file_type: %s, date: %s", path, file_type,
date)
count = 0
date_text = ""
if path in self.lock_list:
file_op = self.lock_list[path]
if file_op == FILE_OP_COPY:
date_text = _("COPYING")
elif file_op == FILE_OP_MOVE:
date_text = _("MOVING")
elif file_op == FILE_OP_DELETE:
date_text = _("DELETING")
else:
if file_type == FILE_TYPE_FILE:
if config.plugins.moviecockpit.list_show_mount_points.value:
words = path.split("/")
if len(words) > 3 and words[1] == "media":
date_text = words[2]
else:
date_text = datetime.fromtimestamp(date).strftime(
config.plugins.moviecockpit.movie_date_format.value
)
else:
if os.path.basename(path) == "trashcan":
info_value = config.plugins.moviecockpit.trashcan_info.value
else:
info_value = config.plugins.moviecockpit.directories_info.value
if os.path.basename(path) == "..":
date_text = _("up")
else:
if info_value == "D":
if os.path.basename(path) == "trashcan":
date_text = _("trashcan")
else:
date_text = _("directory")
else:
count, size = FileManager.getInstance(
).getCountSize(path)
counttext = "%d" % count
size /= (1024 * 1024 * 1024) # GB
sizetext = "%.0f GB" % size
if size >= 1024:
sizetext = "%.1f TB" % (size / 1024)
if info_value == "C":
date_text = "(%s)" % counttext
elif info_value == "S":
date_text = "(%s)" % sizetext
elif info_value == "CS":
date_text = "(%s/%s)" % (counttext, sizetext)
logger.debug("count: %s, date_text: %s", count, date_text)
return date_text
def getProgress(recording, path, event_start_time, length, cuts):
logger.debug("path: %s", path)
if recording:
last = time() - event_start_time
else:
# get last position from cut file
cut_list = unpackCutList(cuts)
logger.debug("cut_list: %s", cut_list)
last = ptsToSeconds(getCutListLast(cut_list))
logger.debug("last: %s", last)
progress = 0
if length > 0 and last > 0:
last = min(last, length)
progress = int(round(float(last) / float(length), 2) * 100)
logger.debug("progress: %s, path: %s, length: %s, recording: %s",
progress, path, length, recording)
return progress
def getFileIcon(path, file_type, progress, recording, cutting):
pixmap = None
if file_type == FILE_TYPE_FILE:
pixmap = self.pic_movie_default
if recording:
pixmap = self.pic_movie_rec
elif cutting:
pixmap = self.pic_movie_cut
else:
if progress >= int(config.plugins.moviecockpit.
movie_finished_percent.value):
pixmap = self.pic_movie_finished
elif progress >= int(config.plugins.moviecockpit.
movie_watching_percent.value):
pixmap = self.pic_movie_watching
elif file_type == FILE_TYPE_LINK:
pixmap = self.pic_link
elif file_type == FILE_TYPE_DIR:
pixmap = self.pic_directory
if os.path.basename(path) == "trashcan":
pixmap = self.pic_trashcan
elif os.path.basename(path) == "..":
pixmap = self.pic_back
return pixmap
def getColor(path, file_type, recording, cutting):
if path in self.selection_list or path in self.lock_list:
color = self.selection_color
color_sel = self.selection_color_sel
else:
if file_type == FILE_TYPE_FILE:
if recording or cutting:
color = self.recording_color
color_sel = self.recording_color_sel
else:
color = self.color
color_sel = self.color_sel
else:
color = self.color_sel
color_sel = self.color_sel
return color, color_sel
logger.debug("list_style: %s", self.list_styles[self.list_style][0])
service = ServiceReference(service_reference)
service_name = service.getServiceName() if service is not None else ""
recording = isRecording(path)
cutting = isCutting(path)
color, color_sel = getColor(path, file_type, recording, cutting)
progress = getProgress(recording, path, event_start_time, length,
cuts) if file_type == FILE_TYPE_FILE else -1
progress_string = str(progress) + "%" if progress >= 0 else ""
progress_bar = self.pic_rec_progress_bar if recording else self.pic_progress_bar
length_string = str(length / 60) + " " + _(
"min") if file_type == FILE_TYPE_FILE else ""
picon = getPicon(
service_reference) if file_type == FILE_TYPE_FILE else None
name = _(name) if name == "trashcan" else name
date_text = getDateText(path, file_type, event_start_time)
file_icon = getFileIcon(path, file_type, progress, recording, cutting)
res = [
None,
name, # 1: name
tags, # 2: tags
service_name, # 3: service name
description, # 4: short description
date_text, # 5: event start time
length_string, # 6: length
color, # 7: color
color_sel, # 8: color_sel
progress, # 9: progress percent (-1 = don't show)
progress_string, # 10: progress (xx%)
progress_bar, # 11: progress bar png
file_icon, # 12: status icon png
picon, # 13: picon png
]
#logger.debug("self.res: %s", res)
return res
def showCoverDelayed(self):
logger.debug("self.cover_path: %s", self.cover_path)
self.showCover(self["cover"], self.cover_path,
getSkinPath("images/tmdb.svg"))
def initSkin(self):
self.MVCFont = parseFont("Regular;30", ((1, 1), (1, 1)))
self.MVCSelectFont = parseFont("Regular;30", ((1, 1), (1, 1)))
self.MVCDateFont = parseFont("Regular;28", ((1, 1), (1, 1)))
self.MVCStartHPos = 10
self.MVCSpacer = 10
self.MVCMovieHPos = None
self.MVCMovieVPos = None
self.MVCMovieWidth = None
self.MVCDateHPos = None
self.MVCDateVPos = None
self.MVCDateWidth = 230
self.MVCProgressHPos = None
self.MVCProgressVPos = None
self.MVCBarHPos = None
self.MVCBarVPos = None
self.MVCBarSize = parseSize("90, 14", ((1, 1), (1, 1)))
self.MVCIconVPos = None
self.MVCIconHPos = None
self.MVCIconSize = parseSize("45, 35", ((1, 1), (1, 1)))
self.MVCRecIconVPos = None
self.MVCRecIconHPos = None
self.MVCRecIconSize = parseSize("230, 40", ((1, 1), (1, 1)))
# MVCSelNumTxtHPos is equal to MVCIconHPos
# MVCSelNumTxtWidth is equal to MVCIconSize.width()
self.MVCSelNumTxtVPos = None
self.MVCPiconHPos = None
self.MVCPiconVPos = None
self.MVCPiconSize = parseSize("55, 35", ((1, 1), (1, 1)))
self.DefaultColor = parseColor("#bababa").argb()
self.TitleColor = parseColor("#bababa").argb()
self.DateColor = parseColor("#bababa").argb()
self.BackColor = None
self.BackColorSel = None
self.FrontColorSel = parseColor(
config.MVC.color_highlight.value).argb()
self.RecordingColor = parseColor(
config.MVC.color_recording.value).argb()
skin_path = getSkinPath("img/")
self.pic_back = LoadPixmap(cached=True, path=skin_path + "back.svg")
self.pic_directory = LoadPixmap(cached=True,
path=skin_path + "dir.svg")
self.pic_movie_default = LoadPixmap(cached=True,
path=skin_path +
"movie_default.svg")
self.pic_movie_watching = LoadPixmap(cached=True,
path=skin_path +
"movie_watching.svg")
self.pic_movie_finished = LoadPixmap(cached=True,
path=skin_path +
"movie_finished.svg")
self.pic_movie_rec = LoadPixmap(cached=True,
path=skin_path + "movie_rec.svg")
self.pic_movie_cut = LoadPixmap(cached=True,
path=skin_path + "movie_cut.svg")
self.pic_e2bookmark = LoadPixmap(cached=True,
path=skin_path + "e2bookmark.svg")
self.pic_trashcan = LoadPixmap(cached=True,
path=skin_path + "trashcan.svg")
self.pic_trashcan_full = LoadPixmap(cached=True,
path=skin_path +
"trashcan_full.svg")
self.pic_link = LoadPixmap(cached=True, path=skin_path + "link.svg")
self.pic_col_dir = LoadPixmap(cached=True,
path=skin_path + "coldir.svg")
self.pic_progress_bar = LoadPixmap(cached=True,
path=skin_path + "progcl.svg")
self.pic_rec_progress_bar = LoadPixmap(cached=True,
path=skin_path +
"rec_progcl.svg")
self.pic_recording = LoadPixmap(cached=True,
path=skin_path + "recording.svg")
def fillList(self):
self.file = self.filelist[self.fileindex]
self['pic'].hide()
ptr = LoadPixmap(path=getSkinPath("images/" + self.file[FILE_TYPE] +
'.svg'),
cached=False)
self['icon'].instance.setPixmap(ptr)
self['icon'].show()
alist = []
alist.append((_('Filename'), self.file[FILE_PATH], None))
date_time = datetime.fromtimestamp(
self.file[FILE_DATE]).strftime('%Y:%m:%d %H:%M:%S')
alist.append((_('Date'), date_time, None))
metadata = {}
if self.file[FILE_TYPE] == "picture":
metadata = self.file[FILE_META]
#print("MDC: FileInfo: fillList: metadata: %s" % str(metadata))
tmpfile = rotatePictureExif(self.file[FILE_PATH], metadata)
self.picload.startDecode(tmpfile)
MeteringModeDesc = (_('unknown'), 'Average',
'Center-Weighted-Average', 'Spot', 'MultiSpot',
'Pattern', 'Partial')
OrientDesc = (' ', 'Top-Left', 'Top-Right', 'Bottom-Right',
'Bottom-Left', 'Left-Top', 'Right-Top',
'Right-Bottom', 'Left-Bottom')
ExposureProgram = (_('not defined'), 'Manual', 'Normal',
'Aperture priority', 'Shutter priority',
'Creative', 'Action', 'Portrait', 'Landscape')
if 'Width' in metadata and 'Height' in metadata:
alist.append(
(_('Width') + '/' + _('Height'),
'%dx%d' % (metadata['Width'], metadata['Height']), None))
if 'Model' in metadata:
alist.append((_('Camera'), metadata['Model'], None))
if 'Producer' in metadata:
alist.append((_('Producer'), metadata['Producer'], None))
if 'Date' in metadata:
alist.append(
(_('Date') + '/' + _('Time'), metadata['Date'], None))
if 'Flash' in metadata:
alist.append((_('Flash'), str(metadata['Flash']), None))
if 'Meteringmode' in metadata:
alist.append(
(_('Metering-mode'),
MeteringModeDesc[metadata['Meteringmode']], None))
if 'ISO Speed Rating' in metadata:
alist.append((_('ISO Speed Rating'),
metadata['ISO Speed Rating'], None))
if 'Orientation' in metadata:
alist.append((_('Orientation'),
OrientDesc[metadata['Orientation']], None))
if 'Exposure-Program' in metadata:
alist.append(
(_('Exposure-Program'),
ExposureProgram[metadata['Exposure-Program']], None))
if 'Software' in metadata:
alist.append((_('Software'), metadata['Software'], None))
if 'GPS-Altitude' in metadata:
alist.append((_('Altitude'), metadata['GPS-Altitude'], None))
if 'GPS-Latitude' in metadata and 'GPS-Longitude' in metadata:
lat = metadata['GPS-Latitude']
lng = metadata['GPS-Longitude']
alist.append((_('Latitude'), lat, None))
alist.append((_('Longitude'), lng, None))
self['list'].setList(alist)
self['list'].master.downstream_elements.setSelectionEnabled(0)
def loadLCDSkin():
loadSkin(getSkinPath("MediaCenter_LCD.xml"))
class TMDBInfo(Screen, TMDB, Cover, object):
skin = Util.readFile(getSkinPath("TMDBInfo.xml"))
def __init__(self, session, moviename, spath=None):
print("MVC: TMDBInfo: __init__: moviename: %s, spath: %s" % (moviename, spath))
Screen.__init__(self, session)
self.cover_size = config.MVC.cover_size.value
self.show_format = config.MVC.movie_show_format.value
self.moviename = self.getMovieNameWithoutExt(moviename)
self.search_moviename = self.getMovieNameWithoutPhrases(self.moviename)
self.movielist = None
self.spath = spath
self.page = PAGE_DETAILS
self.info = None
self.selection = None
self.coverTimer = eTimer()
self.coverTimer_conn = self.coverTimer.timeout.connect(self.showCover)
self["previewcover"] = Pixmap()
self["nocover"] = Pixmap()
self["previewlist"] = MenuList([])
self["movie_name"] = Label("")
self["contenttxt"] = ScrollLabel()
self["runtime"] = Label(_("Runtime") + ":")
self["runtimetxt"] = Label("")
self["genre"] = Label(_("Genre") + ":")
self["genretxt"] = Label("")
self["country"] = Label(_("Production Countries") + ":")
self["countrytxt"] = Label("")
self["release"] = Label(_("Release Date") + ":")
self["releasetxt"] = Label("")
self["rating"] = Label(_("Vote") + ":")
self["ratingtxt"] = Label("")
self["stars"] = ProgressBar()
self["starsbg"] = Pixmap()
self["stars"].hide()
self["starsbg"].hide()
self.ratingstars = -1
self.deleteCover(TEMP_COVER)
self.movielist = self.getMovieList(self.search_moviename, config.MVC.cover_auto_selection.value)
if self.movielist:
self["previewlist"] = MenuList(self.movielist[0])
if self.movielist[1] > 1:
self.page = PAGE_SELECTION
else:
self.page = PAGE_DETAILS
self.selection = self["previewlist"].l.getCurrentSelection()
print("MVC: TMDBInfo: __init__: selection: " + str(self.selection))
if self.selection:
self.info = self.getTMDBInfo(self.selection[SELECTION_ID], self.selection[SELECTION_TYPE], config.MVC.cover_language.value)
self.downloadCover(self.info[IDX_COVER_URL], TEMP_COVER)
else:
self.page = PAGE_DETAILS
self.selection = None
self.info = None
self.mpath = None
self.onLayoutFinish.append(self.layoutFinished)
self["actions"] = HelpableActionMap(
self,
"TMDBInfo",
{
"MVCEXIT": self.exit,
"MVCUp": self.pageUp,
"MVCDown": self.pageDown,
"MVCOK": self.ok,
"MVCGreen": self.ok,
"MVCYellow": self.save,
"MVCRed": self.exit,
},
-1
)
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("OK"))
self["key_blue"] = Button("")
self["key_yellow"] = Button(_("Save"))
self["previewlist"].onSelectionChanged.append(self.selectionChanged)
def layoutFinished(self):
self.setTitle(_("Movie Information TMDb"))
self.switchPage()
def selectionChanged(self):
print("MVC: TMDBInfo: selectionChanged")
if self.page == PAGE_SELECTION:
self.deleteCover(TEMP_COVER)
self.selection = self["previewlist"].l.getCurrentSelection()
print("MVC: TMDBInfo: selectionChanged: selection: " + str(self.selection))
if self.selection:
self.info = self.getTMDBInfo(self.selection[SELECTION_ID], self.selection[SELECTION_TYPE], config.MVC.cover_language.value)
self.downloadCover(self.info[IDX_COVER_URL], TEMP_COVER)
self.switchPage()
def switchPage(self):
print("MVC: TMDBInfo: switchPage: " + str(self.page))
if self.page == PAGE_SELECTION:
self["movie_name"].setText(_("Search results for") + ": " + self.search_moviename)
self["previewlist"].show()
self["contenttxt"].hide()
self["key_yellow"].hide()
self["key_green"].show()
else:
self["previewlist"].hide()
self["contenttxt"].show()
self["key_yellow"].show()
self["key_green"].hide()
if self.info:
self["movie_name"].setText(self.moviename)
content, runtime, genres, countries, release, vote, _cover_url = self.info
self["contenttxt"].setText(content)
if runtime != "":
self["runtimetxt"].setText(runtime + " " + _("Minutes"))
else:
self["runtimetxt"].setText(runtime)
self["genretxt"].setText(genres)
self["countrytxt"].setText(countries)
self["releasetxt"].setText(release)
if vote:
self["ratingtxt"].setText(vote.replace('\n', '') + " / 10")
self.ratingstars = int(10 * round(float(vote.replace(',', '.')), 1))
if self.ratingstars > 0:
self["starsbg"].show()
self["stars"].show()
self["stars"].setValue(self.ratingstars)
else:
self["starsbg"].show()
self["stars"].hide()
else:
self["ratingtxt"].setText("0 / 10")
self["starsbg"].show()
self["stars"].hide()
else:
self["movie_name"].setText(_("Search results for") + ": " + self.search_moviename)
self["contenttxt"].setText(_("Nothing was found"))
self["contenttxt"].show()
self.coverTimer.start(int(config.MVC.cover_delay.value), True)
def save(self):
print("MVC: TMDBInfo: save: self.spath: " + self.spath)
if self.page == PAGE_DETAILS and self.spath:
self.mpath = self.getCoverPath(self.spath)
if fileExists(self.mpath):
self.session.openWithCallback(
self.saveCallback,
MessageBox,
_("Cover exists")
+ "\n"
+ _("Do you want to replace the existing cover?"),
MessageBox.TYPE_YESNO
)
else:
self.saveTempCover(self.mpath)
def saveCallback(self, result):
if result:
self.saveTempCover(self.mpath)
def saveTempCover(self, cover_path):
print("MVC: TMDBInfo: saveTempCover: cover_path: " + cover_path)
if fileExists(TEMP_COVER):
try:
shutil.copy2(TEMP_COVER, cover_path)
self.showMsg(failed=False)
except Exception as e:
print('MVC: TMDBInfo: saveTempCover: exception failure:\n', str(e))
self.showMsg(failed=True)
else:
self.showMsg(failed=True)
def showMsg(self, askno=False, failed=False):
if not askno:
if not failed:
msg = _("Cover saved successfully")
else:
msg = _("Saving cover failed")
self.session.open(
MessageBox,
msg,
MessageBox.TYPE_INFO,
5
)
def ok(self):
if self.page == PAGE_SELECTION:
self.page = PAGE_DETAILS
self.switchPage()
def pageUp(self):
if self.page == PAGE_DETAILS:
self["contenttxt"].pageUp()
if self.page == PAGE_SELECTION:
self["previewlist"].up()
def pageDown(self):
if self.page == PAGE_DETAILS:
self["contenttxt"].pageDown()
if self.page == PAGE_SELECTION:
self["previewlist"].down()
def showCover(self):
print("MVC: TMDBInfo: ShowCover")
self.displayCover(TEMP_COVER, self["previewcover"], getSkinPath("img/tmdb.svg"))
def exit(self):
print("MVC: TMDBInfo: exit")
if self.movielist:
if self.page == PAGE_DETAILS and self.movielist[1] > 1:
self["movie_name"].setText(_("Search results for") + ": " + self.moviename)
self.page = PAGE_SELECTION
self.switchPage()
return
self["previewlist"].onSelectionChanged = []
self.close()
def __init__(self, current_sort_mode):
logger.debug("...")
self.current_sort_mode = current_sort_mode
self.file_list = []
self.selection_list = []
self.lock_list = {}
self.list_styles = {}
self.file_list_index = {}
self.skinAttributes = None
TemplatedMultiContentComponent.__init__(self)
self.l.setBuildFunc(self.buildMovieListEntry)
self.color = parseColor(config.plugins.moviecockpit.color.value).argb()
self.color_sel = parseColor(
config.plugins.moviecockpit.color_sel.value).argb()
self.recording_color = parseColor(
config.plugins.moviecockpit.recording_color.value).argb()
self.recording_color_sel = parseColor(
config.plugins.moviecockpit.recording_color_sel.value).argb()
self.selection_color = parseColor(
config.plugins.moviecockpit.selection_color.value).argb()
self.selection_color_sel = parseColor(
config.plugins.moviecockpit.selection_color_sel.value).argb()
skin_path = getSkinPath("images/")
self.pic_back = LoadPixmap(skin_path + "back.svg",
cached=True,
size=eSize(24, 24))
self.pic_directory = LoadPixmap(skin_path + "dir.svg",
cached=True,
size=eSize(24, 24))
self.pic_link = LoadPixmap(skin_path + "link.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_default = LoadPixmap(skin_path + "movie_default.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_watching = LoadPixmap(skin_path + "movie_watching.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_finished = LoadPixmap(skin_path + "movie_finished.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_rec = LoadPixmap(skin_path + "movie_rec.svg",
cached=True,
size=eSize(24, 24))
self.pic_movie_cut = LoadPixmap(skin_path + "movie_cut.svg",
cached=True,
size=eSize(24, 24))
self.pic_bookmark = LoadPixmap(skin_path + "bookmark.svg",
cached=True,
size=eSize(24, 24))
self.pic_trashcan = LoadPixmap(skin_path + "trashcan.svg",
cached=True,
size=eSize(24, 24))
self.pic_progress_bar = LoadPixmap(skin_path + "progcl.svg",
cached=True)
self.pic_rec_progress_bar = LoadPixmap(skin_path + "rec_progcl.svg",
cached=True)
self.onSelectionChanged = []
class ConfigScreen(ConfigListScreen, Screen, Trashcan, object):
skin = Util.readFile(getSkinPath("ConfigScreen.xml"))
def __init__(self, session):
Screen.__init__(self, session)
self.skinName = "ConfigScreenMenu"
self["actions"] = ActionMap(
["SetupActions", "OkCancelActions", "MVCConfigActions"],
{
"ok": self.keyOK,
"cancel": self.keyCancel,
"red": self.keyCancel,
"up": self.keyUp,
"down": self.keyDown,
"green": self.keySaveNew,
# "bluelong": self.loadPredefinedSettings,
"blueshort": self.loadDefaultSettings,
"nextBouquet": self.keyPreviousSection,
"prevBouquet": self.keyNextSection,
},
-2 # higher priority
)
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("Save"))
self["key_blue"] = Button(_("Defaults"))
self["help"] = StaticText()
self.list = []
self.MVCConfig = []
ConfigListScreen.__init__(self, self.list, on_change=self.changedEntry)
self.needsRestartFlag = False
self.defineConfig()
self.createConfig()
self.reloadTimer = eTimer()
self.reloadTimer_conn = self.reloadTimer.timeout.connect(
self.createConfig)
# Override selectionChanged because our config tuples have a size bigger than 2
def selectionChanged():
current = self["config"].getCurrent()
if self["config"].current != current:
if self["config"].current:
try:
self["config"].current[1].onDeselect()
except Exception:
pass
if current:
try:
current[1].onSelect()
except Exception:
pass
self["config"].current = current
for x in self["config"].onSelectionChanged:
try:
x()
except Exception:
pass
self["config"].selectionChanged = selectionChanged
self["config"].onSelectionChanged.append(self.updateHelp)
def defineConfig(self):
self.section = 400 * "¯"
# _config list entry
# _ , config element
# _ , , function called on save
# _ , , , function called if user has pressed OK
# _ , , , , usage setup level from E2
# _ , , , , 0: simple+
# _ , , , , 1: intermediate+
# _ , , , , 2: expert+
# _ , , , , , depends on relative parent entries
# _ , , , , , parent config value < 0 = true
# _ , , , , , parent config value > 0 = false
# _ , , , , , , _context sensitive help text
# _ , , , , , , ,
# _ 0 , 1 , 2 , 3 , 4 , 5 , 6 ,
self.MVCConfig = [
(self.section, _("GENERAL"), None, None, 0, [], ""),
(_("About"), config.MVC.fake_entry, None, self.showInfo, 0, [],
_("HELP About")),
(_("Disable plugin"), config.MVC.ml_disable, self.needsRestart,
None, 1, [], _("Help Disable Plugin")),
(_("Start plugin with"), config.MVC.movie_launch,
self.launchListSet, None, 0, [], _("Help Start plugin with")),
(_("Show plugin config in extensions menu"),
config.MVC.extmenu_plugin, self.needsRestart, None, 0, [],
_("Help Show plugin config in extensions menu")),
(_("Show plugin in extensions menu"), config.MVC.extmenu_list,
self.needsRestart, None, 0, [],
_("Help Show plugin in extensions menu")),
(_("Movie home at start"), config.MVC.MVCStartHome, None, None, 0,
[], _("Help Movie home at start")),
(_("Default sort mode"), config.MVC.moviecenter_sort, None, None,
0, [], _("Help Sort mode at startup")),
(_("Movie home home path"), config.MVC.movie_homepath,
self.validatePath, self.openLocationBox, 0, [],
_("Help Movie home home path")),
(_("Path access limit"), config.MVC.movie_pathlimit, None, None, 1,
[], _("Help Path access limit")),
(_("Display directory reading text"),
config.MVC.moviecenter_loadtext, None, None, 1, [],
_("Help Display directory reading text")),
(self.section, _("KEYMAPPING"), None, None, 0, [], ""),
(_("Bouquet buttons behaviour"), config.MVC.bqt_keys, None, None,
0, [], _("Help Bouquet buttons behaviour")),
(_("List entries to skip"), config.MVC.list_skip_size, None, None,
0, [], _("Help List entries to skip")),
(_("Red button function"), config.MVC.movie_redfunc, None, None, 0,
[], _("Help Red button function")),
(_("Long Red button function"), config.MVC.movie_longredfunc, None,
None, 0, [], _("Help Long Red button function")),
(_("Yellow button function"), config.MVC.movie_yellowfunc, None,
None, 0, [], _("Help Yellow button function")),
(_("Long Yellow button function"), config.MVC.movie_longyellowfunc,
None, None, 0, [], _("Help Long Yellow button function")),
(_("Blue button function"), config.MVC.movie_bluefunc, None, None,
0, [], _("Help Blue button function")),
(_("Long Blue button function"), config.MVC.movie_longbluefunc,
None, None, 0, [], _("Help Long Blue button function")),
(_("LongInfo Button"), config.MVC.InfoLong, None, None, 0, [],
_("Help LongInfo Button")),
(self.section, _("PLAYBACK"), None, None, 0, [], ""),
(_("No resume below 10 seconds"),
config.MVC.movie_ignore_firstcuts, None, None, 1, [],
_("Help No resume below 10 seconds")),
(_("Jump to first mark when playing movie"),
config.MVC.movie_jump_first_mark, None, None, 1, [],
_("Help Jump to first mark when playing movie")),
(_("Rewind finished movies before playing"),
config.MVC.movie_rewind_finished, None, None, 1, [],
_("Help Rewind finished movies before playing")),
(_("Zap to channel after record EOF"), config.MVC.record_eof_zap,
None, None, 1, [], _("Help Zap to channel after record EOF")),
(_("Re-open list after stop"), config.MVC.movie_reopen, None, None,
1, [], _("Help Re-open list after STOP-press")),
(_("Re-open list after movie end"), config.MVC.movie_reopenEOF,
None, None, 1, [], _("Help Re-open list after Movie end")),
(_("Leave movie with Exit"), config.MVC.movie_exit, None, None, 0,
[], _("Help Leave Movie with Exit")),
(_("Automatic timers list cleaning"), config.MVC.timer_autoclean,
None, None, 1, [], _("Help Automatic timers list cleaning")),
(self.section, _("DISPLAY-SETTINGS"), None, None, 0, [], ""),
(_("Show directories"), config.MVC.directories_show, None, None, 0,
[], _("Help Show directories")),
(_("Show directories within movielist"),
config.MVC.directories_ontop, None, None, 0, [-1],
_("Help Show directories within movielist")),
(_("Show directories information"), config.MVC.directories_info,
None, None, 0, [-2], _("Help Show directories information")),
(_("Hide movies being moved"), config.MVC.movie_hide_mov, None,
None, 1, [], _("Help Hide movies being moved")),
(_("Hide movies being deleted"), config.MVC.movie_hide_del, None,
None, 1, [], _("Help Hide movies being deleted")),
(_("Cursor predictive move after selection"),
config.MVC.moviecenter_selmove, None, None, 0, [],
_("Help Cursor predictive move after selection")),
(_("Show bookmarks in movielist"), config.MVC.bookmarks, None,
None, 0, [], _("Help Show Bookmarks in movielist")),
(_("Description field update delay"), config.MVC.movie_descdelay,
None, None, 2, [], _("Help Description field update delay")),
(self.section, _("SKIN-SETTINGS"), None, None, 0, [], ""),
(_("Skin style (needs reopen)"), config.MVC.skinstyle, None, None,
0, [], _("Help Skin style (needs reopen)")),
(_("Date format"), config.MVC.movie_date_format, None, None, 0, [],
_("Help Date format")),
(_("Horizontal alignment for count/size"),
config.MVC.count_size_position, None, None, 0, [],
_("Help Horizontal alignment for count / size")),
(_("Show movie icons"), config.MVC.movie_icons, None, None, 0, [],
_("Help Show movie icons")),
(_("Show link arrow"), config.MVC.link_icons, None, None, 0, [-1],
_("Help Show link arrow")),
(_("Show movie picons"), config.MVC.movie_picons, None, None, 0,
[], _("Help Show movie picons")),
(_("Path to movie picons"), config.MVC.movie_picons_path,
self.validatePath, self.openLocationBox, 0, [-1],
_("Help Path to movie picons")),
(_("Show movie progress"), config.MVC.movie_progress, None, None,
0, [], _("Help Show movie progress")),
(_("Short watching percent"), config.MVC.movie_watching_percent,
None, None, 0, [-1], _("Help Short watching percent")),
(_("Finished watching percent"), config.MVC.movie_finished_percent,
None, None, 0, [-2], _("Help Finished watching percent")),
(_("Default color for recording movie"),
config.MVC.color_recording, None, None, 0, [-3],
_("Help Default color recording")),
(_("Default color for highlighted movie"),
config.MVC.color_highlight, None, None, 0, [-4],
_("Help Default color highlighted")),
(_("Hide MiniTV"), config.MVC.hide_miniTV, None, None, 0, [],
_("Help hide_MiniTV")),
(self.section, _("COVER DISPLAY"), None, None, 0, [], ""),
(_("Show Cover"), config.MVC.cover, None, None, 0, [],
_("Help Show Cover")),
(_("Cover delay in ms"), config.MVC.cover_delay, None, None, 0,
[-1], _("Help Cover delay in ms")),
(_("Cover background"), config.MVC.cover_background, None, None, 0,
[-2], _("HELP_Cover background")),
(_("Show fallback cover"), config.MVC.cover_fallback, None, None,
0, [-3], _("Help Cover fallback")),
(_("Hide MiniTV if Cover is shown"), config.MVC.cover_hide_miniTV,
None, None, 0, [-4], _("Help Cover hide_MiniTV")),
(self.section, _("COVER SEARCH"), None, None, 0, [], ""),
(_("Cover language"), config.MVC.cover_language, None, None, 0, [],
_("Help Cover language")),
(_("Cover size"), config.MVC.cover_size, None, None, 0, [],
_("Help Cover size")),
(_("Cover automatic selection"), config.MVC.cover_auto_selection,
None, None, 0, [], _("Help Cover auto selection")),
(_("Cover in flash"), config.MVC.cover_flash, None, None, 0, [],
_("Help Cover in flash")),
(_("Cover bookmark"), config.MVC.cover_bookmark, self.validatePath,
self.openLocationBox, 0, [-1], _("Help Cover bookmark")),
(self.section, _("TRASHCAN"), None, None, 0, [], ""),
(_("Trashcan enable"), config.MVC.movie_trashcan_enable,
self.activateTrashcan, None, 0, [], _("Help Trashcan enable")),
(_("Trashcan path"), config.MVC.movie_trashcan_path,
self.validatePath, self.openLocationBox, 0, [-1],
_("Help Trashcan path")),
(_("Show trashcan directory"), config.MVC.movie_trashcan_show,
None, None, 0, [-2], _("Help Show trashcan directory")),
(_("Show trashcan information"), config.MVC.movie_trashcan_info,
None, None, 0, [-3, -1], _("Help Dynamic trashcan")),
(_("Delete validation"), config.MVC.movie_delete_validation, None,
None, 0, [-4], _("Help Delete validation")),
(_("Enable auto trashcan cleanup"),
config.MVC.movie_trashcan_clean, None, None, 0, [-5],
_("Help Enable auto trashcan cleanup")),
(_("How many days files may remain in trashcan"),
config.MVC.movie_trashcan_limit, None, None, 0, [-6, -1],
_("Help How many days files may remain in trashcan")),
(self.section, _("LANGUAGE"), None, None, 1, [], ""),
(_("Preferred EPG language"), config.MVC.epglang, setEPGLanguage,
None, 1, [], _("Help Preferred EPG language")),
(_("Enable playback auto-subtitling"), config.MVC.autosubs, None,
None, 1, [], _("Help Enable playback auto-subtitling")),
(_("Primary playback subtitle language"),
config.MVC.sublang1, None, None, 1, [-1],
_("Help Primary playback subtitle language")),
(_("Secondary playback subtitle language"),
config.MVC.sublang2, None, None, 1, [-2],
_("Help Secondary playback subtitle language")),
(_("Tertiary playback subtitle language"),
config.MVC.sublang3, None, None, 1, [-3],
_("Help Tertiary playback subtitle language")),
(_("Enable playback auto-language selection"),
config.MVC.autoaudio, None, None, 1, [],
_("Help Enable playback auto-language selection")),
(_("Enable playback AC3-track first"), config.MVC.autoaudio_ac3,
None, None, 1, [-1], _("Help Enable playback AC3-track first")),
(_("Primary playback audio language"), config.MVC.audlang1, None,
None, 1, [-2], _("Help Primary playback audio language")),
(_("Secondary playback audio language"), config.MVC.audlang2, None,
None, 1, [-3], _("Help Secondary playback audio language")),
(_("Tertiary playback audio language"), config.MVC.audlang3, None,
None, 1, [-4], _("Help Tertiary playback audio language")),
]
def createConfig(self):
self.list = []
for i, conf in enumerate(self.MVCConfig):
# 0 entry text
# 1 variable
# 2 validation
# 3 pressed ok
# 4 setup level
# 5 parent entries
# 6 help text
# Config item must be valid for current usage setup level
if config.usage.setup_level.index >= conf[4]:
# Parent entries must be true
for parent in conf[5]:
if parent < 0:
if not self.MVCConfig[i + parent][1].value:
break
elif parent > 0:
if self.MVCConfig[i - parent][1].value:
break
else:
# Loop fell through without a break
if conf[0] == self.section:
if len(self.list) > 1:
self.list.append(
getConfigListEntry("", config.MVC.fake_entry,
None, None, 0, [], ""))
if conf[1] == "":
self.list.append(
getConfigListEntry("<DUMMY CONFIGSECTION>", ))
else:
self.list.append(getConfigListEntry(conf[1], ))
else:
self.list.append(
getConfigListEntry(conf[0], conf[1], conf[2],
conf[3], conf[4], conf[5],
conf[6]))
self["config"].setList(self.list)
self.setTitle(_("Setup"))
def loadDefaultSettings(self):
self.session.openWithCallback(
self.loadDefaultSettingsCB, MessageBox,
_("Loading default settings will overwrite all settings, really load them?"
), MessageBox.TYPE_YESNO)
def loadDefaultSettingsCB(self, result):
if result:
# Refresh is done implicitly on change
for conf in self.MVCConfig:
if len(conf) > 1 and conf[0] != self.section:
conf[1].value = conf[1].default
self.createConfig()
def changedEntry(self, _addNotifier=None):
if self.reloadTimer.isActive():
self.reloadTimer.stop()
self.reloadTimer.start(50, True)
def updateHelp(self):
cur = self["config"].getCurrent()
self["help"].text = cur and cur[6] or ""
def dirSelected(self, res):
if res:
res = os.path.normpath(res)
self["config"].getCurrent()[1].value = res
def keyOK(self):
try:
current = self["config"].getCurrent()
if current:
current[3](current[1])
except Exception:
pass
def keySaveNew(self):
config.MVC.needsreload.value = True
for i, entry in enumerate(self.list):
if len(entry) > 1:
if entry[1].isChanged():
if entry[2]:
# execute value changed -function
if entry[2](entry[1]):
# Stop exiting, user has to correct the config
return
# Check parent entries
for parent in entry[5]:
try:
if self.list[i + parent][2]:
# execute parent value changed -function
if self.list[i + parent][2](
self.MVCConfig[i + parent][1]):
# Stop exiting, user has to correct the config
return
except Exception:
continue
entry[1].save()
configfile.save()
if self.needsRestartFlag:
self.session.open(MessageBox,
_("Some changes require a GUI restart"),
MessageBox.TYPE_INFO, 10)
self.close()
def activateTrashcan(self, element):
if element:
self.enableTrashcan()
def launchListSet(self, element):
if element:
self.needsRestart()
def needsRestart(self, dummy=None):
self.needsRestartFlag = True
def openLocationBox(self, element):
if element:
path = os.path.normpath(element.value)
self.session.openWithCallback(self.dirSelected,
LocationBox,
windowTitle=_("Select Location"),
text=_("Select directory"),
currDir=str(path) + "/",
bookmarks=config.movielist.videodirs,
autoAdd=False,
editDir=True,
inhibitDirs=[
"/bin", "/boot", "/dev", "/etc",
"/lib", "/proc", "/sbin", "/sys",
"/var"
],
minFree=100)
def showInfo(self, dummy=None):
self.session.open(MessageBox, "MovieCockpit" + ": Version " + VERSION,
MessageBox.TYPE_INFO)
def validatePath(self, element):
element.value = os.path.normpath(element.value)
if not os.path.exists(element.value):
self.session.open(
MessageBox,
_("Path does not exist") + ": " + str(element.value),
MessageBox.TYPE_ERROR)
return False
try:
from __init__ import _ # pylint: disable=W0611
except ImportError:
def _(txt):
return "_(\"" + txt + "\")"
try:
import pprint
pp = pprint.PrettyPrinter(indent=4, width=120)
except ImportError:
pp = None
try:
from SkinUtils import getSkinPath
template_path = getSkinPath("MovieListTemplate.py")
except ImportError:
template_path = "skin/MovieListTemplate.py"
def MultiContentEntryProgressPixmap(pos, size, png, foreColor, percent,
borderWidth):
return "MultiContentEntryProgressPixmap(" + "pos=" + str(pos) + ", size=" + str(size) + ", percent=" + str(percent) + ", png=" + str(png)\
+ ", foreColor=" + ("0x%x" % foreColor) + ", borderWidth=" + str(borderWidth) + ")"
def MultiContentEntryText(pos, size, font, flags, text, color, color_sel):
return "MultiContentEntryText(" + "pos=" + str(pos) + ", size=" + str(size) + ", font=" + str(font) + ", flags=" + str(flags)\
+ ", text=" + str(text) + ", color=" + ("0x%x" % color) + ", color_sel=" + ("0x%x" % color_sel) + ")"
