# -*- coding: iso-8859-1 -*-
# Copyright 20003 - 2008: Julien Bourdaillet (julien.bourdaillet@lip6.fr), Jean-Gabriel Ganascia (jean-gabriel.ganascia@lip6.fr)
# This file is part of MEDITE.
#
#    MEDITE is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    MEDITE is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with Foobar; if not, write to the Free Software
#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#----------------------------------------------------------------------------
# Nom:          planTravail.py
# Objet:        Fichier qui regroupe la classe PlanTravail,
#               la classe des parametres, la classe des couleurs
#               et la classe qui permet d'accéder aux trois
#----------------------------------------------------------------------------

from Utile.constantesDonnees import *
from Utile.exceptionsDonnees import *


import shelve
import posixpath
import sys

class ListePlanTravail:
    def __init__(self):
        self.__listePlanTravail = []

    def getListe(self):
        return self.__listePlanTravail
        
    def appendPlanTravail(self, planTravail):
        self.__listePlanTravail.append(planTravail)

    def deletePlanTravail(self,plan):
        self.__listePlanTravail.remove(plan)
        
    def flushListe(self):
        self.__listePlanTravail = []
        
    def estVide(self):
        if len(self.__listePlanTravail) == 0:
            return True
        else: return False
        
    def toString(self):
        res = ''
        if len(self.__listePlanTravail) == 0:
            res = "listePlanTravil vide"
        else:
            for plan in self.__listePlanTravail:
                res += plan.toString()
        return res
        
# classe qui regroupe les donnees du plan de travail du chercheur
class PlanTravail:
    # constructeur de la classe
    def __init__(self, pAuteur, pOeuvre, pVS, pFS, pVC, pFC, pParam):
        self.__auteur = pAuteur
        self.__oeuvre = pOeuvre
        self.__versSource = pVS
        self.__feuilSource = pFS
        self.__versCible = pVC
        self.__feuilCible = pFC
        self.__param = pParam

    def toString(self):
        return 'Auteur = ' +self.getAuteur()+ " / Oeuvre = "+self.getOeuvre()+ " / Version Source = "+self.getVersionSource()+" / Etat Source = "+self.getEtatSource()+" / Version Cible = "+self.getVersionCible()+ " / Etat Cible = "+self.getEtatCible()+ " / " +self.getParam().toString()+"\n"
        
    # Methode d'acces aux attributs prives
    def getAuteur(self):
        return self.__auteur

    def getOeuvre(self):
        return self.__oeuvre

    def getVersionSource(self):
        return self.__versSource
    
    def getEtatSource(self):
        return self.__feuilSource
    
    def getVersionCible(self):
        return self.__versCible 
    
    def getEtatCible(self):
        return self.__feuilCible
        
    def getParam(self):
        return self.__param
        
    # Methode de mise à jour des attributs prives
    def setAuteur(self, pAuteur):
        self.__auteur = pAuteur

    def setOeuvre(self, pOeuvre):
        self.__oeuvre = pOeuvre

    def setVersionSource(self, pVS):
        self.__versSource = pVS
    
    def setEtatSource(self, pFS):
        self.__feuilSource = pFS
    
    def setVersionCible(self, pVC):
        self.__versCible = pVC
    
    def setEtatCible(self, pFC):
        self.__feuilCible = pFC

    def setParam(self, pParam):
        self.__param = pParam
        
# classe qui regroupe les parametres de lissage
# 1 - longueur minimale des chaines pivots (et deplacees)
# 2 - ratio minimal de longueur des chaines pour valider un remplacement
# 3 - seuil du rapport de longueur des chaines pour valider un lissage
# 4 - mode mot ou caractère pour l'algo medite  
class Parametres:
    # constructeur de la classe
    def __init__(self, pP1=5, pP2=50, pP3=50, pP4=0, pP5=1, pP6=1, pP7=1):
        self.__p1 = pP1
        self.__p2 = pP2
        self.__p3 = pP3
        self.__p4 = pP4
        self.__p5 = pP5
        self.__p6 = pP6
        self.__p7 = pP7
        
    def isNull(self):
        if self.getp1()==0 and self.getp2()==0 and self.getp3()==0: return True
        else: return False
        
    def toString(self):
        return "Param: p1 = "+str(self.getp1())+" / p2 = "+str(self.getp2())+ \
        " / p3 = "+str(self.getp3())+" / p4 = "+str(self.getp4())+ \
        " / p5 = "+str(self.getp5())+" / p6 = "+str(self.getp6())+ \
        " / p7 = "+str(self.getp7())+"\n"
    
    # Methode d'acces aux attributs prives
    def getp1(self):
        return self.__p1

    def getp2(self):
        return self.__p2

    def getp3(self):
        return self.__p3

    def getp4(self):
        return self.__p4
        
    def getp5(self):
        return self.__p5

    def getp6(self):
        return self.__p6
        
    def getp7(self):
        return self.__p7
        
    # Methode de mise a jour des attributs prives
    def setp1(self, pP1):
        self.__p1 = pP1

    def setp2(self,pP2):
        self.__p2 = pP2

    def setp3(self, pP3):
        self.__p3 = pP3 
        
    def setp4(self, pP4):
        self.__p4 = pP4 

    def setp5(self, pP5):
        self.__p5 = pP5 
        
    def setp6(self, pP6):
        self.__p6 = pP6 
    
    def setp7(self, pP7):
        self.__p7 = pP7
        
