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

import os, shutil, glob
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui_modules_animation.animation_base import Base
from moteur_modules_animation.mencoder import WidgetMEncoder
from moteur_modules_animation.mplayer import Mplayer
from gui_modules_lecture.affichage_image.afficheurImage import VisionneurImagePourEKD


class Animation_ConvertirUneAnimEnImg(QWidget):
	# ----------------------------------------------------------------------------------------
	# Cadre accueillant les widgets de : Animation >> Séparer le flux vidéo et le flux audio
	# ----------------------------------------------------------------------------------------
	def __init__(self, parent):
		QWidget.__init__(self)
		
		# -------------------------------
		# Parametres généraux du widget
		# -------------------------------
		self.base = Base(self) # module de animation
		#=== tout sera mis dans une boîte verticale ===#
		vbox=QVBoxLayout(self)
		
		#=== Variable de configuration ===#
		self.config=parent.config
		
		#=== Identifiant de la classe ===#
		self.idSection = "Animation - Convertir Une Video en Images"
		self.base.printSection()
		
		# Création des répertoires temporaires
		self.repTampon = '/tmp/ekd/tampon/temp_anim_en_img/'
		if os.path.isdir(self.repTampon) is False:
        		os.makedirs(self.repTampon)
		
		# Au cas où le répertoire existait déjà et qu'il n'était pas vide -> purge (simple précausion)
		for toutRepCompo in glob.glob(self.repTampon+'*.*'):
			os.remove(toutRepCompo)
		
		#=== Accès à la barre des tâches ===#
		self.statusBar = parent.statusBar()
		
		#=== Drapeaux liés au problème de centrage de l'image d'accueil ===#
		# Est-ce que la conversion a été effectuée?
		self.convEffectuee = 0
		# Est-ce qu'on a déjà cliqué sur l'onglet images (le 2ème)?
		self.tabImgDejaActive = 0
		
		# -------------------------------------------------------------------
		# Boîte de groupe : "Fichier vidéo source"
		# -------------------------------------------------------------------
		self.base.widgetSource(vbox)
		
		#----------
		# Onglets
		#----------
		self.tab = QTabWidget()
		self.connect(self.tab, SIGNAL("currentChanged(int)"), self.centreImgAccueil)
		self.dicoTab = {}
		
		#=== Widgets mplayer ===#
		widget = QWidget()
		vboxMplayer = QVBoxLayout(widget)
		vboxMplayer.addStretch()
		hbox = QHBoxLayout()
		vboxMplayer.addLayout(hbox)
		hbox.addStretch()
		self.mplayer = Mplayer(taille=(350,252))
		hbox.addWidget(self.mplayer)
		hbox.addStretch()
		vboxMplayer.addStretch()
		chemin = self.ligneEditionSource.text()
		self.mplayer.setEnabled(False)
		self.dicoTab['video']=self.tab.addTab(widget, _(u'Vidéo source'))
		
		#=== Là où s'afficheront les images ===#
		widget = QWidget()
		vboxMplayer = QVBoxLayout(widget)
		self.afficheurImg=VisionneurImagePourEKD()
		self.curseurImg = QSlider(Qt.Horizontal)
		self.curseurImg.setEnabled(False)
		
		
		# Drapeau servant à ne pas afficher 2 fois la même image
		self.verrouillerValueChange = 0
		self.connect(self.curseurImg,SIGNAL("sliderReleased()"), self.curseurImgRelache)
		self.connect(self.curseurImg,SIGNAL("sliderMoved(int)"), self.curseurImgBouge)
		self.connect(self.curseurImg,SIGNAL("sliderPressed()"), self.curseurPresse)
		self.connect(self.curseurImg,SIGNAL("valueChanged(int)"), self.curseurChange)
		
		vboxMplayer.addWidget(self.afficheurImg)
		vboxMplayer.addWidget(self.curseurImg)
		self.dicoTab['images']=self.tab.addTab(widget, _(u'Images crées'))
		
		vbox.addWidget(self.tab)
		
		# -------------------------------------------------------------------
		# widgets du bas : ligne + boutons Aide et Appliquer
		# -------------------------------------------------------------------
		self.base.widgetBas(vbox)
		
		# affichage de la boîte principale
		self.setLayout(vbox)
	
	
	def centreImgAccueil(self):
		""""Centrage de l'image d'accueil poue palier au bogue"""
		if not self.tabImgDejaActive and not self.convEffectuee:
			self.afficheurImg.setTailleFenetre()
			self.tabImgDejaActive=1
	
	def curseurImgRelache(self):
		"""Changement de l'image affichée lors du déplacement du curseur associée"""
		self.verrouillerValueChange = 0
		i = self.curseurImg.value()
		self.afficheurImg.setImage(self.listeFichierFinal[i])
	
	def curseurImgBouge(self, i):
		"""Montre le nom de l'image qui serait affichée si le curseur associée était relâché"""
		self.statusBar.showMessage(self.listeFichierFinal[i])
	
	def curseurPresse(self):
		self.verrouillerValueChange = 1
	
	def curseurChange(self, i):
		"Permet un changement de l'image avec les flèches gauche et droite \
		et avec un simple clic sur une partie du curseur"
		if not self.verrouillerValueChange:
			self.afficheurImg.setImage(self.listeFichierFinal[i])
			self.statusBar.showMessage(self.listeFichierFinal[i])
	
	
	def afficherAide(self):
		""" Boîte de dialogue de l'aide """
		self.base.afficherAide(_(u"Blablablablablablablablablabla ... blablabla ... blablablabla ... blablabla."))
		'''
		messageAide=QMessageBox(self)
		messageAide.setText(_(u"Blablablabla ... blabla anim_conv_video_en_img."))
		messageAide.setWindowTitle(_(u"Aide"))
		messageAide.setIcon(QMessageBox.Information)
		messageAide.exec_()
		'''
	
	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.base.recupSource(nomEntree)
		if not chemin: return
		print "chemin vidéo d'entrée:", chemin, type(chemin)
		
		# Affichage du chemin + nom de fichier dans la ligne d'édition
		self.ligneEditionSource.setText(chemin)
		
		self.boutApp.setEnabled(True)
		
		self.mplayer.setEnabled(True)
		self.mplayer.listeVideos = [chemin]
		
		self.afficheurImg.setImage()
		self.curseurImg.setEnabled(False)
		self.tab.setCurrentIndex(self.dicoTab['video'])
	
	
	def appliquer(self, nomSortie=None, ouvert=1):
		""" Appelle la boite de dialogue de sélection de fichier à sauver et appel de la fonction de conversion d'une vidéo en images """
		
		#=== Détermination des chemins d'entrée et sortie ===#
		
		if not nomSortie:
			# récupération du chemin de la vidéo de destination (à l'exception de l'extension)
			chemin=str(QFileDialog.getSaveFileName(None, _(u"Sauver"), os.path.expanduser(self.base.repSortieProv()), _(u"Tous les fichiers *.*")))
		else: # module séquentiel
			chemin=nomSortie
		
		if chemin=="": return
		
		# Préfixe des images
		prefixeImg=os.path.basename(chemin)
		
		# Chemin du répertoire de sortie des images
		cheminRepDestination = os.path.dirname(chemin) + '/'
		
		# Récupération du chemin de la vidéo source
		cheminVideoSource=str(self.ligneEditionSource.text())
		
		commande = "mplayer \""+cheminVideoSource+" -vo jpeg:outdir=\""+self.repTampon+"\":quality=100"
		
		print "Commande de conversion d'une vidéo en images :\n", commande
		
		try:
			mencoder = WidgetMEncoder('jpeg', cheminVideoSource, self.repTampon, laisserOuvert=ouvert)
			mencoder.setWindowTitle(_(u"Convertir une animation en images"))
			mencoder.exec_()
		except:
			messageErrAnEnc=QMessageBox(self)
			messageErrAnEnc.setText(_(u"Problème lors de la conversion d'une vidéo en images (mencodeur)"))
			messageErrAnEnc.setWindowTitle(_(u"Erreur"))
			messageErrAnEnc.setIcon(QMessageBox.Warning)
			messageErrAnEnc.exec_()
			return
		
		# Renommage et déplacement des fichiers dans le bon répertoire
		# Liste des noms de fichiers (de type 00000001.jpg ... 00000025.jpg...)
		listeFichiers=os.listdir(self.repTampon)
		self.listeFichierFinal = []
		for nomFichier in listeFichiers:
			#print "A", self.repTampon+nomFichier, "B", cheminRepDestination+prefixeImg+'_'+nomFichier
			#os.rename(self.repTampon+nomFichier, cheminRepDestination+prefixeImg+'_'+nomFichier)
			shutil.move(self.repTampon+nomFichier, cheminRepDestination+prefixeImg+'_'+nomFichier)
			self.listeFichierFinal.append(cheminRepDestination+prefixeImg+'_'+nomFichier)
		
		self.listeFichierFinal.sort()
		
		self.convEffectuee = 1
		self.curseurImg.setRange(0,len(self.listeFichierFinal)-1)
		self.curseurImg.setValue(0)
		self.curseurImg.setEnabled(True)
		self.tab.setCurrentIndex(self.dicoTab['images'])
		self.afficheurImg.setImage(self.listeFichierFinal[0])
		
		return self.listeFichierFinal # module séquentiel
	
	
	def sequentiel(self, entree, sortie, ouvert=0):
		"""Utile dans le module du même nom. Applique les opérations de la classe. Retourne le vrai nom du fichier de sortie"""
		self.ouvrirSource(entree)
		return self.appliquer(sortie, ouvert)
	
	
	def sequentielReglage(self):
		"""Utile dans le module du même nom. Récupère le widget de réglage associé à l'identifiant donné en 1er argument. Retourne l'instance du widget de réglage"""
		groupReglage =  QGroupBox(_(u"Réglages: convertir une animation en images"))
		hbox = QHBoxLayout(groupReglage)
		hbox.addWidget(QLabel(_(u"<center>Pas de réglages ici</center>")))
		return groupReglage