1 # -*- coding: iso-8859-1 -*-
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):
38 # Attention l ordre des if est important
40 if self.item.wait_matrice ():
41 from monMatricePanel import MonMatricePanel
43 # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
44 elif self.item.has_into():
45 if self.item.is_list() :
46 from monPlusieursIntoPanel import MonPlusieursIntoPanel
47 klass = MonPlusieursIntoPanel
49 from monUniqueIntoPanel import MonUniqueIntoPanel
50 klass = MonUniqueIntoPanel
52 # l'objet prend une ou des valeurs a priori quelconques
54 # on attend une liste de valeurs
55 if self.item.is_list() :
56 # on attend une liste de SD
57 if self.item.wait_tuple() :
58 from monFonctionPanel import MonFonctionPanel
59 klass = MonFonctionPanel
60 elif self.item.wait_assd():
61 from monPlusieursASSDPanel import MonPlusieursASSDPanel
62 klass = MonPlusieursASSDPanel
64 # on attend une liste de valeurs de types debase (entiers, réels,...)
65 from monPlusieursBasePanel import MonPlusieursBasePanel
66 klass = MonPlusieursBasePanel
67 # on n'attend qu'une seule valeur
69 # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
70 if self.item.wait_co():
71 if len(self.item.get_sd_avant_du_bon_type()) != 0 :
72 from monUniqueSDCOIntoPanel import MonUniqueSDCOIntoPanel
73 klass = MonUniqueSDCOIntoPanel
75 from monUniqueSDCOPanel import MonUniqueSDCOPanel
76 klass = MonUniqueSDCOPanel
79 elif self.item.wait_assd():
80 if 'R' in self.item.GetType():
81 from monUniqueASSDPanel import MonUniqueASSDReelPanel
82 klass = MonUniqueASSDReelPanel
84 from monUniqueASSDPanel import MonUniqueASSDPanel
85 klass = MonUniqueASSDPanel
87 # on attend une valeur d'un type de base (entier,reel,...)
89 # on attend un complexe
90 if self.item.wait_complex():
91 from monUniqueCompPanel import MonUniqueCompPanel
92 klass = MonUniqueCompPanel
93 elif self.item.wait_bool() :
94 from monUniqueBoolPanel import MonUniqueBoolPanel
95 klass = MonUniqueBoolPanel
97 from monUniqueBasePanel import MonUniqueBasePanel
98 klass = MonUniqueBasePanel
100 # cas particulier des fonctions
101 genea = self.item.get_genealogie()
102 if "VALE" in genea or "VALE_C" in genea:
103 if "DEFI_FONCTION" in genea :
104 from monFonctionPanel import MonFonctionPanel
105 klass = MonFonctionPanel
109 return klass( self, self.editor )
112 def createPopUpMenu(self):
113 typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
116 def getPanelGroupe(self,parentQt,commande):
117 maDefinition=self.item.get_definition()
118 monObjet=self.item.object
123 if monObjet.isInformation():
124 from monWidgetInfo import MonWidgetInfo
125 widget=MonWidgetInfo(self,maDefinition,monNom,monObjet,parentQt,maCommande)
130 # Attention l ordre des if est important
131 # Attention il faut gerer les blocs et les facteurs
132 # a gerer comme dans composimp
133 # Gestion des matrices
134 if self.item.wait_matrice ():
135 from monWidgetMatrice import MonWidgetMatrice
136 widget=MonWidgetMatrice(self,maDefinition,monNom,monObjet,parentQt,maCommande)
140 #print "____________________________", monNom, self.item.wait_co()
141 #print "____________________________", monNom, self.item.wait_assd()
142 # Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
143 if maDefinition.max == 1 :
146 if maDefinition.into != [] and maDefinition.into != None:
147 if len(maDefinition.into) < 4 :
148 from monWidgetRadioButton import MonWidgetRadioButton
149 widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
150 elif len(maDefinition.into) < 7 :
151 from monWidget4a6RadioButton import MonWidget4a6RadioButton
152 widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
154 from monWidgetCB import MonWidgetCB
155 widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
157 elif self.item.wait_bool() :
158 from monWidgetSimpBool import MonWidgetSimpBool
159 widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
160 elif self.item.wait_fichier():
161 from monWidgetSimpFichier import MonWidgetSimpFichier
162 widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
165 elif self.item.wait_date():
166 from monWidgetDate import MonWidgetDate
167 widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
168 elif self.item.wait_heure():
169 from monWidgetHeure import MonWidgetHeure
170 widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
172 elif self.item.wait_tuple() :
173 if self.item.object.definition.type[0].ntuple == 2:
174 from monWidgetSimpTuple2 import MonWidgetSimpTuple2
175 widget=MonWidgetSimpTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
176 elif self.item.object.definition.type[0].ntuple == 3 :
177 from monWidgetSimpTuple3 import MonWidgetSimpTuple3
178 widget=MonWidgetSimpTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
180 print "Pas de Tuple de longueur > 3"
181 print "Prevenir la maintenance "
183 elif self.item.wait_complex():
184 from monWidgetSimpComplexe import MonWidgetSimpComplexe
185 widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
187 elif self.item.wait_co():
188 if len(self.item.get_sd_avant_du_bon_type()) == 0 :
189 from monWidgetUniqueSDCO import MonWidgetUniqueSDCO
190 widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
192 from monWidgetSDCOInto import MonWidgetSDCOInto
193 widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
194 elif self.item.wait_assd():
195 if len(self.item.get_sd_avant_du_bon_type()) == 0 :
196 from monWidgetVide import MonWidgetVide
197 widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
198 if len(self.item.get_sd_avant_du_bon_type()) < 4 :
199 from monWidgetRadioButton import MonWidgetRadioButtonSD
200 widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
201 elif len(self.item.get_sd_avant_du_bon_type()) < 7 :
202 from monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
203 widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
205 from monWidgetCB import MonWidgetCBSD
206 widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
208 elif self.item.wait_Salome() and self.editor.salome:
210 from monWidgetSimpSalome import MonWidgetSimpSalome
211 widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
213 elif self.item.wait_TXM():
214 from monWidgetSimpTxt import MonWidgetSimpTxt
215 widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
217 from monWidgetSimpBase import MonWidgetSimpBase
218 widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
222 #if maDefinition.into != [] and maDefinition.into != None:
223 # Attention pas fini --> on attend une liste de ASSD avec ordre
224 if self.item.wait_assd() and self.item.is_list_SansOrdreNiDoublon():
225 from monWidgetPlusieursInto import MonWidgetPlusieursInto
226 widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
227 elif self.item.wait_tuple() :
228 if self.item.object.definition.type[0].ntuple == 2:
229 from monWidgetPlusieursTuple2 import MonWidgetPlusieursTuple2
230 widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
231 # elif self.item.object.definition.type[0].ntuple == 3 :
232 # from monWidgetSimpTuple3 import MonWidgetSimpTuple3
233 # widget=MonWidgetSimpTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
235 print "Pas de Tuple de longueur > 3"
236 print "Prevenir la maintenance "
237 elif self.item.has_into():
238 if self.item.is_list_SansOrdreNiDoublon():
239 from monWidgetPlusieursInto import MonWidgetPlusieursInto
240 widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
242 from monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
243 widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
245 from monWidgetPlusieursBase import MonWidgetPlusieursBase
246 widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
251 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
258 #-----------------------------------------------
260 # Methodes liees aux informations sur le Panel
261 # ou au mot-clef simple
263 #-----------------------------------------------
265 # get_into a priori inutile --> commentee
267 # wait_into a priori inutile --> commentee
276 Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
277 ou s'il n'en attend pas (valeur de retour 0)
279 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
280 Dans le cas sans validateur, l'information est donnee par l'attribut max
281 de la definition du mot cle.
282 Dans le cas avec validateur, il faut combiner l'information precedente avec
283 celle issue de l'appel de la methode is_list sur le validateur.On utilisera
284 l'operateur ET pour effectuer cette combinaison (AndVal).
287 min,max = self.GetMinMax()
291 # Dans le cas avec validateurs, pour que le mot cle soit considere
292 # comme acceptant une liste, il faut que max soit superieur a 1
293 # ET que la methode is_list du validateur retourne 1. Dans les autres cas
294 # on retournera 0 (n'attend pas de liste)
295 if self.definition.validators :
296 is_a_list= self.definition.validators.is_list() * is_a_list
299 def is_list_SansOrdreNiDoublon(self):
300 if self.definition.homo=="SansOrdreNiDoublon": return 1
305 Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
306 ou s'il n'en propose pas (valeur de retour 0)
308 Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
309 Dans le cas sans validateur, l'information est donnee par l'attribut into
310 de la definition du mot cle.
311 Dans le cas avec validateurs, pour que le mot cle soit considere
312 comme proposant un choix, il faut que into soit present OU
313 que la methode has_into du validateur retourne 1. Dans les autres cas
314 on retournera 0 (ne propose pas de choix)
317 if self.definition.into:
319 elif self.definition.validators :
320 has_an_into= self.definition.validators.has_into()
325 """ Retourne les valeurs min et max de la definition de object """
326 return self.object.get_min_max()
328 def GetMultiplicite(self):
330 Retourne la multiplicite des valeurs affectees a l'objet
331 represente par l'item. Pour le moment retourne invariablement 1.
335 def GetIntervalle(self):
337 Retourne le domaine de valeur attendu par l'objet represente
340 return self.object.getintervalle()
342 def GetListeValeurs(self) :
343 """ Retourne la liste des valeurs de object """
344 valeurs=self.object.get_liste_valeurs()
346 if "R" in self.object.definition.type:
347 clef=self.object.GetNomConcept()
348 if self.appli.dict_reels.has_key(clef):
349 if type(valeurs) == types.TupleType:
352 if self.appli.dict_reels[clef].has_key(val) :
353 valeurs_reelles.append(self.appli.dict_reels[clef][val])
355 valeurs_reelles.append(val)
357 if self.appli.dict_reels[clef].has_key(valeurs):
358 valeurs_reelles=self.appli.dict_reels[clef][valeurs]
359 valeurs=valeurs_reelles
364 def get_liste_possible(self,listeActuelle=[]):
365 if hasattr(self.definition.validators,'into'):
366 valeurspossibles = self.definition.validators.into
368 valeurspossibles = self.get_definition().into
370 #On ne garde que les items valides
372 if type(valeurspossibles) in (types.ListType,types.TupleType) :
375 valeurspossibles=(valeurspossibles,)
376 for item in valeurspossibles:
377 encorevalide=self.valide_item(item)
379 listevalideitem.append(item)
381 #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
383 for item in listevalideitem:
384 encorevalide=self.valide_liste_partielle(item,listeActuelle)
386 listevalideliste.append(item)
387 return listevalideliste
389 def get_liste_param_possible(self):
391 l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
392 for param in self.object.jdc.params:
393 if param.nom not in l1 : continue
394 encorevalide=self.valide_item(param.valeur)
396 type_param=param.valeur.__class__.__name__
397 for typ in self.definition.type:
399 liste_param.append(param)
400 if typ=='I' and type_param=='int':
401 liste_param.append(param)
402 if typ=='TXM' and type_param=='str':
403 liste_param.append(repr(param))
404 if ('grma' in repr(typ)) and type_param=='str':
405 liste_param.append(param.nom)
408 #--------------------------------------------------
410 # Methodes liees a la validite des valeurs saisies
412 #---------------------------------------------------
414 # valide_liste_partielle
415 # valide_liste_complete
421 def valide_item(self,item):
423 La validation est realisee directement par l'objet
425 return self.object.valide_item(item)
427 def valide_liste_partielle(self,item,listecourante):
428 #On protege la liste en entree en la copiant
429 valeur=listecourante[:]
431 return self.object.valid_valeur_partielle(valeur)
433 def valide_liste_complete (self,valeur):
434 return self.object.valid_valeur(valeur)
436 def valide_val (self,valeur):
437 return self.object.valid_val(valeur)
439 def info_erreur_item(self) :
441 if self.definition.validators :
442 commentaire=self.definition.validators.info_erreur_item()
447 if self.definition.validators :
448 commentaire=self.definition.validators.aide()
451 def info_erreur_liste(self) :
453 if self.definition.validators :
454 commentaire=self.definition.validators.info_erreur_liste()
457 def IsInIntervalle(self,valeur):
459 Retourne 1 si la valeur est dans l'intervalle permis par
460 l'objet represente par l'item.
462 return self.valide_item(valeur)
465 valide=self.object.isvalid()
468 #--------------------------------------------------
472 #---------------------------------------------------
476 # get_sd_avant_du_bon_type
480 def GetIconName(self):
482 return "ast-green-ball"
483 elif self.object.isoblig():
484 return "ast-red-ball"
486 return "ast-yel-ball"
492 Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
495 text= self.object.GetText()
496 if text == None : text=""
500 def set_valeur_co(self,nom_co):
502 Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
504 ret = self.object.set_valeur_co(nom_co)
505 #print "set_valeur_co",ret
508 def get_sd_avant_du_bon_type(self):
510 Retourne la liste des noms des SD présentes avant l'étape qui contient
511 le MCS pointé par self et du type requis par ce MCS
513 a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
516 def get_sd_avant_du_bon_type_pour_type_de_base(self):
517 a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
523 def delete_valeur_co(self,valeur=None):
525 Supprime la valeur du mot cle (de type CO)
526 il faut propager la destruction aux autres etapes
528 if not valeur : valeur=self.object.valeur
529 # XXX faut il vraiment appeler del_sdprod ???
530 #self.object.etape.parent.del_sdprod(valeur)
531 self.object.etape.parent.delete_concept(valeur)
533 #-----------------------------------------------
535 # Methodes liees au type de l objet attendu
537 #-----------------------------------------------
547 Méthode booléenne qui retourne 1 si l'objet pointé par self
548 attend un objet de type ASSD qui n'existe pas encore (type CO()),
551 return self.object.wait_co()
553 def wait_fichier(self):
554 maDefinition=self.object.definition
556 if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
563 Méthode booléenne qui retourne 1 si l'objet pointé par self
564 attend un objet GEOM, 0 sinon
566 return self.object.wait_geom()
568 def wait_complex(self):
569 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
570 attend un complexe, 0 sinon """
571 if 'C' in self.object.definition.type:
577 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
578 attend un réel, 0 sinon """
579 if 'R' in self.object.definition.type:
585 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
586 attend un réel, 0 sinon """
587 if 'DateHHMMAAAA' in self.object.definition.type:
592 def wait_heure(self):
593 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
594 attend un réel, 0 sinon """
595 if 'HeureHHMMSS' in self.object.definition.type:
602 def wait_tuple(self):
603 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
604 attend un Tuple, 0 sinon """
605 for ss_type in self.object.definition.type:
606 if repr(ss_type).find('Tuple') != -1 :
610 def wait_matrice(self):
611 """ Méthode booléenne qui retourne 1 si l'objet pointé par self
612 attend un Tuple, 0 sinon """
613 for ss_type in self.object.definition.type:
614 if repr(ss_type).find('Matrice') != -1 :
619 """Méthode booléenne qui retourne 1 si l'objet pointé par self
620 attend un objet de type ASSD ou dérivé, 0 sinon """
621 return self.object.wait_assd()
623 def wait_assd_or_type_base(self) :
625 if len(self.object.definition.type) > 1 :
626 if self.wait_reel() :
628 if 'I' in self.object.definition.type :
632 def wait_Salome(self):
633 type = self.object.definition.type[0]
634 if 'grma' in repr(type) : return True
635 if 'grno' in repr(type) : return True
636 if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
641 Retourne le type de valeur attendu par l'objet représenté par l'item.
643 return self.object.get_type()
645 #-----------------------------------------------------
647 # Methodes liees a l evaluation de la valeur saisie
649 #-----------------------------------------------------
655 def eval_valeur(self,valeur):
656 """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
657 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
658 - retourne 'valeur' (chaine de caractéres) sinon
660 newvaleur=self.eval_val(valeur)
663 def eval_valeur_BAK(self,valeur):
664 """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
665 de l'objet pointé par self :
666 - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
667 - retourne 'valeur' (chaine de caractéres) sinon
668 - retourne None en cas d invalidite
669 - retourne invalide si 1 des objets du tuple l est
672 if type(valeur) in (types.ListType,types.TupleType) :
675 newvaleur,validiteitem=self.eval_valeur_item(item)
676 valeurretour.append(newvaleur)
677 if validiteitem == 0:
680 valeurretour,validite= self.eval_valeur_item(valeur)
683 return valeurretour,validite
685 def eval_valeur_item(self,valeur):
686 """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
687 - va retourner la valeur de retour et la validite
688 selon le type de l objet attendu
689 - traite les reels et les parametres
691 #print "eval_valeur_item",valeur
692 if valeur==None or valeur == "" :
696 valeurinter = self.traite_reel(valeur)
697 if valeurinter != None :
698 valeurretour,validite= self.object.eval_valeur(valeurinter)
700 valeurretour,validite= self.object.eval_valeur(valeur)
701 elif self.wait_geom():
702 valeurretour,validite = valeur,1
704 valeurretour,validite= self.object.eval_valeur(valeur)
705 #print "eval_valeur_item",valeurretour,validite
708 if type(valeur) == types.StringType and self.object.wait_TXM():
709 essai_valeur="'" + valeur + "'"
710 valeurretour,validite= self.object.eval_valeur(essai_valeur)
712 if hasattr(valeurretour,'__class__'):
713 #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
714 if valeurretour.__class__.__name__ in ('PARAMETRE',):
718 # CCAR : il ne faut pas essayer de creer un concept
719 # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
721 #valeurretour=Accas.CO(valeur)
725 # on est dans le cas ou on a évalué et ou on n'aurait pas du
726 if self.object.wait_TXM() :
727 if type(valeurretour) != types.StringType:
728 valeurretour=str(valeur)
730 return valeurretour,validite
732 def is_CO(self,valeur=None):
734 Indique si valeur est un concept produit de la macro
735 Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
736 Si valeur vaut None on teste la valeur du mot cle
738 # Pour savoir si un concept est un nouveau concept de macro
739 # on regarde s'il est présent dans l'attribut sdprods de l'étape
740 # ou si son nom de classe est CO.
741 # Il faut faire les 2 tests car une macro non valide peut etre
742 # dans un etat pas tres catholique avec des CO pas encore types
743 # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
744 if not valeur:valeur=self.object.valeur
745 if valeur in self.object.etape.sdprods:return 1
746 if type(valeur) is not types.InstanceType:return 0
747 if valeur.__class__.__name__ == 'CO':return 1
750 def is_param(self,valeur) :
751 for param in self.jdc.params:
752 if (repr(param) == valeur):
756 def traite_reel(self,valeur):
758 Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
759 ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
762 valeur = string.strip(valeur)
763 liste_reels = self.get_sd_avant_du_bon_type()
764 if valeur in liste_reels:
766 if len(valeur) >= 3 :
767 if valeur[0:4] == 'EVAL' :
768 # on a trouvé un EVAL --> on retourne directement la valeur
770 if string.find(valeur,'.') == -1 :
771 # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
772 if (self.is_param(valeur)):
775 if string.find(valeur,'e') != -1:
776 # Notation scientifique ?
789 treeitem = SIMPTreeItem