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) + ")"