1 # -*- coding: utf-8 -*-
2 # CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
8 # (AT YOUR OPTION) ANY LATER VERSION.
10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
17 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
20 # ======================================================================
22 import string,types,os
25 from copy import copy,deepcopy
33 from widgets import ListeChoix
34 from widgets import FenetreDeSelection
36 from Noyau.N_CR import justify_text
37 from utils import substract_list
40 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
41 from newsimppanel import newSIMPPanel
49 def affect_panel(self):
51 Cette méthode attribue le panel à l'objet pointé par self en fonction de la
52 nature de la valeur demandée pour cet objet
54 from uniquepanel import UNIQUE_Panel
55 from plusieurspanel import PLUSIEURS_Panel
57 #print "affect_panel : ",self.nom,self.is_list(),self.has_into(), self.get_into(None)
60 # l'objet attend un shell
61 from shellpanel import SHELLPanel
62 self.panel = SHELLPanel
64 # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
66 from plusieursintopanel import PLUSIEURS_INTO_Panel
67 self.panel = PLUSIEURS_INTO_Panel
69 from uniqueintopanel import UNIQUE_INTO_Panel
70 self.panel = UNIQUE_INTO_Panel
72 # l'objet prend une ou des valeurs à priori quelconques
74 # on attend une liste de valeurs mais de quel type ?
76 # on attend une liste de SD
77 from plusieursassdpanel import PLUSIEURS_ASSD_Panel
78 self.panel = PLUSIEURS_ASSD_Panel
80 # on attend une liste de valeurs de types debase (entiers, réels,...)
81 from plusieursbasepanel import PLUSIEURS_BASE_Panel
82 self.panel = PLUSIEURS_BASE_Panel
84 # on n'attend qu'une seule valeur mais de quel type ?
86 # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
87 from uniquesdcopanel import UNIQUE_SDCO_Panel
88 self.panel = UNIQUE_SDCO_Panel
89 elif self.wait_assd():
91 from uniqueassdpanel import UNIQUE_ASSD_Panel
92 from uniqueassdpanel import UNIQUE_ASSD_Panel_Reel
93 if 'R' in self.GetType():
94 self.panel = UNIQUE_ASSD_Panel_Reel
96 self.panel = UNIQUE_ASSD_Panel
98 # on attend une valeur d'un type de base (entier,réel,...)
99 if self.wait_complex():
100 # on attend un complexe
101 from uniquecomppanel import UNIQUE_COMP_Panel
102 self.panel = UNIQUE_COMP_Panel
104 # on attend un entier, un réel ou une string
105 from uniquebasepanel import UNIQUE_BASE_Panel
106 self.panel = UNIQUE_BASE_Panel
107 # cas particulier des fonctions
108 genea = self.get_genealogie()
109 if "VALE" in genea or "VALE_C" in genea:
110 if "DEFI_FONCTION" in genea :
111 from fonctionpanel import FONCTION_Panel
112 self.panel=FONCTION_Panel
113 #---------------------------------------------------------
114 # PN ajout pour lancement de Salome
115 #---------------------------------------------------------
116 if self.appli.salome != 0 :
119 self.select_noeud_maille=0
120 self.clef_fonction="SALOME"
121 for i in range(0,len( genea )) :
122 self.clef_fonction=self.clef_fonction+"_"+ genea[i]
123 if genea[i] == "GROUP_NO" or genea[i] == "GROUP_MA":
124 self.select_noeud_maille=1
126 recherche=panelsSalome.dict_classes_salome[self.panel]
127 if hasattr(recherche,self.clef_fonction):
129 if self.select_noeud_maille==1 :
133 #-----------------------------------------------
135 # Methodes liees aux informations sur le Panel
136 # ou au mot-clef simple
138 #-----------------------------------------------
140 # get_into a priori inutile --> commentee
142 # wait_into a priori inutile --> commentee
151 Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
152 ou s'il n'en attend pas (valeur de retour 0)
154 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
155 Dans le cas sans validateur, l'information est donnée par l'attribut max
156 de la definition du mot cle.
157 Dans le cas avec validateur, il faut combiner l'information précédente avec
158 celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
159 l'operateur ET pour effectuer cette combinaison (AndVal).
162 min,max = self.GetMinMax()
166 # Dans le cas avec validateurs, pour que le mot cle soit considéré
167 # comme acceptant une liste, il faut que max soit supérieur a 1
168 # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
169 # on retournera 0 (n'attend pas de liste)
170 if self.definition.validators :
171 is_a_list= self.definition.validators.is_list() * is_a_list
174 #def get_into(self,liste_courante=None):
176 # Cette méthode retourne la liste de choix proposée par le mot cle. Si le mot cle ne propose
177 # pas de liste de choix, la méthode retourne None.
178 # L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déjà
179 # effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
180 # en en tenant compte.
181 # Cette méthode part du principe que la relation entre into du mot clé et les validateurs est
182 # une relation de type ET (AndVal).
184 # if not self.object.definition.validators :
185 # return self.object.definition.into
187 # return self.object.definition.validators.get_into(liste_courante,self.definition.into)
191 Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
192 ou s'il n'en propose pas (valeur de retour 0)
194 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
195 Dans le cas sans validateur, l'information est donnée par l'attribut into
196 de la definition du mot cle.
197 Dans le cas avec validateurs, pour que le mot cle soit considéré
198 comme proposant un choix, il faut que into soit présent OU
199 que la méthode has_into du validateur retourne 1. Dans les autres cas
200 on retournera 0 (ne propose pas de choix)
203 if self.definition.into:
205 elif self.definition.validators :
206 has_an_into= self.definition.validators.has_into()
209 # def wait_into(self):
210 # """ Méthode booléenne qui retourne 1 si l'objet pointé par self
211 # prend ses valeurs dans un ensemble discret (into), 0 sinon """
212 # if self.object.definition.into != None :
218 """ Retourne les valeurs min et max de la définition de object """
219 return self.object.get_min_max()
221 def GetMultiplicite(self):
223 Retourne la multiplicité des valeurs affectées à l'objet
224 représenté par l'item. Pour le moment retourne invariablement 1.
228 def GetIntervalle(self):
230 Retourne le domaine de valeur attendu par l'objet représenté
233 return self.object.getintervalle()
235 def GetListeValeurs(self) :
236 """ Retourne la liste des valeurs de object """
237 valeurs=self.object.get_liste_valeurs()
239 if "R" in self.object.definition.type:
240 clef=self.object.GetNomConcept()
241 if self.appli.dict_reels.has_key(clef):
242 if type(valeurs) == types.TupleType:
245 if self.appli.dict_reels[clef].has_key(val) :
246 valeurs_reelles.append(self.appli.dict_reels[clef][val])
248 valeurs_reelles.append(val)
250 if self.appli.dict_reels[clef].has_key(valeurs):
251 valeurs_reelles=self.appli.dict_reels[clef][valeurs]
252 valeurs=valeurs_reelles
257 def get_liste_possible(self,listeActuelle=[]):
258 if hasattr(self.definition.validators,'into'):
259 self.get_definition().into=self.definition.validators.into
260 valeurspossibles = self.get_definition().into
261 # CCAR : Ne serait-il pas preferable d'appeler get_into ?
262 #valeurspossibles=self.get_into(listeActuelle)
265 for item in valeurspossibles:
266 encorevalide=self.valide_item(item)
268 listevalideitem.append(item)
269 # on ne verifie pas la liste des choix si max = 1
270 # (sinon cela enleve tous les choix possibles)
271 min,max=self.GetMinMax()
274 for item in listevalideitem:
276 for item2 in listeActuelle : listetravail.append(item2)
277 encorevalide=self.valide_liste_partielle(item,listetravail)
279 listevalideliste.append(item)
281 listevalideliste=listevalideitem
282 return listevalideliste
284 def get_liste_param_possible(self):
287 for param in self.object.jdc.params:
288 encorevalide=self.valide_item(param.valeur)
290 type_param=param.valeur.__class__.__name__
291 for typ in self.definition.type:
293 liste_param.append(param)
294 if typ=='I' and type_param=='int':
295 liste_param.append(param)
296 if typ=='TXM' and type_param=='str':
297 liste_param.append(repr(param))
300 #--------------------------------------------------
302 # Methodes liees a la validite des valeurs saisies
304 #---------------------------------------------------
306 # valide_liste_partielle
307 # valide_liste_complete
313 def valide_item(self,item):
315 On fait un try except pour les erreurs de type (exple
316 on rentre 1 pour une chaine de caracteres
319 if self.definition.validators :
321 valide=self.definition.validators.verif_item(item)
326 def valide_liste_partielle(self,item,listecourante):
329 valeur = tuple(valeur)
330 return self.object.valid_valeur_partielle(valeur)
332 def valide_liste_partielle_BAK(self,item,listecourante):
334 valeuravant=self.object.valeur
337 valeur = tuple(valeur)
338 retour=self.object.set_valeur(valeur)
340 if self.object.isvalid():
342 elif self.definition.validators :
343 validite=self.definition.validators.valide_liste_partielle(valeur)
346 min,max=self.GetMinMax()
347 if len(valeur) < min :
349 retour=self.object.set_valeur(valeuravant)
352 def valide_liste_complete (self,valeur):
353 return self.object.valid_valeur(valeur)
355 def valide_liste_complete_BAK (self,valeur):
357 valeuravant=self.object.valeur
358 retour=self.object.set_valeur(valeur)
360 if self.object.isvalid():
362 retour=self.object.set_valeur(valeuravant)
365 def info_erreur_item(self) :
367 if self.definition.validators :
368 commentaire=self.definition.validators.info_erreur_item()
373 if self.definition.validators :
374 commentaire=self.definition.validators.aide()
377 def info_erreur_liste(self) :
379 if self.definition.validators :
380 commentaire=self.definition.validators.info_erreur_liste()
383 def IsInIntervalle(self,valeur):
385 Retourne 1 si la valeur est dans l'intervalle permis par
386 l'objet représenté par l'item.
388 return self.object.isinintervalle(valeur)
391 valide=self.object.isvalid()
394 #--------------------------------------------------
398 #---------------------------------------------------
399 # SetText a priori inutilisee --> commentee
402 # getval a priori inutilisee --> commentee
404 # get_sd_avant_du_bon_type
405 # verif a priori inutilisee --> commentee
408 #def SetText(self, text):
411 # self.object.setval(value)
415 def GetIconName(self):
417 return "ast-green-ball"
418 elif self.object.isoblig():
419 return "ast-red-ball"
421 return "ast-yel-ball"
426 Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
429 text= self.object.GetText()
433 # return self.object.getval()
435 def set_valeur_co(self,nom_co):
437 Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
439 ret = self.object.set_valeur_co(nom_co)
440 #print "set_valeur_co",ret
443 def get_sd_avant_du_bon_type(self):
445 Retourne la liste des noms des SD présentes avant l'étape qui contient
446 le MCS pointé par self et du type requis par ce MCS
448 a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
454 def delete_valeur_co(self,valeur=None):
456 Supprime la valeur du mot cle (de type CO)
457 il faut propager la destruction aux autres etapes
459 if not valeur : valeur=self.object.valeur
460 # XXX faut il vraiment appeler del_sdprod ???
461 #self.object.etape.parent.del_sdprod(valeur)
462 self.object.etape.parent.delete_concept(valeur)
464 #-----------------------------------------------
466 # Methodes liees au type de l objet attendu
468 #-----------------------------------------------
479 Méthode booléenne qui retourne 1 si l'objet pointé par self
480 attend un objet de type ASSD qui n'existe pas encore (type CO()),
483 return self.object.wait_co()
487 Méthode booléenne qui retourne 1 si l'objet pointé par self
488 attend un objet GEOM, 0 sinon
490 return self.object.wait_geom()
492 def wait_complex(self):
493 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
494 attend un complexe, 0 sinon """
495 if 'C' in self.object.definition.type:
501 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
502 attend un réel, 0 sinon """
503 if 'R' in self.object.definition.type:
508 def wait_shell(self):
509 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
510 attend un shell, 0 sinon """
511 if 'shell' in self.object.definition.type:
517 """Méthode booléenne qui retourne 1 si l'objet pointé par self
518 attend un objet de type ASSD ou dérivé, 0 sinon """
519 return self.object.wait_assd()
523 Retourne le type de valeur attendu par l'objet représenté par l'item.
525 return self.object.get_type()
527 #-----------------------------------------------------
529 # Methodes liees a l evaluation de la valeur saisie
531 #-----------------------------------------------------
537 def eval_valeur(self,valeur):
538 """ Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur
539 de l'objet pointé par self :
540 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
541 - retourne 'valeur' (chaîne de caractères) sinon
542 - retourne None en cas d invalidite
543 - retourne invalide si 1 des objets du tuple l est
546 if type(valeur) in (types.ListType,types.TupleType) :
549 newvaleur,validiteitem=self.eval_valeur_item(item)
550 valeurretour.append(newvaleur)
551 if validiteitem == 0:
554 valeurretour,validite= self.eval_valeur_item(valeur)
557 return valeurretour,validite
559 def eval_valeur_item(self,valeur):
560 """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
561 - va retourner la valeur de retour et la validite
562 selon le type de l objet attendu
563 - traite les reels et les parametres
565 #print "eval_valeur_item",valeur
566 if valeur==None or valeur == "" :
570 valeurinter = self.traite_reel(valeur)
571 valeurretour,validite= self.object.eval_valeur(valeurinter)
572 elif self.wait_geom():
573 valeurretour,validite = valeur,1
575 valeurretour,validite= self.object.eval_valeur(valeur)
576 #print "eval_valeur_item",valeurretour,validite
579 if type(valeur) == types.StringType and self.object.wait_TXM():
580 essai_valeur="'" + valeur + "'"
581 valeurretour,validite= self.object.eval_valeur(essai_valeur)
583 if hasattr(valeurretour,'__class__'):
584 #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
585 if valeurretour.__class__.__name__ in ('PARAMETRE',):
589 # CCAR : il ne faut pas essayer de creer un concept
590 # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
592 #valeurretour=Accas.CO(valeur)
596 # on est dans le cas où on a évalué et où on n'aurait pas du
597 if self.object.wait_TXM() :
598 if type(valeurretour) != types.StringType:
599 valeurretour=str(valeur)
601 return valeurretour,validite
603 def is_CO(self,valeur=None):
605 Indique si valeur est un concept produit de la macro
606 Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
607 Si valeur vaut None on teste la valeur du mot cle
609 # Pour savoir si un concept est un nouveau concept de macro
610 # on regarde s'il est présent dans l'attribut sdprods de l'étape
611 # ou si son nom de classe est CO.
612 # Il faut faire les 2 tests car une macro non valide peut etre
613 # dans un etat pas tres catholique avec des CO pas encore types
614 # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
615 if not valeur:valeur=self.object.valeur
616 if valeur in self.object.etape.sdprods:return 1
617 if type(valeur) is not types.InstanceType:return 0
618 if valeur.__class__.__name__ == 'CO':return 1
621 def is_param(self,valeur) :
622 for param in self.jdc.params:
623 if (repr(param) == valeur):
627 def traite_reel(self,valeur):
629 Cette fonction a pour but de rajouter le '.' en fin de chaîne pour un réel
630 ou de détecter si on fait référence à un concept produit par DEFI_VALEUR
633 valeur = string.strip(valeur)
634 liste_reels = self.get_sd_avant_du_bon_type()
635 if valeur in liste_reels:
637 if len(valeur) >= 3 :
638 if valeur[0:4] == 'EVAL' :
639 # on a trouvé un EVAL --> on retourne directement la valeur
641 if string.find(valeur,'.') == -1 :
642 # aucun '.' n'a été trouvé dans valeur --> on en rajoute un à la fin
643 if (self.is_param(valeur)):
646 if string.find(valeur,'e') != -1:
647 # Notation scientifique ?
660 treeitem = SIMPTreeItem