def __init__(self, statusBar):
        # -------------------------------
        # Parametres généraux du widget
        # -------------------------------
        # === tout sera mis dans une boîte verticale ===#
        self.vbox = QVBoxLayout()

        # === Variable de configuration ===#
        self.config = EkdConfig

        # === Identifiant de la classe ===#
        self.idSection = "animation_decouper_une_video"

        super(Animation_MontagVideoDecoupUneVideo, self).__init__(
            "vbox", titre=_(u"Montage: Découpage d'une vidéo")
        )  # module de animation

        self.printSection()

        # === Drapeaux ===#
        # drapeau pour savoir si la valeur de début de la sélection vidéo été enregistré
        self.debutEstSelect = False
        # drapeau pour savoir si la valeur de fin de la sélection vidéo été enregistré
        self.finEstSelect = False
        # drapeau d'extraction du son
        self.extraireSon = True

        # -------------------------------------------------------------------
        # Boîte de groupe : "Fichier vidéo source"
        # -------------------------------------------------------------------
        self.afficheurVideoSource = SelectWidget(
            extensions=["*.avi", "*.mpg", "*.mpeg", "*.mjpeg", "*.flv", "*.mp4", "*.dv", "*.vob"],
            mode="texte",
            video=True,
        )
        # Onglets
        self.indexVideoSource = self.add(self.afficheurVideoSource, _(u"Video(s) source"))
        self.connect(self.afficheurVideoSource, SIGNAL("fileSelected"), self.getFile)
        self.connect(self.afficheurVideoSource, SIGNAL("pictureChanged(int)"), self.getFile)
        # --------------------------------------------------------------------

        ## ---------------------------------------------------------------------
        # Variables pour la fonction tampon
        ## ---------------------------------------------------------------------
        self.typeEntree = "video"  # Défini le type de fichier source.
        self.typeSortie = "video"  # Défini le type de fichier de sortie.
        self.sourceEntrees = self.afficheurVideoSource  # Fait le lien avec le sélecteur de fichier source.

        # --------------------------------------------------------------------------
        # Boîte de groupe de réglage: visualisation et de marquage de la sélection
        # --------------------------------------------------------------------------

        # Création de la boite de groupe de réglage (contenant la boite self.layoutReglage)
        reglageGroup = QGroupBox()
        self.layoutReglage = QVBoxLayout(reglageGroup)
        # === Widgets mplayer ===#
        vboxMplayer = QVBoxLayout()
        # Le facteur limitant est la largeur -> + simple à coder à cause de la largeur de la barre
        self.mplayer = Mplayer(
            taille=(300, 270),
            facteurLimitant=Mplayer.LARGEUR,
            choixWidget=(Mplayer.RATIO, Mplayer.PAS_PRECEDENT_SUIVANT, Mplayer.CURSEUR_A_PART),
        )

        self.mplayer.listeVideos = []
        self.mplayer.setToolTip(
            _(u"La lecture de la vidéo est nécessaire pour achever la sélection d'une zone de la vidéo")
        )
        self.mplayer.setEnabled(False)
        hbox = QHBoxLayout()
        hbox.addStretch()
        hbox.addWidget(self.mplayer)
        hbox.addStretch()
        vboxMplayer.addLayout(hbox)

        self.radioSource = QRadioButton(_(u"vidéo(s) source(s)"))
        self.radioSource.setChecked(True)
        self.radioSource.setEnabled(False)
        self.connect(self.radioSource, SIGNAL("clicked(bool)"), self.fctRadioSource)
        self.radioApercu = QRadioButton(_(u"aperçu"))
        self.radioApercu.setEnabled(False)
        self.connect(self.radioApercu, SIGNAL("clicked(bool)"), self.fctRadioApercu)
        self.radioConvert = QRadioButton(_(u"vidéo convertie"))
        self.radioConvert.setEnabled(False)
        self.connect(self.radioConvert, SIGNAL("clicked(bool)"), self.fctRadioConvert)

        self.layoutReglage.addLayout(vboxMplayer)

        self.add(reglageGroup, _(u"Réglages"))
        # Le widget-mplayer récupère des informations tous les 10ème
        # de seconde au lieu de toutes les secondes -> le marquage du
        # début et de la fin de la sélection seront plus précis
        self.mplayer.dureeTimer = 100

        self.connect(self.mplayer.bout_LectPause, SIGNAL("clicked()"), self.lectureMPlayer)

        # === Marquage et affichage des bornes de la sélection ===#

        # ||| Label de visualisation de la sélection |||#

        self.marques = (0, 0, 1)
        self.visuSelect = Label(self.marques, 300)
        self.visuSelect.setToolTip(_(u"La zone sélectionnée apparait en vert dans cette bande"))
        self.valeurDebut = 0
        self.valeurFin = 0

        hbox = QHBoxLayout()
        hbox.addWidget(self.visuSelect)
        self.layoutReglage.addLayout(hbox)

        # ||| boutons de marquage de la sélection |||#

        iconTaille = 28

        self.frameMarque = QFrame()
        boiteMarque = QHBoxLayout()
        boiteMarque.addStretch()

        boutMarqDebutSelect = QPushButton()
        boutMarqDebutSelect.setIcon(QIcon("Icones" + os.sep + "Tdebut.png"))
        boutMarqDebutSelect.setIconSize(QSize(iconTaille, iconTaille))
        boutMarqDebutSelect.setToolTip(_(u"Marquer le début de la sélection"))
        boiteMarque.addWidget(boutMarqDebutSelect)

        self.boutMarqFinSelect = QPushButton()
        self.boutMarqFinSelect.setIcon(QIcon("Icones" + os.sep + "Tfin.png"))
        self.boutMarqFinSelect.setIconSize(QSize(iconTaille, iconTaille))
        self.boutMarqFinSelect.setToolTip(_(u"Marquer la fin de la sélection"))
        self.boutMarqFinSelect.setEnabled(False)
        boiteMarque.addWidget(self.boutMarqFinSelect)

        boutMarqDebutSelect_min = QPushButton()
        boutMarqDebutSelect_min.setIcon(QIcon("Icones" + os.sep + "Tdebut2.png"))
        boutMarqDebutSelect_min.setIconSize(QSize(iconTaille, iconTaille))
        boutMarqDebutSelect_min.setToolTip(_(u"Marquer le début de la sélection au temps minimum (t=0)"))
        boiteMarque.addWidget(boutMarqDebutSelect_min)

        self.boutMarqFinSelect_max = QPushButton()
        self.boutMarqFinSelect_max.setIcon(QIcon("Icones" + os.sep + "Tfin2.png"))
        self.boutMarqFinSelect_max.setIconSize(QSize(iconTaille, iconTaille))
        self.boutMarqFinSelect_max.setToolTip(
            _(u'Marquer la fin de la sélection au temps maximum (t="la durée de la vidéo")')
        )
        self.boutMarqFinSelect_max.setEnabled(False)
        boiteMarque.addWidget(self.boutMarqFinSelect_max)

        boutMiseAZeroSelect = QPushButton()
        boutMiseAZeroSelect.setIcon(QIcon("Icones" + os.sep + "update.png"))
        boutMiseAZeroSelect.setIconSize(QSize(iconTaille, iconTaille))
        boutMiseAZeroSelect.setToolTip(_(u"Remettre à zéro les paramètres"))
        boiteMarque.addWidget(boutMiseAZeroSelect)

        self.boutExtractionSon = QPushButton()
        self.boutExtractionSon.setIcon(QIcon("Icones" + os.sep + "sound.png"))
        self.boutExtractionSon.setIconSize(QSize(iconTaille, iconTaille))
        self.boutExtractionSon.setToolTip(_(u"Pressez le bouton si vous voulez exclure le son de l'extraction vidéo"))
        boiteMarque.addWidget(self.boutExtractionSon)

        # -------------------------------------------------------------------------
        ## Bouton d'augmentation/réduction de la vitesse
        taille = QSize(15, 15)
        speedBox = QVBoxLayout()
        self.moinsvite = QPushButton("-")
        self.moinsvite.setFixedSize(taille)
        self.moinsvite.setToolTip(_(u"Pressez le bouton si vous réduire la vitesse de la vidéo"))
        speedBox.addWidget(self.moinsvite)

        self.initspeed = QPushButton("=")
        self.initspeed.setFixedSize(taille)
        self.initspeed.setToolTip(_(u"Pressez le bouton si vous réinitialiser la vitesse de la vidéo"))
        speedBox.addWidget(self.initspeed)

        self.plusvite = QPushButton("+")
        self.plusvite.setFixedSize(taille)
        self.plusvite.setToolTip(_(u"Pressez le bouton si vous augmenter la vitesse de la vidéo"))
        speedBox.addWidget(self.plusvite)
        boiteMarque.addLayout(speedBox)

        self.connect(self.moinsvite, SIGNAL("clicked()"), self.mplayer.speeddown)
        self.connect(self.initspeed, SIGNAL("clicked()"), self.mplayer.initspeed)
        self.connect(self.plusvite, SIGNAL("clicked()"), self.mplayer.speedup)
        # -------------------------------------------------------------------------

        self.connect(boutMarqDebutSelect, SIGNAL("clicked()"), self.marqDebutSelect)
        self.connect(self.boutMarqFinSelect, SIGNAL("clicked()"), self.marqFinSelect)
        self.connect(boutMarqDebutSelect_min, SIGNAL("clicked()"), self.marqDebutSelect_min)
        self.connect(self.boutMarqFinSelect_max, SIGNAL("clicked()"), self.marqFinSelect_max)
        self.connect(boutMiseAZeroSelect, SIGNAL("clicked()"), self.miseAZeroSelect)
        self.connect(self.boutExtractionSon, SIGNAL("clicked()"), self.reglageSon)

        self.frameMarque.setLayout(boiteMarque)
        # On grise le widget au début
        self.frameMarque.setEnabled(False)

        self.layoutReglage.addWidget(self.frameMarque)
        boiteMarque.addStretch()

        # ||| boutons radio de lecture de la source ou du fichier converti|||#
        hbox = QHBoxLayout()
        hbox.addWidget(self.radioSource)
        hbox.addWidget(self.radioApercu)
        hbox.addWidget(self.radioConvert)
        hbox.setAlignment(Qt.AlignHCenter)
        self.layoutReglage.addLayout(hbox)
        self.layoutReglage.addStretch(50)

        self.addLog()
