def __init__(self, config): self.radarr = Radarr(config.radarr_url, config.radarr_base_path, config.radarr_api_key, config.radarr_quality_profile) self.imdb = Imdb() self.score11 = Score11(self.imdb) self.ask = Preferences(self.imdb)
def init(self): self._preferences = Preferences() if constants.IS_DEVELOPMENT: self.__servers = DevelopmentServers(self._preferences) else: self.__servers = Servers(self._preferences) connectionManager.onLoggedOn += self._onLoggedOn
def open_preferences(self, event): # wxGlade: MeerK40t.<event_handler> project.close_old_window("preferences") from Preferences import Preferences window = Preferences(None, wx.ID_ANY, "") window.set_project(project) window.Show() project.windows["preferences"] = window
def init(self): self.tryPrepareWGCLogin() self._preferences = Preferences() if constants.IS_DEVELOPMENT: self.__servers = DevelopmentServers(self._preferences) else: self.__servers = Servers(self._preferences) self.connectionMgr.onLoggedOn += self._onLoggedOn
def __init__(self, arguments): super().__init__(arguments) self.mainWindow = None self.setOrganizationName('QtHEP') self.setApplicationName('QtHEP') QStandardPaths.setTestModeEnabled(__DEVELOPEMENT__) preferencesPath = QStandardPaths.writableLocation( QStandardPaths.AppDataLocation) if (not os.path.exists(preferencesPath)): os.makedirs(preferencesPath) self.preferencesFilename = os.path.join( preferencesPath, '{}.preferences.xml'.format(self.applicationName())) self.preferences = Preferences() if (os.path.exists(self.preferencesFilename)): self.preferences.fromXML(self.preferencesFilename) self.preferences.logging.initializeLog() else: self.preferences.toXML(self.preferencesFilename) DiscFilenameTemplatesSingleton().set( self.preferences.filenameTemplates) DiscMixdownsSingleton().set(self.preferences.mixdowns.getMixdowns()) DiscPresetsSingleton().set(self.preferences.presets.getNames()) self.disc = Disc(self) TitleVisibleSingleton().set( self.preferences.autoTitle.minimumTitleSeconds, self.disc.hideShortTitles) self.defaultSessionFilename = "{}.state.xml".format( self.applicationName()) if __DEVELOPEMENT__: # self.settingsFilename = os.path.join(os.getcwd(), "{}.settings.xml".format(APP_NAME)) # self.fullDefaultSessionFilename = os.path.join(os.getcwd(), self.defaultSessionFilename) s = os.path.join(os.getcwd(), 'TestFiles') self.temporarySessionFilename = os.path.join( s, "temp.{}".format(self.defaultSessionFilename)) # self.logFilename = os.path.join(os.getcwd(), "{}.log".format(APP_NAME)) else: if (os.path.exists(self.standardPaths.GetUserDataDir()) == False): os.makedirs(self.standardPaths.GetUserDataDir()) SingletonLog().writeline('{} created'.format( self.standardPaths.GetUserDataDir())) # self.settingsFilename = os.path.join(self.standardPaths.GetUserDataDir(), "{}.settings.xml".format(APP_NAME)) # self.fullDefaultSessionFilename = os.path.join(self.standardPaths.GetUserDataDir(), self.defaultSessionFilename) self.temporarySessionFilename = os.path.join( self.standardPaths.GetUserDataDir(), "temp.{}".format(self.defaultSessionFilename))
def test_table_time_gen(sh): startdate = datetime(2016, 01, 31, 12, 00, 00) totalSeconds = 86400 interval = 3600 amount = totalSeconds / interval pr = Preferences() prefix = pr.get('DBPrefix') sh.createNewTableStructure(prefix) sh.generateTimeSlots(startdate, interval, amount, prefix)
def __init__(self, *args, **kwds): # begin wxGlade: MainFrame.__init__ kwds["style"] = wx.DEFAULT_FRAME_STYLE wx.Frame.__init__(self, *args, **kwds) # Menu Bar self.main_frame_menubar = wx.MenuBar() self.File = wx.Menu() self.Exit = wx.MenuItem(self.File, wx.ID_EXIT, _("E&xit\tCtrl-Q"), _("Exit"), wx.ITEM_NORMAL) self.File.AppendItem(self.Exit) self.main_frame_menubar.Append(self.File, _("&File")) self.Help = wx.Menu() self.About = wx.MenuItem(self.Help, wx.ID_ABOUT, _("&About"), _("About"), wx.ITEM_NORMAL) self.Help.AppendItem(self.About) self.main_frame_menubar.Append(self.Help, _("&Help")) self.SetMenuBar(self.main_frame_menubar) # Menu Bar end self.logo_bitmap = wx.StaticBitmap(self, wx.ID_ANY, wx.NullBitmap) self.src_dir_text_ctrl = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_READONLY) self.src_dir_button = wx.Button(self, wx.ID_ANY, _("Source folder")) self.dest_dir_text_ctrl = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_READONLY) self.dst_folder_button = wx.Button(self, wx.ID_ANY, _("Destination folder")) self.tiff_checkbox = wx.CheckBox(self, wx.ID_ANY, _("TIFF")) self.dng_checkbox = wx.CheckBox(self, wx.ID_ANY, _("DNG")) self.thumb_checkbox = wx.CheckBox(self, wx.ID_ANY, _("Thumbnail")) self.rotate_checkbox = wx.CheckBox(self, wx.ID_ANY, _("Rotation")) self.convert_button = wx.Button(self, wx.ID_ANY, _("Convert")) self.status_text_ctrl = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_MULTILINE | wx.TE_READONLY) self.abort_button = wx.Button(self, wx.ID_ANY, _("Abort")) self.__set_properties() self.__do_layout() self.Bind(wx.EVT_MENU, self.OnClose, self.Exit) self.Bind(wx.EVT_MENU, self.OnMenuAbout, self.About) self.Bind(wx.EVT_BUTTON, self.OnSrcFolder, self.src_dir_button) self.Bind(wx.EVT_BUTTON, self.OnDstFolder, self.dst_folder_button) self.Bind(wx.EVT_CHECKBOX, self.OnTIFFClicked, self.tiff_checkbox) self.Bind(wx.EVT_CHECKBOX, self.OnDNGClicked, self.dng_checkbox) self.Bind(wx.EVT_CHECKBOX, self.OnThumbnailClicked, self.thumb_checkbox) self.Bind(wx.EVT_CHECKBOX, self.OnRotationClicked, self.rotate_checkbox) self.Bind(wx.EVT_BUTTON, self.OnConvert, self.convert_button) self.Bind(wx.EVT_BUTTON, self.OnAbort, self.abort_button) # end wxGlade self.images = Images() self.logo_bitmap.SetBitmap(self.images.bmp_logo) self.proc = None self.Bind(wx.EVT_CLOSE, self.OnClose) self.SetMinSize(self.GetSize()) self.prefs = Preferences() self.dng_checkbox.SetValue(self.prefs.get_dng()) self.tiff_checkbox.SetValue(self.prefs.get_tiff()) self.thumb_checkbox.SetValue(self.prefs.get_thumbnail()) self.rotate_checkbox.SetValue(self.prefs.get_rotate())
def test_competitor_creation(sh): global pr pr = Preferences() prefix = pr.get('DBPrefix') sh = SetupHelper.SetupHelper() sh.setManualDbCursor(DatabaseConnection.DatabaseConnection().getDatabaseCursor()) if random() < 0.5: print sh.createNewCompetitor(names.get_last_name(), names.get_first_name(gender='male'), "U18M", prefix) else: print sh.createNewCompetitor(names.get_last_name(), names.get_first_name(gender='female'), "U18F", prefix)
def init(self): if WGC.prepare(): self.__wgcPublication = WGC.getPublication() else: _logger.error('WGC API initialization failed') self.tryPrepareWGCLogin() self._preferences = Preferences() if constants.IS_DEVELOPMENT: self.__servers = DevelopmentServers(self._preferences) else: self.__servers = Servers(self._preferences) self.connectionMgr.onLoggedOn += self._onLoggedOn
def __init__(self, master): self.valves = self.get_valves() self.master = master self.master.configure(bg='sky blue') self.password = '******' self.momentary = Momentary(self.master, self.valves) self.edit = Edit(self.master, self.valves) self.summary = Summary(self.master, self.valves) self.preferences = Preferences(self.master, self.valves) self.run_screen = RunScreen(self.master, self.valves) self.header = self.make_header(self.master) self.home = self.home_page(self.master) self.frame = self.home
def __init__(self, layout='MainLayout', settings_key=""): super(Plugin, self).__init__() # Name of layout that this plugin should be added (see PluginManager.py) self._main_layout_name = layout # The default size policy self.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) # Must be a QtWidget if not isinstance(self, QtWidgets.QWidget): mooseutils.mooseError("A Plugin must also be a QWidget.") return # The Peacock tab index self._index = None self._plugin_manager = None self._preferences = Preferences(settings_key)
def setDefaults(self): """ Setup parts of the application that have some sort of default. Intended to be used when creating a new project to reset the application to a blank slate. """ # Remove or hide any windows subWindows = self.ui.workspace.subWindowList() for window in subWindows: if type(window).__name__ in ["DataTableSubWindow", "FigureSubWindow"]: window.setAttribute(Qt.WA_DeleteOnClose) window.close() else: window.setVisible(False) # Remove signals try: self.waves().waveAdded.disconnect(self.model('appWaves').appendRow) except: pass try: self.waves().allWavesRemoved.disconnect(self.model('appWaves').removeAllWaves) except: pass # Set variables self._waves = Waves() self._figures = Figures() self._models = {} self.projectDir = "" # current project directory self.setCurrentProject("") self._storedSettings = {} # this is a dict with widgetName: list pairs # where each list has [setting-name, setting-value] pairs # setting-value is a dict with (property-name: Property) pairs # Load Preferences Util.debug(2, "App", "Loading Preferences from file") self.preferences = Preferences("~/.pysciplotrc") # Create application-wide models self._models['appWaves'] = WavesListModel(self.waves().waveNames()) # Signals self.waves().waveAdded.connect(self.model('appWaves').appendRow) self.waves().allWavesRemoved.connect(self.model('appWaves').removeAllWaves) # Reload modules for module in self._loadedModules.values(): module.reload()
def __init__(self): # On cree l'instance de la classe dialog self.dialog = Dialog() self.dialog.setBackgroundTitle("TVDownloader") # On recupere l'instance de API self.api = API.getInstance() # On instancie le gestionnaire de download self.downloader = Downloader() # On instancie le gestionnaire d'historique self.historique = Historique() # On instancie le gestionnaire de preferences self.preferences = Preferences() # Liste des telechargements self.listeTelechargements = [] # Quand le programme se termine, on execute la fonction actionsAvantQuitter atexit.register(self.actionsAvantQuitter) # On commence self.bouclePrincipale()
def __init__(self): self.prefs = Preferences() self.db = SQLController() self.load_skill_bp_into_prefs() self.__ui_components = {} self.__pc_roster = {} self.__skill_shorts = {} pc_filepaths = [] #pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml') pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml') self.load_pc_roster(pc_filepaths) #print(str(self.__pc_roster['Toni'])) self.prepare_skill_shorts() weapons = self.prefs.transfer_wpns_from_txt_to_sql() wpn_table=self.db.table('wpn_blueprints') skills = self.prefs.get_skills_dictionary() skill_bp_table = self.db.table('skill_blueprints') #self.__wpn_db = WeaponSqlController() self.add_skills_bp_to_db(skills, skill_bp_table) #print(weapons) for weapon in weapons: name = str(weapon.get_attribute('name')) type = str(weapon.get_attribute('type')) wa = str(weapon.get_attribute('wa')) con = str(weapon.get_attribute('con')) av = str(weapon.get_attribute('av')) dmg = str(weapon.get_attribute('dmg')) ammo = str(weapon.get_attribute('ammo')) shts = str(weapon.get_attribute('shts')) rof = str(weapon.get_attribute('rof')) rel = str(weapon.get_attribute('rel')) range = str(weapon.get_attribute('range')) cost = str(weapon.get_attribute('cost')) source = str(weapon.get_attribute('source')) category = str(weapon.get_attribute('category')) wpn_table.add_wpn(name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, category=category, source=source) #wpn_table.print_table() self.load_character('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml') self.db.add_character_to_database(self.c) start = StartMenu(self)
class PreferencesTests( unittest.TestCase ): ## Initialisation def setUp( self ): self.preferences = Preferences() ## Fin def tearDown( self ): pass def testSingleton( self ): """Test si le pattern singleton est bien en place""" self.assertEqual( id( self.preferences ), id( Preferences() ) ) def testSauvegarde( self ): """Test si les preferences sont bien sauvegardees""" listePreferences = getattr( self.preferences, "preferences" ) nomPreference = listePreferences.keys()[ 0 ] nouvelleValeur = "ValeurDeTest" # On met en place la preference self.preferences.setPreference( nomPreference, nouvelleValeur ) # On verifie qu'elle est bien en place self.assertEqual( nouvelleValeur, self.preferences.getPreference( nomPreference ) )
def __init__(self, layout='MainLayout', settings_key="", **kwargs): super(Plugin, self).__init__() # Name of layout that this plugin should be added (see PluginManager.py) self._main_layout_name = layout # The default size policy self.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) # Must be a QtWidget if not isinstance(self, QtWidgets.QWidget): mooseutils.mooseError("A Plugin must also be a QWidget.") return # The Peacock tab index self._index = None self._plugin_manager = None self._preferences = Preferences(settings_key)
def main(): from Preferences import Preferences app = wx.PySimpleApp() preferences = Preferences() frame = PreferencesDialog(preferences) result = frame.ShowModal() if result == wx.ID_OK: print 'OK' for subject in preferences.default: category = subject[0] print category for (field, value, width) in subject[1:]: if type(value) == type([]): print ' ', field,\ frame.controls[category][field].GetSelection() else: print ' ', field,\ frame.controls[category][field].GetValue() else: print 'Cancel' frame.Destroy() app.MainLoop()
# Dynamically imports all of the modules in the "animations" folder animations = [] animationNames = [] for (_, name, _) in pkgutil.iter_modules([Path('/home/pi/LEDWebsite/src/animations')]): animations.append(import_module('animations.' + name, package=__name__)) for i in dir(animations[len(animations) - 1]): attribute = getattr(animations[len(animations) - 1], i) for i in dir(animations[len(animations) - 1]): attribute = getattr(animations[len(animations) - 1], i) if inspect.isclass(attribute): setattr(sys.modules[__name__], name, attribute) # Set up the preferences class preferences = Preferences() # Define the number of pixels for the LED Strip numPixels = preferences.get_setup_preferences('num-pixels') # Initializes the LED strip pixels = neopixel.NeoPixel( board.D18, numPixels, brightness=preferences.get_setup_preferences('brightness'), auto_write=False, pixel_order=neopixel.GRB) def getAnimationOptions(): global thread
class Manager(object): def __init__(self): self._preferences = None self.__servers = None return def init(self): self._preferences = Preferences() if constants.IS_DEVELOPMENT: self.__servers = DevelopmentServers(self._preferences) else: self.__servers = Servers(self._preferences) connectionManager.onLoggedOn += self._onLoggedOn def fini(self): connectionManager.onLoggedOn -= self._onLoggedOn self._preferences = None self.__servers.fini() self.__servers = None return def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser): isToken2Login = isSocialToken2Login or self._preferences['token2'] if isToken2Login: authMethod = CONNECTION_METHOD.TOKEN2 else: authMethod = CONNECTION_METHOD.BASIC serverName = self._getHost(authMethod, serverName) self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session']) self._preferences['password_length'] = len(password) self._preferences['remember_user'] = rememberUser self._preferences['login'] = email self._preferences['server_name'] = serverName loginParams = {'login': self._preferences['login'], 'session': self._preferences['session'], 'temporary': str(int(not rememberUser)), 'auth_method': authMethod} if isToken2Login: loginParams['token2'] = self._preferences['token2'] if isSocialToken2Login: self._preferences['login_type'] = self._preferences['login_type'] else: self._preferences['login_type'] = 'credentials' connectionManager.initiateConnection(loginParams, password, serverName) def initiateRelogin(self, login, token2, serverName): loginParams = {'login': login, 'token2': token2, 'session': BigWorld.wg_cpsalt(self._preferences['session']), 'temporary': str(int(not self._preferences['remember_user'])), 'auth_method': CONNECTION_METHOD.TOKEN2} self._preferences['server_name'] = serverName connectionManager.initiateConnection(loginParams, '', serverName) def getPreference(self, key): return self._preferences[key] def clearPreferences(self): self._preferences.clear() def clearToken2Preference(self): self._preferences['token2'] = '' def writePreferences(self): self._preferences.writeLoginInfo() @property def servers(self): return self.__servers def _onLoggedOn(self, responseData): name = responseData.get('name', 'UNKNOWN') token2 = responseData.get('token2', '') g_lobbyContext.setCredentials(name, token2) if self._preferences['remember_user']: self._preferences['name'] = name self._preferences['token2'] = token2 if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED: del self._preferences['server_name'] else: email = self._preferences['login'] serverName = self._preferences['server_name'] session = self._preferences['session'] self._preferences.clear() if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset: self._preferences['login'] = email if not AUTO_LOGIN_QUERY_ENABLED: self._preferences['server_name'] = serverName self._preferences['session'] = session self.writePeripheryLifetime() self._preferences.writeLoginInfo() self.__dumpUserName(name) self._showSecurityMessage(responseData) def _showSecurityMessage(self, responseData): securityWarningType = responseData.get('security_msg') if securityWarningType is not None: securityLink = '' if not GUI_SETTINGS.isEmpty('securitySettingsURL'): securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS), 'linkType': 'securityLink'}) SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink) return def writePeripheryLifetime(self): if AUTO_LOGIN_QUERY_ENABLED and connectionManager.peripheryID: self._preferences['peripheryLifetime'] = pickle.dumps((connectionManager.peripheryID, time.time() + _PERIPHERY_DEFAULT_LIFETIME)) def _getHost(self, authMethod, hostName): if hostName != AUTO_LOGIN_QUERY_URL: return hostName else: pickledData = self._preferences['peripheryLifetime'] if pickledData: try: peripheryID, expirationTimestamp = pickle.loads(pickledData) except: LOG_DEBUG("Couldn't to read pickled periphery data. Connecting to {0}.".format(hostName)) return hostName if expirationTimestamp > time.time(): host = g_preDefinedHosts.periphery(peripheryID, False) if host is None: return hostName if authMethod != CONNECTION_METHOD.BASIC and host.urlToken: return host.urlToken return host.url return hostName def __dumpUserName(self, name): """ Dump user name to the preferences.xml (required by WGLeague's anti-cheat). See WOTD-55587. This method doesn't belong to Preferences class, so it's placed here. """ Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString('user', name) Settings.g_instance.save()
class Manager(ILoginManager): def __init__(self): self._preferences = None self.__servers = None return def init(self): self._preferences = Preferences() if constants.IS_DEVELOPMENT: self.__servers = DevelopmentServers(self._preferences) else: self.__servers = Servers(self._preferences) connectionManager.onLoggedOn += self._onLoggedOn def fini(self): connectionManager.onLoggedOn -= self._onLoggedOn self._preferences = None self.__servers.fini() self.__servers = None return def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser): isToken2Login = isSocialToken2Login or self._preferences['token2'] if isToken2Login: authMethod = CONNECTION_METHOD.TOKEN2 else: authMethod = CONNECTION_METHOD.BASIC serverName = self._getHost(authMethod, serverName) self._preferences['session'] = BigWorld.wg_cpsalt( self._preferences['session']) self._preferences['password_length'] = len(password) self._preferences['remember_user'] = rememberUser self._preferences['login'] = email self._preferences['server_name'] = serverName loginParams = { 'login': self._preferences['login'], 'session': self._preferences['session'], 'temporary': str(int(not rememberUser)), 'auth_method': authMethod } if isToken2Login: loginParams['token2'] = self._preferences['token2'] if not isSocialToken2Login: self._preferences['login_type'] = 'credentials' connectionManager.initiateConnection(loginParams, password, serverName) def initiateRelogin(self, login, token2, serverName): loginParams = { 'login': login, 'token2': token2, 'session': BigWorld.wg_cpsalt(self._preferences['session']), 'temporary': str(int(not self._preferences['remember_user'])), 'auth_method': CONNECTION_METHOD.TOKEN2 } self._preferences['server_name'] = serverName connectionManager.initiateConnection(loginParams, '', serverName) def getPreference(self, key): return self._preferences[key] def clearPreferences(self): self._preferences.clear() def clearToken2Preference(self): self._preferences['token2'] = '' def writePreferences(self): self._preferences.writeLoginInfo() @property def servers(self): return self.__servers def _onLoggedOn(self, responseData): name = responseData.get('name', 'UNKNOWN') token2 = responseData.get('token2', '') g_lobbyContext.setCredentials(name, token2) if self._preferences['remember_user']: self._preferences['name'] = name self._preferences['token2'] = token2 if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED: del self._preferences['server_name'] else: email = self._preferences['login'] serverName = self._preferences['server_name'] session = self._preferences['session'] self._preferences.clear() if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset: self._preferences['login'] = email if not AUTO_LOGIN_QUERY_ENABLED: self._preferences['server_name'] = serverName self._preferences['session'] = session self._preferences.writeLoginInfo() self.__dumpUserName(name) self._showSecurityMessage(responseData) def _showSecurityMessage(self, responseData): securityWarningType = responseData.get('security_msg') if securityWarningType is not None: securityLink = '' if not GUI_SETTINGS.isEmpty('securitySettingsURL'): securityLink = makeHtmlString( 'html_templates:lobby/system_messages', 'link', { 'text': _ms( SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS), 'linkType': 'securityLink' }) SystemMessages.pushI18nMessage( '#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink) return def writePeripheryLifetime(self): if AUTO_LOGIN_QUERY_ENABLED and connectionManager.peripheryID: self._preferences['peripheryLifetime'] = pickle.dumps( (connectionManager.peripheryID, time.time() + _PERIPHERY_DEFAULT_LIFETIME)) self._preferences.writeLoginInfo() def _getHost(self, authMethod, hostName): if hostName != AUTO_LOGIN_QUERY_URL: return hostName else: pickledData = self._preferences['peripheryLifetime'] if pickledData: try: peripheryID, expirationTimestamp = pickle.loads( pickledData) except: LOG_DEBUG( "Couldn't to read pickled periphery data. Connecting to {0}." .format(hostName)) return hostName if expirationTimestamp > time.time(): host = g_preDefinedHosts.periphery(peripheryID, False) if host is None: return hostName if authMethod != CONNECTION_METHOD.BASIC and host.urlToken: return host.urlToken return host.url return hostName def __dumpUserName(self, name): """ Dump user name to the preferences.xml (required by WGLeague's anti-cheat). See WOTD-55587. This method doesn't belong to Preferences class, so it's placed here. """ Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString( 'user', name) Settings.g_instance.save()
class MainWindow( QtGui.QMainWindow ): ## Constructeur # Le constructeur va creer la fenetre principale en y ajoutant tous les widgets necessaires au programme def __init__( self ): # Appel au constructeur de la classe mere QtGui.QMainWindow.__init__( self ) ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle( "TVDownloader" ) # Mise en place de son icone self.setWindowIcon( QtGui.QIcon( "ico/TVDownloader.png" ) ) ### # Mise en place des widgets dans la fenetre ### # Widget central qui contiendra tout self.centralWidget = QtGui.QWidget( self ) # # Barre du haut # # Layout horizontal qui contiendra les listes deroulantes self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout() # Liste deroulante pour choisir le site (plugin) self.comboBoxSite = QtGui.QComboBox( self.centralWidget ) self.horizontalLayoutBarreHaut.addWidget( self.comboBoxSite ) # Liste deroulante pour choisir une chaine du site courant self.comboBoxChaine = QtGui.QComboBox( self.centralWidget) self.horizontalLayoutBarreHaut.addWidget( self.comboBoxChaine ) # Liste deroulante pour choisir une emission de la chaine courante self.comboBoxEmission = QtGui.QComboBox( self.centralWidget ) self.horizontalLayoutBarreHaut.addWidget( self.comboBoxEmission ) # # Onglets # # Gestionnaire onglets self.tabWidget = QtGui.QTabWidget( self.centralWidget ) # Onglet Fichiers self.tabFichiers = QtGui.QSplitter( self.centralWidget ) # L'onglet Fichier contient un splitter self.tabWidget.addTab( self.tabFichiers, u"Choix des fichiers" ) # Onglet Telechargements self.tabTelechargements = QtGui.QWidget( self.centralWidget ) self.tabWidget.addTab( self.tabTelechargements, u"Téléchargements" ) # # Liste des fichiers # # Layout de grille qui contient le tableau qui liste les fichiers + boutons self.gridLayoutFichiers = QtGui.QGridLayout( self.tabFichiers ) # Tableau qui contient la liste des fichiers disponibles pour l'emission courante self.tableWidgetFichier = MyQTableWidget( self.tabFichiers ) # Il a 4 colonnes et 0 ligne (pour l'instant) self.tableWidgetFichier.setColumnCount( 3 ) self.tableWidgetFichier.setRowCount( 0 ) # On ajoute les titres self.tableWidgetFichier.setHorizontalHeaderItem( 0, self.tableWidgetFichier.creerItem( "" ) ) self.tableWidgetFichier.setHorizontalHeaderItem( 1, self.tableWidgetFichier.creerItem( "Date" ) ) self.tableWidgetFichier.setHorizontalHeaderItem( 2, self.tableWidgetFichier.creerItem( "Emission" ) ) # On l'ajoute au layout self.gridLayoutFichiers.addWidget( self.tableWidgetFichier, 0, 1, 6, 1 ) # Icones du tableWidget self.iconeFichier = QtGui.QIcon( "ico/gtk-file.svg" ) self.iconeAjoute = QtGui.QIcon( "ico/gtk-add.svg" ) self.iconeTelecharge = QtGui.QIcon( "ico/gtk-apply.svg" ) # Bouton pour ajouter tous les fichiers a la liste des telechargements self.pushButtonToutAjouter = MyQPushButton( self.tabFichiers ) self.pushButtonToutAjouter.setIcon( QtGui.QIcon( "ico/gtk-add.svg" ) ) self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements" ) self.gridLayoutFichiers.addWidget( self.pushButtonToutAjouter, 0, 0, 2, 1 ) # Bouton pour rafraichir le plugin courant self.pushButtonRafraichirPlugin = MyQPushButton( self.tabFichiers ) self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) ) self.pushButtonRafraichirPlugin.setToolTip( "Rafraichir le plugin" ) self.gridLayoutFichiers.addWidget( self.pushButtonRafraichirPlugin, 2, 0, 2, 1 ) # Bouton pour ouvrir la fenetre des preferences du plugin courant self.pushButtonPreferencesPlugin = MyQPushButton( self.tabFichiers ) self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) ) self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin" ) self.gridLayoutFichiers.addWidget( self.pushButtonPreferencesPlugin, 4, 0, 2, 1 ) # On met en place ce layout sur un widget (pour le splitter) self.widgetFichiers = QtGui.QWidget() self.widgetFichiers.setLayout( self.gridLayoutFichiers ) # # Descriptif des fichiers # # Layout de grille self.gridLayoutDescriptif = QtGui.QGridLayout() # Label pour afficher un logo self.logoFichierDefaut = QtGui.QPixmap() self.logoFichierDefaut.load( "img/gtk-dialog-question.svg" ) self.labelLogo = QtGui.QLabel( self.centralWidget ) self.labelLogo.setPixmap( self.logoFichierDefaut.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) ) self.gridLayoutDescriptif.addWidget( self.labelLogo, 0, 0, 1, 1 ) # Zone de texte pour afficher un descriptif self.plainTextEdit = QtGui.QPlainTextEdit( self.centralWidget ) self.gridLayoutDescriptif.addWidget( self.plainTextEdit, 0, 1, 1, 2 ) # On met en place ce layout sur un widget (pour le splitter) self.widgetDescriptif = QtGui.QWidget() self.widgetDescriptif.setLayout( self.gridLayoutDescriptif ) # Onrientation verticale du splitter self.tabFichiers.setOrientation( QtCore.Qt.Vertical ) # On ajoute les 2 elements au splitter (qui est notre onglet) self.tabFichiers.addWidget( self.widgetFichiers ) self.tabFichiers.addWidget( self.widgetDescriptif ) # # Liste des telechargements # # Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller self.gridLayoutTelechargement = QtGui.QGridLayout( self.tabTelechargements ) # Tableau qui contient la liste des fichiers a telecharger self.tableWidgetTelechargement = MyQTableWidget( self.tabTelechargements ) # Il a 5 colonnes et 0 ligne (pour l'instant) self.tableWidgetTelechargement.setColumnCount( 3 ) self.tableWidgetTelechargement.setRowCount( 0 ) # On ajoute le titre des 5 colonnes self.tableWidgetTelechargement.setHorizontalHeaderItem( 0, self.tableWidgetTelechargement.creerItem( "Date" ) ) self.tableWidgetTelechargement.setHorizontalHeaderItem( 1, self.tableWidgetTelechargement.creerItem( "Emission" ) ) self.tableWidgetTelechargement.setHorizontalHeaderItem( 2, self.tableWidgetTelechargement.creerItem( "Etat" ) ) # On l'ajoute au layout self.gridLayoutTelechargement.addWidget( self.tableWidgetTelechargement, 0, 1, 4, 1 ) # Bouton pour monter l'element selectionne tout en haut de la liste self.pushButtonExtremiteMonter = MyQPushButton( self.tabTelechargements ) self.pushButtonExtremiteMonter.setIcon( QtGui.QIcon( "ico/gtk-jump-to-rtl.svg" ) ) self.pushButtonExtremiteMonter.setToolTip( u"Placer l'élément sélectionné tout en haut" ) self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteMonter, 0, 0, 1, 1 ) # Bouton pour monter l'element selectionne d'un cran dans la liste self.pushButtonMonter = MyQPushButton( self.tabTelechargements ) self.pushButtonMonter.setIcon( QtGui.QIcon( "ico/gtk-go-up.svg" ) ) self.pushButtonMonter.setToolTip( u"Monter l'élément sélectionné" ) self.gridLayoutTelechargement.addWidget( self.pushButtonMonter, 1, 0, 1, 1 ) # Bouton pour descendre l'element selectionne d'un cran dans la liste self.pushButtonDescendre = MyQPushButton( self.tabTelechargements ) self.pushButtonDescendre.setIcon( QtGui.QIcon( "ico/gtk-go-down.svg" ) ) self.pushButtonDescendre.setToolTip( u"Descendre l'élément selectionné" ) self.gridLayoutTelechargement.addWidget( self.pushButtonDescendre, 2, 0, 1, 1 ) # Bouton pour descendre l'element selectionne tout en bas de la liste self.pushButtonExtremiteDescendre = MyQPushButton( self.tabTelechargements ) self.pushButtonExtremiteDescendre.setIcon( QtGui.QIcon( "ico/gtk-jump-to-ltr.svg" ) ) self.pushButtonExtremiteDescendre.setToolTip( u"Placer l'élément sélectionné tout en bas" ) self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteDescendre, 3, 0, 1, 1 ) # Bouton pour supprimer tous les elements de la liste self.pushButtonToutSupprimer = MyQPushButton( self.tabTelechargements ) self.pushButtonToutSupprimer.setIcon( QtGui.QIcon( "ico/gtk-cancel.svg" ) ) self.pushButtonToutSupprimer.setToolTip( u"Supprimer tous les téléchargements" ) self.gridLayoutTelechargement.addWidget( self.pushButtonToutSupprimer, 0, 2, 1, 1 ) # Bouton pour supprimer de la liste les telechargements termines self.pushButtonNettoyer = MyQPushButton( self.tabTelechargements ) self.pushButtonNettoyer.setIcon( QtGui.QIcon( "ico/gtk-delete-full.svg" ) ) self.pushButtonNettoyer.setToolTip( u"Supprimer les téléchargement terminés" ) self.gridLayoutTelechargement.addWidget( self.pushButtonNettoyer, 1, 2, 1, 1 ) # Bouton pour ouvrir le dossier des telechargements self.pushButtonOuvrirDossierTelechargement = MyQPushButton( self.tabTelechargements ) self.pushButtonOuvrirDossierTelechargement.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) ) self.pushButtonOuvrirDossierTelechargement.setToolTip( u"Ouvrir le dossier des téléchargements" ) self.gridLayoutTelechargement.addWidget( self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1 ) # # Barre progression de telechargement d'un fichier # self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget ) self.progressBarTelechargementFichier.setProperty( "value", 0 ) # # Barre de progression de telechargement des fichiers # self.progressBarTelechargement = QtGui.QProgressBar( self.centralWidget ) self.progressBarTelechargement.setProperty( "value", 0 ) # # Boutons du bas pour gerer ajouter/supprimer/lancer telechargements # # Layout horizontal qui contiendra les boutons self.horizontalLayoutBarreBas = QtGui.QHBoxLayout() # Bouton pour lancer les telechargements self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ), u"Lancer téléchargement", self.centralWidget ) self.horizontalLayoutBarreBas.addWidget( self.pushButtonLancer ) # Bouton pour stopper les telechargements self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-stop.svg" ), u"Stopper le téléchargement", self.centralWidget ) self.pushButtonStop.setEnabled( False ) self.horizontalLayoutBarreBas.addWidget( self.pushButtonStop ) ### # Positionnement des differents widgets/layouts sur le layout de grille ### # Layout de grille dans lequel on va placer nos widgets/layouts self.gridLayout = QtGui.QGridLayout( self.centralWidget ) # On ajoute la barre du haut self.gridLayout.addLayout( self.horizontalLayoutBarreHaut, 0, 0, 1, 3 ) # On ajoute le gestionnaire d'onglets self.gridLayout.addWidget( self.tabWidget, 1, 0, 1, 3 ) # On ajoute la barre de progression de telechargement d'un fichier self.gridLayout.addWidget( self.progressBarTelechargementFichier, 2, 0, 1, 3 ) # On ajoute la barre de progression de telechargement des fichiers self.gridLayout.addWidget( self.progressBarTelechargement, 3, 0, 1, 3 ) # On ajoute les boutons ajouter/supprimer/lancer self.gridLayout.addLayout( self.horizontalLayoutBarreBas, 4, 0, 1, 3 ) ### # Mise en place le central widget dans la fenetre ### self.setCentralWidget( self.centralWidget ) ### # Mise en place du menu ### # Menu barre self.menubar = QtGui.QMenuBar( self ) self.menubar.setGeometry( QtCore.QRect( 0, 0, 480, 25 ) ) # Menu Fichier self.menuFichier = QtGui.QMenu( "&Fichier", self.menubar ) self.menubar.addAction( self.menuFichier.menuAction() ) # Action Fichier -> Quitter self.actionQuitter = QtGui.QAction( QtGui.QIcon( "ico/gtk-quit.svg" ), "&Quitter", self ) self.actionQuitter.setIconVisibleInMenu( True ) self.menuFichier.addAction( self.actionQuitter ) # Menu Edition self.menuEdition = QtGui.QMenu( "&Edition", self.menubar ) self.menubar.addAction( self.menuEdition.menuAction() ) # Action Edition -> Mise a jour self.actionMAJ = QtGui.QAction( QtGui.QIcon( "ico/gtk-refresh.svg" ), u"&Mise à jour des plugins", self ) self.actionMAJ.setIconVisibleInMenu( True ) self.menuEdition.addAction( self.actionMAJ ) # Action Edition -> Preferences self.actionPreferences = QtGui.QAction( QtGui.QIcon( "ico/gtk-preferences.svg" ), u"&Préférences", self ) self.actionPreferences.setIconVisibleInMenu( True ) self.menuEdition.addAction( self.actionPreferences ) # Menu Aide self.menuAide = QtGui.QMenu( "&Aide", self.menubar ) self.menubar.addAction( self.menuAide.menuAction() ) # Action Aide -> A propos self.actionAPropos = QtGui.QAction( QtGui.QIcon( "ico/gtk-about.svg" ), u"À p&ropos", self ) self.actionAPropos.setIconVisibleInMenu( True ) self.menuAide.addAction( self.actionAPropos ) # Ajout du menu a l'interface self.setMenuBar( self.menubar ) ### # Signaux provenants de l'interface ### QtCore.QObject.connect( self.tableWidgetFichier, QtCore.SIGNAL( "cellClicked(int,int)" ), self.afficherInformationsFichier ) QtCore.QObject.connect( self.tableWidgetFichier, QtCore.SIGNAL( "cellDoubleClicked(int,int)" ), self.gererTelechargement ) QtCore.QObject.connect( self.pushButtonToutAjouter, QtCore.SIGNAL( "clicked()" ), self.ajouterTousLesFichiers ) QtCore.QObject.connect( self.pushButtonRafraichirPlugin, QtCore.SIGNAL( "clicked()" ), self.rafraichirPlugin ) QtCore.QObject.connect( self.tableWidgetTelechargement, QtCore.SIGNAL( "cellDoubleClicked(int,int)" ), self.supprimerTelechargement ) QtCore.QObject.connect( self.pushButtonExtremiteMonter, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = True, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonMonter, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = True, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonDescendre, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = False, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonExtremiteDescendre, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = False, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonToutSupprimer, QtCore.SIGNAL( "clicked()" ), self.supprimerTousLesTelechargements ) QtCore.QObject.connect( self.pushButtonNettoyer, QtCore.SIGNAL( "clicked()" ), self.nettoyer ) QtCore.QObject.connect( self.pushButtonLancer, QtCore.SIGNAL( "clicked()" ), self.lancerTelechargement ) QtCore.QObject.connect( self.pushButtonStop, QtCore.SIGNAL( "clicked()" ), self.stopperTelechargement ) QtCore.QObject.connect( self.actionQuitter, QtCore.SIGNAL( "triggered()" ), self.close ) ################################################ # Instanciations + initialisation de variables # ################################################ # Fenetre About self.aProposDialog = None # Fenetre des preferences du logiciel self.preferencesDialog = None # Fenetre de mise a jour des plugins self.updateManagerDialog = None # Nom plugin courant self.nomPluginCourant = "" # Liste des fichiers self.listeFichiers = [] # Liste des fichiers a telecharger self.listeFichiersATelecharger = [] # Cache des images descriptive # Clef : urlImage Valeur : image (binaire) self.cacheImage = {} # On intancie le lanceur de signaux self.signaux = Signaux() # On instancie le gestionnaire de preferences self.preferences = Preferences() # On instancie le gestionnaire de preferences des plugins self.preferencesPluginDialog = PreferencePluginDialog( self ) # On instancie le gestionnaire de download self.downloader = Downloader( self.signaux ) # On recupere l'instance de API self.api = API.getInstance() # On instancie le gestionnaire d'historique self.historique = Historique() # On instancie la fenetre d'attente self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog( self ) # On instancie le gest # # Fenetre de confirmation pour quitter le logiciel # self.quitterMessageBox = QtGui.QMessageBox( self ) self.quitterMessageBox.setWindowTitle( "Fermeture de TVDownloader" ) self.quitterMessageBox.setText( u"Voulez-vous réellement quitter TVDownloader ?" ) self.quitterMessageBox.setInformativeText( u"Votre liste de téléchargement sera perdue" ) self.quitterMessageBox.addButton( "Oui", QtGui.QMessageBox.AcceptRole ) self.quitterMessageBox.addButton( "Non", QtGui.QMessageBox.RejectRole ) ############################################################ # On connecte les signaux des instances precedements crees # ############################################################ QtCore.QObject.connect( self.pushButtonOuvrirDossierTelechargement, QtCore.SIGNAL( "clicked()" ), self.ouvrirRepertoireTelechargement ) QtCore.QObject.connect( self.comboBoxSite, QtCore.SIGNAL( "activated(QString)" ), self.listerChaines ) QtCore.QObject.connect( self.comboBoxChaine, QtCore.SIGNAL( "activated(QString)" ), self.listerEmissions ) QtCore.QObject.connect( self.comboBoxEmission, QtCore.SIGNAL( "activated(QString)" ), self.listerFichiers ) QtCore.QObject.connect( self.pushButtonPreferencesPlugin, QtCore.SIGNAL( "clicked()" ), self.ouvrirPreferencesPlugin ) QtCore.QObject.connect( self.actionPreferences, QtCore.SIGNAL( "triggered()" ), self.ouvrirPreferencesLogiciel ) QtCore.QObject.connect( self.actionMAJ, QtCore.SIGNAL( "triggered()" ), self.ouvrirFenetreMiseAJour ) QtCore.QObject.connect( self.actionAPropos, QtCore.SIGNAL( "triggered()" ), self.ouvrirFenetreAPropos ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ) , self.fenetreAttenteProgressDialog.ouvrirFenetreAttente ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finActualisation()" ) , self.fenetreAttenteProgressDialog.fermerFenetreAttente ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "actualiserListesDeroulantes()" ) , self.actualiserListesDeroulantes ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" ) , self.ajouterChaines ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeEmissions(PyQt_PyObject)" ) , self.ajouterEmissions ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" ) , self.ajouterFichiers ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "nouvelleImage(PyQt_PyObject)" ) , self.mettreEnPlaceImage ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutTelechargement(int)" ) , self.debutTelechargement ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finTelechargement(int)" ) , self.finTelechargement ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finDesTelechargements()" ) , self.activerDesactiverInterface ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "pourcentageFichier(int)" ) , self.progressBarTelechargementFichier.setValue ) ######### # Début # ######### # La fenetre prend la dimension qu'elle avait a sa fermeture taille = self.preferences.getPreference( "tailleFenetre" ) self.resize( taille[ 0 ], taille[ 1 ] ) # Si aucun plugin n'est active, on ouvre la fenetre des preferences if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ): self.ouvrirPreferencesLogiciel() # On actualise tous les plugins self.rafraichirTousLesPlugins() ## Methode qui execute les actions necessaires avant de quitter le programme def actionsAvantQuitter( self ): # On sauvegarde les options des plugins self.api.fermeture() # On sauvegarde la taille de la fenetre taille = self.size() self.preferences.setPreference( "tailleFenetre", [ taille.width(), taille.height() ] ) # On sauvegarde les options du logiciel self.preferences.sauvegarderConfiguration() # On sauvegarde l'historique self.historique.sauverHistorique() # On stoppe les telechargements self.stopperTelechargement() ######################################### # Surcharge des methodes de QMainWindow # ######################################### ## Surcharge de la methode appelee lors de la fermeture de la fenetre # Ne doit pas etre appele explicitement # @param evenement Evenement qui a provoque la fermeture def closeEvent( self, evenement ): # On affiche une fenetre pour demander la fermeture si des fichiers sont dans la liste de telechargement if( self.tableWidgetTelechargement.rowCount() > 0 ): # On affiche une fenetre qui demande si on veut quitter retour = self.quitterMessageBox.exec_() # Si on veut quitter if( retour == 0 ): # On execute les actions necessaires self.actionsAvantQuitter() # On accept la fermeture evenement.accept() else: # On refuse la fermeture evenement.ignore() else: # S'il n'y a pas de fichier # On execute les actions necessaires self.actionsAvantQuitter() # On accept la fermeture evenement.accept() ############################################## # Methodes pour remplir les menus deroulants # ############################################## ## Methode qui actualise les listes deroulantes def actualiserListesDeroulantes( self ): # On lance juste l'ajout des sites en se basant sur les plugins actifs self.ajouterSites( self.preferences.getPreference( "pluginsActifs" ) ) ## Methode qui lance le listage des chaines # @param site Nom du plugin/site pour lequel on va lister les chaines def listerChaines( self, site ): def threadListerChaines( self, nomPlugin ): self.signaux.signal( "debutActualisation", nomPlugin ) listeChaines = self.api.getPluginListeChaines( nomPlugin ) self.signaux.signal( "listeChaines", listeChaines ) self.signaux.signal( "finActualisation" ) if( site != "" ): self.nomPluginCourant = qstringToString( site ) threading.Thread( target = threadListerChaines, args = ( self, self.nomPluginCourant ) ).start() # On active (ou pas) le bouton de preference du plugin self.pushButtonPreferencesPlugin.setEnabled( self.api.getPluginListeOptions( self.nomPluginCourant ) != [] ) ## Methode qui lance le listage des emissions # @param chaine Nom de la chaine pour laquelle on va lister les emissions def listerEmissions( self, chaine ): def threadListerEmissions( self, nomPlugin, chaine ): self.signaux.signal( "debutActualisation", nomPlugin ) listeEmissions = self.api.getPluginListeEmissions( nomPlugin, chaine ) self.signaux.signal( "listeEmissions", listeEmissions ) self.signaux.signal( "finActualisation" ) if( chaine != "" ): threading.Thread( target = threadListerEmissions, args = ( self, self.nomPluginCourant, qstringToString( chaine ) ) ).start() ## Methode qui lance le listage des fichiers # @param emission Nom de l'emission pour laquelle on va lister les fichiers def listerFichiers( self, emission ): def threadListerFichiers( self, nomPlugin, emission ): self.signaux.signal( "debutActualisation", nomPlugin ) listeFichiers = self.api.getPluginListeFichiers( nomPlugin, emission ) self.signaux.signal( "listeFichiers", listeFichiers ) self.signaux.signal( "finActualisation" ) if( emission != "" ): threading.Thread( target = threadListerFichiers, args = ( self, self.nomPluginCourant, qstringToString( emission ) ) ).start() ## Methode qui met en place une liste de sites sur l'interface # @param listeSites Liste des sites a mettre en place def ajouterSites( self, listeSites ): # On efface la liste des sites self.comboBoxSite.clear() # On met en place les sites for site in listeSites: self.comboBoxSite.addItem( stringToQstring( site ) ) # On selectionne par defaut celui choisis dans les preference index = self.comboBoxSite.findText( stringToQstring( self.preferences.getPreference( "pluginParDefaut" ) ) ) if( index != -1 ): self.comboBoxSite.setCurrentIndex( index ) # On lance l'ajout des chaines self.listerChaines( self.comboBoxSite.currentText() ) ## Methode qui met en place une liste de chaines sur l'interface # @param listeChaines Liste des chaines a mettre en place def ajouterChaines( self, listeChaines ): # On trie la liste des chaines listeChaines.sort() # On efface la liste des chaines self.comboBoxChaine.clear() # On efface la liste des emissions self.comboBoxEmission.clear() # On efface la liste des fichiers self.tableWidgetFichier.toutSupprimer() # On met en place les chaines for chaine in listeChaines: self.comboBoxChaine.addItem( stringToQstring( chaine ) ) # Si on a juste une seule chaine if( self.comboBoxChaine.count() == 1 ): # On lance l'ajout des emissions self.listerEmissions( self.comboBoxChaine.currentText() ) else: # On ne selectionne pas de chaine self.comboBoxChaine.setCurrentIndex( -1 ) ## Methode qui met en place une liste d'emissions sur l'interface # @param listeEmissions Liste des emissions a mettre en place def ajouterEmissions( self, listeEmissions ): # On trie la liste des emissions listeEmissions.sort() # On efface la liste des emissions self.comboBoxEmission.clear() # On efface la liste des fichiers self.tableWidgetFichier.toutSupprimer() # On met en place la liste des emissions for emission in listeEmissions: self.comboBoxEmission.addItem( stringToQstring( emission ) ) # Si on a juste une seule emission if( self.comboBoxEmission.count() == 1 ): # On lance l'ajout des fichiers self.listerFichiers( self.comboBoxEmission.currentText() ) else: # On ne selectionne pas d'emission self.comboBoxEmission.setCurrentIndex( -1 ) ############################################### # Methodes pour remplir la liste des fichiers # ############################################### ## Methode pour ajouter des fichiers a l'interface # @param listeFichiers Liste des fichiers a ajouter def ajouterFichiers( self, listeFichiers ): self.listeFichiers = listeFichiers # On efface la liste des fichiers self.tableWidgetFichier.toutSupprimer() # On commence au depart ligneCourante = 0 # On met en place chacun des fichiers for fichier in listeFichiers: # On ajoute une ligne self.tableWidgetFichier.insertRow( ligneCourante ) # On ajoute les informations au tableWidgetFichier liste = [] liste.append( self.tableWidgetFichier.creerItem( "" ) ) liste.append( self.tableWidgetFichier.creerItem( getattr( fichier, "date" ) ) ) liste.append( self.tableWidgetFichier.creerItem( getattr( fichier, "nom" ) ) ) self.tableWidgetFichier.setLigne( ligneCourante, liste ) # On met en place l'icone qui va bien self.gererIconeListeFichier( fichier ) ligneCourante += 1 # On adapte la taille des colonnes self.tableWidgetFichier.adapterColonnes() ## Methode qui rafraichit le plugin courant def rafraichirPlugin( self ): def threadRafraichirPlugin( self, nomPlugin ): self.signaux.signal( "debutActualisation", nomPlugin ) self.api.pluginRafraichir( nomPlugin ) self.signaux.signal( "finActualisation" ) threading.Thread( target = threadRafraichirPlugin, args = ( self, self.nomPluginCourant ) ).start() ## Methode qui met en place l'image de la description d'un fichier # @param image Image a mettre en place (binaire) def mettreEnPlaceImage( self, image ): logoFichier = QtGui.QPixmap() logoFichier.loadFromData( image ) self.labelLogo.setPixmap( logoFichier.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) ) ## Methode qui affiche des informations sur le fichier selectionne def afficherInformationsFichier( self, ligne, colonne ): def threadRecupererImage( self, urlImage ): image = self.api.getPage( urlImage ) self.cacheImage[ urlImage ] = image self.signaux.signal( "nouvelleImage", image ) fichier = self.listeFichiers[ ligne ] # On recupere le lien de l'image et le texte descriptif urlImage = getattr( fichier, "urlImage" ) texteDescriptif = getattr( fichier, "descriptif" ) self.plainTextEdit.clear() # Si on a un texte descriptif, on l'affiche if( texteDescriptif != "" ): self.plainTextEdit.appendPlainText( stringToQstring( texteDescriptif ) ) else: self.plainTextEdit.appendPlainText( u"Aucune information disponible" ) # Si on n'a pas d'image if( urlImage == "" ): # On met en place celle par defaut self.logoFichier = self.logoFichierDefaut self.labelLogo.setPixmap( self.logoFichier.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) ) else: # Si on en a une # Si elle est dans le cache des images if( self.cacheImage.has_key( urlImage ) ): self.mettreEnPlaceImage( self.cacheImage[ urlImage ] ) else: # Sinon # On lance le thread pour la recuperer threading.Thread( target = threadRecupererImage, args = ( self, urlImage ) ).start() ## Methode qui gere l'icone d'un fichier dans la liste des telechargements # Il y a 3 icones possible : # - C'est un fichier # - C'est un fichier present dans l'historique (donc deja telecharge) # - C'est un fichier present dans la liste des telechargements # @param fichier Fichier a gerer def gererIconeListeFichier( self, fichier ): if( fichier in self.listeFichiers ): ligneFichier = self.listeFichiers.index( fichier ) # On cherche quel icone mettre en place if( fichier in self.listeFichiersATelecharger ): icone = self.iconeAjoute elif( self.historique.comparerHistorique( fichier ) ): icone = self.iconeTelecharge else: icone = self.iconeFichier # On met en place l'icone self.tableWidgetFichier.item( ligneFichier, 0 ).setIcon( icone ) ###################################################### # Methodes pour remplir la liste des telechargements # ###################################################### ## Methode qui gere la liste des telechargements # @param ligne Numero de la ligne (dans la liste des fichiers) de l'element a ajouter # @param colonne Numero de colonne (inutile, juste pour le slot) def gererTelechargement( self, ligne, colonne = 0 ): fichier = self.listeFichiers[ ligne ] # Si le fichier est deja dans la liste des telechargements if( fichier in self.listeFichiersATelecharger ): ligneTelechargement = self.listeFichiersATelecharger.index( fichier ) self.supprimerTelechargement( ligneTelechargement ) else: # S'il n'y est pas, on l'ajoute self.listeFichiersATelecharger.append( fichier ) numLigne = self.tableWidgetTelechargement.rowCount() # On insere une nouvelle ligne dans la liste des telechargements self.tableWidgetTelechargement.insertRow( numLigne ) # On y insere les elements qui vont biens self.tableWidgetTelechargement.setLigne( numLigne, [ self.tableWidgetTelechargement.creerItem( getattr( fichier, "date" ) ), self.tableWidgetTelechargement.creerItem( getattr( fichier, "nom" ) ), self.tableWidgetTelechargement.creerItem( u"En attente de téléchargement" ) ] ) # On adapte la taille des colonnes self.tableWidgetTelechargement.adapterColonnes() # On modifie l'icone dans la liste des fichiers self.gererIconeListeFichier( fichier ) ## Methode qui ajoute tous les fichiers a la liste des telechargements def ajouterTousLesFichiers( self ): for i in range( self.tableWidgetFichier.rowCount() ): self.gererTelechargement( i ) ## Methode qui supprime un fichier de la liste des telechargements # @param ligne Numero de la ligne a supprimer # @param colonne Numero de colonne (inutile, juste pour le slot) def supprimerTelechargement( self, ligne, colonne = 0 ): fichier = self.listeFichiersATelecharger[ ligne ] # On supprime l'element du tableWidgetTelechargement self.tableWidgetTelechargement.removeRow( ligne ) # On supprime l'element de la liste des fichiers a telecharger self.listeFichiersATelecharger.remove( fichier ) # On modifie l'icone dans la liste des fichiers self.gererIconeListeFichier( fichier ) ## Methode qui supprime tous les telechargement de la liste des telechargements def supprimerTousLesTelechargements( self ): for i in range( self.tableWidgetTelechargement.rowCount() -1, -1, -1 ): self.supprimerTelechargement( i ) ## Methode qui lance le telechargement des fichiers def lancerTelechargement( self ): # On liste les emissions a telecharger avec leurs numeros de ligne listeFichiers = [] for i in range( self.tableWidgetTelechargement.rowCount() ): # Pour chaque ligne fichier = self.listeFichiersATelecharger[ i ] listeFichiers.append( [ i, getattr( fichier, "lien" ), getattr( fichier, "nomFichierSortie" ) ] ) nbATelecharger = len( listeFichiers ) # Si on a des elements a charger if( nbATelecharger > 0 ): # On met en place la valeur du progressBar self.progressBarTelechargement.setMaximum( nbATelecharger ) self.progressBarTelechargement.setValue( 0 ) # On lance le telechargement threading.Thread( target = self.downloader.lancerTelechargement, args = ( listeFichiers, ) ).start() # On active/desactive ce qui va bien sur l'interface self.activerDesactiverInterface( True ) ## Methode qui stoppe le telechargement def stopperTelechargement( self ): # On stoppe le telechargement self.downloader.stopperTelechargement() ############################################ # Methodes pour ouvrir les autres fenetres # ############################################ # # Fenetre About # ## Methode pour afficher la fenetre About def ouvrirFenetreAPropos( self ): if( self.aProposDialog == None ): self.aProposDialog = AProposDialog() self.aProposDialog.show() # # Fenetre de preference du logiciel # ## Methode pour ouvrir les preferences du logiciel def ouvrirPreferencesLogiciel( self ): if( self.preferencesDialog == None ): self.preferencesDialog = PreferencesDialog( self, self.signaux ) self.preferencesDialog.afficher() # # Fenetre de mise a jour des plugins # ## Methode pour ouvrir la fenetre de mise a jour des plugins def ouvrirFenetreMiseAJour( self ): if( self.updateManagerDialog == None ): self.updateManagerDialog = UpdateManagerDialog( self ) self.updateManagerDialog.afficher() # # Fenetre de preference des plugins # ## Methode pour ouvrir les preferences du plugin courant def ouvrirPreferencesPlugin( self ): listeOptions = self.api.getPluginListeOptions( self.nomPluginCourant ) self.preferencesPluginDialog.ouvrirDialogPreferences( self.nomPluginCourant, listeOptions ) ######### # Slots # ######### ## Methode qui ouvre le repertoire de telechargement def ouvrirRepertoireTelechargement( self ): QtGui.QDesktopServices.openUrl( QtCore.QUrl.fromLocalFile( self.preferences.getPreference( "repertoireTelechargement" ) ) ) ## Methode qui rafraichit le plugin courant def rafraichirPlugin( self ): def threadRafraichirPlugin( self, nomPlugin ): self.signaux.signal( "debutActualisation", nomPlugin ) self.api.pluginRafraichir( nomPlugin ) self.signaux.signal( "finActualisation" ) threading.Thread( target = threadRafraichirPlugin, args = ( self, self.nomPluginCourant ) ).start() ## Methode qui rafraichit tous les plugins # A utiliser au lancement du programme def rafraichirTousLesPlugins( self ): def threadRafraichirTousLesPlugins( self ): self.signaux.signal( "debutActualisation", "TVDownloader" ) self.api.pluginRafraichirAuto() self.signaux.signal( "finActualisation" ) self.signaux.signal( "actualiserListesDeroulantes" ) threading.Thread( target = threadRafraichirTousLesPlugins, args = ( self, ) ).start() ## Slot qui active/desactive des elements de l'interface pendant un telechargement # @param telechargementEnCours Indique si on telecharge ou pas def activerDesactiverInterface( self, telechargementEnCours = False ): # Les boutons self.pushButtonLancer.setEnabled( not telechargementEnCours ) self.pushButtonStop.setEnabled( telechargementEnCours ) self.pushButtonExtremiteMonter.setEnabled( not telechargementEnCours ) self.pushButtonMonter.setEnabled( not telechargementEnCours ) self.pushButtonDescendre.setEnabled( not telechargementEnCours ) self.pushButtonExtremiteDescendre.setEnabled( not telechargementEnCours ) self.pushButtonToutSupprimer.setEnabled( not telechargementEnCours ) self.pushButtonNettoyer.setEnabled( not telechargementEnCours ) # Le table widget self.tableWidgetTelechargement.setEnabled( not telechargementEnCours ) ## Slot appele lors ce qu'un le debut d'un telechargement commence # @param numero Position dans la liste des telechargement du telechargement qui commence def debutTelechargement( self, numero ): self.tableWidgetTelechargement.item( numero, 2 ).setText( stringToQstring( u"Téléchargement en cours..." ) ) self.tableWidgetTelechargement.adapterColonnes() self.progressBarTelechargementFichier.setValue( 0 ) ## Slot appele lorsqu'un telechargement se finit # @param numero Position dans la liste des telechargement du telechargement qui se finit def finTelechargement( self, numero ): fichier = self.listeFichiersATelecharger[ numero ] # On ajoute le fichier a l'historique self.historique.ajouterHistorique( fichier ) # On modifie l'icone dans la liste des fichiers self.gererIconeListeFichier( fichier ) # On modifie l'interface self.tableWidgetTelechargement.item( numero, 2 ).setText( stringToQstring( u"Fini !" ) ) self.progressBarTelechargement.setValue( self.progressBarTelechargement.value() + 1 ) self.tableWidgetTelechargement.adapterColonnes() self.progressBarTelechargementFichier.setValue( 100 ) ## Slot qui nettoie la liste des telechargements de tous les telechargements finis def nettoyer( self ): for i in range( self.tableWidgetTelechargement.rowCount() - 1, -1, -1 ): # [ nbLignes - 1, nbLignes - 2, ..., 1, 0 ] if( self.tableWidgetTelechargement.item( i, 2 ).text() == u"Fini !" ): # Si c'est telecharge self.supprimerTelechargement( i )
def setUp( self ): self.preferences = Preferences()
def __init__(self): #declaration des variables global choice, temp, plugins, chaines, programs, fichiers, DLlist chaines = '' programs = '' fichiers = '' temp = 0 choice = "" selectedPlugin = '' selectedChaine = '' selectedProgram = '' DLlist = [] ################################################ # Instanciations + initialisation de variables # ################################################ # On instancie le plugin manager self.pluginManager = PluginManager() # On instancie le gestionnaire de preferences self.preferences = Preferences() # On instancie le gestionnaire de download self.downloader = Downloader() # On recupere l'instance de API self.api = API.getInstance() # # On instancie le gestionnaire d'historique # self.historique = Historique() # Si aucun plugin n'est active, on ouvre la fenetre des preferences if (len(self.preferences.getPreference("pluginsActifs")) == 0): choice = 'p' self.api.pluginRafraichirAuto() # On met en place la liste des plugins dans API plugins = self.preferences.getPreference("pluginsActifs") plugins.sort() # On actualise tous les plugins self.api.pluginRafraichirAuto() #boucle qui raffraichit l'affichage apres chaque interaction utilisateur while choice != 'exit': #ouverture du menu de preferences if choice == 'p' or choice == 'P': prefs() # On met en place la liste des plugins dans API plugins = self.preferences.getPreference("pluginsActifs") plugins.sort() # On actualise tous les plugins self.api.pluginRafraichirAuto() #ouverture du menu de telechargement elif choice == 't' or choice == 'T': dl(DLlist) #ouverture de l'invite de fermeture elif choice == 'q' or choice == 'Q': quitter() #actualisation de l'affichage ecran elif choice == 'i' or choice == 'I': info() #actualisation de l'affichage ecran elif choice == 'a' or choice == 'A': header(selectedPlugin, selectedChaine, selectedProgram) print "\n\n\n\n\t\tRafraichissement\n\n\n" self.api.pluginRafraichirAuto() #recharger les listes if len(selectedProgram) != 0: fichiers = self.api.getPluginListeFichiers( selectedPlugin, selectedProgram) elif len(selectedChaine) != 0: programs = self.api.getPluginListeEmissions( selectedPlugin, selectedChaine) elif len(selectedPlugin) != 0: chaines = self.api.getPluginListeChaines(selectedPlugin) elif len(selectedPlugin) == 0 and len( selectedChaine) == 0 and len(selectedProgram) == 0: plugins = self.preferences.getPreference("pluginsActifs") plugins.sort() #mise a jour de l'affichage header(selectedPlugin, selectedChaine, selectedProgram) print "\n\n\n\n\t\tVeuillez patientez pendant la mise a jour des informations\n\n\n" time.sleep(1) show(selectedPlugin, selectedChaine, selectedProgram, temp) elif choice == 'r' or choice == 'R': temp = 0 if len(selectedProgram) != 0: selectedProgram = "" elif len(selectedChaine) != 0: selectedChaine = "" if len(chaines) == 1: selectedPlugin = "" elif len(selectedPlugin) != 0: selectedPlugin = "" elif choice.isdigit() and int(choice) >= 0: choice = 10 * temp + int(choice) if len(selectedPlugin) == 0 and len(plugins) > choice: temp = 0 selectedPlugin = plugins[choice] chaines = self.api.getPluginListeChaines(selectedPlugin) if len(chaines) == 1: header(selectedPlugin, '', '') print "Une seule chaine :", chaines time.sleep(0.5) selectedChaine = chaines[0] programs = self.api.getPluginListeEmissions( selectedPlugin, selectedChaine) elif len(selectedChaine) == 0 and len(chaines) > choice: temp = 0 selectedChaine = chaines[choice] programs = self.api.getPluginListeEmissions( selectedPlugin, selectedChaine) elif len(selectedProgram) == 0 and len(programs) > choice: selectedProgram = programs[choice] header(selectedPlugin, selectedChaine, selectedProgram) print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n" fichiers = self.api.getPluginListeFichiers( selectedPlugin, selectedProgram) if len(fichiers) == 0: header(selectedPlugin, selectedChaine, selectedProgram) print "\n\n\n\n\n\n\n\t\tAucun fichier dans le programme :", selectedProgram time.sleep(1) selectedProgram = '' else: temp = 0 elif len(selectedPlugin) != 0 and len( selectedChaine) != 0 and len( selectedProgram) != 0 and len(fichiers) > choice: header(selectedPlugin, selectedChaine, selectedProgram) if fichiers[choice] not in DLlist: print "\n\n\n\n\n\n\najout", fichiers[ choice].nom, "a la liste de telechargement\n\n\n\n\n\n\n\n\n" DLlist.append(fichiers[choice]) else: print "\n\n\n\n\n\n\n\t\tFichier deja dans la liste de telechargement\n\n\n\n\n\n\n\n\n" time.sleep(1) os.system(['clear', 'cls'][os.name == 'nt']) elif choice == '*': # if len(selectedPlugin)==0: # temp=0 # selectedPlugin = 'None' # chaines = self.api.getPluginListeChaines() # elif len(selectedChaine)==0: # temp=0 # selectedChaine='None' # programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine) # el if len(selectedProgram) == 0: selectedProgram = 'Tous' header(selectedPlugin, selectedChaine, selectedProgram) print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n" # for choice in range(len(programs)) : fichiers = self.api.getPluginListeFichiers( selectedPlugin, None) #programs[choice]) elif len(selectedPlugin) != 0 and len( selectedChaine) != 0 and len(selectedProgram) != 0: header(selectedPlugin, selectedChaine, selectedProgram) for choice in range(len(fichiers)): if fichiers[int(choice)] not in DLlist: header(selectedPlugin, selectedChaine, selectedProgram) print "\n\n\n\n\t\tajout", fichiers[int( choice)].nom, "a la liste de telechargement" DLlist.append(fichiers[int(choice)]) else: print "\t\tFichier deja dans la liste de telechargement" time.sleep(0.5) #afficher la suite de la liste elif choice == '+': if len(selectedPlugin) == 0: if len(plugins) > temp * 10 + 10: temp += 1 elif len(selectedChaine) == 0: if len(chaines) > temp * 10 + 10: temp += 1 elif len(selectedProgram) == 0: if len(programs) > temp * 10 + 10: temp += 1 elif len(selectedPlugin) != 0 and len( selectedChaine) != 0 and len(selectedProgram) != 0: if len(fichiers) > temp * 10 + 10: temp += 1 #afficher le debut de la liste elif choice == '-': if temp != 0: temp -= 1 show(selectedPlugin, selectedChaine, selectedProgram, temp) choice = '' # if not choice:choice=raw_input("\n\t\tEntrez votre choix : ") if not choice: choice = getch()
def __init__( self, signaux = None ): self.preferences = Preferences() self.signaux = signaux self.arreter = True self.process = None
# CPU Temp Import from gpiozero import CPUTemperature # Read preferences from files from Preferences import Preferences preferences = Preferences() # Gets the list of all possible information values to see on the webpage # Format: DisplayName, Value, DisplayType, Parameters # DisplayType Parameters: # loadingBar: minValue, maxValue, displayUnits # text: none def getInfo(): params = [] # Add CPU Temperature params.append( ['CPU Temperature', get_CPU_temp(), 'loadingBar', 0, 87, '°C']) # Add preferences from Setup File for key, value in preferences.get_debug_preferences().items(): params.append([key, value, 'text']) return params # Gets the Pi's CPU temp to send to the client def get_CPU_temp(): cpu = CPUTemperature()
def __init__( self, parent ): # Appel au constructeur de la classe mere QtGui.QDialog.__init__( self, parent ) self.preferences = Preferences() self.pluginManager = PluginManager() ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle( u"Préférences" ) # Dimensions la fenetre self.resize( 325, 510 ) # Mise en place de son icone self.setWindowIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) ) ### # Mise en place des widgets dans la fenetre ### # Layout du dialog (il ne contiendra que la scroll area) self.layoutPrincipal = QtGui.QVBoxLayout( self ) # Scroll Area (elle ne contiendra que le widget central) self.scrollArea = QtGui.QScrollArea( self ) self.layoutPrincipal.addWidget( self.scrollArea ) # Widget central self.widgetCentral = QtGui.QWidget( self.scrollArea ) # Layout de grillequi contient les elements self.gridLayout = QtGui.QGridLayout( self.widgetCentral ) # Font pour les titres fontTitres = QtGui.QFont() fontTitres.setPointSize( 11 ) fontTitres.setWeight( 75 ) fontTitres.setBold( True ) # # Choix du repertoire telechargement # # Label self.labelRepertoire = QtGui.QLabel( self ) self.labelRepertoire.setFont( fontTitres ) self.labelRepertoire.setText( u"Répertoire de téléchargement :" ) # Repertoire de telechargement self.lineEditRepertoireTelechargement = QtGui.QLineEdit( self ) # Bouton pour ouvrir la fenetre de selection de repertoire self.pushButtonSelectionDossier = QtGui.QPushButton( self ) self.pushButtonSelectionDossier.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) ) # # Choix du plugin par defaut # # Label self.labelPluginDefaut = QtGui.QLabel( self ) self.labelPluginDefaut.setFont( fontTitres ) self.labelPluginDefaut.setText( u"Plugin par défaut :" ) # Liste de choix du plugin par defaut self.comboBoxPluginDefaut = QtGui.QComboBox( self ) # # Choix des plugins a activer # # Label self.labelPlugins = QtGui.QLabel( self ) self.labelPlugins.setFont( fontTitres ) self.labelPlugins.setText( "Plugins actifs :" ) # Liste des plugins self.listWidgetPlugin = QtGui.QListWidget( self ) # # Choix des parametres Internet # # Label self.labelInternet = QtGui.QLabel( self ) self.labelInternet.setFont( fontTitres ) self.labelInternet.setText( u"Paramètres Internet :" ) # Layout formulaire self.layoutInternet = QtGui.QFormLayout() # SpinBox pour choisir le timeOut self.spinBoxTimeOut = QtGui.QSpinBox() self.spinBoxTimeOut.setMinimum( 1 ) self.spinBoxTimeOut.setMaximum( 60 ) self.layoutInternet.addRow( u"Time out (en s) :", self.spinBoxTimeOut ) # SpinBox pour choisir le nombre de threads max self.spinBoxNbThread = QtGui.QSpinBox() self.spinBoxNbThread.setMinimum( 1 ) self.spinBoxNbThread.setMaximum( 100 ) self.layoutInternet.addRow( u"Nombre de threads max :", self.spinBoxNbThread ) # Bouton pour enregistrer/annuler les preferences self.buttonBox = QtGui.QDialogButtonBox( self ) self.buttonBox.addButton( "Enregistrer", QtGui.QDialogButtonBox.AcceptRole ) self.buttonBox.addButton( "Fermer", QtGui.QDialogButtonBox.RejectRole ) # On ajoute le tout au layout self.gridLayout.addWidget( self.labelRepertoire, 0, 0, 1, 2 ) self.gridLayout.addWidget( self.lineEditRepertoireTelechargement, 1, 0, 1, 1 ) self.gridLayout.addWidget( self.pushButtonSelectionDossier, 1, 1, 1, 1 ) self.gridLayout.addWidget( self.labelPluginDefaut, 2, 0, 1, 2 ) self.gridLayout.addWidget( self.comboBoxPluginDefaut, 3, 0, 1, 2 ) self.gridLayout.addWidget( self.labelPlugins, 4, 0, 1, 2 ) self.gridLayout.addWidget( self.listWidgetPlugin, 5, 0, 1, 2 ) self.gridLayout.addWidget( self.labelInternet, 6, 0, 1, 2 ) self.gridLayout.addLayout( self.layoutInternet, 7, 0, 1, 2 ) # Les boutons sont ajoutes au layout principal self.layoutPrincipal.addWidget( self.buttonBox ) # On adapte la taille du widget self.widgetCentral.adjustSize() # On ajoute le widget central a la scroll area self.scrollArea.setWidget( self.widgetCentral ) ### # Signaux provenants de l'interface ### QtCore.QObject.connect( self.pushButtonSelectionDossier, QtCore.SIGNAL( "clicked()" ), self.afficherSelecteurDossier ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "accepted()" ), self.enregistrerPreferences ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "rejected()" ), self.reject )
def __init__(self): #declaration des variables global choice, temp, plugins, chaines, programs, fichiers, DLlist chaines='' programs='' fichiers='' temp = 0 choice = "" selectedPlugin ='' selectedChaine ='' selectedProgram = '' DLlist=[] ################################################ # Instanciations + initialisation de variables # ################################################ # On instancie le plugin manager self.pluginManager = PluginManager() # On instancie le gestionnaire de preferences self.preferences = Preferences() # On instancie le gestionnaire de download self.downloader = Downloader() # On recupere l'instance de API self.api = API.getInstance() # # On instancie le gestionnaire d'historique # self.historique = Historique() # Si aucun plugin n'est active, on ouvre la fenetre des preferences if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ): choice = 'p' self.api.pluginRafraichirAuto() # On met en place la liste des plugins dans API plugins = self.preferences.getPreference( "pluginsActifs" ) plugins.sort() # On actualise tous les plugins self.api.pluginRafraichirAuto() #boucle qui raffraichit l'affichage apres chaque interaction utilisateur while choice != 'exit': #ouverture du menu de preferences if choice == 'p' or choice == 'P': prefs() # On met en place la liste des plugins dans API plugins = self.preferences.getPreference( "pluginsActifs" ) plugins.sort() # On actualise tous les plugins self.api.pluginRafraichirAuto() #ouverture du menu de telechargement elif choice == 't' or choice == 'T': dl(DLlist) #ouverture de l'invite de fermeture elif choice == 'q' or choice == 'Q': quitter() #actualisation de l'affichage ecran elif choice == 'i' or choice == 'I': info() #actualisation de l'affichage ecran elif choice == 'a' or choice == 'A': header(selectedPlugin,selectedChaine,selectedProgram) print "\n\n\n\n\t\tRafraichissement\n\n\n" self.api.pluginRafraichirAuto() #recharger les listes if len(selectedProgram)!=0: fichiers = self.api.getPluginListeFichiers(selectedPlugin,selectedProgram) elif len(selectedChaine)!=0: programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine) elif len(selectedPlugin)!=0: chaines = self.api.getPluginListeChaines(selectedPlugin) elif len(selectedPlugin)==0 and len(selectedChaine)==0 and len(selectedProgram)==0: plugins = self.preferences.getPreference( "pluginsActifs" ) plugins.sort() #mise a jour de l'affichage header(selectedPlugin,selectedChaine,selectedProgram) print "\n\n\n\n\t\tVeuillez patientez pendant la mise a jour des informations\n\n\n" time.sleep(1) show(selectedPlugin,selectedChaine,selectedProgram,temp) elif choice == 'r' or choice == 'R': temp=0 if len(selectedProgram)!=0: selectedProgram="" elif len(selectedChaine)!=0: selectedChaine="" if len(chaines)==1: selectedPlugin="" elif len(selectedPlugin)!=0: selectedPlugin="" elif choice.isdigit() and int(choice)>=0: choice=10*temp+int(choice) if len(selectedPlugin)==0 and len(plugins)>choice: temp=0 selectedPlugin = plugins[choice] chaines = self.api.getPluginListeChaines(selectedPlugin) if len(chaines)==1: header(selectedPlugin,'','') print "Une seule chaine :",chaines time.sleep (0.5) selectedChaine=chaines[0] programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine) elif len(selectedChaine)==0 and len(chaines)>choice: temp=0 selectedChaine=chaines[choice] programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine) elif len(selectedProgram)==0 and len(programs)>choice: selectedProgram=programs[choice] header(selectedPlugin,selectedChaine,selectedProgram) print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n" fichiers = self.api.getPluginListeFichiers(selectedPlugin,selectedProgram) if len(fichiers)==0: header (selectedPlugin,selectedChaine,selectedProgram) print "\n\n\n\n\n\n\n\t\tAucun fichier dans le programme :",selectedProgram time.sleep (1) selectedProgram='' else:temp=0 elif len(selectedPlugin)!=0 and len(selectedChaine)!=0 and len(selectedProgram)!=0 and len(fichiers)>choice: header(selectedPlugin,selectedChaine,selectedProgram) if fichiers[choice] not in DLlist: print "\n\n\n\n\n\n\najout",fichiers[choice].nom,"a la liste de telechargement\n\n\n\n\n\n\n\n\n" DLlist.append(fichiers[choice]) else: print "\n\n\n\n\n\n\n\t\tFichier deja dans la liste de telechargement\n\n\n\n\n\n\n\n\n" time.sleep(1) os.system(['clear','cls'][os.name == 'nt']) elif choice=='*': # if len(selectedPlugin)==0: # temp=0 # selectedPlugin = 'None' # chaines = self.api.getPluginListeChaines() # elif len(selectedChaine)==0: # temp=0 # selectedChaine='None' # programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine) # el if len(selectedProgram)==0: selectedProgram='Tous' header(selectedPlugin,selectedChaine,selectedProgram) print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n" # for choice in range(len(programs)) : fichiers = self.api.getPluginListeFichiers(selectedPlugin,None)#programs[choice]) elif len(selectedPlugin)!=0 and len(selectedChaine)!=0 and len(selectedProgram)!=0: header(selectedPlugin,selectedChaine,selectedProgram) for choice in range(len(fichiers)) : if fichiers[int(choice)] not in DLlist: header(selectedPlugin,selectedChaine,selectedProgram) print "\n\n\n\n\t\tajout",fichiers[int(choice)].nom,"a la liste de telechargement" DLlist.append(fichiers[int(choice)]) else: print "\t\tFichier deja dans la liste de telechargement" time.sleep(0.5) #afficher la suite de la liste elif choice=='+': if len(selectedPlugin) == 0: if len(plugins)>temp*10+10: temp+=1 elif len(selectedChaine) == 0: if len(chaines)>temp*10+10: temp+=1 elif len(selectedProgram) == 0: if len(programs)>temp*10+10: temp+=1 elif len(selectedPlugin) != 0 and len(selectedChaine) != 0 and len(selectedProgram) != 0: if len(fichiers)>temp*10+10: temp+=1 #afficher le debut de la liste elif choice=='-': if temp!=0: temp-=1 show(selectedPlugin,selectedChaine,selectedProgram,temp) choice='' # if not choice:choice=raw_input("\n\t\tEntrez votre choix : ") if not choice:choice=getch()
class PreferencesDialog( QtGui.QDialog ): ## Constructeur def __init__( self, parent ): # Appel au constructeur de la classe mere QtGui.QDialog.__init__( self, parent ) self.preferences = Preferences() self.pluginManager = PluginManager() ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle( u"Préférences" ) # Dimensions la fenetre self.resize( 325, 510 ) # Mise en place de son icone self.setWindowIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) ) ### # Mise en place des widgets dans la fenetre ### # Layout du dialog (il ne contiendra que la scroll area) self.layoutPrincipal = QtGui.QVBoxLayout( self ) # Scroll Area (elle ne contiendra que le widget central) self.scrollArea = QtGui.QScrollArea( self ) self.layoutPrincipal.addWidget( self.scrollArea ) # Widget central self.widgetCentral = QtGui.QWidget( self.scrollArea ) # Layout de grillequi contient les elements self.gridLayout = QtGui.QGridLayout( self.widgetCentral ) # Font pour les titres fontTitres = QtGui.QFont() fontTitres.setPointSize( 11 ) fontTitres.setWeight( 75 ) fontTitres.setBold( True ) # # Choix du repertoire telechargement # # Label self.labelRepertoire = QtGui.QLabel( self ) self.labelRepertoire.setFont( fontTitres ) self.labelRepertoire.setText( u"Répertoire de téléchargement :" ) # Repertoire de telechargement self.lineEditRepertoireTelechargement = QtGui.QLineEdit( self ) # Bouton pour ouvrir la fenetre de selection de repertoire self.pushButtonSelectionDossier = QtGui.QPushButton( self ) self.pushButtonSelectionDossier.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) ) # # Choix du plugin par defaut # # Label self.labelPluginDefaut = QtGui.QLabel( self ) self.labelPluginDefaut.setFont( fontTitres ) self.labelPluginDefaut.setText( u"Plugin par défaut :" ) # Liste de choix du plugin par defaut self.comboBoxPluginDefaut = QtGui.QComboBox( self ) # # Choix des plugins a activer # # Label self.labelPlugins = QtGui.QLabel( self ) self.labelPlugins.setFont( fontTitres ) self.labelPlugins.setText( "Plugins actifs :" ) # Liste des plugins self.listWidgetPlugin = QtGui.QListWidget( self ) # # Choix des parametres Internet # # Label self.labelInternet = QtGui.QLabel( self ) self.labelInternet.setFont( fontTitres ) self.labelInternet.setText( u"Paramètres Internet :" ) # Layout formulaire self.layoutInternet = QtGui.QFormLayout() # SpinBox pour choisir le timeOut self.spinBoxTimeOut = QtGui.QSpinBox() self.spinBoxTimeOut.setMinimum( 1 ) self.spinBoxTimeOut.setMaximum( 60 ) self.layoutInternet.addRow( u"Time out (en s) :", self.spinBoxTimeOut ) # SpinBox pour choisir le nombre de threads max self.spinBoxNbThread = QtGui.QSpinBox() self.spinBoxNbThread.setMinimum( 1 ) self.spinBoxNbThread.setMaximum( 100 ) self.layoutInternet.addRow( u"Nombre de threads max :", self.spinBoxNbThread ) # Bouton pour enregistrer/annuler les preferences self.buttonBox = QtGui.QDialogButtonBox( self ) self.buttonBox.addButton( "Enregistrer", QtGui.QDialogButtonBox.AcceptRole ) self.buttonBox.addButton( "Fermer", QtGui.QDialogButtonBox.RejectRole ) # On ajoute le tout au layout self.gridLayout.addWidget( self.labelRepertoire, 0, 0, 1, 2 ) self.gridLayout.addWidget( self.lineEditRepertoireTelechargement, 1, 0, 1, 1 ) self.gridLayout.addWidget( self.pushButtonSelectionDossier, 1, 1, 1, 1 ) self.gridLayout.addWidget( self.labelPluginDefaut, 2, 0, 1, 2 ) self.gridLayout.addWidget( self.comboBoxPluginDefaut, 3, 0, 1, 2 ) self.gridLayout.addWidget( self.labelPlugins, 4, 0, 1, 2 ) self.gridLayout.addWidget( self.listWidgetPlugin, 5, 0, 1, 2 ) self.gridLayout.addWidget( self.labelInternet, 6, 0, 1, 2 ) self.gridLayout.addLayout( self.layoutInternet, 7, 0, 1, 2 ) # Les boutons sont ajoutes au layout principal self.layoutPrincipal.addWidget( self.buttonBox ) # On adapte la taille du widget self.widgetCentral.adjustSize() # On ajoute le widget central a la scroll area self.scrollArea.setWidget( self.widgetCentral ) ### # Signaux provenants de l'interface ### QtCore.QObject.connect( self.pushButtonSelectionDossier, QtCore.SIGNAL( "clicked()" ), self.afficherSelecteurDossier ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "accepted()" ), self.enregistrerPreferences ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "rejected()" ), self.reject ) ## Methode pour afficher la fenetre des preferences def afficher( self ): # On met en place dans le textEdit le repertoire self.lineEditRepertoireTelechargement.setText( stringToQstring( self.preferences.getPreference( "repertoireTelechargement" ) ) ) # On met en place le plugin par defaut self.remplirPluginParDefaut() # On met en place la liste des plugins self.afficherPlugins() # On met en place les valeurs des SpinBox self.spinBoxTimeOut.setValue( self.preferences.getPreference( "timeOut" ) ) self.spinBoxNbThread.setValue( self.preferences.getPreference( "nbThreadMax" ) ) # On affiche la fenetre self.exec_() ## Methode pour enregistrer les preferences du logiciel def enregistrerPreferences( self ): # On sauvegarde les valeurs des SpinBox self.preferences.setPreference( "nbThreadMax", self.spinBoxNbThread.value() ) self.preferences.setPreference( "timeOut", self.spinBoxTimeOut.value() ) # On sauvegarde les plugins actifs self.sauvegarderPlugins() # On sauvegarde le plugin par defaut self.preferences.setPreference( "pluginParDefaut", qstringToString( self.comboBoxPluginDefaut.currentText() ) ) # On sauvegarde le repertoire de telechargement self.preferences.setPreference( "repertoireTelechargement", qstringToString( self.lineEditRepertoireTelechargement.text() ) ) # On sauvegarde dans le fichier self.preferences.sauvegarderConfiguration() # On masque la fenetre self.hide() #################################################################### # Methodes qui gerent l'emplacement de telechargement des fichiers # #################################################################### ## Methode qui affiche le selecteur de dossier def afficherSelecteurDossier( self ): rep = QtGui.QFileDialog.getExistingDirectory( None, u"Sélectionnez le répertoire de téléchargement", self.lineEditRepertoireTelechargement.text(), QtGui.QFileDialog.ShowDirsOnly ) # Si le repertoire existe if( os.path.isdir( qstringToString( rep ) ) ): self.lineEditRepertoireTelechargement.setText( rep ) # On modifie la zone de texte qui affiche le repertoire ################################################ # Methodes qui gerent la partie plugins actifs # ################################################ ## Methode qui liste les plugins actif dans le listWidgetPlugin def afficherPlugins( self ): # On recupere les listes de plugins listePluginsDisponibles = self.pluginManager.getListeSites() listePluginsDisponibles.sort() # On trie cette liste listePluginsActives = self.preferences.getPreference( "pluginsActifs" ) # On remet a 0 le listWidget self.listWidgetPlugin.clear() # On affiche les plugins for plugin in listePluginsDisponibles: # On met en place l'item self.listWidgetPlugin.addItem( self.creerItem( plugin, plugin in listePluginsActives ) ) ## Methode qui remplie la combo box du plugin par defaut def remplirPluginParDefaut( self ): # On efface la liste self.comboBoxPluginDefaut.clear() # On ajoute les plugins actifs for plugin in self.preferences.getPreference( "pluginsActifs" ): self.comboBoxPluginDefaut.addItem( stringToQstring( plugin ) ) # On selectionne le plugin par defaut index = self.comboBoxPluginDefaut.findText( stringToQstring( self.preferences.getPreference( "pluginParDefaut" ) ) ) if( index != -1 ): self.comboBoxPluginDefaut.setCurrentIndex( index ) ## Methode qui sauvegarde les plugins actifs def sauvegarderPlugins( self ): # On liste les plugins actifs liste = [] for i in range( self.listWidgetPlugin.count() ): # Pour chaque ligne if( self.listWidgetPlugin.item( i ).checkState() == QtCore.Qt.Checked ): # Si elle est selectionnee liste.append( qstringToString( self.listWidgetPlugin.item( i ).text() ) ) # On met cela en place dans les preferences self.preferences.setPreference( "pluginsActifs", liste ) # On relance l'actualisation de l'affichage self.emit( QtCore.SIGNAL( "actualiserListesDeroulantes()" ) ) #################### # Autres methodes # #################### ## Methode qui creer une element pour un listeWidget # @param texte Texte de l'element # @param checkBox Si la checkBox de l'element est cochee ou non # @return L'element cree def creerItem( self, texte, checkBox = False ): # On cree l'item avec le texte item = QtGui.QListWidgetItem( stringToQstring( texte ) ) # On centre le texte item.setTextAlignment( QtCore.Qt.AlignCenter ) # L'item ne doit pas etre modifiable item.setFlags( item.flags() & ~QtCore.Qt.ItemIsEditable ) # L'item doit avoir sa checkBox cochee ? if( checkBox ): item.setCheckState( QtCore.Qt.Checked ) else: item.setCheckState( QtCore.Qt.Unchecked ) # On renvoie l'item return item
def __init__(self, preferences: Preferences): """ Create data model from given preferences object. This also lists all the fetch/settable values :param preferences: Program preferences to establish model's default values """ self._master_combine_method: int = preferences.get_master_combine_method( ) self._min_max_number_clipped_per_end: int = preferences.get_min_max_number_clipped_per_end( ) self._sigma_clip_threshold: float = preferences.get_sigma_clip_threshold( ) self._input_file_disposition: int = preferences.get_input_file_disposition( ) self._disposition_subfolder_name: str = preferences.get_disposition_subfolder_name( ) self._precalibration_type: int = preferences.get_precalibration_type() self._precalibration_pedestal: int = preferences.get_precalibration_pedestal( ) self._precalibration_fixed_path: str = preferences.get_precalibration_fixed_path( ) self._precalibration_auto_directory: str = preferences.get_precalibration_auto_directory( ) self._auto_directory_recursive: bool = preferences.get_auto_directory_recursive( ) self._auto_directory_bias_only: bool = preferences.get_auto_directory_bias_only( ) self._group_by_size: bool = preferences.get_group_by_size() self._group_by_temperature: bool = preferences.get_group_by_temperature( ) self._group_by_filter: bool = preferences.get_group_by_filter() self._temperature_group_bandwidth: float = preferences.get_temperature_group_bandwidth( ) self._ignore_file_type: bool = False self._ignore_groups_fewer_than: bool = preferences.get_ignore_groups_fewer_than( ) self._minimum_group_size: int = preferences.get_minimum_group_size() self._display_average_adus: bool = preferences.get_display_average_adus( ) self._display_auto_select_results: bool = preferences.get_display_auto_select_results( )
class CLIDialog(): ## Constructeur def __init__(self): # On cree l'instance de la classe dialog self.dialog = Dialog() self.dialog.setBackgroundTitle("TVDownloader") # On recupere l'instance de API self.api = API.getInstance() # On instancie le gestionnaire de download self.downloader = Downloader() # On instancie le gestionnaire d'historique self.historique = Historique() # On instancie le gestionnaire de preferences self.preferences = Preferences() # Liste des telechargements self.listeTelechargements = [] # Quand le programme se termine, on execute la fonction actionsAvantQuitter atexit.register(self.actionsAvantQuitter) # On commence self.bouclePrincipale() ## Debut def bouclePrincipale(self): choix = (1, "") while (choix != (0, "Quitter")): # On affiche le menu principal choix = self.dialog.menu( text="Menu Principal", choices=[ ["Commencer", "Afficher la liste des plugins"], ["Téléchargements", "Gérer les téléchargements"], ["Préférences", "Modifier les préférences"], ["Quitter", "Quitter TVDownloader"], ]) # On lance la methode qui va bien if (choix == (0, "Commencer")): self.utilisationPlugins() elif (choix == (0, "Téléchargements")): self.utlisationTelechargements() elif (choix == (0, "Préférences")): pass elif (choix == (0, "Quitter")): # Rien a faire, atexit gere cela pass ## Methode pour selectionner les fichiers a telecharger avec les plugins def utilisationPlugins(self): # Liste des plugins actifs listePlugins = [] for nomPlugin in self.preferences.getPreference("pluginsActifs"): listePlugins.append([nomPlugin, ""]) choixPlugin = (0, "") while (choixPlugin[0] != 1): # On affiche le menu de selection de plugins choixPlugin = self.dialog.menu( text="De quelle plugin voulez-vous voir les chaines ?", choices=listePlugins) if (choixPlugin[0] != 1): # Liste des chaines du plugin listeChaines = [] for nomChaine in self.api.getPluginListeChaines( choixPlugin[1]): listeChaines.append([nomChaine, ""]) choixChaine = (0, "") while (choixChaine[0] != 1): # On affiche le menu de selection de la chaine choixChaine = self.dialog.menu( text= "De quelle chaine voulez-vous voir les emissions ?", choices=listeChaines) if (choixChaine[0] != 1): # Liste des emissions de la chaine listeEmissions = [] for nomEmission in self.api.getPluginListeEmissions( choixPlugin[1], choixChaine[1]): listeEmissions.append([nomEmission, ""]) choixEmission = (0, "") while (choixEmission[0] != 1): # On affiche le menu de selection de l'emission choixEmission = self.dialog.menu( text= "De quelle emission voulez-vous voir les fichiers ?", choices=listeEmissions) if (choixEmission[0] != 1): listeFichiersAAfficher = [] listeFichiersCoches = [] listeFichiersPrecedementCoches = [] listeFichiersAPI = self.api.getPluginListeFichiers( choixPlugin[1], choixEmission[1]) i = 0 for fichier in listeFichiersAPI: texteAAfficher = "(%s) %s" % (getattr( fichier, "date"), getattr(fichier, "nom")) if (fichier in self.listeTelechargements): listeFichiersPrecedementCoches.append( fichier) cochee = 1 else: cochee = 0 listeFichiersAAfficher.append( [str(i), texteAAfficher, cochee]) i += 1 choixFichiers = (0, []) while (choixFichiers[0] != 1): choixFichiers = self.dialog.checklist( text= "Quels fichiers voulez-vous ajouter à la liste des téléchargements ?", choices=listeFichiersAAfficher) if (choixFichiers[0] != 1): for numeroFichier in choixFichiers[1]: fichier = listeFichiersAPI[int( numeroFichier)] listeFichiersCoches.append(fichier) for fichier in listeFichiersCoches: if not (fichier in listeFichiersPrecedementCoches ): self.listeTelechargements.append( fichier) for fichier in listeFichiersPrecedementCoches: if not (fichier in listeFichiersCoches): self.listeTelechargements.remove( fichier) # On retourne au menu precedent choixFichiers = (1, "") ## Methode qui gere le gestionnaire de telechargement def utlisationTelechargements(self): choix = (0, "") while (choix[0] != 1): # On affiche le menu principal choix = self.dialog.menu( text="Gestionnaire de téléchargement", choices=[["Consulter", "Consulter la liste"], ["Lancer", "Lancer les téléchargements"]]) # On lance la methode qui va bien if (choix == (0, "Consulter")): if (len(self.listeTelechargements) > 0): texte = "" for fichier in self.listeTelechargements: texte += "(%s) %s\n" % (getattr( fichier, "date"), getattr(fichier, "nom")) else: texte = "La liste des téléchargements est vide" # On affiche la liste des fichiers a telecharger self.dialog.msgbox(text=texte) elif (choix == (0, "Lancer")): if (len(self.listeTelechargements) > 0): liste = [] for fichier in self.listeTelechargements: lien = getattr(fichier, "lien") nomFichierSortie = getattr(fichier, "nomFichierSortie") if ( nomFichierSortie == "" ): # Si le nom du fichier de sortie n'existe pas, on l'extrait de l'URL nomFichierSortie = os.path.basename(lien) liste.append([0, lien, nomFichierSortie]) # On lance le telechargement self.downloader.lancerTelechargement(liste) self.dialog.msgbox( text="Fin du téléchargement des fichiers") del self.listeTelechargements[:] else: self.dialog.msgbox(text="Aucun fichier à télécharger") ## Methode qui execute les actions necessaires avant de quitter le programme def actionsAvantQuitter(self): print "Fermeture" # On sauvegarde les options des plugins self.api.fermeture() # On sauvegarde l'historique self.historique.sauverHistorique() # On sauvegarde les options du logiciel self.preferences.sauvegarderConfiguration()
class PreferencesDialog(QtGui.QDialog): ## Constructeur # @param signaux Lanceur de signaux def __init__(self, parent, signaux): # Appel au constructeur de la classe mere QtGui.QDialog.__init__(self, parent) self.preferences = Preferences() self.pluginManager = PluginManager() self.signaux = signaux ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle(u"Préférences") # Dimensions la fenetre self.resize(280, 340) # Mise en place de son icone self.setWindowIcon(QtGui.QIcon("ico/gtk-preferences.svg")) ### # Mise en place des widgets dans la fenetre ### # Layout de grille principal self.gridLayout = QtGui.QGridLayout(self) # Font pour les titres fontTitres = QtGui.QFont() fontTitres.setPointSize(11) fontTitres.setWeight(75) fontTitres.setBold(True) # # Choix du repertoire telechargement # # Label self.labelRepertoire = QtGui.QLabel(self) self.labelRepertoire.setFont(fontTitres) self.labelRepertoire.setText(u"Répertoire de téléchargement :") # Repertoire de telechargement self.lineEditRepertoireTelechargement = QtGui.QLineEdit(self) # Bouton pour ouvrir la fenetre de selection de repertoire self.pushButtonSelectionDossier = QtGui.QPushButton(self) self.pushButtonSelectionDossier.setIcon( QtGui.QIcon("ico/gtk-folder.svg")) # # Choix du plugin par defaut # # Label self.labelPluginDefaut = QtGui.QLabel(self) self.labelPluginDefaut.setFont(fontTitres) self.labelPluginDefaut.setText(u"Plugin par défaut :") # Liste de choix du plugin par defaut self.comboBoxPluginDefaut = QtGui.QComboBox(self) # # Choix des plugins a activer # # Label self.labelPlugins = QtGui.QLabel(self) self.labelPlugins.setFont(fontTitres) self.labelPlugins.setText("Plugins actifs :") # Liste des plugins self.listWidgetPlugin = QtGui.QListWidget(self) # # Choix des parametres Internet # # Label self.labelInternet = QtGui.QLabel(self) self.labelInternet.setFont(fontTitres) self.labelInternet.setText(u"Paramètres Internet :") # Layout formulaire self.layoutInternet = QtGui.QFormLayout() # SpinBox pour choisir le timeOut self.spinBoxTimeOut = QtGui.QSpinBox() self.spinBoxTimeOut.setMinimum(1) self.spinBoxTimeOut.setMaximum(60) self.layoutInternet.addRow(u"Time out (en s) :", self.spinBoxTimeOut) # SpinBox pour choisir le nombre de threads max self.spinBoxNbThread = QtGui.QSpinBox() self.spinBoxNbThread.setMinimum(1) self.spinBoxNbThread.setMaximum(100) self.layoutInternet.addRow(u"Nombre de threads max :", self.spinBoxNbThread) # Bouton pour enregistrer/annuler les preferences self.buttonBox = QtGui.QDialogButtonBox(self) self.buttonBox.addButton("Enregistrer", QtGui.QDialogButtonBox.AcceptRole) self.buttonBox.addButton("Fermer", QtGui.QDialogButtonBox.RejectRole) # On ajoute le tout au layout self.gridLayout.addWidget(self.labelRepertoire, 0, 0, 1, 2) self.gridLayout.addWidget(self.lineEditRepertoireTelechargement, 1, 0, 1, 1) self.gridLayout.addWidget(self.pushButtonSelectionDossier, 1, 1, 1, 1) self.gridLayout.addWidget(self.labelPluginDefaut, 2, 0, 1, 2) self.gridLayout.addWidget(self.comboBoxPluginDefaut, 3, 0, 1, 2) self.gridLayout.addWidget(self.labelPlugins, 4, 0, 1, 2) self.gridLayout.addWidget(self.listWidgetPlugin, 5, 0, 1, 2) self.gridLayout.addWidget(self.labelInternet, 6, 0, 1, 2) self.gridLayout.addLayout(self.layoutInternet, 7, 0, 1, 2) self.gridLayout.addWidget(self.buttonBox, 8, 0, 1, 2) ### # Signaux provenants de l'interface ### QtCore.QObject.connect(self.pushButtonSelectionDossier, QtCore.SIGNAL("clicked()"), self.afficherSelecteurDossier) QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("accepted()"), self.enregistrerPreferences) QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("rejected()"), self.reject) ## Methode pour afficher la fenetre des preferences def afficher(self): # On met en place dans le textEdit le repertoire self.lineEditRepertoireTelechargement.setText( stringToQstring( self.preferences.getPreference("repertoireTelechargement"))) # On met en place le plugin par defaut self.remplirPluginParDefaut() # On met en place la liste des plugins self.afficherPlugins() # On met en place les valeurs des SpinBox self.spinBoxTimeOut.setValue(self.preferences.getPreference("timeOut")) self.spinBoxNbThread.setValue( self.preferences.getPreference("nbThreadMax")) # On affiche la fenetre self.exec_() ## Methode pour enregistrer les preferences du logiciel def enregistrerPreferences(self): # On sauvegarde les valeurs des SpinBox self.preferences.setPreference("nbThreadMax", self.spinBoxNbThread.value()) self.preferences.setPreference("timeOut", self.spinBoxTimeOut.value()) # On sauvegarde les plugins actifs self.sauvegarderPlugins() # On sauvegarde le plugin par defaut self.preferences.setPreference( "pluginParDefaut", qstringToString(self.comboBoxPluginDefaut.currentText())) # On sauvegarde le repertoire de telechargement self.preferences.setPreference( "repertoireTelechargement", qstringToString(self.lineEditRepertoireTelechargement.text())) # On sauvegarde dans le fichier self.preferences.sauvegarderConfiguration() # On masque la fenetre self.hide() #################################################################### # Methodes qui gerent l'emplacement de telechargement des fichiers # #################################################################### ## Methode qui affiche le selecteur de dossier def afficherSelecteurDossier(self): rep = QtGui.QFileDialog.getExistingDirectory( None, u"Sélectionnez le répertoire de téléchargement", self.lineEditRepertoireTelechargement.text(), QtGui.QFileDialog.ShowDirsOnly) # Si le repertoire existe if (os.path.isdir(rep)): self.lineEditRepertoireTelechargement.setText( rep) # On modifie la zone de texte qui affiche le repertoire ################################################ # Methodes qui gerent la partie plugins actifs # ################################################ ## Methode qui liste les plugins actif dans le listWidgetPlugin def afficherPlugins(self): # On recupere les listes de plugins listePluginsDisponibles = self.pluginManager.getListeSites() listePluginsDisponibles.sort() # On trie cette liste listePluginsActives = self.preferences.getPreference("pluginsActifs") # On remet a 0 le listWidget self.listWidgetPlugin.clear() # On affiche les plugins for plugin in listePluginsDisponibles: # On met en place l'item self.listWidgetPlugin.addItem( self.creerItem(plugin, plugin in listePluginsActives)) ## Methode qui remplie la combo box du plugin par defaut def remplirPluginParDefaut(self): # On efface la liste self.comboBoxPluginDefaut.clear() # On ajoute les plugins actifs for plugin in self.preferences.getPreference("pluginsActifs"): self.comboBoxPluginDefaut.addItem(stringToQstring(plugin)) # On selectionne le plugin par defaut index = self.comboBoxPluginDefaut.findText( stringToQstring(self.preferences.getPreference("pluginParDefaut"))) if (index != -1): self.comboBoxPluginDefaut.setCurrentIndex(index) ## Methode qui sauvegarde les plugins actifs def sauvegarderPlugins(self): # On liste les plugins actifs liste = [] for i in range(self.listWidgetPlugin.count()): # Pour chaque ligne if (self.listWidgetPlugin.item(i).checkState() == QtCore.Qt.Checked ): # Si elle est selectionnee liste.append( qstringToString(self.listWidgetPlugin.item(i).text())) # On met cela en place dans les preferences self.preferences.setPreference("pluginsActifs", liste) # On relance l'actualisation de l'affichage self.signaux.signal("actualiserListesDeroulantes") #################### # Autres methodes # #################### ## Methode qui creer une element pour un listeWidget # @param texte Texte de l'element # @param checkBox Si la checkBox de l'element est cochee ou non # @return L'element cree def creerItem(self, texte, checkBox=False): # On cree l'item avec le texte item = QtGui.QListWidgetItem(stringToQstring(texte)) # On centre le texte item.setTextAlignment(QtCore.Qt.AlignCenter) # L'item ne doit pas etre modifiable item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable) # L'item doit avoir sa checkBox cochee ? if (checkBox): item.setCheckState(QtCore.Qt.Checked) else: item.setCheckState(QtCore.Qt.Unchecked) # On renvoie l'item return item
class ImdbSelect: def __init__(self, config): self.radarr = Radarr(config.radarr_url, config.radarr_base_path, config.radarr_api_key, config.radarr_quality_profile) self.imdb = Imdb() self.score11 = Score11(self.imdb) self.ask = Preferences(self.imdb) def add_all_actors(self, actors, rating_above=0, votes_above=0, manual=False, retry=True): for count, actor in enumerate(actors, start=1): print("[ " + str(count) + "/" + str(len(actors)) + " ] going through all movies with: " + actor) imdb_ids = self.imdb.imdb_id_list_from_person(actor) self.add_all_imdb_ids(imdb_ids, rating_above, votes_above, manual, retry) def add_all_imdb_ids(self, imdb_ids, rating_above=0, votes_above=0, manual=False, retry=True): movie_data_map = self.collect_movie_data(imdb_ids, retry) self.choices(movie_data_map, rating_above, votes_above, manual, prepare=True) movies_to_add = self.choices(movie_data_map, rating_above, votes_above, manual) self.add_movies(movies_to_add) def collect_movie_data(self, imdb_ids, retry=True): movie_data_map = {} error_list = [] print("[ " + str(len(imdb_ids)) + " ] ", end='', flush=True) next_print = 10 for count, imdb_id in enumerate(imdb_ids): try: if not self.ask.is_answered_no( imdb_id) and not self.radarr.movie_exist(imdb_id): movie_data_map[imdb_id] = self.radarr.get_movie( imdb_id, retry) print('.', end='', flush=True) except MovieNotFoundError: error_list.append(imdb_id) print(Fore.RED + '.' + Style.RESET_ALL, end='', flush=True) if 100 * count // len(imdb_ids) >= next_print: print(str(next_print) + "%", end='', flush=True) next_print += 10 print("/") if len(error_list) > 0: err_title = [ self.imdb.get_movie_title_year(imdb_id) for imdb_id in error_list ] print('Could not find ' + str(len(error_list)) + ': ' + ', '.join(err_title)) return movie_data_map def choices(self, movie_data_map, rating_above=None, votes_above=None, manual=False, prepare=False): movies_to_add = [] for imdb_id, movie in movie_data_map.items(): if rating_above and votes_above: if not movie.rating_above(rating_above): if not prepare: print("\t" + str(movie) + " has too low ratings") continue if not movie.votes_above(votes_above): if not prepare: print("\t\t" + str(movie) + " has not enough votes") continue if manual: if self.ask.ask(imdb_id, movie, prepare): movies_to_add.append(movie) else: if not prepare: print(str(movie) + " has good ratings") movies_to_add.append(movie) elif manual and self.ask.ask(imdb_id, movie, prepare): movies_to_add.append(movie) return movies_to_add def add_movies(self, movies_to_add): for movie in movies_to_add: status = self.radarr.add_movie(movie) if status / 100 == 4: print("\t" + movie.short_string() + " exists already.") else: print("\t" + movie.short_string() + " added.") def delete_non_downloaded_movies_added_ago(self, time_delta=timedelta(days=1)): movies = self.radarr.get_all_non_downloaded_movies() filtered = [ movie for movie in movies if movie.added_date() > datetime.now(timezone.utc) - time_delta ] count = len(filtered) for movie in filtered: print(count, movie.title()) count -= 1 self.radarr.remove_movie(movie)
class GUI: def __init__(self, master): self.valves = self.get_valves() self.master = master self.master.configure(bg='sky blue') self.password = '******' self.momentary = Momentary(self.master, self.valves) self.edit = Edit(self.master, self.valves) self.summary = Summary(self.master, self.valves) self.preferences = Preferences(self.master, self.valves) self.run_screen = RunScreen(self.master, self.valves) self.header = self.make_header(self.master) self.home = self.home_page(self.master) self.frame = self.home def make_header(self, master): header = Frame(master, bg='sky blue') self.label = StringVar() self.label.set('NONE') self.start_label = StringVar() self.start_label.set('START') self.lock_label = StringVar() self.lock_label.set('LOCKED') self.title = Label(header, textvariable=self.label, pady=20, font=('Lucida Console', 50)) self.title.config(bg='sky blue', fg='RoyalBlue4') self.run_image = PhotoImage(file="img/animate.png").subsample(x=5, y=5) self.run_button = Button(header, image=self.run_image, command=self.run, bg='SkyBlue4', activebackground='midnight blue', border=5) self.start_button = Button(header, textvariable=self.start_label, font=('Lucida Console', 30), command=self.start_stop, height=5) self.start_button.config(bg='brown3', activebackground='brown4', fg='white', activeforeground='white', width=10, border=5) self.save_image = PhotoImage(file="img/save.png").subsample(x=5, y=5) self.save_button = Button(header, image=self.save_image, command=self.save, bg='SkyBlue4', activebackground='midnight blue', border=5) self.save_button.config(state='disabled') self.reset_image = PhotoImage(file="img/reset.png").subsample(x=5, y=5) self.reset_button = Button(header, image=self.reset_image, command=self.reset, bg='SkyBlue4', activebackground='midnight blue', border=5) self.home_image = PhotoImage(file="img/home.png").subsample(x=5, y=5) self.home_button = Button(header, image=self.home_image, command=self.to_home, bg='SkyBlue4', activebackground='midnight blue', border=5) self.locked_image = PhotoImage(file="img/lock.png").subsample(x=5, y=5) self.unlocked_image = PhotoImage(file="img/unlock.png").subsample(x=5, y=5) self.lock_button = Button(header, image=self.locked_image, command=self.lock, bg='SkyBlue4', activebackground='midnight blue', border=5, textvariable=self.lock_label) return header def home_page(self, master): frame = Frame(master) frame.grid(row=0, column=0) image = PhotoImage(file="img/guido.gif") bg = Label(frame, image=image) bg.image = image bg.grid(row=0, column=0, rowspan=4, columnspan=2) index = 0 while index < 3: frame.grid_columnconfigure(index, minsize=200) frame.grid_rowconfigure(index, minsize=80) index += 1 summary_button = HomeButton(frame, self.to_summary, 'img/summary.png') summary_button.grid(row=0, column=0, sticky='w') edit_button = HomeButton(frame, self.to_edit, 'img/edit.png') edit_button.grid(row=0, column=1, sticky='e') momentary_button = HomeButton(frame, self.to_momentary, 'img/momentary.png') momentary_button.grid(row=1, column=0, sticky='w') preferences_button = HomeButton(frame, self.to_pref, 'img/preferences.png') preferences_button.grid(row=1, column=1, sticky='e') music = HomeButton(frame, self.to_summary, 'img/music.png') music.grid(row=2, column=0, sticky='w') info = HomeButton(frame, self.to_summary, 'img/info.png') info.grid(row=2, column=1, sticky='e') return frame # CSV file input def get_valves(self): valves = [Valve('VALVE 1', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 2', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 3', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 4', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 5', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 6', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 7', 'DEFAULT', 'Action A', 'Action B', [0, 0]), Valve('VALVE 8', 'DEFAULT', 'Action A', 'Action B', [0, 0])] file = open('data.csv', 'rt', newline='') try: reader = csv.reader(file, lineterminator='\n') index = 0 for row in reader: if index == 0: index += 1 continue else: run = int(row[4]) delay = int(row[5]) interval = [run, delay] valves[index - 1] = Valve(row[0], row[1], row[2], row[3], interval) index += 1 finally: file.close() return valves def lock(self): if self.lock_label.get() == 'LOCKED': window = Toplevel() window.geometry('318x550') self.keypad = Keypad(window, self, self.password) else: self.save_button.config(state='disabled') self.edit.lock() self.preferences.lock() self.lock_label.set('LOCKED') self.lock_button.config(image=self.locked_image) def save(self): self.save_pref() self.save_edit() def save_edit(self): file = open('data.csv', 'w') interval = self.edit.get_intervals() try: writer = csv.writer(file, lineterminator='\n') writer.writerow(('Name', 'Setting', 'Action A', 'Action B', 'Runtime', 'Delaytime')) index = 0 for i in self.valves: i.set_interval([interval[index].get(), interval[index + 8].get()]) valve_interval = i.get_interval() if self.edit.plusInterval[index].cget('state') == 'disabled' and self.edit.motor[index].cget('state') != 'disabled': i.set_setting('MOTOR') writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), 0, 0)) elif interval[index].get() is 0: i.set_setting('INACTIVE') writer.writerow((i.get_name().get(), i.get_setting(), 'NONE', 'NONE', 0, 0)) else: i.set_setting('DEFAULT') writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), valve_interval[0], valve_interval[1])) index += 1 finally: file.close() # must fix def save_pref(self): index = 0 for i in self.valves: num = index * 3 if self.preferences.entry_field[num].get(): i.set_name(self.preferences.entry_field[num].get()) self.preferences.entry_field[num].delete(0, 'end') if self.preferences.entry_field[num + 1].get(): i.set_action_a(self.preferences.entry_field[num + 1].get()) self.preferences.entry_field[num + 1].delete(0, 'end') if self.preferences.entry_field[num + 2].get(): i.set_action_b(self.preferences.entry_field[num + 2].get()) self.preferences.entry_field[num + 2].delete(0, 'end') index += 1 def start_stop(self): if self.start_label.get() == 'START': self.start_label.set('STOP') self.master.update() self.run_screen.run_all(True) self.home_button.config(state='disabled') else: self.start_label.set('START') self.run_screen.run_all(False) self.home_button.config(state='normal') def run(self): self.summary.grid_remove() self.run_button.pack_forget() self.run_screen.make_frame() self.frame = self.run_screen self.frame.grid(row=0, column=0) self.header.grid(row=0, column=1) self.label.set('RUN') self.title.pack(side='top') self.start_button.pack() self.home_button.pack(side='bottom') def to_home(self): self.momentary.end_all() self.momentary.delete_frame() self.lock_button.pack_forget() self.run_button.pack_forget() self.save_button.pack_forget() self.reset_button.pack_forget() self.home_button.pack_forget() self.start_button.pack_forget() self.preferences.grid_remove() self.frame.grid_remove() self.header.grid_remove() self.frame = self.home self.frame.grid(row=0, column=0) def to_summary(self): self.frame.grid_remove() self.label.set('SUMMARY') self.home_button.pack(side='right') self.run_button.pack(side='right') self.header.grid(row=0, column=0, columnspan=1, sticky='nsew') self.title.pack(side='left') self.summary = Summary(self.master, self.valves) self.frame = self.summary self.frame.grid(row=1, column=0) def to_edit(self): self.frame.grid_remove() self.label.set('EDIT PROGRAM') self.header.grid(row=0, column=0, columnspan=1, sticky='nsew') self.home_button.pack(side='right') self.save_button.pack(side='right') self.lock_button.pack(side='right') self.reset_button.pack(side='right') self.title.pack(side='left') self.frame = self.edit self.frame.grid(row=1, column=0) def to_momentary(self): self.frame.grid_forget() self.label.set('MOMENTARY') self.header.grid(row=0, column=0, columnspan=12, sticky='ew') self.title.pack(side='left') self.home_button.pack(side='right') self.momentary.make_frame() def to_pref(self): self.frame.grid_remove() self.label.set('PREFERENCES') self.header.grid(row=0, column=0, columnspan=1, sticky='nsew') self.home_button.pack(side='right') self.save_button.pack(side='right') self.lock_button.pack(side='right') self.reset_button.pack(side='right') self.title.pack(side='left') self.frame = self.preferences self.frame.grid(row=1, column=0) def reset(self): self.master.quit() def access_granted(self): self.lock_label.set('UNLOCKED') self.lock_button.config(image=self.unlocked_image) self.save_button.config(state='normal') index = 0 while index < 8: self.edit.minusInterval[index].config(state='normal') self.edit.minusDelay[index].config(state='normal') self.edit.plusInterval[index].config(state='normal') self.edit.plusDelay[index].config(state='normal') self.edit.motor[index].config(state='normal') self.edit.adv[index].config(state='normal') index += 1 for each in self.preferences.entry_field: each.config(state='normal') self.edit.set_seconds() self.save_button.config(state='normal')
class Downloader( object ): # Instance de la classe (singleton) instance = None ## Surcharge de la methode de construction standard (pour mettre en place le singleton) def __new__( self, *args, **kwargs ): if( self.instance is None ): self.instance = super( Downloader, self ).__new__( self ) return self.instance ## Constructeur # @param signaux Lanceur de signaux. Si on le precise pas, aucun signal n'est lance (mode CLI). def __init__( self, signaux = None ): self.preferences = Preferences() self.signaux = signaux self.arreter = True self.process = None ## Methode pour afficher un pourcentage à l'ecran # @param pourcentage Pourcentage actuel a afficher def afficherPourcentage( self, pourcentage ): # On s'assure que le pourcentage soit bien entre 0 et 100 if( pourcentage < 0 ): pourcentage = 0 elif( pourcentage > 100 ): pourcentage = 100 message = str( pourcentage ) + " %" print '\r', # Permet d'écrire au même endroit sys.stdout.write( message ) sys.stdout.flush() ## Methode pour lancer le telecharger des fichiers # @param listeFichiers Liste des fichiers a telecharger def lancerTelechargement( self, listeFichiers ): self.arreter = False for ( numero, fichier, nomFichierSortie ) in listeFichiers: logger.info( u"téléchargement de %s" %( fichier ) ) # Si on demande de s'arreter, on sort if self.arreter: break # Si on a le lanceur de signal if self.signaux : # On envoie le signal de debut de telechargement d'un fichier self.signaux.signal( "debutTelechargement", numero ) else: print "Debut telechargement", nomFichierSortie # On ajoute le repertoire de destination au nom du fichier fichierSortie = self.preferences.getPreference( "repertoireTelechargement" ) + "/" + nomFichierSortie # On telecharge de differentes manieres selon le protocole if( fichier[ :4 ] == "rtmp" ): commande = urlToRtmpdump( fichier ) self.telecharger( commande + " -o \"" + fichierSortie + "\"" ) elif( fichier[ :4 ] == "http" or fichier[ :3 ] == "ftp" or fichier[ :3 ] == "mms" ): self.telecharger( "msdl -c " + fichier + " -o \"" + fichierSortie + "\"" ) else: logger.warn( "le protocole du fichier %s n'est pas gere" %( fichier ) ) # Si on a le lanceur de signal if self.signaux : # On envoie le signal de fin de telechargement d'un fichier self.signaux.signal( "finTelechargement", numero ) else: print "\n\tFin telechargement" # Si on a le lanceur de signal if self.signaux : # On envoie le signal de fin de telechargement des fichiers self.signaux.signal( "finDesTelechargements" ) ## Methode qui telecharge un fichier # @param commande Commande a lancer pour telecharger le fichier def telecharger( self, commande ): # Commande mise au bon format pour Popen if( not isinstance( commande, str ) ): commande = str( commande ) arguments = shlex.split( commande ) # On lance la commande en redirigeant stdout et stderr (stderr va dans stdout) self.process = subprocess.Popen( arguments, stdout = subprocess.PIPE, stderr = subprocess.STDOUT ) # On recupere le flux stdout stdoutF = self.process.stdout # On recupere le descripteur de fichier de stdout stdoutFD = stdoutF.fileno() # On recupere les flags existants stdoutFlags = fcntl.fcntl( stdoutFD, fcntl.F_GETFL ) # On modifie les flags existants en ajoutant le flag NoDelay fcntl.fcntl( stdoutFD, fcntl.F_SETFL, stdoutFlags | os.O_NDELAY ) # Tant que le subprocess n'est pas fini while( self.process.poll() == None ): # On attent que stdout soit lisible if( stdoutFD in select.select( [ stdoutFD ],[],[] )[ 0 ] ): # On lit stdout ligne = stdoutF.read() # On affiche que les textes non vides if ligne: pourcentListe = re.findall( "(\d{1,3}\.{0,1}\d{0,1})%", ligne ) if( pourcentListe != [] ): pourcent = int( float( pourcentListe[ -1 ] ) ) if( pourcent >= 0 and pourcent <= 100 ): # Si on a le lanceur de signal if not self.signaux : self.afficherPourcentage( pourcent ) elif self.signaux : # On envoit le pourcentage d'avancement a l'interface self.signaux.signal( "pourcentageFichier", pourcent ) # On attent avant de recommencer a lire time.sleep( 3 ) ## Methode pour stopper le telechargement des fichiers def stopperTelechargement( self ): if not self.arreter: # On sort de la boucle principale self.arreter = True # On stop le process s'il est lance if( self.process.poll() == None ): self.process.terminate()
class Plugin(MooseWidget): """ A base class for all plugin objects. A plugin object are stand-alone widgets contained by a peacock tab. In general, the plugins should be independent and be able to be removed or added to a given tab. Plugins are stored Manager objects. see Manager.py """ def __init__(self, layout='MainLayout', settings_key=""): super(Plugin, self).__init__() # Name of layout that this plugin should be added (see PluginManager.py) self._main_layout_name = layout # The default size policy self.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) # Must be a QtWidget if not isinstance(self, QtWidgets.QWidget): mooseutils.mooseError("A Plugin must also be a QWidget.") return # The Peacock tab index self._index = None self._plugin_manager = None self._preferences = Preferences(settings_key) @staticmethod def commandLineArgs(parser): """ Allows the plugin to add command line options to the parser. """ def connect(self, other): """ Connect the slots of supplied plugin (other) to the signals emited by this (self) plugin. Args: other[Plugin]: A plugin object to connect. """ if self is not other: for name, signal in self.signals().iteritems(): slot_name = 'on' + name[0].upper() + name[1:] if hasattr(other, slot_name): mooseutils.mooseDebug('{}.{} --> {}.{}'.format( self.__class__.__name__, name, other.__class__.__name__, slot_name)) signal.connect(getattr(other, slot_name)) #def initialize(self, *args, **kwargs): # """ # This method is called by the Manager after all plugins have been created. # """ # self.setEnabled(True) def setMainLayoutName(self, name): """ Method for changing the name of the main layout that this plugin will be added. Args: name[str]: The name of the layout within the PluginManager. """ self._main_layout_name = name def mainLayoutName(self): """ Return the name of the layout within the PluginManager that this plugin is to be added. """ return self._main_layout_name def repr(self): """ Return data for reproducing the plugin as a script. """ return dict() def canClose(self): """ Called when the application wants to close. This is intended to allow the plugin to check if it has unsaved state and ask the user if they want to cancel the close or throw away the changes. Return: bool: Whether it is OK to close """ return True def closing(self): """ Called when the application is about to close. This is intended to allow the plugin to do any cleanup before closing """ pass def onPreferencesSaved(self): """ Called when the preferences have been saved. """ def clearRecentlyUsed(self): """ Clears any recently used items """ def addToMainMenu(self, menubar): """ This allows the plugin to add menu items to the main menu. Args: menubar[QMenuBar]: Menubar to add items to """ pass def onCurrentChanged(self, index): """ Executes when the TabWidget (TabPluginManager) changes active tabs. Inputs: index[int]: The index of the active tab """ pass def setTabIndex(self, index, signal=None): """ Set the Peacock Tab index (see TabPluginManager) """ if signal: signal.connect(self.onCurrentChanged) self._index = index def preferenceWidgets(self): return self._preferences.widgets()
def __init__(self): from API import API from APIPrive import APIPrive from PluginManager import PluginManager ################################################ # Instanciations + initialisation de variables # ################################################ # On instancie le plugin manager self.pluginManager = PluginManager() # On instancie le gestionnaire de preferences et sa fenetre self.preferences = Preferences() # On instancie le gestionnaire de download self.downloader = Downloader() # On instancie seulement les plugins qui sont selectionnes dans les preferences #~ self.pluginManager.activerPlugins( self.preferences.getPreference( "pluginsActifs" ) ) # On recupere l'instance de API self.api = API.getInstance() # On met en place la liste des plugins dans API current=0 global choice choice='' while choice!='r' and choice!='R': # self.api.setListeInstance( getattr( self.pluginManager, "listeInstances" ) ) pluginsActifs = self.pluginManager.listeInstances plugins = self.pluginManager.getListeSites() plugins.sort() rep= self.preferences.getPreference( "repertoireTelechargement" ) # if choice.isdigit() and int(choice) < int(len(plugins)-10*current): print int(choice)+int(10*current) # elif choice.isdigit() and int(choice) > int(len(plugins)-10*current): print int(choice)+int(10*current) if choice=='q' or choice=='Q': quitter() elif choice.isdigit() and int(choice) < int(len(plugins)-10*current): if plugins[int(choice)+10*current] in pluginsActifs: self.pluginManager.desactiverPlugin(plugins[int(choice)+10*current]) print int(choice)+10*current, else: self.pluginManager.activerPlugin(plugins[int(choice)+10*current]) print int(choice)+10*current, elif choice=='m' or choice =='M': os.system(['clear','cls'][os.name == 'nt']) header ('','','Repertoire de telechargement') choice=raw_input('\n\n\n\n\n\n\n\tVeuillez saisir un repertoire valide\n\n\t\t') if not os.path.isdir(choice): os.system(['clear','cls'][os.name == 'nt']) header ('','','Repertoire de telechargement') print "\n\n\n\n\n\n\n\trepertoire ",choice," inexistant\n\n\t\tRepertoire courant:",rep else : os.system(['clear','cls'][os.name == 'nt']) header ('','','Repertoire de telechargement') rep=choice print "\n\n\n\n\n\n\n\tModification du repertoire de telechargement :\n\n\t\tNouveau repertoire :",choice self.preferences.setPreference( "repertoireTelechargement", str(rep)) time.sleep(1) elif choice=='+': if len(plugins)>current*15+15: current+=1 elif choice=='-': if current!=0: current-=1 #affichage a l'ecran de la liste header ('','','Menus des options') print " Repertoire de telechargement :",rep for i in range(10) : if i+10*current<len(plugins): print "\n ",i,":",plugins[i+10*current], if len(plugins[i+10*current])<=8:print"\t\t", elif len(plugins[i+10*current])<=15:print"\t", for j in pluginsActifs: if j==plugins[i+10*current]: print "actif", else: print "" print "\n\n m:modifier le repertoire de telechargement +/-:afficher les autres plugins" footer() choice=getch()
class WordFrequencies: ############################################################################################### # Members ############################################################################################### namesSet = set() wordDict = WordDict() namesDict = {} #{ name : ( count , last occurence ) } # wordsPerDayDict = {} #{ word : { 'count': count , 'lastOccurence': last occurence } } only counts one occurence per day wordsPerDayDict = WordsPerDayDict() namesPerDayDict = {} #{ word : ( count , last occurence ) } namesToGraphDict = {} #{ word : [ [ date , count ] ] } namesToGraphDictUniqueOccurences = {} #{ word : [ date ] } wordCountOfEntriesDict = {} #{ date : word count } relatedNamesDict = {} #{ name : { name : unique day count } } lastNamesForFirstNameDict = {} #{ first name : [ last names ] } totalNumberOfWords = 0 dayEntryHashTable = {} #{ date : hash } firstDate = datetime.datetime(datetime.MAXYEAR,12,31) mostRecentDate = datetime.datetime(datetime.MINYEAR,1,1) namesURL = os.path.dirname(os.path.realpath(__file__)) + '/names.txt' prefs = Preferences() #stored the user's preferences for various things printer = PrintHelper(prefs) ############################################################################################### # Loading and Setup ############################################################################################### ############################################################################################### # Data Processing ############################################################################################### #parse a line and add the words to the dictionaries #print the line to markunder file, with the proper qualification on names #all markunder printing should happen here def addLine(self, line, currentDate): # markunderFile = open(self.markUnderFilePath, 'a') words = line.split(' ') wordsToCount = 0 #used to calculate the length of entries - don't want to include invalid words in the word count TODO: rethink this? namesFound = set() for word in words: if word == '' or word == None or re.compile('^\s+$').search(word) != None: continue (beforeStuff, word, afterStuff) = Helper.cleanWordForInitialAdd(word) word = WordClass(word) #words are represented by the WordClass, which is basically an encapsulation of normal words and markup names in one object if self.prefs.COMBINE_PLURALS: if word.endswith("'s"): word = WordClass.addWordOrMarkup(word.toString()[:len(word)-2]) #TODO: this is broken wasUpper = False; if word.toString()[:1].isupper(): wasUpper = True; originalWord = word word = Helper.cleanWord(word) #this strips off all punctuation and other information that we want to pass into markup. if not Helper.valid(word): continue wordsToCount += 1 #names if word in self.namesSet and (Preferences.REQUIRE_CAPS_FOR_NAMES and wasUpper): namesFound.add(word) try: self.namesDict[word] = (self.namesDict[word][0] + 1, currentDate) except: self.namesDict[word] = (1, currentDate) #names per day try: if self.namesPerDayDict[word][1] != currentDate: self.namesPerDayDict[word] = (self.namesPerDayDict[word][0] + 1, currentDate) except: self.namesPerDayDict[word] = (1, currentDate) #names for graphing purposes try: #{ word : [ [ date , count ] ] } self.namesToGraphDict[word] #trigger exception if self.namesToGraphDict[word][-1][0] == currentDate: #increment count self.namesToGraphDict[word][-1][1] += 1 else: #start a new tuple with a new date self.namesToGraphDict[word].append([currentDate, 1]) except: #this name hasn't been encountered yet self.namesToGraphDict[word] = [[currentDate, 1]] #names for graph, counting on unique occurences try: #{ word : [ date ] } self.namesToGraphDictUniqueOccurences[word].append(currentDate) except: self.namesToGraphDictUniqueOccurences[word] = [currentDate] #words if self.wordDict.exists(word): self.wordDict.addOrReplaceWord(word, self.wordDict.getCount(word) + 1, currentDate, self.wordDict.getFirstOccurrence(word), wasUpper) else: self.wordDict.addWord(word, 1, currentDate, currentDate, wasUpper) #TODO: wasUpper wasn't there originally #words per day if self.wordsPerDayDict.exists(word): self.wordsPerDayDict.addWord(word, self.wordsPerDayDict.getCount(word), currentDate) #TODO: was addOrReplaceWord, need to think what it should be else: self.wordsPerDayDict(word, 1, currentDate) #TODO: this is being moved to its own class to be called separately # if self.prefs.DO_MARK_UNDER: # #if it's a name, qualify it for the markunder # if word in self.namesSet:# or not (Preferences.REQUIRE_CAPS_FOR_NAMES and wasUpper): # markUnderWord = self.getMarkUnderWord(word, originalWord, line, currentDate) # else: # markUnderWord = word # markunderFile.write(markUnderWord + ' ') # markunderFile.close() return (wordsToCount, namesFound) ############################################################################################### # Graphing and Printing ############################################################################################### #print the x most occuring words #num: number to print. if 'all', prints all #TODO: it would be nice to move at least part of this function to the printer class def printHighest(self, args, option): if self.prefs.VERBOSE: print('args: ', end=' ') print(args) print('option: ', end=' ') print(option) if option == PrintOption.RELATED: nameForRelated = args[0] args = args[1:] if len(args) < 1: print('Too few arguments.') return if self.prefs.VERBOSE: print('nameForRelated: ' + nameForRelated) start_num = 0 end_num = 0 index1 = 0 index2 = 1 if len(args) == 1: #only an end num try: if (args[index1] == 'all'): end_num = float('inf') else: end_num = int(args[index1]) except: print('Invalid arguments') return elif len(args) >= 2: #start and end try: start_num = int(args[index1]) if (args[index2] == 'all'): end_num = float('inf') else: end_num = int(args[index2]) except: print('Invalid arguments') return if self.prefs.VERBOSE: print('start_num: ', end=' ') print(start_num, end=' ') print(' end_num ', end=' ') print(end_num) #TODO: add headers to all cases if option == PrintOption.NAMES: sortedNamesDict = sorted(list(self.namesDict.items()), key=operator.itemgetter(1)) sortedNamesDict.reverse() end_num = min(end_num, len(sortedNamesDict)) self.printer.makePrettyHeader('Word', 'Count', 'Last Occurence') for x in range(start_num, end_num): self.printer.makeOutputPretty(sortedNamesDict[x]) elif option == PrintOption.RELATED: #TODO: deal with 'all' here, since it won't be caught earlier sortedRelatedNamesDict = sorted(list(self.relatedNamesDict[nameForRelated].items()), key=operator.itemgetter(1)) sortedRelatedNamesDict.reverse() print('Related names for ' + nameForRelated + ':\n') self.printer.makePrettyHeader('Name', 'Count') end_num = min(end_num, len(sortedRelatedNamesDict)) for x in range(start_num, end_num): self.printer.makeOutputPrettyRelated(sortedRelatedNamesDict[x]) elif option == PrintOption.WORDSPERDAY: sortedWordsPerDayDict = self.wordsPerDayDict.getSortedDictByCount() sortedWordsPerDayDict.reverse() end_num = min(end_num, len(sortedWordsPerDayDict)) self.printer.makePrettyHeader('Word', 'Count', 'Last Occurence') for x in range(start_num, end_num): self.printer.makeOutputPrettyWPD(sortedWordsPerDayDict[x]) elif option == PrintOption.NAMESPERDAY: sortedNamesPerDayDict = sorted(list(self.namesPerDayDict.items()), key=operator.itemgetter(1)) sortedNamesPerDayDict.reverse() end_num = min(end_num, len(sortedNamesPerDayDict)) self.printer.makePrettyHeader('Name', 'Count', 'Last Occurence') for x in range(start_num, end_num): self.printer.makeOutputPretty(sortedNamesPerDayDict[x]) elif option == PrintOption.LENGTH: sortedLengthOfEntriesDict = sorted(list(self.wordCountOfEntriesDict.items()), key=operator.itemgetter(1)) sortedLengthOfEntriesDict.reverse() end_num = min(end_num, len(sortedLengthOfEntriesDict)) self.printer.makePrettyHeader('Date', 'Count') for x in range(start_num, end_num): self.printer.makeOutputPrettyLength(sortedLengthOfEntriesDict[x]) else: #regular words self.printer.makePrettyHeader('Word', 'Count', 'Last Occurence') sortedWordsDict = self.wordDict.getSortedDictByCount() sortedWordsDict.reverse() end_num = min(end_num, len(sortedWordsDict)) for x in range(start_num, end_num): self.printer.makeOutputPrettyWordsDict(sortedWordsDict[x]) #graphs the number of occurences of the name per day def graphAnalytics(self, args): #{ word : [ [ date , count ] ] } name = args[0] try: self.namesToGraphDict[name] except: print('Invalid input - must be a valid name') return try: x = [date[0] for date in self.namesToGraphDict[name]] y = [count[1] for count in self.namesToGraphDict[name]] ax = plt.subplot(111) ax.bar(x, y, width=2) ax.xaxis_date() plt.show() except: print('Unknown error occured while graphing') #graphs a bar for each day that an entry exists def graphEntries(self, args): #{ date : word count } sortedLengthOfEntriesDict = sorted(list(self.wordCountOfEntriesDict.items()), key=operator.itemgetter(1)) x = [i[0] for i in sortedLengthOfEntriesDict] y = [1 for j in sortedLengthOfEntriesDict] self.graphHelper(x, y) def graphHelper(self, x, y): ax = plt.subplot(111) ax.bar(x, y, width=2) ax.xaxis_date() plt.show() def graphNameValue(self, in_dict): x = list(in_dict.keys()) y = list(in_dict.values()) self.graphHelper(x, y) def lookupWord(self, args): word = args[0] if not self.wordDict.exists(word): print('Invalid word') return print(word + ': ') print('First usage: ' + str(self.wordDict.getFirstOccurrence(word))) print('Last usage: ' + str(self.wordDict.getLastOccurrence(word))) total_uses = self.wordDict.getCount(word) total_days_used = self.wordsPerDayDict.getCount(word) total_number_of_days = len(self.wordCountOfEntriesDict) print('Total usages: ' + str(total_uses)) print('Total days with at least one usage: ' + str(total_days_used)) length = (self.wordDict.getLastOccurrence(word) - self.wordDict.getFirstOccurrence(word)).days print('Length from first use to last: ' + Helper.daysAsPrettyLength(length)) print('Average usages per day: ' + str(float(total_uses) / length)) print('Percentage of days with at least one useage: ' + str(round(float(total_days_used) / total_number_of_days * 100, 2)) + '%') def overallAnalytics(self): print('Total number of entries: ', end=' ') print(len(self.wordCountOfEntriesDict)) print('First entry: ', end=' ') print(Helper.prettyPrintDate(self.firstDate)) print('Last entry: ', end=' ') print(Helper.prettyPrintDate(self.mostRecentDate)) print('Total days from first to last entry: ', end=' ') totalDays = self.mostRecentDate - self.firstDate #this is correct days = totalDays.days print(days) print('Percentage of days from first to last with an entry: ', end=' ') print(str(round(float(len(self.wordCountOfEntriesDict)) / days * 100, 2)) + '%') print('Average length per entry: ', end=' ') numberOfEntries = len(self.wordCountOfEntriesDict) sumOfLengths = 0 longestEntryLength = 0 for date in list(self.wordCountOfEntriesDict.keys()): length = self.wordCountOfEntriesDict[date] if length > longestEntryLength: longestEntryLength = length longestEntryDate = date sumOfLengths += length print(round(float(sumOfLengths) / numberOfEntries, 2)) print('Longest entry: ' + str(longestEntryLength) + ' words on ', end=' ') print(Helper.prettyPrintDate(longestEntryDate)) print('Total number of words written: ', end=' ') print(locale.format("%d", self.totalNumberOfWords, grouping=True)) ############################################################################################### # Names ############################################################################################### def addRelatedNames(self, namesFound): #{ name : { name : unique day count } } for keyName in namesFound: for otherName in namesFound: if keyName == otherName: continue try: self.relatedNamesDict[keyName] except: self.relatedNamesDict[keyName] = {} try: self.relatedNamesDict[keyName][otherName] += 1 except: self.relatedNamesDict[keyName][otherName] = 1 #populate namesList from file def makeNamesSet(self): try: f = open(self.namesURL, 'r') #TODO: error handling except: raise Exception("Names file not found") self.namesSet.clear() line = f.readline() while line != '': self.namesSet.add(line.strip().lower()) #TODO: does this do anything? What? line = f.readline() f.close() #iterate over def guessNamesHelper(self, guessedNamesSet): newNames = set() print('Are these names? (y/n)') for name in guessedNamesSet: if name in self.namesSet: break inp = input(name + ': ') if inp == 'y': newNames.add(name.lower()) f = open(self.namesURL, 'r+') for name in newNames: f.write(name + '\n') f.close() #try to guess what is a name by looking for capitalized letters in the middle of sentences def guessNames(self, line, testFlag = False): guessedNamesSet = set() names = regex.findall('[^\.]\s+([ABCDEFGHIJKLMNOPQRSTUVWXYZ][\w]+)\W', line, overlapped=True) try: for name in names: if name.lower() not in self.namesSet: guessedNamesSet.add(name) except: return #want to return the guessedNamesSet here if this is running for a test #TODO: figure out how to send more input during a test and get rid of this hack if testFlag: return guessedNamesSet self.guessNamesHelper(guessedNamesSet) #Add a name manually to the names set def addName(self, args): name = args[0] if name in self.namesDict: print("Name already added") return self.namesSet.add(name); f = open(self.namesURL, 'a') f.write('\n' + name) f.close() def removeName(self, name): self.namesSet.remove(name); f = open(self.namesURL, 'r+') f.clear() for name in self.namesSet: f.write(name) + '\n' f.close() ############################################################################################### # Control Loop ############################################################################################### def main(self, args): self.mainSetup(args) self.runMainLoop() #break apart the main function for testing def mainSetup(self, args): locale.setlocale(locale.LC_ALL, 'en_US') fileurl = args.file if args.verbosity: self.prefs.VERBOSE = True if args.combineplurals: self.prefs.COMBINE_PLURALS = True if args.guessnames: self.prefs.GUESS_NAMES = True if args.markunder: self.prefs.DO_MARK_UNDER = True print('Set DO_MARK_UNDER=True') # if args.noMarkunder: # self.prefs.DO_MARK_UNDER = False # print 'Set DO_MARK_UNDER=False' self.makeNamesSet() self.readFile(fileurl) def runMainLoop(self): # if self.prefs.GUESS_NAMES: # self.getGuessedNames() while True: print(''' Options: Highest x words highest [num | all] (num | all) Highest x words per day wpd [num | all] Lookup lookup [word] Highest x names names [num | all] Related Names related [name] [num | all] Highest x names per day npd [num | all] Graph names graph [name] Graph entries graphentries Graph length graphlength Add name add name [name] Set Options option [option_name] [value] Length length [num | all] Overall analytics overall Exit exit ''') if not self.parseInput(input('>')): return def parseInput(self, inpStr): parts = inpStr.split() command = parts[0].lower().strip().lstrip() args = parts[1:] if (self.prefs.VERBOSE): print('Parsed arguments: command: ' + str(command) + ' args: ' + str(args)) return self.callInputFunction(command, args) def readFile(self, url): try: f = open(url, 'r') except: print('File not found') newPath = input('Enter new path > '); return self.readFile(newPath) #TODO: this doesn't work for entirely unknown reasons newdate = re.compile('\s*([0-9]{1,2}-[0-9]{1,2}-[0-9]{2})\s*') currentDateStr = None currentDateObj = None numWords = 0 namesFound = set() totalWordNum = 0 currentDayEntry = '' #holds all the lines for the current day, so we can compute a hash of the day later on line = f.readline() while (line != ''): if self.prefs.GUESS_NAMES: self.guessNames(line) #check a line to see if it's a date, therefore a new day dateFound = newdate.match(line) if dateFound != None: #it's a new date, so wrapup the previous date and set up to move onto the next one if namesFound != None: self.addRelatedNames(namesFound) namesFound = set() self.dayEntryHashTable[currentDateObj] = hashlib.md5(currentDayEntry.encode()) #TODO: deal with first date if numWords > 0: self.wordCountOfEntriesDict[currentDateObj] = numWords #should be here, since we want it triggered at the end totalWordNum += numWords numWords = 0 currentDateStr = dateFound.group(0) currentDateStr = Helper.formatDateStringIntoCleanedString(currentDateStr) currentDateObj = Helper.makeDateObject(currentDateStr) if currentDateObj > self.mostRecentDate: #found a higher date than what we've seen so far self.mostRecentDate = currentDateObj if currentDateObj < self.firstDate: #found a lower date than what we have now self.firstDate = currentDateObj line = line[len(currentDateStr):] #remove date from line, so it's not a word if currentDateStr != None: (wordsFound, namesFoundThisLine) = self.addLine(line, currentDateObj) for name in namesFoundThisLine: namesFound.add(name) numWords += wordsFound line = f.readline() currentDayEntry += line #add line to the day's entry #need to capture the last date for the entry length self.wordCountOfEntriesDict[currentDateObj] = numWords self.totalNumberOfWords = totalWordNum + numWords #need to get words from last line f.close() #args is a list of arguments in order def callInputFunction(self, inp, args): if inp == CommandOptions.HIGHEST.value: self.printHighest(args, None) elif inp == CommandOptions.LOOKUP.value: self.lookupWord(args) elif inp == CommandOptions.NAMES.value: self.printHighest(args, PrintOption.NAMES) elif inp == CommandOptions.RELATED.value: self.printHighest(args, PrintOption.RELATED) elif inp == CommandOptions.GRAPH.value: self.graphAnalytics(args) elif inp == CommandOptions.GRAPH_ENTRIES.value: self.graphEntries(args) # elif inp == 'gpd': # self.graphAnalyticsPerDay(args) elif inp == CommandOptions.WPD.value: self.printHighest(args, PrintOption.WORDSPERDAY) elif inp == CommandOptions.NPD.value: self.printHighest(args, PrintOption.NAMESPERDAY) elif inp == CommandOptions.ADDNAME.value: self.addName(args) elif inp == CommandOptions.OPTION.value: print("Setting options isn't supported yet") pass elif inp == CommandOptions.LENGTH.value: self.printHighest(args, PrintOption.LENGTH) elif inp == CommandOptions.GRAPH_LENGTH.value: self.graphNameValue(self.wordCountOfEntriesDict) elif inp == CommandOptions.OVERALL.value: self.overallAnalytics() elif inp == CommandOptions.EXIT.value: return False else: print('Unknown command.') return True
def __init__(self, signaux=None): self.preferences = Preferences() self.signaux = signaux self.arreter = True self.process = None
def mass_test_raw_data_entry_creation(sh, start, end, interval=1): pr = Preferences() prefix = pr.get('DBPrefix') sh.generateRawDataEntrys(start, end, interval, prefix)
def load_ui_from_prefs(self, preferences: Preferences): """Load the UI fields from the given preferences""" # Filter wheel? ufw = preferences.get_use_filter_wheel() self.ui.useFilterWheel.setChecked(ufw if ufw is not None else False) self.enable_filter_fields() # Number of flats self.ui.numFlats.setText(str(preferences.get_default_frame_count())) # Target ADUs self.ui.targetADUs.setText(str(preferences.get_target_adus())) self.ui.aduTolerance.setText(str(preferences.get_adu_tolerance() * 100.0)) # Server address and port number self.ui.serverAddress.setText(preferences.get_server_address()) self.ui.portNumber.setText(str(preferences.get_port_number())) # Information about slewing to the flat light source self.ui.sourceAlt.setText(str(round(preferences.get_source_alt(), 4))) self.ui.sourceAz.setText(str(round(preferences.get_source_az(), 4))) # Dithering self.ui.ditherFlats.setChecked(preferences.get_dither_flats()) self.ui.ditherRadius.setText(str(preferences.get_dither_radius())) self.ui.ditherMaxRadius.setText(str(preferences.get_dither_max_radius())) # Filter specifications filter_specs = preferences.get_filter_spec_list() fs: FilterSpec for fs in filter_specs: check_box_name: str = f"useFilter_{fs.get_slot_number()}" this_check_box: QCheckBox = self.ui.findChild(QCheckBox, check_box_name) assert this_check_box is not None this_check_box.setChecked(fs.get_is_used()) name_field_name: str = f"filterName_{fs.get_slot_number()}" this_name_field: QLineEdit = self.ui.findChild(QLineEdit, name_field_name) assert this_name_field is not None this_name_field.setText(fs.get_name()) # Binning specifications binning_specs = preferences.get_binning_spec_list() bs: BinningSpec for bs in binning_specs: this_default_name: str = f"binDefault_{bs.get_binning_value()}" this_available_name: str = f"binAvailable_{bs.get_binning_value()}" this_off_name: str = f"binOff_{bs.get_binning_value()}" default_button: QRadioButton = self.ui.findChild(QRadioButton, this_default_name) assert default_button is not None available_button: QRadioButton = self.ui.findChild(QRadioButton, this_available_name) assert available_button is not None off_button: QRadioButton = self.ui.findChild(QRadioButton, this_off_name) assert off_button is not None if bs.get_is_default(): default_button.setChecked(True) elif bs.get_is_available(): available_button.setChecked(True) else: off_button.setChecked(True)
def __init__( self ): # Appel au constructeur de la classe mere QtGui.QMainWindow.__init__( self ) ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle( "TVDownloader" ) # Mise en place de son icone self.setWindowIcon( QtGui.QIcon( "ico/TVDownloader.png" ) ) ### # Mise en place des widgets dans la fenetre ### # Widget central qui contiendra tout self.centralWidget = QtGui.QWidget( self ) # # Barre du haut # # Layout horizontal qui contiendra les listes deroulantes self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout() # Liste deroulante pour choisir le site (plugin) self.comboBoxSite = QtGui.QComboBox( self.centralWidget ) self.horizontalLayoutBarreHaut.addWidget( self.comboBoxSite ) # Liste deroulante pour choisir une chaine du site courant self.comboBoxChaine = QtGui.QComboBox( self.centralWidget) self.horizontalLayoutBarreHaut.addWidget( self.comboBoxChaine ) # Liste deroulante pour choisir une emission de la chaine courante self.comboBoxEmission = QtGui.QComboBox( self.centralWidget ) self.horizontalLayoutBarreHaut.addWidget( self.comboBoxEmission ) # # Onglets # # Gestionnaire onglets self.tabWidget = QtGui.QTabWidget( self.centralWidget ) # Onglet Fichiers self.tabFichiers = QtGui.QSplitter( self.centralWidget ) # L'onglet Fichier contient un splitter self.tabWidget.addTab( self.tabFichiers, u"Choix des fichiers" ) # Onglet Telechargements self.tabTelechargements = QtGui.QWidget( self.centralWidget ) self.tabWidget.addTab( self.tabTelechargements, u"Téléchargements" ) # # Liste des fichiers # # Layout de grille qui contient le tableau qui liste les fichiers + boutons self.gridLayoutFichiers = QtGui.QGridLayout( self.tabFichiers ) # Tableau qui contient la liste des fichiers disponibles pour l'emission courante self.tableWidgetFichier = MyQTableWidget( self.tabFichiers ) # Il a 4 colonnes et 0 ligne (pour l'instant) self.tableWidgetFichier.setColumnCount( 3 ) self.tableWidgetFichier.setRowCount( 0 ) # On ajoute les titres self.tableWidgetFichier.setHorizontalHeaderItem( 0, self.tableWidgetFichier.creerItem( "" ) ) self.tableWidgetFichier.setHorizontalHeaderItem( 1, self.tableWidgetFichier.creerItem( "Date" ) ) self.tableWidgetFichier.setHorizontalHeaderItem( 2, self.tableWidgetFichier.creerItem( "Emission" ) ) # On l'ajoute au layout self.gridLayoutFichiers.addWidget( self.tableWidgetFichier, 0, 1, 6, 1 ) # Icones du tableWidget self.iconeFichier = QtGui.QIcon( "ico/gtk-file.svg" ) self.iconeAjoute = QtGui.QIcon( "ico/gtk-add.svg" ) self.iconeTelecharge = QtGui.QIcon( "ico/gtk-apply.svg" ) # Bouton pour ajouter tous les fichiers a la liste des telechargements self.pushButtonToutAjouter = MyQPushButton( self.tabFichiers ) self.pushButtonToutAjouter.setIcon( QtGui.QIcon( "ico/gtk-add.svg" ) ) self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements" ) self.gridLayoutFichiers.addWidget( self.pushButtonToutAjouter, 0, 0, 2, 1 ) # Bouton pour rafraichir le plugin courant self.pushButtonRafraichirPlugin = MyQPushButton( self.tabFichiers ) self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) ) self.pushButtonRafraichirPlugin.setToolTip( "Rafraichir le plugin" ) self.gridLayoutFichiers.addWidget( self.pushButtonRafraichirPlugin, 2, 0, 2, 1 ) # Bouton pour ouvrir la fenetre des preferences du plugin courant self.pushButtonPreferencesPlugin = MyQPushButton( self.tabFichiers ) self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) ) self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin" ) self.gridLayoutFichiers.addWidget( self.pushButtonPreferencesPlugin, 4, 0, 2, 1 ) # On met en place ce layout sur un widget (pour le splitter) self.widgetFichiers = QtGui.QWidget() self.widgetFichiers.setLayout( self.gridLayoutFichiers ) # # Descriptif des fichiers # # Layout de grille self.gridLayoutDescriptif = QtGui.QGridLayout() # Label pour afficher un logo self.logoFichierDefaut = QtGui.QPixmap() self.logoFichierDefaut.load( "img/gtk-dialog-question.svg" ) self.labelLogo = QtGui.QLabel( self.centralWidget ) self.labelLogo.setPixmap( self.logoFichierDefaut.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) ) self.gridLayoutDescriptif.addWidget( self.labelLogo, 0, 0, 1, 1 ) # Zone de texte pour afficher un descriptif self.plainTextEdit = QtGui.QPlainTextEdit( self.centralWidget ) self.gridLayoutDescriptif.addWidget( self.plainTextEdit, 0, 1, 1, 2 ) # On met en place ce layout sur un widget (pour le splitter) self.widgetDescriptif = QtGui.QWidget() self.widgetDescriptif.setLayout( self.gridLayoutDescriptif ) # Onrientation verticale du splitter self.tabFichiers.setOrientation( QtCore.Qt.Vertical ) # On ajoute les 2 elements au splitter (qui est notre onglet) self.tabFichiers.addWidget( self.widgetFichiers ) self.tabFichiers.addWidget( self.widgetDescriptif ) # # Liste des telechargements # # Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller self.gridLayoutTelechargement = QtGui.QGridLayout( self.tabTelechargements ) # Tableau qui contient la liste des fichiers a telecharger self.tableWidgetTelechargement = MyQTableWidget( self.tabTelechargements ) # Il a 5 colonnes et 0 ligne (pour l'instant) self.tableWidgetTelechargement.setColumnCount( 3 ) self.tableWidgetTelechargement.setRowCount( 0 ) # On ajoute le titre des 5 colonnes self.tableWidgetTelechargement.setHorizontalHeaderItem( 0, self.tableWidgetTelechargement.creerItem( "Date" ) ) self.tableWidgetTelechargement.setHorizontalHeaderItem( 1, self.tableWidgetTelechargement.creerItem( "Emission" ) ) self.tableWidgetTelechargement.setHorizontalHeaderItem( 2, self.tableWidgetTelechargement.creerItem( "Etat" ) ) # On l'ajoute au layout self.gridLayoutTelechargement.addWidget( self.tableWidgetTelechargement, 0, 1, 4, 1 ) # Bouton pour monter l'element selectionne tout en haut de la liste self.pushButtonExtremiteMonter = MyQPushButton( self.tabTelechargements ) self.pushButtonExtremiteMonter.setIcon( QtGui.QIcon( "ico/gtk-jump-to-rtl.svg" ) ) self.pushButtonExtremiteMonter.setToolTip( u"Placer l'élément sélectionné tout en haut" ) self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteMonter, 0, 0, 1, 1 ) # Bouton pour monter l'element selectionne d'un cran dans la liste self.pushButtonMonter = MyQPushButton( self.tabTelechargements ) self.pushButtonMonter.setIcon( QtGui.QIcon( "ico/gtk-go-up.svg" ) ) self.pushButtonMonter.setToolTip( u"Monter l'élément sélectionné" ) self.gridLayoutTelechargement.addWidget( self.pushButtonMonter, 1, 0, 1, 1 ) # Bouton pour descendre l'element selectionne d'un cran dans la liste self.pushButtonDescendre = MyQPushButton( self.tabTelechargements ) self.pushButtonDescendre.setIcon( QtGui.QIcon( "ico/gtk-go-down.svg" ) ) self.pushButtonDescendre.setToolTip( u"Descendre l'élément selectionné" ) self.gridLayoutTelechargement.addWidget( self.pushButtonDescendre, 2, 0, 1, 1 ) # Bouton pour descendre l'element selectionne tout en bas de la liste self.pushButtonExtremiteDescendre = MyQPushButton( self.tabTelechargements ) self.pushButtonExtremiteDescendre.setIcon( QtGui.QIcon( "ico/gtk-jump-to-ltr.svg" ) ) self.pushButtonExtremiteDescendre.setToolTip( u"Placer l'élément sélectionné tout en bas" ) self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteDescendre, 3, 0, 1, 1 ) # Bouton pour supprimer tous les elements de la liste self.pushButtonToutSupprimer = MyQPushButton( self.tabTelechargements ) self.pushButtonToutSupprimer.setIcon( QtGui.QIcon( "ico/gtk-cancel.svg" ) ) self.pushButtonToutSupprimer.setToolTip( u"Supprimer tous les téléchargements" ) self.gridLayoutTelechargement.addWidget( self.pushButtonToutSupprimer, 0, 2, 1, 1 ) # Bouton pour supprimer de la liste les telechargements termines self.pushButtonNettoyer = MyQPushButton( self.tabTelechargements ) self.pushButtonNettoyer.setIcon( QtGui.QIcon( "ico/gtk-delete-full.svg" ) ) self.pushButtonNettoyer.setToolTip( u"Supprimer les téléchargement terminés" ) self.gridLayoutTelechargement.addWidget( self.pushButtonNettoyer, 1, 2, 1, 1 ) # Bouton pour ouvrir le dossier des telechargements self.pushButtonOuvrirDossierTelechargement = MyQPushButton( self.tabTelechargements ) self.pushButtonOuvrirDossierTelechargement.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) ) self.pushButtonOuvrirDossierTelechargement.setToolTip( u"Ouvrir le dossier des téléchargements" ) self.gridLayoutTelechargement.addWidget( self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1 ) # # Barre progression de telechargement d'un fichier # self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget ) self.progressBarTelechargementFichier.setProperty( "value", 0 ) # # Barre de progression de telechargement des fichiers # self.progressBarTelechargement = QtGui.QProgressBar( self.centralWidget ) self.progressBarTelechargement.setProperty( "value", 0 ) # # Boutons du bas pour gerer ajouter/supprimer/lancer telechargements # # Layout horizontal qui contiendra les boutons self.horizontalLayoutBarreBas = QtGui.QHBoxLayout() # Bouton pour lancer les telechargements self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ), u"Lancer téléchargement", self.centralWidget ) self.horizontalLayoutBarreBas.addWidget( self.pushButtonLancer ) # Bouton pour stopper les telechargements self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-stop.svg" ), u"Stopper le téléchargement", self.centralWidget ) self.pushButtonStop.setEnabled( False ) self.horizontalLayoutBarreBas.addWidget( self.pushButtonStop ) ### # Positionnement des differents widgets/layouts sur le layout de grille ### # Layout de grille dans lequel on va placer nos widgets/layouts self.gridLayout = QtGui.QGridLayout( self.centralWidget ) # On ajoute la barre du haut self.gridLayout.addLayout( self.horizontalLayoutBarreHaut, 0, 0, 1, 3 ) # On ajoute le gestionnaire d'onglets self.gridLayout.addWidget( self.tabWidget, 1, 0, 1, 3 ) # On ajoute la barre de progression de telechargement d'un fichier self.gridLayout.addWidget( self.progressBarTelechargementFichier, 2, 0, 1, 3 ) # On ajoute la barre de progression de telechargement des fichiers self.gridLayout.addWidget( self.progressBarTelechargement, 3, 0, 1, 3 ) # On ajoute les boutons ajouter/supprimer/lancer self.gridLayout.addLayout( self.horizontalLayoutBarreBas, 4, 0, 1, 3 ) ### # Mise en place le central widget dans la fenetre ### self.setCentralWidget( self.centralWidget ) ### # Mise en place du menu ### # Menu barre self.menubar = QtGui.QMenuBar( self ) self.menubar.setGeometry( QtCore.QRect( 0, 0, 480, 25 ) ) # Menu Fichier self.menuFichier = QtGui.QMenu( "&Fichier", self.menubar ) self.menubar.addAction( self.menuFichier.menuAction() ) # Action Fichier -> Quitter self.actionQuitter = QtGui.QAction( QtGui.QIcon( "ico/gtk-quit.svg" ), "&Quitter", self ) self.actionQuitter.setIconVisibleInMenu( True ) self.menuFichier.addAction( self.actionQuitter ) # Menu Edition self.menuEdition = QtGui.QMenu( "&Edition", self.menubar ) self.menubar.addAction( self.menuEdition.menuAction() ) # Action Edition -> Mise a jour self.actionMAJ = QtGui.QAction( QtGui.QIcon( "ico/gtk-refresh.svg" ), u"&Mise à jour des plugins", self ) self.actionMAJ.setIconVisibleInMenu( True ) self.menuEdition.addAction( self.actionMAJ ) # Action Edition -> Preferences self.actionPreferences = QtGui.QAction( QtGui.QIcon( "ico/gtk-preferences.svg" ), u"&Préférences", self ) self.actionPreferences.setIconVisibleInMenu( True ) self.menuEdition.addAction( self.actionPreferences ) # Menu Aide self.menuAide = QtGui.QMenu( "&Aide", self.menubar ) self.menubar.addAction( self.menuAide.menuAction() ) # Action Aide -> A propos self.actionAPropos = QtGui.QAction( QtGui.QIcon( "ico/gtk-about.svg" ), u"À p&ropos", self ) self.actionAPropos.setIconVisibleInMenu( True ) self.menuAide.addAction( self.actionAPropos ) # Ajout du menu a l'interface self.setMenuBar( self.menubar ) ### # Signaux provenants de l'interface ### QtCore.QObject.connect( self.tableWidgetFichier, QtCore.SIGNAL( "cellClicked(int,int)" ), self.afficherInformationsFichier ) QtCore.QObject.connect( self.tableWidgetFichier, QtCore.SIGNAL( "cellDoubleClicked(int,int)" ), self.gererTelechargement ) QtCore.QObject.connect( self.pushButtonToutAjouter, QtCore.SIGNAL( "clicked()" ), self.ajouterTousLesFichiers ) QtCore.QObject.connect( self.pushButtonRafraichirPlugin, QtCore.SIGNAL( "clicked()" ), self.rafraichirPlugin ) QtCore.QObject.connect( self.tableWidgetTelechargement, QtCore.SIGNAL( "cellDoubleClicked(int,int)" ), self.supprimerTelechargement ) QtCore.QObject.connect( self.pushButtonExtremiteMonter, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = True, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonMonter, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = True, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonDescendre, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = False, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonExtremiteDescendre, QtCore.SIGNAL( "clicked()" ), lambda versLeHaut = False, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) ) QtCore.QObject.connect( self.pushButtonToutSupprimer, QtCore.SIGNAL( "clicked()" ), self.supprimerTousLesTelechargements ) QtCore.QObject.connect( self.pushButtonNettoyer, QtCore.SIGNAL( "clicked()" ), self.nettoyer ) QtCore.QObject.connect( self.pushButtonLancer, QtCore.SIGNAL( "clicked()" ), self.lancerTelechargement ) QtCore.QObject.connect( self.pushButtonStop, QtCore.SIGNAL( "clicked()" ), self.stopperTelechargement ) QtCore.QObject.connect( self.actionQuitter, QtCore.SIGNAL( "triggered()" ), self.close ) ################################################ # Instanciations + initialisation de variables # ################################################ # Fenetre About self.aProposDialog = None # Fenetre des preferences du logiciel self.preferencesDialog = None # Fenetre de mise a jour des plugins self.updateManagerDialog = None # Nom plugin courant self.nomPluginCourant = "" # Liste des fichiers self.listeFichiers = [] # Liste des fichiers a telecharger self.listeFichiersATelecharger = [] # Cache des images descriptive # Clef : urlImage Valeur : image (binaire) self.cacheImage = {} # On intancie le lanceur de signaux self.signaux = Signaux() # On instancie le gestionnaire de preferences self.preferences = Preferences() # On instancie le gestionnaire de preferences des plugins self.preferencesPluginDialog = PreferencePluginDialog( self ) # On instancie le gestionnaire de download self.downloader = Downloader( self.signaux ) # On recupere l'instance de API self.api = API.getInstance() # On instancie le gestionnaire d'historique self.historique = Historique() # On instancie la fenetre d'attente self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog( self ) # On instancie le gest # # Fenetre de confirmation pour quitter le logiciel # self.quitterMessageBox = QtGui.QMessageBox( self ) self.quitterMessageBox.setWindowTitle( "Fermeture de TVDownloader" ) self.quitterMessageBox.setText( u"Voulez-vous réellement quitter TVDownloader ?" ) self.quitterMessageBox.setInformativeText( u"Votre liste de téléchargement sera perdue" ) self.quitterMessageBox.addButton( "Oui", QtGui.QMessageBox.AcceptRole ) self.quitterMessageBox.addButton( "Non", QtGui.QMessageBox.RejectRole ) ############################################################ # On connecte les signaux des instances precedements crees # ############################################################ QtCore.QObject.connect( self.pushButtonOuvrirDossierTelechargement, QtCore.SIGNAL( "clicked()" ), self.ouvrirRepertoireTelechargement ) QtCore.QObject.connect( self.comboBoxSite, QtCore.SIGNAL( "activated(QString)" ), self.listerChaines ) QtCore.QObject.connect( self.comboBoxChaine, QtCore.SIGNAL( "activated(QString)" ), self.listerEmissions ) QtCore.QObject.connect( self.comboBoxEmission, QtCore.SIGNAL( "activated(QString)" ), self.listerFichiers ) QtCore.QObject.connect( self.pushButtonPreferencesPlugin, QtCore.SIGNAL( "clicked()" ), self.ouvrirPreferencesPlugin ) QtCore.QObject.connect( self.actionPreferences, QtCore.SIGNAL( "triggered()" ), self.ouvrirPreferencesLogiciel ) QtCore.QObject.connect( self.actionMAJ, QtCore.SIGNAL( "triggered()" ), self.ouvrirFenetreMiseAJour ) QtCore.QObject.connect( self.actionAPropos, QtCore.SIGNAL( "triggered()" ), self.ouvrirFenetreAPropos ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ) , self.fenetreAttenteProgressDialog.ouvrirFenetreAttente ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finActualisation()" ) , self.fenetreAttenteProgressDialog.fermerFenetreAttente ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "actualiserListesDeroulantes()" ) , self.actualiserListesDeroulantes ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" ) , self.ajouterChaines ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeEmissions(PyQt_PyObject)" ) , self.ajouterEmissions ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" ) , self.ajouterFichiers ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "nouvelleImage(PyQt_PyObject)" ) , self.mettreEnPlaceImage ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutTelechargement(int)" ) , self.debutTelechargement ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finTelechargement(int)" ) , self.finTelechargement ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finDesTelechargements()" ) , self.activerDesactiverInterface ) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "pourcentageFichier(int)" ) , self.progressBarTelechargementFichier.setValue ) ######### # Début # ######### # La fenetre prend la dimension qu'elle avait a sa fermeture taille = self.preferences.getPreference( "tailleFenetre" ) self.resize( taille[ 0 ], taille[ 1 ] ) # Si aucun plugin n'est active, on ouvre la fenetre des preferences if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ): self.ouvrirPreferencesLogiciel() # On actualise tous les plugins self.rafraichirTousLesPlugins()
class Plugin(MooseWidget): """ A base class for all plugin objects. A plugin object are stand-alone widgets contained by a peacock tab. In general, the plugins should be independent and be able to be removed or added to a given tab. Plugins are stored Manager objects. see Manager.py """ def __init__(self, layout='MainLayout', settings_key="", **kwargs): super(Plugin, self).__init__() # Name of layout that this plugin should be added (see PluginManager.py) self._main_layout_name = layout # The default size policy self.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) # Must be a QtWidget if not isinstance(self, QtWidgets.QWidget): mooseutils.mooseError("A Plugin must also be a QWidget.") return # The Peacock tab index self._index = None self._plugin_manager = None self._preferences = Preferences(settings_key) @staticmethod def commandLineArgs(parser): """ Allows the plugin to add command line options to the parser. """ def setup(self): """ Adds automatic Preference callback connection to the setup method. """ super(Plugin, self).setup() for key, widget in self._preferences._widgets.iteritems(): name = key.split('/')[-1] name = '_prefCallback{}{}'.format(name[0].upper(), name[1:]) callback = getattr(self, name, None) if callback: widget.valueSaved.connect(callback) def connect(self, other): """ Connect the slots of supplied plugin (other) to the signals emited by this (self) plugin. Args: other[Plugin]: A plugin object to connect. """ if self is not other: for name, signal in self.signals().iteritems(): slot_name = 'on' + name[0].upper() + name[1:] if hasattr(other, slot_name): mooseutils.mooseDebug('{}.{} --> {}.{}'.format(self.__class__.__name__, name, other.__class__.__name__, slot_name)) signal.connect(getattr(other, slot_name)) def setMainLayoutName(self, name): """ Method for changing the name of the main layout that this plugin will be added. Args: name[str]: The name of the layout within the PluginManager. """ self._main_layout_name = name def mainLayoutName(self): """ Return the name of the layout within the PluginManager that this plugin is to be added. """ return self._main_layout_name def repr(self): """ Return data for reproducing the plugin as a script. """ return dict() def canClose(self): """ Called when the application wants to close. This is intended to allow the plugin to check if it has unsaved state and ask the user if they want to cancel the close or throw away the changes. Return: bool: Whether it is OK to close """ return True def closing(self): """ Called when the application is about to close. This is intended to allow the plugin to do any cleanup before closing """ pass def onPreferencesSaved(self): """ Called when the preferences have been saved. """ def clearRecentlyUsed(self): """ Clears any recently used items """ def addToMenu(self, menu): pass def addToMainMenu(self, menubar): """ This allows the plugin to add menu items to the main menu. Args: menubar[QMenuBar]: Menubar to add items to """ pass def onCurrentChanged(self, index): """ Executes when the TabWidget (TabPluginManager) changes active tabs. Inputs: index[int]: The index of the active tab """ pass def setTabIndex(self, index, signal=None): """ Set the Peacock Tab index (see TabPluginManager) """ if signal: signal.connect(self.onCurrentChanged) self._index = index def preferenceWidgets(self): return self._preferences.widgets() def setupMenu(self, menu): pass
def showPreferences(self): dlg = Preferences() dlg.exec_()
class Manager(object): def __init__(self): self._preferences = None self.__servers = None return def init(self): self._preferences = Preferences() if constants.IS_DEVELOPMENT: self.__servers = DevelopmentServers(self._preferences) else: self.__servers = Servers(self._preferences) connectionManager.onLoggedOn += self._onLoggedOn def fini(self): connectionManager.onLoggedOn -= self._onLoggedOn self._preferences = None self.__servers.fini() self.__servers = None return def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser): authMethod = CONNECTION_METHOD.BASIC self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session']) self._preferences['password_length'] = len(password) self._preferences['remember_user'] = rememberUser self._preferences['login'] = email self._preferences['server_name'] = serverName loginParams = {'login': self._preferences['login'], 'session': self._preferences['session'], 'temporary': str(int(not rememberUser)), 'auth_method': authMethod} if isSocialToken2Login or self._preferences['token2']: loginParams['auth_method'] = CONNECTION_METHOD.TOKEN2 loginParams['token2'] = self._preferences['token2'] if isSocialToken2Login: self._preferences['login_type'] = self._preferences['login_type'] else: self._preferences['login_type'] = 'credentials' connectionManager.initiateConnection(loginParams, password, serverName) def getPreference(self, key): return self._preferences[key] def clearPreferences(self): self._preferences.clear() def clearToken2Preference(self): self._preferences['token2'] = '' def writePreferences(self): self._preferences.writeLoginInfo() @property def servers(self): return self.__servers def _onLoggedOn(self, responseData): name = responseData.get('name', 'UNKNOWN') token2 = responseData.get('token2', '') g_lobbyContext.setCredentials(name, token2) if self._preferences['remember_user']: self._preferences['name'] = name self._preferences['token2'] = token2 if not constants.IS_DEVELOPMENT: del self._preferences['server_name'] else: email = self._preferences['login'] serverName = self._preferences['server_name'] session = self._preferences['session'] self._preferences.clear() if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset: self._preferences['login'] = email if constants.IS_DEVELOPMENT: self._preferences['server_name'] = serverName self._preferences['session'] = session self._preferences.writeLoginInfo() self._showSecurityMessage(responseData) def _showSecurityMessage(self, responseData): securityWarningType = responseData.get('security_msg') if securityWarningType is not None: securityLink = '' if not GUI_SETTINGS.isEmpty('securitySettingsURL'): securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS), 'linkType': 'securityLink'}) SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink) return
def make_from_preferences(cls, preferences: Preferences): """Create a DataModel instance from the saved preferences""" model = DataModel() model.set_default_frame_count(preferences.get_default_frame_count()) model.set_target_adus(preferences.get_target_adus()) model.set_adu_tolerance(preferences.get_adu_tolerance()) model.set_server_address(preferences.get_server_address()) model.set_port_number(preferences.get_port_number()) model.set_warm_when_done(preferences.get_warm_when_done()) model.set_use_filter_wheel(preferences.get_use_filter_wheel()) model.set_filter_specs(preferences.get_filter_spec_list()) model.set_binning_specs(preferences.get_binning_spec_list()) model.set_save_files_locally(False) model.set_flat_frame_count_table( FlatFrameTable(preferences.get_default_frame_count(), preferences.get_filter_spec_list(), preferences.get_binning_spec_list())) model.set_source_alt(float(preferences.get_source_alt())) model.set_source_az(float(preferences.get_source_az())) model.set_dither_flats(bool(preferences.get_dither_flats())) model.set_dither_radius(float(preferences.get_dither_radius())) model.set_dither_max_radius(float(preferences.get_dither_max_radius())) return model
class Pysciplot(QMainWindow): """ This class initializes the PySciPlot program. """ def __init__(self): QMainWindow.__init__(self) Util.debug(2, "App", "Setting up UI") self.ui = Ui_MainWindow() self.ui.setupUi(self) def setup(self): """ Setup the application. """ # Variables Util.debug(2, "App", "Initializing variables") self._version = 1 self._loadedModules = {} self.setDefaults() # Let the workspace resize when the main window is resized self.setCentralWidget(self.ui.workspace) # Make signal/slot connections Util.debug(2, "App", "Connecting signals and slots") self.ui.actionQuit.triggered.connect(self.close) self.ui.actionNew_Project.triggered.connect(self.newProjectSlot) self.ui.actionLoad_Project.triggered.connect(self.loadProjectSlot) self.ui.actionSave_Project.triggered.connect(self.saveProject) self.ui.actionSave_Project_As.triggered.connect(self.saveProjectAs) self.ui.actionSave_Current_Figure.triggered.connect(self.saveCurrentFigure) self.ui.actionPreferences.triggered.connect(self.preferences.showDialog) self.ui.actionShow_Waves.triggered.connect(self.printAllWaves) self.ui.actionShow_Figures.triggered.connect(self.printAllFigures) Util.debug(2, "App", "Loading modules") for moduleName in modules.__all__: module = eval(moduleName + "." + moduleName + "()") module.load() self._loadedModules[moduleName] = module def setDefaults(self): """ Setup parts of the application that have some sort of default. Intended to be used when creating a new project to reset the application to a blank slate. """ # Remove or hide any windows subWindows = self.ui.workspace.subWindowList() for window in subWindows: if type(window).__name__ in ["DataTableSubWindow", "FigureSubWindow"]: window.setAttribute(Qt.WA_DeleteOnClose) window.close() else: window.setVisible(False) # Remove signals try: self.waves().waveAdded.disconnect(self.model('appWaves').appendRow) except: pass try: self.waves().allWavesRemoved.disconnect(self.model('appWaves').removeAllWaves) except: pass # Set variables self._waves = Waves() self._figures = Figures() self._models = {} self.projectDir = "" # current project directory self.setCurrentProject("") self._storedSettings = {} # this is a dict with widgetName: list pairs # where each list has [setting-name, setting-value] pairs # setting-value is a dict with (property-name: Property) pairs # Load Preferences Util.debug(2, "App", "Loading Preferences from file") self.preferences = Preferences("~/.pysciplotrc") # Create application-wide models self._models['appWaves'] = WavesListModel(self.waves().waveNames()) # Signals self.waves().waveAdded.connect(self.model('appWaves').appendRow) self.waves().allWavesRemoved.connect(self.model('appWaves').removeAllWaves) # Reload modules for module in self._loadedModules.values(): module.reload() def waves(self): """ Return the app's Waves object. NOT A LIST OF WAVES. """ return self._waves def figures(self): """ Return the app's Figures object. NOT A LIST OF FIGURES. """ return self._figures def storedSettings(self): """ Return the storedSettings dict. """ return self._storedSettings def models(self): """ Return the models dict. """ return self._models def model(self, name): """ Return a specific model from the models dict. """ return self._models[name] def createTable(self, waves=[], tableName="Table"): """ Create a table. """ Util.debug(2, "App.createTable", "Creating a table") model = DataTableModel(waves, self) # Connect slots self.waves().waveRemoved[Wave].connect(model.removeWave) self.waves().allWavesRemoved.connect(model.removeAllWaves) return self.createDataTableView(model, tableName) def createDataTableView(self, tableModel, tableName="Table"): """ Create a table view based on the given model. """ tableViewSubWindow = DataTableSubWindow(self.ui.workspace) tableView = QDataTableView(tableModel, tableName, tableViewSubWindow) tableViewSubWindow.setWidget(tableView) tableViewSubWindow.setAttribute(Qt.WA_DeleteOnClose) tableViewSubWindow.resize(600, 300) self.ui.workspace.addSubWindow(tableViewSubWindow) tableViewSubWindow.setVisible(True) return tableViewSubWindow def saveProjectAs(self): """ Save the current project to a file which will be selected by the user. """ Util.debug(2, "App.saveProjectAs", "Saving project as") fileName = str(QFileDialog.getSaveFileName(self.ui.workspace, "Save Project", self.projectDirectory(), "PySciPlot Project (*.psp);;All Files (*)")) Save.writeProjectToFile(self, fileName) def saveProject(self): """ Save the current project to a file. If project has previously been saved, use that location. """ Util.debug(2, "App.saveProject", "Saving project") if self.currentProjectFile != "" and QFile.exists(self.currentProjectFile): Save.writeProjectToFile(self, self.currentProjectFile) else: self.saveProjectAs() def loadProjectSlot(self): """ Slot to pick up menu selection and run loadProject. Required because of different parameters. """ self.loadProject() def loadProject(self, fileName="", confirmReset=True): """ Load a project from a file which will be selected by the user. """ Util.debug(2, "App.loadProject", "Loading project from file " + str(fileName)) # Reset app to a clean slate self.resetToDefaults(confirmReset) # Now load the project if fileName == "": fileDialog = QFileDialog(self.ui.workspace, "Load Project") fileDialog.setNameFilter("PySciPlot Project (*.psp);;All Files (*)") fileDialog.setDefaultSuffix("psp") fileDialog.setConfirmOverwrite(False) fileDialog.setDirectory(self.projectDirectory()) fileDialog.setAcceptMode(QFileDialog.AcceptOpen) fileDialog.exec_() fileName = str(fileDialog.selectedFiles()[0]) Load.loadProjectFromFile(self, fileName) def newProjectSlot(self): """ Slot to pick up menu selection and create a new project. Required because of different parameters. """ Util.debug(2, "App.newProject", "Creating new project") self.resetToDefaults(True) def resetToDefaults(self, confirm=True): """ Reset the application to the defaults. At the very least, this will delete all waves, tables, and figures. Before resetting, this will ask the user if they want to save the current project. """ Util.debug(2, "App.resetToDefaults", "Resetting application to defaults") if confirm: # Check to see if we want to save the current project saveProjectMessage = QMessageBox() saveProjectMessage.setText("You are about to load another project.") saveProjectMessage.setInformativeText("Do you want to save your current project?") saveProjectMessage.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel) saveProjectResponse = saveProjectMessage.exec_() if saveProjectResponse == QMessageBox.Save: self.saveProject() elif saveProjectResponse == QMessageBox.Cancel: return # Now reset to a clean slate self.setDefaults() def setCurrentProject(self, fileName): Util.debug(3, "App.setCurrentProject", "Setting current project title") self.currentProjectFile = fileName if fileName != "": self.setWindowTitle("PySciPlot - " + fileName) else: self.setWindowTitle("PySciPlot") def projectDirectory(self): if os.path.isdir(self.projectDir): return self.projectDir return self.preferences.getInternal('projectDirectory') def saveCurrentFigure(self): """ Save the current figure to a file. First we make sure that the active window has a figure in it. Then we ask the user for certain options to be set. Then we ask for the file to save the figure to. Then we save the file. """ Util.debug(2, "App.saveCurrentFigure", "Saving current Figure") currentWindow = self.ui.workspace.activeSubWindow() # Check if the active window has a figure in it if type(currentWindow).__name__ != "FigureSubWindow": notFigureMessage = QMessageBox() notFigureMessage.setText("The active window is not a figure, so you cannot save it as a figure.") notFigureMessage.exec_() return False # Ask user for user-configurable options figureOptionsDialog = QDialog() figureOptionsUi = Ui_SaveFigureOptionsDialog() figureOptionsUi.setupUi(figureOptionsDialog) figureOptionsSubWindow = self.ui.workspace.addSubWindow(figureOptionsDialog) figureOptionsResult = figureOptionsDialog.exec_() figureOptionsSubWindow.close() dpi = 100 orientation = "Landscape" if figureOptionsResult == QDialog.Accepted: dpi = Util.getWidgetValue(figureOptionsUi.dpi) orientation = Util.getWidgetValue(figureOptionsUi.orientation) else: return False # As user for the filename to save to fileName = QFileDialog.getSaveFileName(self.ui.workspace, "Save Figure", self.projectDirectory()) # Save the figure to the file currentWindow.widget().figure.savefig(str(fileName), dpi=dpi, orientation=orientation) ###################### # temporary methods, for testing ###################### def createDefaultTable(self): waveNames = self.model('appWaves').orderedWaveNames() waves = [] for waveName in waveNames: waves.append(self.waves().wave(waveName)) return self.createTable(waves) def printAllWaves(self): print self._waves def printAllFigures(self): print self._figures def setTestData(self): self._waves.addWave(Wave("Wave1", "Integer", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) self._waves.addWave(Wave("Wave2", "Integer", [0, 1, 4, 9, 4, 1, 0, 1, 4, 9])) self._waves.addWave(Wave("Wave3", "Integer", [0, 1, 3, 1, 3, 1, 3, 1, 3, 1])) self._waves.addWave(Wave("Wave4", "Integer", [4, 3, 2, 1, 0, 1, 2, 3, 4, 5]))
def __init__(self, pixels, numPixels, name): threading.Thread.__init__(self) self.preferences = Preferences() self.pixels = pixels self.numPixels = numPixels self.name = name
def __init__(self, preferences: Preferences, data_model: DataModel): """ Initialize the main window controller :param preferences: Preferences object for application defaults :param data_model: Data model object for the current run """ self._preferences = preferences self._data_model = data_model QMainWindow.__init__(self) self.ui = uic.loadUi( MultiOsUtil.path_for_file_in_program_directory("MainWindow.ui")) self._field_validity: {object, bool} = {} self._table_model: FitsFileTableModel self._indent_level = 0 self._adu_values_known = False # Load algorithm from preferences algorithm = data_model.get_master_combine_method() if algorithm == Constants.COMBINE_MEAN: self.ui.combineMeanRB.setChecked(True) elif algorithm == Constants.COMBINE_MEDIAN: self.ui.combineMedianRB.setChecked(True) elif algorithm == Constants.COMBINE_MINMAX: self.ui.combineMinMaxRB.setChecked(True) else: assert (algorithm == Constants.COMBINE_SIGMA_CLIP) self.ui.combineSigmaRB.setChecked(True) self.ui.minMaxNumDropped.setText( str(data_model.get_min_max_number_clipped_per_end())) self.ui.sigmaThreshold.setText( str(data_model.get_sigma_clip_threshold())) # Load disposition from preferences disposition = data_model.get_input_file_disposition() if disposition == Constants.INPUT_DISPOSITION_SUBFOLDER: self.ui.dispositionSubFolderRB.setChecked(True) else: assert (disposition == Constants.INPUT_DISPOSITION_NOTHING) self.ui.dispositionNothingRB.setChecked(True) self.ui.subFolderName.setText( data_model.get_disposition_subfolder_name()) # Pre-calibration options precalibration_option = data_model.get_precalibration_type() if precalibration_option == Constants.CALIBRATION_FIXED_FILE: self.ui.fixedPreCalFileRB.setChecked(True) elif precalibration_option == Constants.CALIBRATION_NONE: self.ui.noPreClalibrationRB.setChecked(True) elif precalibration_option == Constants.CALIBRATION_AUTO_DIRECTORY: self.ui.autoPreCalibrationRB.setChecked(True) else: assert precalibration_option == Constants.CALIBRATION_PEDESTAL self.ui.fixedPedestalRB.setChecked(True) self.ui.fixedPedestalAmount.setText( str(data_model.get_precalibration_pedestal())) self.ui.precalibrationPathDisplay.setText( os.path.basename(data_model.get_precalibration_fixed_path())) self.ui.autoDirectoryName.setText( os.path.basename(data_model.get_precalibration_auto_directory())) self.ui.autoRecursive.setChecked( data_model.get_auto_directory_recursive()) self.ui.autoBiasOnly.setChecked( data_model.get_auto_directory_bias_only()) self.ui.displayAutoResultsCB.setChecked( data_model.get_display_auto_select_results()) # Grouping boxes and parameters self.ui.groupBySizeCB.setChecked(data_model.get_group_by_size()) self.ui.groupByTemperatureCB.setChecked( data_model.get_group_by_temperature()) self.ui.groupByFilterCB.setChecked(data_model.get_group_by_filter()) self.ui.ignoreSmallGroupsCB.setChecked( data_model.get_ignore_groups_fewer_than()) self.ui.temperatureGroupBandwidth.setText( f"{data_model.get_temperature_group_bandwidth()}") self.ui.minimumGroupSize.setText( str(data_model.get_minimum_group_size())) # Display average ADUs self.ui.displayAvgADUs.setChecked( data_model.get_display_average_adus()) # Set up the file table self._table_model = FitsFileTableModel( self.ui.filesTable, data_model.get_ignore_file_type(), preferences.get_display_average_adus()) self.ui.filesTable.setModel(self._table_model) # Columns should resize to best fit their contents self.ui.filesTable.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) # Write a summary, in the main tab, of the settings from the options tab (and data model) self.fill_options_readout() self.connect_responders() # If a window size is saved, set the window size window_size = self._preferences.get_main_window_size() if window_size is not None: self.ui.resize(window_size) self.enable_fields() self.enable_buttons()
def __init__(self, parent, signaux): # Appel au constructeur de la classe mere QtGui.QDialog.__init__(self, parent) self.preferences = Preferences() self.pluginManager = PluginManager() self.signaux = signaux ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle(u"Préférences") # Dimensions la fenetre self.resize(280, 340) # Mise en place de son icone self.setWindowIcon(QtGui.QIcon("ico/gtk-preferences.svg")) ### # Mise en place des widgets dans la fenetre ### # Layout de grille principal self.gridLayout = QtGui.QGridLayout(self) # Font pour les titres fontTitres = QtGui.QFont() fontTitres.setPointSize(11) fontTitres.setWeight(75) fontTitres.setBold(True) # # Choix du repertoire telechargement # # Label self.labelRepertoire = QtGui.QLabel(self) self.labelRepertoire.setFont(fontTitres) self.labelRepertoire.setText(u"Répertoire de téléchargement :") # Repertoire de telechargement self.lineEditRepertoireTelechargement = QtGui.QLineEdit(self) # Bouton pour ouvrir la fenetre de selection de repertoire self.pushButtonSelectionDossier = QtGui.QPushButton(self) self.pushButtonSelectionDossier.setIcon( QtGui.QIcon("ico/gtk-folder.svg")) # # Choix du plugin par defaut # # Label self.labelPluginDefaut = QtGui.QLabel(self) self.labelPluginDefaut.setFont(fontTitres) self.labelPluginDefaut.setText(u"Plugin par défaut :") # Liste de choix du plugin par defaut self.comboBoxPluginDefaut = QtGui.QComboBox(self) # # Choix des plugins a activer # # Label self.labelPlugins = QtGui.QLabel(self) self.labelPlugins.setFont(fontTitres) self.labelPlugins.setText("Plugins actifs :") # Liste des plugins self.listWidgetPlugin = QtGui.QListWidget(self) # # Choix des parametres Internet # # Label self.labelInternet = QtGui.QLabel(self) self.labelInternet.setFont(fontTitres) self.labelInternet.setText(u"Paramètres Internet :") # Layout formulaire self.layoutInternet = QtGui.QFormLayout() # SpinBox pour choisir le timeOut self.spinBoxTimeOut = QtGui.QSpinBox() self.spinBoxTimeOut.setMinimum(1) self.spinBoxTimeOut.setMaximum(60) self.layoutInternet.addRow(u"Time out (en s) :", self.spinBoxTimeOut) # SpinBox pour choisir le nombre de threads max self.spinBoxNbThread = QtGui.QSpinBox() self.spinBoxNbThread.setMinimum(1) self.spinBoxNbThread.setMaximum(100) self.layoutInternet.addRow(u"Nombre de threads max :", self.spinBoxNbThread) # Bouton pour enregistrer/annuler les preferences self.buttonBox = QtGui.QDialogButtonBox(self) self.buttonBox.addButton("Enregistrer", QtGui.QDialogButtonBox.AcceptRole) self.buttonBox.addButton("Fermer", QtGui.QDialogButtonBox.RejectRole) # On ajoute le tout au layout self.gridLayout.addWidget(self.labelRepertoire, 0, 0, 1, 2) self.gridLayout.addWidget(self.lineEditRepertoireTelechargement, 1, 0, 1, 1) self.gridLayout.addWidget(self.pushButtonSelectionDossier, 1, 1, 1, 1) self.gridLayout.addWidget(self.labelPluginDefaut, 2, 0, 1, 2) self.gridLayout.addWidget(self.comboBoxPluginDefaut, 3, 0, 1, 2) self.gridLayout.addWidget(self.labelPlugins, 4, 0, 1, 2) self.gridLayout.addWidget(self.listWidgetPlugin, 5, 0, 1, 2) self.gridLayout.addWidget(self.labelInternet, 6, 0, 1, 2) self.gridLayout.addLayout(self.layoutInternet, 7, 0, 1, 2) self.gridLayout.addWidget(self.buttonBox, 8, 0, 1, 2) ### # Signaux provenants de l'interface ### QtCore.QObject.connect(self.pushButtonSelectionDossier, QtCore.SIGNAL("clicked()"), self.afficherSelecteurDossier) QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("accepted()"), self.enregistrerPreferences) QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("rejected()"), self.reject)
class Controller(object): """description of class""" def __init__(self): self.prefs = Preferences() self.db = SQLController() self.load_skill_bp_into_prefs() self.__ui_components = {} self.__pc_roster = {} self.__skill_shorts = {} pc_filepaths = [] #pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml') pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml') self.load_pc_roster(pc_filepaths) #print(str(self.__pc_roster['Toni'])) self.prepare_skill_shorts() weapons = self.prefs.transfer_wpns_from_txt_to_sql() wpn_table=self.db.table('wpn_blueprints') skills = self.prefs.get_skills_dictionary() skill_bp_table = self.db.table('skill_blueprints') #self.__wpn_db = WeaponSqlController() self.add_skills_bp_to_db(skills, skill_bp_table) #print(weapons) for weapon in weapons: name = str(weapon.get_attribute('name')) type = str(weapon.get_attribute('type')) wa = str(weapon.get_attribute('wa')) con = str(weapon.get_attribute('con')) av = str(weapon.get_attribute('av')) dmg = str(weapon.get_attribute('dmg')) ammo = str(weapon.get_attribute('ammo')) shts = str(weapon.get_attribute('shts')) rof = str(weapon.get_attribute('rof')) rel = str(weapon.get_attribute('rel')) range = str(weapon.get_attribute('range')) cost = str(weapon.get_attribute('cost')) source = str(weapon.get_attribute('source')) category = str(weapon.get_attribute('category')) wpn_table.add_wpn(name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, category=category, source=source) #wpn_table.print_table() self.load_character('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml') self.db.add_character_to_database(self.c) start = StartMenu(self) #start = SkillShortsInspector(controller=self) def add_skills_bp_to_db(self, skill_list, skill_table): for key, value in skill_list.items(): name = value.get_attribute('name') stat = value.get_attribute('stat') short = value.get_attribute('short') diff = value.get_attribute('diff') category = value.get_attribute('category') description = value.get_attribute('description') chip = value.get_attribute('ischippable') skill_table.add(name, stat, short, diff, category, chip, description) def load_pc_roster(self, filepath_table): for path in filepath_table: c = Character(self.prefs) self.prefs.load_character(path, c) player = c.get_attribute('player') self.__pc_roster[player] = c #print(str(c)) def load_wpn_sql_table(self): wpn = self.db.table('wpn_blueprints') return wpn.query_all() def load_single_sql_wpn(self, name): wpn = self.db.table('wpn_blueprints') return wpn.search_with_name(name) def update_sql_wpn(self, name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, weight, flags, options, alt_munitions, description, category): wpn_table = self.db.table('wpn_blueprints') wpn_table.update_wpn(name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, weight, flags, options, alt_munitions, description, category) def prepare_skill_shorts(self): skills = self.prefs.get_skills_dictionary() for key, value in skills.items(): try: short = value.get_attribute('short') name = value.get_attribute('name') self.__skill_shorts[short] = name except Exception: pass def get_skill_from_short(self, short): try: skill = self.__skill_shorts[short] return skill except Exception: return 'error' def get_pc_roster(self): return self.__pc_roster def load_character(self, filepath): self.c = Character(self.prefs) self.prefs.load_character(filepath,self.c) def get_player_fuz_roll(self, player, detailed=False): search_for = str.strip(player) return self.__pc_roster[search_for].fuz_roll(detailed) def set_char_stat(self, command, value): self.c.set(command, value) def destroy_char_attributes_of_type(self, type, attribute): self.c.remove_all_attributes_of_type(type, attribute) def add_skill_to_char(self, name, lvl, ip, chipped): self.c.add_skill(name, lvl, ip=ip, chipped=chipped) def get_slate_gameobject(self): o = GameObject() return o def get_char_stat(self, name, attribute, search_category=False, return_all=False): if search_category: return self.c.get_stat(name, name, True, return_all) return self.c.get_stat(name, attribute) def get_char_attribute(self, name): return self.c.get_attribute(name) def get_char_stat_list(self, stat_type): return self.c.get_stat_list(stat_type) def get_char_inventory(self): return self.c.get_inventory() def get_char_bp_points(self, player, skill, detailed=False): character = self.__pc_roster[player] array = [] if detailed: source_stat_name = character.get_stat(skill, 'stat') source_stat_lvl = character.get_stat(source_stat_name, 'lvl') skill_lvl = character.get_stat(skill, 'lvl') array.append(source_stat_lvl) array.append(skill_lvl) return array bp = character.get_bpoints(skill) return bp def add_ui_component(self, comp_name, component): self.__ui_components[comp_name] = component def save_to_xml(self, root_name, childname, values_dict, filepath): x = XmlController() x.create_root(root_name) for key, value in values_dict.items(): x.create_sub_element(childname, 'root') x.set_text(value, childname) x.set_value('type',key, childname) x.save_file(filepath) def load_from_xml(self, filename, root_name): x = XmlController() x.load_file(filename) return x.get_dataset(root_name, True, dict_tag_name='type') def calc_dv_probabilities(self, bp, dv): percent = self.prefs.get_probability(bp, dv) return percent def load_skill_bp_into_prefs(self): skill_table = self.db.table('skill_blueprints') skills = skill_table.query_all() for skill in skills: self.prefs.set_skill_blueprint(skill.name, skill.stat, skill.category, skill.description, skill.chip, skill.diff, skill.short) def update_skill_bp_to_db(self): skill_table = self.db.table('skill_blueprints') for key, value in self.prefs.get_skills_dictionary().items(): name = value.get_attribute('name') stat = value.get_attribute('stat') short = value.get_attribute('short') diff = value.get_attribute('diff') category = value.get_attribute('category') description = value.get_attribute('description') chip = value.get_attribute('ischippable') skill_table.update(name, stat, short, diff, category, chip, description) def get_all_skill_blueprints(self): skills_table = self.db.table('skill_blueprints') return skills_table.query_all()
class MainWindow(QtGui.QMainWindow): ## Constructeur # Le constructeur va creer la fenetre principale en y ajoutant tous les widgets necessaires au programme def __init__(self): # Appel au constructeur de la classe mere QtGui.QMainWindow.__init__(self) ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle("TVDownloader") # Mise en place de son icone self.setWindowIcon(QtGui.QIcon("ico/TVDownloader.png")) ### # Mise en place des widgets dans la fenetre ### # Widget central qui contiendra tout self.centralWidget = QtGui.QWidget(self) # # Barre du haut # # Layout horizontal qui contiendra les listes deroulantes self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout() # Liste deroulante pour choisir le site (plugin) self.comboBoxSite = QtGui.QComboBox(self.centralWidget) self.horizontalLayoutBarreHaut.addWidget(self.comboBoxSite) # Liste deroulante pour choisir une chaine du site courant self.comboBoxChaine = QtGui.QComboBox(self.centralWidget) self.horizontalLayoutBarreHaut.addWidget(self.comboBoxChaine) # Liste deroulante pour choisir une emission de la chaine courante self.comboBoxEmission = QtGui.QComboBox(self.centralWidget) self.horizontalLayoutBarreHaut.addWidget(self.comboBoxEmission) # # Onglets # # Gestionnaire onglets self.tabWidget = QtGui.QTabWidget(self.centralWidget) # Onglet Fichiers self.tabFichiers = QtGui.QSplitter( self.centralWidget) # L'onglet Fichier contient un splitter self.tabWidget.addTab(self.tabFichiers, u"Choix des fichiers") # Onglet Telechargements self.tabTelechargements = QtGui.QWidget(self.centralWidget) self.tabWidget.addTab(self.tabTelechargements, u"Téléchargements") # # Liste des fichiers # # Layout de grille qui contient le tableau qui liste les fichiers + boutons self.gridLayoutFichiers = QtGui.QGridLayout(self.tabFichiers) # Tableau qui contient la liste des fichiers disponibles pour l'emission courante self.tableWidgetFichier = MyQTableWidget(self.tabFichiers) # Il a 4 colonnes et 0 ligne (pour l'instant) self.tableWidgetFichier.setColumnCount(3) self.tableWidgetFichier.setRowCount(0) # On ajoute les titres self.tableWidgetFichier.setHorizontalHeaderItem( 0, self.tableWidgetFichier.creerItem("")) self.tableWidgetFichier.setHorizontalHeaderItem( 1, self.tableWidgetFichier.creerItem("Date")) self.tableWidgetFichier.setHorizontalHeaderItem( 2, self.tableWidgetFichier.creerItem("Emission")) # On l'ajoute au layout self.gridLayoutFichiers.addWidget(self.tableWidgetFichier, 0, 1, 6, 1) # Icones du tableWidget self.iconeFichier = QtGui.QIcon("ico/gtk-file.svg") self.iconeAjoute = QtGui.QIcon("ico/gtk-add.svg") self.iconeTelecharge = QtGui.QIcon("ico/gtk-apply.svg") # Bouton pour ajouter tous les fichiers a la liste des telechargements self.pushButtonToutAjouter = MyQPushButton(self.tabFichiers) self.pushButtonToutAjouter.setIcon(QtGui.QIcon("ico/gtk-add.svg")) self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements") self.gridLayoutFichiers.addWidget(self.pushButtonToutAjouter, 0, 0, 2, 1) # Bouton pour rafraichir le plugin courant self.pushButtonRafraichirPlugin = MyQPushButton(self.tabFichiers) self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon("ico/gtk-refresh.svg")) self.pushButtonRafraichirPlugin.setToolTip("Rafraichir le plugin") self.gridLayoutFichiers.addWidget(self.pushButtonRafraichirPlugin, 2, 0, 2, 1) # Bouton pour ouvrir la fenetre des preferences du plugin courant self.pushButtonPreferencesPlugin = MyQPushButton(self.tabFichiers) self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon("ico/gtk-preferences.svg")) self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin") self.gridLayoutFichiers.addWidget(self.pushButtonPreferencesPlugin, 4, 0, 2, 1) # On met en place ce layout sur un widget (pour le splitter) self.widgetFichiers = QtGui.QWidget() self.widgetFichiers.setLayout(self.gridLayoutFichiers) # # Descriptif des fichiers # # Layout de grille self.gridLayoutDescriptif = QtGui.QGridLayout() # Label pour afficher un logo self.logoFichierDefaut = QtGui.QPixmap() self.logoFichierDefaut.load("img/gtk-dialog-question.svg") self.labelLogo = QtGui.QLabel(self.centralWidget) self.labelLogo.setPixmap( self.logoFichierDefaut.scaled(QtCore.QSize(150, 150), QtCore.Qt.KeepAspectRatio)) self.gridLayoutDescriptif.addWidget(self.labelLogo, 0, 0, 1, 1) # Zone de texte pour afficher un descriptif self.plainTextEdit = QtGui.QPlainTextEdit(self.centralWidget) self.gridLayoutDescriptif.addWidget(self.plainTextEdit, 0, 1, 1, 2) # On met en place ce layout sur un widget (pour le splitter) self.widgetDescriptif = QtGui.QWidget() self.widgetDescriptif.setLayout(self.gridLayoutDescriptif) # Onrientation verticale du splitter self.tabFichiers.setOrientation(QtCore.Qt.Vertical) # On ajoute les 2 elements au splitter (qui est notre onglet) self.tabFichiers.addWidget(self.widgetFichiers) self.tabFichiers.addWidget(self.widgetDescriptif) # # Liste des telechargements # # Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller self.gridLayoutTelechargement = QtGui.QGridLayout( self.tabTelechargements) # Tableau qui contient la liste des fichiers a telecharger self.tableWidgetTelechargement = MyQTableWidget( self.tabTelechargements) # Il a 5 colonnes et 0 ligne (pour l'instant) self.tableWidgetTelechargement.setColumnCount(3) self.tableWidgetTelechargement.setRowCount(0) # On ajoute le titre des 5 colonnes self.tableWidgetTelechargement.setHorizontalHeaderItem( 0, self.tableWidgetTelechargement.creerItem("Date")) self.tableWidgetTelechargement.setHorizontalHeaderItem( 1, self.tableWidgetTelechargement.creerItem("Emission")) self.tableWidgetTelechargement.setHorizontalHeaderItem( 2, self.tableWidgetTelechargement.creerItem("Etat")) # On l'ajoute au layout self.gridLayoutTelechargement.addWidget(self.tableWidgetTelechargement, 0, 1, 4, 1) # Bouton pour monter l'element selectionne tout en haut de la liste self.pushButtonExtremiteMonter = MyQPushButton(self.tabTelechargements) self.pushButtonExtremiteMonter.setIcon( QtGui.QIcon("ico/gtk-jump-to-rtl.svg")) self.pushButtonExtremiteMonter.setToolTip( u"Placer l'élément sélectionné tout en haut") self.gridLayoutTelechargement.addWidget(self.pushButtonExtremiteMonter, 0, 0, 1, 1) # Bouton pour monter l'element selectionne d'un cran dans la liste self.pushButtonMonter = MyQPushButton(self.tabTelechargements) self.pushButtonMonter.setIcon(QtGui.QIcon("ico/gtk-go-up.svg")) self.pushButtonMonter.setToolTip(u"Monter l'élément sélectionné") self.gridLayoutTelechargement.addWidget(self.pushButtonMonter, 1, 0, 1, 1) # Bouton pour descendre l'element selectionne d'un cran dans la liste self.pushButtonDescendre = MyQPushButton(self.tabTelechargements) self.pushButtonDescendre.setIcon(QtGui.QIcon("ico/gtk-go-down.svg")) self.pushButtonDescendre.setToolTip(u"Descendre l'élément selectionné") self.gridLayoutTelechargement.addWidget(self.pushButtonDescendre, 2, 0, 1, 1) # Bouton pour descendre l'element selectionne tout en bas de la liste self.pushButtonExtremiteDescendre = MyQPushButton( self.tabTelechargements) self.pushButtonExtremiteDescendre.setIcon( QtGui.QIcon("ico/gtk-jump-to-ltr.svg")) self.pushButtonExtremiteDescendre.setToolTip( u"Placer l'élément sélectionné tout en bas") self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteDescendre, 3, 0, 1, 1) # Bouton pour supprimer tous les elements de la liste self.pushButtonToutSupprimer = MyQPushButton(self.tabTelechargements) self.pushButtonToutSupprimer.setIcon(QtGui.QIcon("ico/gtk-cancel.svg")) self.pushButtonToutSupprimer.setToolTip( u"Supprimer tous les téléchargements") self.gridLayoutTelechargement.addWidget(self.pushButtonToutSupprimer, 0, 2, 1, 1) # Bouton pour supprimer de la liste les telechargements termines self.pushButtonNettoyer = MyQPushButton(self.tabTelechargements) self.pushButtonNettoyer.setIcon(QtGui.QIcon("ico/gtk-delete-full.svg")) self.pushButtonNettoyer.setToolTip( u"Supprimer les téléchargement terminés") self.gridLayoutTelechargement.addWidget(self.pushButtonNettoyer, 1, 2, 1, 1) # Bouton pour ouvrir le dossier des telechargements self.pushButtonOuvrirDossierTelechargement = MyQPushButton( self.tabTelechargements) self.pushButtonOuvrirDossierTelechargement.setIcon( QtGui.QIcon("ico/gtk-folder.svg")) self.pushButtonOuvrirDossierTelechargement.setToolTip( u"Ouvrir le dossier des téléchargements") self.gridLayoutTelechargement.addWidget( self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1) # # Barre progression de telechargement d'un fichier # self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget) self.progressBarTelechargementFichier.setProperty("value", 0) # # Barre de progression de telechargement des fichiers # self.progressBarTelechargement = QtGui.QProgressBar(self.centralWidget) self.progressBarTelechargement.setProperty("value", 0) # # Boutons du bas pour gerer ajouter/supprimer/lancer telechargements # # Layout horizontal qui contiendra les boutons self.horizontalLayoutBarreBas = QtGui.QHBoxLayout() # Bouton pour lancer les telechargements self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon("ico/gtk-media-play-ltr.svg"), u"Lancer téléchargement", self.centralWidget) self.horizontalLayoutBarreBas.addWidget(self.pushButtonLancer) # Bouton pour stopper les telechargements self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon("ico/gtk-media-stop.svg"), u"Stopper le téléchargement", self.centralWidget) self.pushButtonStop.setEnabled(False) self.horizontalLayoutBarreBas.addWidget(self.pushButtonStop) ### # Positionnement des differents widgets/layouts sur le layout de grille ### # Layout de grille dans lequel on va placer nos widgets/layouts self.gridLayout = QtGui.QGridLayout(self.centralWidget) # On ajoute la barre du haut self.gridLayout.addLayout(self.horizontalLayoutBarreHaut, 0, 0, 1, 3) # On ajoute le gestionnaire d'onglets self.gridLayout.addWidget(self.tabWidget, 1, 0, 1, 3) # On ajoute la barre de progression de telechargement d'un fichier self.gridLayout.addWidget(self.progressBarTelechargementFichier, 2, 0, 1, 3) # On ajoute la barre de progression de telechargement des fichiers self.gridLayout.addWidget(self.progressBarTelechargement, 3, 0, 1, 3) # On ajoute les boutons ajouter/supprimer/lancer self.gridLayout.addLayout(self.horizontalLayoutBarreBas, 4, 0, 1, 3) ### # Mise en place le central widget dans la fenetre ### self.setCentralWidget(self.centralWidget) ### # Mise en place du menu ### # Menu barre self.menubar = QtGui.QMenuBar(self) self.menubar.setGeometry(QtCore.QRect(0, 0, 480, 25)) # Menu Fichier self.menuFichier = QtGui.QMenu("&Fichier", self.menubar) self.menubar.addAction(self.menuFichier.menuAction()) # Action Fichier -> Quitter self.actionQuitter = QtGui.QAction(QtGui.QIcon("ico/gtk-quit.svg"), "&Quitter", self) self.actionQuitter.setIconVisibleInMenu(True) self.menuFichier.addAction(self.actionQuitter) # Menu Edition self.menuEdition = QtGui.QMenu("&Edition", self.menubar) self.menubar.addAction(self.menuEdition.menuAction()) # Action Edition -> Mise a jour self.actionMAJ = QtGui.QAction(QtGui.QIcon("ico/gtk-refresh.svg"), u"&Mise à jour des plugins", self) self.actionMAJ.setIconVisibleInMenu(True) self.menuEdition.addAction(self.actionMAJ) # Action Edition -> Preferences self.actionPreferences = QtGui.QAction( QtGui.QIcon("ico/gtk-preferences.svg"), u"&Préférences", self) self.actionPreferences.setIconVisibleInMenu(True) self.menuEdition.addAction(self.actionPreferences) # Menu Aide self.menuAide = QtGui.QMenu("&Aide", self.menubar) self.menubar.addAction(self.menuAide.menuAction()) # Action Aide -> A propos self.actionAPropos = QtGui.QAction(QtGui.QIcon("ico/gtk-about.svg"), u"À p&ropos", self) self.actionAPropos.setIconVisibleInMenu(True) self.menuAide.addAction(self.actionAPropos) # Ajout du menu a l'interface self.setMenuBar(self.menubar) ### # Signaux provenants de l'interface ### QtCore.QObject.connect(self.tableWidgetFichier, QtCore.SIGNAL("cellClicked(int,int)"), self.afficherInformationsFichier) QtCore.QObject.connect(self.tableWidgetFichier, QtCore.SIGNAL("cellDoubleClicked(int,int)"), self.gererTelechargement) QtCore.QObject.connect(self.pushButtonToutAjouter, QtCore.SIGNAL("clicked()"), self.ajouterTousLesFichiers) QtCore.QObject.connect(self.pushButtonRafraichirPlugin, QtCore.SIGNAL("clicked()"), self.rafraichirPlugin) QtCore.QObject.connect(self.tableWidgetTelechargement, QtCore.SIGNAL("cellDoubleClicked(int,int)"), self.supprimerTelechargement) QtCore.QObject.connect( self.pushButtonExtremiteMonter, QtCore.SIGNAL("clicked()"), lambda versLeHaut=True, extremite=True: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect( self.pushButtonMonter, QtCore.SIGNAL("clicked()"), lambda versLeHaut=True, extremite=False: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect( self.pushButtonDescendre, QtCore.SIGNAL("clicked()"), lambda versLeHaut=False, extremite=False: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect( self.pushButtonExtremiteDescendre, QtCore.SIGNAL("clicked()"), lambda versLeHaut=False, extremite=True: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect(self.pushButtonToutSupprimer, QtCore.SIGNAL("clicked()"), self.supprimerTousLesTelechargements) QtCore.QObject.connect(self.pushButtonNettoyer, QtCore.SIGNAL("clicked()"), self.nettoyer) QtCore.QObject.connect(self.pushButtonLancer, QtCore.SIGNAL("clicked()"), self.lancerTelechargement) QtCore.QObject.connect(self.pushButtonStop, QtCore.SIGNAL("clicked()"), self.stopperTelechargement) QtCore.QObject.connect(self.actionQuitter, QtCore.SIGNAL("triggered()"), self.close) ################################################ # Instanciations + initialisation de variables # ################################################ # Fenetre About self.aProposDialog = None # Fenetre des preferences du logiciel self.preferencesDialog = None # Fenetre de mise a jour des plugins self.updateManagerDialog = None # Nom plugin courant self.nomPluginCourant = "" # Liste des fichiers self.listeFichiers = [] # Liste des fichiers a telecharger self.listeFichiersATelecharger = [] # Cache des images descriptive # Clef : urlImage Valeur : image (binaire) self.cacheImage = {} # On intancie le lanceur de signaux self.signaux = Signaux() # On instancie le gestionnaire de preferences self.preferences = Preferences() # On instancie le gestionnaire de preferences des plugins self.preferencesPluginDialog = PreferencePluginDialog(self) # On instancie le gestionnaire de download self.downloader = Downloader(self.signaux) # On recupere l'instance de API self.api = API.getInstance() # On instancie le gestionnaire d'historique self.historique = Historique() # On instancie la fenetre d'attente self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog(self) # On instancie le gest # # Fenetre de confirmation pour quitter le logiciel # self.quitterMessageBox = QtGui.QMessageBox(self) self.quitterMessageBox.setWindowTitle("Fermeture de TVDownloader") self.quitterMessageBox.setText( u"Voulez-vous réellement quitter TVDownloader ?") self.quitterMessageBox.setInformativeText( u"Votre liste de téléchargement sera perdue") self.quitterMessageBox.addButton("Oui", QtGui.QMessageBox.AcceptRole) self.quitterMessageBox.addButton("Non", QtGui.QMessageBox.RejectRole) ############################################################ # On connecte les signaux des instances precedements crees # ############################################################ QtCore.QObject.connect(self.pushButtonOuvrirDossierTelechargement, QtCore.SIGNAL("clicked()"), self.ouvrirRepertoireTelechargement) QtCore.QObject.connect(self.comboBoxSite, QtCore.SIGNAL("activated(QString)"), self.listerChaines) QtCore.QObject.connect(self.comboBoxChaine, QtCore.SIGNAL("activated(QString)"), self.listerEmissions) QtCore.QObject.connect(self.comboBoxEmission, QtCore.SIGNAL("activated(QString)"), self.listerFichiers) QtCore.QObject.connect(self.pushButtonPreferencesPlugin, QtCore.SIGNAL("clicked()"), self.ouvrirPreferencesPlugin) QtCore.QObject.connect(self.actionPreferences, QtCore.SIGNAL("triggered()"), self.ouvrirPreferencesLogiciel) QtCore.QObject.connect(self.actionMAJ, QtCore.SIGNAL("triggered()"), self.ouvrirFenetreMiseAJour) QtCore.QObject.connect(self.actionAPropos, QtCore.SIGNAL("triggered()"), self.ouvrirFenetreAPropos) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL("debutActualisation(PyQt_PyObject)"), self.fenetreAttenteProgressDialog.ouvrirFenetreAttente) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL("finActualisation()"), self.fenetreAttenteProgressDialog.fermerFenetreAttente) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("actualiserListesDeroulantes()"), self.actualiserListesDeroulantes) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("listeChaines(PyQt_PyObject)"), self.ajouterChaines) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("listeEmissions(PyQt_PyObject)"), self.ajouterEmissions) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("listeFichiers(PyQt_PyObject)"), self.ajouterFichiers) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("nouvelleImage(PyQt_PyObject)"), self.mettreEnPlaceImage) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("debutTelechargement(int)"), self.debutTelechargement) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("finTelechargement(int)"), self.finTelechargement) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("finDesTelechargements()"), self.activerDesactiverInterface) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("pourcentageFichier(int)"), self.progressBarTelechargementFichier.setValue) ######### # Début # ######### # La fenetre prend la dimension qu'elle avait a sa fermeture taille = self.preferences.getPreference("tailleFenetre") self.resize(taille[0], taille[1]) # Si aucun plugin n'est active, on ouvre la fenetre des preferences if (len(self.preferences.getPreference("pluginsActifs")) == 0): self.ouvrirPreferencesLogiciel() # On actualise tous les plugins self.rafraichirTousLesPlugins() ## Methode qui execute les actions necessaires avant de quitter le programme def actionsAvantQuitter(self): # On sauvegarde les options des plugins self.api.fermeture() # On sauvegarde la taille de la fenetre taille = self.size() self.preferences.setPreference( "tailleFenetre", [taille.width(), taille.height()]) # On sauvegarde les options du logiciel self.preferences.sauvegarderConfiguration() # On sauvegarde l'historique self.historique.sauverHistorique() # On stoppe les telechargements self.stopperTelechargement() ######################################### # Surcharge des methodes de QMainWindow # ######################################### ## Surcharge de la methode appelee lors de la fermeture de la fenetre # Ne doit pas etre appele explicitement # @param evenement Evenement qui a provoque la fermeture def closeEvent(self, evenement): # On affiche une fenetre pour demander la fermeture si des fichiers sont dans la liste de telechargement if (self.tableWidgetTelechargement.rowCount() > 0): # On affiche une fenetre qui demande si on veut quitter retour = self.quitterMessageBox.exec_() # Si on veut quitter if (retour == 0): # On execute les actions necessaires self.actionsAvantQuitter() # On accept la fermeture evenement.accept() else: # On refuse la fermeture evenement.ignore() else: # S'il n'y a pas de fichier # On execute les actions necessaires self.actionsAvantQuitter() # On accept la fermeture evenement.accept() ############################################## # Methodes pour remplir les menus deroulants # ############################################## ## Methode qui actualise les listes deroulantes def actualiserListesDeroulantes(self): # On lance juste l'ajout des sites en se basant sur les plugins actifs self.ajouterSites(self.preferences.getPreference("pluginsActifs")) ## Methode qui lance le listage des chaines # @param site Nom du plugin/site pour lequel on va lister les chaines def listerChaines(self, site): def threadListerChaines(self, nomPlugin): self.signaux.signal("debutActualisation", nomPlugin) listeChaines = self.api.getPluginListeChaines(nomPlugin) self.signaux.signal("listeChaines", listeChaines) self.signaux.signal("finActualisation") if (site != ""): self.nomPluginCourant = qstringToString(site) threading.Thread(target=threadListerChaines, args=(self, self.nomPluginCourant)).start() # On active (ou pas) le bouton de preference du plugin self.pushButtonPreferencesPlugin.setEnabled( self.api.getPluginListeOptions(self.nomPluginCourant) != []) ## Methode qui lance le listage des emissions # @param chaine Nom de la chaine pour laquelle on va lister les emissions def listerEmissions(self, chaine): def threadListerEmissions(self, nomPlugin, chaine): self.signaux.signal("debutActualisation", nomPlugin) listeEmissions = self.api.getPluginListeEmissions( nomPlugin, chaine) self.signaux.signal("listeEmissions", listeEmissions) self.signaux.signal("finActualisation") if (chaine != ""): threading.Thread(target=threadListerEmissions, args=(self, self.nomPluginCourant, qstringToString(chaine))).start() ## Methode qui lance le listage des fichiers # @param emission Nom de l'emission pour laquelle on va lister les fichiers def listerFichiers(self, emission): def threadListerFichiers(self, nomPlugin, emission): self.signaux.signal("debutActualisation", nomPlugin) listeFichiers = self.api.getPluginListeFichiers( nomPlugin, emission) self.signaux.signal("listeFichiers", listeFichiers) self.signaux.signal("finActualisation") if (emission != ""): threading.Thread(target=threadListerFichiers, args=(self, self.nomPluginCourant, qstringToString(emission))).start() ## Methode qui met en place une liste de sites sur l'interface # @param listeSites Liste des sites a mettre en place def ajouterSites(self, listeSites): # On efface la liste des sites self.comboBoxSite.clear() # On met en place les sites for site in listeSites: self.comboBoxSite.addItem(stringToQstring(site)) # On selectionne par defaut celui choisis dans les preference index = self.comboBoxSite.findText( stringToQstring(self.preferences.getPreference("pluginParDefaut"))) if (index != -1): self.comboBoxSite.setCurrentIndex(index) # On lance l'ajout des chaines self.listerChaines(self.comboBoxSite.currentText()) ## Methode qui met en place une liste de chaines sur l'interface # @param listeChaines Liste des chaines a mettre en place def ajouterChaines(self, listeChaines): # On trie la liste des chaines listeChaines.sort() # On efface la liste des chaines self.comboBoxChaine.clear() # On efface la liste des emissions self.comboBoxEmission.clear() # On efface la liste des fichiers self.tableWidgetFichier.toutSupprimer() # On met en place les chaines for chaine in listeChaines: self.comboBoxChaine.addItem(stringToQstring(chaine)) # Si on a juste une seule chaine if (self.comboBoxChaine.count() == 1): # On lance l'ajout des emissions self.listerEmissions(self.comboBoxChaine.currentText()) else: # On ne selectionne pas de chaine self.comboBoxChaine.setCurrentIndex(-1) ## Methode qui met en place une liste d'emissions sur l'interface # @param listeEmissions Liste des emissions a mettre en place def ajouterEmissions(self, listeEmissions): # On trie la liste des emissions listeEmissions.sort() # On efface la liste des emissions self.comboBoxEmission.clear() # On efface la liste des fichiers self.tableWidgetFichier.toutSupprimer() # On met en place la liste des emissions for emission in listeEmissions: self.comboBoxEmission.addItem(stringToQstring(emission)) # Si on a juste une seule emission if (self.comboBoxEmission.count() == 1): # On lance l'ajout des fichiers self.listerFichiers(self.comboBoxEmission.currentText()) else: # On ne selectionne pas d'emission self.comboBoxEmission.setCurrentIndex(-1) ############################################### # Methodes pour remplir la liste des fichiers # ############################################### ## Methode pour ajouter des fichiers a l'interface # @param listeFichiers Liste des fichiers a ajouter def ajouterFichiers(self, listeFichiers): self.listeFichiers = listeFichiers # On efface la liste des fichiers self.tableWidgetFichier.toutSupprimer() # On commence au depart ligneCourante = 0 # On met en place chacun des fichiers for fichier in listeFichiers: # On ajoute une ligne self.tableWidgetFichier.insertRow(ligneCourante) # On ajoute les informations au tableWidgetFichier liste = [] liste.append(self.tableWidgetFichier.creerItem("")) liste.append( self.tableWidgetFichier.creerItem(getattr(fichier, "date"))) liste.append( self.tableWidgetFichier.creerItem(getattr(fichier, "nom"))) self.tableWidgetFichier.setLigne(ligneCourante, liste) # On met en place l'icone qui va bien self.gererIconeListeFichier(fichier) ligneCourante += 1 # On adapte la taille des colonnes self.tableWidgetFichier.adapterColonnes() ## Methode qui rafraichit le plugin courant def rafraichirPlugin(self): def threadRafraichirPlugin(self, nomPlugin): self.signaux.signal("debutActualisation", nomPlugin) self.api.pluginRafraichir(nomPlugin) self.signaux.signal("finActualisation") threading.Thread(target=threadRafraichirPlugin, args=(self, self.nomPluginCourant)).start() ## Methode qui met en place l'image de la description d'un fichier # @param image Image a mettre en place (binaire) def mettreEnPlaceImage(self, image): logoFichier = QtGui.QPixmap() logoFichier.loadFromData(image) self.labelLogo.setPixmap( logoFichier.scaled(QtCore.QSize(150, 150), QtCore.Qt.KeepAspectRatio)) ## Methode qui affiche des informations sur le fichier selectionne def afficherInformationsFichier(self, ligne, colonne): def threadRecupererImage(self, urlImage): image = self.api.getPage(urlImage) self.cacheImage[urlImage] = image self.signaux.signal("nouvelleImage", image) fichier = self.listeFichiers[ligne] # On recupere le lien de l'image et le texte descriptif urlImage = getattr(fichier, "urlImage") texteDescriptif = getattr(fichier, "descriptif") self.plainTextEdit.clear() # Si on a un texte descriptif, on l'affiche if (texteDescriptif != ""): self.plainTextEdit.appendPlainText( stringToQstring(texteDescriptif)) else: self.plainTextEdit.appendPlainText( u"Aucune information disponible") # Si on n'a pas d'image if (urlImage == ""): # On met en place celle par defaut self.logoFichier = self.logoFichierDefaut self.labelLogo.setPixmap( self.logoFichier.scaled(QtCore.QSize(150, 150), QtCore.Qt.KeepAspectRatio)) else: # Si on en a une # Si elle est dans le cache des images if (self.cacheImage.has_key(urlImage)): self.mettreEnPlaceImage(self.cacheImage[urlImage]) else: # Sinon # On lance le thread pour la recuperer threading.Thread(target=threadRecupererImage, args=(self, urlImage)).start() ## Methode qui gere l'icone d'un fichier dans la liste des telechargements # Il y a 3 icones possible : # - C'est un fichier # - C'est un fichier present dans l'historique (donc deja telecharge) # - C'est un fichier present dans la liste des telechargements # @param fichier Fichier a gerer def gererIconeListeFichier(self, fichier): if (fichier in self.listeFichiers): ligneFichier = self.listeFichiers.index(fichier) # On cherche quel icone mettre en place if (fichier in self.listeFichiersATelecharger): icone = self.iconeAjoute elif (self.historique.comparerHistorique(fichier)): icone = self.iconeTelecharge else: icone = self.iconeFichier # On met en place l'icone self.tableWidgetFichier.item(ligneFichier, 0).setIcon(icone) ###################################################### # Methodes pour remplir la liste des telechargements # ###################################################### ## Methode qui gere la liste des telechargements # @param ligne Numero de la ligne (dans la liste des fichiers) de l'element a ajouter # @param colonne Numero de colonne (inutile, juste pour le slot) def gererTelechargement(self, ligne, colonne=0): fichier = self.listeFichiers[ligne] # Si le fichier est deja dans la liste des telechargements if (fichier in self.listeFichiersATelecharger): ligneTelechargement = self.listeFichiersATelecharger.index(fichier) self.supprimerTelechargement(ligneTelechargement) else: # S'il n'y est pas, on l'ajoute self.listeFichiersATelecharger.append(fichier) numLigne = self.tableWidgetTelechargement.rowCount() # On insere une nouvelle ligne dans la liste des telechargements self.tableWidgetTelechargement.insertRow(numLigne) # On y insere les elements qui vont biens self.tableWidgetTelechargement.setLigne(numLigne, [ self.tableWidgetTelechargement.creerItem( getattr(fichier, "date")), self.tableWidgetTelechargement.creerItem( getattr(fichier, "nom")), self.tableWidgetTelechargement.creerItem( u"En attente de téléchargement") ]) # On adapte la taille des colonnes self.tableWidgetTelechargement.adapterColonnes() # On modifie l'icone dans la liste des fichiers self.gererIconeListeFichier(fichier) ## Methode qui ajoute tous les fichiers a la liste des telechargements def ajouterTousLesFichiers(self): for i in range(self.tableWidgetFichier.rowCount()): self.gererTelechargement(i) ## Methode qui supprime un fichier de la liste des telechargements # @param ligne Numero de la ligne a supprimer # @param colonne Numero de colonne (inutile, juste pour le slot) def supprimerTelechargement(self, ligne, colonne=0): fichier = self.listeFichiersATelecharger[ligne] # On supprime l'element du tableWidgetTelechargement self.tableWidgetTelechargement.removeRow(ligne) # On supprime l'element de la liste des fichiers a telecharger self.listeFichiersATelecharger.remove(fichier) # On modifie l'icone dans la liste des fichiers self.gererIconeListeFichier(fichier) ## Methode qui supprime tous les telechargement de la liste des telechargements def supprimerTousLesTelechargements(self): for i in range(self.tableWidgetTelechargement.rowCount() - 1, -1, -1): self.supprimerTelechargement(i) ## Methode qui lance le telechargement des fichiers def lancerTelechargement(self): # On liste les emissions a telecharger avec leurs numeros de ligne listeFichiers = [] for i in range(self.tableWidgetTelechargement.rowCount() ): # Pour chaque ligne fichier = self.listeFichiersATelecharger[i] listeFichiers.append([ i, getattr(fichier, "lien"), getattr(fichier, "nomFichierSortie") ]) nbATelecharger = len(listeFichiers) # Si on a des elements a charger if (nbATelecharger > 0): # On met en place la valeur du progressBar self.progressBarTelechargement.setMaximum(nbATelecharger) self.progressBarTelechargement.setValue(0) # On lance le telechargement threading.Thread(target=self.downloader.lancerTelechargement, args=(listeFichiers, )).start() # On active/desactive ce qui va bien sur l'interface self.activerDesactiverInterface(True) ## Methode qui stoppe le telechargement def stopperTelechargement(self): # On stoppe le telechargement self.downloader.stopperTelechargement() ############################################ # Methodes pour ouvrir les autres fenetres # ############################################ # # Fenetre About # ## Methode pour afficher la fenetre About def ouvrirFenetreAPropos(self): if (self.aProposDialog == None): self.aProposDialog = AProposDialog() self.aProposDialog.show() # # Fenetre de preference du logiciel # ## Methode pour ouvrir les preferences du logiciel def ouvrirPreferencesLogiciel(self): if (self.preferencesDialog == None): self.preferencesDialog = PreferencesDialog(self, self.signaux) self.preferencesDialog.afficher() # # Fenetre de mise a jour des plugins # ## Methode pour ouvrir la fenetre de mise a jour des plugins def ouvrirFenetreMiseAJour(self): if (self.updateManagerDialog == None): self.updateManagerDialog = UpdateManagerDialog(self) self.updateManagerDialog.afficher() # # Fenetre de preference des plugins # ## Methode pour ouvrir les preferences du plugin courant def ouvrirPreferencesPlugin(self): listeOptions = self.api.getPluginListeOptions(self.nomPluginCourant) self.preferencesPluginDialog.ouvrirDialogPreferences( self.nomPluginCourant, listeOptions) ######### # Slots # ######### ## Methode qui ouvre le repertoire de telechargement def ouvrirRepertoireTelechargement(self): QtGui.QDesktopServices.openUrl( QtCore.QUrl.fromLocalFile( self.preferences.getPreference("repertoireTelechargement"))) ## Methode qui rafraichit le plugin courant def rafraichirPlugin(self): def threadRafraichirPlugin(self, nomPlugin): self.signaux.signal("debutActualisation", nomPlugin) self.api.pluginRafraichir(nomPlugin) self.signaux.signal("finActualisation") threading.Thread(target=threadRafraichirPlugin, args=(self, self.nomPluginCourant)).start() ## Methode qui rafraichit tous les plugins # A utiliser au lancement du programme def rafraichirTousLesPlugins(self): def threadRafraichirTousLesPlugins(self): self.signaux.signal("debutActualisation", "TVDownloader") self.api.pluginRafraichirAuto() self.signaux.signal("finActualisation") self.signaux.signal("actualiserListesDeroulantes") threading.Thread(target=threadRafraichirTousLesPlugins, args=(self, )).start() ## Slot qui active/desactive des elements de l'interface pendant un telechargement # @param telechargementEnCours Indique si on telecharge ou pas def activerDesactiverInterface(self, telechargementEnCours=False): # Les boutons self.pushButtonLancer.setEnabled(not telechargementEnCours) self.pushButtonStop.setEnabled(telechargementEnCours) self.pushButtonExtremiteMonter.setEnabled(not telechargementEnCours) self.pushButtonMonter.setEnabled(not telechargementEnCours) self.pushButtonDescendre.setEnabled(not telechargementEnCours) self.pushButtonExtremiteDescendre.setEnabled(not telechargementEnCours) self.pushButtonToutSupprimer.setEnabled(not telechargementEnCours) self.pushButtonNettoyer.setEnabled(not telechargementEnCours) # Le table widget self.tableWidgetTelechargement.setEnabled(not telechargementEnCours) ## Slot appele lors ce qu'un le debut d'un telechargement commence # @param numero Position dans la liste des telechargement du telechargement qui commence def debutTelechargement(self, numero): self.tableWidgetTelechargement.item(numero, 2).setText( stringToQstring(u"Téléchargement en cours...")) self.tableWidgetTelechargement.adapterColonnes() self.progressBarTelechargementFichier.setValue(0) ## Slot appele lorsqu'un telechargement se finit # @param numero Position dans la liste des telechargement du telechargement qui se finit def finTelechargement(self, numero): fichier = self.listeFichiersATelecharger[numero] # On ajoute le fichier a l'historique self.historique.ajouterHistorique(fichier) # On modifie l'icone dans la liste des fichiers self.gererIconeListeFichier(fichier) # On modifie l'interface self.tableWidgetTelechargement.item(numero, 2).setText( stringToQstring(u"Fini !")) self.progressBarTelechargement.setValue( self.progressBarTelechargement.value() + 1) self.tableWidgetTelechargement.adapterColonnes() self.progressBarTelechargementFichier.setValue(100) ## Slot qui nettoie la liste des telechargements de tous les telechargements finis def nettoyer(self): for i in range(self.tableWidgetTelechargement.rowCount() - 1, -1, -1): # [ nbLignes - 1, nbLignes - 2, ..., 1, 0 ] if (self.tableWidgetTelechargement.item( i, 2).text() == u"Fini !"): # Si c'est telecharge self.supprimerTelechargement(i)
def test_get_raw_data_cell(actions, timeSlotID, id, prefix=""): print actions.getRawDataEntry(timeSlotID, id) def test_get_competitor_info(actions, uuid, prefix=""): timeSlots = range(1, 25) return actions.getCompetitorInfo(timeSlots, uuid, prefix) if __name__ == "__main__": actions = Actions.Actions() actions.setManualDbCursor(DatabaseConnection.DatabaseConnection().getDatabaseCursor()) # test_update_raw_data_cell(actions, 5, 5, 5) # for i in range(50): # test_random_update_raw_data_cell(actions) try: pr = Preferences() while True: test_random_update_raw_data_cell(actions, pr.get("DBPrefix")) time.sleep(0.5) except KeyboardInterrupt: print "\nShutting down!\n" sys.exit(0) # test_get_raw_data_cell(actions, 2, 2) # test_get_raw_data_cell(actions, 8, 7) # print test_get_competitor_info(actions, 1, "testDB_")
def applicationDidFinishLaunching_(self, sender): self.preferences = Preferences.alloc().init() NSLog("Application did finish launching.")
def __init__(self): # Appel au constructeur de la classe mere QtGui.QMainWindow.__init__(self) ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle("TVDownloader") # Mise en place de son icone self.setWindowIcon(QtGui.QIcon("ico/TVDownloader.png")) ### # Mise en place des widgets dans la fenetre ### # Widget central qui contiendra tout self.centralWidget = QtGui.QWidget(self) # # Barre du haut # # Layout horizontal qui contiendra les listes deroulantes self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout() # Liste deroulante pour choisir le site (plugin) self.comboBoxSite = QtGui.QComboBox(self.centralWidget) self.horizontalLayoutBarreHaut.addWidget(self.comboBoxSite) # Liste deroulante pour choisir une chaine du site courant self.comboBoxChaine = QtGui.QComboBox(self.centralWidget) self.horizontalLayoutBarreHaut.addWidget(self.comboBoxChaine) # Liste deroulante pour choisir une emission de la chaine courante self.comboBoxEmission = QtGui.QComboBox(self.centralWidget) self.horizontalLayoutBarreHaut.addWidget(self.comboBoxEmission) # # Onglets # # Gestionnaire onglets self.tabWidget = QtGui.QTabWidget(self.centralWidget) # Onglet Fichiers self.tabFichiers = QtGui.QSplitter( self.centralWidget) # L'onglet Fichier contient un splitter self.tabWidget.addTab(self.tabFichiers, u"Choix des fichiers") # Onglet Telechargements self.tabTelechargements = QtGui.QWidget(self.centralWidget) self.tabWidget.addTab(self.tabTelechargements, u"Téléchargements") # # Liste des fichiers # # Layout de grille qui contient le tableau qui liste les fichiers + boutons self.gridLayoutFichiers = QtGui.QGridLayout(self.tabFichiers) # Tableau qui contient la liste des fichiers disponibles pour l'emission courante self.tableWidgetFichier = MyQTableWidget(self.tabFichiers) # Il a 4 colonnes et 0 ligne (pour l'instant) self.tableWidgetFichier.setColumnCount(3) self.tableWidgetFichier.setRowCount(0) # On ajoute les titres self.tableWidgetFichier.setHorizontalHeaderItem( 0, self.tableWidgetFichier.creerItem("")) self.tableWidgetFichier.setHorizontalHeaderItem( 1, self.tableWidgetFichier.creerItem("Date")) self.tableWidgetFichier.setHorizontalHeaderItem( 2, self.tableWidgetFichier.creerItem("Emission")) # On l'ajoute au layout self.gridLayoutFichiers.addWidget(self.tableWidgetFichier, 0, 1, 6, 1) # Icones du tableWidget self.iconeFichier = QtGui.QIcon("ico/gtk-file.svg") self.iconeAjoute = QtGui.QIcon("ico/gtk-add.svg") self.iconeTelecharge = QtGui.QIcon("ico/gtk-apply.svg") # Bouton pour ajouter tous les fichiers a la liste des telechargements self.pushButtonToutAjouter = MyQPushButton(self.tabFichiers) self.pushButtonToutAjouter.setIcon(QtGui.QIcon("ico/gtk-add.svg")) self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements") self.gridLayoutFichiers.addWidget(self.pushButtonToutAjouter, 0, 0, 2, 1) # Bouton pour rafraichir le plugin courant self.pushButtonRafraichirPlugin = MyQPushButton(self.tabFichiers) self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon("ico/gtk-refresh.svg")) self.pushButtonRafraichirPlugin.setToolTip("Rafraichir le plugin") self.gridLayoutFichiers.addWidget(self.pushButtonRafraichirPlugin, 2, 0, 2, 1) # Bouton pour ouvrir la fenetre des preferences du plugin courant self.pushButtonPreferencesPlugin = MyQPushButton(self.tabFichiers) self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon("ico/gtk-preferences.svg")) self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin") self.gridLayoutFichiers.addWidget(self.pushButtonPreferencesPlugin, 4, 0, 2, 1) # On met en place ce layout sur un widget (pour le splitter) self.widgetFichiers = QtGui.QWidget() self.widgetFichiers.setLayout(self.gridLayoutFichiers) # # Descriptif des fichiers # # Layout de grille self.gridLayoutDescriptif = QtGui.QGridLayout() # Label pour afficher un logo self.logoFichierDefaut = QtGui.QPixmap() self.logoFichierDefaut.load("img/gtk-dialog-question.svg") self.labelLogo = QtGui.QLabel(self.centralWidget) self.labelLogo.setPixmap( self.logoFichierDefaut.scaled(QtCore.QSize(150, 150), QtCore.Qt.KeepAspectRatio)) self.gridLayoutDescriptif.addWidget(self.labelLogo, 0, 0, 1, 1) # Zone de texte pour afficher un descriptif self.plainTextEdit = QtGui.QPlainTextEdit(self.centralWidget) self.gridLayoutDescriptif.addWidget(self.plainTextEdit, 0, 1, 1, 2) # On met en place ce layout sur un widget (pour le splitter) self.widgetDescriptif = QtGui.QWidget() self.widgetDescriptif.setLayout(self.gridLayoutDescriptif) # Onrientation verticale du splitter self.tabFichiers.setOrientation(QtCore.Qt.Vertical) # On ajoute les 2 elements au splitter (qui est notre onglet) self.tabFichiers.addWidget(self.widgetFichiers) self.tabFichiers.addWidget(self.widgetDescriptif) # # Liste des telechargements # # Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller self.gridLayoutTelechargement = QtGui.QGridLayout( self.tabTelechargements) # Tableau qui contient la liste des fichiers a telecharger self.tableWidgetTelechargement = MyQTableWidget( self.tabTelechargements) # Il a 5 colonnes et 0 ligne (pour l'instant) self.tableWidgetTelechargement.setColumnCount(3) self.tableWidgetTelechargement.setRowCount(0) # On ajoute le titre des 5 colonnes self.tableWidgetTelechargement.setHorizontalHeaderItem( 0, self.tableWidgetTelechargement.creerItem("Date")) self.tableWidgetTelechargement.setHorizontalHeaderItem( 1, self.tableWidgetTelechargement.creerItem("Emission")) self.tableWidgetTelechargement.setHorizontalHeaderItem( 2, self.tableWidgetTelechargement.creerItem("Etat")) # On l'ajoute au layout self.gridLayoutTelechargement.addWidget(self.tableWidgetTelechargement, 0, 1, 4, 1) # Bouton pour monter l'element selectionne tout en haut de la liste self.pushButtonExtremiteMonter = MyQPushButton(self.tabTelechargements) self.pushButtonExtremiteMonter.setIcon( QtGui.QIcon("ico/gtk-jump-to-rtl.svg")) self.pushButtonExtremiteMonter.setToolTip( u"Placer l'élément sélectionné tout en haut") self.gridLayoutTelechargement.addWidget(self.pushButtonExtremiteMonter, 0, 0, 1, 1) # Bouton pour monter l'element selectionne d'un cran dans la liste self.pushButtonMonter = MyQPushButton(self.tabTelechargements) self.pushButtonMonter.setIcon(QtGui.QIcon("ico/gtk-go-up.svg")) self.pushButtonMonter.setToolTip(u"Monter l'élément sélectionné") self.gridLayoutTelechargement.addWidget(self.pushButtonMonter, 1, 0, 1, 1) # Bouton pour descendre l'element selectionne d'un cran dans la liste self.pushButtonDescendre = MyQPushButton(self.tabTelechargements) self.pushButtonDescendre.setIcon(QtGui.QIcon("ico/gtk-go-down.svg")) self.pushButtonDescendre.setToolTip(u"Descendre l'élément selectionné") self.gridLayoutTelechargement.addWidget(self.pushButtonDescendre, 2, 0, 1, 1) # Bouton pour descendre l'element selectionne tout en bas de la liste self.pushButtonExtremiteDescendre = MyQPushButton( self.tabTelechargements) self.pushButtonExtremiteDescendre.setIcon( QtGui.QIcon("ico/gtk-jump-to-ltr.svg")) self.pushButtonExtremiteDescendre.setToolTip( u"Placer l'élément sélectionné tout en bas") self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteDescendre, 3, 0, 1, 1) # Bouton pour supprimer tous les elements de la liste self.pushButtonToutSupprimer = MyQPushButton(self.tabTelechargements) self.pushButtonToutSupprimer.setIcon(QtGui.QIcon("ico/gtk-cancel.svg")) self.pushButtonToutSupprimer.setToolTip( u"Supprimer tous les téléchargements") self.gridLayoutTelechargement.addWidget(self.pushButtonToutSupprimer, 0, 2, 1, 1) # Bouton pour supprimer de la liste les telechargements termines self.pushButtonNettoyer = MyQPushButton(self.tabTelechargements) self.pushButtonNettoyer.setIcon(QtGui.QIcon("ico/gtk-delete-full.svg")) self.pushButtonNettoyer.setToolTip( u"Supprimer les téléchargement terminés") self.gridLayoutTelechargement.addWidget(self.pushButtonNettoyer, 1, 2, 1, 1) # Bouton pour ouvrir le dossier des telechargements self.pushButtonOuvrirDossierTelechargement = MyQPushButton( self.tabTelechargements) self.pushButtonOuvrirDossierTelechargement.setIcon( QtGui.QIcon("ico/gtk-folder.svg")) self.pushButtonOuvrirDossierTelechargement.setToolTip( u"Ouvrir le dossier des téléchargements") self.gridLayoutTelechargement.addWidget( self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1) # # Barre progression de telechargement d'un fichier # self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget) self.progressBarTelechargementFichier.setProperty("value", 0) # # Barre de progression de telechargement des fichiers # self.progressBarTelechargement = QtGui.QProgressBar(self.centralWidget) self.progressBarTelechargement.setProperty("value", 0) # # Boutons du bas pour gerer ajouter/supprimer/lancer telechargements # # Layout horizontal qui contiendra les boutons self.horizontalLayoutBarreBas = QtGui.QHBoxLayout() # Bouton pour lancer les telechargements self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon("ico/gtk-media-play-ltr.svg"), u"Lancer téléchargement", self.centralWidget) self.horizontalLayoutBarreBas.addWidget(self.pushButtonLancer) # Bouton pour stopper les telechargements self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon("ico/gtk-media-stop.svg"), u"Stopper le téléchargement", self.centralWidget) self.pushButtonStop.setEnabled(False) self.horizontalLayoutBarreBas.addWidget(self.pushButtonStop) ### # Positionnement des differents widgets/layouts sur le layout de grille ### # Layout de grille dans lequel on va placer nos widgets/layouts self.gridLayout = QtGui.QGridLayout(self.centralWidget) # On ajoute la barre du haut self.gridLayout.addLayout(self.horizontalLayoutBarreHaut, 0, 0, 1, 3) # On ajoute le gestionnaire d'onglets self.gridLayout.addWidget(self.tabWidget, 1, 0, 1, 3) # On ajoute la barre de progression de telechargement d'un fichier self.gridLayout.addWidget(self.progressBarTelechargementFichier, 2, 0, 1, 3) # On ajoute la barre de progression de telechargement des fichiers self.gridLayout.addWidget(self.progressBarTelechargement, 3, 0, 1, 3) # On ajoute les boutons ajouter/supprimer/lancer self.gridLayout.addLayout(self.horizontalLayoutBarreBas, 4, 0, 1, 3) ### # Mise en place le central widget dans la fenetre ### self.setCentralWidget(self.centralWidget) ### # Mise en place du menu ### # Menu barre self.menubar = QtGui.QMenuBar(self) self.menubar.setGeometry(QtCore.QRect(0, 0, 480, 25)) # Menu Fichier self.menuFichier = QtGui.QMenu("&Fichier", self.menubar) self.menubar.addAction(self.menuFichier.menuAction()) # Action Fichier -> Quitter self.actionQuitter = QtGui.QAction(QtGui.QIcon("ico/gtk-quit.svg"), "&Quitter", self) self.actionQuitter.setIconVisibleInMenu(True) self.menuFichier.addAction(self.actionQuitter) # Menu Edition self.menuEdition = QtGui.QMenu("&Edition", self.menubar) self.menubar.addAction(self.menuEdition.menuAction()) # Action Edition -> Mise a jour self.actionMAJ = QtGui.QAction(QtGui.QIcon("ico/gtk-refresh.svg"), u"&Mise à jour des plugins", self) self.actionMAJ.setIconVisibleInMenu(True) self.menuEdition.addAction(self.actionMAJ) # Action Edition -> Preferences self.actionPreferences = QtGui.QAction( QtGui.QIcon("ico/gtk-preferences.svg"), u"&Préférences", self) self.actionPreferences.setIconVisibleInMenu(True) self.menuEdition.addAction(self.actionPreferences) # Menu Aide self.menuAide = QtGui.QMenu("&Aide", self.menubar) self.menubar.addAction(self.menuAide.menuAction()) # Action Aide -> A propos self.actionAPropos = QtGui.QAction(QtGui.QIcon("ico/gtk-about.svg"), u"À p&ropos", self) self.actionAPropos.setIconVisibleInMenu(True) self.menuAide.addAction(self.actionAPropos) # Ajout du menu a l'interface self.setMenuBar(self.menubar) ### # Signaux provenants de l'interface ### QtCore.QObject.connect(self.tableWidgetFichier, QtCore.SIGNAL("cellClicked(int,int)"), self.afficherInformationsFichier) QtCore.QObject.connect(self.tableWidgetFichier, QtCore.SIGNAL("cellDoubleClicked(int,int)"), self.gererTelechargement) QtCore.QObject.connect(self.pushButtonToutAjouter, QtCore.SIGNAL("clicked()"), self.ajouterTousLesFichiers) QtCore.QObject.connect(self.pushButtonRafraichirPlugin, QtCore.SIGNAL("clicked()"), self.rafraichirPlugin) QtCore.QObject.connect(self.tableWidgetTelechargement, QtCore.SIGNAL("cellDoubleClicked(int,int)"), self.supprimerTelechargement) QtCore.QObject.connect( self.pushButtonExtremiteMonter, QtCore.SIGNAL("clicked()"), lambda versLeHaut=True, extremite=True: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect( self.pushButtonMonter, QtCore.SIGNAL("clicked()"), lambda versLeHaut=True, extremite=False: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect( self.pushButtonDescendre, QtCore.SIGNAL("clicked()"), lambda versLeHaut=False, extremite=False: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect( self.pushButtonExtremiteDescendre, QtCore.SIGNAL("clicked()"), lambda versLeHaut=False, extremite=True: self. tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite)) QtCore.QObject.connect(self.pushButtonToutSupprimer, QtCore.SIGNAL("clicked()"), self.supprimerTousLesTelechargements) QtCore.QObject.connect(self.pushButtonNettoyer, QtCore.SIGNAL("clicked()"), self.nettoyer) QtCore.QObject.connect(self.pushButtonLancer, QtCore.SIGNAL("clicked()"), self.lancerTelechargement) QtCore.QObject.connect(self.pushButtonStop, QtCore.SIGNAL("clicked()"), self.stopperTelechargement) QtCore.QObject.connect(self.actionQuitter, QtCore.SIGNAL("triggered()"), self.close) ################################################ # Instanciations + initialisation de variables # ################################################ # Fenetre About self.aProposDialog = None # Fenetre des preferences du logiciel self.preferencesDialog = None # Fenetre de mise a jour des plugins self.updateManagerDialog = None # Nom plugin courant self.nomPluginCourant = "" # Liste des fichiers self.listeFichiers = [] # Liste des fichiers a telecharger self.listeFichiersATelecharger = [] # Cache des images descriptive # Clef : urlImage Valeur : image (binaire) self.cacheImage = {} # On intancie le lanceur de signaux self.signaux = Signaux() # On instancie le gestionnaire de preferences self.preferences = Preferences() # On instancie le gestionnaire de preferences des plugins self.preferencesPluginDialog = PreferencePluginDialog(self) # On instancie le gestionnaire de download self.downloader = Downloader(self.signaux) # On recupere l'instance de API self.api = API.getInstance() # On instancie le gestionnaire d'historique self.historique = Historique() # On instancie la fenetre d'attente self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog(self) # On instancie le gest # # Fenetre de confirmation pour quitter le logiciel # self.quitterMessageBox = QtGui.QMessageBox(self) self.quitterMessageBox.setWindowTitle("Fermeture de TVDownloader") self.quitterMessageBox.setText( u"Voulez-vous réellement quitter TVDownloader ?") self.quitterMessageBox.setInformativeText( u"Votre liste de téléchargement sera perdue") self.quitterMessageBox.addButton("Oui", QtGui.QMessageBox.AcceptRole) self.quitterMessageBox.addButton("Non", QtGui.QMessageBox.RejectRole) ############################################################ # On connecte les signaux des instances precedements crees # ############################################################ QtCore.QObject.connect(self.pushButtonOuvrirDossierTelechargement, QtCore.SIGNAL("clicked()"), self.ouvrirRepertoireTelechargement) QtCore.QObject.connect(self.comboBoxSite, QtCore.SIGNAL("activated(QString)"), self.listerChaines) QtCore.QObject.connect(self.comboBoxChaine, QtCore.SIGNAL("activated(QString)"), self.listerEmissions) QtCore.QObject.connect(self.comboBoxEmission, QtCore.SIGNAL("activated(QString)"), self.listerFichiers) QtCore.QObject.connect(self.pushButtonPreferencesPlugin, QtCore.SIGNAL("clicked()"), self.ouvrirPreferencesPlugin) QtCore.QObject.connect(self.actionPreferences, QtCore.SIGNAL("triggered()"), self.ouvrirPreferencesLogiciel) QtCore.QObject.connect(self.actionMAJ, QtCore.SIGNAL("triggered()"), self.ouvrirFenetreMiseAJour) QtCore.QObject.connect(self.actionAPropos, QtCore.SIGNAL("triggered()"), self.ouvrirFenetreAPropos) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL("debutActualisation(PyQt_PyObject)"), self.fenetreAttenteProgressDialog.ouvrirFenetreAttente) QtCore.QObject.connect( self.signaux, QtCore.SIGNAL("finActualisation()"), self.fenetreAttenteProgressDialog.fermerFenetreAttente) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("actualiserListesDeroulantes()"), self.actualiserListesDeroulantes) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("listeChaines(PyQt_PyObject)"), self.ajouterChaines) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("listeEmissions(PyQt_PyObject)"), self.ajouterEmissions) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("listeFichiers(PyQt_PyObject)"), self.ajouterFichiers) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("nouvelleImage(PyQt_PyObject)"), self.mettreEnPlaceImage) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("debutTelechargement(int)"), self.debutTelechargement) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("finTelechargement(int)"), self.finTelechargement) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("finDesTelechargements()"), self.activerDesactiverInterface) QtCore.QObject.connect(self.signaux, QtCore.SIGNAL("pourcentageFichier(int)"), self.progressBarTelechargementFichier.setValue) ######### # Début # ######### # La fenetre prend la dimension qu'elle avait a sa fermeture taille = self.preferences.getPreference("tailleFenetre") self.resize(taille[0], taille[1]) # Si aucun plugin n'est active, on ouvre la fenetre des preferences if (len(self.preferences.getPreference("pluginsActifs")) == 0): self.ouvrirPreferencesLogiciel() # On actualise tous les plugins self.rafraichirTousLesPlugins()
class Downloader(object): # Instance de la classe (singleton) instance = None ## Surcharge de la methode de construction standard (pour mettre en place le singleton) def __new__(self, *args, **kwargs): if (self.instance is None): self.instance = super(Downloader, self).__new__(self) return self.instance ## Constructeur # @param signaux Lanceur de signaux. Si on le precise pas, aucun signal n'est lance (mode CLI). def __init__(self, signaux=None): self.preferences = Preferences() self.signaux = signaux self.arreter = True self.process = None ## Methode pour afficher un pourcentage à l'ecran # @param pourcentage Pourcentage actuel a afficher def afficherPourcentage(self, pourcentage): # On s'assure que le pourcentage soit bien entre 0 et 100 if (pourcentage < 0): pourcentage = 0 elif (pourcentage > 100): pourcentage = 100 message = str(pourcentage) + " %" print '\r', # Permet d'écrire au même endroit sys.stdout.write(message) sys.stdout.flush() ## Methode pour lancer le telecharger des fichiers # @param listeFichiers Liste des fichiers a telecharger def lancerTelechargement(self, listeFichiers): self.arreter = False for (numero, fichier, nomFichierSortie) in listeFichiers: logger.info("Telechargement de %s" % (fichier)) # Si on demande de s'arreter, on sort if self.arreter: break # Si on a le lanceur de signal if self.signaux: # On envoie le signal de debut de telechargement d'un fichier self.signaux.signal("debutTelechargement", numero) else: print "Debut telechargement", nomFichierSortie # On ajoute le repertoire de destination au nom du fichier fichierSortie = self.preferences.getPreference( "repertoireTelechargement") + "/" + nomFichierSortie # On telecharge de differentes manieres selon le protocole if (fichier[:4] == "rtmp"): if (fichier.find("swfVfy") == -1): commande = urlToRtmpdump(fichier) else: commande = "rtmpdump -r " + fichier self.telecharger(commande + " -o \"" + fichierSortie + "\"") elif (fichier[:4] == "http" or fichier[:3] == "ftp" or fichier[:3] == "mms"): self.telecharger("msdl -c " + fichier + " -o \"" + fichierSortie + "\"") else: logger.warn("le protocole du fichier %s n'est pas gere" % (fichier)) # Si on a le lanceur de signal if self.signaux: # On envoie le signal de fin de telechargement d'un fichier self.signaux.signal("finTelechargement", numero) else: print "\n\tFin telechargement" # Si on a le lanceur de signal if self.signaux: # On envoie le signal de fin de telechargement des fichiers self.signaux.signal("finDesTelechargements") ## Methode qui telecharge un fichier # @param commande Commande a lancer pour telecharger le fichier def telecharger(self, commande): # Commande mise au bon format pour Popen if (not isinstance(commande, str)): commande = str(commande) arguments = shlex.split(commande) # On lance la commande en redirigeant stdout et stderr (stderr va dans stdout) self.process = subprocess.Popen(arguments, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) # On recupere le flux stdout stdoutF = self.process.stdout # On recupere le descripteur de fichier de stdout stdoutFD = stdoutF.fileno() # On recupere les flags existants stdoutFlags = fcntl.fcntl(stdoutFD, fcntl.F_GETFL) # On modifie les flags existants en ajoutant le flag NoDelay fcntl.fcntl(stdoutFD, fcntl.F_SETFL, stdoutFlags | os.O_NDELAY) # Tant que le subprocess n'est pas fini while (self.process.poll() == None): # On attent que stdout soit lisible if (stdoutFD in select.select([stdoutFD], [], [])[0]): # On lit stdout ligne = stdoutF.read() # On affiche que les textes non vides if ligne: pourcentListe = re.findall("(\d{1,3}\.{0,1}\d{0,1})%", ligne) if (pourcentListe != []): pourcent = int(float(pourcentListe[-1])) if (pourcent >= 0 and pourcent <= 100): # Si on a le lanceur de signal if not self.signaux: self.afficherPourcentage(pourcent) elif self.signaux: # On envoit le pourcentage d'avancement a l'interface self.signaux.signal("pourcentageFichier", pourcent) # On attent avant de recommencer a lire time.sleep(3) ## Methode pour stopper le telechargement des fichiers def stopperTelechargement(self): if not self.arreter: # On sort de la boucle principale self.arreter = True # On stop le process s'il est lance if (self.process.poll() == None): self.process.terminate()
def launchPreferences_(self, notification): NSLog('AppDelegate: launchPreferences') self.preferences = Preferences.alloc().init() self.preferences.showWindow_(self)