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

from PyQt4.QtCore import *
from PyQt4.QtGui import *

class VisionneurImagePourEKD(QScrollArea):
	''' Classe pour l'affichage des images (avec des barres de
	défilement)'''
	def __init__(self, img=""):
		QScrollArea.__init__(self)
		
		# Variables de paramètres
		self.modeTransformation=Qt.SmoothTransformation
		
		# widget qui contiendra l'image
		# Création du label
		self.imageLabel=QLabel(self)
		
		self.setBackgroundRole(QPalette.Dark)
		
		# L'image chargée s'aligne au centre
		self.imageLabel.setAlignment(Qt.AlignCenter)
		
		# image par défaut
		self.setImage("Icones/avant-image.png")
		
		self.setWidget(self.imageLabel)
		
		# Si une image est en paramètre de classe, on l'affiche directement
		# sinon on pourra toujours l'afficher plus tard en appelant la
		# méthode setImage() de l'objet VisionneurImagePourEKD, le moment venu
		if img != "":
			self.setImage(img)
			self.setToolTip(img)
		else: self.setToolTip(_(u"image d'accueil"))
		
		print "Label : Y : " + str(self.imageLabel.height()), "X : " + str(self.imageLabel.width())
		print 'TAILLE', self.height(), self.width() 	# 480 x 640 au lieu de 597 x 548

		# Position du curseur dans le QScrollArea au moment du clic de la souris
		self.positionPresseeSourisIni = QPoint()
		# Position du point haut-gauche du QScrollArea par rapport au QPixMap entier au
		# moment du clic de la souris (par la suite appelée "position de la barre de défilement")
        	self.positionBarrePresseeSourisIni = QPoint()
		
		# Création du menu contextuel
		self.menuZoom=QMenu("Zoom")
		
		# Entrée zoom taille réelle
		self.menuTailleReelle=self.menuZoom.addAction(_(u'&Taille Réelle'))
		self.menuTailleReelle.setIcon(QIcon("Icones/taillereelle.png"))
		self.connect(self.menuTailleReelle, SIGNAL("triggered()"), self.setTailleReelle)
		
		# Entrée zoom taille fenetre
		self.menuTailleFenetre=self.menuZoom.addAction(_(u'&Adapter à la fenêtre'))
		self.menuTailleFenetre.setIcon(QIcon("Icones/fenetre.png"))
		self.connect(self.menuTailleFenetre, SIGNAL("triggered()"), self.setTailleFenetre)
	
		# Entrée zoom +
		self.menuZoomPlus=self.menuZoom.addAction(_(u'&Zoom Avant'))
		self.menuZoomPlus.setIcon(QIcon("Icones/zoomplus.png"))
		self.connect(self.menuZoomPlus, SIGNAL("triggered()"), self.zoomAvant)
		
		# Entrée zoom - 
		self.menuZoomMoins=self.menuZoom.addAction(_(u'&Zoom Arrière'))
		self.menuZoomMoins.setIcon(QIcon("Icones/zoommoins.png"))
		self.connect(self.menuZoomMoins, SIGNAL("triggered()"), self.zoomArriere)
		
		self.setAlignment(Qt.AlignCenter)
	
	
	def mousePressEvent(self, event):
		"Menu contextuel et enregistrement de données préparant le déplacement de l'image par pincement"
		
		# Menu contextuel
		if event.button() == Qt.RightButton: 
			self.menuZoom.popup(event.globalPos())
		#else:
			# Déplacement
		#	self.startPos=event.pos()
		
		# On enregistre la position du curseur et de la barre de défilement au moment du clic
		elif event.button() == Qt.LeftButton:
			self.positionPresseeSourisIni = QPoint(event.pos())
			self.positionBarrePresseeSourisIni.setX(self.horizontalScrollBar().value())
			self.positionBarrePresseeSourisIni.setY(self.verticalScrollBar().value())
			self.setCursor(Qt.ClosedHandCursor) # curseur main fermée
			event.accept()
	
	def mouseMoveEvent(self, event):
		"Déplacement de l'image dans le QScrollArea quand la souris est pressée"
		# Déplacement uniquement si l'image dépasse
		#if (self.objImg.height() > self.height()) or (self.objImg.width() > self.width()):
		#	# Calcul du chemin parcouru
		#	self.
		
		if self.positionPresseeSourisIni.isNull():
			event.ignore()
			return
		
		# Nouvelles positions de la barre de défilement (selon x et y)
		self.horizontalScrollBar().setValue(self.positionBarrePresseeSourisIni.x() + (self.positionPresseeSourisIni.x() - event.pos().x()))
		self.verticalScrollBar().setValue(self.positionBarrePresseeSourisIni.y() + (self.positionPresseeSourisIni.y() - event.pos().y()))
		self.horizontalScrollBar().update()
		self.verticalScrollBar().update()
		event.accept()
	
	def mouseReleaseEvent(self, event):
		"Réaffichage du curseur classique de la souris"
		self.setCursor(Qt.ArrowCursor)
		event.accept()
	
	def setScaleMode(self, mode):
		"Choix du mode de redimensionnement"
		# Mise à jour du paramètre
		self.modeTransformation=mode
	
	def setTailleFenetre(self):
		"Affichage taille fenetre"
		#print "-----------------------------------------"
		#print "Scroll : Y : " + str(self.height()), "X : " + str(self.width())		
		#print "Label : Y : " + str(self.imageLabel.height()), "X : " + str(self.imageLabel.width())
		#print "Image : Y : " + str(self.objImg.height()), "X : " + str(self.objImg.width())
		
		# Gestion de la taille
		#- Si l'image rentre
		if (self.objImg.height() < self.height()) and (self.objImg.width() < self.width()):
			# On redimensionne le label à la taille de l'image
			self.imageLabel.resize(self.objImg.width(), self.objImg.height())
			self.imageLabel.setPixmap(self.objImg)
			
		#- Si l'image est trop grande
		else:
			#print "Hauteur :", str(self.objImg.height()-self.height()), "Largeur :", str(self.objImg.width()-self.width())
			
			#-- Calcul de la différence de dépassement
			if (self.objImg.height()-self.height()) >= (self.objImg.width()-self.width()):
				#--- C'est en hauteur que ca depasse le plus
				#--- On redimensionne en hauteur
				resultat = self.objImg.scaledToHeight(self.height()-5, self.modeTransformation)
				#print "Hauteur"
			else:
				#--- C'est en largeur que ca depasse le plus
				#--- On redimensionne en largeur
				resultat = self.objImg.scaledToWidth(self.width()-5, self.modeTransformation)
				#print "Largeur"
			
			#-- On met l'image et on redimensionne le Label
			self.imageLabel.setPixmap(resultat)
			self.imageLabel.resize(resultat.width(), resultat.height())
			#print "Scroll : Y : " + str(self.height()), "X : " + str(self.width())
			#print "Label : Y : " + str(self.imageLabel.height()), "X : " + str(self.imageLabel.width())
			#print "Image : Y : " + str(resultat.height()), "X : " + str(resultat.width())	
	
	def setTailleReelle(self):
		"Fonction d'affichage en taille réelle"
		
		# On redimensionne le label à la taille de l'image
		self.imageLabel.resize(self.objImg.width(), self.objImg.height())
		
		# On place l'image originale dans le label
		self.imageLabel.setPixmap(self.objImg)
	
	def zoomAvant(self):
		"Fonction de zoom avant 25%"
		
		# On redimensionne l'image à 125% de la taille actuelle
		resultat = self.objImg.scaledToWidth(int(self.imageLabel.width()*5/4), self.modeTransformation)
		self.imageLabel.setPixmap(resultat)
		self.imageLabel.resize(resultat.width(), resultat.height())
	
	def zoomArriere(self):
		"Fonction de zoom arrière 25%"
		
		# On redimensionne l'image à 75% de la taille actuelle
		resultat = self.objImg.scaledToWidth(int(self.imageLabel.width()*3/4), self.modeTransformation)	
		self.imageLabel.setPixmap(resultat)
		self.imageLabel.resize(resultat.width(), resultat.height())
	
	def setImage(self, img=None):
		"Fonction de mise en place de l'image"
		
		if not img:
			img = "Icones/avant-image.png"
			self.setToolTip(_(u"image d'accueil"))
		else: self.setToolTip(img)
		
		# Chargement de l'image
		self.objImg = QPixmap(img)
		self.imageLabel.clear()
		
		# Par défault on charge en taille fenetre
		self.setTailleFenetre()