Ejemplo n.º 2
0
    def addPreview(self, boite='vbox', nomPreview = None, light = False, mode = "Video"):
        # ----------------------------
        # Boite de groupe de mplayer
        # ----------------------------
        group=QGroupBox("")
        if nomPreview == None : nomPreview=_(u'Visionner vidéo')
        else : nomPreview=_(nomPreview)
        vboxMplayer = QVBoxLayout(group)
        if mode =="Video+Audio" :
            vidtitre = QLabel(_(u"Vidéo"))
            vidtitre.setAlignment(Qt.AlignHCenter)
            vboxMplayer.addWidget(vidtitre)

        self.mplayer=Mplayer(taille=(250, 225), choixWidget=(Mplayer.RATIO, Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_SUR_UNE_LIGNE,Mplayer.PAS_PARCOURIR, Mplayer.LIST))
        ## On utilise la nouvelle interface de récupération des vidéos
        self.mplayer.listeVideos = []
        self.mplayer.setEnabled(False)
        hbox = QHBoxLayout()
        hbox.addStretch()
        hbox.addWidget(self.mplayer)
        hbox.addStretch()
        vboxMplayer.addLayout(hbox)
        hbox = QHBoxLayout()
        if not light :
            self.radioSource = QRadioButton(_(u"vidéo(s) source(s)"))
            self.radioSource.setChecked(True)
            self.radioSource.setEnabled(False)
            self.connect(self.radioSource, SIGNAL("toggled(bool)"), self.fctRadioSource)
            self.radioConvert = QRadioButton(_(u"vidéo(s) convertie(s)"))
            self.radioConvert.setEnabled(False)
            self.connect(self.radioConvert, SIGNAL("toggled(bool)"), self.fctRadioConvert)
            self.boutCompare = QPushButton(_(u"Comparateur de vidéos"))
            self.boutCompare.setEnabled(False)

            self.connect(self.boutCompare, SIGNAL("clicked()"), self.widget2Mplayer)
            hbox.addWidget(self.radioSource)
            hbox.addWidget(self.radioConvert)
            hbox.addWidget(self.boutCompare)
            if self.idSection == "animation_filtresvideo":
                self.boutApercu = QPushButton(_(u"Aperçu"))
                self.connect(self.boutApercu, SIGNAL("clicked()"), self.apercu)
                self.boutApercu.setEnabled(False)
                hbox.addWidget(self.boutApercu)

        if mode =="Video+Audio" :
            self.mplayerA=Mplayer(taille=(250, 225), choixWidget=(Mplayer.RATIO,Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_SUR_UNE_LIGNE,Mplayer.PAS_PARCOURIR))
            self.mplayerA.setAudio(True)
            self.mplayerA.listeVideos = []
            self.mplayerA.setEnabled(False)
            hboxA = QHBoxLayout()
            hboxA.addStretch()
            hboxA.addWidget(self.mplayerA)
            hboxA.addStretch()

        hbox.setAlignment(Qt.AlignHCenter)
        vboxMplayer.addLayout(hbox)
        if mode =="Video+Audio" :
            audtitre = QLabel(_(u"Audio"))
            audtitre.setAlignment(Qt.AlignHCenter)
            vboxMplayer.addWidget(audtitre)
            vboxMplayer.addLayout(hboxA)
        vboxMplayer.addStretch()
        group.setAlignment(Qt.AlignHCenter)
        self.add(group, nomPreview)
