1 # -*- coding: utf-8 -*-
5 from copy import copy,deepcopy
10 from Editeur import Objecttreeitem
12 from Noyau.N_CR import justify_text
14 class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
20 # Attention l ordre des if est important
22 if self.item.wait_matrice ():
23 from monMatricePanel import MonMatricePanel
25 # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
26 elif self.item.has_into():
27 if self.item.is_list() :
28 from monPlusieursIntoPanel import MonPlusieursIntoPanel
29 klass = MonPlusieursIntoPanel
31 from monUniqueIntoPanel import MonUniqueIntoPanel
32 klass = MonUniqueIntoPanel
34 # l'objet prend une ou des valeurs a priori quelconques
36 # on attend une liste de valeurs
37 if self.item.is_list() :
38 # on attend une liste de SD
39 if self.item.wait_tuple() :
40 from monFonctionPanel import MonFonctionPanel
41 klass = MonFonctionPanel
42 elif self.item.wait_assd():
43 from monPlusieursASSDPanel import MonPlusieursASSDPanel
44 klass = MonPlusieursASSDPanel
46 # on attend une liste de valeurs de types debase (entiers, réels,...)
47 from monPlusieursBasePanel import MonPlusieursBasePanel
48 klass = MonPlusieursBasePanel
49 # on n'attend qu'une seule valeur
51 # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
52 if self.item.wait_co():
53 if len(self.item.get_sd_avant_du_bon_type()) != 0 :
54 from monUniqueSDCOIntoPanel import MonUniqueSDCOIntoPanel
55 klass = MonUniqueSDCOIntoPanel
57 from monUniqueSDCOPanel import MonUniqueSDCOPanel
58 klass = MonUniqueSDCOPanel
61 elif self.item.wait_assd():
62 if 'R' in self.item.GetType():
63 from monUniqueASSDPanel import MonUniqueASSDReelPanel
64 klass = MonUniqueASSDReelPanel
66 from monUniqueASSDPanel import MonUniqueASSDPanel
67 klass = MonUniqueASSDPanel
69 # on attend une valeur d'un type de base (entier,reel,...)
71 # on attend un complexe
72 if self.item.wait_complex():
73 from monUniqueCompPanel import MonUniqueCompPanel
74 klass = MonUniqueCompPanel
76 # on attend un entier, un réel ou une string
77 from monUniqueBasePanel import MonUniqueBasePanel
78 klass = MonUniqueBasePanel
80 # cas particulier des fonctions
81 genea = self.item.get_genealogie()
82 if "VALE" in genea or "VALE_C" in genea:
83 if "DEFI_FONCTION" in genea :
84 from monFonctionPanel import MonFonctionPanel
85 klass = MonFonctionPanel
89 return klass( self, self.editor )
91 def createPopUpMenu(self):
92 typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
96 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
103 #-----------------------------------------------
105 # Methodes liees aux informations sur le Panel
106 # ou au mot-clef simple
108 #-----------------------------------------------
110 # get_into a priori inutile --> commentee
112 # wait_into a priori inutile --> commentee
121 Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
122 ou s'il n'en attend pas (valeur de retour 0)
124 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
125 Dans le cas sans validateur, l'information est donnée par l'attribut max
126 de la definition du mot cle.
127 Dans le cas avec validateur, il faut combiner l'information précédente avec
128 celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
129 l'operateur ET pour effectuer cette combinaison (AndVal).
132 min,max = self.GetMinMax()
136 # Dans le cas avec validateurs, pour que le mot cle soit considéré
137 # comme acceptant une liste, il faut que max soit supérieur a 1
138 # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
139 # on retournera 0 (n'attend pas de liste)
140 if self.definition.validators :
141 is_a_list= self.definition.validators.is_list() * is_a_list
147 Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
148 ou s'il n'en propose pas (valeur de retour 0)
150 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
151 Dans le cas sans validateur, l'information est donnée par l'attribut into
152 de la definition du mot cle.
153 Dans le cas avec validateurs, pour que le mot cle soit considéré
154 comme proposant un choix, il faut que into soit présent OU
155 que la méthode has_into du validateur retourne 1. Dans les autres cas
156 on retournera 0 (ne propose pas de choix)
159 if self.definition.into:
161 elif self.definition.validators :
162 has_an_into= self.definition.validators.has_into()
167 """ Retourne les valeurs min et max de la définition de object """
168 return self.object.get_min_max()
170 def GetMultiplicite(self):
172 Retourne la multiplicité des valeurs affectées a l'objet
173 représenté par l'item. Pour le moment retourne invariablement 1.
177 def GetIntervalle(self):
179 Retourne le domaine de valeur attendu par l'objet représenté
182 return self.object.getintervalle()
184 def GetListeValeurs(self) :
185 """ Retourne la liste des valeurs de object """
186 valeurs=self.object.get_liste_valeurs()
188 if "R" in self.object.definition.type:
189 clef=self.object.GetNomConcept()
190 if self.appli.dict_reels.has_key(clef):
191 if type(valeurs) == types.TupleType:
194 if self.appli.dict_reels[clef].has_key(val) :
195 valeurs_reelles.append(self.appli.dict_reels[clef][val])
197 valeurs_reelles.append(val)
199 if self.appli.dict_reels[clef].has_key(valeurs):
200 valeurs_reelles=self.appli.dict_reels[clef][valeurs]
201 valeurs=valeurs_reelles
206 def get_liste_possible(self,listeActuelle=[]):
207 if hasattr(self.definition.validators,'into'):
208 valeurspossibles = self.definition.validators.into
210 valeurspossibles = self.get_definition().into
212 #On ne garde que les items valides
214 if type(valeurspossibles) in (types.ListType,types.TupleType) :
217 valeurspossibles=(valeurspossibles,)
218 for item in valeurspossibles:
219 encorevalide=self.valide_item(item)
221 listevalideitem.append(item)
223 #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
225 for item in listevalideitem:
226 encorevalide=self.valide_liste_partielle(item,listeActuelle)
228 listevalideliste.append(item)
229 return listevalideliste
231 def get_liste_param_possible(self):
233 for param in self.object.jdc.params:
234 encorevalide=self.valide_item(param.valeur)
236 type_param=param.valeur.__class__.__name__
237 for typ in self.definition.type:
239 liste_param.append(param)
240 if typ=='I' and type_param=='int':
241 liste_param.append(param)
242 if typ=='TXM' and type_param=='str':
243 liste_param.append(repr(param))
244 if ('grma' in repr(typ)) and type_param=='str':
245 liste_param.append(param.nom)
248 #--------------------------------------------------
250 # Methodes liees a la validite des valeurs saisies
252 #---------------------------------------------------
254 # valide_liste_partielle
255 # valide_liste_complete
261 def valide_item(self,item):
263 La validation est réalisée directement par l'objet
265 return self.object.valide_item(item)
267 def valide_liste_partielle(self,item,listecourante):
268 #On protege la liste en entree en la copiant
269 valeur=listecourante[:]
271 return self.object.valid_valeur_partielle(valeur)
273 def valide_liste_complete (self,valeur):
274 return self.object.valid_valeur(valeur)
276 def valide_val (self,valeur):
277 return self.object.valid_val(valeur)
279 def info_erreur_item(self) :
281 if self.definition.validators :
282 commentaire=self.definition.validators.info_erreur_item()
287 if self.definition.validators :
288 commentaire=self.definition.validators.aide()
291 def info_erreur_liste(self) :
293 if self.definition.validators :
294 commentaire=self.definition.validators.info_erreur_liste()
297 def IsInIntervalle(self,valeur):
299 Retourne 1 si la valeur est dans l'intervalle permis par
300 l'objet représenté par l'item.
302 return self.valide_item(valeur)
305 valide=self.object.isvalid()
308 #--------------------------------------------------
312 #---------------------------------------------------
316 # get_sd_avant_du_bon_type
320 def GetIconName(self):
322 return "ast-green-ball"
323 elif self.object.isoblig():
324 return "ast-red-ball"
326 return "ast-yel-ball"
331 Retourne le texte a afficher dans l'arbre représentant la valeur de l'objet
334 text= self.object.GetText()
335 if text == None : text=""
339 def set_valeur_co(self,nom_co):
341 Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
343 ret = self.object.set_valeur_co(nom_co)
344 #print "set_valeur_co",ret
347 def get_sd_avant_du_bon_type(self):
349 Retourne la liste des noms des SD présentes avant l'étape qui contient
350 le MCS pointé par self et du type requis par ce MCS
352 a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
355 def get_sd_avant_du_bon_type_pour_type_de_base(self):
356 a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
362 def delete_valeur_co(self,valeur=None):
364 Supprime la valeur du mot cle (de type CO)
365 il faut propager la destruction aux autres etapes
367 if not valeur : valeur=self.object.valeur
368 # XXX faut il vraiment appeler del_sdprod ???
369 #self.object.etape.parent.del_sdprod(valeur)
370 self.object.etape.parent.delete_concept(valeur)
372 #-----------------------------------------------
374 # Methodes liees au type de l objet attendu
376 #-----------------------------------------------
386 Méthode booléenne qui retourne 1 si l'objet pointé par self
387 attend un objet de type ASSD qui n'existe pas encore (type CO()),
390 return self.object.wait_co()
394 Méthode booléenne qui retourne 1 si l'objet pointé par self
395 attend un objet GEOM, 0 sinon
397 return self.object.wait_geom()
399 def wait_complex(self):
400 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
401 attend un complexe, 0 sinon """
402 if 'C' in self.object.definition.type:
408 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
409 attend un réel, 0 sinon """
410 if 'R' in self.object.definition.type:
415 def wait_tuple(self):
416 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
417 attend un Tuple, 0 sinon """
418 for ss_type in self.object.definition.type:
419 if repr(ss_type).find('Tuple') != -1 :
423 def wait_matrice(self):
424 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
425 attend un Tuple, 0 sinon """
426 for ss_type in self.object.definition.type:
427 if repr(ss_type).find('Matrice') != -1 :
432 """Méthode booléenne qui retourne 1 si l'objet pointé par self
433 attend un objet de type ASSD ou dérivé, 0 sinon """
434 return self.object.wait_assd()
436 def wait_assd_or_type_base(self) :
438 if len(self.object.definition.type) > 1 :
439 if self.wait_reel() :
441 if 'I' in self.object.definition.type :
448 Retourne le type de valeur attendu par l'objet représenté par l'item.
450 return self.object.get_type()
452 #-----------------------------------------------------
454 # Methodes liees a l evaluation de la valeur saisie
456 #-----------------------------------------------------
462 def eval_valeur(self,valeur):
463 """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
464 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
465 - retourne 'valeur' (chaine de caractéres) sinon
467 newvaleur=self.eval_val(valeur)
470 def eval_valeur_BAK(self,valeur):
471 """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
472 de l'objet pointé par self :
473 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
474 - retourne 'valeur' (chaine de caractéres) sinon
475 - retourne None en cas d invalidite
476 - retourne invalide si 1 des objets du tuple l est
479 if type(valeur) in (types.ListType,types.TupleType) :
482 newvaleur,validiteitem=self.eval_valeur_item(item)
483 valeurretour.append(newvaleur)
484 if validiteitem == 0:
487 valeurretour,validite= self.eval_valeur_item(valeur)
490 return valeurretour,validite
492 def eval_valeur_item(self,valeur):
493 """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
494 - va retourner la valeur de retour et la validite
495 selon le type de l objet attendu
496 - traite les reels et les parametres
498 #print "eval_valeur_item",valeur
499 if valeur==None or valeur == "" :
503 valeurinter = self.traite_reel(valeur)
504 if valeurinter != None :
505 valeurretour,validite= self.object.eval_valeur(valeurinter)
507 valeurretour,validite= self.object.eval_valeur(valeur)
508 elif self.wait_geom():
509 valeurretour,validite = valeur,1
511 valeurretour,validite= self.object.eval_valeur(valeur)
512 #print "eval_valeur_item",valeurretour,validite
515 if type(valeur) == types.StringType and self.object.wait_TXM():
516 essai_valeur="'" + valeur + "'"
517 valeurretour,validite= self.object.eval_valeur(essai_valeur)
519 if hasattr(valeurretour,'__class__'):
520 #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
521 if valeurretour.__class__.__name__ in ('PARAMETRE',):
525 # CCAR : il ne faut pas essayer de creer un concept
526 # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
528 #valeurretour=Accas.CO(valeur)
532 # on est dans le cas ou on a évalué et ou on n'aurait pas du
533 if self.object.wait_TXM() :
534 if type(valeurretour) != types.StringType:
535 valeurretour=str(valeur)
537 return valeurretour,validite
539 def is_CO(self,valeur=None):
541 Indique si valeur est un concept produit de la macro
542 Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
543 Si valeur vaut None on teste la valeur du mot cle
545 # Pour savoir si un concept est un nouveau concept de macro
546 # on regarde s'il est présent dans l'attribut sdprods de l'étape
547 # ou si son nom de classe est CO.
548 # Il faut faire les 2 tests car une macro non valide peut etre
549 # dans un etat pas tres catholique avec des CO pas encore types
550 # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
551 if not valeur:valeur=self.object.valeur
552 if valeur in self.object.etape.sdprods:return 1
553 if type(valeur) is not types.InstanceType:return 0
554 if valeur.__class__.__name__ == 'CO':return 1
557 def is_param(self,valeur) :
558 for param in self.jdc.params:
559 if (repr(param) == valeur):
563 def traite_reel(self,valeur):
565 Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
566 ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
569 valeur = string.strip(valeur)
570 liste_reels = self.get_sd_avant_du_bon_type()
571 if valeur in liste_reels:
573 if len(valeur) >= 3 :
574 if valeur[0:4] == 'EVAL' :
575 # on a trouvé un EVAL --> on retourne directement la valeur
577 if string.find(valeur,'.') == -1 :
578 # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
579 if (self.is_param(valeur)):
582 if string.find(valeur,'e') != -1:
583 # Notation scientifique ?
596 treeitem = SIMPTreeItem