def seek_back(self): if not self.seekable: show_info_message(self.session, _("Its not possible to seek in this video"), 3) elif self.download is not None and self.download.running: show_info_message(self.session, _("Its not possible to use trick seek in downloading video "), 3) else: self._seek_back()
def updateAddonGUI(self): image = None title = author = version = description = "" item = self.getSelectedItem() if item is not None: title = item.name and toString(item.name) or "" imagePath = item.image and toString(item.image) or "" if imagePath: try: image = LoadPixmap(path=imagePath, cached=False) except Exception as e: print '[ArchivCZSKContent] error when loading image', e try: # addon author = item.author and toString(item.author) or "" version = item.version and toString(item.version) or "" description = item.description and toString(item.description) or "" except AttributeError: # category pass self["title"].setText(title.strip()) if author: self["author"].setText(_("Author: ") + author.strip()) else: self["author"].setText("") if version: self["version"].setText(_("Version: ") + version.strip()) else: self["version"].setText("") self["about"].setText(description.strip()) self["image"].instance.setPixmap(image)
def _init_menu(self, item): provider = self.content_provider if 'play' in provider.capabilities: item.add_context_menu_item(_("Play"), action=self.play_item, params={'item':item, 'mode':'play'}) if 'play_and_download' in provider.capabilities: item.add_context_menu_item(_("Play and Download"), action=self.play_item, params={'item':item, 'mode':'play_and_download'}) if 'play_and_download_gst' in provider.capabilities: item.add_context_menu_item(_("Play and download (Gstreamer)"), action=self.play_item, params={'item':item, 'mode':'play_and_download_gst'}) if 'download' in provider.capabilities: item.add_context_menu_item(_("Download"), action=self.download_item, params={'item':item, 'mode':'auto'})
def __init__(self, session, addon, lst_items): self.addon = addon contentHandler = VideoAddonContentHandler(session, self, addon.provider) BaseContentScreen.__init__(self, session, contentHandler, lst_items) # include DownloadList DownloadList.__init__(self) # include TipList TipBar.__init__(self, [self.CSFD_TIP, self.CONTEXT_TIP, self.INFO_TIP], startOnShown=True) self["key_red"] = Label("") self["key_green"] = Label(_("Downloads")) self["key_yellow"] = Label(_("Shortcuts")) self["key_blue"] = Label(_("Settings")) self["actions"] = ActionMap(["archivCZSKActions"], { "ok": self.ok, "up": self.up, "down": self.down, "cancel": self.cancel, "green" : self.openAddonDownloads, "blue": self.openAddonSettings, "yellow": self.openAddonShortcuts, "info": self.openInfo, "menu": self.menu, "csfd": self.openCSFD }, -2) #self.onUpdateGUI.append(self.updateFullTitle) self.onLayoutFinish.append(self.setWindowTitle)
def _askSaveDownloadCB(self): def saveDownload(callback=None): if not callback: from Plugins.Extensions.archivCZSK.engine.downloader import DownloadManager DownloadManager.getInstance().removeDownload(self.download) downloadedSucc = self.download.downloaded downloadedErr = not self.download.downloaded and not self.download.running downloading = not self.download.downloaded and self.download.running if downloadedSucc: self.session.openWithCallback(saveDownload, MessageBox, _("Do you want to save") + ' ' + self.download.name.encode('utf-8', 'ignore') + ' ' + _("to disk?"), type=MessageBox.TYPE_YESNO) elif downloadedErr: self.session.openWithCallback(saveDownload, MessageBox, _("Do you want to save") + " " + _('not succesfully finished download') + " " + self.download.name.encode('utf-8', 'ignore') + ' ' + _("to disk?"), type=MessageBox.TYPE_YESNO) elif downloading: self.session.openWithCallback(saveDownload, MessageBox, _("Do you want to continue downloading") + ' ' + self.download.name.encode('utf-8', 'ignore') + ' ' + _("to disk?"), type=MessageBox.TYPE_YESNO) self.download.playMode = False
def updateStatus(self): download = self._download status = download.status status.update(self.timer_interval / 1000) speed = status.speed speedKB = util.BtoKB(speed) if speedKB <= 1000 and speedKB > 0: self['speed'].setText(("%d KB/s" % speedKB)) elif speedKB > 1000: self['speed'].setText(("%.2f MB/s" % util.BtoMB(speed))) else: self['speed'].setText(("%d KB/s" % 0)) currentLength = status.currentLength totalLength = status.totalLength size = "%s (%2.f MB %s)" % (_("unknown"), util.BtoMB(currentLength), _("downloaded")) if totalLength > 0: size = "%2.f MB (%2.f MB %s)" % (util.BtoMB(totalLength), util.BtoMB(currentLength), _("downloaded")) self["size"].setText(size) if not download.running: self.stopTimer()
def __init__(self, session, configEntry): initDir = configEntry.getValue() if initDir is not None and not initDir.endswith('/'): initDir = initDir + '/' Screen.__init__(self, session) #inhibitDirs = ["/bin", "/boot", "/dev", "/etc", "/lib", "/proc", "/sbin", "/sys", "/usr", "/var"] #inhibitMounts = [] self.configEntry = configEntry self["filelist"] = FileList(initDir, showDirectories=True, showFiles=False) self["target"] = Label() self["actions"] = ActionMap(["WizardActions", "DirectionActions", "ColorActions", "EPGSelectActions"], { "back": self.cancel, "left": self.left, "right": self.right, "up": self.up, "down": self.down, "ok": self.ok, "green": self.green, "red": self.cancel }, -1) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self.onShown.append(self.setWindowTitle)
def buildEntry(self, name, res, width): if res is None: return PanelColorListEntry(name, _("UNKNOWN"), 0xffff00, width) elif res: return PanelColorListEntry(name, _("OK"), 0x00ff00, width) else: return PanelColorListEntry(name, _("FAIL"), 0xff0000, width)
def PanelListDownloadListEntry(pdownload): res = [(pdownload.name)] finishText = _('Finished: ') if pdownload.finish_time is not None: finishText = _('Finished: ') + time.strftime("%b %d %Y %H:%M:%S", time.localtime(pdownload.finish_time)) sizeKB = util.BtoKB(pdownload.size) if sizeKB <= 1024 and sizeKB >= 0: size = ("%d KB " % sizeKB) elif sizeKB <= 1024 * 1024: size = ("%d MB " % util.BtoMB(pdownload.size)) else: size = ("%.2f GB " % util.BtoGB(pdownload.size)) sizeText = _('Size: ') + size stateText = pdownload.textState res.append(MultiContentEntryPixmapAlphaTest(pos=(5, 5), size=(35, 25), png=loadPNG(pdownload.thumb))) res.append(MultiContentEntryText(pos=(60, 5), size=(760, 30), font=0, flags=RT_HALIGN_LEFT, text=toUTF8(pdownload.name))) res.append(MultiContentEntryText(pos=(0, 38), size=(900, 18), font=2, flags=RT_VALIGN_TOP | RT_HALIGN_RIGHT, text=sizeText, color=0xE6A800)) if pdownload.state == 'success_finished': res.append(MultiContentEntryText(pos=(0, 38), size=(900, 18), font=2, flags=RT_VALIGN_TOP | RT_HALIGN_LEFT, text=finishText, color=0xE6A800)) res.append(MultiContentEntryText(pos=(0, 38), size=(900, 18), font=2, flags=RT_VALIGN_TOP | RT_HALIGN_CENTER, text=stateText, color=0x00FF00)) elif pdownload.state == 'error_finished': res.append(MultiContentEntryText(pos=(0, 38), size=(900, 18), font=2, flags=RT_VALIGN_TOP | RT_HALIGN_LEFT, text=finishText, color=0xE6A800)) res.append(MultiContentEntryText(pos=(0, 38), size=(900, 18), font=2, flags=RT_VALIGN_TOP | RT_HALIGN_CENTER, text=stateText, color=0xff0000)) elif pdownload.state == 'downloading': res.append(MultiContentEntryText(pos=(0, 38), size=(900, 18), font=2, flags=RT_VALIGN_TOP | RT_HALIGN_CENTER, text=stateText, color=0xE6A800)) return res
def __init__(self, session, categories=[]): BaseArchivCZSKScreen.__init__(self, session) ConfigListScreen.__init__(self, [], session=session, on_change=self.changedEntry) self.onChangedEntry = [ ] self.categories = categories self.selected_category = 0 self.config_list_entries = [] self.category_widgets = [] self.category_widgets_y = 100 self.initializeCategories() self.initializeSkin() self["key_yellow"] = Label(_("Changelog")) self["key_green"] = Label(_("Save")) self["key_red"] = Label(_("Cancel")) self["key_blue"] = Label(_("Next")) self["actions"] = ActionMap(["SetupActions", "ColorActions"], { "cancel": self.keyCancel, "green": self.keySave, "ok": self.keyOk, "red": self.keyCancel, "blue": self.nextCategory, "yellow": self.changelog }, -2)
def __init__(self, session): BaseArchivCZSKMenuListScreen.__init__(self, session) DownloadListScreen.instance = self self["key_red"] = Button(_("Cancel")) self["key_green"] = Button(_("Play")) self["key_yellow"] = Button(_("Remove")) self["key_blue"] = Button("") from Plugins.Extensions.archivCZSK.engine.player.player import Player self.player = Player(session, self.workingFinished) self.lst_items = [] self.title = "ArchivyCZSK" + " - " + _("Recent downloads") self.onClose.append(self.__onClose) self["actions"] = NumberActionMap(["archivCZSKActions"], { "ok": self.ok, "cancel": self.cancel, "red": self.askCancelDownload, "green": self.askPlayDownload, "yellow": self.askRemoveDownload, "up": self.up, "down": self.down, }, -2) self.lst_items = DownloadManager.getInstance().download_lst self.onShown.append(self.setWindowTitle)
def updateProtocolList(self,width): menuList = [] menuList.append(self.buildEntry(_("HTTP Protocol"), videoPlayerInfo.isHTTPSupported(), width)) menuList.append(self.buildEntry(_("HLS Protocol"), videoPlayerInfo.isHLSSupported(), width)) menuList.append(self.buildEntry(_("MMS Protocol"), videoPlayerInfo.isMMSSupported(), width)) menuList.append(self.buildEntry(_("RTMP Protocol"), videoPlayerInfo.isRTMPSupported(), width)) menuList.append(self.buildEntry(_("RTSP Protocol"), videoPlayerInfo.isRTSPSupported(), width)) self["protocol_list"].setList(menuList)
def initInfoList(self): blueB = os.path.join(settings.IMAGE_PATH, 'buttons/blue.png') redB = os.path.join(settings.IMAGE_PATH, 'buttons/red.png') yellowB = os.path.join(settings.IMAGE_PATH, 'buttons/yellow.png') infolist = [] infolist.append(PanelListEntry2(_("change search expression"), self.WIDTH_HD, yellowB)) infolist.append(PanelListEntry2(_("remove diacritic"), self.WIDTH_HD, redB)) infolist.append(PanelListEntry2(_("choose from EPG"), self.WIDTH_HD, blueB)) self['infolist'].l.setList(infolist)
def __init__(self): try: self.ctx_items.append((_("Show recent downloads"), None, self.showDownloadListScreen)) except AttributeError: pass self["DownloadListActions"] = HelpableActionMap(self, "DownloadActions", { "showDownloadListView": (self.showDownloadListScreen, _("show download list")), })
def __call__(self, func): def wrapped(*args, **kwargs): try: func(*args, **kwargs) except download.NotSupportedProtocolError, e: message = "%s %s" % (e.message, _("protocol is not supported")) self.errorMessage(message) except urllib2.HTTPError, e: message = "%s %s:%d" % (_("Error in loading"), _("HTTP Error"), e.code) self.errorMessage(message)
def __call__(self, func): def wrapped(*args, **kwargs): try: func(*args, **kwargs) except urllib2.HTTPError, e: message = "%s %s:%d" % (_("Error in loading"), _("HTTP Error"), e.code) self.errorMessage(message) except urllib2.URLError, e: message = "%s %s:%s" % (_("Error in loading"), _("URL Error"), str(e.reason)) self.errorMessage(message)
def _createMenuListEntry(self, item, idx): addon = item.addon name = item.name width = self["menu"].instance.size().width() -5 if addon.get_info('broken'): return PanelColorListEntry2(name, _('broken'), 0xffffff, 0xff0000, width) elif not addon.get_setting('enabled'): return PanelColorListEntry2(name, _('disabled'), 0xffffff, 0xffff00, width) else: return PanelColorListEntry2(name, _('enabled'), 0xffffff, 0x00ff00, width)
def toggleCancelLoading(self): if Task.getInstance() is not None and not Task.getInstance().isCancelling(): self["status_label"].setText(_("Canceling...")) Task.getInstance().setCancel() elif Task.getInstance() is not None and Task.getInstance().isCancelling(): self["status_label"].setText(_("Loading...")) Task.getInstance().setResume() else: log.debug("Task is not running")
def _init_menu(self, item, *args, **kwargs): provider = self.content_provider if 'play' in provider.capabilities: item.add_context_menu_item(_("Play"), action=self.play_item, params={'item':item, 'mode':'play'}) item.add_context_menu_item(_("Show playlist"), action=self.show_playlist, params={'item':item})
def __init__(self, session, archivCZSK): provider = ArchivCZSKContentProvider(archivCZSK, os.path.join(settings.PLUGIN_PATH, 'categories')) provider.start() contentHandler = ArchivCZSKContentHandler(session, self, provider) defaultCategory = config.plugins.archivCZSK.defaultCategory.value categoryItem = categoryAddons = None if defaultCategory != 'categories': categoryItem = provider.get_content({'category':defaultCategory}) categoryAddons = provider.get_content({'category_addons':defaultCategory}) categoryAddons is not None and categoryAddons.insert(0, PExit()) categoryItems = provider.get_content() BaseContentScreen.__init__(self, session, contentHandler, categoryItems) if categoryItem is not None and categoryAddons is not None: self.save() self.load({'lst_items':categoryAddons, 'parent_it':categoryItem, 'refresh':False}) self.ctx_items.append((_("Add Category"), None, self.addCategory)) self.provider = provider self.updateGUITimer = eTimer() self.updateGUITimer.callback.append(self.updateAddonGUI) # include DownloadList DownloadList.__init__(self) # include TipList TipBar.__init__(self, [self.CONTEXT_TIP], startOnShown=True) self.onUpdateGUI.append(self.changeAddon) self.onClose.append(self.__onClose) self["image"] = Pixmap() self["title"] = Label("") self["author"] = Label("") self["version"] = Label("") self["about"] = Label("") self["key_red"] = Label("") self["key_green"] = Label(_("Manager")) self["key_yellow"] = Label(_("Live streams")) self["key_blue"] = Label(_("Settings")) self["actions"] = ActionMap(["archivCZSKActions"], { "ok": self.ok, "cancel": self.cancel, "up": self.up, "down": self.down, "blue": self.openSettings, "green": self.openAddonManagement, "yellow": self.showStreams, "menu" : self.menu }, -2) # after layout show update item "GUI" - edit: shamann self.onLayoutFinish.append(self.updateAddonGUI)
def __init__(self, session): categories = [ {'label':_("Main"), 'subentries':settings.get_main_settings}, {'label':_("Player"), 'subentries':settings.get_player_settings}, {'label':_("Path"), 'subentries':settings.get_path_settings}, {'label':_("Misc"), 'subentries':settings.get_misc_settings} ] BaseArchivCZSKConfigScreen.__init__(self, session, categories=categories) self.onLayoutFinish.append(self.layoutFinished) self.onShown.append(self.buildMenu)
def renameCB(callback=None): if callback and len(callback) > 0: dpath = os.path.join(download.destDir, callback) if download.filename == callback: session.open(MessageBox, _("You've to change download filename. Try again.."), type=MessageBox.TYPE_WARNING) elif os.path.isfile(dpath): message = "%s: %s %s\n%s" % (_("The file"), callback, _("already exists"), _("Try to use another name...")) session.open(MessageBox, message, type=MessageBox.TYPE_WARNING) else: download.filename = callback download.local = dpath dManager.addDownload(download)
def _showPlayDownloadDelay(self, download): """called on download start""" self.download = download # download is not running already, so we dont continue if not self.download.downloaded and not self.download.running: log.debug("download %s not started at all", self.download.name) self.download = None self.exit() else: self.session.openWithCallback(self._playAndDownloadCB, MessageBox, '%s %d %s' % (_('Video starts playing in'), \ self.playDelay, _("seconds.")), type=MessageBox.TYPE_INFO, timeout=self.playDelay, enable_input=False)
def _handle_broken_addon(self, addon): def disable_addon(cb): if cb: addon.set_setting('enabled', False) self.content_screen.workingStarted() self.content_screen.refreshList() self.content_screen.workingFinished() reason = addon.get_info('broken').encode('utf-8') message = _("Addon is broken") + '\n' message += _("Reason") + ' : ' + reason +'\n\n' message += _("Do you want to disable this addon?") self.session.openWithCallback(disable_addon,MessageBox, message, type=MessageBox.TYPE_YESNO)
def __updateState(self): if not self.running and self.downloaded: self.state = 'success_finished' self.textState = _('succesfully finished') elif not self.running and not self.downloaded: self.state = 'error_finished' self.textState = _('not succesfully finished') elif self.running and not self.downloaded: self.state = 'downloading' self.textState = _('downloading') else: self.state = 'unknown' self.textState = _("unknown")
def finishDownloadCB(download): session = GlobalSession.getSession() def updateDownloadList(callback=None): if DownloadListScreen.instance is not None: DownloadListScreen.instance.refreshList() if download.downloaded: session.openWithCallback(updateDownloadList, MessageBox, _("ArchivyCZSK - Download:") + ' ' + \ download.name.encode('utf-8', 'ignore') + ' ' + _("successfully finished."), \ type=MessageBox.TYPE_INFO, timeout=0) else: session.openWithCallback(updateDownloadList, MessageBox, _("ArchivyCZSK - Download:") + ' ' + \ download.name.encode('utf-8', 'ignore') + ' ' + _("finished with errors."), \ type=MessageBox.TYPE_ERROR, timeout=0)
def _init_menu(self, item): MediaItemHandler._init_menu(self, item) item.add_context_menu_item(_("Resolve videos"), action=self._resolve_videos, params={'item':item}) if 'favorites' in self.content_provider.capabilities: item.add_context_menu_item(_("Add Shortcut"), action=self.ask_add_shortcut, params={'item':item}) else: item.remove_context_menu_item(_("Add Shortcut"), action=self.ask_add_shortcut, params={'item':item})
def getInstance(session, cb=None): if ArchivCZSKSeeker.instance is None: try: return ArchivCZSKSeeker(session, cb) except ImportError: showInfoMessage(session, _('Cannot search, archivCZSK is not installed'), 5, cb=cb) print 'cannot found archivCZSK' return None except Exception: traceback.print_exc() showErrorMessage(session, _('unknown error'), 5, cb=cb) return None return ArchivCZSKSeeker.instance
def search(self, search_exp, addon_id, mode=None): if self.searching: showInfoMessage(self.session, _("You cannot search, archivCZSK Search is already running")) print "%s cannot search, searching is not finished" % self return searcher = getSearcher(self.session, addon_id, self.archivCZSK, self._successSearch, self._errorSearch) if searcher is not None: self.searcher = searcher self.searching = True self.addon = searcher.addon searcher.start() searcher.search(search_exp, mode) else: showInfoMessage(self.session, _("Cannot find searcher") + ' ' + addon_id.encode('utf-8'))
def askInstallRtmpPlugin(self): if ARCH == 'mipsel': self.selectedInstallType = self.GST_INSTALL_RTMP warnMessage = _("ATTENTION: Installation of this plugin can cause") warnMessage += '\n' + _("crash of Enigma2.") if videoPlayerInfo.isRTMPSupported(): message = warnMessage message += '\n' message += '\n' + _("It looks like RTMP plugin is already installed") message += '\n' + _("Do you want to reinstall it?") else: message = warnMessage message += '\n\n' + _("Do you want to continue?") showYesNoDialog(self.session, message, self.installGstPlugins)
def __init__(self, session): categories = [{ 'label': _("Main"), 'subentries': settings.get_main_settings }, { 'label': _("Player"), 'subentries': settings.get_player_settings }, { 'label': _("Path"), 'subentries': settings.get_path_settings }, { 'label': _("Misc"), 'subentries': settings.get_misc_settings }] BaseArchivCZSKConfigScreen.__init__(self, session, categories=categories) self.onLayoutFinish.append(self.layoutFinished) self.onShown.append(self.buildMenu)
def _save_download(self, cb=None): if cb: # we need to pause playing downloaded file because we want to move # it to our download location self.pause_service() log.debug("saving %s to %s", self.gst_download_path, self.download_path) os.system('mv %s %s' % (self.gst_download_path, self.download_path)) #shutil.move(self.gst_download_path, self.download_path) show_info_message(self.session, _("Download was succesfully saved")) self._exit_video_player() else: self._exit_video_player()
def cancel(self): if self.working: self.toggleCancelLoading() elif not self.working: if config.plugins.archivCZSK.confirmExit.value: self.session.openWithCallback( self.closePlugin, MessageBox, _('Do you want to exit ArchivCZSK?'), type=MessageBox.TYPE_YESNO) else: self.closePlugin(True)
def do_seek_relative(self, pts): if self.download_percent == 100 or pts < 0: self._do_seek_relative(pts) return play_pts = self.video.getCurrentPosition() download_pts = self.get_download_position() if play_pts is None or download_pts is None: show_info_message(self.session, _("Error when trying to seek"), 2) return if (play_pts + pts) < download_pts: self._do_seek_relative(pts) return else: want_seek_minutes = pts / 90000 / 60 can_seek = self.pts_to_hms(download_pts - play_pts) can_seek_minutes = can_seek[1] show_info_message(self.session, _("Cannot seek") + " " + str(want_seek_minutes) + " " + _("minutes forward not enough video is downloaded.\n") + _("You can seek maximum") + " " + str(can_seek_minutes) + " " + _("minutes forward"))
def get_misc_settings(): list = [] list.append( getConfigListEntry(_("Show broken addons"), config.plugins.archivCZSK.showBrokenAddons)) list.append( getConfigListEntry(_("Convert captcha images to 8bit"), config.plugins.archivCZSK.convertPNG)) list.append( getConfigListEntry(_("Drop caches on exit"), config.plugins.archivCZSK.clearMemory)) verification = config.plugins.archivCZSK.linkVerification.getValue() if not (videoPlayerInfo.type == 'gstreamer'): list.append( getConfigListEntry(_("Use link verification"), config.plugins.archivCZSK.linkVerification)) if verification: list.append( getConfigListEntry( _("Verification timeout"), config.plugins.archivCZSK.linkVerificationTimeout)) if ARCH == 'sh4': list.append( getConfigListEntry(_("Amiko HDMU fix"), config.plugins.archivCZSK.hdmuFix)) return list
def __init__(self, session, name, content_provider): BaseArchivCZSKMenuListScreen.__init__(self, session, panelList=PanelListDownload) DownloadList.__init__(self) self.name = name self.content_provider = content_provider from Plugins.Extensions.archivCZSK.engine.player.player import Player self.player = Player(session, self.workingFinished) self.sort_options = [{'id':'az', 'name':_('Sort alphabetically')}, {'id':'date', 'name':_('Sort by date')}, {'id':'size', 'name':_('Sort by size')}, {'id':'state', 'name':_('Sort by state')}] self.sort_current = self.sort_options[0] self.sort_next = self.sort_options[1] self.lst_items = self.content_provider.get_downloads() self["key_red"] = Button(_("Remove")) self["key_green"] = Button("") self["key_yellow"] = Button(self.sort_next['name']) self["key_blue"] = Button("") self.title = self.name.encode('utf-8', 'ignore') + ' - ' + (_("Downloads")) self["actions"] = NumberActionMap(["archivCZSKActions"], { "ok": self.ok, "cancel": self.cancel, "red": self.askRemoveDownload, "yellow": self.toggleSort, "up": self.up, "down": self.down, }, -2) self.onLayoutFinish.append(self.sortList) self.onShown.append(self.setWindowTitle)
def __init__(self, session, it): BaseArchivCZSKScreen.__init__(self, session) self.image_link = None self.it = it self.image_dest = None if it.image is not None: self.image_link = it.image.encode('utf-8', 'ignore') self.image_dest = os.path.join('/tmp/', self.image_link.split('/')[-1]) self.plot = '' self.genre = '' self.rating = '' self.year = '' for key, value in it.info.iteritems(): if key == 'Plot' or key == 'plot': self.plot = value.encode('utf-8', 'ignore') if key == 'Genre' or key == 'genre': self.genre = value.encode('utf-8', 'ignore') if key == 'Rating' or key == 'rating': self.rating = value.encode('utf-8', 'ignore') if key == 'Year' or key == 'year': self.year = value.encode('utf-8', 'ignore') self["img"] = Pixmap() self["genre"] = Label(_("Genre: ") + self.genre) self["year"] = Label(_("Year: ") + self.year) self["rating"] = Label(_("Rating: ") + self.rating) self["plot"] = ScrollLabel(self.plot) self["actions"] = NumberActionMap(["archivCZSKActions"], { "cancel": self.close, "up": self.pageUp, "down": self.pageDown, }, -2) self.title = self.it.name.encode('utf-8', 'ignore') self.Scale = AVSwitch().getFramebufferScale() self.picLoad = ePicLoad() self.picLoad.PictureData.get().append(self.decodePicture) self.onLayoutFinish.append(self.showPicture)
def showCSFDInfo(session, item): try: name = removeDiacriticsCsfd(item.name) name = name.replace('.', ' ').replace('_', ' ').replace('-', ' ') name = name.replace(" CZ ", "").replace(" EN ", "").replace( " SK ", "").replace(" DA ", "").replace(" FI ", "").replace( " CH ", "").replace(" HI ", "").replace(" JP ", "").replace(" KH ", "") name = name.replace(" RU ", "").replace(" KO ", "").replace(" SP ", "") year = 0 yearStr = "" try: mask = re.compile('([0-9]{4})', re.DOTALL) yearStr = mask.findall(name)[0] year = int(yearStr) except: pass if ' (' in name: name = name[0:name.index("(")] name = name.strip() log.logDebug("Csfd search '%s', year=%s." % (name, year)) csfdType = int(config.plugins.archivCZSK.csfdMode.getValue()) if csfdType == 1: from Plugins.Extensions.archivCZSK.gui.archivcsfd import ArchivCSFD session.open(ArchivCSFD, name, year) elif csfdType == 2: from Plugins.Extensions.CSFD.plugin import CSFD session.open(CSFD, name) elif csfdType == 3: from Plugins.Extensions.CSFDLite.plugin import CSFDLite try: session.open(CSFDLite, name, yearStr) except: log.logDebug("Trying CsfdLite older version compatibility...") session.open(CSFDLite, name) else: raise Exception("CsfdMode '%s' not supported." % csfdType) except: log.logError( "Show CSFD info failed (plugin may not be installed).\n%s" % traceback.format_exc()) try: showInfoMessage(session, _("Show CSFD info failed."), timeout=6) except: pass
def showUpdatePremium2(self, callback=None): if not callback: pdir = os.path.join(settings.ENIGMA_PLUGIN_PATH,'archivCZSKpremium') if not os.path.isdir(pdir): os.mkdir(pdir) self.downloadCommit() else: strMsg = _('Remove old ArchivCZSK?')+'\n' self.archiv.session.openWithCallback(self.updatePremium, MessageBox, strMsg, type=MessageBox.TYPE_YESNO, default=False)
def removeDiacritics(self): try: import unicodedata except ImportError: showInfoMessage( self.session, _("Cannot remove diacritics, missing unicodedata.so")) else: self.searchExp = ''.join( (c for c in unicodedata.normalize( 'NFD', unicode(self.searchExp, 'utf-8', 'ignore')) if unicodedata.category(c) != 'Mn')).encode('utf-8') self["search"].setText(self.searchExp)
def askOverrideCB(callback=None): if callback: if callback[1] == "override": try: if dInstance: dManager.removeDownload(dInstance) else: os.remove(download.local) dManager.addDownload(download) except OSError as e: print e elif callback[1] == "rename": session.openWithCallback(renameCB, VirtualKeyBoard, _("Rename filename"), text=download.filename)
def showMenu(self): try: self["statusbar"].show() #if ( self.Page is 1 or self.Page is 2 ) and self.resultlist: self.setTitle(_("Search results for")+ (" '%s'"%self.nazeveventuproskin)) self["menu"].show() self["stars"].hide() self["starsbg"].hide() self["ratinglabel"].hide() self["poster"].hide() self["extralabel"].hide() #self["titlelabel"].hide() self["detailslabel"].hide() self["baseFilmInfo"].hide() self["key_blue"].setText("") self["key_green"].setText(_("List")) self["key_yellow"].setText(_("Film info")) self.Page = 0 except: self["statusbar"].show() self["statusbar"].setText("Fatal ERROR") log.logError("Action showMenu failed.\n%s"%traceback.format_exc())
def _init_menu(self, item): addon = item.addon item.add_context_menu_item(_("Enable"), enabled=not addon.get_setting('enabled'), action=self._enable_addon, params={'addon': addon}) item.add_context_menu_item(_("Disable"), enabled=addon.get_setting(('enabled')), action=self._disable_addon, params={'addon': addon}) item.add_context_menu_item(_("Settings"), action=addon.open_settings, params={'session': self.session}) item.add_context_menu_item(_("Changelog"), action=addon.open_changelog, params={'session': self.session}) item.add_context_menu_item(_("Remove"), enabled=not addon.supported, action=self._remove_addon, params={'addon': addon}) ItemHandler._init_menu(self, item)
def search(self, search_exp, addon_id, mode=None): if self.searching: showInfoMessage(self.session, _("You cannot search, archivCZSK Search is already running")) print "%s cannot search, searching is not finished" % self return if addon_id.lower() == 'csfd': CsfdSearch().showCSFDInfo(self.session, search_exp) return self.cb() elif addon_id.lower() == 'internalcsfd': return self.cb() else: searcher = getSearcher(self.session, addon_id, self.archivCZSK, self._successSearch, self._errorSearch) if searcher is not None: self.searcher = searcher self.searching = True self.addon = searcher.addon searcher.start() searcher.search(search_exp, mode) else: showInfoMessage(self.session, _("Cannot find searcher") + ' ' + addon_id.encode('utf-8')) return self.cb()
def __init__(self, session, captcha_file): BaseArchivCZSKScreen.__init__(self, session, False) VirtualKeyBoard.__init__(self, session, title=removeDiac(_('Type text of picture'))) self["captcha"] = Pixmap() self.Scale = AVSwitch().getFramebufferScale() self.picPath = captcha_file self.picLoad = ePicLoad() self.picLoad_conn = eConnectCallback(self.picLoad.PictureData, self.decodePicture) self.onLayoutFinish.append(self.showPicture) self.onClose.append(self.__onClose)
def __service_started(self): self.__timer.stop() self.resetSubs(True) if (self.__resume_time_sec is not None or self.__subtitles_url is not None): if self.__resume_time_sec is not None: Notifications.AddNotificationWithID(self.RESUME_POPUP_ID, MessageBox, _("Resuming playback"), timeout=0, type=MessageBox.TYPE_INFO, enable_input=False) self.__timer.start(500, True)
def player_callback(self, callback): log.info("player_callback(%r)" % (callback, )) if callback is not None: if callback[0] == "eof": if callback[1]: self.player_callback(("playlist", "next")) else: self.video_player.close() elif callback[0] == "exit": exit_player = True if len(callback) == 2: exit_player = callback[1] else: if self.settings.confirmExit.value: self.session.openWithCallback( lambda x: self.player_callback(("exit", x)), MessageBox, text=_("Stop playing this movie?"), type=MessageBox.TYPE_YESNO) exit_player = False if exit_player: playpos = getPlayPositionInSeconds(self.session) duration = getDurationInSeconds(self.session) self.video_player.close() elif callback[0] == "playlist": if callback[1] == "show": if self.playlist_item is not None: title = self.playlist_item.name else: title = self._play_item.name self.playlist_dialog = self.session.openWithCallback( lambda x: self.player_callback( ("playlist", "idx", x)), ArchivCZSKPlaylist, self.playlist, title, self.curr_idx) elif callback[1] == "prev": idx = self.curr_idx if idx == 0: idx = len(self.playlist) - 1 else: idx -= 1 self.play_item(idx=idx) elif callback[1] == "next": idx = self.curr_idx # maybe ignore/make optional if idx == len(self.playlist) - 1: self.video_player.close() else: idx += 1 self.play_item(idx=idx) elif callback[1] == "idx": self.play_item(idx=callback[2])
def getCapabilities(): """ Vrati zoznam vsetkych moznosti vyhladavania: tuple(nazov_vyhladavania, id_doplnku, mod_vyhladavania) """ list = [] #list.append((_('Search in') + ' ' + 'OnlineFiles', 'plugin.video.online-files', 'all')) list.append((_('Search in') + ' ' + 'Stream Cinema Community', 'plugin.video.sc2', 'all')) list.append((_('Search in') + ' ' + 'Stream Cinema', 'plugin.video.stream-cinema', 'all')) list.append((_('Search in') + ' ' + 'Sosac', 'plugin.video.sosac.ph', 'all')) list.append((_('Search in') + ' ' + 'CSFD', 'csfd', 'all')) #list.append((_('Search in') + ' ' + 'Befun.cz', 'plugin.video.befun.cz', 'all')) #list.append((_('Search in') + ' ' + 'Koukni.cz', 'plugin.video.koukni.cz', 'koukni.cz')) list.append((_('Search in') + ' ' + 'Webshare.cz', 'plugin.video.online-files', 'webshare.cz')) list.append((_('Search in') + ' ' + 'Ulozto.cz', 'plugin.video.online-files', 'ulozto.cz')) list.append((_('Search in') + ' ' + 'Bezvadata.cz', 'plugin.video.online-files', 'bezvadata.cz')) list.append((_('Search in') + ' ' + 'Hellspy.cz', 'plugin.video.online-files', 'hellspy.cz')) list.append((_('Search in') + ' ' + 'Fastshare.cz', 'plugin.video.online-files', 'fastshare.cz')) return list
def get_main_settings(): list = [] list.append(getConfigListEntry(_("Skin"), config.plugins.archivCZSK.skin)) list.append( getConfigListEntry(_("Default category"), config.plugins.archivCZSK.defaultCategory)) list.append( getConfigListEntry(_("Allow archivCZSK auto update"), config.plugins.archivCZSK.archivAutoUpdate)) list.append( getConfigListEntry(_("Allow addons auto update"), config.plugins.archivCZSK.autoUpdate)) list.append(MENU_SEPARATOR) list.append( getConfigListEntry(_("Show movie info"), config.plugins.archivCZSK.showVideoInfo)) list.append( getConfigListEntry(_("Show movie poster"), config.plugins.archivCZSK.downloadPoster)) list.append( getConfigListEntry(_("Max posters on HDD"), config.plugins.archivCZSK.posterImageMax)) list.append(MENU_SEPARATOR) # list.append(getConfigListEntry(_("Preload"), config.plugins.archivCZSK.preload)) list.append( getConfigListEntry(_("Add to extensions menu"), config.plugins.archivCZSK.extensions_menu)) list.append( getConfigListEntry(_("Add to main menu"), config.plugins.archivCZSK.main_menu)) # if i know this is not functional #list.append(getConfigListEntry(_("Add search option in epg menu"), config.plugins.archivCZSK.epg_menu)) list.append(MENU_SEPARATOR) list.append( getConfigListEntry(_("CSFD plugin"), config.plugins.archivCZSK.csfdMode)) return list
def _init_menu(self, item): self.item = item addon = item.addon # item.add_context_menu_item(_("Update"), action=item.addon.update) item.add_context_menu_item(_("Settings"), action=addon.open_settings, params={'session': self.session}) item.add_context_menu_item(_("Changelog"), action=addon.open_changelog, params={'session': self.session}) item.add_context_menu_item(_("Downloads"), action=addon.open_downloads, params={ 'session': self.session, 'cb': self.content_screen.workingFinished }) item.add_context_menu_item(_("Shortcuts"), action=addon.open_shortcuts, params={ 'session': self.session, 'cb': self.open_shortcuts_cb })
def Plugins(path, **kwargs): list = [PluginDescriptor(where=[PluginDescriptor.WHERE_SESSIONSTART], fnc=sessionStart), PluginDescriptor(NAME, description=DESCRIPTION, where=PluginDescriptor.WHERE_PLUGINMENU, fnc=main, icon="czsk.png")] if config.plugins.archivCZSK.extensions_menu.value: #list.append(PluginDescriptor(NAME, where=PluginDescriptor.WHERE_EXTENSIONSMENU, fnc=main)) list.append(PluginDescriptor(NAME, description=DESCRIPTION, where=PluginDescriptor.WHERE_EXTENSIONSMENU, fnc=main)) if config.plugins.archivCZSK.main_menu.value: #list.append(PluginDescriptor(NAME, where=PluginDescriptor.WHERE_MENU, fnc=menu)) list.append(PluginDescriptor(NAME, description=DESCRIPTION, where=PluginDescriptor.WHERE_MENU, fnc=menu)) if config.plugins.archivCZSK.epg_menu.value: list.append(PluginDescriptor(_("Search in ArchivCZSK"), where=PluginDescriptor.WHERE_EVENTINFO, fnc=eventInfo)) list.append(PluginDescriptor("OS_refresh", where=PluginDescriptor.WHERE_EVENTINFO, fnc=osrefresh)) return list
def wrapped(*args, **kwargs): try: try: func(*args, **kwargs) # addon specific exceptions except addon.AddonInfoError as er: log.logError("Addon (AddonInfoError) error '%s'.\n%s"%(er.value,traceback.format_exc())) self.infoMessage(er.value) except addon.AddonWarningError as er: log.logError("Addon (AddonWarningError) error '%s'.\n%s"%(er.value,traceback.format_exc())) self.warningMessage(er.value) except addon.AddonError as er: log.logError("Addon (AddonError) error '%s'.\n%s"%(er.value,traceback.format_exc())) self.errorMessage(er.value) # loading exceptions except urllib2.HTTPError, e: log.logError("Addon (HTTPError) error '%s'.\n%s"%(e.code,traceback.format_exc())) message = "%s %s:%d" % (_("Error in loading"), _("HTTP Error"), e.code) self.errorMessage(message) except urllib2.URLError, e: log.logError("Addon (URLError) error '%s'.\n%s"%(e.reason,traceback.format_exc())) message = "%s %s:%s" % (_("Error in loading"), _("URL Error"), str(e.reason)) self.errorMessage(message)
def showCSFDInfo(self, session, searchExp): try: name = removeDiac(searchExp) name = name.replace('.', ' ').replace('_', ' ').replace('*', '') # remove languages ... "Mother - CZ, EN, KO (2017)" name = re.sub("\s-\s[A-Z]{2}(,\s[A-Z]{2})*\s\(", " (", name) year = 0 yearStr = "" try: mask = re.compile('([0-9]{4})', re.DOTALL) yearStr = mask.findall(name)[0] year = int(yearStr) except: pass # remove year name = re.sub("\([0-9]{4}\)", "", name) name = name.strip() log.logDebug("Csfd search '%s', year=%s." % (name, year)) csfdType = int(config.plugins.archivCZSK.csfdMode.getValue()) if csfdType == 1: from Plugins.Extensions.archivCZSK.gui.archivcsfd import ArchivCSFD session.open(ArchivCSFD, name, year) elif csfdType == 2: from Plugins.Extensions.CSFD.plugin import CSFD session.open(CSFD, name) elif csfdType == 3: from Plugins.Extensions.CSFDLite.plugin import CSFDLite try: session.open(CSFDLite, name, yearStr) except: log.logDebug( "Trying CsfdLite older version compatibility...") session.open(CSFDLite, name) else: raise Exception("CsfdMode '%s' not supported." % csfdType) except: log.logError( "Show CSFD info failed (plugin may not be installed).\n%s" % traceback.format_exc()) try: showInfoMessage(session, _("Show CSFD info failed."), timeout=6) except: pass
def get_misc_settings(): list = [] list.append(getConfigListEntry(_("Debug mode"), config.plugins.archivCZSK.debugMode)) list.append(getConfigListEntry(_("Confirm exit when closing plugin"), config.plugins.archivCZSK.confirmExit)) list.append(getConfigListEntry(_("Show broken addons"), config.plugins.archivCZSK.showBrokenAddons)) list.append(getConfigListEntry(_("Show video source selection"), config.plugins.archivCZSK.showVideoSourceSelection)) list.append(getConfigListEntry(_("Convert captcha images to 8bit"), config.plugins.archivCZSK.convertPNG)) list.append(getConfigListEntry(_("Drop caches on exit"), config.plugins.archivCZSK.clearMemory)) return list
class AddonExceptionHandler(GUIExceptionHandler): errorName = _("Addon error") warningName = _("Addon warning") infoName = _("Addon info") def __call__(self, func): def wrapped(*args, **kwargs): try: try: func(*args, **kwargs) # addon specific exceptions except addon.AddonInfoError as er: log.logError("Addon (AddonInfoError) error '%s'.\n%s"%(er.value,traceback.format_exc())) self.infoMessage(er.value) except addon.AddonWarningError as er: log.logError("Addon (AddonWarningError) error '%s'.\n%s"%(er.value,traceback.format_exc())) self.warningMessage(er.value) except addon.AddonError as er: log.logError("Addon (AddonError) error '%s'.\n%s"%(er.value,traceback.format_exc())) self.errorMessage(er.value) # loading exceptions except urllib2.HTTPError, e: log.logError("Addon (HTTPError) error '%s'.\n%s"%(e.code,traceback.format_exc())) message = "%s %s:%d" % (_("Error in loading"), _("HTTP Error"), e.code) self.errorMessage(message) except urllib2.URLError, e: log.logError("Addon (URLError) error '%s'.\n%s"%(e.reason,traceback.format_exc())) message = "%s %s:%s" % (_("Error in loading"), _("URL Error"), str(e.reason)) self.errorMessage(message) except addon.AddonThreadException as er: log.logError("Addon (AddonThreadException) error.\n%s"%(traceback.format_exc())) pass # we handle all possible exceptions since we dont want plugin to crash because of addon error.. except Exception, e: log.logError("Addon error.\n%s"%traceback.format_exc()) self.errorMessage(_("Author of this addon needs to update it")) traceback.print_exc()
def search(session, search_exp, addon_id, mode=None, cb=None): """ Vyhlada v archivCZSK hladany vyraz prostrednictvom addonu s addon_id s modom vyhladavania mode @param : session - aktivna session @param : search_exp - hladany vyraz @param : addon_id - id addonu v ktorom chceme vyhladavat @param : mode - mod vyhladavania podporovany addonom """ if search_exp is None or search_exp == "": showInfoMessage(session, _("Empty search expression")) return cb() archivCZSKSeeker = ArchivCZSKSeeker.getInstance(session, cb) if archivCZSKSeeker is not None: archivCZSKSeeker.search(search_exp, addon_id, mode)
def download_commit(self): try: log.logInfo("Checking addons update...") path = os.path.join(os.path.dirname(__file__), 'commit') if os.path.exists(path): os.remove(path) self.__updateDialog = self.session.openWithCallback(self.check_updates_finished, MessageBox, _("Checking for updates"), type=MessageBox.TYPE_INFO, enable_input=False) self.__console = Console() self.__console.ePopen('curl -kfo %s https://raw.githubusercontent.com/mx3L/archivczsk-doplnky/master-next/commit' % path, self.check_commit_download) except: log.logError("Download addons commit failed.") self.open_archive_screen()
def updateMenuList(self, index=0): itemList = [] itemColor = 0xffffff addonState = _("enabled") for item in self.lst_items: addon = item.addon if addon.get_info('broken'): itemColor = 0xff0000 addonState = _("broken") elif not addon.get_setting('enabled'): if addon.supported: itemColor = 0xffff00 else: itemColor = 0xf5f500 addonState = _("disabled") else: if addon.supported: itemColor = 0x00ff00 else: itemColor = 0x00f500 addonState = _("enabled") itemList.append((toString(item.name), addonState, itemColor)) self["menu"].list = itemList self["menu"].index = index
def ask_if_download(): filename[0], size_bytes = getFilenameAndLength( item.url, headers, filename[0]) size_mbytes = size_bytes and util.BtoMB(size_bytes) or "???" free_bytes = util.get_free_space(destination[0]) free_mbytes = free_bytes and util.BtoMB(free_bytes) or "???" message = "%s:\n\n%s:\n%s - %sMB\n\n%s:\n%s - %sMB %s\n\n%s:\n%s" % ( _("Do you want to download"), _("Source"), toString( item.name), str(size_mbytes), _("Destination"), toString(destination[0]), str(free_mbytes), _("free"), _("Filename"), toString(filename[0])) choices = [(_("yes"), "yes"), (_("no"), "no"), (_("Change location"), "change"), (_("Edit filename"), "filename")] session.openWithCallback(ask_if_download_callback, MessageBox, message, MessageBox.TYPE_YESNO, list=choices)
def doWork(self): try: def check_archiv(): try: if self.downloadUpdateXml(): from Plugins.Extensions.archivCZSK.version import version local_version = version xmlroot = util.load_xml( self.updateXmlFilePath).getroot() self.remote_version = xmlroot.attrib.get('version') log.logDebug( "ArchivUpdater version local/remote: %s/%s" % (local_version, self.remote_version)) if util.check_version(local_version, self.remote_version): self.needUpdate = True else: self.needUpdate = False else: self.needUpdate = False except: log.logError("ArchivUpdater compare versions failed.\n%s" % traceback.format_exc()) check_archiv() #thread = threading.Thread(target=check_archiv) #thread.start() #thread.join() if self.needUpdate: log.logInfo("ArchivUpdater update found...%s" % self.remote_version) strMsg = "%s %s?" % ( _("Do you want to update archivCZSK to version"), toString(self.remote_version)) self.archiv.session.openWithCallback( self.updateArchiv, MessageBox, strMsg, type=MessageBox.TYPE_YESNO) else: self.continueToArchiv() except: log.logError("ArchivUpdater update failed.\n%s" % traceback.format_exc()) self.continueToArchiv()