class Animation_MontagVideoDecoupUneVideo(Base):
    # -------------------------------------------------------------------------------------
    # Cadre accueillant les widgets de : Animation >> Montage Vidéo >> Découper une Vidéo
    # -------------------------------------------------------------------------------------
    def __init__(self, statusBar):
        # -------------------------------
        # Parametres généraux du widget
        # -------------------------------
        # === tout sera mis dans une boîte verticale ===#
        self.vbox = QVBoxLayout()

        # === Variable de configuration ===#
        self.config = EkdConfig

        # === Identifiant de la classe ===#
        self.idSection = "animation_decouper_une_video"

        super(Animation_MontagVideoDecoupUneVideo, self).__init__(
            "vbox", titre=_(u"Montage: Découpage d'une vidéo")
        )  # module de animation

        self.printSection()

        # === Drapeaux ===#
        # drapeau pour savoir si la valeur de début de la sélection vidéo été enregistré
        self.debutEstSelect = False
        # drapeau pour savoir si la valeur de fin de la sélection vidéo été enregistré
        self.finEstSelect = False
        # drapeau d'extraction du son
        self.extraireSon = True

        # -------------------------------------------------------------------
        # Boîte de groupe : "Fichier vidéo source"
        # -------------------------------------------------------------------
        self.afficheurVideoSource = SelectWidget(
            extensions=["*.avi", "*.mpg", "*.mpeg", "*.mjpeg", "*.flv", "*.mp4", "*.dv", "*.vob"],
            mode="texte",
            video=True,
        )
        # Onglets
        self.indexVideoSource = self.add(self.afficheurVideoSource, _(u"Video(s) source"))
        self.connect(self.afficheurVideoSource, SIGNAL("fileSelected"), self.getFile)
        self.connect(self.afficheurVideoSource, SIGNAL("pictureChanged(int)"), self.getFile)
        # --------------------------------------------------------------------

        ## ---------------------------------------------------------------------
        # Variables pour la fonction tampon
        ## ---------------------------------------------------------------------
        self.typeEntree = "video"  # Défini le type de fichier source.
        self.typeSortie = "video"  # Défini le type de fichier de sortie.
        self.sourceEntrees = self.afficheurVideoSource  # Fait le lien avec le sélecteur de fichier source.

        # --------------------------------------------------------------------------
        # Boîte de groupe de réglage: visualisation et de marquage de la sélection
        # --------------------------------------------------------------------------

        # Création de la boite de groupe de réglage (contenant la boite self.layoutReglage)
        reglageGroup = QGroupBox()
        self.layoutReglage = QVBoxLayout(reglageGroup)
        # === Widgets mplayer ===#
        vboxMplayer = QVBoxLayout()
        # Le facteur limitant est la largeur -> + simple à coder à cause de la largeur de la barre
        self.mplayer = Mplayer(
            taille=(300, 270),
            facteurLimitant=Mplayer.LARGEUR,
            choixWidget=(Mplayer.RATIO, Mplayer.PAS_PRECEDENT_SUIVANT, Mplayer.CURSEUR_A_PART),
        )

        self.mplayer.listeVideos = []
        self.mplayer.setToolTip(
            _(u"La lecture de la vidéo est nécessaire pour achever la sélection d'une zone de la vidéo")
        )
        self.mplayer.setEnabled(False)
        hbox = QHBoxLayout()
        hbox.addStretch()
        hbox.addWidget(self.mplayer)
        hbox.addStretch()
        vboxMplayer.addLayout(hbox)

        self.radioSource = QRadioButton(_(u"vidéo(s) source(s)"))
        self.radioSource.setChecked(True)
        self.radioSource.setEnabled(False)
        self.connect(self.radioSource, SIGNAL("clicked(bool)"), self.fctRadioSource)
        self.radioApercu = QRadioButton(_(u"aperçu"))
        self.radioApercu.setEnabled(False)
        self.connect(self.radioApercu, SIGNAL("clicked(bool)"), self.fctRadioApercu)
        self.radioConvert = QRadioButton(_(u"vidéo convertie"))
        self.radioConvert.setEnabled(False)
        self.connect(self.radioConvert, SIGNAL("clicked(bool)"), self.fctRadioConvert)

        self.layoutReglage.addLayout(vboxMplayer)

        self.add(reglageGroup, _(u"Réglages"))
        # Le widget-mplayer récupère des informations tous les 10ème
        # de seconde au lieu de toutes les secondes -> le marquage du
        # début et de la fin de la sélection seront plus précis
        self.mplayer.dureeTimer = 100

        self.connect(self.mplayer.bout_LectPause, SIGNAL("clicked()"), self.lectureMPlayer)

        # === Marquage et affichage des bornes de la sélection ===#

        # ||| Label de visualisation de la sélection |||#

        self.marques = (0, 0, 1)
        self.visuSelect = Label(self.marques, 300)
        self.visuSelect.setToolTip(_(u"La zone sélectionnée apparait en vert dans cette bande"))
        self.valeurDebut = 0
        self.valeurFin = 0

        hbox = QHBoxLayout()
        hbox.addWidget(self.visuSelect)
        self.layoutReglage.addLayout(hbox)

        # ||| boutons de marquage de la sélection |||#

        iconTaille = 28

        self.frameMarque = QFrame()
        boiteMarque = QHBoxLayout()
        boiteMarque.addStretch()

        boutMarqDebutSelect = QPushButton()
        boutMarqDebutSelect.setIcon(QIcon("Icones" + os.sep + "Tdebut.png"))
        boutMarqDebutSelect.setIconSize(QSize(iconTaille, iconTaille))
        boutMarqDebutSelect.setToolTip(_(u"Marquer le début de la sélection"))
        boiteMarque.addWidget(boutMarqDebutSelect)

        self.boutMarqFinSelect = QPushButton()
        self.boutMarqFinSelect.setIcon(QIcon("Icones" + os.sep + "Tfin.png"))
        self.boutMarqFinSelect.setIconSize(QSize(iconTaille, iconTaille))
        self.boutMarqFinSelect.setToolTip(_(u"Marquer la fin de la sélection"))
        self.boutMarqFinSelect.setEnabled(False)
        boiteMarque.addWidget(self.boutMarqFinSelect)

        boutMarqDebutSelect_min = QPushButton()
        boutMarqDebutSelect_min.setIcon(QIcon("Icones" + os.sep + "Tdebut2.png"))
        boutMarqDebutSelect_min.setIconSize(QSize(iconTaille, iconTaille))
        boutMarqDebutSelect_min.setToolTip(_(u"Marquer le début de la sélection au temps minimum (t=0)"))
        boiteMarque.addWidget(boutMarqDebutSelect_min)

        self.boutMarqFinSelect_max = QPushButton()
        self.boutMarqFinSelect_max.setIcon(QIcon("Icones" + os.sep + "Tfin2.png"))
        self.boutMarqFinSelect_max.setIconSize(QSize(iconTaille, iconTaille))
        self.boutMarqFinSelect_max.setToolTip(
            _(u'Marquer la fin de la sélection au temps maximum (t="la durée de la vidéo")')
        )
        self.boutMarqFinSelect_max.setEnabled(False)
        boiteMarque.addWidget(self.boutMarqFinSelect_max)

        boutMiseAZeroSelect = QPushButton()
        boutMiseAZeroSelect.setIcon(QIcon("Icones" + os.sep + "update.png"))
        boutMiseAZeroSelect.setIconSize(QSize(iconTaille, iconTaille))
        boutMiseAZeroSelect.setToolTip(_(u"Remettre à zéro les paramètres"))
        boiteMarque.addWidget(boutMiseAZeroSelect)

        self.boutExtractionSon = QPushButton()
        self.boutExtractionSon.setIcon(QIcon("Icones" + os.sep + "sound.png"))
        self.boutExtractionSon.setIconSize(QSize(iconTaille, iconTaille))
        self.boutExtractionSon.setToolTip(_(u"Pressez le bouton si vous voulez exclure le son de l'extraction vidéo"))
        boiteMarque.addWidget(self.boutExtractionSon)

        # -------------------------------------------------------------------------
        ## Bouton d'augmentation/réduction de la vitesse
        taille = QSize(15, 15)
        speedBox = QVBoxLayout()
        self.moinsvite = QPushButton("-")
        self.moinsvite.setFixedSize(taille)
        self.moinsvite.setToolTip(_(u"Pressez le bouton si vous réduire la vitesse de la vidéo"))
        speedBox.addWidget(self.moinsvite)

        self.initspeed = QPushButton("=")
        self.initspeed.setFixedSize(taille)
        self.initspeed.setToolTip(_(u"Pressez le bouton si vous réinitialiser la vitesse de la vidéo"))
        speedBox.addWidget(self.initspeed)

        self.plusvite = QPushButton("+")
        self.plusvite.setFixedSize(taille)
        self.plusvite.setToolTip(_(u"Pressez le bouton si vous augmenter la vitesse de la vidéo"))
        speedBox.addWidget(self.plusvite)
        boiteMarque.addLayout(speedBox)

        self.connect(self.moinsvite, SIGNAL("clicked()"), self.mplayer.speeddown)
        self.connect(self.initspeed, SIGNAL("clicked()"), self.mplayer.initspeed)
        self.connect(self.plusvite, SIGNAL("clicked()"), self.mplayer.speedup)
        # -------------------------------------------------------------------------

        self.connect(boutMarqDebutSelect, SIGNAL("clicked()"), self.marqDebutSelect)
        self.connect(self.boutMarqFinSelect, SIGNAL("clicked()"), self.marqFinSelect)
        self.connect(boutMarqDebutSelect_min, SIGNAL("clicked()"), self.marqDebutSelect_min)
        self.connect(self.boutMarqFinSelect_max, SIGNAL("clicked()"), self.marqFinSelect_max)
        self.connect(boutMiseAZeroSelect, SIGNAL("clicked()"), self.miseAZeroSelect)
        self.connect(self.boutExtractionSon, SIGNAL("clicked()"), self.reglageSon)

        self.frameMarque.setLayout(boiteMarque)
        # On grise le widget au début
        self.frameMarque.setEnabled(False)

        self.layoutReglage.addWidget(self.frameMarque)
        boiteMarque.addStretch()

        # ||| boutons radio de lecture de la source ou du fichier converti|||#
        hbox = QHBoxLayout()
        hbox.addWidget(self.radioSource)
        hbox.addWidget(self.radioApercu)
        hbox.addWidget(self.radioConvert)
        hbox.setAlignment(Qt.AlignHCenter)
        self.layoutReglage.addLayout(hbox)
        self.layoutReglage.addStretch(50)

        self.addLog()

    def getFile(self):
        """
		# On utilise la nouvelle interface de récupération des vidéos
		Récupération de la vidéo source selectionnée
		"""
        self.chemin = self.afficheurVideoSource.getFile()
        self.boutApp.setEnabled(True)

        self.mplayer.setEnabled(True)
        self.mplayer.setVideos([self.chemin])

        # On active les réglage
        self.frameMarque.setEnabled(True)
        self.boutMarqFinSelect_max.setEnabled(True)
        self.boutMarqFinSelect.setEnabled(True)
        # Restauration de l'état initial de sélection
        self.radioSource.setEnabled(True)
        self.radioSource.setChecked(True)
        self.radioApercu.setEnabled(False)
        self.radioApercu.setChecked(False)
        self.radioConvert.setEnabled(False)
        self.radioConvert.setChecked(False)

        self.emit(SIGNAL("loaded"))
        self.miseAZeroSelect()

    def lectureMPlayer(self):
        """Dégriser les 2 boutons de sélection de fin si le début a déjà été sélectionné"""
        if self.debutEstSelect:
            self.boutMarqFinSelect.setEnabled(True)
            self.boutMarqFinSelect_max.setEnabled(True)

    def reglageSon(self):
        """Extraire ou pas le son de la vidéo lors de l'extraction vidéo"""
        if self.extraireSon:
            self.extraireSon = False
            self.boutExtractionSon.setIcon(QIcon("Icones" + os.sep + "nosound.png"))
            self.boutExtractionSon.setToolTip(
                _(u"Pressez le bouton si vous voulez ré-inclure le son de l'extraction vidéo")
            )
        else:
            self.extraireSon = True
            self.boutExtractionSon.setIcon(QIcon("Icones" + os.sep + "sound.png"))
            self.boutExtractionSon.setToolTip(
                _(u"Pressez le bouton si vous voulez exclure le son de l'extraction vidéo")
            )

    def miseAZeroSelect(self):
        """On remet à zéro les zones sélectionnées"""
        self.debutEstSelect = False
        self.finEstSelect = False
        self.boutApp.setEnabled(False)
        self.boutMarqFinSelect.setEnabled(False)
        self.boutMarqFinSelect_max.setEnabled(False)
        self.valeurDebut, self.valeurFin = 0, 0
        self.marques = (0, 0, 1)
        self.visuSelect.update_marques(self.marques)
        self.visuSelect.repaint()

    def marqDebutSelect(self):
        """Récupération de la valeur du marqueur du début de la sélection"""

        # Le début n'a pas été sélectionné ou il a été sélectionné mais pas la fin
        # -> un seul trait sur le QLabel
        if not self.debutEstSelect or (self.debutEstSelect and not self.finEstSelect):
            self.valeurDebut = self.mplayer.temps
            # print self.valeurDebut
            EkdPrint(u"%s" % self.valeurDebut)
            self.debutEstSelect = True
            # mplayer est en lecture
            if self.mplayer.estLue:
                self.boutMarqFinSelect.setEnabled(True)
                self.boutMarqFinSelect_max.setEnabled(True)
                # tracer d'un seul trait
            self.marques = (self.valeurDebut, self.valeurDebut, self.mplayer.dureeVideo)
            self.visuSelect.update_marques(self.marques)
            self.visuSelect.repaint()

            # Le début et la fin ont déjà été sélectionnés
        elif self.debutEstSelect and self.finEstSelect:
            self.valeurDebut = self.mplayer.temps
            # print self.valeurDebut
            EkdPrint(u"%s" % self.valeurDebut)
            self.mettreAJourLabel("debut")

    def marqFinSelect(self):
        """Récupération de la valeur du marqueur de la fin de la sélection"""
        self.valeurFin = self.mplayer.temps
        # print self.valeurFin
        EkdPrint(u"%s" % self.valeurFin)
        self.finEstSelect = True
        self.mettreAJourLabel("fin")

    def marqDebutSelect_min(self):
        """La valeur du marqueur du début de la sélection est placé au temps t=0 seconde"""

        # Le début n'a pas été sélectionné ou il a été sélectionné mais pas la fin
        # -> un seul trait sur le QLabel
        if not self.debutEstSelect or (self.debutEstSelect and not self.finEstSelect):
            self.valeurDebut = 0
            # print self.valeurDebut
            EkdPrint(u"%s" % self.valeurDebut)
            self.debutEstSelect = True
            # mplayer est en lecture
            if self.mplayer.estLue:
                self.boutMarqFinSelect.setEnabled(True)
                self.boutMarqFinSelect_max.setEnabled(True)
                # tracer d'un seul trait
            self.marques = (self.valeurDebut, self.valeurDebut, self.mplayer.dureeVideo)
            self.visuSelect.update_marques(self.marques)
            self.visuSelect.repaint()

            # Le début et la fin ont déjà été sélectionnés
        elif self.debutEstSelect and self.finEstSelect:
            self.valeurDebut = 0
            # print self.valeurDebut
            EkdPrint(u"%s" % self.valeurDebut)
            self.mettreAJourLabel()

    def marqFinSelect_max(self):
        """La valeur du marqueur de la fin de la sélection est placé à la fin de la vidéo"""
        self.valeurFin = self.mplayer.dureeVideo
        # print self.valeurFin
        EkdPrint(u"%s" % self.valeurFin)
        self.finEstSelect = True
        self.mettreAJourLabel()

    def mettreAJourLabel(self, debutOuFin=None):
        """Redessiner le QLabel"""

        # si les valeurs de début et de fin sont identiques (possible car notre précision est de un dixième de seconde) alors on remet tout à zéro
        if self.valeurDebut == self.valeurFin:
            self.finEstSelect = False
            self.boutApp.setEnabled(False)
            # tracer d'un seul trait
            self.marques = (self.valeurDebut, self.valeurFin, self.mplayer.dureeVideo)
            self.visuSelect.update_marques(self.marques)
            self.visuSelect.repaint()
            self.radioConvert.setEnabled(False)
            self.radioApercu.setEnabled(False)

            # Truisme: la valeur du début de la sélection doit être inférieure à la valeur de la fin
            # sinon les valeurs de début et de fin sont égalisées
        elif self.valeurDebut > self.valeurFin:
            self.radioSource.setEnabled(False)
            self.radioApercu.setEnabled(False)
            if debutOuFin == "debut":
                self.valeurFin = self.valeurDebut
                self.boutApp.setEnabled(False)
                self.marques = (self.valeurDebut, self.valeurFin, self.mplayer.dureeVideo)
                self.visuSelect.update_marques(self.marques)
                self.visuSelect.repaint()

            if debutOuFin == "fin":
                self.valeurDebut = self.valeurFin
                self.boutApp.setEnabled(False)
                self.marques = (self.valeurDebut, self.valeurFin, self.mplayer.dureeVideo)
                self.visuSelect.update_marques(self.marques)
                self.visuSelect.repaint()
                # Le cas normal
        else:
            self.marques = (self.valeurDebut, self.valeurFin, self.mplayer.dureeVideo)
            self.visuSelect.update_marques(self.marques)
            self.visuSelect.repaint()
            self.boutApp.setEnabled(True)
            self.radioSource.setEnabled(True)
            self.radioApercu.setEnabled(True)

            # print "Bornes de la sélection :", self.valeurDebut, self.valeurFin, type(self.valeurDebut), type(self.valeurFin)
        EkdPrint(
            u"Bornes de la sélection : %s %s %s" % (self.valeurDebut, self.valeurFin, type(self.valeurDebut)),
            type(self.valeurFin),
        )

    def fctRadioSource(self):
        """"Communique le fichier source à mplayer"""
        self.mplayer.listeVideos = [self.chemin]
        self.mplayer.debutFin = (0, 0)
        self.frameMarque.setEnabled(True)
        self.visuSelect.setEnabled(True)
        self.radioApercu.setChecked(False)
        self.radioConvert.setChecked(False)

    def fctRadioApercu(self):
        """"Communique le fichier aperçu à mplayer"""
        self.mplayer.listeVideos = [self.chemin]
        debut = float("%.1f" % self.valeurDebut)
        fin = float("%.1f" % self.valeurFin)
        self.mplayer.debutFin = (debut, fin)
        self.frameMarque.setEnabled(False)
        self.radioSource.setChecked(False)
        self.radioConvert.setChecked(False)

    def fctRadioConvert(self):
        """"Communique le fichier converti à mplayer"""
        self.mplayer.listeVideos = [self.fichierSortie]
        self.mplayer.debutFin = (0, 0)
        self.frameMarque.setEnabled(False)
        self.visuSelect.setEnabled(False)
        self.radioSource.setChecked(False)
        self.radioApercu.setChecked(False)

    def ouvrirSource(self, nomEntree=None):
        """Récupération du chemin de la vidéo sélectionnée et activation de certains widgets"""

        # Récupération du chemin de la vidéo
        chemin = self.recupSource(nomEntree)

        if not chemin:
            return

        # Affichage du chemin + nom de fichier dans la ligne d'édition
        self.ligneEditionSource.setText(chemin)

        self.mplayer.setEnabled(True)
        self.mplayer.listeVideos = [chemin]
        self.radioSource.setChecked(True)
        self.radioSource.setEnabled(False)
        self.radioConvert.setEnabled(False)

        # les boutons de marquage apparaissent
        self.frameMarque.setEnabled(True)

        # Utile lors de la sélection d'une 2ème vidéo et au-delà
        self.miseAZeroSelect()

    def afficherAide(self):
        """ Boîte de dialogue de l'aide du cadre Animation > Encodage """

        super(Animation_MontagVideoDecoupUneVideo, self).afficherAide(
            _(
                u"""<p><b>Vous pouvez ici découper une vidéo et ainsi en garder uniquement la partie qui vous intéresse.</b></p><p><font color='green'>Ce cadre est assez différent des autres, vous avez tout d'abord la zone de visualisation vidéo, puis en dessous les boutons marche, arrêt et le compteur, la glissière de défilement, la zone d'affichage de la découpe (les parties découpées seront affichées en vert), les boutons début/fin de sélection, remise à zéro (vous pouvez sélectionner ou non le son par le bouton haut parleur), à la doite de ce dernier bouton, vous avez trois minuscules boutons contenant +, = et - (ils servent à accélérer ou diminuer la vitesse de lecture de la vidéo), puis les choix de visualisation <b>'vidéo(s) source(s)'</b>, <b>'vidéo convertie'</b> et le bouton <b>'Comparateur de vidéos'</b>.</font></p><p><b>Tout ce qui vient de vous être décrit se trouve dans l'onglet Réglages</b>.</p><p>Dans l'onglet <b>'Vidéo(s) source'</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher la/les vidéo(s). Si vous voulez sélectionner plusieurs vidéos d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos vidéos), cliquez sur <b>Ajouter</b>.</p><p>Vous pouvez dès lors sélectionner une vidéo dans la liste et la visionner (par le bouton juste à la droite de cette liste), vous noterez que vous pouvez visionner la vidéo en quatre tiers, en seize neuvième ou avec les proportions d'origine de la vidéo (w;h). De même si vous le désirez, vous pouvez obtenir des informations complètes sur la vidéo sélectionnée, et ce par le bouton <b>'Infos'</b> (en bas).</p><p>Dans l'onglet <b>'Réglages'</b>, lisez la vidéo (par le bouton avec la flèche orientée vers la droite <b>'La lecture de la vidéo est nécessaire ...'</b>), pour la vitesse de lecture, profitez des boutons + ou - pour augmenter ou diminuer la vitesse de lecture <b>(plus vous diminuez la vitesse de lecture, plus la découpe pourra se faire de façon précise)</b>, cliquez ensuite sur le bouton <b>'Marquer le début de la sélection'</b> ou <b>'Marquer le début de la sélection au temps minimum (t=0)'</b> (pour sélectionner la vidéo à son tout début), laissez jouer (regardez la vidéo défiler) et cliquez sur le bouton <b>'Marquer la fin de la sélection'</b> au moment propice (ou <b>'Marquer la fin de la sélection au temps maximum t="la durée de la vidéo"'</b> pour garder la dite vidéo jusqu'à la fin).</p><p><font color='blue'>Sachez que vous pouvez revenir aux paramètres par défaut en cliquant sur le bouton <b>'Remettre à zéro les paramètres'</b> (les deux flèches vertes inversées), vous devrez alors rejouer la vidéo et recommencer vos différentes sélections.</font></p><p>Cliquez sur le bouton <b>'Appliquer'</b>, sélectionnez le répertoire de sauvegarde de votre vidéo, entrez le <b>'Nom de Fichier'</b> dans le champ de texte réservé à cet effet ... cliquez sur le bouton <b>'Enregistrer'</b> et attendez le temps de la conversion. A la fin cliquez sur le bouton <b>'Voir les informations d'encodage'</b> et fermez cette dernière fenêtre après avoir vu les informations en question.</p><p>Vous pouvez visionner votre vidéo (avant la conversion) en sélectionnant <b>'vidéo(s) source(s)'</b>, après la conversion <b>'vidéo convertie'</b> ou bien encore les deux en même temps, en cliquant sur le bouton <b>'Comparateur de vidéos'</b>.</p><p>L'onglet <b>'Infos'</b> vous permet de voir les vidéos et fichiers audio chargés (avec leurs chemins exacts) avant et après conversion.</p>"""
            )
        )

    def appliquer(self):
        """Découpage de la vidéo"""

        # Récupération du chemin source
        chemin = unicode(self.chemin)
        # suffix du fichier actif
        suffix = os.path.splitext(chemin)[1]
        # Modifié le 30/06/2009 : On joue avec l'éritage de Base
        saveDialog = EkdSaveDialog(self, mode="video", suffix=suffix, title=_(u"Sauver"))

        cheminFichierEnregistrerVideo = saveDialog.getFile()

        if not cheminFichierEnregistrerVideo:
            return
        ###########################################################################################################################

        tempsDebut = float("%.1f" % self.valeurDebut)
        tempsFin = float("%.1f" % self.valeurFin)
        dureeSelection = str(tempsFin - tempsDebut)
        #

        # Extension du fichier
        # print "extension :", suffix, type(suffix)
        EkdPrint(u"extension : %s %s" % (suffix, type(suffix)))

        try:
            mencoder = WidgetMEncoder(
                "decoupervideo",
                chemin,
                cheminFichierEnregistrerVideo,
                valeurNum=(str(tempsDebut), str(dureeSelection)),
                optionSpeciale=self.extraireSon,
                laisserOuvert=1,
            )
            mencoder.setWindowTitle(_(u"Découper une vidéo"))
            mencoder.exec_()
        except:
            messageErrAnEnc = QMessageBox(self)
            messageErrAnEnc.setText(_(u'Un problème est survenu lors de l\'exécution de "mencoder -ss ..."'))
            messageErrAnEnc.setWindowTitle(_(u"Error"))
            messageErrAnEnc.setIcon(QMessageBox.Warning)
            messageErrAnEnc.exec_()
            return

        self.fichierSortie = cheminFichierEnregistrerVideo
        self.radioSource.setEnabled(True)
        self.radioSource.setChecked(False)
        self.radioConvert.setEnabled(True)
        self.radioConvert.setChecked(True)
        ### Information à l'utilisateur
        self.infoLog(None, chemin, None, cheminFichierEnregistrerVideo)

    def saveFiles(self):
        """
		# On sauvegarde la liste des fichiers chargés
		"""
        self.afficheurVideoSource.saveFileLocation(self.idSection)
        # Ajout de la sauvegarde des positions début et fin
        EkdConfig.set(self.idSection, u"valeurDebut", unicode(self.valeurDebut))
        EkdConfig.set(self.idSection, u"valeurFin", unicode(self.valeurFin))

    def loadFiles(self):
        """
		# On sauvegarde la liste des fichiers chargés
		"""
        self.afficheurVideoSource.loadFileLocation(self.idSection)
        self.valeurDebut = float(EkdConfig.get(self.idSection, "valeurDebut"))
        self.valeurFin = float(EkdConfig.get(self.idSection, "valeurFin"))
        self.mettreAJourLabel("debut")
        self.mettreAJourLabel("fin")

    def load(self):
        """
		Chargement de la configuration de tous les objets
		"""
        self.loadFiles()

    def save(self):
        """
		Sauvegarde de la configuration de tous les objets
		"""
        self.saveFiles()
