X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MCSIMP.py;h=507cead75a6b56c7edebc6af905de397aa995797;hb=2446a0c7137fa3418368ec577194a6d00e54ed65;hp=f85d97a5c88654a5116330af645755fae8aea9b0;hpb=0d46fd52a1ecb7221e33cbf9bf9d7d997b296ed0;p=tools%2Feficas.git diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index f85d97a5..507cead7 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -1,3 +1,4 @@ +# -*- coding: utf-8 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -39,48 +40,73 @@ from Noyau.N_utils import repr_float 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 +from Extensions import param2 import I_OBJECT +import CONNECTOR +from I_VALIDATOR import ValError,listProto class MCSIMP(I_OBJECT.OBJECT): + + def GetNomConcept(self): + p=self + while p.parent : + try : + nomconcept=p.get_sdname() + return nomconcept + except: + try : + nomconcept= p.object.get_sdname() + 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 """ + if self.valeur == None : return None elif type(self.valeur) == types.FloatType : - #txt = repr_float(self.valeur) - # Normalement str fait un travail correct + # Traitement d'un flottant isolé txt = str(self.valeur) + clefobj=self.GetNomConcept() + if self.jdc.appli.dict_reels.has_key(clefobj): + if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur): + txt=self.jdc.appli.dict_reels[clefobj][self.valeur] elif type(self.valeur) in (types.ListType,types.TupleType) : + # Traitement des listes txt='(' - i=0 + sep='' for val in self.valeur: if type(val) == types.FloatType : - # Normalement str fait un travail correct - #txt=txt + i*',' + repr_float(val) - txt=txt + i*',' + str(val) - elif type(val) == types.InstanceType and isinstance(val,ASSD): - txt = txt + i*',' + val.get_name() - #PN - # ajout du elif - elif val.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'): - txt = txt + i*','+ str(val) + clefobj=self.GetNomConcept() + if self.jdc.appli.dict_reels.has_key(clefobj): + if self.jdc.appli.dict_reels[clefobj].has_key(val): + txt=txt + sep +self.jdc.appli.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 + txt = txt + sep+ str(val) + if len(txt) > 200: + #ligne trop longue, on tronque + txt=txt+" ..." + break + sep=',' 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) + # Traitement des autres cas + txt = str(self.valeur) + # 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 @@ -88,21 +114,16 @@ class MCSIMP(I_OBJECT.OBJECT): # Pour le moment on retourne la chaine telle que return txt - # Partie de code inaccessible (pour memoire) - # txt est tronquee au dela d'un certain nombre de caractères - # et avant tout retour chariot (txt peut etre une chaine 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] - def getval(self): """ Retourne une chaîne de caractère représentant la valeur de self """ val=self.valeur + if type(val) == types.FloatType : + clefobj=self.GetNomConcept() + if self.jdc.appli.dict_reels.has_key(clefobj): + if self.jdc.appli.dict_reels[clefobj].has_key(val): + return self.jdc.appli.dict_reels[clefobj][val] if type(val) != types.TupleType : try: return val.get_name() @@ -124,7 +145,7 @@ class MCSIMP(I_OBJECT.OBJECT): qui n'existe pas encore (type CO()), 0 sinon """ for typ in self.definition.type: - if type(typ) == types.ClassType : + if type(typ) == types.ClassType or isinstance(typ,type): if issubclass(typ,CO) : return 1 return 0 @@ -135,7 +156,7 @@ class MCSIMP(I_OBJECT.OBJECT): ou dérivé, 0 sinon """ for typ in self.definition.type: - if type(typ) == types.ClassType : + if type(typ) == types.ClassType or isinstance(typ,type): if issubclass(typ,ASSD) and not issubclass(typ,GEOM): return 1 return 0 @@ -147,7 +168,7 @@ class MCSIMP(I_OBJECT.OBJECT): Retourne 0 dans le cas contraire """ for typ in self.definition.type: - if type(typ) == types.ClassType : + if type(typ) == types.ClassType or isinstance(typ,type): if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) : return 1 return 0 @@ -158,7 +179,7 @@ class MCSIMP(I_OBJECT.OBJECT): Retourne 0 dans le cas contraire """ for typ in self.definition.type: - if type(typ) == types.ClassType : + if type(typ) == types.ClassType or isinstance(typ,type): if issubclass(typ,GEOM) : return 1 return 0 @@ -186,54 +207,71 @@ class MCSIMP(I_OBJECT.OBJECT): 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() -# self.fin_modif() -# return 1 -# 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.init_modif() -# self.val=self.valeur -# self.fin_modif() -# return 1 -# elif type(new_valeur)==types.StringType and self.wait_TXM(): -# self.init_modif() -# self.val = new_valeur -# self.valeur = new_valeur -# self.fin_modif() -# return 1 -# else: -# return 0 -# else : - # on ne fait aucune vérification ... + def valid_val(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="None n'est pas une valeur autorisée" + else: + 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,e: + mess=str(e) + valid=0 + return valid,mess + + def valid_valeur(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) + """ + validite,mess=self.valid_val(new_valeur) + return validite + + def valid_valeur_partielle(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: + for val in new_valeur: + self.typeProto.adapt(val) + self.intoProto.adapt(val) + #on ne verifie pas la cardinalité + if self.definition.validators: + validite=self.definition.validators.valide_liste_partielle(new_valeur) + except ValError,e: + validite=0 + + return validite + + def update_condition_bloc(self): + """ Met a jour les blocs conditionnels dependant du mot cle simple self + """ + if self.definition.position == 'global' : + self.etape.deep_update_condition_bloc() + elif self.definition.position == 'global_jdc' : + self.jdc.deep_update_condition_bloc() + else: + self.parent.update_condition_bloc() + def set_valeur(self,new_valeur,evaluation='oui'): + #print "set_valeur",new_valeur self.init_modif() self.valeur = new_valeur self.val = new_valeur + self.update_condition_bloc() self.fin_modif() return 1 @@ -242,21 +280,85 @@ class MCSIMP(I_OBJECT.OBJECT): 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) """ - sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None) - if sd : + sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape) + #sd = self.jdc.get_contexte_avant(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) + 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.cherche_item_parametre(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 eval_val(self,new_valeur): + """ + Tente d'evaluer new_valeur comme un objet du jdc (par appel a eval_val_item) + 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): + valeurretour=[] + for item in new_valeur : + valeurretour.append(self.eval_val_item(item)) + return valeurretour + else: + valeur=self.eval_val_item(new_valeur) + return valeur + + def eval_val_item(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) + return valeur + else: + try : + valeur = eval(val) + return valeur + except: + #traceback.print_exc() + return new_valeur + pass + + def cherche_item_parametre (self,new_valeur): + try: + nomparam=new_valeur[0:new_valeur.find("[")] + indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")] + for p in self.jdc.params: + if p.nom == nomparam : + if int(indice) < len(p.get_valeurs()): + 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) : + if sd in self.valeur:self.fin_modif() + else: + if sd == self.valeur:self.fin_modif() + def delete_concept(self,sd): """ Inputs : @@ -265,20 +367,24 @@ class MCSIMP(I_OBJECT.OBJECT): Met a jour la valeur du mot cle simple suite à la disparition du concept sd """ + #print "delete_concept",sd if type(self.valeur) == types.TupleType : if sd in self.valeur: + self.init_modif() self.valeur=list(self.valeur) self.valeur.remove(sd) - self.init_modif() + self.fin_modif() elif type(self.valeur) == types.ListType: if sd in self.valeur: - self.valeur.remove(sd) self.init_modif() + self.valeur.remove(sd) + self.fin_modif() else: if self.valeur == sd: + self.init_modif() self.valeur=None self.val=None - self.init_modif() + self.fin_modif() def replace_concept(self,old_sd,sd): """ @@ -289,61 +395,36 @@ class MCSIMP(I_OBJECT.OBJECT): 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 : if old_sd in self.valeur: + self.init_modif() self.valeur=list(self.valeur) i=self.valeur.index(old_sd) self.valeur[i]=sd - self.init_modif() + self.fin_modif() elif type(self.valeur) == types.ListType: if old_sd in self.valeur: + self.init_modif() i=self.valeur.index(old_sd) self.valeur[i]=sd - self.init_modif() + self.fin_modif() else: if self.valeur == old_sd: + self.init_modif() self.valeur=sd self.val=sd - 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 - - 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 - """ - 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 - + self.fin_modif() def set_valeur_co(self,nom_co): """ Affecte à self l'objet de type CO et de nom nom_co """ + #print "set_valeur_co",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 # courant sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui') @@ -360,51 +441,47 @@ class MCSIMP(I_OBJECT.OBJECT): CONTEXT.unset_current_step() CONTEXT.set_current_step(step) step.set_etape_context(self.etape) - new_objet = CO(nom_co) + new_objet = Accas.CO(nom_co) CONTEXT.unset_current_step() CONTEXT.set_current_step(cs) self.init_modif() self.valeur = new_objet self.val = new_objet - self.fin_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) + self.fin_modif() + step.reset_context() + #print "set_valeur_co",new_objet return 1,"Concept créé" - - def reparent(self,parent): - """ - Cette methode sert a reinitialiser la parente de l'objet - """ - 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 + avant étape, sinon enlève la référence à ces concepts """ + #print "verif_existence_sd" + # 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=[] 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 - # Est ce init_modif ou init_modif_up - # Normalement init_modif va avec fin_modif - self.init_modif() - self.fin_modif() + if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd: + l.append(sd) + else: + l.append(sd) + if len(l) < len(self.valeur): + self.init_modif() + self.valeur=tuple(l) + self.fin_modif() else: if isinstance(self.valeur,ASSD) : - if self.valeur not in l_sd_avant_etape : - self.valeur = None + if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None: self.init_modif() + self.valeur = None self.fin_modif() def get_min_max(self): @@ -419,147 +496,89 @@ class MCSIMP(I_OBJECT.OBJECT): Retourne le type attendu par le mot-clé simple """ return self.definition.type - -#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation -# Elles doivent etre reintegrees des que possible - def is_complexe(self,valeur): - """ Retourne 1 si valeur est un complexe, 0 sinon """ - if type(valeur) == types.InstanceType : - #XXX je n'y touche pas pour ne pas tout casser mais il serait - #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('C'), par exemple - if valeur.__class__.__name__ in ('EVAL','complexe','PARAMETRE_EVAL'): - return 1 - elif valeur.__class__.__name__ in ('PARAMETRE',): - # il faut tester si la valeur du parametre est un entier - #XXX ne serait ce pas plutot complexe ???? sinon expliquer - return self.is_entier(valeur.valeur) - else: - print "Objet non reconnu dans is_complexe %s" %`valeur` - return 0 - # Pour permettre l'utilisation de complexes Python - #elif type(valeur) == types.ComplexType: - #return 1 - elif type(valeur) != types.TupleType : - return 0 - else: - if len(valeur) != 3 : - return 0 - else: - if type(valeur[0]) != types.StringType : return 0 - if string.strip(valeur[0]) not in ('RI','MP'): - return 0 - else: - if not self.is_reel(valeur[1]) or not self.is_reel(valeur[2]) : return 0 - else: return 1 - - def is_reel(self,valeur): + def delete_mc_global(self): + """ Retire self des declarations globales """ - Retourne 1 si valeur est un reel, 0 sinon - """ - if type(valeur) == types.InstanceType : - #XXX je n'y touche pas pour ne pas tout casser mais il serait - #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('R'), par exemple - #XXX ou valeur.is_reel() - #XXX ou encore valeur.compare(self.is_reel) - if valeur.__class__.__name__ in ('EVAL','reel','PARAMETRE_EVAL') : - return 1 - elif valeur.__class__.__name__ in ('PARAMETRE',): - # il faut tester si la valeur du parametre est un réel - return self.is_reel(valeur.valeur) - else: - print "Objet non reconnu dans is_reel %s" %`valeur` - return 0 - elif type(valeur) not in (types.IntType,types.FloatType,types.LongType): - # ce n'est pas un réel - return 0 - else: - return 1 - - def is_entier(self,valeur): - """ Retourne 1 si valeur est un entier, 0 sinon """ - if type(valeur) == types.InstanceType : - #XXX je n'y touche pas pour ne pas tout casser mais il serait - #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('I'), par exemple - if valeur.__class__.__name__ in ('EVAL','entier','PARAMETRE_EVAL') : - return 1 - elif valeur.__class__.__name__ in ('PARAMETRE',): - # il faut tester si la valeur du parametre est un entier - return self.is_entier(valeur.valeur) - else: - print "Objet non reconnu dans is_reel %s" %`valeur` - return 0 - elif type(valeur) not in (types.IntType,types.LongType): - # ce n'est pas un entier - return 0 - else: - return 1 - - def is_object_from(self,objet,classe): - """ - Retourne 1 si valeur est un objet de la classe classe ou d'une - sous-classe de classe, 0 sinon - """ - if type(objet) != types.InstanceType : - return 0 - if not objet.__class__ == classe and not issubclass(objet.__class__,classe): - return 0 - else: - return 1 - - def get_valid(self): - if hasattr(self,'valid'): - return self.valid - else: - self.valid=None - return None - - def set_valid(self,valid): - old_valid=self.get_valid() - self.valid = valid - self.state = 'unchanged' - if not old_valid or old_valid != self.valid : - self.init_modif_up() + if self.definition.position == 'global' : + etape = self.get_etape() + 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): + """ + Met a jour les mots cles globaux enregistrés dans l'étape parente + et dans le jdc parent. + Un mot cle simple peut etre global. + """ + if self.definition.position == 'global' : + etape = self.get_etape() + 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.get_genealogie() + 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""" + 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é + if self.definition.validators: + valid=self.definition.validators.verif_item(item) + except ValError,e: + #traceback.print_exc() + valid=0 + return valid - def isvalid(self,cr='non'): - """ - Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP + def verif_type(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 + if self.definition.validators: + valid=self.definition.validators.verif_item(item) + comment="" + valid=1 + except ValError,e: + #traceback.print_exc() + comment=str(e) + valid=0 + return valid,comment - - 0 si l'objet est invalide - - 1 si l'objet est valide +#-------------------------------------------------------------------------------- + +#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation +# Elles doivent etre reintegrees des que possible - Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui' - la méthode construit également un comte-rendu de validation - dans self.cr qui doit avoir été créé préalablement. - """ - if self.state == 'unchanged': - return self.valid - else: - v=self.valeur - valid = 1 - # verifiaction presence - if self.isoblig() and v == None : - if cr == 'oui' : - self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé"))) - valid = 0 - - if v is None: - valid=0 - if cr == 'oui' : - self.cr.fatal("None n'est pas une valeur autorisée") - else: - # type,into ... - valid = self.verif_type(val=v,cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr) - # - # On verifie les validateurs s'il y en a et si necessaire (valid == 1) - # - if valid and self.definition.validators and not self.definition.validators.verif(self.valeur): - if cr == 'oui' : - self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info()))) - valid=0 - # fin des validateurs - # - self.set_valid(valid) - return self.valid + def verif_typeihm(self,val,cr='non'): + try : + val.eval() + return 1 + except : + traceback.print_exc() + pass + return self.verif_type(val,cr) + + def verif_typeliste(self,val,cr='non') : + verif=0 + for v in val : + verif=verif+self.verif_typeihm(v,cr) + return verif