X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MCSIMP.py;h=0bd9a544771ce49c5aafad018c4faba90bff3efb;hb=94531d13450fad5a118e4d39d9693f46eb7e59a0;hp=3c4052a31b0fe598c357f69a797d54390dedab3a;hpb=61f2a263b67981f299c496ce7ef8bccc3ac6e68b;p=tools%2Feficas.git diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 3c4052a3..0bd9a544 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -1,43 +1,46 @@ # -*- coding: utf-8 -*- -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM 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. +# Copyright (C) 2007-2017 EDF R&D # -# THIS PROGRAM 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. +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# This library 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 +# Lesser General Public License for more details. # +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # -# ====================================================================== -import types,string +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +from __future__ import absolute_import +import types import traceback from copy import copy -from repr import Repr +from six.moves.reprlib import Repr +from Extensions.i18n import tr +from Extensions.eficas_exception import EficasException +from six.moves import range myrepr = Repr() myrepr.maxstring = 100 myrepr.maxother = 100 from Noyau.N_utils import repr_float import Validation -import CONNECTOR +from . import CONNECTOR -# Attention : les classes ASSD,.... peuvent etre surchargées -# dans le package Accas. Il faut donc prendre des précautions si +# Attention : les classes ASSD,.... peuvent etre surchargees +# dans le package Accas. Il faut donc prendre des precautions si # on utilise les classes du Noyau pour faire des tests (isxxxx, ...) -# Si on veut créer des objets comme des CO avec les classes du noyau +# Si on veut creer des objets comme des CO avec les classes du noyau # ils n'auront pas les conportements des autres packages (pb!!!) -# Il vaut mieux les importer d'Accas mais problème d'import circulaire, -# on ne peut pas les importer au début. -# On fait donc un import local quand c'est nécessaire (peut occasionner +# Il vaut mieux les importer d'Accas mais probleme d'import circulaire, +# on ne peut pas les importer au debut. +# On fait donc un import local quand c'est necessaire (peut occasionner # des pbs de prformance). from Noyau.N_ASSD import ASSD,assd from Noyau.N_GEOM import GEOM,geom @@ -47,75 +50,92 @@ import Accas from Extensions import parametre from Extensions import param2 -import I_OBJECT -import CONNECTOR -from I_VALIDATOR import ValError,listProto +from . import I_OBJECT +from . import CONNECTOR +from .I_VALIDATOR import ValError,listProto class MCSIMP(I_OBJECT.OBJECT): - def isvalid(self,cr='non'): + + def isValid(self,cr='non'): if self.state == 'unchanged': return self.valid for type_permis in self.definition.type: if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice': self.monType=type_permis return self.valideMatrice(cr=cr) - return Validation.V_MCSIMP.MCSIMP.isvalid(self,cr=cr) + validite=Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr) + if self.definition.siValide != None and validite: + self.definition.siValide(self) + return validite - def GetNomConcept(self): + def getNomConcept(self): p=self while p.parent : try : - nomconcept=p.get_sdname() + nomconcept=p.getSdname() return nomconcept except: try : - nomconcept= p.object.get_sdname() + nomconcept= p.object.getSdname() return nomconcept except : pass p=p.parent return "" - def GetText(self): + def getText(self): """ - Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet - pointé par self + Retourne le texte a afficher dans l'arbre representant la valeur de l'objet + pointe par self """ if self.valeur == None : return None - elif type(self.valeur) == types.FloatType : - # Traitement d'un flottant isolé + elif type(self.valeur) == float : + # traitement d'un flottant isole txt = str(self.valeur) - clefobj=self.GetNomConcept() - if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj): - if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(self.valeur): + clefobj=self.getNomConcept() + if clefobj in self.jdc.appli.appliEficas.dict_reels : + if self.valeur in self.jdc.appli.appliEficas.dict_reels[clefobj]: txt=self.jdc.appli.appliEficas.dict_reels[clefobj][self.valeur] - elif type(self.valeur) in (types.ListType,types.TupleType) : - # Traitement des listes + elif type(self.valeur) in (list,tuple) : + if self.valeur==[] or self.valeur == (): return str(self.valeur) + # traitement des listes txt='(' sep='' for val in self.valeur: - if type(val) == types.FloatType : - clefobj=self.GetNomConcept() - if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj): - if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(val): + if type(val) == float : + clefobj=self.getNomConcept() + if clefobj in self.jdc.appli.appliEficas.dict_reels: + if val in self.jdc.appli.appliEficas.dict_reels[clefobj]: txt=txt + sep +self.jdc.appli.appliEficas.dict_reels[clefobj][val] else : txt=txt + sep + str(val) else : txt=txt + sep + str(val) else: - txt = txt + sep+ str(val) - if len(txt) > 200: - #ligne trop longue, on tronque - txt=txt+" ..." - break + if isinstance(val,tuple): + texteVal='(' + for i in val : + if isinstance(i, bytes) or isinstance(i,str) : texteVal = texteVal +"'"+str(i)+"'," + else : texteVal = texteVal + str(i)+',' + texteVal=texteVal[:-1]+')' + else : + if isinstance(val,bytes) or isinstance(val, str): texteVal="'"+str(val)+"'" + else :texteVal=str(val) + txt = txt + sep+ texteVal + +## if len(txt) > 200: +## #ligne trop longue, on tronque +## txt=txt+" ..." +## break sep=',' + # cas des listes de tuples de longueur 1 + if isinstance(val,tuple) and len(self.valeur) == 1 : txt=txt+',' txt=txt+')' else: - # Traitement des autres cas + # traitement des autres cas txt = str(self.valeur) # txt peut etre une longue chaine sur plusieurs lignes. @@ -125,100 +145,125 @@ class MCSIMP(I_OBJECT.OBJECT): # Pour le moment on retourne la chaine telle que return txt - def getval(self): + def getVal(self): """ - Retourne une chaîne de caractère représentant la valeur de self + Retourne une chaine de caractere representant la valeur de self """ val=self.valeur - if type(val) == types.FloatType : - clefobj=self.GetNomConcept() - if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj): - if self.jdc.appli.appliEficas.appliEficas.dict_reels[clefobj].has_key(val): + if type(val) == float : + clefobj=self.getNomConcept() + if clefobj in self.jdc.appli.appliEficas.dict_reels : + if val in self.jdc.appli.appliEficas.appliEficas.dict_reels[clefobj] : return self.jdc.appli.appliEficas.dict_reels[clefobj][val] - if type(val) != types.TupleType : + if type(val) != tuple : try: - return val.get_name() + return val.getName() except: return val else : + if val ==() or val == [] : return val s='( ' for item in val : try : - s=s+item.get_name()+',' + s=s+item.getName()+',' except: - s=s+`item`+',' + s=s+repr(item)+',' s=s+' )' return s - def wait_co(self): + def waitBool(self): + for typ in self.definition.type: + try : + if typ == bool: return True + except : + pass + return False + + def waitCo(self): """ - Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD + Methode booleenne qui retourne 1 si l'objet attend un objet ASSD qui n'existe pas encore (type CO()), 0 sinon """ for typ in self.definition.type: - if type(typ) == types.ClassType or isinstance(typ,type): + if type(typ) == type or isinstance(typ,type): if issubclass(typ,CO) : return 1 return 0 - def wait_assd(self): + def waitAssd(self): """ - Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD - ou dérivé, 0 sinon + Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD + ou derive, 0 sinon """ for typ in self.definition.type: - if type(typ) == types.ClassType or isinstance(typ,type): + if type(typ) == type or isinstance(typ,type): if issubclass(typ,ASSD) and not issubclass(typ,GEOM): return 1 return 0 - def wait_assd_or_geom(self): + def waitAssdOrGeom(self): """ - Retourne 1 si le mot-clé simple attend un objet de type + Retourne 1 si le mot-cle simple attend un objet de type assd, ASSD, geom ou GEOM Retourne 0 dans le cas contraire """ for typ in self.definition.type: - if type(typ) == types.ClassType or isinstance(typ,type): + if type(typ) == type or isinstance(typ,type): if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) : return 1 return 0 - def wait_geom(self): + def waitGeom(self): """ - Retourne 1 si le mot-clé simple attend un objet de type GEOM + Retourne 1 si le mot-cle simple attend un objet de type GEOM Retourne 0 dans le cas contraire """ for typ in self.definition.type: - if type(typ) == types.ClassType or isinstance(typ,type): + if type(typ) == type or isinstance(typ,type): if issubclass(typ,GEOM) : return 1 return 0 - def wait_TXM(self): + + def waitTxm(self): """ - Retourne 1 si le mot-clé simple attend un objet de type TXM + Retourne 1 si le mot-cle simple attend un objet de type TXM Retourne 0 dans le cas contraire """ for typ in self.definition.type: if typ == 'TXM' :return 1 return 0 - def get_liste_valeurs(self): + def waitTuple(self): + for ss_type in self.definition.type: + if repr(ss_type).find('Tuple') != -1 : + return 1 + return 0 + + + def getListeValeurs(self): """ """ if self.valeur == None: return [] - elif type(self.valeur) == types.TupleType: + elif type(self.valeur) == tuple: return list(self.valeur) - elif type(self.valeur) == types.ListType: + elif type(self.valeur) == list: return self.valeur else: return [self.valeur] - def isoblig(self): + def isOblig(self): return self.definition.statut=='o' - def valid_val(self,valeur): + def isImmuable(self): + return self.definition.homo=='constant' + + def isInformation(self): + return self.definition.homo=='information' + + + + def validVal(self,valeur): """ Verifie que la valeur passee en argument (valeur) est valide sans modifier la valeur courante @@ -226,7 +271,7 @@ class MCSIMP(I_OBJECT.OBJECT): lval=listProto.adapt(valeur) if lval is None: valid=0 - mess="None n'est pas une valeur autorisée" + mess=tr("None n'est pas une valeur autorisee") else: try: for val in lval: @@ -236,20 +281,20 @@ class MCSIMP(I_OBJECT.OBJECT): if self.definition.validators: self.definition.validators.convert(lval) valid,mess=1,"" - except ValError,e: + except ValError as e: mess=str(e) valid=0 return valid,mess - def valid_valeur(self,new_valeur): + def validValeur(self,new_valeur): """ Verifie que la valeur passee en argument (new_valeur) est valide - sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant) + sans modifier la valeur courante (evite d'utiliser setValeur et est plus performant) """ - validite,mess=self.valid_val(new_valeur) + validite,mess=self.validVal(new_valeur) return validite - def valid_valeur_partielle(self,new_valeur): + def validValeurPartielle(self,new_valeur): """ Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide sans modifier la valeur courante du mot cle @@ -259,45 +304,46 @@ class MCSIMP(I_OBJECT.OBJECT): for val in new_valeur: self.typeProto.adapt(val) self.intoProto.adapt(val) - #on ne verifie pas la cardinalité + #on ne verifie pas la cardinalite if self.definition.validators: - validite=self.definition.validators.valide_liste_partielle(new_valeur) - except ValError,e: + validite=self.definition.validators.valideListePartielle(new_valeur) + except ValError as e: validite=0 return validite - def update_condition_bloc(self): + def updateConditionBloc(self): """ Met a jour les blocs conditionnels dependant du mot cle simple self """ if self.definition.position == 'global' : - self.etape.deep_update_condition_bloc() + self.etape.deepUpdateConditionBloc() elif self.definition.position == 'global_jdc' : - self.jdc.deep_update_condition_bloc() + self.jdc.deepUpdateConditionBloc() else: - self.parent.update_condition_bloc() + self.parent.updateConditionBloc() - def set_valeur(self,new_valeur,evaluation='oui'): - #print "set_valeur",new_valeur - self.init_modif() + def setValeur(self,new_valeur,evaluation='oui'): + print ("setValeur Ihm/IMCSIMP ",new_valeur) + self.initModif() self.valeur = new_valeur self.val = new_valeur - self.update_condition_bloc() + #self.setValeurObjPyxb(new_valeur) + self.updateConditionBloc() self.etape.modified() - self.fin_modif() + self.finModif() return 1 - def eval_valeur(self,new_valeur): + def evalValeur(self,new_valeur): """ - Essaie d'évaluer new_valeur comme une SD, une déclaration Python - ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0) + Essaie d'evaluer new_valeur comme une SD, une declaration Python + ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0) """ - sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape) - #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None) + sd = self.jdc.getSdAvantEtape(new_valeur,self.etape) + #sd = self.jdc.getContexteAvant(self.etape).get(new_valeur,None) #print sd if sd is not None: return sd,1 - lsd = self.jdc.cherche_list_avant(self.etape,new_valeur) + lsd = self.jdc.chercheListAvant(self.etape,new_valeur) if lsd : return lsd,1 else: @@ -308,7 +354,7 @@ class MCSIMP(I_OBJECT.OBJECT): objet = eval(new_valeur,d) return objet,1 except Exception: - itparam=self.cherche_item_parametre(new_valeur) + itparam=self.chercheItemParametre(new_valeur) if itparam: return itparam,1 try : @@ -318,30 +364,33 @@ class MCSIMP(I_OBJECT.OBJECT): if CONTEXT.debug : traceback.print_exc() return None,0 - def eval_val(self,new_valeur): + def evalVal(self,new_valeur): """ - Tente d'evaluer new_valeur comme un objet du jdc (par appel a eval_val_item) + Tente d'evaluer new_valeur comme un objet du jdc (par appel a evalValItem) ou comme une liste de ces memes objets Si new_valeur contient au moins un separateur (,), tente l'evaluation sur la chaine splittee """ - if type(new_valeur) in (types.ListType,types.TupleType): + if new_valeur in ('True','False') and 'TXM' in self.definition.type : + valeur=self.evalValItem(str(new_valeur)) + return new_valeur + if type(new_valeur) in (list,tuple): valeurretour=[] for item in new_valeur : - valeurretour.append(self.eval_val_item(item)) + valeurretour.append(self.evalValItem(item)) return valeurretour else: - valeur=self.eval_val_item(new_valeur) + valeur=self.evalValItem(new_valeur) return valeur - def eval_val_item(self,new_valeur): + def evalValItem(self,new_valeur): """ Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python Si c'est impossible retourne new_valeur inchange argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine) """ if self.etape and self.etape.parent: - valeur=self.etape.parent.eval_in_context(new_valeur,self.etape) + valeur=self.etape.parent.evalInContext(new_valeur,self.etape) return valeur else: try : @@ -352,193 +401,194 @@ class MCSIMP(I_OBJECT.OBJECT): return new_valeur pass - def cherche_item_parametre (self,new_valeur): + def chercheItemParametre (self,new_valeur): try: nomparam=new_valeur[0:new_valeur.find("[")] - indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")] + indice=new_valeur[new_valeur.find(u"[")+1:new_valeur.find(u"]")] for p in self.jdc.params: if p.nom == nomparam : - if int(indice) < len(p.get_valeurs()): + if int(indice) < len(p.getValeurs()): itparam=parametre.ITEM_PARAMETRE(p,int(indice)) return itparam return None except: return None - def update_concept(self,sd): - if type(self.valeur) in (types.ListType,types.TupleType) : + def updateConcept(self,sd): + if type(self.valeur) in (list,tuple) : if sd in self.valeur: - self.init_modif() - self.fin_modif() + self.initModif() + self.finModif() else: if sd == self.valeur: - self.init_modif() - self.fin_modif() + self.initModif() + self.finModif() - def delete_concept(self,sd): + def deleteConcept(self,sd): """ Inputs : - sd=concept detruit Fonction : - Met a jour la valeur du mot cle simple suite à la disparition + Met a jour la valeur du mot cle simple suite a la disparition du concept sd Attention aux matrices """ - if type(self.valeur) == types.TupleType : + if type(self.valeur) == tuple : if sd in self.valeur: - self.init_modif() + self.initModif() self.valeur=list(self.valeur) self.valeur.remove(sd) - self.fin_modif() - elif type(self.valeur) == types.ListType: + self.finModif() + elif type(self.valeur) == list: if sd in self.valeur: - self.init_modif() + self.initModif() self.valeur.remove(sd) - self.fin_modif() + self.finModif() else: if self.valeur == sd: - self.init_modif() + self.initModif() self.valeur=None self.val=None - self.fin_modif() + self.finModif() # Glut Horrible pour les matrices ??? if sd.__class__.__name__== "variable": for type_permis in self.definition.type: - if type(type_permis) == types.InstanceType: + #if type(type_permis) == types.InstanceType: + # a voir en python 3 if type_permis.__class__.__name__ == 'Matrice' : self.state="changed" - self.isvalid() + self.isValid() - def replace_concept(self,old_sd,sd): + def replaceConcept(self,old_sd,sd): """ Inputs : - - old_sd=concept remplacé + - old_sd=concept remplace - sd=nouveau concept Fonction : Met a jour la valeur du mot cle simple suite au remplacement du concept old_sd """ - #print "replace_concept",old_sd,sd - if type(self.valeur) == types.TupleType : + #print "replaceConcept",old_sd,sd + if type(self.valeur) == tuple : if old_sd in self.valeur: - self.init_modif() + self.initModif() self.valeur=list(self.valeur) i=self.valeur.index(old_sd) self.valeur[i]=sd - self.fin_modif() - elif type(self.valeur) == types.ListType: + self.finModif() + elif type(self.valeur) == list: if old_sd in self.valeur: - self.init_modif() + self.initModif() i=self.valeur.index(old_sd) self.valeur[i]=sd - self.fin_modif() + self.finModif() else: if self.valeur == old_sd: - self.init_modif() + self.initModif() self.valeur=sd self.val=sd - self.fin_modif() + self.finModif() - def set_valeur_co(self,nom_co): + def setValeurCo(self,nom_co): """ - Affecte à self l'objet de type CO et de nom nom_co + Affecte a self l'objet de type CO et de nom nom_co """ - #print "set_valeur_co",nom_co + #print "setValeurCo",nom_co step=self.etape.parent if nom_co == None or nom_co == '': new_objet=None else: - # Avant de créer un concept il faut s'assurer du contexte : step + # Avant de creer un concept il faut s'assurer du contexte : step # courant - sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui') + sd= step.getSdAutourEtape(nom_co,self.etape,avec='oui') if sd: - # Si un concept du meme nom existe deja dans la portée de l'étape - # on ne crée pas le concept - return 0,"un concept de meme nom existe deja" - # Il n'existe pas de concept de meme nom. On peut donc le créer - # Il faut néanmoins que la méthode NommerSdProd de step gère les + # Si un concept du meme nom existe deja dans la portee de l'etape + # on ne cree pas le concept + return 0,tr("un concept de meme nom existe deja") + # Il n'existe pas de concept de meme nom. On peut donc le creer + # Il faut neanmoins que la methode NommerSdProd de step gere les # contextes en mode editeur - # Normalement la méthode du Noyau doit etre surchargée - # On déclare l'étape du mot clé comme etape courante pour NommerSdprod - cs= CONTEXT.get_current_step() - CONTEXT.unset_current_step() - CONTEXT.set_current_step(step) - step.set_etape_context(self.etape) + # Normalement la methode du Noyau doit etre surchargee + # On declare l'etape du mot cle comme etape courante pour NommerSdprod + cs= CONTEXT.getCurrentStep() + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(step) + step.setEtapeContext(self.etape) new_objet = Accas.CO(nom_co) - CONTEXT.unset_current_step() - CONTEXT.set_current_step(cs) - self.init_modif() + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(cs) + self.initModif() self.valeur = new_objet self.val = new_objet # On force l'enregistrement de new_objet en tant que concept produit - # de la macro en appelant get_type_produit avec force=1 - self.etape.get_type_produit(force=1) - self.fin_modif() - step.reset_context() - #print "set_valeur_co",new_objet - return 1,"Concept créé" + # de la macro en appelant getType_produit avec force=1 + self.etape.getType_produit(force=1) + self.finModif() + step.resetContext() + #print "setValeurCo",new_objet + return 1,tr("Concept cree") - def verif_existence_sd(self): + def verifExistenceSd(self): """ - Vérifie que les structures de données utilisées dans self existent bien dans le contexte - avant étape, sinon enlève la référence à ces concepts + Verifie que les structures de donnees utilisees dans self existent bien dans le contexte + avant etape, sinon enleve la referea ces concepts """ - #print "verif_existence_sd" + #print "verifExistenceSd" # Attention : possible probleme avec include # A priori il n'y a pas de raison de retirer les concepts non existants # avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro - l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values() - if type(self.valeur) in (types.TupleType,types.ListType) : + l_sd_avant_etape = list(self.jdc.getContexteAvant(self.etape).values()) + if type(self.valeur) in (tuple,list) : l=[] for sd in self.valeur: if isinstance(sd,ASSD) : - if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd: + if sd in l_sd_avant_etape or self.etape.getSdprods(sd.nom) is sd: l.append(sd) else: l.append(sd) if len(l) < len(self.valeur): - self.init_modif() + self.initModif() self.valeur=tuple(l) - self.fin_modif() + self.finModif() else: if isinstance(self.valeur,ASSD) : - if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None: - self.init_modif() + if self.valeur not in l_sd_avant_etape and self.etape.getSdprods(self.valeur.nom) is None: + self.initModif() self.valeur = None - self.fin_modif() + self.finModif() - def get_min_max(self): + def getMinMax(self): """ Retourne les valeurs min et max admissibles pour la valeur de self """ return self.definition.min,self.definition.max - def get_type(self): + def getType(self): """ - Retourne le type attendu par le mot-clé simple + Retourne le type attendu par le mot-cle simple """ return self.definition.type - def delete_mc_global(self): + def deleteMcGlobal(self): """ Retire self des declarations globales """ if self.definition.position == 'global' : - etape = self.get_etape() + etape = self.getEtape() if etape : del etape.mc_globaux[self.nom] elif self.definition.position == 'global_jdc' : del self.jdc.mc_globaux[self.nom] - def update_mc_global(self): + def updateMcGlobal(self): """ - Met a jour les mots cles globaux enregistrés dans l'étape parente + Met a jour les mots cles globaux enregistres dans l'etape parente et dans le jdc parent. Un mot cle simple peut etre global. """ if self.definition.position == 'global' : - etape = self.get_etape() + etape = self.getEtape() if etape : etape.mc_globaux[self.nom]=self elif self.definition.position == 'global_jdc' : @@ -546,49 +596,53 @@ class MCSIMP(I_OBJECT.OBJECT): self.jdc.mc_globaux[self.nom]=self def nbrColonnes(self): - genea = self.get_genealogie() + genea = self.getGenealogie() if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3 if "VALE" in genea and "DEFI_FONCTION" in genea : return 2 return 0 - def valide_item(self,item): - """Valide un item isolé. Cet item est candidat à l'ajout à la liste existante""" + def valideItem(self,item): + """Valide un item isole. Cet item est candidata l'ajout a la liste existante""" valid=1 try: #on verifie le type self.typeProto.adapt(item) #on verifie les choix possibles self.intoProto.adapt(item) - #on ne verifie pas la cardinalité + #on ne verifie pas la cardinalite if self.definition.validators: - valid=self.definition.validators.verif_item(item) - except ValError,e: + valid=self.definition.validators.verifItem(item) + except ValError as e: #traceback.print_exc() valid=0 return valid - def verif_type(self,item): + def verifType(self,item): """Verifie le type d'un item de liste""" try: #on verifie le type self.typeProto.adapt(item) #on verifie les choix possibles self.intoProto.adapt(item) - #on ne verifie pas la cardinalité mais on verifie les validateurs + #on ne verifie pas la cardinalite mais on verifie les validateurs if self.definition.validators: - valid=self.definition.validators.verif_item(item) + valid=self.definition.validators.verifItem(item) comment="" valid=1 - except ValError,e: + except ValError as e: #traceback.print_exc() - comment=str(e) + comment=tr(e.__str__()) valid=0 return valid,comment def valideMatrice(self,cr): #Attention, la matrice contient comme dernier tuple l ordre des variables + if self.valideEnteteMatrice()==False : + self.setValid(0) + if cr == "oui" : self.cr.fatal(tr("La matrice n'a pas le bon entete")) + return 0 if self.monType.methodeCalculTaille != None : - apply (MCSIMP.__dict__[self.monType.methodeCalculTaille],(self,)) + MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,)) try : #if 1 : ok=0 @@ -598,21 +652,39 @@ class MCSIMP(I_OBJECT.OBJECT): if len(self.valeur[i])!= self.monType.nbCols: ok=0 if ok: - self.set_valid(1) + self.setValid(1) return 1 except : #else : pass if cr == 'oui' : - self.cr.fatal("La matrice n est pas une matrice "+str(self.monType.nbLigs)+","+str(self.monType.nbCols)) - self.set_valid(0) + self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \ + {'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols})) + self.setValid(0) return 0 - def NbDeVariables(self): - listeVariables=self.jdc.get_variables(self.etape) + + def nbDeVariables(self): + listeVariables=self.jdc.getVariables(self.etape) self.monType.nbLigs=len(listeVariables) self.monType.nbCols=len(listeVariables) + def valideEnteteMatrice(self): + if self.jdc.getDistributions(self.etape) == () or self.valeur == None : return 0 + if self.jdc.getDistributions(self.etape) != self.valeur[0] : return 0 + return 1 + + def changeEnteteMatrice(self): + a=[self.jdc.getDistributions(self.etape),] + for t in self.valeur[1:]: + a.append(t) + self.valeur=a + + + def nNbDeDistributions(self): + listeVariables=self.jdc.getDistributions(self.etape) + self.monType.nbLigs=len(listeVariables) + self.monType.nbCols=len(listeVariables) #-------------------------------------------------------------------------------- @@ -620,21 +692,21 @@ class MCSIMP(I_OBJECT.OBJECT): # Elles doivent etre reintegrees des que possible - def verif_typeihm(self,val,cr='non'): + def verifTypeIhm(self,val,cr='non'): try : val.eval() return 1 except : traceback.print_exc() pass - return self.verif_type(val,cr) + return self.verifType(val,cr) - def verif_typeliste(self,val,cr='non') : + def verifTypeliste(self,val,cr='non') : verif=0 for v in val : - verif=verif+self.verif_typeihm(v,cr) + verif=verif+self.verifTypeIhm(v,cr) return verif - def init_modif_up(self): - Validation.V_MCSIMP.MCSIMP.init_modif_up(self) + def initModifUp(self): + Validation.V_MCSIMP.MCSIMP.initModifUp(self) CONNECTOR.Emit(self,"valid")