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 ) )
Esempio n. 2
0
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
Esempio n. 3
0
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 )
Esempio n. 4
0
class cli:
    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()
Esempio n. 5
0
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)
Esempio n. 6
0
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()
Esempio n. 7
0
class cli:
	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
Esempio n. 9
0
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()
Esempio n. 10
0
class prefs:
	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()
		liste=[]
		for instance in pluginsActifs:
			liste.append(instance)
		self.preferences.setPreference( "pluginsActifs", liste)
		self.preferences.sauvegarderConfiguration()
Esempio n. 11
0
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()