X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MCSIMP.py;h=c2d771fc7ee08671bf87b509b87cc50619e446d3;hb=c3b19c097b238b972a67f1b5cbced6a670adccdf;hp=1080104b5622788c97b7ee5268510256616d3cef;hpb=5cf288c86365cbfd1de55e16600559711ad1c538;p=tools%2Feficas.git diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 1080104b..c2d771fc 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,24 +40,48 @@ 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 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 : # Traitement d'un flottant isolé - #txt = repr_float(self.valeur) + # txt = repr_float(self.valeur) # Normalement str fait un travail correct 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='(' @@ -65,7 +90,14 @@ class MCSIMP(I_OBJECT.OBJECT): if type(val) == types.FloatType : # CCAR : Normalement str fait un travail correct #txt=txt + i*',' + repr_float(val) - 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 + i*',' +self.jdc.appli.dict_reels[clefobj][val] + else : + txt=txt + i*',' + str(val) + else : + txt=txt + i*',' + str(val) elif isinstance(val,ASSD): txt = txt + i*',' + val.get_name() #PN @@ -76,15 +108,15 @@ class MCSIMP(I_OBJECT.OBJECT): txt = txt + i*','+ myrepr.repr(val) i=1 txt=txt+')' + elif isinstance(self.valeur,ASSD): + # Cas des ASSD + txt=self.getval() + elif type(self.valeur) == types.InstanceType and self.valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'): + # Cas des PARAMETRES + txt=str(self.valeur) else: # Traitement des autres cas - txt = self.getval() - - if type(txt) == types.InstanceType: - if isinstance(txt,parametre.PARAMETRE): - txt= str(txt) - else: - txt=repr(txt) + txt = myrepr.repr(self.valeur) # txt peut etre une longue chaine sur plusieurs lignes. # Il est possible de tronquer cette chaine au premier \n et @@ -98,6 +130,11 @@ class MCSIMP(I_OBJECT.OBJECT): 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() @@ -181,54 +218,67 @@ 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_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) + """ + old_valeur=self.valeur + old_val=self.val + self.valeur = new_valeur + self.val = new_valeur + self.state="modified" + validite=self.isvalid() + self.valeur = old_valeur + self.val = old_valeur + self.state="modified" + self.isvalid() + return validite + + def valid_valeur_partielle(self,new_valeur): + """ + Verifie que la valeur passee en argument (new_valeur) est partiellement valide + sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant) + """ + old_valeur=self.valeur + old_val=self.val + + self.valeur = new_valeur + self.val = new_valeur + self.state="modified" + validite=0 + if self.isvalid(): + validite=1 + elif self.definition.validators : + validite=self.definition.validators.valide_liste_partielle(new_valeur) + + if validite==0: + min,max=self.get_min_max() + if len(new_valeur) < min : + validite=1 + + self.valeur = old_valeur + self.val = old_valeur + self.state="modified" + self.isvalid() + 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 @@ -237,21 +287,51 @@ 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) + 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 : 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 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 : @@ -260,20 +340,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): """ @@ -284,61 +368,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') @@ -355,7 +414,7 @@ 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() @@ -366,24 +425,20 @@ class MCSIMP(I_OBJECT.OBJECT): # 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) + #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 """ + #print "verif_existence_sd" + # Attention : possible probleme avec include l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values() if type(self.valeur) in (types.TupleType,types.ListType) : l=[] + self.init_modif() for sd in self.valeur: if isinstance(sd,ASSD) : if sd in l_sd_avant_etape : @@ -391,15 +446,12 @@ class MCSIMP(I_OBJECT.OBJECT): else: l.append(sd) self.valeur=tuple(l) - # Est ce init_modif ou init_modif_up - # Normalement init_modif va avec fin_modif - self.init_modif() self.fin_modif() else: if isinstance(self.valeur,ASSD) : if self.valeur not in l_sd_avant_etape : - self.valeur = None self.init_modif() + self.valeur = None self.fin_modif() def get_min_max(self): @@ -414,111 +466,43 @@ class MCSIMP(I_OBJECT.OBJECT): Retourne le type attendu par le mot-clé simple """ return self.definition.type + + def delete_mc_global(self): + """ Retire self des declarations globales + """ + 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 + print dir(self) + return 0 + +#-------------------------------------------------------------------------------- #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_complexe(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.ListType : - # On n'autorise pas les listes de complexes - return 0 - elif type(valeur) != types.TupleType : - # Un complexe doit etre un tuple - 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): - """ - 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() def isvalid(self,cr='non'): """ @@ -534,68 +518,78 @@ class MCSIMP(I_OBJECT.OBJECT): if self.state == 'unchanged': return self.valid else: - v=self.valeur valid = 1 - # verifiaction presence + v=self.valeur + # verification 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") + 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 - # + # type,into ... + #PN ??? je n ose pas y toucher ??? + #if v.__class__.__name__ in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'): + if ((issubclass(v.__class__,param2.Formula)) or + (v.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))): + verif_type=self.verif_typeihm(v) + else: + verif_type=self.verif_type(val=v,cr=None) + # cas des tuples avec un ITEM_PARAMETRE + if verif_type == 0: + if type(v) == types.TupleType : + new_val=[] + for i in v: + if ((issubclass(i.__class__,param2.Formula)) or + (i.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))): + if self.verif_typeihm(val=i,cr=cr) == 0: + verif_type = 0 + break + else: + new_val.append(i) + if new_val != [] : + verif_type=self.verif_type(val=new_val,cr=cr) + else : + # Cas d une liste de paramétre + verif_type=self.verif_typeliste(val=v,cr=cr) + else: + verif_type=self.verif_type(val=v,cr=cr) + valid = verif_type*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 + # + # cas d un item Parametre + if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE': + valid=self.valeur.isvalid() + if valid == 0: + if cr == 'oui' : + self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect")) self.set_valid(valid) return self.valid - def verif_into(self,cr='non'): - """ - Vérifie si la valeur de self est bien dans l'ensemble discret de valeurs - donné dans le catalogue derrière l'attribut into ou vérifie que valeur est bien compris - entre val_min et val_max - """ - if self.definition.into == None : - #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle) - if type(self.valeur)==types.TupleType : - test = 1 - for val in self.valeur : - if type(val)!=types.StringType and type(val)!=types.InstanceType: - test = test*self.isinintervalle(val,cr=cr) - return test - else : - val = self.valeur - if type(val)!=types.StringType and type(val)!=types.InstanceType: - return self.isinintervalle(self.valeur,cr=cr) - else : - return 1 - else : - # on est dans le cas d'un ensemble discret de valeurs possibles (into) - # PN : pour résoudre le pb du copier /coller de la liste Ordonnee - # if type(self.valeur) == types.TupleType : - if type(self.valeur) in (types.ListType,types.TupleType) : - for e in self.valeur: - if e not in self.definition.into: - if cr=='oui': - self.cr.fatal(string.join(("La valeur :",`e`," n'est pas permise pour le mot-clé :",self.nom))) - return 0 - else: - if self.valeur == None or self.valeur not in self.definition.into: - if cr=='oui': - self.cr.fatal(string.join(("La valeur :",`self.valeur`," n'est pas permise pour le mot-clé :",self.nom))) - return 0 - return 1 + def verif_typeihm(self,val,cr='non'): + try : + val.eval() + return 1 + except : + 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 +