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

import os, string, Image, glob
import shutil
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui_modules_image.image_base import Base

from gui_modules_lecture.affichage_image.afficheurImage import VisionneurImagePourEKD

class Image_Divers_Compositing(QWidget):
	# -----------------------------------
	# Cadre accueillant les widgets de :
	# Image >> Divers >> Compositing
	# -----------------------------------
	def __init__(self, parent):
        	QWidget.__init__(self)
		
		# ----------------------------
		# quelques paramètres de base
		# ----------------------------
		
		# Paramètres de configuration
		self.config = parent.config
		
		# Fonctions communes à plusieurs cadres du module Image
		self.base = Base()
		
		# création des répertoires temporaires
		if os.path.isdir('/tmp/ekd/tampon/temp_duplication') is False:
        		os.makedirs('/tmp/ekd/tampon/temp_duplication')
		
		# liste de chemins de fichiers avec et sans canal alpha et du dossier de sauvegarde
		self.listeChemAVcanAlph=[]
		self.listeChemSANScanAlph=[]
		self.chemDossierSauv=''
		
		# variable provisoire contenant le texte des infos
		self.infosImgProv = ''
		
		# Boite d'alignement vertical
		vbox=QVBoxLayout(self)
		
		# --------------------------------------------------
		# widgets du haut : titre + bouton de sélection
		# --------------------------------------------------
		
		#=== Titre de la page ===#
		#txt1=_(u"Image composite")
		#titre_du_cadre=QLabel('<H2><CENTER>%s</CENTER></H2>' %txt1, self)
		
		hbox = QHBoxLayout()
		
		#hbox.addWidget(titre_du_cadre,1) # étirement: centré
		
		# Ajout du titre de la page et de l'aperçu à la boite verticale
		vbox.addLayout(hbox, 0)
		
		#=== Bouton de sélection des images alpha et sans alpha ===#
		hbox = QHBoxLayout()
		self.boutOuvChargerTousTypesImages = QPushButton(_(u"Charger images avec et sans canal alpha"))
		self.boutOuvChargerTousTypesImages.setFocusPolicy(Qt.NoFocus)
		hbox.addWidget(self.boutOuvChargerTousTypesImages,1)
		vbox.addLayout(hbox)
		
		self.connect(self.boutOuvChargerTousTypesImages, SIGNAL("clicked()"), self.ouvrirImages)
		
		# -----------------------------------------------------------------------
		# tabwidget qui affiche la 1ère image chargée par
		# les boîtes de dialogue, puis la 1ère image du résultat du compositing
		# -----------------------------------------------------------------------
		# widget QScrolledArea (avec un Qlabel à l'intérieur) pour l'affichage
		# des images (fichier -->
		# gui_modules_lecture/affichage_image/afficheurImage.py,
		# classe --> VisionneurImagePourEKD)
		self.afficheurImg_1=VisionneurImagePourEKD()
		self.afficheurImg_2=VisionneurImagePourEKD()
		self.afficheurImg_3=VisionneurImagePourEKD()
		
		# infos - logs
		self.zoneAffichInfosImg = QTextEdit("")
		self.zoneAffichInfosImg.setReadOnly(True)
		self.fram=QFrame()
		vboxInfIm=QVBoxLayout(self.fram)
		vboxInfIm.addWidget(self.zoneAffichInfosImg)
		self.fram.setEnabled(False)
		
		self.tabwidget=QTabWidget()
		
		self.tab_1 = self.tabwidget.addTab(self.afficheurImg_1, _(u'Avec canal alpha'))
		self.tab_2 = self.tabwidget.addTab(self.afficheurImg_2, _(u'Sans canal alpha'))
		self.tab_3 = self.tabwidget.addTab(self.afficheurImg_3, _(u'Résultat final'))
		self.tab_4 = self.tabwidget.addTab(self.fram, _(u'Infos'))
		
		# [bidouillage] Comme on n'arrive pas à afficher les images centrées
		# de façon 'propre', en attendant on bidouille pour y
		# arriver (le prbl concerne surtout les images d'acceuil)
		self.connect(self.tabwidget, SIGNAL("currentChanged(int)"), self.protheseCentrageImg)
		
		vbox.addWidget(self.tabwidget)
		
		# -------------------------------------------------------------------
		# widgets du bas : ligne + boutons
		# -------------------------------------------------------------------
		
		# boutons
		boutAide=QPushButton(_(u" Aide"))
		boutAide.setIcon(QIcon("Icones/icone_aide_128.png"))
		self.connect(boutAide, SIGNAL("clicked()"), self.afficherAide)
		
		self.boutAppliquer=QPushButton(_(u" Appliquer et sauver"))
		# Apply and save
		self.boutAppliquer.setIcon(QIcon("Icones/icone_appliquer_128.png"))
		
		# Bouton inactif au départ
		self.boutAppliquer.setEnabled(False)
		
		self.connect(self.boutAppliquer, SIGNAL("clicked()"), self.appliquer)
		
		# ligne de séparation juste au dessus des boutons
		ligne = QFrame()
		ligne.setFrameShape(QFrame.HLine)
		ligne.setFrameShadow(QFrame.Sunken)
		vbox.addWidget(ligne)
		vbox.addSpacing(-5)	# la ligne doit être plus près des boutons
		
		hbox=QHBoxLayout()
		hbox.addWidget(boutAide)
		hbox.addStretch()	# espace entre les 2 boutons
		hbox.addWidget(self.boutAppliquer)
		vbox.addLayout(hbox)
		
		# affichage de la boîte principale
		self.setLayout(vbox)
	
	def protheseCentrageImg(self, i):
		"""Rafraichissemnt pour affichage de l'image au
		# milieu de la fenêtre. La fonction setTailleFenetre()
		# vient de la classe VisionneurImagePourEKD du fichier
		# gui_modules_lecture/affichage_image/afficheurImage.py
		self.afficheurImg_3.setTailleFenetre()"""
		if i==1: # 2ème onglet
			self.afficheurImg_2.setTailleFenetre()
		elif i==2: # 3ème onglet
			self.afficheurImg_3.setTailleFenetre()
	
	def ouvrirImages_1(self):
		""" Récupération du chemin des images avec canal alpha sélectionnées """
		
		try:
			# Ouvrir images avec canal alpha pour compositing
			rep = self.base.getRepSource(self.listeChemAVcanAlph, self.config)
			chemin_avec_can_alph=QFileDialog.getOpenFileNames(None, _(u"Ouvrir images avec canal alpha"), rep, ("PNG (*.png *.PNG);;GIF (*.gif *.GIF);;TARGA (*.tga *.TGA)"))
		
			# Si pas de fichier sélectionné -> sortir de la fonction
			if chemin_avec_can_alph.count()==0: return
		
			# Convertir les differents fichiers selectionnes
			# en une liste de chaines de caracteres .
			self.listeChemAVcanAlph=[str(chemin_avec_can_alph[iAVcan]) for iAVcan in range(chemin_avec_can_alph.count())]
			
			self.base.setRepSource(self.listeChemAVcanAlph, self.config)
			
			self.listeChemAVcanAlph.sort()
			
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			text=_(u"Image(s) avec canal alpha chargée(s)")
			a='#'*36
			self.infosImgProv = a + '\n# ' + text + '\n' + a
			
			for chemin in self.listeChemAVcanAlph:
				self.infosImgProv=self.infosImgProv+'\n'+chemin
			self.infosImgProv = self.infosImgProv + '\n\n'
			
			'''
			# ==> Prend pas mal de temps ...
			# Scan de ttes les images chargées et vérification du fait que les images
			# possèdent bien un canal alpha (puisqu'il s'agit des images devant venir au
			# 1er plan), si non une erreur est déclenchée 
			for v in self.listeChemAVcanAlph:
				verifAlpha=QImage(v)
				if verifAlpha.hasAlphaChannel:
					print "L'image %s possede bien un canal alpha" % os.path.basename(v)
			'''
			
			# - Affichage de l'image avec le fond quadrillé compositée -
			# Ouverture des images (i1 --> avec canal alpha et i2 -->
			# sans canal alpha)
			i1=Image.open(self.listeChemAVcanAlph[0])
			i2=Image.open('gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png')
		
			# Redimensionnement de l'image du quadrillage pour qu'elle s'adapte 
			# à l'image avec canal alpha
			redimQuad=i2.resize(i1.size)
			redimQuad.save('/tmp/ekd/tampon/temp_duplication/img_aff_quad_compo.png', "PNG")
		
			imQuad=Image.open('/tmp/ekd/tampon/temp_duplication/img_aff_quad_compo.png')
	
			# Application du compositing
			imgCompo_1=Image.composite(i1, imQuad, i1)
		
			# Sauvegarde des images resultant du Compositing 
			imgCompo_1.save('/tmp/ekd/tampon/temp_duplication/img_aff_quad_compo.png', "PNG")
	
			# Affichage de l'image avec canal alpha ------------------------------
			image1 = '/tmp/ekd/tampon/temp_duplication/img_aff_quad_compo.png'
			qImage1=QImage(image1)
			# Selon la valeur de la largeur ou de la hauteur, la taille de l'image affichée varie
			# dans tous les cas self.width_1 et self.height_1 
			# doivent être définis (même s'ils ne servent pas ici)
			self.width_1=qImage1.width()
			self.height_1=qImage1.height()
			self.afficheurImg_1.setImage(image1)
			# --------------------------------------------------------------------
	
			# Elimination de l'image tampon, on en a plus besoin
			os.remove('/tmp/ekd/tampon/temp_duplication/img_aff_quad_compo.png')
			
			# Activer le bouton 'appliquer' si les chemins ont été donnés
			if self.listeChemAVcanAlph!=[] and self.listeChemSANScanAlph!=[]:
				self.boutAppliquer.setEnabled(True)
			
			# tout s'est bien passé
			return 1
		
		except:
			messageErreur=QMessageBox(self)
			messageErreur.setText(_(u"Il s'est produit une erreur. Les images chargées doivent toutes contenir un canal alpha, et être en partie transparentes pour qu'un compositing soit opéré. Ce n'est pas le cas ici !."))
			messageErreur.setWindowTitle(_(u"Erreur"))
			messageErreur.setIcon(QMessageBox.Critical)
			messageErreur.exec_()
			# Ça n'a pas bien marché
			self.infosImgProv = ''
			return 0
	
	
	def ouvrirImages_2(self):
		""" Récupération du chemin des images sans canal alpha sélectionnées """
		
		#try:
		# Ouvrir images sans canal alpha pour compositing
		rep = self.base.getRepSource(self.listeChemAVcanAlph, self.config)
		chemin_sans_can_alph=QFileDialog.getOpenFileNames(None, _(u"Ouvrir images sans canal alpha"), rep,  ("JPEG (*.jpg *.JPG *.jpeg *.JPEG);;PNG (*.png *.PNG);;GIF (*.gif *.GIF);;BMP (*.bmp *.BMP);;SGI (*.sgi *.SGI);;TIF (*.tif *.TIF);;TARGA (*.tga *.TGA);;PNM (*.pnm *.PNM);;PPM (*.ppm *.PPM)"))
	
		# Si pas de fichier sélectionné -> sortir de la fonction
		if chemin_sans_can_alph.count()==0: return
	
		# Convertir les differents fichiers selectionnes
		# en une liste de chaines de caracteres .
		self.listeChemSANScanAlph=[str(chemin_sans_can_alph[iSANScan]) for iSANScan in range(chemin_sans_can_alph.count())]
		
		self.listeChemSANScanAlph.sort()
		
		# On implémente les chemins des fichiers dans une variable
		# pour préparer l'affichage des infos
		text=_(u"Image(s) sans canal alpha chargée(s)")
		a='#'*36
		self.infosImgProv = self.infosImgProv + a + '\n# ' + text + '\n' + a
		
		for chemin in self.listeChemSANScanAlph:
			self.infosImgProv=self.infosImgProv+'\n'+chemin
		self.infosImgProv = self.infosImgProv + '\n\n'
		
		# Affichage de l'image sans canal alpha ------------------------------
		qImage2=QImage(self.listeChemSANScanAlph[0])
		# Selon la valeur de la largeur ou de la hauteur, la taille de l'image affichée varie
		# dans tous les cas self.width_2 et self.height_2 
		# doivent être définis (même s'ils ne servent pas ici)
		self.width_2=qImage2.width()
		self.height_2=qImage2.height()
		self.afficheurImg_2.setImage(self.listeChemSANScanAlph[0])
		# --------------------------------------------------------------------
		
		# Activer le bouton 'appliquer' si les chemins ont été donnés
		if self.listeChemAVcanAlph!=[] and self.listeChemSANScanAlph!=[]:
			self.boutAppliquer.setEnabled(True)
		
		# Pour ne pas risquer d'afficher un résultat contraire
		# aux images alpha et sans alpha, on remet l'image d'accueil
		self.afficheurImg_3.setImage()
		
		# tout s'est bien passé
		return 1
		
		#except:
			#messageErreur=QMessageBox(self)
			#messageErreur.setText(_(u"Il s'est produit une erreur avec les images sans canal alpha"))
			#messageErreur.setWindowTitle(_(u"Erreur"))
			#messageErreur.setIcon(QMessageBox.Critical)
			#messageErreur.exec_()
			## Ça n'a pas bien marché
			#self.infosImgProv = ''
			#return 0
	
	
	def ouvrirImages(self):
		""" Récupération du chemin des images sélectionnées """
		# S'il y a une erreur lors du chargement des images
		# alpha ou sans alpha, pas la peine de continuer
		if not self.ouvrirImages_1(): return
		self.tabwidget.setCurrentIndex(self.tab_1)
		
		if not self.ouvrirImages_2(): return
		self.tabwidget.setCurrentIndex(self.tab_2)
	
	
	def appliquer(self):
		"""appliquer le compositing"""
		
		# ----- TRAVAIL PREPARATOIRE --- Redimensionnement des images -----------------
		# Ce redimensionnement ne gère que le lien entre la taille des images sans 
		# canal alpha, il ne gère pas le redimensionnement des images avec canal
		# alpha.
    		# Recuperation du chemin + nom de la 1ere image chargee et sans canal alpha
    		recupImg=self.listeChemSANScanAlph[0]
    		# Recup du chemin des images chargees
    		NomImgComp=os.path.dirname(recupImg)
    		# Ouverture de la 1ere image chargee avec canal alpha pour connaitre 
    		# les dimensions (largeur, hauteur) de cette image .
		imgOuvComp=Image.open(self.listeChemAVcanAlph[0])
    		# Dimension (w--> largeur, h --> hauteur) 
    		w, h=imgOuvComp.size
    		# Boucle pour redimensionner les images chargees sans canal alpha .
    		# Les images sont redimensionnees aux dimensions des images avec
    		# canal alpha .
    		n=0
		# Tant qu'on a pas atteint le nbre d'images sans canal alpha
    		while n < len(self.listeChemSANScanAlph) :
        		for parcRedim in self.listeChemSANScanAlph :
            			OuvrirImag=Image.open(parcRedim)
            			# Redimensionnement des images
            			sRedimComp=OuvrirImag.resize(imgOuvComp.size)
            			# Recup du nom exact de l'image chargee .
            			f=string.split(parcRedim, '/')[-1:]
            			sRedimComp.save(NomImgComp+'/'+''.join(f))
            			n=n+1
    		# -----------------------------------------------------------------------------
		# Boîte de dialogue pour sauvegarder (nom du nouveau fichier)
		#------------------------------------------------------------------------------
		rep = self.base.getRepSource(self.listeChemAVcanAlph, self.config)
		self.chemDossierSauv=str(QFileDialog.getSaveFileName(None, _(u"Sauver"), rep, _(u"Tous les fichiers *.*")))
		
		if self.chemDossierSauv=='': return
		
		# Liste pour affichage (ds le tabwidget)
		listeAff=[]
		
		# Barre de progression dans une fenêtre séparée . Attention la fenêtre
		# de la barre se ferme dès que la progression est terminée . En cas de
		# process très court, la fenêtre peut n'apparaître que très brièvement
		# (voire pas du tout si le temps est très très court) .
		self.progress=QProgressDialog(_(u"Progression ..."), _(u"Arrêter le processus"), 0, 100)
		self.progress.setWindowTitle(_(u'EnKoDeur-Mixeur. Fenêtre de progression'))
		# Attribution des nouvelles dimensions 
		self.progress.setMinimumWidth(500)
		self.progress.setMinimumHeight(100)
		
		nbreElem_1=len(self.listeChemAVcanAlph)
		nbreElem_2=len(self.listeChemSANScanAlph)
		
		# On implémente les chemins des fichiers dans une variable
		# pour préparer l'affichage des infos
		text=_(u"Résultat image(s) composite")
		a='#'*36
		self.infosImgProv = self.infosImgProv + a + '\n# ' + text + '\n' + a +'\n'
		
		# -------------------------------------------------------------------
		# Si le nbre d'images chargées avec canal alpha est égal à 1 ...
		# en fait si l'utilisateur ne charge qu'une image avec et sans canal
		# alpha ...
		# -------------------------------------------------------------------
		if nbreElem_1 == 1:
		
			try :
                		# Ouverture des images (im01 --> avec canal alpha et 
				# im02 --> sans canal alpha)
                		im01=Image.open(self.listeChemAVcanAlph[0])
                		im02=Image.open(self.listeChemSANScanAlph[0])

                		# Application du compositing
                		imgCompoUndeChaque=Image.composite(im01, im02, im01)

                		# Sauvegarde des images resultant du Compositing 
				chem = self.chemDossierSauv+'_'+string.zfill((1), 6)+'.png'
				imgCompoUndeChaque.save(chem, "PNG")
					
				# Remplissage de listeAff pour affichage (ds le tabwidget)
				listeAff.append(chem)
				
				# log
				self.infosImgProv = self.infosImgProv + chem
				
				# Affichage de l'image composite ---------------
				self.afficheurImg_3.setImage(listeAff[0])
				# ----------------------------------------------------
				
			except: 
				messageErreur=QMessageBox(self)
				messageErreur.setText(_(u"Une erreur s'est produite !"))
				messageErreur.setWindowTitle(_(u"Erreur"))
				messageErreur.setIcon(QMessageBox.Critical)
				messageErreur.exec_()
				self.infosImgProv = '' # remise à 0 du log provisoire

		# -------------------------------------------------------------------
		# Si le nbre d'images chargées sans canal alpha est supérieur à 1 ...
		# ce qui correspond à un travail avec un fond animé
		# -------------------------------------------------------------------
		elif nbreElem_2 > 1:
		
			self.progress.show()
		
			nbre=min(nbreElem_1, nbreElem_2)
			
			try :
				for parcoursComposit_un in range(nbre):
					
                			# Ouverture des images (imm1 --> avec canal alpha et 
					# imm2 --> sans canal alpha)
                			imm1=Image.open(self.listeChemAVcanAlph[parcoursComposit_un])
                			imm2=Image.open(self.listeChemSANScanAlph[parcoursComposit_un])
					
					# ---- Redimensionnement des images avec canal alpha ----
					# L'utilisateur peut charger des images (avec canal alpha)
					# avec des tailles complètement différentes. Elles seront 
					# redimensionnées à la taille de la 1ère image de:
					# self.listeChemAVcanAlph (défini dans la fonction
					# ouvrirImages)
					if (int(self.width_1), int(self.height_1)) != imm1.size:
						imm1=imm1.resize(Image.open(self.listeChemAVcanAlph[0]).size)
					# -------------------------------------------------------
					
                			# Application du compositing
                			imgCompo_1=Image.composite(imm1, imm2, imm1)

                			# Sauvegarde des images resultant du Compositing
					chem = self.chemDossierSauv+'_'+string.zfill((parcoursComposit_un+1), 6)+'.png'
					imgCompo_1.save(chem, "PNG")
					
					# Remplissage de listeAff pour affichage (ds le tabwidget)
					listeAff.append(chem)
					
					# log
					self.infosImgProv = self.infosImgProv + chem +'\n'
					
					# --------------------------------------------
					# Affichage de la progression (avec
					# QProgressDialog) ds une fenêtre séparée
					val_pourc_1=((parcoursComposit_un+1)*100)/nbre

					# Bouton Cancel pour arrêter la progression donc le process
					if (self.progress.wasCanceled()): break

					self.progress.setValue(val_pourc_1)
			
					QApplication.processEvents()
					# --------------------------------------------
				
				# Affichage de l'image composite ---------------
				self.afficheurImg_3.setImage(listeAff[0])
				# ----------------------------------------------------
			
			except:
				messageErreur=QMessageBox(self)
				messageErreur.setText(_(u"Une erreur s'est produite !"))
				messageErreur.setWindowTitle(_(u"Erreur"))
				messageErreur.setIcon(QMessageBox.Critical)
				messageErreur.exec_()
				self.infosImgProv = '' # remise à 0 du log provisoire
	
		# -------------------------------------------------------------------
		# Si le nbre d'images chargées sans canal alpha est égal à 1 ...
		# ce qui correspond à un travail avec un fond fixe (caméra fixe)
		# -------------------------------------------------------------------
		elif nbreElem_2 == 1:
			
			self.progress.show()
			
			listeTempCompo=[]
			
			try :
				for parcoursDupli in range(nbreElem_1) :
					
					dupliString=self.listeChemSANScanAlph[0]
					
					## Multiplication de l'image
					#dup="d"*nbreElem_1 ### ??? Tu avais de la fièvre? Un délire? Ça va mieux? :-)
					
					# Ouverture de l'image 
					reS=Image.open(dupliString)
					
					# Sauvegarde de l'image après multiplication 
					reS.save(str('/tmp/ekd/tampon/temp_duplication/d_'+string.zfill((parcoursDupli+1), 6)+'.tiff'), "TIFF")
					
					# Remplissage de la liste tampon
					listeTempCompo.append('/tmp/ekd/tampon/temp_duplication/d_'+string.zfill((parcoursDupli+1), 6)+'.tiff')
					
					# Copie de l'ensemble des images (avec canal alpha)
					# chargees par l'utilisateur, dans le sous-repertoire
					# temporaire --> /tmp/ekd/tampon/temp_duplication/ . Il est
					# indispensable que ces images se retrouvent dans le meme
					# repertoire que les images multipliées (sans canal alpha)
					for parCop in self.listeChemSANScanAlph :
						cop=shutil.copy(parCop, '/tmp/ekd/tampon/temp_duplication/')
						
					# Ouverture des images (imm3 --> avec canal alpha et 
					# imm4 --> sans canal alpha) 
					imm3=Image.open(self.listeChemAVcanAlph[parcoursDupli])
					imm4=Image.open(listeTempCompo[parcoursDupli])
					
					# ---- Redimensionnement des images avec canal alpha ----
					# L'utilisateur peut charger des images (avec canal alpha)
					# avec des tailles complètement différentes. Elles seront 
					# redimensionnées à la taille de la 1ère image de:
					# self.listeChemAVcanAlph (défini dans la fonction
					# ouvrirImages).
					### bizarrerie
					if (int(self.width_2), int(self.height_2))!=imm3.size:
						imm3=imm3.resize(Image.open(self.listeChemAVcanAlph[0]).size)
					# -------------------------------------------------------
					
					# Application du compositing .
					imgCompo_2=Image.composite(imm3, imm4, imm3)
					
					# Sauvegarde des images resultant du Compositing .
					chem = self.chemDossierSauv+'_'+string.zfill((parcoursDupli+1), 6)+'.png'
					imgCompo_2.save(chem, "PNG")
					
					# Epuration/elimination des fichiers tampon
					for toutRepCompo in glob.glob('/tmp/ekd/tampon/temp_duplication/*.*') :
						os.remove(toutRepCompo)
					
					# Remplissage de listeAff pour affichage (ds le tabwidget)
					listeAff.append(chem)
					
					# log
					self.infosImgProv = self.infosImgProv + chem +'\n'
					
					# --------------------------------------------
					# Affichage de la progression (avec
					# QProgressDialog) ds une fenêtre séparée .
					val_pourc_2=((parcoursDupli+1)*100)/nbreElem_1
	
					# Bouton Cancel pour arrêter la progression donc le process
					if (self.progress.wasCanceled()): break
	
					self.progress.setValue(val_pourc_2)
			
					QApplication.processEvents()
					# --------------------------------------------
					
				# Affichage de l'image composite ---------------
				self.afficheurImg_3.setImage(listeAff[0])
				# ----------------------------------------------------
			
			except:
				messageErreur=QMessageBox(self)
				messageErreur.setText(_(u"Une erreur s'est produite !"))
				messageErreur.setWindowTitle(_(u"Erreur"))
				messageErreur.setIcon(QMessageBox.Critical)
				messageErreur.exec_()
				self.infosImgProv = '' # remise à 0 du log provisoire
		
		# On fait apparaître le dernier onglet
		self.tabwidget.setCurrentIndex(self.tab_3)
		
		# Le bouton appliquer n'a plus besoin d'être valide
		# car sinon on referait exactement la même action
		self.boutAppliquer.setEnabled(False)
		
		# affichage des infos dans l'onglet
		self.zoneAffichInfosImg.setText(self.infosImgProv)
		self.fram.setEnabled(True)
		
		# remise à 0 de la variable provisoire de log
		self.infosImgProv = ''
	
	
	def afficherAide(self):
		"""Boîte de dialogue de l'aide"""

		messageAide=QMessageBox(self)
		messageAide.setText(_(u"<h3><center>Superposition d'images (avec zones transparentes) sur d'autres images</center></h3><p>Vous allez ici superposer des images avec un canal alpha (transparence) sur d'autres images sans canal alpha (ces dernières sont en quelque sorte l'arrière-plan). Vous avez aussi ici la possibilité de travailler avec un arrière-plan composé d'une seule image, en cas de travail en plan fixe (le programme duplique lui-même les images, vous n'avez juste qu'à mettre la dite image dans le répertoire, comme précisé plus bas).</p><p>Vous allez pouvoir voir un apperçu de la première image du lot chargée et ce dans les pages 'Avec canal alpha' et 'Sans canal alpha'. En ce qui concerne la page 'Résultat final', il s'agit bien sûr du résultat de votre compositing.</p><p>Avant toute chose, vous devez créer trois répertoires:</p><h4><ul>** un où vous allez déposer toutes les images (avec canal alpha) qui devront se trouver au premier plan.</ul></h4><h4><ul>** un autre où vous allez mettre l'image ou les images (sans canal alpha) qui sera/seront à l'arrière-plan.</ul></h4><h4><ul>** le dernier où seront sauvegardées les images résultant du compositing.</ul></h4>Ensuite chargez votre (ou vos) image(s) par le bouton 'Parcourir...', une première boîte de dialogue apparaît, allez chercher l'image (ou les images) avec canal alpha. Si vous voulez sélectionner plusieurs images d'un coup, maintenez la touche CTRL (ou SHIFT) du clavier enfoncée (tout en sélectionnant vos images). Ceci fait cliquez sur le bouton 'Open', une nouvelle boîte s'ouvre dans laquelle (de la même façon que la précédente) vous allez sélectionner votre (ou vos) image(s). Attention dans les deux précédentes boîtes de dialogue, sélectionnez bien le type d'extension par l'onglet 'Files of type'. Pour finir cliquez sur le bouton 'Appliquer et sauver', entrez le titre de votre futur compositing (après 'File name:') dans cette dernière boîte (vous aurez évidemment pris soin de sélectionner le répertoire de destination de votre compositing). Cliquez sur le bouton 'Save', et voilà !."))
		messageAide.setWindowTitle(_(u"Aide"))
		messageAide.setIcon(QMessageBox.Information)
		messageAide.exec_()