X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MCSIMP.py;h=dd02069d3cdf4cbcc0541b2e4ab42a11e918aeea;hb=217a9ce2f303b098ad28d282bb0df2dfeeeed3c2;hp=694bc83a4b9a25c5ca8bb27c7b130b639d116adc;hpb=f915c06cd9182a855ff99527a373ff976fbcd815;p=tools%2Feficas.git diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 694bc83a..dd02069d 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -1,41 +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-2013 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 +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 @@ -45,12 +50,22 @@ 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'): + 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) + def GetNomConcept(self): p=self while p.parent : @@ -68,40 +83,53 @@ class MCSIMP(I_OBJECT.OBJECT): 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.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) : + 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='(' sep='' for val in self.valeur: - if type(val) == types.FloatType : + if type(val) == float : 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] + 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) : texteVal = texteVal +"'"+str(i)+"'," + else : texteVal = texteVal + str(i)+',' + texteVal=texteVal[:-1]+')' + else : + if isinstance(val,bytes): 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 @@ -116,76 +144,86 @@ class MCSIMP(I_OBJECT.OBJECT): 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 : + if type(val) == float : 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 : + 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() except: return val else : + if val ==() or val == [] : return val s='( ' for item in val : try : s=s+item.get_name()+',' except: - s=s+`item`+',' + s=s+repr(item)+',' s=s+' )' return s + def wait_bool(self): + for typ in self.definition.type: + try : + if typ == bool: return True + except : + pass + return False + def wait_co(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): """ - 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): """ - 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 : + 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): """ - 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): """ - 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: @@ -197,9 +235,9 @@ class MCSIMP(I_OBJECT.OBJECT): """ 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] @@ -207,6 +245,14 @@ class MCSIMP(I_OBJECT.OBJECT): def isoblig(self): return self.definition.statut=='o' + def isImmuable(self): + return self.definition.homo=='constant' + + def isInformation(self): + return self.definition.homo=='information' + + + def valid_val(self,valeur): """ Verifie que la valeur passee en argument (valeur) est valide @@ -215,7 +261,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: @@ -225,7 +271,7 @@ 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 @@ -248,10 +294,10 @@ 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: + except ValError as e: validite=0 return validite @@ -272,13 +318,14 @@ class MCSIMP(I_OBJECT.OBJECT): self.valeur = new_valeur self.val = new_valeur self.update_condition_bloc() + self.etape.modified() self.fin_modif() return 1 def eval_valeur(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) @@ -313,7 +360,10 @@ class MCSIMP(I_OBJECT.OBJECT): 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.eval_val_item(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)) @@ -343,7 +393,7 @@ class MCSIMP(I_OBJECT.OBJECT): 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("]")] + 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()): @@ -354,27 +404,31 @@ class MCSIMP(I_OBJECT.OBJECT): return None def update_concept(self,sd): - if type(self.valeur) in (types.ListType,types.TupleType) : - if sd in self.valeur:self.fin_modif() + if type(self.valeur) in (list,tuple) : + if sd in self.valeur: + self.init_modif() + self.fin_modif() else: - if sd == self.valeur:self.fin_modif() + if sd == self.valeur: + self.init_modif() + self.fin_modif() def delete_concept(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 """ - #print "delete_concept",sd - if type(self.valeur) == types.TupleType : + if type(self.valeur) == tuple : if sd in self.valeur: self.init_modif() self.valeur=list(self.valeur) self.valeur.remove(sd) self.fin_modif() - elif type(self.valeur) == types.ListType: + elif type(self.valeur) == list: if sd in self.valeur: self.init_modif() self.valeur.remove(sd) @@ -385,25 +439,33 @@ class MCSIMP(I_OBJECT.OBJECT): self.valeur=None self.val=None self.fin_modif() + # 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_permis.__class__.__name__ == 'Matrice' : + self.state="changed" + self.isvalid() + def replace_concept(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 : + if type(self.valeur) == tuple : 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.fin_modif() - elif type(self.valeur) == types.ListType: + elif type(self.valeur) == list: if old_sd in self.valeur: self.init_modif() i=self.valeur.index(old_sd) @@ -418,25 +480,25 @@ class MCSIMP(I_OBJECT.OBJECT): def set_valeur_co(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 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') 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 + # Normalement la methode du Noyau doit etre surchargee + # On declare l'etape du mot cle comme etape courante pour NommerSdprod cs= CONTEXT.get_current_step() CONTEXT.unset_current_step() CONTEXT.set_current_step(step) @@ -453,19 +515,19 @@ class MCSIMP(I_OBJECT.OBJECT): self.fin_modif() step.reset_context() #print "set_valeur_co",new_objet - return 1,"Concept créé" + return 1,tr("Concept cree") 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 + 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" # 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.get_contexte_avant(self.etape).values()) + if type(self.valeur) in (tuple,list) : l=[] for sd in self.valeur: if isinstance(sd,ASSD) : @@ -493,7 +555,7 @@ class MCSIMP(I_OBJECT.OBJECT): def get_type(self): """ - Retourne le type attendu par le mot-clé simple + Retourne le type attendu par le mot-cle simple """ return self.definition.type @@ -509,7 +571,7 @@ class MCSIMP(I_OBJECT.OBJECT): def update_mc_global(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. """ @@ -528,17 +590,17 @@ class MCSIMP(I_OBJECT.OBJECT): return 0 def valide_item(self,item): - """Valide un item isolé. Cet item est candidat à l'ajout à la liste existante""" + """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: + except ValError as e: #traceback.print_exc() valid=0 return valid @@ -550,17 +612,68 @@ class MCSIMP(I_OBJECT.OBJECT): 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) 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.set_valid(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.set_valid(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.set_valid(0) + return 0 + + + def NbDeVariables(self): + listeVariables=self.jdc.get_variables(self.etape) + self.monType.nbLigs=len(listeVariables) + self.monType.nbCols=len(listeVariables) + + def valideEnteteMatrice(self): + if self.jdc.get_distributions(self.etape) == () or self.valeur == None : return 0 + if self.jdc.get_distributions(self.etape) != self.valeur[0] : return 0 + return 1 + + def changeEnteteMatrice(self): + a=[self.jdc.get_distributions(self.etape),] + for t in self.valeur[1:]: + a.append(t) + self.valeur=a + + + def NbDeDistributions(self): + listeVariables=self.jdc.get_distributions(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 @@ -582,3 +695,6 @@ class MCSIMP(I_OBJECT.OBJECT): verif=verif+self.verif_typeihm(v,cr) return verif + def init_modif_up(self): + Validation.V_MCSIMP.MCSIMP.init_modif_up(self) + CONNECTOR.Emit(self,"valid")