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

import sys, os, string, glob
import Image
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui_modules_lecture.affichage_image.afficheurImage import VisionneurImagePourEKD
from gui_modules_image.image_base import Base

class CadresAvecSpin(QFrame):
	"""Widget de réglage à 1, 2 ou 3 boites de spins"""
	def __init__(self, ligne1=('',('','','')), ligne2=None, ligne3=None):
        	QFrame.__init__(self)
		
		grid = QGridLayout(self)
		
		if not ligne2: # 1 seul spin
			self.spin = QSpinBox()
			self.spin.setRange(ligne1[1][0], ligne1[1][1])
			self.spin.setValue(ligne1[1][2])
			self.curseur = QSlider(Qt.Horizontal)
			self.curseur.setRange(ligne1[1][0], ligne1[1][1])
			self.curseur.setValue(ligne1[1][2])
			grid.addWidget(self.spin,0,0)
			grid.addWidget(self.curseur,0,1)
			grid.addWidget(QLabel(ligne1[0]),0,2)
			self.connect(self.spin,SIGNAL("valueChanged(int)"), self.spinChange)
			self.connect(self.curseur,SIGNAL("sliderMoved(int)"), self.curseurBouge)
		elif not ligne3: # 2 spins
			self.spin1 = QSpinBox()
			self.spin2 = QSpinBox()
			self.spin1.setRange(ligne1[1][0], ligne1[1][1])
			self.spin1.setValue(ligne1[1][2])
			self.spin2.setRange(ligne2[1][0], ligne2[1][1])
			self.spin2.setValue(ligne2[1][2])
			self.curseur1 = QSlider(Qt.Horizontal)
			self.curseur1.setRange(ligne1[1][0], ligne1[1][1])
			self.curseur1.setValue(ligne1[1][2])
			self.curseur2 = QSlider(Qt.Horizontal)
			self.curseur2.setRange(ligne2[1][0], ligne2[1][1])
			self.curseur2.setValue(ligne2[1][2])
			grid.addWidget(self.spin1,0,0)
			grid.addWidget(self.curseur1,0,1)
			grid.addWidget(QLabel(ligne1[0]),0,2)
			grid.addWidget(self.spin2,1,0)
			grid.addWidget(self.curseur2,1,1)
			grid.addWidget(QLabel(ligne2[0]),1,2)
			self.connect(self.spin1,SIGNAL("valueChanged(int)"), self.spinChange1Bis)
			self.connect(self.curseur1,SIGNAL("sliderMoved(int)"), self.curseurBouge1Bis)
			self.connect(self.spin2,SIGNAL("valueChanged(int)"), self.spinChange2Bis)
			self.connect(self.curseur2,SIGNAL("sliderMoved(int)"), self.curseurBouge2Bis)

		grid.setAlignment(Qt.AlignCenter)
	
	def spinChange(self, i):
		"""modifie le curseur lorsque le curseur bouge"""
		self.curseur.setValue(i)
	
	def curseurBouge(self, i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spin.setValue(i)

	def spinChange1Bis(self, i):
		"""modifie le curseur lorsque le curseur bouge"""
		self.curseur1.setValue(i)
	
	def curseurBouge1Bis(self, i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spin1.setValue(i)

	def spinChange2Bis(self, i):
		"""modifie le curseur lorsque le curseur bouge"""
		self.curseur2.setValue(i)
	
	def curseurBouge2Bis(self, i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spin2.setValue(i)


class Image_Divers_PourLeWeb(QWidget):
	# -----------------------------------
	# Cadre accueillant les widgets de :
	# Image >> Divers >> Pour le web
	# -----------------------------------
	def __init__(self, parent):
        	QWidget.__init__(self)
		
		# ----------------------------
		# Quelques paramètres de base
		# ----------------------------
		
		#=== Création des répertoires temporaires ===#
		self.repTampon = '/tmp/ekd/tampon/pour_le_web/'
		if os.path.isdir(self.repTampon) is False:
        		os.makedirs(self.repTampon)
		if os.path.isdir(self.repTampon+'redim/') is False:
        		os.makedirs(self.repTampon+'redim/')
		
		#=== Variable contenant les titres du log ===#
		self.infosImgTitre = []
		txt = _(u"Image(s) chargée(s)")
		a='#'*36
		b = a + '\n# ' + txt + '\n' + a + '\n'
		txt=_(u"Image(s) convertie(s)")
		c = a + '\n# ' + txt + '\n' + a + '\n'
		self.infosImgTitre.append(b)
		self.infosImgTitre.append(c)
		
		self.timer = QTimer()
		self.connect(self.timer, SIGNAL('timeout()'), self.sonderTempsActuel)
		
		# Fonctions communes à plusieurs cadres du module Image
		self.base = Base()
		# Paramètres de configuration
		self.config = parent.config
		self.listeChemin = []
		
		#self.process = QProcess()
		#self.connect(self.process, SIGNAL('finished(int)'), self.finConversion)
		
		# Boite d'alignement vertical
		vbox=QVBoxLayout(self)
		
		# ----------------------------------------
		# Bouton de sélection des images sources
		# ----------------------------------------
		
		#=== Bouton de sélection des images seq A et B ===#
		hbox = QHBoxLayout()
		self.boutOuvrirSource = QPushButton(_(u"Charger image(s) source(s)"))
		self.boutOuvrirSource.setFocusPolicy(Qt.NoFocus)
		hbox.addWidget(self.boutOuvrirSource)
		vbox.addLayout(hbox)
		
		self.connect(self.boutOuvrirSource, SIGNAL("clicked()"), self.ouvrirImages)
		
		self.tabwidget=QTabWidget()
		
		#------------------
		# Onglet Réglages
		#------------------
		
		self.framReglage=QFrame()
		vboxReglage=QVBoxLayout(self.framReglage)
		
		#=== Stacked ===#
		
		self.stacked = QStackedWidget()
		self.stacked.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed))
		
		#=== Instanciation des widgets du stacked  ===#
		
		# Widgets du stacked sans réglage
		stacked_sansReglage = QFrame()
		vboxStacked = QVBoxLayout(stacked_sansReglage)
		txt=_(u"Pas de réglages ici")
		vboxStacked.addWidget(QLabel("<center>%s</center>" %txt))
		
		# Widget du stacked avec une seule boite de spin
		stacked_gif_anime = CadresAvecSpin((_(u"Nombre de couleurs (Réduction)"),(8,256,128)))
		
		# Widget du stacked avec 2 boites de spin
		stacked_morcellementImg = CadresAvecSpin((_(u"Nombre de morceaux (sens horizontal)"),(1,10,2)),(_(u"Nombre de morceaux (sens vertical)"),(1,10,2)))
		
		# Widgets du stacked avec une seule boite de spin
		indexStacked_gif_anime = self.stacked.addWidget(stacked_gif_anime)
		
		# Widgets du stacked avec 2 boites de spin
		indexStacked_morcellementImg = self.stacked.addWidget(stacked_morcellementImg)
		
		# boite de combo
		self.comboReglage=QComboBox()
		# Paramètres de la liste de combo: [(nom entrée, identifiant, index du stacked,
		# instance stacked),...]
		self.listeComboReglage=[(_(u'Gif animé'),    'gif_anime',    indexStacked_gif_anime,    stacked_gif_anime),\
		(_(u"Morcellement/découpe d'image"),    'morcellement_img',    indexStacked_morcellementImg,    stacked_morcellementImg)]
		
		# Insertion des codecs de compression dans la boite de combo
		for i in self.listeComboReglage:
                	self.comboReglage.addItem(i[0])
		self.connect(self.comboReglage, SIGNAL("activated(int)"), self.changerComboReglage)
		
		hbox = QHBoxLayout()
		hbox.addWidget(QLabel(_(u'Type')))
		hbox.addWidget(self.comboReglage)
		hbox.setAlignment(Qt.AlignHCenter)
		
		vboxReglage.addLayout(hbox)
		vboxReglage.addWidget(self.stacked)
		vboxReglage.addStretch()
		
		#----------------
		# Onglet de log
		#----------------
		
		self.zoneAffichInfosImg = QTextEdit("")
		self.zoneAffichInfosImg.setReadOnly(True)
		self.framInfos=QFrame()
		vboxInfIm=QVBoxLayout(self.framInfos)
		vboxInfIm.addWidget(self.zoneAffichInfosImg)
		self.framInfos.setEnabled(False)
		
		# -------------------------------------------------
		# Onglets d'affichage image source et destination
		# -------------------------------------------------
		
		# Là où s'afficheront les images
		self.afficheurImg_1=VisionneurImagePourEKD()
		self.afficheurImg_2=VisionneurImagePourEKD()
		
		vbox.addWidget(self.tabwidget)
		
		self.indexTabImgReglage = self.tabwidget.addTab(self.framReglage, _(u'Réglages'))
		self.indexTabImgSource = self.tabwidget.addTab(self.afficheurImg_1, _(u'Image(s) source(s)'))
		self.indexTabImgDestin = self.tabwidget.addTab(self.afficheurImg_2, _(u'Image(s) après traitement'))
		self.indexTabImgInfos = self.tabwidget.addTab(self.framInfos, _(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) 
		
		# -------------------------------------------
		# widgets du bas : curseur + 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"))
		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.appliquer0)
		
		# 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()
		hbox.addWidget(self.boutAppliquer)
		vbox.addLayout(hbox)
		
		self.setLayout(vbox)
		
		#-----------------------------
		# Barre de progression
		#-----------------------------
		
		self.progress=QProgressDialog(_(u"Conversion en cours..."), _(u"Arrêter"), 0, 100)
		self.progress.setWindowTitle(_(u'EnKoDeur-Mixeur. Fenêtre de progression'))
		self.progress.setMinimumWidth(500)
		self.progress.setMinimumHeight(100)
	
	
	def changerComboReglage(self, i):
		"""Récup/affichage ds le terminal de l'index de self.comboReglage"""
		self.stacked.setCurrentIndex(self.listeComboReglage[i][2])
		
		print self.comboReglage.currentIndex()
		
		
	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"""
		if i==1: # 2ème onglet
			self.afficheurImg_1.setTailleFenetre()
		elif i==2: # 3ème onglet
			self.afficheurImg_2.setTailleFenetre()
	
	
	def ouvrirImages(self):
		txt = _("Fichier images")
		rep = self.base.getRepSource(self.listeChemin, self.config)
		listeChemin=QFileDialog.getOpenFileNames(None, _(u"Ouvrir"), 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);; *"))
		
		print "Chemin de chargement des images:", listeChemin, type(listeChemin)
		
		self.listeChemin = [str(listeChemin[i]) for i in range(len(listeChemin))]
		
		if self.listeChemin==[]: return
		
		self.listeChemin.sort()
		
		self.base.setRepSource(self.listeChemin, self.config)
		
		# Bouton actif une fois les images chargées
		self.boutAppliquer.setEnabled(True)
	
	
	def stat_dim_img(self):
		"""Calcul statistique des dimensions des images les plus présentes dans le lot"""
		
		# Ouverture et mise ds une liste des dimensions des images
		listePrepaRedim=[Image.open(aA).size for aA in self.listeChemin]
		
		# Merci beaucoup à Marc Keller de la liste: python at aful.org de m'avoir
		# aidé pour cette partie (les 4 lignes en dessous)
		dictSeq={}.fromkeys(listePrepaRedim, 0)
		for cle in listePrepaRedim: dictSeq[cle]+=1
		self.lStatDimSeq=sorted(zip(dictSeq.itervalues(), dictSeq.iterkeys()), reverse=1)
		self.dimStatImg=self.lStatDimSeq[0][1]
		
		print "Toutes les dimensions des images (avec le nbre d'images):", self.lStatDimSeq
		print 'Dimension des images la plus presente dans la sequence:', self.dimStatImg
		print "Nombre de tailles d'images différentes dans le lot :", len(self.lStatDimSeq)
		
		if len(self.lStatDimSeq)>1: return 0
		else: return 1
	
	
	def redim_img(self):
		"""Si l'utilisateur charge des images avec des tailles complètement différentes --> les images de la séquence  peuvent être redimensionnées"""
		
		if not self.stat_dim_img():
			reply = QMessageBox.warning(self, 'Message',
			_(u"Vos images ne sont pas toutes de la même taille. Voulez-vous redimensionner les images de sortie à la taille la plus répandue dans la séquence?"), QMessageBox.Yes, QMessageBox.No)
			if reply == QMessageBox.No:
				return
			
			# Les images de tailles différentes à la plus répandue sont redimensionnées
			# dans un répertoire temporaire.
			# Les images redimensionnées voient leur chemin modifié dans la liste des
			# chemins des images sources. Les autres chemins ne changent pas.
			index=0
			for chemImg in self.listeChemin:
				obImg=Image.open(chemImg)
				if obImg.size!=self.dimStatImg:
					pass
				sRedim=obImg.resize(self.dimStatImg)
				chemSortie = self.repTampon+'redim/'+os.path.basename(chemImg)
				sRedim.save(chemSortie)
				self.listeChemin[index] = chemSortie
				index += 1
	
	
	def sonderTempsActuel(self):
		"""x ms après l'apparition de la boite de dialogue, on lance la conversion. But: faire en sorte que la boite de dialogue ait le temps de s'afficher correctement"""
		self.timer.stop()
		self.appliquer()
	
	
	def appliquer0(self):
		"""Préparation de la conversion"""
		
		# Redimensionner les images de tailles différentes?
		self.redim_img()
		
		# Boîte de dialogue pour sauvegarder (nom du nouveau fichier)
		rep = self.base.getRepSource(self.listeChemin, self.config)
		self.chemDossierSauv=str(QFileDialog.getSaveFileName(None, _(u"Sauver"), rep, _(u"Tous les fichiers *.*")))
		
		if self.chemDossierSauv=='': return
		
		# Récupération de l'identifiant du codec
		self.i = self.comboReglage.currentIndex()
		
		self.progress.reset()
		self.progress.show()
		self.progress.setValue(0)
		QApplication.processEvents()
		
		# Lancement de la conversion dans 250 ms (seule solution trouvée pour éviter le grisage au début)
		self.timer.start(250)
	
	
	def appliquer(self):
		"""Conversion des images"""
		
		#for parcImg in self.listeChemin:
		nbreElem=len(self.listeChemin)
		
		# Liste pour affichage des images chargées (ds le tabwidget)
		listeAff_1=[]
		# Liste pour affichage des images sauvegardées (ds le tabwidget)
		listeAff_2=[]

		# Si Gif animé est sélectionné
		if self.comboReglage.currentIndex()==0:
			
			# Recup de la valeur de Nombre de couleurs (Réduction)
			spin = str(self.listeComboReglage[self.i][3].spin.value())
			
			os.system('convert -quiet -delay 5 -loop 0 -dither -colors '+spin+' '+' '.join(self.listeChemin)+' '+"\""+self.chemDossierSauv+'.gif'+"\"")
			
			for parc in range(nbreElem):
			
				# Remplissage de la liste pour les statistiques de rendu
				listeAff_1.append(self.listeChemin[parc])
				
				# --------------------------------------------
				# Affichage de la progression (avec
				# QProgressDialog) ds une fenêtre séparée .
				val_pourc=((parc+1)*100)/nbreElem

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

				self.progress.setValue(val_pourc)
			
				QApplication.processEvents()
				# --------------------------------------------
			
			# Affichage de la dernière image du lot chargée par l'utilisateur---
			self.afficheurImg_1.setImage(self.listeChemin[len(self.listeChemin)-1])
			# ------------------------------------------------------------------
			# Affichage du gif animé final (n'est pas affiché correctement) ----
			self.afficheurImg_2.setImage(self.chemDossierSauv+'.gif')
			# La page Image résultat devient visible à la fin des conversions
			self.tabwidget.setCurrentIndex(self.indexTabImgDestin)
			
			# Affichage des infos sur l'image -------------------------	
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte1=_(u" Image(s) chargée(s)")
			texte2=_(u" Gif animé final")
			a='#'*36
			
			self.infosImgProv_1=a+'\n#'+texte1+'\n'+a
			self.infosImgProv_2=a+'\n#'+texte2+'\n'+a
		
			# Images chargées
			for parcStatRendu_1 in listeAff_1:
				self.infosImgProv_1=self.infosImgProv_1+'\n'+parcStatRendu_1
			
			# Gif animé sauvegardé
			self.infosImgProv_2=self.infosImgProv_2+'\n'+self.chemDossierSauv+'.gif'
		
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv_1+'\n\n'+self.infosImgProv_2+'\n\n')
			self.framInfos.setEnabled(True)
			
			# remise à 0 de la variable provisoire de log
			self.infosImgProv_1=''
			self.infosImgProv_2=''
			# ---------------------------------------------------------

		# Si Morcellement/découpe d'image est sélectionné	
		elif self.comboReglage.currentIndex()==1:
			
			# Recup de la valeur de Nombre de morceaux (sens horizontal)
			spin_1 = self.listeComboReglage[self.i][3].spin1.value()
			# Recup de la valeur de Nombre de morceaux (sens vertical)
			spin_2 = self.listeComboReglage[self.i][3].spin2.value()
			
			# Ouverture de la 1ère image du lot pour extension
			im=Image.open(self.listeChemin[0])
			# Chemin, extension
			f, ext=os.path.splitext(self.listeChemin[0])
			
			# Résolution de l'image
			resLarg, resHaut=im.size
			
			# Comprehension-list pour calculer les coordonnées de découpe dans le sens horizontal
			l_1=[(totoX*(resLarg/spin_1), totoY*(resHaut/spin_2)) for totoY in range(spin_2) for totoX in range(spin_1)]
			# Comprehension-list pour calculer les coordonnées de découpe dans le sens vertical
			l_2=[(totoX*(resLarg/spin_1)+(resLarg/spin_1), totoY*(resHaut/spin_2)+(resHaut/spin_2)) for totoY in range(spin_2) for totoX in range(spin_1)]
			# Regroupement sens horizontal et vertical
			inter=zip(l_1, l_2)
			# Regroupement final des coordonnées horizontales et verticales pour la découpe.
			# Affiche par exemple: [(0, 0, 105, 144), (105, 0, 210, 144), (210, 0, 315, 144), ...]
			lF=[(x1[0], x1[1], y1[0], y1[1]) for x1, y1 in inter]
			
			# Marge (en pixels) pour l'affichage
			marge=6
			# Calcul des coordonnées pour affichage dans l'interface
			lCoAff=[(((tX+1)*marge)+(tX*(resLarg/spin_1)), ((tY+1)*marge)+(tY*(resHaut/spin_2))) for tY in range(spin_2) for tX in range(spin_1)]
			# Largeur de l'image de fond pour affichage ds l'interface
			largFondAffichage=resLarg+((spin_1+1)*marge)
			# Hauteur de l'image de fond pour affichage ds l'interface
			hautFondAffichage=resHaut+((spin_2+1)*marge)
			# Creation de l'image de fond pour acceuillir les morceaux de l'image (affichage
			# dans l'interface)
			imgFond=Image.new('RGB', (largFondAffichage, hautFondAffichage), (119, 119, 121))
			
			# Regroupement des coordonnées horizontales et verticales pour la découpe et des
			# coordonnées d'affichage des images découpées dans l'interface.
			lFinal=zip(lF, lCoAff)
			
			nbreElem_2=len(self.listeChemin)
			# Parcours principal des images chargées par l'utilisateur
			#for parcImg in range(len(self.listeChemin)):
			for parcImg in range(nbreElem_2):
				# Parcours pour la découpe de chaque image
				for a1 in enumerate(lFinal):
				
					# Index du morceau
					nb=a1[0]
					# Coordonnées de la découpe sous la forme (a, b, c, d)
					cDecoup=a1[1][0]
					# Coordonnées d'affichage ds l'interface (a, b)
					cAffInterfac=a1[1][1]
				
					print 'Index', nb, 'Coord decoupe', cDecoup, 'Coord affichage', cAffInterfac
					
					# Ouverture de chaque image
					im=Image.open(self.listeChemin[parcImg])
				
					# Voir doc: http://www.pythonware.com/library/pil/handbook/introduction.htm
					# Découpe ...
					c=im.crop(cDecoup)
					# Attention (et ce pour chaque fichier qui sera sauvegardé --> utilisateur
					# ou rep. temporaire) le 1er chiffre correspondra à l'image en cours, le 
					# second chiffre correspondra au morceau découpé en cours, la dernière
					# partie correspond au nombre de morceaux sur chaque ligne ... le signe
					# multiplié ... le nombre de morceaux sur chaque colonne. Exemple:
					# /.../.../.../nom_image_003_006_3x2.jpg
					# --> il s'agit de la 3ème image et du 6ème morceau découpé ... et nous
					# avons 3 images sur chaque ligne et 2 sur chaque colonne.
					c.save(self.chemDossierSauv+'_'+string.zfill(parcImg+1, 3)+'_'+string.zfill(nb+1, 3)+'_'+str(spin_1)+'x'+str(spin_2)+ext)
				
					# Ré-ouverture ...
					im2=Image.open(self.chemDossierSauv+'_'+string.zfill(parcImg+1, 3)+'_'+string.zfill(nb+1, 3)+'_'+str(spin_1)+'x'+str(spin_2)+ext)
				
					# Copie des images découpées dans l'image de fond
					imgFond.paste(im2, cAffInterfac)
					# Sauvegarde dans le rep. tampon pour affichage dans l'interface
					imgFond.save(self.repTampon+'dec_im_'+string.zfill(parcImg+1, 3)+'_'+string.zfill(nb+1, 3)+'_'+str(spin_1)+'x'+str(spin_2)+'.jpg')
					# Affichage ...
					self.afficheurImg_2.setImage(self.repTampon+'dec_im_'+string.zfill(parcImg+1, 3)+'_'+string.zfill(nb+1, 3)+'_'+str(spin_1)+'x'+str(spin_2)+'.jpg')
				
					# Remplissage de la liste des pages sauvegardées (Info)
					listeAff_2.append(self.chemDossierSauv+'_'+string.zfill(parcImg+1, 3)+'_'+string.zfill(nb+1, 3)+'_'+str(spin_1)+'x'+str(spin_2)+ext)
					
					# Remplissage de la liste pour les statistiques de rendu
					listeAff_1.append(self.listeChemin[parcImg])
				
					# La page Image résultat devient visible à la fin des conversions
					self.tabwidget.setCurrentIndex(self.indexTabImgDestin)
			
					# Affichage de la dernière image du lot chargée par l'utilisateur---
					self.afficheurImg_1.setImage(self.listeChemin[len(self.listeChemin)-1])
				
					# --------------------------------------------
					# Affichage de la progression (avec
					# QProgressDialog) ds une fenêtre séparée .
					val_pourc=((parcImg+1)*100)/nbreElem_2

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

					self.progress.setValue(val_pourc)
			
					QApplication.processEvents()
					# --------------------------------------------
					
			# Récupération du chemin + nom des fichiers
			# sauvegardés en ayant éliminé les doublons
			import sets
			listeAff_1=list(set(listeAff_1))
			listeAff_1.sort()
			
			# Affichage des infos sur l'image -------------------------	
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte1=_(u" Image(s) chargée(s)")
			texte2=_(u" Image(s) et morceaux découpés")
			a='#'*36
			
			self.infosImgProv_1=a+'\n#'+texte1+'\n'+a
			self.infosImgProv_2=a+'\n#'+texte2+'\n'+a
		
			# Images chargées
			for parcStatRendu_1 in listeAff_1:
				self.infosImgProv_1=self.infosImgProv_1+'\n'+parcStatRendu_1
			
			# Pages sauvegardées
			for parcStatRendu_2 in listeAff_2:
				self.infosImgProv_2=self.infosImgProv_2+'\n'+parcStatRendu_2
		
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv_1+'\n\n'+self.infosImgProv_2+'\n\n')
			self.framInfos.setEnabled(True)
			
			# remise à 0 de la variable provisoire de log
			self.infosImgProv_1=''
			self.infosImgProv_2=''
			# ---------------------------------------------------------

			# Epuration/elimination des fichiers tampon
			for toutRepTemp in glob.glob(self.repTampon+'*.*'):
				os.remove(toutRepTemp)
			# Si les images viennent d'être redimensionnées ...	
			if len(glob.glob(self.repTampon+'redim/*.*'))>0:
				# Epuration/elimination des fichiers tampon dans le rep redim
				for repTemp in glob.glob(self.repTampon+'redim/*.*'):
					os.remove(repTemp)
			
	
	def afficherAide(self):
		"""Boîte de dialogue de l'aide"""
		messageAide=QMessageBox(self)
		messageAide.setText(_(u"Blablablabla ... blabla."))
		messageAide.setWindowTitle(_(u"Aide"))
		messageAide.setIcon(QMessageBox.Information)
		messageAide.exec_()