Editeur/composimp.py

   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.
   9 #
  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.
  14 #
  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.
  18 #
  19 #
  20 # ======================================================================
  21 # Modules Python
  22 import string,types,os
  23 from Tkinter import *
  24 import Pmw
  25 from copy import copy,deepcopy
  26 import traceback
  27
  28 # Modules Eficas
  29 import Objecttreeitem
  30 import prefs
  31 import panels
  32 import images
  33 from widgets import ListeChoix
  34 from widgets import FenetreDeSelection
  35
  36 from Noyau.N_CR import justify_text
  37 from utils import substract_list
  38
  39
  40 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
  41   from newsimppanel import newSIMPPanel
  42   panel = newSIMPPanel
  43
  44   def init(self) :
  45       self.expandable = 0
  46       self.affect_panel()
  47
  48
  49   def affect_panel(self):
  50       """
  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
  53       """
  54       from uniquepanel import UNIQUE_Panel
  55       from plusieurspanel import PLUSIEURS_Panel
  56
  57       #print "affect_panel : ",self.nom,self.is_list(),self.has_into()
  58       # Attention l ordre des if est important
  59
  60       if self.wait_shell():
  61           # l'objet attend un shell
  62           from shellpanel import SHELLPanel
  63           self.panel = SHELLPanel
  64       elif self.has_into():
  65           # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
  66           if self.is_list() :
  67              from plusieursintopanel import PLUSIEURS_INTO_Panel
  68              self.panel = PLUSIEURS_INTO_Panel
  69           else:
  70              from uniqueintopanel import UNIQUE_INTO_Panel
  71              self.panel = UNIQUE_INTO_Panel
  72       else:
  73           # l'objet prend une ou des valeurs à priori quelconques
  74           if self.is_list() :
  75               # on attend une liste de valeurs mais de quel type ?
  76               if self.wait_assd():
  77                   # on attend une liste de SD
  78                   from plusieursassdpanel import PLUSIEURS_ASSD_Panel
  79                   self.panel = PLUSIEURS_ASSD_Panel
  80               else:
  81                   # on attend une liste de valeurs de types debase (entiers, réels,...)
  82                   #from plusieursbasepanel import PLUSIEURS_BASE_OR_UNELISTE_Panel
  83                   #self.panel = PLUSIEURS_BASE_OR_UNELISTE_Panel
  84                   from plusieursbasepanel import PLUSIEURS_BASE_Panel
  85                   self.panel = PLUSIEURS_BASE_Panel
  86           else:
  87               # on n'attend qu'une seule valeur mais de quel type ?
  88               if self.wait_co():
  89                   # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
  90                   from uniquesdcopanel import UNIQUE_SDCO_Panel
  91                   self.panel = UNIQUE_SDCO_Panel
  92               elif self.wait_assd():
  93                   # on attend une SD
  94                   from uniqueassdpanel import UNIQUE_ASSD_Panel
  95                   from uniqueassdpanel import UNIQUE_ASSD_Panel_Reel
  96                   if 'R' in self.GetType():
  97                      self.panel = UNIQUE_ASSD_Panel_Reel
  98                   else :
  99                      self.panel = UNIQUE_ASSD_Panel
 100               else:
 101                   # on attend une valeur d'un type de base (entier,réel,...)
 102                   if self.wait_complex():
 103                       # on attend un complexe
 104                       from uniquecomppanel import UNIQUE_COMP_Panel
 105                       self.panel = UNIQUE_COMP_Panel
 106                   else:
 107                       # on attend un entier, un réel ou une string
 108                       from uniquebasepanel import UNIQUE_BASE_Panel
 109                       self.panel = UNIQUE_BASE_Panel
 110       # cas particulier des fonctions
 111       genea = self.get_genealogie()
 112       if "VALE" in genea or "VALE_C" in genea:
 113          if "DEFI_FONCTION" in genea :
 114             from fonctionpanel import FONCTION_Panel
 115             self.panel=FONCTION_Panel
 116       #---------------------------------------------------------
 117       # PN ajout pour lancement de Salome
 118       #---------------------------------------------------------
 119       if hasattr( self.appli, 'salome' ):
 120           import panelsSalome
 121
 122           self.select_noeud_maille=0
 123           self.clef_fonction="SALOME"
 124           for i in range(0,len( genea )) :
 125              self.clef_fonction=self.clef_fonction+"_"+ genea[i]
 126              #if genea[i] == "GROUP_NO" or genea[i] == "GROUP_MA":
 127           if "GROUP_NO" in genea[len(genea)-1] or "GROUP_MA" in genea[len(genea)-1]:
 128              self.select_noeud_maille=1
 129
 130           recherche=panelsSalome.dict_classes_salome[self.panel]
 131           if hasattr(recherche,self.clef_fonction):
 132              self.panel=recherche
 133           if self.select_noeud_maille==1 :
 134              self.panel=recherche
 135
 136
 137   #-----------------------------------------------
 138   #
 139   # Methodes liees aux informations sur le Panel
 140   # ou au mot-clef simple
 141   #
 142   #-----------------------------------------------
 143   # is_list
 144   # get_into                a priori inutile --> commentee
 145   # has_into
 146   # wait_into                a priori inutile --> commentee
 147   # GetMinMax
 148   # GetMultiplicite
 149   # GetIntervalle
 150   # GetListeValeurs
 151   # get_liste_possible
 152
 153   def is_list(self):
 154       """
 155           Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
 156           ou s'il n'en attend pas (valeur de retour 0)
 157
 158           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 159           Dans le cas sans validateur, l'information est donnée par l'attribut max
 160           de la definition du mot cle.
 161           Dans le cas avec validateur, il faut combiner l'information précédente avec
 162           celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
 163           l'operateur ET pour effectuer cette combinaison (AndVal).
 164       """
 165       is_a_list=0
 166       min,max = self.GetMinMax()
 167       assert (min <= max)
 168       if max > 1 :
 169                 is_a_list=1
 170       # Dans le cas avec validateurs, pour que le mot cle soit considéré
 171       # comme acceptant une liste, il faut que max soit supérieur a 1
 172       # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
 173       # on retournera 0 (n'attend pas de liste)
 174       if self.definition.validators :
 175          is_a_list= self.definition.validators.is_list() * is_a_list
 176       return is_a_list
 177
 178   #def get_into(self,liste_courante=None):
 179   #    """
 180   #        Cette méthode retourne la liste de choix proposée par le mot cle. Si le mot cle ne propose
 181   #        pas de liste de choix, la méthode retourne None.
 182   #        L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déjà
 183   #        effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
 184   #        en en tenant compte.
 185   #        Cette méthode part du principe que la relation entre into du mot clé et les validateurs est
 186   #        une relation de type ET (AndVal).
 187   #    """
 188   #    if not self.object.definition.validators :
 189   #       return self.object.definition.into
 190   #    else:
 191   #       return self.object.definition.validators.get_into(liste_courante,self.definition.into)
 192
 193   def has_into(self):
 194       """
 195           Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
 196           ou s'il n'en propose pas (valeur de retour 0)
 197
 198           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 199           Dans le cas sans validateur, l'information est donnée par l'attribut into
 200           de la definition du mot cle.
 201           Dans le cas avec validateurs, pour que le mot cle soit considéré
 202           comme proposant un choix, il faut que into soit présent OU
 203           que la méthode has_into du validateur retourne 1. Dans les autres cas
 204           on retournera 0 (ne propose pas de choix)
 205       """
 206       has_an_into=0
 207       if self.definition.into:
 208                has_an_into=1
 209       elif self.definition.validators :
 210          has_an_into= self.definition.validators.has_into()
 211       return has_an_into
 212
 213 #  def wait_into(self):
 214 #      """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 215 #      prend ses valeurs dans un ensemble discret (into), 0 sinon """
 216 #      if self.object.definition.into != None :
 217 #          return 1
 218 #      else:
 219 #          return 0
 220
 221   def GetMinMax(self):
 222       """ Retourne les valeurs min et max de la définition de object """
 223       return self.object.get_min_max()
 224
 225   def GetMultiplicite(self):
 226       """ A préciser.
 227           Retourne la multiplicité des valeurs affectées à l'objet
 228           représenté par l'item. Pour le moment retourne invariablement 1.
 229       """
 230       return 1
 231
 232   def GetIntervalle(self):
 233       """
 234            Retourne le domaine de valeur attendu par l'objet représenté
 235            par l'item.
 236       """
 237       return self.object.getintervalle()
 238
 239   def GetListeValeurs(self) :
 240       """ Retourne la liste des valeurs de object """
 241       valeurs=self.object.get_liste_valeurs()
 242       try :
 243         if "R" in self.object.definition.type:
 244            clef=self.object.GetNomConcept()
 245            if self.appli.dict_reels.has_key(clef):
 246               if type(valeurs) == types.TupleType:
 247                  valeurs_reelles=[]
 248                  for val in valeurs :
 249                     if self.appli.dict_reels[clef].has_key(val) :
 250                        valeurs_reelles.append(self.appli.dict_reels[clef][val])
 251                     else :
 252                        valeurs_reelles.append(val)
 253               else :
 254                  if self.appli.dict_reels[clef].has_key(valeurs):
 255                     valeurs_reelles=self.appli.dict_reels[clef][valeurs]
 256               valeurs=valeurs_reelles
 257       except :
 258         pass
 259       return valeurs
 260
 261   def get_liste_possible(self,listeActuelle=[]):
 262       if hasattr(self.definition.validators,'into'):
 263          valeurspossibles = self.definition.validators.into
 264       else:
 265          valeurspossibles = self.get_definition().into
 266
 267       #On ne garde que les items valides
 268       listevalideitem=[]
 269       for item in valeurspossibles:
 270           encorevalide=self.valide_item(item)
 271           if encorevalide :
 272              listevalideitem.append(item)
 273
 274       #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
 275       listevalideliste=[]
 276       for item in listevalideitem:
 277           encorevalide=self.valide_liste_partielle(item,listeActuelle)
 278           if encorevalide :
 279               listevalideliste.append(item)
 280       return listevalideliste
 281
 282   def get_liste_param_possible(self):
 283       liste_param=[]
 284       for param in self.object.jdc.params:
 285           encorevalide=self.valide_item(param.valeur)
 286           if encorevalide:
 287              type_param=param.valeur.__class__.__name__
 288              for typ in self.definition.type:
 289                  if typ=='R':
 290                      liste_param.append(param)
 291                  if typ=='I' and type_param=='int':
 292                      liste_param.append(param)
 293                  if typ=='TXM' and type_param=='str':
 294                      liste_param.append(repr(param))
 295       return liste_param
 296
 297   #--------------------------------------------------
 298   #
 299   # Methodes liees a la validite des valeurs saisies
 300   #
 301   #---------------------------------------------------
 302   # valide_item
 303   # valide_liste_partielle
 304   # valide_liste_complete
 305   # info_erreur_item
 306   # info_erreur_liste
 307   # IsInIntervalle
 308   # isvalid
 309
 310   def valide_item(self,item):
 311       """
 312         La validation est réalisée directement par l'objet
 313       """
 314       return self.object.valide_item(item)
 315
 316   def valide_liste_partielle(self,item,listecourante):
 317       #On protege la liste en entree en la copiant
 318       valeur=listecourante[:]
 319       valeur.append(item)
 320       return self.object.valid_valeur_partielle(valeur)
 321
 322   def valide_liste_complete (self,valeur):
 323       return self.object.valid_valeur(valeur)
 324
 325   def valide_val (self,valeur):
 326       return self.object.valid_val(valeur)
 327
 328   def info_erreur_item(self) :
 329       commentaire=""
 330       if self.definition.validators :
 331          commentaire=self.definition.validators.info_erreur_item()
 332       return commentaire
 333
 334   def aide(self) :
 335       commentaire=""
 336       if self.definition.validators :
 337          commentaire=self.definition.validators.aide()
 338       return commentaire
 339
 340   def info_erreur_liste(self) :
 341       commentaire=""
 342       if self.definition.validators :
 343          commentaire=self.definition.validators.info_erreur_liste()
 344       return commentaire
 345
 346   def IsInIntervalle(self,valeur):
 347       """
 348           Retourne 1 si la valeur est dans l'intervalle permis par
 349           l'objet représenté par l'item.
 350       """
 351       return self.valide_item(valeur)
 352
 353   def isvalid(self):
 354     valide=self.object.isvalid()
 355     return valide
 356
 357   #--------------------------------------------------
 358   #
 359   # Autres ...
 360   #
 361   #---------------------------------------------------
 362   # SetText         a priori inutilisee --> commentee
 363   # GetIconName
 364   # GetText
 365   # getval     a  priori inutilisee --> commentee
 366   # set_valeur_co
 367   # get_sd_avant_du_bon_type
 368   # verif        a  priori inutilisee --> commentee
 369   # delete_valeur_co
 370
 371   #def SetText(self, text):
 372   #  try:
 373   #    value = eval(text)
 374   #    self.object.setval(value)
 375   #  except:
 376   #    pass
 377
 378   def GetIconName(self):
 379     if self.isvalid():
 380       return "ast-green-ball"
 381     elif self.object.isoblig():
 382       return "ast-red-ball"
 383     else:
 384       return "ast-yel-ball"
 385
 386   def GetText(self):
 387     """
 388     Classe SIMPTreeItem
 389     Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
 390     pointé par self
 391     """
 392     text= self.object.GetText()
 393     return text
 394
 395   #def getval(self):
 396   #    return self.object.getval()
 397
 398   def set_valeur_co(self,nom_co):
 399       """
 400       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
 401       """
 402       ret = self.object.set_valeur_co(nom_co)
 403       #print "set_valeur_co",ret
 404       return ret
 405
 406   def get_sd_avant_du_bon_type(self):
 407       """
 408       Retourne la liste des noms des SD présentes avant l'étape qui contient
 409       le MCS pointé par self et du type requis par ce MCS
 410       """
 411       a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
 412       return a
 413
 414   def get_sd_avant_du_bon_type_pour_type_de_base(self):
 415       a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
 416       return a
 417
 418
 419
 420   #def verif(self):
 421   #    pass
 422
 423   def delete_valeur_co(self,valeur=None):
 424       """
 425            Supprime la valeur du mot cle (de type CO)
 426            il faut propager la destruction aux autres etapes
 427       """
 428       if not valeur : valeur=self.object.valeur
 429       # XXX faut il vraiment appeler del_sdprod ???
 430       #self.object.etape.parent.del_sdprod(valeur)
 431       self.object.etape.parent.delete_concept(valeur)
 432
 433   #-----------------------------------------------
 434   #
 435   # Methodes liees au type de l objet attendu
 436   #
 437   #-----------------------------------------------
 438   # wait_co
 439   # wait_geom
 440   # wait_complex
 441   # wait_reel
 442   # wait_shell
 443   # wait_assd
 444   # GetType
 445
 446   def wait_co(self):
 447       """
 448       Méthode booléenne qui retourne 1 si l'objet pointé par self
 449       attend un objet de type ASSD qui n'existe pas encore (type CO()),
 450       0 sinon
 451       """
 452       return self.object.wait_co()
 453
 454   def wait_geom(self):
 455       """
 456       Méthode booléenne qui retourne 1 si l'objet pointé par self
 457       attend un objet GEOM, 0 sinon
 458       """
 459       return self.object.wait_geom()
 460
 461   def wait_complex(self):
 462       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 463       attend un complexe, 0 sinon """
 464       if 'C' in self.object.definition.type:
 465           return 1
 466       else:
 467           return 0
 468
 469   def wait_reel(self):
 470       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 471       attend un réel, 0 sinon """
 472       if 'R' in self.object.definition.type:
 473           return 1
 474       else:
 475           return 0
 476
 477   def wait_shell(self):
 478       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 479       attend un shell, 0 sinon """
 480       if 'shell' in self.object.definition.type:
 481           return 1
 482       else:
 483           return 0
 484
 485   def wait_assd(self):
 486       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 487       attend un objet de type ASSD ou dérivé, 0 sinon """
 488       return self.object.wait_assd()
 489
 490   def wait_assd_or_type_base(self) :
 491       boo=0
 492       if len(self.object.definition.type) > 1 :
 493          if self.wait_reel() :
 494             boo = 1
 495          if 'I' in self.object.definition.type :
 496             boo = 1
 497       return boo
 498
 499
 500   def GetType(self):
 501       """
 502           Retourne le type de valeur attendu par l'objet représenté par l'item.
 503       """
 504       return self.object.get_type()
 505
 506   #-----------------------------------------------------
 507   #
 508   # Methodes liees  a l evaluation de la valeur saisie
 509   #
 510   #-----------------------------------------------------
 511   # eval_valeur
 512   # eval_valeur_item
 513   # is_CO
 514   # traite_reel
 515
 516   def eval_valeur(self,valeur):
 517       """ Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur de self :
 518              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 519              - retourne 'valeur' (chaîne de caractères) sinon
 520       """
 521       newvaleur=self.eval_val(valeur)
 522       return newvaleur,1
 523
 524   def eval_valeur_BAK(self,valeur):
 525       """ Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur
 526       de l'objet pointé par self :
 527         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 528         - retourne 'valeur' (chaîne de caractères) sinon
 529         - retourne None en cas d invalidite
 530         - retourne invalide si 1 des objets du tuple l est
 531       """
 532       validite=1
 533       if type(valeur) in (types.ListType,types.TupleType) :
 534          valeurretour=[]
 535          for item in valeur :
 536              newvaleur,validiteitem=self.eval_valeur_item(item)
 537              valeurretour.append(newvaleur)
 538              if validiteitem == 0:
 539                 validite=0
 540       else :
 541          valeurretour,validite= self.eval_valeur_item(valeur)
 542       if validite == 0 :
 543          valeurretour = None
 544       return valeurretour,validite
 545
 546   def eval_valeur_item(self,valeur):
 547       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 548           - va retourner la valeur de retour et la validite
 549             selon le type de l objet attendu
 550           - traite les reels et les parametres
 551       """
 552       #print "eval_valeur_item",valeur
 553       if valeur==None or valeur == "" :
 554          return None,0
 555       validite=1
 556       if self.wait_reel():
 557              valeurinter = self.traite_reel(valeur)
 558              if valeurinter != None :
 559                 valeurretour,validite= self.object.eval_valeur(valeurinter)
 560              else:
 561                 valeurretour,validite= self.object.eval_valeur(valeur)
 562       elif self.wait_geom():
 563              valeurretour,validite = valeur,1
 564       else :
 565              valeurretour,validite= self.object.eval_valeur(valeur)
 566       #print "eval_valeur_item",valeurretour,validite
 567
 568       if validite == 0:
 569          if type(valeur) == types.StringType and self.object.wait_TXM():
 570             essai_valeur="'" + valeur + "'"
 571             valeurretour,validite= self.object.eval_valeur(essai_valeur)
 572
 573       if hasattr(valeurretour,'__class__'):
 574          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 575          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 576             validite=1
 577
 578       #if self.wait_co():
 579          # CCAR : il ne faut pas essayer de creer un concept
 580          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
 581          #try:
 582             #valeurretour=Accas.CO(valeur)
 583          #except:
 584             #valeurretour=None
 585             #validite=0
 586       # on est dans le cas où on a évalué et où on n'aurait pas du
 587       if self.object.wait_TXM() :
 588           if type(valeurretour) != types.StringType:
 589              valeurretour=str(valeur)
 590              validite=1
 591       return valeurretour,validite
 592
 593   def is_CO(self,valeur=None):
 594       """
 595          Indique si valeur est un concept produit de la macro
 596          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 597          Si valeur vaut None on teste la valeur du mot cle
 598       """
 599       # Pour savoir si un concept est un nouveau concept de macro
 600       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 601       # ou si son nom de classe est CO.
 602       # Il faut faire les 2 tests car une macro non valide peut etre
 603       # dans un etat pas tres catholique avec des CO pas encore types
 604       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
 605       if not valeur:valeur=self.object.valeur
 606       if valeur in self.object.etape.sdprods:return 1
 607       if type(valeur) is not types.InstanceType:return 0
 608       if valeur.__class__.__name__ == 'CO':return 1
 609       return 0
 610
 611   def is_param(self,valeur) :
 612       for param in self.jdc.params:
 613           if (repr(param) == valeur):
 614              return 1
 615       return 0
 616
 617   def traite_reel(self,valeur):
 618       """
 619       Cette fonction a pour but de rajouter le '.' en fin de chaîne pour un réel
 620       ou de détecter si on fait référence à un concept produit par DEFI_VALEUR
 621       ou un EVAL ...
 622       """
 623       valeur = string.strip(valeur)
 624       liste_reels = self.get_sd_avant_du_bon_type()
 625       if valeur in liste_reels:
 626           return valeur
 627       if len(valeur) >= 3 :
 628           if valeur[0:4] == 'EVAL' :
 629               # on a trouvé un EVAL --> on retourne directement la valeur
 630               return valeur
 631       if string.find(valeur,'.') == -1 :
 632           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un à la fin
 633           if (self.is_param(valeur)):
 634               return valeur
 635           else:
 636               if string.find(valeur,'e') != -1:
 637                  # Notation scientifique ?
 638                  try :
 639                     r=eval(valeur)
 640                     return valeur
 641                  except :
 642                     return None
 643               else :
 644                  return valeur+'.'
 645       else:
 646           return valeur
 647
 648
 649 import Accas
 650 treeitem = SIMPTreeItem
 651 objet = Accas.MCSIMP
 652