def sauverSpin_2(self,i):
		"""conserver le spin dans le fichier de configuration et modifie le curseur"""
		debug("%s %d" % (self.choixCodec,i))
		#EkdConfig.set(self.idSection,self.choixCodec,i)
		EkdConfig.set('animation_encodage_general_bitrate_video',self.choixCodec,i)
		# sauver curseur
		self.curseur_2.setValue(i)

	def __init__(self, statusBar, filer=False):
        	QWidget.__init__(self)
		
		# Boite d'alignement vertical
		vbox=QVBoxLayout(self)
		
		# On ne passe pas tout le parent, mais juste ce dont on a besoin (ici la bar de status)
		# Barre des tâches
		self.statusBar = statusBar

                #-------------------
		# Navigateur de répertoires
		#-------------------
		
		# arborescence des fichiers et dossiers permettant l'affichage
		self.listViewVisioVideo = QListView()

		filtres_option = QDir.AllDirs | QDir.Files | QDir.Readable
		filtres = QStringList()
		filtres << "*.avi" << "*.mpg" << "*.mpeg" << "*.mjpeg" << "*.flv" << "*.mp4" << "*.ogg" << "*.vob" << "*.mov" << "*.h264" << "*.wmv" << "*.3gp"
                sorting = QDir.DirsFirst
                if int(EkdConfig.get("general", "ignore_case")):
                    sorting |= QDir.IgnoreCase
		self.model = QDirModel(filtres, filtres_option, sorting)
		
		try :
			index = self.model.index(EkdConfig.get('general', 'video_input_path'))
		except Exception, e:
			index = self.model.index(QDir.homePath())

	def changerReglagesNbrImgSec(self):
		"Fonction pour collecte du nombre d'images/seconde en sortie"
		# Afficher la valeur choisie par l'utilisateur du nbre d'img/sec
		self.select_nbreImgSec = self.nbrImage.value()
		#print "Valeur du nombre d'images par seconde:", self.select_nbreImgSec
		EkdPrint(u"Valeur du nombre d'images par seconde: %s" % self.select_nbreImgSec)
		EkdConfig.set(self.idSection, 'images_par_seconde', self.select_nbreImgSec)

	def changerReglagesQual(self):
		"Fonction pour collecte de la qualité de la vidéo en sortie"
		# Afficher la valeur choisie par l'utilisateur de la qualité de la vidéo
		self.select_qualite = self.qualite.value()
		#print "Valeur de la qualité de la vidéo:", self.select_qualite
		EkdPrint(u"Valeur de la qualité de la vidéo: %s" % self.select_qualite)
		EkdConfig.set(self.idSection, 'qualite', self.select_qualite)

	def nouvelleResolution(self):
		"""Mets une liste de chemins vidéos dans l'ordre alpha-numérique si tel est le choix de l'utilisateur"""
		i=self.combo.currentIndex()
		idCombo = str(self.combo.itemData(i).toStringList()[0])
		#print "Combo :", idCombo
		EkdPrint(u"Combo : %s" % idCombo)
		# Si ordre alpha-numérique choisi, alors on ordonne la liste
		if idCombo == '16_9':
			self.idCombo=1.77777
		elif idCombo == '16_10':
			self.idCombo=1.60
		elif idCombo == '4_3':
			self.idCombo=1.33333
		elif idCombo == '5_3':
			self.idCombo=1.66666
		elif idCombo == '1_85':
			self.idCombo=1.85
		elif idCombo == '2_35':
			self.idCombo=2.35
		elif idCombo == '2_39':
			self.idCombo=2.39
		elif idCombo == '2_55':
			self.idCombo=2.55
		######################################################################################
		EkdConfig.set(self.idSection,'type',idCombo)

    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 updateColor(self):
     newcolor = QColorDialog.getColor(QColor.fromRgb(int("%d" % int(self.value, 16))), None )# Non supporté sous Jaunty ??
     if newcolor.isValid():
         self.value = str("%x" % newcolor.rgb())[2:]
         self.color.fill(QColor.fromRgb(int("%d" % int(self.value, 16))))
         self.boutton.setIcon(QIcon(self.color))
         self.line.setText(self.value)
         EkdConfig.set(self.section, self.id, self.value)

	def save(self):
		'''
		Sauvegarde de la configuration de tous les objets
		'''
		self.saveFiles()
		entry = u""
		for files in self.ordreVideo.getListFile() : entry += files+u":"
		EkdConfig.set(self.idSection, u'ordreVideo', entry[:-1])

    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 loadOptions(self):
		"""
		On charge les différentes variables necessaire au widget
		"""
		idCodec = EkdConfig.get(self.idSection,'codec')
		self.codecSortie.setCurrentIndex(int(idCodec))
		resolution = EkdConfig.get(self.idSection,'resolution')
		self.resoSortie.setCurrentIndex(int(resolution))
		frequence = EkdConfig.get(self.idSection,'images_par_seconde')
		self.nbrImage.setValue(int(frequence))
		qualite = EkdConfig.get(self.idSection,'qualite')
		self.qualite.setValue(int(qualite))

	def ouvrirSource(self, nomEntree=None):
		""" Récupération des chemins vidéo sélectionnée """

		# On n'utilise pas le fonction recupSources du fichier animation_base.py contenu dans
		# le répertoire gui_modules_animation car pour cette fonction uniquement les fichiers
		# AVI (donc extension .avi) sont autorisés
		try:
			repEntree = EkdConfig.get('general', 'video_input_path')
		except:
			repEntree = os.path.expanduser('~')
		####################################################################################

		txt = _(u"Fichiers vidéos")

		if not nomEntree:
			liste=QFileDialog.getOpenFileNames(None, _(u"Ouvrir"), repEntree,
				"%s (*.avi *.mpg *.mpeg *.vob)\n" %txt)

			self.liste = [unicode(i) for i in liste]
		####################################################################################

		chemin=self.liste
		if not chemin: return

		## On a récupérer la vidéo, on défini le nouveau chemin par défaut des vidéos
		EkdConfig.set('general', 'video_input_path', os.path.dirname(chemin[0]))

		self.lstFichiersSource = []

		for fichier in chemin:
			self.lstFichiersSource.append(fichier)

		# Appel de la fonction nouvelleResolution pour application 16/9 ou 4/3
		self.nouvelleResolution()
		#print 'self.idCombo', self.idCombo
		EkdPrint(u'self.idCombo %s' % self.idCombo)

		# Le bouton appliquer devient utilisable
		self.boutApp.setEnabled(True)
		self.boutApp.setToolTip("")

		self.mplayer.setEnabled(True)
		self.mplayer.listeVideos = self.lstFichiersSource
		self.radioSource.setChecked(True)
		self.radioSource.setEnabled(False)
		self.radioConvert.setEnabled(False)

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

		self.statusBar.showMessage(_(u"La vidéo résultante ne pourra pas être lue avec tous les logiciels"))

	def load(self):
		'''
		Chargement de la configuration de tous les objets
		'''
		self.loadFiles()
		files = EkdConfig.get(self.idSection, 'ordreVideo')
		if debug : 
			#print files
			EkdPrint(u"%s" % str(files))
		self.ordreVideo.addSoundAction(files.split(u":"))
		files = EkdConfig.get(self.idSection, 'ordreAudio')
		if debug : 
			#print files
			EkdPrint(u"%s" % str(files))
		self.ordreAudio.addSoundAction(files.split(u":"))

    def __init__(self, cheminVideoEntre, cheminFFmpeg=None):

        QThread.__init__(self)

        self.cancel = False

        #=== Paramètres généraux ===#

        self.repTampon = unicode(EkdConfig.getTempDir() + os.sep)
        # Répertoire de sauvegarde ds le rep tampon
        self.rep_audio = self.repTampon  + u'concat_audio' + os.sep

        # Uniquement pour Linux et MacOSX
        if os.name in ['posix', 'mac'] or not cheminFFmpeg  :
            self.cheminFFmpeg=u"ffmpeg"

        elif cheminFFmpeg :
            self.cheminFFmpeg=unicode(cheminFFmpeg)

        # Uniquement pour windows
        else :
            self.cheminFFmpeg=u"ffmpeg"

        # chemin(s) des vidéos chargées
        self.cheminVideoEntre = cheminVideoEntre

    def displayLenght(self) : #QT4 OK
      self.totimage=0
      if self.videof.currentText()=="NTSC" :
        self.n=1
        imgpsec=30
        ips=float(30000/1001)
      else :
        self.n=0
        imgpsec=25
        ips=imgpsec
      dicspeed={"0":1,"1":2,"2":4,"3":5,"4":10,"5":20}
      speedtrans=dicspeed[str(EkdConfig.get("videoporamaconfig","speedt"))]
      frametransition = 100 / speedtrans
      k=0
      while k<self.timeline.columnCount() :
        self.totimage += self.timeline.cellWidget(0,k).imagetime(self.n)[1]+self.timeline.cellWidget(0,k).imagetime(self.n)[2]
        k+=1
      self.totimage+=frametransition

      sec=float(self.totimage) / ips
      seconde=str(sec % 60).split(".")
      minute=int(sec / 60)
      heure=int(minute / 60)
      timesnd="%s:%s:%s.%s" % (str(heure).rjust(2,'0'),str(minute).rjust(2,'0'),seconde[0].rjust(2,'0'),seconde[1].ljust(3,'0')[0:3])
      self.duration.setText(timesnd)

    def checkfirsttime(self,p) : #OK QT4
      a, b, c, d = 0, 0, 0, 0
      pathname = os.path.dirname (sys.argv[0])
      refdir = os.path.abspath (pathname) + os.sep + u"videoporama" + os.sep + u"template" + os.sep
      if p=="o" :
        self.templatedir=unicode(QDir.homePath()) + os.sep + self.parent.configdir
      else :
        self.templatedir=refdir
      if (not os.path.exists(self.templatedir)) :
        print "Configuration directory doesn't exist"
        print "Create configuration directory at "+self.templatedir
        os.makedirs(self.templatedir)

      if (not os.path.exists(self.templatedir + os.sep + u"template_data.idv")) :
        d=1
        reffile=open(refdir + os.sep +u"template_data.idv","r")
        destfile=open(self.templatedir + os.sep + u"template_data.idv","w")
        destfile.write(reffile.read())
        destfile.close()

      ### check or create temporary dir
      self.T = EkdConfig.getTempDir() + os.sep + u"videoporamatmp"
      if (not os.path.exists(self.T)) :
        os.makedirs(self.T)

      if (c or d) :
        print "Configuration files not find (First time open ?)"
        if (a==c and b==d) :
          return False
        else :
          return True
      else :
        return False

    def __init__(self, cheminVideoEntre, valeurNum=0, cheminMEncoder=None):

        QDialog.__init__(self)

        # === Paramètres généraux ===#

        self.repTampon = EkdConfig.getTempDir() + os.sep
        # Répertoire de sauvegarde ds le rep tampon
        self.rep_video_ext_resol = self.repTampon + "video_extension_resol" + os.sep

        # Uniquement pour Linux et MacOSX
        if os.name in ["posix", "mac"] or not cheminMEncoder:
            self.cheminMEncoder = u"mencoder"

        # Uniquement pour windows
        elif os.name == "nt" and cheminMEncoder:
            self.cheminMEncoder = unicode(cheminMEncoder)

        # chemin(s) des vidéos chargées
        self.cheminVideoEntre = cheminVideoEntre

        # valeur de la boite de spin pour l'encodage
        self.valeurNum = valeurNum

        self.fichiers = [os.path.basename(parc) for parc in self.cheminVideoEntre]

        # Appel de la fonction lanceur
        self.lanceur()

	def changerItemQStacked(self, i):
		""" L'entrée sélectionnée de la boîte de combo modifie le QWidget de réglage du codec associée """
		#print "index", i
		EkdPrint(u"index %d" % i)
		idCodec=str(self.combo.itemData(i).toString())
		#print "idCodec:", idCodec, type(idCodec)
		EkdPrint(u"idCodec: %s %s" % (idCodec ,type(idCodec)))
		
		for k in self.listeCombo:
			if k[0]==idCodec:
				# Utilisation de EkdConfig : modification des sections
				if self.idSection == "animation_filtresvideo":
					if k[0] in ('decoupageassiste', 'decoupagelibre'):
						self.filtreDecouper.setStacked(k[0])
				if self.stacked:
					self.stacked.setCurrentIndex(k[2])
		
		EkdConfig.set(self.idSection,'codec', idCodec)

	def ouvrirVideo(self):
		"""Ouverture de la boîte de dialogue de fichiers"""
		txt = u"Fichiers vidéo"
		if self.cheminPourBoutonParcourir:
			chemin = self.cheminPourBoutonParcourir

		else:
			try:
				chemin = EkdConfig.get('general','video_input_path').decode("UTF8")
			except:
				chemin = os.path.expanduser('~')

		liste=QFileDialog.getOpenFileNames(None, u"Ouvrir", chemin, "%s (*.avi *.mpg *.mpeg *.mjpeg *.flv *.mp4 *.ogg *.vob *.mov *.wmv *.3gp *.h264)\n*" %txt)
		if not liste: return
		self.listeVideos = liste
		self.changeRatio(unicode(self.listeVideos[0]))

		chemin = unicode(self.listeVideos[0])
		EkdConfig.set('general','video_input_path',os.path.dirname(chemin).encode("UTF8"))

    def recupSourceAudio(self, nomEntree=None):
        """Récupère le fichier source audio via une boite de dialogue. Utilise et modifie les paramètres de configuration"""

        if self.ligneEditionSource.text().isEmpty(): lignePleine = False
        else:
            lignePleine = True
            fichier = unicode(self.ligneEditionSource.text())
            path = os.path.dirname(fichier)

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

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

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

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