Ejemplo n.º 4
0
class Base(QWidget):
    """
        Module des cadres de l'onglet animation
    """

    Audio = 1
    Video = 2

    def __init__(self, boite='grid', nomReglage=None, nomSource=None, titre="None", parent=None):
        super(Base, self).__init__(parent)
        # Taille du widget mplayer
        self.tailleMplayer = (240,216)

        # Définition du titre
        self.Titre =  QLabel()
        self.setTitle(titre)

        # Définition des tabs
        #----------------------------------------------------------------
        self.Source =  QLabel("<h1>Source</h1>")
        self.Reglage =  QLabel("<h1>Reglage</h1>")
        self.Preview = QLabel("<h1>Preview</h1>")
        self.Logs = QLabel("<h1>Logs</h1>")

        self.tab = QTabWidget()
        self.scroll = QScrollArea()
        self.scroll.setWidget(self.tab)
        self.scroll.setWidgetResizable(True)

        self.connect(self.tab, SIGNAL("currentChanged (int)"), self.activateTab)

        # Definition du layout :
        #| Titre                            |
        # ----------------------------------
        #| tabOuvrir | tabReglage | ... |   |
        #|----------------------------------|
        #|...                               |
        #|----------------------------------|
        #|Aide|                   |Appliquer|
        #'----------------------------------'
        self.layout = QVBoxLayout(self)
        self.layout.addWidget(self.Titre)
        #self.layout.addWidget(self.tab)
        self.layout.addWidget(self.scroll)
        #----------------------------------------------------------------

        self.boutAide=QPushButton(_(u"Aide"))
        self.boutAide.setIcon(QIcon("Icones" + os.sep + "icone_aide_128.png"))
        self.connect(self.boutAide, SIGNAL("clicked()"), self.afficherAide)

        #self.tamponBut = QPushButton(QIcon("Icones"+os.sep+"icone_load_128.png"), _(u"Tampon test"))
        #self.connect(self.tamponBut, SIGNAL("clicked()"), self.tamponAction)

        # On ajoute des bouton pour forcer l'utilisateur à vérifier ses réglages
        self.Next = QPushButton(_(u"Réglages"))
        ####################################################################
        self.Next.setIcon(QIcon("Icones" + os.sep + "droite.png"))
        ####################################################################
        self.connect(self.Next, SIGNAL("clicked()"), self.next)

        self.boutApp=QPushButton(_(u"Appliquer"))
        self.boutApp.setIcon(QIcon("Icones" + os.sep + "icone_appliquer_128.png"))
        ## Le bouton doit toujours être désactivé à l'initialisation
        self.boutApp.setEnabled(False)

        self.connect(self.boutApp, SIGNAL("clicked()"), self.appliquer)

        # ligne de séparation juste au dessus des boutons
        ligne = QFrame()
        ligne.setFrameShape(QFrame.HLine)
        ligne.setFrameShadow(QFrame.Sunken)
        self.layout.addWidget(ligne)
        self.layout.addSpacing(-5)      # la ligne doit être plus près des boutons

        hbox=QHBoxLayout()
        hbox.addWidget(self.boutAide)
        #hbox.addWidget(self.tamponBut)
        hbox.addStretch()       # espace entre les 2 boutons
        hbox.addWidget(self.Next)
        hbox.addWidget(self.boutApp)

        self.layout.addLayout(hbox)

    def tamponAction(self) :
      """Fonction à définir dans chaque tableau pour importer les données du tampon"""
      #print u"[DEBUG] Fonction tamponAction non implémentée dans le tableau ", self.idSection
      EkdPrint(u"[DEBUG] Fonction tamponAction non implémentée dans le tableau %s" % self.idSection)

    def setTitle(self, titre=_(u"Title")):
        titre=u"<h2>" + titre + u"</h2>"
        self.Titre.setText(titre)

    def add(self, objet, nom=_(u"Onglet")):
        self.tab.addTab(objet, nom)

    def activateTab(self, index):
        tabCount = self.tab.count()
        if 0 == index :
            self.Next.setText(_(u"Réglages"))
        elif ( tabCount - 1 ) == index :
            self.Next.setText(_(u"Recommencer"))
        elif (tabCount - 2) == index :
            self.Next.setText(_(u"Infos supplémentaires"))
        else:
            self.Next.setText(_(u"Suivant"))

    def next(self):
        tabCount = self.tab.count()
        index = self.tab.currentIndex()
        index = (index + 1) % tabCount
        self.tab.setCurrentIndex(index)

    #----------------
    # Meta-widgets
    #----------------


    def addSource(self, type, nomSource=None):
        """ Boîte de groupe : "Fichier vidéo source" """
        if type == Base.Video :
            if not nomSource: nomSource=_(u'Vidéo source')
            self.ligneEditionSource=QLineEdit()
            self.ligneEditionSource.setReadOnly(True)
            boutParcourir=QPushButton(_(u'Parcourir...'))
            boutParcourir.setIcon(QIcon("Icones/ouvrir.png"))
            self.connect(boutParcourir, SIGNAL("clicked()"), self.ouvrirSource)

            groupSource=QGroupBox(nomSource)
            hbox=QHBoxLayout(groupSource)
            hbox.addWidget(self.ligneEditionSource)
            hbox.addWidget(boutParcourir)
            self.Source = groupSource
            self.tabOuvrirVideo  = self.tab.addTab(self.Source, nomSource)

        else :
            if not nomSource: nomSource=_(u"Fichier audio source")
            self.ligneEditionSourceAudio=QLineEdit()
            self.ligneEditionSourceAudio.setReadOnly(True)

            boutParcourir=QPushButton(_(u'Parcourir...'))
            boutParcourir.setIcon(QIcon("Icones/ouvrir.png"))
            self.connect(boutParcourir, SIGNAL("clicked()"), self.ouvrirSource)

            groupSource=QGroupBox(nomSource)
            hbox=QHBoxLayout(groupSource)
            hbox.addWidget(self.ligneEditionSourceAudio)
            hbox.addWidget(boutParcourir)
            self.Source = groupSource
            self.tabOuvrirAudio = self.tab.addTab(self.Source, nomSource)


    def addReglage(self, boite='hbox', nomReglage = None):
        """ Boîte de groupe de réglage """
        if not nomReglage: nomReglage=_(u"Réglages")
        self.groupReglage=QGroupBox()

        if boite=='vbox':
            self.layoutReglage = QVBoxLayout(self.groupReglage)
        elif boite=='hbox':
            self.layoutReglage = QHBoxLayout(self.groupReglage)
        elif boite=='grid':
            self.layoutReglage = QGridLayout(self.groupReglage)

        self.Reglage = self.groupReglage
        self.add(self.Reglage, nomReglage)



    def addPreview(self, boite='vbox', nomPreview = None, light = False, mode = "Video"):
        # ----------------------------
        # Boite de groupe de mplayer
        # ----------------------------
        group=QGroupBox("")
        if nomPreview == None : nomPreview=_(u'Visionner vidéo')
        else : nomPreview=_(nomPreview)
        vboxMplayer = QVBoxLayout(group)
        if mode =="Video+Audio" :
            vidtitre = QLabel(_(u"Vidéo"))
            vidtitre.setAlignment(Qt.AlignHCenter)
            vboxMplayer.addWidget(vidtitre)

        self.mplayer=Mplayer(taille=(250, 225), choixWidget=(Mplayer.RATIO, Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_SUR_UNE_LIGNE,Mplayer.PAS_PARCOURIR, Mplayer.LIST))
        ## On utilise la nouvelle interface de récupération des vidéos
        self.mplayer.listeVideos = []
        self.mplayer.setEnabled(False)
        hbox = QHBoxLayout()
        hbox.addStretch()
        hbox.addWidget(self.mplayer)
        hbox.addStretch()
        vboxMplayer.addLayout(hbox)
        hbox = QHBoxLayout()
        if not light :
            self.radioSource = QRadioButton(_(u"vidéo(s) source(s)"))
            self.radioSource.setChecked(True)
            self.radioSource.setEnabled(False)
            self.connect(self.radioSource, SIGNAL("toggled(bool)"), self.fctRadioSource)
            self.radioConvert = QRadioButton(_(u"vidéo(s) convertie(s)"))
            self.radioConvert.setEnabled(False)
            self.connect(self.radioConvert, SIGNAL("toggled(bool)"), self.fctRadioConvert)
            self.boutCompare = QPushButton(_(u"Comparateur de vidéos"))
            self.boutCompare.setEnabled(False)

            self.connect(self.boutCompare, SIGNAL("clicked()"), self.widget2Mplayer)
            hbox.addWidget(self.radioSource)
            hbox.addWidget(self.radioConvert)
            hbox.addWidget(self.boutCompare)
            if self.idSection == "animation_filtresvideo":
                self.boutApercu = QPushButton(_(u"Aperçu"))
                self.connect(self.boutApercu, SIGNAL("clicked()"), self.apercu)
                self.boutApercu.setEnabled(False)
                hbox.addWidget(self.boutApercu)

        if mode =="Video+Audio" :
            self.mplayerA=Mplayer(taille=(250, 225), choixWidget=(Mplayer.RATIO,Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_SUR_UNE_LIGNE,Mplayer.PAS_PARCOURIR))
            self.mplayerA.setAudio(True)
            self.mplayerA.listeVideos = []
            self.mplayerA.setEnabled(False)
            hboxA = QHBoxLayout()
            hboxA.addStretch()
            hboxA.addWidget(self.mplayerA)
            hboxA.addStretch()

        hbox.setAlignment(Qt.AlignHCenter)
        vboxMplayer.addLayout(hbox)
        if mode =="Video+Audio" :
            audtitre = QLabel(_(u"Audio"))
            audtitre.setAlignment(Qt.AlignHCenter)
            vboxMplayer.addWidget(audtitre)
            vboxMplayer.addLayout(hboxA)
        vboxMplayer.addStretch()
        group.setAlignment(Qt.AlignHCenter)
        self.add(group, nomPreview)

    def addLog(self):
        self.Logs = QTextEdit()
        self.tabLog = self.add(self.Logs, _(u'Infos'))



    def infoLog(self, image=None, video=None, audio=None, sortie=None) :
        """Fonction pour la mise à jour des informations de log données à l'utilisateur en fin de process sur les données entrées, et le résultat du process"""
        if image != None :
            if type(image) == list :
                msgIm = _(u"<p>####################################<br># Images chargées<br>####################################</p>")
                for im in image :
                    msgIm += unicode(im)+u"<br>"
            else :
                msgIm = _(u"<p>####################################<br># Image chargée<br>####################################</p>")+unicode(image)+u"<br>"
        else :
            msgIm = u""

        if video != None :
            if type(video) == list :
                msgVid = _(u"<p>####################################<br># Vidéos chargées<br>####################################</p>")
                for vid in video :
                    msgVid += unicode(vid)+u"<br>"
            else :
                msgVid = _(u"<p>####################################<br># Vidéo chargée<br>####################################</p>")+unicode(video)+u"<br>"
        else :
            msgVid = u""

        if audio != None :
            if type(audio) == list :
                msgAu = _(u"<p>####################################<br># Fichiers audio chargés<br>####################################</p>")
                for au in audio :
                    msgAu += unicode(au)+u"<br>"
            else :
                msgAu = _(u"<p>####################################<br># Fichier audio chargé<br>####################################</p>")+unicode(audio)+u"<br>"
        else :
            msgAu = u""

        if sortie != None :
            if type(sortie) == list :
                msgOut = _(u"<p>####################################<br># Fichiers de sortie<br>####################################</p>")
                for out in sortie :
                    msgOut += unicode(out)+u"<br>"
            else :
                msgOut = _(u"<p>####################################<br># Fichier de sortie<br>####################################</p>")+unicode(sortie)+u"<br>"
        else :
            msgOut = _(u"<p>Sortie non définie ???</br>")
        messageLog = QString(msgIm+msgVid+msgAu+msgOut)
        self.Logs.setHtml(messageLog)

    def widget2Mplayer(self):
        """Boite de dialogue de comparaison de vidéos"""

        if type(self.chemin) == list :
            chemin = self.chemin
        else :
            chemin = [self.chemin]

        mplayerAvantConv=Mplayer(chemin, (350,262), (Mplayer.RATIO, Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_SUR_UNE_LIGNE,Mplayer.PAS_PARCOURIR, Mplayer.LIST))

        # Widget-mplayer après encodage: lecture du fichier de sortie

        mplayerApresConv=Mplayer(self.lstFichiersSortie, (350,262), (Mplayer.RATIO, Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_SUR_UNE_LIGNE,Mplayer.PAS_PARCOURIR, Mplayer.LIST))

        #print "Affichage de la meta-barre mplayer"
	EkdPrint(u"Affichage de la meta-barre mplayer")
        metaMPlayer = MetaMPlayer(mplayerAvantConv,mplayerApresConv)
        metaMPlayer.exec_()

    #---------------------
    # Fonctions communes
    #---------------------

    def fctRadioSource(self, bool=None):
        """"Communique la vidéo appropriée à mplayer"""
        if bool:
            self.mplayer.setVideos(self.chemin)
            self.mplayer.arretMPlayer()
            try :
                self.radioConvert.setChecked(False)
            except : None

    def fctRadioConvert(self, bool=None):
        """"Communique la vidéo résultat appropriée à mplayer"""
        if bool:
            self.mplayer.arretMPlayer()
            self.mplayer.setVideos(self.lstFichiersSortie)
            try :
                self.radioSource.setChecked(False)
            except : None


    def repSortieProv(self):
        """Répertoire sur lequel s'ouvrira la boite de dialogue de sauvegarde"""
        rep = os.path.dirname(unicode(self.chemin))

        if os.path.exists(rep): return rep
        else: return '~'


    def recupSources(self, nomEntree=None):
        """Récupère les fichiers sources vidéo via une boite de dialogue. Utilise et modifie les paramètres de configuration"""

        if not self.lstFichiersSource: listePleine = False
        else:
            listePleine = True
            fichier = self.lstFichiersSource[0]
            path = os.path.dirname(fichier)

        if listePleine and os.path.exists(path):
            repEntree = path
        else:
            try:
                repEntree = EkdConfig.get('general','video_input_path').decode("UTF8")
            except Exception, e:
                repEntree = '~'
                EkdConfig.set('general','video_input_path', repEntree.encode("UTF8"))
            if not os.path.exists(repEntree):
                repEntree = '~'
                EkdConfig.set('general','video_input_path', repEntree.encode("UTF8"))

        txt = _(u"Fichiers vidéo")
        if not nomEntree:
            liste=QFileDialog.getOpenFileNames(None, _(u"Ouvrir"), os.path.expanduser(repEntree),
                    "%s (*.avi *.mpg *.mpeg *.mjpeg *.flv *.mp4 *.h264 *.dv *.vob)\n*" %txt)
            liste = [unicode(i) for i in liste]
        else: # module séquentiel
            liste = nomEntree

        if len(liste)==0: return
        EkdConfig.set('general','video_input_path',os.path.dirname(liste[0]).encode("UTF8"))

        return liste