dmonde/lib/rsc.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""controle l'acces aux ressources variables (sons, images, sauvegardes)"""
import os
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from ui.ecran_explorateur import Ui_exr_fenetre
from ui.panneauImage import Ui_exi_panneau

#le repertoire de l'application
ppal = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))

def repApp():
    return ppal

def repRessources():
    return ["ressources\\commun", \
            "ressources\\dd35", \
            "parties\\Partie1\\ressources"]

def selectionImage():
    retour = None
    expl = ExplorateurRessources()
    expl.charger("I")
    expl.show()
    expl.exec_()
    img = expl.selection()
    if img:
        if img.estValide():
            retour = img
    del expl    
    return retour

class Ressource(object):
    """classe de base des ressources utilisees"""
    def __init__(self, cheminR = ""):
        self._cheminR = cheminR

    def cheminR(self):
        return self._cheminR

    def chemin(self):
        """renvoie le chemin absolu vers le fichier"""
        return os.path.join(repApp(), self._cheminR)

    def nom(self):
        #on vire l'extension
        nom = ""
        for car in reversed(self._cheminR):
            if car in ["\\", "/"]:
                break
            else:
                nom = car + nom
        nom = os.path.splitext(nom)[0]
        return nom

    def repR(self):
        """renvoie le repertoire, presente de maniere relative"""
        return os.path.dirname(self._cheminR)
        
    def extension(self):
        return os.path.splitext(self._cheminR)[1]

    def definition(self):
        return self._cheminR
                
    def existe(self):
        return os.path.isfile(self.chemin())

    def estValide(self):
        return self.existe()

class RImage(Ressource):
    """classe de base des ressources utilisees"""
    def __init__(self, cheminR = ""):
        super(RImage, self).__init__(cheminR)

    def pix(self, l = 0, h = 0):
        pix = QPixmap(self.chemin())
        if not pix.isNull():
            if l > 0 and h > 0:
                pix = pix.scaled(l, h, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            elif l > 0 and h == 0:
                pix = pix.scaledToWidth(l, Qt.SmoothTransformation)
            elif l == 0 and h > 0:
                pix = pix.scaledToHeight(h, Qt.SmoothTransformation)                
        return pix

    def estValide(self):
        return self.existe() and \
               self.extension() in [".png", ".jpg", ".gif"]


class ExplorateurRessources(QDialog):
    def __init__(self, parent=None):
        """initialisation de la fenetre"""
        super (ExplorateurRessources, self).__init__(parent)
        self.createWidgets()
        self._selection = None
        self._panneaux = []
        self._panneauSelectionne = None

    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_exr_fenetre()
        self.ui.setupUi(self)
        
        self.connect(self.ui.exr_ok, SIGNAL("clicked()"), self.valider)
        self.connect(self.ui.exr_annuler, SIGNAL("clicked()"), self.annuler)
        self.connect(self.ui.exr_filtreNom, SIGNAL("textEdited(QString)"), self.majFiltre)
        self.connect(self.ui.exr_filtreRep, SIGNAL("currentIndexChanged(int)"), self.majFiltre)
        self.majLayout()

    def charger(self, typeRessource = "I"):
        """ressource vaut I ou S, pour image et sons"""
        fichiers = []
        for repR in repRessources():
            repAbs = os.path.join(repApp(), repR)
            for (dirpath, dirnames, filenames) in os.walk(repAbs):
                for f in filenames:
                    if typeRessource == "I":
                        r = RImage(os.path.join(repR, f))
                    else:
                        r = RSon(os.path.join(repR, f))
                    if r.estValide():          
                        fichiers.append(r)

        for f in fichiers:
            self.ajouterImage(f)
            
    def ajouterImage(self, img):
        """ajoute un panneau image a la liste deroulante"""
        panneau = PanneauImage(self)
        panneau.chargerImage(img)
        self._panneaux.append(panneau)
        self.ui.exr_layout.addWidget(panneau)

    def selection(self):
        return self._selection

    def majSelection(self, panneau):
        if self._panneauSelectionne:
            self._panneauSelectionne.selectionner(False)
        self._panneauSelectionne = panneau
        self.majAffichage()

    def majAffichage(self):
        self.ui.exr_ok.setEnabled(self._panneauSelectionne != None)

    def majFiltre(self):
        filtreRep = ""
        if self.ui.exr_filtreRep.currentIndex() > 0:
            filtreRep = repRessources()[(self.ui.exr_filtreRep.currentIndex()-1)]
        filtreNom = self.ui.exr_filtreNom.texte()
        for panneau in self._panneaux:
            panneau.appliquerFiltre(filtreRep, filtreNom)

    def majLayout(self):
        self.ui.exr_layout.setColumnMinimumWidth(0, 140)
        self.ui.exr_layout.setColumnStretch(0, 1)
        self.ui.exr_layout.setColumnMinimumWidth(1, 140)
        self.ui.exr_layout.setColumnStretch(1, 1)
        self.ui.exr_layout.setColumnMinimumWidth(2, 140)
        self.ui.exr_layout.setColumnStretch(2, 1)
        self.ui.exr_layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)

    def valider(self):
        self._selection = self._panneauSelectionne.image()
        self.done(1)

    def annuler(self):
        self.done(0)

class PanneauImage(QFrame):
    def __init__(self, fenetre, parent=None):
        """initialisation de la fenetre"""
        self.fenetre = fenetre
        super (PanneauImage, self).__init__(parent)
        self.createWidgets()
        self._image = None
        self._selectionnee = False

    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_exi_panneau()
        self.ui.setupUi(self)
        self.connect(self.ui.exi_image, SIGNAL("clicked()"), self.clic)
        self.connect(self.ui.exi_nom, SIGNAL("clicked()"), self.clic)
        self.connect(self.ui.exi_details, SIGNAL("clicked()"), self.clic)
        self.connect(self.ui.exi_situ, SIGNAL("clicked()"), self.clic)
        self.connect(self.ui.exi_image, SIGNAL("doubleClicked()"), self.doubleClic)
        self.connect(self.ui.exi_nom, SIGNAL("doubleClicked()"), self.doubleClic)
        self.connect(self.ui.exi_details, SIGNAL("doubleClicked()"), self.doubleClic)
        self.connect(self.ui.exi_situ, SIGNAL("doubleClicked()"), self.doubleClic)
        
    def selectionner(self, actif):
        if actif:
            couleur = QColor(250, 250, 250, 250)
        else:
            couleur = QColor(240, 240, 240, 240)
        palette = QPalette()
        palette.setColor(QPalette.Window, couleur)
        self.setPalette(palette)
        
    def chargerImage(self, image):
        self.ui.exi_image.chargerImage(image)
        self.ui.exi_nom.majTexte(image.nom())
        self.ui.exi_details.majTexte((image.extension().replace(".", "")).upper())
        self.ui.exi_situ.majTexte(image.repR())
        self._image = image

    def image(self):
        return self._image

    def appliquerFiltre(self, filtreRep, filtreNom):
        if len(filtreRep) > 0:
            self.setVisible(filtreNom in self._image.nom() and \
                            self._image.repR() == filtreRep)
        else:
            self.setVisible(filtreNom in self._image.nom())

    def clic(self):
        if not self._selectionnee:
            self.fenetre.majSelection(self)
            self.selectionner(True)        

    def doubleClic(self):
        self.fenetre.valider()
        
    def mousePressEvent(self, event):
        if event.button() == 1:
            self.clic()

    def mouseDoubleClickEvent(self, event):
        if event.button() == 1:
            self.doubleClic()