1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013 EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 import string,types,os
23 from copy import copy,deepcopy
28 from Editeur import Objecttreeitem
30 from Noyau.N_CR import justify_text
31 from Accas import SalomeEntry
33 class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
39 # Attention l ordre des if est important
41 if self.item.wait_matrice ():
42 from monMatricePanel import MonMatricePanel
44 # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
45 elif self.item.has_into():
46 if self.item.is_list() :
47 from monPlusieursIntoPanel import MonPlusieursIntoPanel
48 klass = MonPlusieursIntoPanel
50 from monUniqueIntoPanel import MonUniqueIntoPanel
51 klass = MonUniqueIntoPanel
53 # l'objet prend une ou des valeurs a priori quelconques
55 # on attend une liste de valeurs
56 if self.item.is_list() :
57 # on attend une liste de SD
58 if self.item.wait_tuple() :
59 from monFonctionPanel import MonFonctionPanel
60 klass = MonFonctionPanel
61 elif self.item.wait_assd():
62 from monPlusieursASSDPanel import MonPlusieursASSDPanel
63 klass = MonPlusieursASSDPanel
65 # on attend une liste de valeurs de types debase (entiers, réels,...)
66 from monPlusieursBasePanel import MonPlusieursBasePanel
67 klass = MonPlusieursBasePanel
68 # on n'attend qu'une seule valeur
70 # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
71 if self.item.wait_co():
72 if len(self.item.get_sd_avant_du_bon_type()) != 0 :
73 from monUniqueSDCOIntoPanel import MonUniqueSDCOIntoPanel
74 klass = MonUniqueSDCOIntoPanel
76 from monUniqueSDCOPanel import MonUniqueSDCOPanel
77 klass = MonUniqueSDCOPanel
80 elif self.item.wait_assd():
81 if 'R' in self.item.GetType():
82 from monUniqueASSDPanel import MonUniqueASSDReelPanel
83 klass = MonUniqueASSDReelPanel
85 from monUniqueASSDPanel import MonUniqueASSDPanel
86 klass = MonUniqueASSDPanel
88 # on attend une valeur d'un type de base (entier,reel,...)
90 # on attend un complexe
91 if self.item.wait_complex():
92 from monUniqueCompPanel import MonUniqueCompPanel
93 klass = MonUniqueCompPanel
94 elif self.item.wait_bool() :
95 from monUniqueBoolPanel import MonUniqueBoolPanel
96 klass = MonUniqueBoolPanel
98 from monUniqueBasePanel import MonUniqueBasePanel
99 klass = MonUniqueBasePanel
101 # cas particulier des fonctions
102 genea = self.item.get_genealogie()
103 if "VALE" in genea or "VALE_C" in genea:
104 if "DEFI_FONCTION" in genea :
105 from monFonctionPanel import MonFonctionPanel
106 klass = MonFonctionPanel
110 return klass( self, self.editor )
113 def createPopUpMenu(self):
114 typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
117 def getPanelGroupe(self,parentQt):
118 maDefinition=self.item.get_definition()
119 monObjet=self.item.object
122 # Attention l ordre des if est important
123 # Attention il faut gerer les blocs et les facteurs
124 # a gerer comme dans composimp
125 # Gerer les matrices --> Actuellement pas dans ce type de panneau
127 if maDefinition.max == 1 :
128 if maDefinition.into != [] and maDefinition.into != None:
130 if len(maDefinition.into) < 4 :
131 from monWidgetRadioButton import MonWidgetRadioButton
132 widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt)
133 elif len(maDefinition.into) < 7 :
134 from monWidget4a6RadioButton import MonWidget4a6RadioButton
135 widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt)
137 from monWidgetCB import MonWidgetCB
138 widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt)
140 elif self.item.wait_bool() :
141 from monWidgetSimpBool import MonWidgetSimpBool
142 widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt)
144 elif self.item.wait_fichier():
145 from monWidgetSimpFichier import MonWidgetSimpFichier
146 widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt)
148 elif self.item.wait_tuple() :
150 from monWidgetSimpTuple import MonWidgetSimpTuple
151 widget=MonWidgetSimpTuple(self,maDefinition,monNom,monObjet,parentQt)
153 elif self.item.wait_complex():
155 from monWidgetSimpComplexe import MonWidgetSimpComplexe
156 widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt)
158 elif self.item.wait_co():
160 from monWidgetSimpASSD import MonWidgetSimpASSD
161 widget=MonWidgetSimpASSD(self,maDefinition,monNom,monObjet,parentQt)
163 elif self.item.wait_Salome() and self.editor.salome:
165 from monWidgetSimpSalome import MonWidgetSimpSalome
166 widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt)
168 elif self.item.wait_TXM():
170 from monWidgetSimpTxt import MonWidgetSimpTxt
171 widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt)
173 from monWidgetSimpBase import MonWidgetSimpBase
174 widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt)
177 if maDefinition.into != [] and maDefinition.into != None:
179 from monWidgetPlusieursInto import MonWidgetPlusieursInto
180 widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt)
182 from monWidgetPlusieursBase import MonWidgetPlusieursBase
183 widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt)
187 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
194 #-----------------------------------------------
196 # Methodes liees aux informations sur le Panel
197 # ou au mot-clef simple
199 #-----------------------------------------------
201 # get_into a priori inutile --> commentee
203 # wait_into a priori inutile --> commentee
212 Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
213 ou s'il n'en attend pas (valeur de retour 0)
215 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
216 Dans le cas sans validateur, l'information est donnee par l'attribut max
217 de la definition du mot cle.
218 Dans le cas avec validateur, il faut combiner l'information precedente avec
219 celle issue de l'appel de la methode is_list sur le validateur.On utilisera
220 l'operateur ET pour effectuer cette combinaison (AndVal).
223 min,max = self.GetMinMax()
227 # Dans le cas avec validateurs, pour que le mot cle soit considere
228 # comme acceptant une liste, il faut que max soit superieur a 1
229 # ET que la methode is_list du validateur retourne 1. Dans les autres cas
230 # on retournera 0 (n'attend pas de liste)
231 if self.definition.validators :
232 is_a_list= self.definition.validators.is_list() * is_a_list
238 Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
239 ou s'il n'en propose pas (valeur de retour 0)
241 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
242 Dans le cas sans validateur, l'information est donnee par l'attribut into
243 de la definition du mot cle.
244 Dans le cas avec validateurs, pour que le mot cle soit considere
245 comme proposant un choix, il faut que into soit present OU
246 que la methode has_into du validateur retourne 1. Dans les autres cas
247 on retournera 0 (ne propose pas de choix)
250 if self.definition.into:
252 elif self.definition.validators :
253 has_an_into= self.definition.validators.has_into()
258 """ Retourne les valeurs min et max de la definition de object """
259 return self.object.get_min_max()
261 def GetMultiplicite(self):
263 Retourne la multiplicite des valeurs affectees a l'objet
264 represente par l'item. Pour le moment retourne invariablement 1.
268 def GetIntervalle(self):
270 Retourne le domaine de valeur attendu par l'objet represente
273 return self.object.getintervalle()
275 def GetListeValeurs(self) :
276 """ Retourne la liste des valeurs de object """
277 valeurs=self.object.get_liste_valeurs()
279 if "R" in self.object.definition.type:
280 clef=self.object.GetNomConcept()
281 if self.appli.dict_reels.has_key(clef):
282 if type(valeurs) == types.TupleType:
285 if self.appli.dict_reels[clef].has_key(val) :
286 valeurs_reelles.append(self.appli.dict_reels[clef][val])
288 valeurs_reelles.append(val)
290 if self.appli.dict_reels[clef].has_key(valeurs):
291 valeurs_reelles=self.appli.dict_reels[clef][valeurs]
292 valeurs=valeurs_reelles
297 def get_liste_possible(self,listeActuelle=[]):
298 if hasattr(self.definition.validators,'into'):
299 valeurspossibles = self.definition.validators.into
301 valeurspossibles = self.get_definition().into
303 #On ne garde que les items valides
305 if type(valeurspossibles) in (types.ListType,types.TupleType) :
308 valeurspossibles=(valeurspossibles,)
309 for item in valeurspossibles:
310 encorevalide=self.valide_item(item)
312 listevalideitem.append(item)
314 #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
316 for item in listevalideitem:
317 encorevalide=self.valide_liste_partielle(item,listeActuelle)
319 listevalideliste.append(item)
320 return listevalideliste
322 def get_liste_param_possible(self):
324 l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
325 for param in self.object.jdc.params:
326 if param.nom not in l1 : continue
327 encorevalide=self.valide_item(param.valeur)
329 type_param=param.valeur.__class__.__name__
330 for typ in self.definition.type:
332 liste_param.append(param)
333 if typ=='I' and type_param=='int':
334 liste_param.append(param)
335 if typ=='TXM' and type_param=='str':
336 liste_param.append(repr(param))
337 if ('grma' in repr(typ)) and type_param=='str':
338 liste_param.append(param.nom)
341 #--------------------------------------------------
343 # Methodes liees a la validite des valeurs saisies
345 #---------------------------------------------------
347 # valide_liste_partielle
348 # valide_liste_complete
354 def valide_item(self,item):
356 La validation est realisee directement par l'objet
360 print self.object.valide_item
361 return self.object.valide_item(item)
363 def valide_liste_partielle(self,item,listecourante):
364 #On protege la liste en entree en la copiant
365 valeur=listecourante[:]
367 return self.object.valid_valeur_partielle(valeur)
369 def valide_liste_complete (self,valeur):
370 return self.object.valid_valeur(valeur)
372 def valide_val (self,valeur):
373 return self.object.valid_val(valeur)
375 def info_erreur_item(self) :
377 if self.definition.validators :
378 commentaire=self.definition.validators.info_erreur_item()
383 if self.definition.validators :
384 commentaire=self.definition.validators.aide()
387 def info_erreur_liste(self) :
389 if self.definition.validators :
390 commentaire=self.definition.validators.info_erreur_liste()
393 def IsInIntervalle(self,valeur):
395 Retourne 1 si la valeur est dans l'intervalle permis par
396 l'objet represente par l'item.
398 return self.valide_item(valeur)
401 valide=self.object.isvalid()
404 #--------------------------------------------------
408 #---------------------------------------------------
412 # get_sd_avant_du_bon_type
416 def GetIconName(self):
418 return "ast-green-ball"
419 elif self.object.isoblig():
420 return "ast-red-ball"
422 return "ast-yel-ball"
428 Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
431 text= self.object.GetText()
432 if text == None : text=""
436 def set_valeur_co(self,nom_co):
438 Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
440 ret = self.object.set_valeur_co(nom_co)
441 #print "set_valeur_co",ret
444 def get_sd_avant_du_bon_type(self):
446 Retourne la liste des noms des SD présentes avant l'étape qui contient
447 le MCS pointé par self et du type requis par ce MCS
449 a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
452 def get_sd_avant_du_bon_type_pour_type_de_base(self):
453 a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
459 def delete_valeur_co(self,valeur=None):
461 Supprime la valeur du mot cle (de type CO)
462 il faut propager la destruction aux autres etapes
464 if not valeur : valeur=self.object.valeur
465 # XXX faut il vraiment appeler del_sdprod ???
466 #self.object.etape.parent.del_sdprod(valeur)
467 self.object.etape.parent.delete_concept(valeur)
469 #-----------------------------------------------
471 # Methodes liees au type de l objet attendu
473 #-----------------------------------------------
483 Méthode booléenne qui retourne 1 si l'objet pointé par self
484 attend un objet de type ASSD qui n'existe pas encore (type CO()),
487 return self.object.wait_co()
489 def wait_fichier(self):
490 maDefinition=self.object.definition
492 if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
499 Méthode booléenne qui retourne 1 si l'objet pointé par self
500 attend un objet GEOM, 0 sinon
502 return self.object.wait_geom()
504 def wait_complex(self):
505 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
506 attend un complexe, 0 sinon """
507 if 'C' in self.object.definition.type:
513 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
514 attend un réel, 0 sinon """
515 if 'R' in self.object.definition.type:
520 def wait_tuple(self):
521 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
522 attend un Tuple, 0 sinon """
523 for ss_type in self.object.definition.type:
524 if repr(ss_type).find('Tuple') != -1 :
528 def wait_matrice(self):
529 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
530 attend un Tuple, 0 sinon """
531 for ss_type in self.object.definition.type:
532 if repr(ss_type).find('Matrice') != -1 :
537 """Méthode booléenne qui retourne 1 si l'objet pointé par self
538 attend un objet de type ASSD ou dérivé, 0 sinon """
539 return self.object.wait_assd()
541 def wait_assd_or_type_base(self) :
543 if len(self.object.definition.type) > 1 :
544 if self.wait_reel() :
546 if 'I' in self.object.definition.type :
550 def wait_Salome(self):
551 type = self.object.definition.type[0]
552 if 'grma' in repr(type) : return True
553 if 'grno' in repr(type) : return True
554 if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
559 Retourne le type de valeur attendu par l'objet représenté par l'item.
561 return self.object.get_type()
563 #-----------------------------------------------------
565 # Methodes liees a l evaluation de la valeur saisie
567 #-----------------------------------------------------
573 def eval_valeur(self,valeur):
574 """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
575 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
576 - retourne 'valeur' (chaine de caractéres) sinon
578 newvaleur=self.eval_val(valeur)
581 def eval_valeur_BAK(self,valeur):
582 """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
583 de l'objet pointé par self :
584 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
585 - retourne 'valeur' (chaine de caractéres) sinon
586 - retourne None en cas d invalidite
587 - retourne invalide si 1 des objets du tuple l est
590 if type(valeur) in (types.ListType,types.TupleType) :
593 newvaleur,validiteitem=self.eval_valeur_item(item)
594 valeurretour.append(newvaleur)
595 if validiteitem == 0:
598 valeurretour,validite= self.eval_valeur_item(valeur)
601 return valeurretour,validite
603 def eval_valeur_item(self,valeur):
604 """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
605 - va retourner la valeur de retour et la validite
606 selon le type de l objet attendu
607 - traite les reels et les parametres
609 #print "eval_valeur_item",valeur
610 if valeur==None or valeur == "" :
614 valeurinter = self.traite_reel(valeur)
615 if valeurinter != None :
616 valeurretour,validite= self.object.eval_valeur(valeurinter)
618 valeurretour,validite= self.object.eval_valeur(valeur)
619 elif self.wait_geom():
620 valeurretour,validite = valeur,1
622 valeurretour,validite= self.object.eval_valeur(valeur)
623 #print "eval_valeur_item",valeurretour,validite
626 if type(valeur) == types.StringType and self.object.wait_TXM():
627 essai_valeur="'" + valeur + "'"
628 valeurretour,validite= self.object.eval_valeur(essai_valeur)
630 if hasattr(valeurretour,'__class__'):
631 #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
632 if valeurretour.__class__.__name__ in ('PARAMETRE',):
636 # CCAR : il ne faut pas essayer de creer un concept
637 # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
639 #valeurretour=Accas.CO(valeur)
643 # on est dans le cas ou on a évalué et ou on n'aurait pas du
644 if self.object.wait_TXM() :
645 if type(valeurretour) != types.StringType:
646 valeurretour=str(valeur)
648 return valeurretour,validite
650 def is_CO(self,valeur=None):
652 Indique si valeur est un concept produit de la macro
653 Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
654 Si valeur vaut None on teste la valeur du mot cle
656 # Pour savoir si un concept est un nouveau concept de macro
657 # on regarde s'il est présent dans l'attribut sdprods de l'étape
658 # ou si son nom de classe est CO.
659 # Il faut faire les 2 tests car une macro non valide peut etre
660 # dans un etat pas tres catholique avec des CO pas encore types
661 # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
662 if not valeur:valeur=self.object.valeur
663 if valeur in self.object.etape.sdprods:return 1
664 if type(valeur) is not types.InstanceType:return 0
665 if valeur.__class__.__name__ == 'CO':return 1
668 def is_param(self,valeur) :
669 for param in self.jdc.params:
670 if (repr(param) == valeur):
674 def traite_reel(self,valeur):
676 Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
677 ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
680 valeur = string.strip(valeur)
681 liste_reels = self.get_sd_avant_du_bon_type()
682 if valeur in liste_reels:
684 if len(valeur) >= 3 :
685 if valeur[0:4] == 'EVAL' :
686 # on a trouvé un EVAL --> on retourne directement la valeur
688 if string.find(valeur,'.') == -1 :
689 # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
690 if (self.is_param(valeur)):
693 if string.find(valeur,'e') != -1:
694 # Notation scientifique ?
707 treeitem = SIMPTreeItem