#!/usr/bin/python
# -*- coding: Utf-8 -*-

import os
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui_modules_animation.animation_base_encodageFiltre import Base_EncodageFiltre
from moteur_modules_animation.mencoder import WidgetMEncoder

class Filtres_SansReglages(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés aux filtres : Niveaux de gris, Reserve 
	# pour sous-titres (Expand) et Miroir
	# -------------------------------------------------------------------
	def __init__(self):
		QWidget.__init__(self)
		
		# label texte
		txt1=_(u"Réglage automatique pour ce choix")
		label=QLabel("<center>%s</center>" %txt1)
		
		vbox=QVBoxLayout()
		vbox.addWidget(label)
		self.setLayout(vbox)


class Filtre_Bruit(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au filtre : Bruit 
	# -------------------------------------------------------------------
	def __init__(self,config):
		QWidget.__init__(self)
		
		self.config=config # récupération des paramètres de configuration
		self.idSection = "Animation - FiltresVideo"
		
		#=== boîte de groupe: Luma ===#
		
		hbox = QHBoxLayout()
		
		group = QGroupBox(_(u"Luma (%)"))
		vbox = QVBoxLayout(group)
		
		# boite de combo
		self.comboLuma=QComboBox() # le self sert à afficher des informations sur les items à partir de la fonction
		self.listeCombo=[(_(u'Bruit uniforme'),	'bruituniforme', 'u'),\
			(_(u'Bruit Temporel'),		'bruittemporel', 't'),\
			(_(u'Bruit Temporel M'),	'bruittemporelm', 'a'),\
			(_(u'Haute Qualité'),		'hautequalite', 'h'),\
			(_(u'Mixe du Bruit'),		'mixedubruit', 'p')]
		
		# Insertion des codecs de compression dans la combo box
		for i in self.listeCombo:
                	self.comboLuma.addItem(i[0],QVariant(i[1]))
		
		self.connect(self.comboLuma,SIGNAL("activated(int)"),self.sauverTypeLuma)
		
		self.spinBruitLuma=QSpinBox()
		self.spinBruitLuma.setRange(0,100)
		
		self.curseurBruitLuma = QSlider(Qt.Horizontal)
		self.curseurBruitLuma.setRange(0,100)
		
		vbox.addWidget(self.comboLuma, 0, Qt.AlignHCenter)
		hboxSpinSlider = QHBoxLayout()
		hboxSpinSlider.addWidget(self.spinBruitLuma)
		hboxSpinSlider.addWidget(self.curseurBruitLuma)
		hboxSpinSlider.setAlignment(Qt.AlignHCenter)
		vbox.addLayout(hboxSpinSlider)
		hbox.addWidget(group)
		
		#=== boîte de groupe: Chroma ===#
		
		group = QGroupBox(_(u"Chroma (%)"))
		vbox = QVBoxLayout(group)
		
		self.comboChroma=QComboBox()
		for i in self.listeCombo:
                	self.comboChroma.addItem(i[0],QVariant(i[1]))
		
		self.connect(self.comboLuma,SIGNAL("activated(int)"),self.sauverTypeLuma)
		self.connect(self.comboChroma,SIGNAL("activated(int)"),self.sauverTypeChroma)
		
		self.spinBruitChroma=QSpinBox()
		self.spinBruitChroma.setRange(0,100)
		
		self.curseurBruitChroma = QSlider(Qt.Horizontal)
		self.curseurBruitChroma.setRange(0,100)
		
		vbox.addWidget(self.comboChroma, 0, Qt.AlignHCenter)
		hboxSpinSlider = QHBoxLayout()
		hboxSpinSlider.addWidget(self.spinBruitChroma)
		hboxSpinSlider.addWidget(self.curseurBruitChroma)
		hboxSpinSlider.setAlignment(Qt.AlignHCenter)
		vbox.addLayout(hboxSpinSlider)
		hbox.addWidget(group)
		#hbox.setAlignment(Qt.AlignHCenter)
		
		#=== sauver configuration ===#
		
		# spins
		
		self.connect(self.spinBruitLuma,SIGNAL("valueChanged(int)"),self.sauverSpinLuma)
		self.connect(self.spinBruitChroma,SIGNAL("valueChanged(int)"),self.sauverSpinChroma)
		self.connect(self.curseurBruitLuma, SIGNAL("sliderMoved(int)"), self.curseurLumaBouge)
		self.connect(self.curseurBruitChroma, SIGNAL("sliderMoved(int)"), self.curseurChromaBouge)
		
		try:
			print self.config.get(self.idSection,'valeur_bruit_luma')
			self.spinBruitLuma.setValue(int(self.config.get(self.idSection,'valeur_bruit_luma')))
			print self.config.get(self.idSection,'valeur_bruit_chroma')
			self.spinBruitChroma.setValue(int(self.config.get(self.idSection,'valeur_bruit_chroma')))
		except:
			print "Pas de paramètres de configuration pour:\n\
			Valeur de Bruit Luma ou Bruit Chroma"
		
		# boites de combo: sauvegarde pas encore implémentée
		
		self.comboLuma.setCurrentIndex(1)
		#self.comboLuma.setItemData(1,QVariant('bruittemporel'),1)
		
		
		# affichage des entrée de boite de combo correspondant à celles du fichier de config
		try:
			# affichage du bon type de bruit luma
			print self.config.get(self.idSection,'type_bruit_luma')
			typ = self.config.get(self.idSection,'type_bruit_luma')
			indice = 0 # indice de la ligne de self.listeCombo correspondant au type de bruit
			for i in self.listeCombo:
				if i[1]!=typ:
					indice += 1
				else:
					break
			self.comboLuma.setCurrentIndex(indice)
			
			# affichage du bon type de bruit chroma
			print self.config.get(self.idSection,'type_bruit_chroma')
			typ = self.config.get(self.idSection,'type_bruit_chroma')
			indice = 0 # indice de la ligne de self.listeCombo correspondant au type de bruit
			for i in self.listeCombo:
				if i[1]!=typ:
					indice += 1
				else:
					break
			self.comboChroma.setCurrentIndex(indice)
		except:
			print "Pas de paramètres de configuration pour:\n\
			Type de Bruit Luma ou Bruit Chroma"
		
		self.setLayout(hbox)
	
	def sauverTypeLuma(self,i):
		""" Pas d'utilité pour le moment """
		idLuma = str(self.comboLuma.itemData(i).toStringList()[0])
		print 'identifiant type de bruit luma :', idLuma, '; indice :', i
		self.config.set(self.idSection,'type_bruit_luma',idLuma)
	
	def sauverTypeChroma(self,i):
		""" Pas d'utilité pour le moment """
		idChroma = str(self.comboChroma.itemData(i).toStringList()[0])
		print 'identifiant type de bruit chroma :', idChroma, '; indice :', i
		self.config.set(self.idSection,'type_bruit_chroma',idChroma)
	
	def sauverSpinLuma(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'Luma :',i
		self.config.set(self.idSection,'valeur_bruit_luma',i)
		self.curseurBruitLuma.setValue(i)
	
	def sauverSpinChroma(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'Chroma :',i
		self.config.set(self.idSection,'valeur_bruit_chroma',i)
		self.curseurBruitChroma.setValue(i)
	
	def curseurLumaBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinBruitLuma.setValue(i)
	
	def curseurChromaBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinBruitChroma.setValue(i)


class Filtre_LuminosContrast(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au filtre : Luminosite-contraste
	# -------------------------------------------------------------------
	def __init__(self,config):
		QWidget.__init__(self)
		
		self.config=config # récupération des paramètres de configuration
		self.idSection = "Animation - FiltresVideo"
		
		vbox = QVBoxLayout(self)
		grid=QGridLayout()
		
		# ligne de la luminosité
		self.spinLuminosite=QSpinBox()
		self.spinLuminosite.setRange(-100,100) # 0 par défaut
		grid.addWidget(self.spinLuminosite,1,1)
		
		self.curseurLuminosite = QSlider(Qt.Horizontal)
		self.curseurLuminosite.setRange(-100,100)
		grid.addWidget(self.curseurLuminosite,1,2)
		
		txt1,txt2,txt3=_(u"Luminosité entre -100 et 100 -> "),_(u'-100: Basse'),_(u'100: Haute')
		label=QLabel('%s <font color="green">%s</font> -- <font color="red">%s</font>' %(txt1,txt2,txt3))
		grid.addWidget(label,1,3)
		
		# ligne du contraste
		self.spinContraste=QSpinBox()
		self.spinContraste.setRange(-100,100) # 0 par défaut
		grid.addWidget(self.spinContraste,2,1)
		
		self.curseurContraste = QSlider(Qt.Horizontal)
		self.curseurContraste.setRange(-100,100)
		grid.addWidget(self.curseurContraste,2,2)
		
		txt1,txt2,txt3=_(u"Contraste entre -100 et 100 -> "),_(u'-100: Bas'),_(u'100: Haut')
		label=QLabel('%s <font color="green">%s</font> -- <font color="red">%s</font>' %(txt1,txt2,txt3))
		grid.addWidget(label,2,3)
		
		vbox.addStretch()
		vbox.addLayout(grid)
		vbox.addStretch()
		
		#=== sauver configuration ===#
		
		self.connect(self.spinLuminosite,SIGNAL("valueChanged(int)"),self.sauverSpinLuminosite)
		self.connect(self.spinContraste,SIGNAL("valueChanged(int)"),self.sauverSpinContraste)
		self.connect(self.curseurLuminosite, SIGNAL("sliderMoved(int)"), self.curseurLuminositeBouge)
		self.connect(self.curseurContraste, SIGNAL("sliderMoved(int)"), self.curseurContrasteBouge)
		
		try:
			print self.config.get(self.idSection,'luminosite')
			self.spinLuminosite.setValue(int(self.config.get(self.idSection,'luminosite')))
			print self.config.get(self.idSection,'contraste')
			self.spinContraste.setValue(int(self.config.get(self.idSection,'contraste')))
		except:
			print "Pas de paramètres de configuration pour:\n\
			Bruit Luminosite ou Contraste"
	
	
	def sauverSpinLuminosite(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'Luminosite :',i
		self.config.set(self.idSection,'luminosite',i)
		self.curseurLuminosite.setValue(i)
	
	def sauverSpinContraste(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'Contraste :',i
		self.config.set(self.idSection,'contraste',i)
		self.curseurContraste.setValue(i)
	
	def curseurLuminositeBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinLuminosite.setValue(i)
	
	def curseurContrasteBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinContraste.setValue(i)


class Filtre_Decouper(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au filtre : Decouper (Crop)
	# -------------------------------------------------------------------
	def __init__(self,config):
		QWidget.__init__(self)
		
		self.config=config # récupération des paramètres de configuration
		self.idSection = "Animation - FiltresVideo"
		
		grid=QGridLayout()
		
		# largeur
		self.spinDecouperLarg=QSpinBox()	# self car on va récupérer la variable depuis le moteur
		self.spinDecouperLarg.setRange(1,10000) # 800 par défaut
		grid.addWidget(self.spinDecouperLarg,1,1)
		
		txt1=_(u"Nouvelle Largeur (px)")
		label=QLabel("%s" %txt1)
		grid.addWidget(label,1,2)
		
		# hauteur
		self.spinDecouperLong=QSpinBox()
		self.spinDecouperLong.setRange(1,10000) # 600 par défaut
		grid.addWidget(self.spinDecouperLong,2,1)
		
		txt1=_(u"Nouvelle Hauteur (px)")
		label=QLabel("%s" %txt1)
		grid.addWidget(label,2,2)
		
		grid.setAlignment(Qt.AlignHCenter)
		
		#=== sauver configuration ===#
		
		self.connect(self.spinDecouperLarg,SIGNAL("valueChanged(int)"),self.sauverSpinDecouperLarg)
		self.connect(self.spinDecouperLong,SIGNAL("valueChanged(int)"),self.sauverSpinDecouperLong)
		
		try:
			print self.config.get(self.idSection,'decouper_largeur')
			self.spinDecouperLarg.setValue(int(self.config.get(self.idSection,'decouper_largeur')))
			print self.config.get(self.idSection,'contraste')
			self.spinDecouperLong.setValue(int(self.config.get(self.idSection,'decouper_longueur')))
		except:
			print "Pas de paramètres de configuration pour:\n\
			Decouper Largeur ou Longueur"
		
		self.setLayout(grid)
	
	def sauverSpinDecouperLarg(self,i):
		"""conserver le spin dans le fichier de configuration"""
		print 'Decouper largeur :',i
		self.config.set(self.idSection,'decouper_largeur',i)
	
	def sauverSpinDecouperLong(self,i):
		"""conserver le spin dans le fichier de configuration"""
		print 'Decouper Longueur :',i
		self.config.set(self.idSection,'decouper_longueur',i)


class Filtre_CouleurSaturation(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au filtre : Couleur/Saturation (Hue)
	# -------------------------------------------------------------------
	def __init__(self,config):
		QWidget.__init__(self)
		
		self.config=config # récupération des paramètres de configuration
		
		self.idSection = "Animation - FiltresVideo"
		
		vbox = QVBoxLayout(self)
		grid=QGridLayout()
		
		# ligne de la couleur
		self.spinCouleur=QSpinBox()
		self.spinCouleur.setRange(-180,180) # 0 par défaut
		grid.addWidget(self.spinCouleur,1,1)
		
		self.curseurCouleur=QSlider(Qt.Horizontal)
		self.curseurCouleur.setRange(-180,180)
		grid.addWidget(self.curseurCouleur,1,2)
		
		txt1,txt2,txt3=_(u"Couleur entre -180 et 180 -> "),_(u'-180: Basse'),_(u'180: Haute')
		label=QLabel('%s <font color="green">%s</font> -- <font color="red">%s</font>' %(txt1,txt2,txt3))
		grid.addWidget(label,1,3)
		
		# ligne de la saturation
		self.spinSaturation=QSpinBox()
		self.spinSaturation.setRange(-10,10) # 0 par défaut
		grid.addWidget(self.spinSaturation,2,1)
		
		self.curseurSaturation=QSlider(Qt.Horizontal)
		self.curseurSaturation.setRange(-10,10)
		grid.addWidget(self.curseurSaturation,2,2)
		
		txt1,txt2,txt3=_(u"Saturation entre -10 et 10 -> "),_(u'-10: Basse'),_(u'10: Haute')
		label=QLabel('%s <font color="green">%s</font> -- <font color="red">%s</font>' %(txt1,txt2,txt3))
		grid.addWidget(label,2,3)
		
		vbox.addStretch()
		vbox.addLayout(grid)
		vbox.addStretch()
		
		#=== sauver configuration ===#
		
		self.connect(self.spinCouleur,SIGNAL("valueChanged(int)"),self.sauverSpinCouleur)
		self.connect(self.spinSaturation,SIGNAL("valueChanged(int)"),self.sauverSpinSaturation)
		self.connect(self.curseurCouleur,SIGNAL("sliderMoved(int)"),self.curseurCouleurBouge)
		self.connect(self.curseurSaturation,SIGNAL("sliderMoved(int)"),self.curseurSaturationBouge)
		
		try:
			print self.config.get(self.idSection,'couleur')
			self.spinCouleur.setValue(int(self.config.get(self.idSection,'couleur')))
			print self.config.get(self.idSection,'saturation')
			self.spinSaturation.setValue(int(self.config.get(self.idSection,'saturation')))
		except:
			print "Pas de paramètres de configuration pour:\n\
			Couleur ou Saturation"
	
	def sauverSpinCouleur(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'Couleur :',i
		self.config.set(self.idSection,'couleur',i)
		self.curseurCouleur.setValue(i)
	
	def sauverSpinSaturation(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'Saturation :',i
		self.config.set(self.idSection,'saturation',i)
		self.curseurSaturation.setValue(i)
	
	def curseurCouleurBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinCouleur.setValue(i)
	
	def curseurSaturationBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinSaturation.setValue(i)


class Filtre_FlouBoite(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au filtre : Flou boîte (Boxblur)
	# -------------------------------------------------------------------
	def __init__(self,config):
		QWidget.__init__(self)
		
		self.config=config # récupération des paramètres de configuration
		self.idSection = "Animation - FiltresVideo"
		
		vbox = QVBoxLayout(self)
		grid=QGridLayout()
		
		# ligne du rayon
		self.spinFlouBoiteRayon=QSpinBox()	# self car on va récupérer la variable depuis le moteur
		
		self.spinFlouBoiteRayon.setRange(1,100) # 1 par défaut
		grid.addWidget(self.spinFlouBoiteRayon,1,1)
		
		self.curseurFlouBoiteRayon=QSlider(Qt.Horizontal)
		self.curseurFlouBoiteRayon.setRange(1,100)
		grid.addWidget(self.curseurFlouBoiteRayon,1,2)
		
		txt1=_(u"Rayon du flou (%)")
		label=QLabel("%s" %txt1)
		grid.addWidget(label,1,3)
		
		# ligne de la puissance
		self.spinFlouBoitePuiss=QSpinBox()
		self.spinFlouBoitePuiss.setRange(1, 100) # 1 par défaut
		grid.addWidget(self.spinFlouBoitePuiss,2,1)
		
		self.curseurFlouBoitePuiss=QSlider(Qt.Horizontal)
		self.curseurFlouBoitePuiss.setRange(1,100)
		grid.addWidget(self.curseurFlouBoitePuiss,2,2)
		
		txt1=_(u"Puissance du flou (%)")
		label=QLabel("%s" %txt1)
		grid.addWidget(label,2,3)
		
		vbox.addStretch()
		vbox.addLayout(grid)
		vbox.addStretch()
		
		#=== sauver configuration ===#
		
		self.connect(self.spinFlouBoiteRayon,SIGNAL("valueChanged(int)"),self.sauverSpinFlouBoiteRayon)
		self.connect(self.spinFlouBoitePuiss,SIGNAL("valueChanged(int)"),self.sauverSpinFlouBoitePuiss)
		self.connect(self.curseurFlouBoiteRayon,SIGNAL("sliderMoved(int)"),self.curseurFlouBoiteRayonBouge)
		self.connect(self.curseurFlouBoitePuiss,SIGNAL("sliderMoved(int)"),self.curseurFlouBoitePuissBouge)
		
		try:
			print self.config.get(self.idSection,'flou_boite_rayon')
			self.spinFlouBoiteRayon.setValue(int(self.config.get(self.idSection,'flou_boite_rayon')))
			print self.config.get(self.idSection,'flou_boite_puissance')
			self.spinFlouBoitePuiss.setValue(int(self.config.get(self.idSection,'flou_boite_puissance')))
		except:
			print "Pas de paramètres de configuration pour:\n\
			Flou Boite Rayon ou Puissance"
	
	def sauverSpinFlouBoiteRayon(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'FlouBoiteRayon :',i
		self.config.set(self.idSection,'flou_boite_rayon',i)
		self.curseurFlouBoiteRayon.setValue(i)
	
	def sauverSpinFlouBoitePuiss(self,i):
		"""conserver le spin dans le fichier de configuration et modifier le curseur"""
		print 'FlouBoitePuiss :',i
		self.config.set(self.idSection,'flou_boite_puissance',i)
		self.curseurFlouBoitePuiss.setValue(i)
	
	def curseurFlouBoiteRayonBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinFlouBoiteRayon.setValue(i)
	
	def curseurFlouBoitePuissBouge(self,i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinFlouBoitePuiss.setValue(i)


class Animation_FiltresVideos(Base_EncodageFiltre):
	# -------------------------------------------------------------------
	# Cadre accueillant les widgets de :
	# Animation >> Filtres videos
	# -------------------------------------------------------------------
	
	def __init__(self, parent):
		
		#=== Variable de configuration ===#
		self.config=parent.config
		
		#=== Identifiant de la classe ===#
		self.idSection = "Animation - FiltresVideo"
		
		# -------------------------------------------------------------------
		# Widgets intégrés à la boîte de groupe "Choix et affichage des 
		# différents filtres". La boîte de combo définie ci-dessus
		# 'sélectionne' ceux qui vont s'afficher -> utilisation d'un stacked
		# -------------------------------------------------------------------
		
		# === Stacked par défaut - QLabel ================================
		
		# Apparaît lorsque les entrées suivantes sont sélectionnées dans la 
		# boîte de combo: Niveaux de gris (0), Reserve pour sous-titres 
		# (Expand) (1) et Miroir (6) .
		
		# création de stacked pour les QWidget
		self.stacked=QStackedWidget()
		self.stacked.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed))
		
		# par défaut
		self.indexStacked_sansReglages=self.stacked.addWidget(Filtres_SansReglages())
		
		
		# === Stacked : "Bruit" ==========================================
		
		# Apparaît lorsque l'entrée suivante est sélectionnée dans la 
		# boîte de combo: Bruit (2) .
		self.filtreBruit = Filtre_Bruit(self.config)
		self.indexStacked_bruit=self.stacked.addWidget(self.filtreBruit)
		
		
		# === Stacked : "Luminosite-contraste" ===========================
		
		# Apparaît lorsque l'entrée suivante est sélectionnée dans la 
		# boîte de combo: Luminosite-contraste (3) .
		self.filtreLuminosite = Filtre_LuminosContrast(self.config)
		self.indexStacked_luminContrast=self.stacked.addWidget(self.filtreLuminosite)
		
		
		# === Stacked : "Decouper (Crop)" ================================
		
		# Apparaît lorsque l'entrée suivante est sélectionnée dans la 
		# boîte de combo: Decouper (Crop) (4) .
		self.filtreDecouper = Filtre_Decouper(self.config)
		self.indexStacked_decouper=self.stacked.addWidget(self.filtreDecouper)
		
		
		# === Stacked : "Couleur/Saturation (Hue)" =======================
		
		# Apparaît lorsque l'entrée suivante est sélectionnée dans la 
		# boîte de combo: Couleur/Saturation (Hue) (5) .
		self.filtreCouleurSat = Filtre_CouleurSaturation(self.config)
		self.indexStacked_coulSat=self.stacked.addWidget(self.filtreCouleurSat)
		
		
		# === Stacked : "Flou boite (Boxblur)" ===========================
		
		# Apparaît lorsque l'entrée suivante est sélectionnée dans la 
		# boîte de combo: Flou boite (Boxblur) (7) .
		self.filtreFlouBoite = Filtre_FlouBoite(self.config)
		self.indexStacked_flouBoite=self.stacked.addWidget(self.filtreFlouBoite)
		
		#-------------------------------------------------------------------------------------
		# Paramètres de la liste de combo: [(identifiant, nom entrée, index du stacked),...]
		#-------------------------------------------------------------------------------------
		
		self.listeCombo=[\
		('niveaudegris',	_(u'Niveaux de gris'),		self.indexStacked_sansReglages),\
		('placesoustitres',	_(u'Reserve (place) pour sous-titres (Expand)'),\
									self.indexStacked_sansReglages),\
		('bruit', 		_(u'Bruit'),			self.indexStacked_bruit),\
		('luminositecontraste',	_(u'Luminosite-contraste'),	self.indexStacked_luminContrast),\
		('decoupercrop',	_(u'Decouper (Crop)'),		self.indexStacked_decouper),\
		('couleursaturationhue',_(u'Couleur/Saturation (Hue)'),	self.indexStacked_coulSat),\
		('miroir',		_(u'Miroir horizontal'),			self.indexStacked_sansReglages),\
		('flouboitebloxblur',	_(u'Flou boite (Boxblur)'),	self.indexStacked_flouBoite)]
		
		#---------------------------
		# Dérivation de la classe
		#---------------------------
		Base_EncodageFiltre.__init__(self, parent)
	
	
	def afficherAide(self):
		""" Boîte de dialogue de l'aide du cadre Animation > Filtres Vidéo """
		self.base.afficherAide(_(u"Blablablablablablablablablabla ... blablabla ... blablablabla ... blablabla."))
		'''
		messageAide=QMessageBox(self)
		messageAide.setText(_(u"Blablablabla ... blabla filtres_video."))
		messageAide.setWindowTitle(_(u"Aide"))
		messageAide.setIcon(QMessageBox.Information)
		messageAide.exec_()
		'''
		
	
	def appliquer(self, nomSortie=None, ouvert=1):
		"""appel du moteur de ekd -> filtre"""
		
		# récupération du chemin de la vidéo de destination (à l'exception de l'extension)
		if not nomSortie:
			cheminVideoSorti=str(QFileDialog.getSaveFileName(None, _(u"Sauver"), os.path.expanduser(self.base.repSortieProv()), _(u"Tous les fichiers *.*")))
		else: # module séquentiel
			cheminVideoSorti=nomSortie
		
		if cheminVideoSorti=="":
			return
		
		# quel est l'index du dernier item sélectionné de la boîte de combo?
		i=self.combo.currentIndex()
		# identifiant du codec actif
		idCodec=str(self.combo.itemData(i).toStringList()[0]) # méthode de QVariant
		
		# récupération du chemin de la vidéo source
		cheminVideoEntre=str(self.ligneEditionSource.text())
		fich, ext=os.path.splitext(cheminVideoEntre)
		
		# On garde la même extension pour le fichier de sortie
		cheminVideoSorti=cheminVideoSorti+os.path.splitext(cheminVideoEntre)[1]
		
		# Si le codec a besoin de 2 valeurs de spin -> tuple de spin 2 éléments
		if idCodec == 'bruit':
			# Pour 'bruit', on n'oublie pas de récupérer de type de bruit Luma ou Chroma
			# et on intégre ces valeurs dans un tuple de 3 èlements: (idFiltre, typeLuma, typeChroma)
			spin = (str(self.filtreBruit.spinBruitLuma.value()), str(self.filtreBruit.spinBruitChroma.value()))
			
			# tuple qui constituera idCodec
			idComboBrouillon = []
			idComboBrouillon.append(idCodec)
			
			# On récupère l'identifiant explicite du fichier de configuration pour luma et chroma
			# de façon à avoir l'identifiant servant dans la commande de mencoder
			
			# récupération identifiant luma mencoder
			i = self.filtreBruit.comboLuma.currentIndex()
			idLuma=str(self.filtreBruit.comboLuma.itemData(i).toStringList()[0]) # méthode de QVariant
			
			for i in self.filtreBruit.listeCombo:
				if i[1]!=idLuma:
					pass
				else:
					idComboBrouillon.append(str(i[2]))
					break
			
			# récupération identifiant chroma mencoder
			i = self.filtreBruit.comboChroma.currentIndex()
			idChroma=str(self.filtreBruit.comboChroma.itemData(i).toStringList()[0]) # méthode de QVariant
			
			for i in self.filtreBruit.listeCombo:
				if i[1]!=idChroma:
					pass
				else:
					idComboBrouillon.append(str(i[2]))
					break
			
			idCodec = idComboBrouillon
			
		elif idCodec == 'luminositecontraste':
			spin = (str(self.filtreLuminosite.spinLuminosite.value()),str(self.filtreLuminosite.spinContraste.value()))
		elif idCodec == 'decoupercrop':
			spin = (str(self.filtreDecouper.spinDecouperLarg.value()),str(self.filtreDecouper.spinDecouperLong.value()))
		elif idCodec == 'couleursaturationhue':
			spin = (str(self.filtreCouleurSat.spinCouleur.value()),str(self.filtreCouleurSat.spinSaturation.value()))
		elif idCodec == 'flouboitebloxblur':
			spin = (str(self.filtreFlouBoite.spinFlouBoiteRayon.value()),str(self.filtreFlouBoite.spinFlouBoitePuiss.value()))
		else: # Pas de valeur de spin pour les filtres 'niveaudegris', 'placesoustitres', 'miroir'
			spin = None
		
		print "IDENTIFIANT CODEC", idCodec
		print "PARAMETRES :", idCodec, cheminVideoEntre, cheminVideoSorti, spin
		
		# appel du moteur -> codec particulier
		try:
			mencoder = WidgetMEncoder(idCodec, cheminVideoEntre, cheminVideoSorti, valeurNum = spin, laisserOuvert=ouvert)
			mencoder.setWindowTitle(_(u"Filtres vidéo"))
			mencoder.exec_()
		except:
			messageErrAnEnc=QMessageBox(self)
			messageErrAnEnc.setText(_(u"A problem was occured."))
			messageErrAnEnc.setWindowTitle(_(u"Error"))
			messageErrAnEnc.setIcon(QMessageBox.Warning)
			messageErrAnEnc.exec_()
			return
		
		self.lstFichiersSortie = cheminVideoSorti # pour la boite de dialogue de comparaison
		self.radioConvert.setChecked(True)
		self.radioSource.setEnabled(True)
		self.radioConvert.setEnabled(True)
		self.boutCompare.setEnabled(True)
		return cheminVideoSorti # module séquentiel