1 # CONFIGURATION MANAGEMENT OF EDF VERSION
2 # ======================================================================
3 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
7 # (AT YOUR OPTION) ANY LATER VERSION.
9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
16 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
19 # ======================================================================
21 import string,types,os
24 from copy import copy,deepcopy
32 from widgets import ListeChoix
33 from widgets import FenetreDeSelection
35 from Noyau.N_CR import justify_text
36 from utils import substract_list
39 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
40 from newsimppanel import newSIMPPanel
48 def affect_panel(self):
50 Cette méthode attribue le panel à l'objet pointé par self en fonction de la
51 nature de la valeur demandée pour cet objet
53 from uniquepanel import UNIQUE_Panel
54 from plusieurspanel import PLUSIEURS_Panel
56 #print "affect_panel : ",self.nom,self.is_list(),self.has_into(), self.get_into(None)
59 # l'objet attend un shell
60 from shellpanel import SHELLPanel
61 self.panel = SHELLPanel
63 # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
65 from plusieursintopanel import PLUSIEURS_INTO_Panel
66 self.panel = PLUSIEURS_INTO_Panel
68 from uniqueintopanel import UNIQUE_INTO_Panel
69 self.panel = UNIQUE_INTO_Panel
71 # l'objet prend une ou des valeurs à priori quelconques
73 # on attend une liste de valeurs mais de quel type ?
75 # on attend une liste de SD
76 from plusieursassdpanel import PLUSIEURS_ASSD_Panel
77 self.panel = PLUSIEURS_ASSD_Panel
79 # on attend une liste de valeurs de types debase (entiers, réels,...)
80 from plusieursbasepanel import PLUSIEURS_BASE_Panel
81 self.panel = PLUSIEURS_BASE_Panel
83 # on n'attend qu'une seule valeur mais de quel type ?
85 # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
86 from uniquesdcopanel import UNIQUE_SDCO_Panel
87 self.panel = UNIQUE_SDCO_Panel
88 elif self.wait_assd():
90 from uniqueassdpanel import UNIQUE_ASSD_Panel
91 self.panel = UNIQUE_ASSD_Panel
93 # on attend une valeur d'un type de base (entier,réel,...)
94 if self.wait_complex():
95 # on attend un complexe
96 from uniquecomppanel import UNIQUE_COMP_Panel
97 self.panel = UNIQUE_COMP_Panel
99 # on attend un entier, un réel ou une string
100 from uniquebasepanel import UNIQUE_BASE_Panel
101 self.panel = UNIQUE_BASE_Panel
102 # cas particulier des fonctions
103 genea = self.get_genealogie()
104 if "VALE" in genea or "VALE_C" in genea:
105 if "DEFI_FONCTION" in genea :
106 from fonctionpanel import FONCTION_Panel
107 self.panel=FONCTION_Panel
108 #---------------------------------------------------------
109 # PN ajout pour lancement de Salome
110 #---------------------------------------------------------
111 if self.appli.salome != 0 :
114 self.clef_fonction="SALOME"
115 for i in range(0,len( genea )) :
116 self.clef_fonction=self.clef_fonction+"_"+ genea[i]
118 self.select_noeud_maille=0
119 if (self.clef_fonction.find("GROUP_NO") != -1) :
120 self.select_noeud_maille=1
121 if (self.clef_fonction.find("GROUP_MA") != -1) :
122 self.select_noeud_maille=1
124 recherche=panelsSalome.dict_classes_salome[self.panel]
125 if hasattr(recherche,self.clef_fonction):
127 if self.select_noeud_maille==1 :
131 #-----------------------------------------------
133 # Methodes liees aux informations sur le Panel
134 # ou au mot-clef simple
136 #-----------------------------------------------
138 # get_into a priori inutile --> commentee
140 # wait_into a priori inutile --> commentee
149 Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
150 ou s'il n'en attend pas (valeur de retour 0)
152 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
153 Dans le cas sans validateur, l'information est donnée par l'attribut max
154 de la definition du mot cle.
155 Dans le cas avec validateur, il faut combiner l'information précédente avec
156 celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
157 l'operateur ET pour effectuer cette combinaison (AndVal).
160 min,max = self.GetMinMax()
164 # Dans le cas avec validateurs, pour que le mot cle soit considéré
165 # comme acceptant une liste, il faut que max soit supérieur a 1
166 # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
167 # on retournera 0 (n'attend pas de liste)
168 if self.definition.validators :
169 is_a_list= self.definition.validators.is_list() * is_a_list
172 #def get_into(self,liste_courante=None):
174 # Cette méthode retourne la liste de choix proposée par le mot cle. Si le mot cle ne propose
175 # pas de liste de choix, la méthode retourne None.
176 # L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déjà
177 # effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
178 # en en tenant compte.
179 # Cette méthode part du principe que la relation entre into du mot clé et les validateurs est
180 # une relation de type ET (AndVal).
182 # if not self.object.definition.validators :
183 # return self.object.definition.into
185 # return self.object.definition.validators.get_into(liste_courante,self.definition.into)
189 Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
190 ou s'il n'en propose pas (valeur de retour 0)
192 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
193 Dans le cas sans validateur, l'information est donnée par l'attribut into
194 de la definition du mot cle.
195 Dans le cas avec validateurs, pour que le mot cle soit considéré
196 comme proposant un choix, il faut que into soit présent OU
197 que la méthode has_into du validateur retourne 1. Dans les autres cas
198 on retournera 0 (ne propose pas de choix)
201 if self.definition.into:
203 elif self.definition.validators :
204 has_an_into= self.definition.validators.has_into()
207 # def wait_into(self):
208 # """ Méthode booléenne qui retourne 1 si l'objet pointé par self
209 # prend ses valeurs dans un ensemble discret (into), 0 sinon """
210 # if self.object.definition.into != None :
216 """ Retourne les valeurs min et max de la définition de object """
217 return self.object.get_min_max()
219 def GetMultiplicite(self):
221 Retourne la multiplicité des valeurs affectées à l'objet
222 représenté par l'item. Pour le moment retourne invariablement 1.
226 def GetIntervalle(self):
228 Retourne le domaine de valeur attendu par l'objet représenté
231 return self.object.getintervalle()
233 def GetListeValeurs(self) :
234 """ Retourne la liste des valeurs de object """
235 return self.object.get_liste_valeurs()
237 def get_liste_possible(self,listeActuelle=[]):
238 if hasattr(self.definition.validators,'into'):
239 self.get_definition().into=self.definition.validators.into
240 valeurspossibles = self.get_definition().into
241 # CCAR : Ne serait-il pas preferable d'appeler get_into ?
242 #valeurspossibles=self.get_into(listeActuelle)
245 for item in valeurspossibles:
246 encorevalide=self.valide_item(item)
248 listevalideitem.append(item)
249 # on ne verifie pas la liste des choix si max = 1
250 # (sinon cela enleve tous les choix possibles)
251 min,max=self.GetMinMax()
254 for item in listevalideitem:
256 for item2 in listeActuelle : listetravail.append(item2)
257 encorevalide=self.valide_liste_partielle(item,listetravail)
259 listevalideliste.append(item)
261 listevalideliste=listevalideitem
262 return listevalideliste
265 #--------------------------------------------------
267 # Methodes liees a la validite des valeurs saisies
269 #---------------------------------------------------
271 # valide_liste_partielle
272 # valide_liste_complete
278 def valide_item(self,item):
280 On fait un try except pour les erreurs de type (exple
281 on rentre 1 pour une chaine de caracteres
284 if self.definition.validators :
286 valide=self.definition.validators.verif_item(item)
291 def valide_liste_partielle(self,item,listecourante):
292 valeuravant=self.object.valeur
295 valeur = tuple(valeur)
296 retour=self.object.set_valeur(valeur)
298 if self.object.isvalid():
300 elif self.definition.validators :
301 validite=self.definition.validators.valide_liste_partielle(valeur)
304 min,max=self.GetMinMax()
305 if len(valeur) < min :
307 retour=self.object.set_valeur(valeuravant)
310 def valide_liste_complete (self,valeur):
311 valeuravant=self.object.valeur
312 retour=self.object.set_valeur(valeur)
314 if self.object.isvalid():
316 retour=self.object.set_valeur(valeuravant)
319 def info_erreur_item(self) :
321 if self.definition.validators :
322 commentaire=self.definition.validators.info_erreur_item()
327 if self.definition.validators :
328 commentaire=self.definition.validators.aide()
331 def info_erreur_liste(self) :
333 if self.definition.validators :
334 commentaire=self.definition.validators.info_erreur_liste()
337 def IsInIntervalle(self,valeur):
339 Retourne 1 si la valeur est dans l'intervalle permis par
340 l'objet représenté par l'item.
342 return self.object.isinintervalle(valeur)
345 valide=self.object.isvalid()
346 return self.object.isvalid()
348 #--------------------------------------------------
352 #---------------------------------------------------
353 # SetText a priori inutilisee --> commentee
356 # getval a priori inutilisee --> commentee
358 # get_sd_avant_du_bon_type
359 # verif a priori inutilisee --> commentee
362 #def SetText(self, text):
365 # self.object.setval(value)
369 def GetIconName(self):
371 return "ast-green-ball"
372 elif self.object.isoblig():
373 return "ast-red-ball"
375 return "ast-yel-ball"
380 Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
383 text= self.object.GetText()
387 # return self.object.getval()
389 def set_valeur_co(self,nom_co):
391 Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
393 return self.object.set_valeur_co(nom_co)
395 def get_sd_avant_du_bon_type(self):
397 Retourne la liste des noms des SD présentes avant l'étape qui contient
398 le MCS pointé par self et du type requis par ce MCS
400 a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
401 return self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,
402 self.object.definition.type)
407 def delete_valeur_co(self,valeur=None):
409 Supprime la valeur du mot cle (de type CO)
410 il faut propager la destruction aux autres etapes
412 if not valeur : valeur=self.object.valeur
413 # XXX faut il vraiment appeler del_sdprod ???
414 #self.object.etape.parent.del_sdprod(valeur)
415 self.object.etape.parent.delete_concept(valeur)
417 #-----------------------------------------------
419 # Methodes liees au type de l objet attendu
421 #-----------------------------------------------
432 Méthode booléenne qui retourne 1 si l'objet pointé par self
433 attend un objet de type ASSD qui n'existe pas encore (type CO()),
436 return self.object.wait_co()
440 Méthode booléenne qui retourne 1 si l'objet pointé par self
441 attend un objet GEOM, 0 sinon
443 return self.object.wait_geom()
445 def wait_complex(self):
446 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
447 attend un complexe, 0 sinon """
448 if 'C' in self.object.definition.type:
454 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
455 attend un réel, 0 sinon """
456 if 'R' in self.object.definition.type:
461 def wait_shell(self):
462 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
463 attend un shell, 0 sinon """
464 if 'shell' in self.object.definition.type:
470 """Méthode booléenne qui retourne 1 si l'objet pointé par self
471 attend un objet de type ASSD ou dérivé, 0 sinon """
472 return self.object.wait_assd()
476 Retourne le type de valeur attendu par l'objet représenté par l'item.
478 return self.object.get_type()
480 #-----------------------------------------------------
482 # Methodes liees a l evaluation de la valeur saisie
484 #-----------------------------------------------------
490 def eval_valeur(self,valeur):
491 """ Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur
492 de l'objet pointé par self :
493 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
494 - retourne 'valeur' (chaîne de caractères) sinon
495 - retourne None en cas d invalidite
496 - retourne invalide si 1 des objets du tuple l est
499 if type(valeur) in (types.ListType,types.TupleType) :
502 newvaleur,validiteitem=self.eval_valeur_item(item)
503 valeurretour.append(newvaleur)
504 if validiteitem == 0:
507 valeurretour,validite= self.eval_valeur_item(valeur)
510 return valeurretour,validite
512 def eval_valeur_item(self,valeur):
513 """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
514 - va retourner la valeur de retour et la validite
515 selon le type de l objet attendu
516 - traite les reels et les parametres
518 if valeur==None or valeur == "" :
522 valeurinter = self.traite_reel(valeur)
523 valeurretour,validite= self.object.eval_valeur(valeurinter)
524 elif self.wait_geom():
525 valeurretour,validite = valeur,1
527 valeurretour,validite= self.object.eval_valeur(valeur)
529 if type(valeur) == types.StringType and self.object.wait_TXM():
530 essai_valeur="'" + valeur + "'"
531 valeurretour,validite= self.object.eval_valeur(essai_valeur)
532 if hasattr(valeurretour,'__class__'):
533 if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
537 valeurretour=Accas.CO(valeur)
541 # on est dans le cas où on a évalué et où on n'aurait pas du
542 if self.object.wait_TXM() :
543 if type(valeurretour) != types.StringType:
544 valeurretour=str(valeur)
546 return valeurretour,validite
548 def is_CO(self,valeur=None):
550 Indique si valeur est un concept produit de la macro
551 Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
552 Si valeur vaut None on teste la valeur du mot cle
554 # Pour savoir si un concept est un nouveau concept de macro
555 # on regarde s'il est présent dans l'attribut sdprods de l'étape
556 # ou si son nom de classe est CO.
557 # Il faut faire les 2 tests car une macro non valide peut etre
558 # dans un etat pas tres catholique avec des CO pas encore types
559 # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
560 if not valeur:valeur=self.object.valeur
561 if valeur in self.object.etape.sdprods:return 1
562 if type(valeur) is not types.InstanceType:return 0
563 if valeur.__class__.__name__ == 'CO':return 1
566 def is_param(self,valeur) :
567 for param in self.jdc.params:
568 if (repr(param) == valeur):
572 def traite_reel(self,valeur):
574 Cette fonction a pour but de rajouter le '.' en fin de chaîne pour un réel
575 ou de détecter si on fait référence à un concept produit par DEFI_VALEUR
578 valeur = string.strip(valeur)
579 liste_reels = self.get_sd_avant_du_bon_type()
580 if valeur in liste_reels:
582 if len(valeur) >= 3 :
583 if valeur[0:4] == 'EVAL' :
584 # on a trouvé un EVAL --> on retourne directement la valeur
586 if string.find(valeur,'.') == -1 :
587 # aucun '.' n'a été trouvé dans valeur --> on en rajoute un à la fin
588 if (self.is_param(valeur)):
597 treeitem = SIMPTreeItem