# classe qui regroupe les couleurs de visualisation des transformations
# de la forme [Red, Green, Blue] pour chaque couleur
class CouleursMemorisees:
    # constructeur de la classe
    def __init__(self, pCoulInsert, pCoulSupp, pCoulRemp, pDeplacement):
        self.__coulRemp = pCoulRemp
        self.__coulSupp = pCoulSupp
        self.__coulInsert = pCoulInsert
        self.__ecriture = DEFAUT_ECRITURE_BLANC
        self.__deplacement = pDeplacement #DEFAUT_SOULIGNE_DEPLACEMENT ## =1 VRAI
        
        
    # Methode d'acces aux attributs prives
    def getCoulRemp(self):
        return self.__coulRemp

    def getCoulSupp(self):
        return self.__coulSupp

    def getCoulInsert(self):
        return self.__coulInsert
    
    def getEcriture(self):
        return self.__ecriture

    def getDeplacement(self):
        return self.__deplacement
        
    # Methode de mise a jour des attributs prives
    def setCoulRemp(self, pCoulRemp):
        self.__coulRemp = pCoulRemp
        
    def setCoulInsert(self, pCoulInsert):
        self.__coulInsert = pCoulInsert
        
    def setCoulSupp(self, pCoulSupp):
        self.__coulSupp = pCoulSupp

# classe qui regroupe les couleurs de visualisation des transformations
# de la forme (Red, Green, Blue) pour chaque couleur
class CouleursInterface:
    # constructeur de la classe
    def __init__(self, pCoulInsert, pCoulSupp, pCoulRemp, pEcriture, pDeplacement):#pSouligne):
        self.__coulRemp = pCoulRemp
        self.__coulSupp = pCoulSupp
        self.__coulInsert = pCoulInsert
        self.__ecriture = pEcriture
        self.__deplacement = pDeplacement
        
    # Methode d'acces aux attributs prives
    def getCoulRemp(self):
        return self.__coulRemp

    def getCoulSupp(self):
        return self.__coulSupp

    def getCoulInsert(self):
        return self.__coulInsert
        
    def getEcriture(self):
        return self.__ecriture
 
    #def getSouligne(self):
    #    return self.__souligneDep

    def getDeplacement(self):
        return self.__deplacement
        
    # Methode de mise a jour des attributs prives
    def setCoulRemp(self, pCoulRemp):
        self.__coulRemp = pCoulRemp
        
    def setCoulInsert(self, pCoulInsert):
        self.__coulInsert = pCoulInsert
        
    def setCoulSupp(self, pCoulSupp):
        self.__coulSupp = pCoulSupp
    
    def setDeplacement(self,pDeplacement):
        self.__deplacement = pDeplacement


        
#classe pour acceder au fichier qui detient les donnees de travail
# sérialiseur des objets de donnée
class DonneesTravail:
    # methode pour recuperer la liste des plans de travail
    def chargerListePlans(self):
        if posixpath.isfile(PLANTRAVAIL):
            ficTravail = shelve.open(PLANTRAVAIL)
            listePlans = ficTravail['listePlans']
            ficTravail.close()
            return listePlans
        else :
            raise FichierNonTrouve()
            
    # methode pour recuperer les donnees du plan de travail
    #def chargerPlan(self):
    #    if posixpath.isfile(PLANTRAVAIL):
    #        ficTravail = shelve.open(PLANTRAVAIL)
    #        plan = ficTravail['plan']
    #        ficTravail.close()
    #        return plan
    #    else :
    #        raise FichierNonTrouve()

    # methode pour recuperer les couleurs
    def chargerCouleurs(self):
        if posixpath.isfile(FIC_COULEURS):
            ficTravail = shelve.open(FIC_COULEURS)
            couleurs = ficTravail['couleurs']
            ficTravail.close()
            return couleurs
        else :
            raise FichierNonTrouve()

    # methode pour recuperer les parametres
    def chargerParametres(self):
        if posixpath.isfile(FIC_PARAMETRES):
            ficTravail = shelve.open(FIC_PARAMETRES)
            parametres = ficTravail['parametres']
            ficTravail.close()
            return parametres
        else :
            raise FichierNonTrouve()

    # methode pour enregistrer la liste des plans de travail
    def enregistrerListePlans(self, pListePlans):
        ficTravail = shelve.open(PLANTRAVAIL)
        ficTravail['listePlans']= pListePlans
        ficTravail.close()
        
    # methode pour enregistrer le plan de travail
#    def enregistrerPlan(self, pPlan):
#        ficTravail = shelve.open(PLANTRAVAIL)
#        ficTravail['plan']= pPlan
#        ficTravail.close()
        
    # methode pour enregistrer les couleurs
    def enregistrerCouleurs(self, pCoul):
        ficTravail = shelve.open(FIC_COULEURS)
        ficTravail['couleurs']= pCoul
        ficTravail.close()

    # methode pour enregistrer les parametres
    def enregistrerParametres(self, pPara):
        ficTravail = shelve.open(FIC_PARAMETRES)
        ficTravail['parametres']= pPara
        ficTravail.close()