X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MCSIMP.py;h=0bd9a544771ce49c5aafad018c4faba90bff3efb;hb=94531d13450fad5a118e4d39d9693f46eb7e59a0;hp=b17097031b1887e1bdcfc915b345ae0891a83dde;hpb=019bec631bb27f0837556b11497b92c57115feff;p=tools%2Feficas.git diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index b1709703..0bd9a544 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -1,376 +1,712 @@ -import types,string +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2017 EDF R&D +# +# 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. +# +# 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 +# +# 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 +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 from Noyau.N_CO import CO +import Accas # fin attention from Extensions import parametre -import I_OBJECT +from Extensions import param2 +from . import I_OBJECT +from . import CONNECTOR +from .I_VALIDATOR import ValError,listProto class MCSIMP(I_OBJECT.OBJECT): - def GetText(self): + + + 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) + 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): + p=self + while p.parent : + try : + nomconcept=p.getSdname() + return nomconcept + except: + try : + nomconcept= p.object.getSdname() + return nomconcept + except : + pass + p=p.parent + return "" + + 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 : - txt = repr_float(self.valeur) - elif type(self.valeur) in (types.ListType,types.TupleType) : + elif type(self.valeur) == float : + # traitement d'un flottant isole + txt = str(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 (list,tuple) : + if self.valeur==[] or self.valeur == (): return str(self.valeur) + # traitement des listes txt='(' - i=0 + sep='' for val in self.valeur: - if type(val) == types.FloatType : - txt=txt + i*',' + repr_float(val) - elif type(val) == types.InstanceType and isinstance(val,ASSD): - txt = txt + i*',' + val.get_name() + 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 + i*','+ myrepr.repr(val) - i=1 + 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: - txt = self.getval() - if type(txt) != types.StringType: - if type(txt) == types.InstanceType: - if isinstance(txt,parametre.PARAMETRE): - return str(txt) - return repr(txt) - # il faut tronquer txt au delà d'un certain nombre de caractères - # et avant tout retour chariot (txt peut être une chaîne de caractères - # sur plusieurs lignes (ex:shell) - txt = string.split(txt,'\n')[0] - if len(txt) < 30 : - return txt - else: - return txt[0:29] + # traitement des autres cas + txt = str(self.valeur) - def getval(self): + # txt peut etre une longue chaine sur plusieurs lignes. + # Il est possible de tronquer cette chaine au premier \n et + # de limiter la longueur de la chaine a 30 caracteres. Cependant + # ceci provoque une perte d'information pour l'utilisateur + # Pour le moment on retourne la chaine telle que + return txt + + 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.TupleType : + 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) != 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 get_min_max(self): - return self.definition.min,self.definition.max + def waitBool(self): + for typ in self.definition.type: + try : + if typ == bool: return True + except : + pass + return False - def wait_co(self): + 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 : + 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 : + 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 - assd, ASSD, geom ou GEOM + 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 : + 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 : + 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 set_valeur(self,new_valeur,evaluation='oui'): - """ - Remplace la valeur de self(si elle existe) par new_valeur - - si evaluation = 'oui' : - essaie d'évaluer new_valeur dans le contexte - - si evaluation = 'non' : - n'essaie pas d'évaluer (on stocke une string ou - une valeur de la liste into ) - """ - if evaluation == 'oui' and not self.wait_assd_or_geom(): - valeur,test = self.eval_valeur(new_valeur) - if test : - self.val = new_valeur - self.valeur = valeur - self.init_modif() - return 1 + 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 + """ + lval=listProto.adapt(valeur) + if lval is None: + valid=0 + mess=tr("None n'est pas une valeur autorisee") else: - # On n'a pas trouve de concept ni réussi à évaluer la valeur - # dans le contexte - # Si le mot cle simple attend un type CO on crée un objet de ce - # type de nom new_valeur - if self.wait_co(): - try: - # Pour avoir la classe CO avec tous ses comportements - from Accas import CO - self.valeur=CO(new_valeur) - except: - traceback.print_exc() - return 0 - self.val=self.valeur - self.init_modif() - return 1 - elif type(new_valeur)==types.StringType and self.wait_TXM(): - self.val = new_valeur - self.valeur = new_valeur - self.init_modif() - return 1 - else: - return 0 - else : - # on ne fait aucune vérification ... + try: + for val in lval: + self.typeProto.adapt(val) + self.intoProto.adapt(val) + self.cardProto.adapt(lval) + if self.definition.validators: + self.definition.validators.convert(lval) + valid,mess=1,"" + except ValError as e: + mess=str(e) + valid=0 + return valid,mess + + def validValeur(self,new_valeur): + """ + Verifie que la valeur passee en argument (new_valeur) est valide + sans modifier la valeur courante (evite d'utiliser setValeur et est plus performant) + """ + validite,mess=self.validVal(new_valeur) + return validite + + 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 + """ + validite=1 try: - self.valeur = eval(new_valeur) - self.val = eval(new_valeur) - self.init_modif() - return 1 - except: + for val in new_valeur: + self.typeProto.adapt(val) + self.intoProto.adapt(val) + #on ne verifie pas la cardinalite + if self.definition.validators: + validite=self.definition.validators.valideListePartielle(new_valeur) + except ValError as e: + validite=0 + + return validite + + def updateConditionBloc(self): + """ Met a jour les blocs conditionnels dependant du mot cle simple self + """ + if self.definition.position == 'global' : + self.etape.deepUpdateConditionBloc() + elif self.definition.position == 'global_jdc' : + self.jdc.deepUpdateConditionBloc() + else: + self.parent.updateConditionBloc() + + def setValeur(self,new_valeur,evaluation='oui'): + print ("setValeur Ihm/IMCSIMP ",new_valeur) + self.initModif() self.valeur = new_valeur self.val = new_valeur - self.init_modif() + #self.setValeurObjPyxb(new_valeur) + self.updateConditionBloc() + self.etape.modified() + 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) - if sd : + 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.chercheListAvant(self.etape,new_valeur) + if lsd : + return lsd,1 else: d={} # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ?? - from Accas import EVAL - d['EVAL']=EVAL + d['EVAL']=Accas.EVAL try : objet = eval(new_valeur,d) return objet,1 except Exception: + itparam=self.chercheItemParametre(new_valeur) + if itparam: + return itparam,1 + try : + object=eval(new_valeur.valeur,d) + except : + pass if CONTEXT.debug : traceback.print_exc() return None,0 - def delete_concept(self,sd): + def evalVal(self,new_valeur): + """ + 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 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.evalValItem(item)) + return valeurretour + else: + valeur=self.evalValItem(new_valeur) + return 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.evalInContext(new_valeur,self.etape) + return valeur + else: + try : + valeur = eval(val) + return valeur + except: + #traceback.print_exc() + return new_valeur + pass + + def chercheItemParametre (self,new_valeur): + try: + nomparam=new_valeur[0: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.getValeurs()): + itparam=parametre.ITEM_PARAMETRE(p,int(indice)) + return itparam + return None + except: + return None + + def updateConcept(self,sd): + if type(self.valeur) in (list,tuple) : + if sd in self.valeur: + self.initModif() + self.finModif() + else: + if sd == self.valeur: + self.initModif() + self.finModif() + + def deleteConcept(self,sd): """ Inputs : - sd=concept detruit + - sd=concept detruit Fonction : - Met a jour la valeur du mot cle simple suite à la disparition - du concept sd + 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.initModif() self.valeur=list(self.valeur) self.valeur.remove(sd) - self.init_modif() - elif type(self.valeur) == types.ListType: + self.finModif() + elif type(self.valeur) == list: if sd in self.valeur: + self.initModif() self.valeur.remove(sd) - self.init_modif() + self.finModif() else: if self.valeur == sd: + self.initModif() self.valeur=None self.val=None - self.init_modif() - - def copy(self): - """ Retourne une copie de self """ - objet = self.makeobjet() - # il faut copier les listes et les tuples mais pas les autres valeurs - # possibles (réel,SD,...) - if type(self.valeur) in (types.ListType,types.TupleType): - objet.valeur = copy(self.valeur) - else: - objet.valeur = self.valeur - objet.val = objet.valeur - return objet + 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: + # a voir en python 3 + if type_permis.__class__.__name__ == 'Matrice' : + self.state="changed" + self.isValid() + - def makeobjet(self): - return self.definition(val = None, nom = self.nom,parent = self.parent) - - def get_sd_utilisees(self): - """ - Retourne une liste qui contient la SD utilisée par self si c'est le cas - ou alors une liste vide + def replaceConcept(self,old_sd,sd): """ - l=[] - if type(self.valeur) == types.InstanceType: - #XXX Est ce différent de isinstance(self.valeur,ASSD) ?? - if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur) - return l - + Inputs : + - 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 "replaceConcept",old_sd,sd + if type(self.valeur) == tuple : + if old_sd in self.valeur: + self.initModif() + self.valeur=list(self.valeur) + i=self.valeur.index(old_sd) + self.valeur[i]=sd + self.finModif() + elif type(self.valeur) == list: + if old_sd in self.valeur: + self.initModif() + i=self.valeur.index(old_sd) + self.valeur[i]=sd + self.finModif() + else: + if self.valeur == old_sd: + self.initModif() + self.valeur=sd + self.val=sd + 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 "setValeurCo",nom_co step=self.etape.parent if nom_co == None or nom_co == '': new_objet=None else: - # Pour le moment on importe en local le CO de Accas. - # Si problème de perfs, il faudra faire autrement - from Accas import CO - # 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) - new_objet = CO(nom_co) - CONTEXT.unset_current_step() - CONTEXT.set_current_step(cs) + # 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.unsetCurrentStep() + CONTEXT.setCurrentStep(cs) + self.initModif() self.valeur = new_objet self.val = new_objet - self.init_modif() - step.reset_context() # 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) - return 1,"Concept créé" - - def reparent(self,parent): + # 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 verifExistenceSd(self): """ - Cette methode sert a reinitialiser la parente de l'objet + Verifie que les structures de donnees utilisees dans self existent bien dans le contexte + avant etape, sinon enleve la referea ces concepts """ - self.parent=parent - self.jdc=parent.jdc - self.etape=parent.etape - - def verif_existence_sd(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 - """ - l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values() - if type(self.valeur) in (types.TupleType,types.ListType) : + #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 = 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 : - l.append(sd) - else: - l.append(sd) - self.valeur=l - self.init_modif() + 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.initModif() + self.valeur=tuple(l) + self.finModif() else: if isinstance(self.valeur,ASSD) : - if self.valeur not in l_sd_avant_etape : - self.valeur = 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.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 deleteMcGlobal(self): + """ Retire self des declarations globales + """ + if self.definition.position == 'global' : + 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 updateMcGlobal(self): + """ + 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.getEtape() + if etape : + etape.mc_globaux[self.nom]=self + elif self.definition.position == 'global_jdc' : + if self.jdc: + self.jdc.mc_globaux[self.nom]=self + + def nbrColonnes(self): + 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 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 cardinalite + if self.definition.validators: + valid=self.definition.validators.verifItem(item) + except ValError as e: + #traceback.print_exc() + valid=0 + return valid + + 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 cardinalite mais on verifie les validateurs + if self.definition.validators: + valid=self.definition.validators.verifItem(item) + comment="" + valid=1 + except ValError as e: + #traceback.print_exc() + 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 : + MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,)) + try : + #if 1 : + ok=0 + if len(self.valeur) == self.monType.nbLigs +1: + ok=1 + for i in range(len(self.valeur) -1): + if len(self.valeur[i])!= self.monType.nbCols: + ok=0 + if ok: + self.setValid(1) + return 1 + except : + #else : + pass + if cr == 'oui' : + 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.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) + +#-------------------------------------------------------------------------------- - - - - - - - - - - - - - +#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation +# Elles doivent etre reintegrees des que possible + + + def verifTypeIhm(self,val,cr='non'): + try : + val.eval() + return 1 + except : + traceback.print_exc() + pass + return self.verifType(val,cr) + + def verifTypeliste(self,val,cr='non') : + verif=0 + for v in val : + verif=verif+self.verifTypeIhm(v,cr) + return verif + + def initModifUp(self): + Validation.V_MCSIMP.MCSIMP.initModifUp(self) + CONNECTOR.Emit(self,"valid")