InterfaceQT4/composimp.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   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.
   8 #
   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.
  13 #
  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
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 # Modules Python
  21 import string,types,os
  22
  23 from copy import copy,deepcopy
  24 import traceback
  25 import typeNode
  26
  27 # Modules Eficas
  28 from Editeur import Objecttreeitem
  29 import browser
  30 from Noyau.N_CR   import justify_text
  31 from Accas        import SalomeEntry
  32
  33 class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
  34     def getPanel(self):
  35         """
  36         """
  37         klass = None
  38         # Attention l ordre des if est important
  39
  40         if self.item.wait_matrice ():
  41                 from monMatricePanel import MonMatricePanel
  42                 klass=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
  48             else:
  49                 from monUniqueIntoPanel import MonUniqueIntoPanel
  50                 klass = MonUniqueIntoPanel
  51
  52         # l'objet prend une ou des valeurs a priori quelconques
  53         else:
  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
  63                 else:
  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
  68             else:
  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
  74                     else :
  75                        from monUniqueSDCOPanel import MonUniqueSDCOPanel
  76                        klass = MonUniqueSDCOPanel
  77
  78                 # on attend une SD
  79                 elif self.item.wait_assd():
  80                     if 'R' in self.item.GetType():
  81                         from monUniqueASSDPanel import MonUniqueASSDReelPanel
  82                         klass = MonUniqueASSDReelPanel
  83                     else :
  84                         from monUniqueASSDPanel import MonUniqueASSDPanel
  85                         klass = MonUniqueASSDPanel
  86
  87                 # on attend une valeur d'un type de base (entier,reel,...)
  88                 else:
  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
  96                      else :
  97                         from monUniqueBasePanel import MonUniqueBasePanel
  98                         klass = MonUniqueBasePanel
  99
 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
 106
 107         if not klass:
 108             return None
 109         return klass( self, self.editor )
 110
 111
 112     def createPopUpMenu(self):
 113         typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
 114
 115
 116     def getPanelGroupe(self,parentQt,commande):
 117         maDefinition=self.item.get_definition()
 118         monObjet=self.item.object
 119         monNom=self.item.nom
 120         maCommande=commande
 121
 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
 126
 127         #print "____________________________", self.item.wait_tuple()
 128         if maDefinition.max == 1 :
 129           if maDefinition.into != [] and maDefinition.into != None:
 130           # a revoir
 131             if len(maDefinition.into) < 4 :
 132               from monWidgetRadioButton import MonWidgetRadioButton
 133               widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 134             elif len(maDefinition.into) < 7 :
 135               from monWidget4a6RadioButton import MonWidget4a6RadioButton
 136               widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 137             else :
 138               from monWidgetCB import MonWidgetCB
 139               widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 140
 141           elif self.item.wait_bool() :
 142             from monWidgetSimpBool import MonWidgetSimpBool
 143             widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 144
 145           elif self.item.wait_fichier():
 146             from monWidgetSimpFichier import MonWidgetSimpFichier
 147             widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 148
 149           elif self.item.wait_tuple() :
 150           # Pas fait
 151             if self.item.object.definition.type[0].ntuple == 2:
 152                from monWidgetSimpTuple2 import MonWidgetSimpTuple2
 153                widget=MonWidgetSimpTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 154             elif self.item.object.definition.type[0].ntuple == 3 :
 155                from monWidgetSimpTuple3 import MonWidgetSimpTuple3
 156                widget=MonWidgetSimpTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 157             else :
 158                print "Pas fait"
 159
 160           elif self.item.wait_complex():
 161           # Pas fait
 162             from monWidgetSimpComplexe import MonWidgetSimpComplexe
 163             widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 164
 165           elif self.item.wait_co():
 166           # Pas fait
 167             from monWidgetSimpASSD import MonWidgetSimpASSD
 168             widget=MonWidgetSimpASSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 169
 170           elif  self.item.wait_Salome() and self.editor.salome:
 171           # Pas fait
 172             from monWidgetSimpSalome import MonWidgetSimpSalome
 173             widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 174
 175           elif self.item.wait_TXM():
 176           # Pas fait
 177             from monWidgetSimpTxt import MonWidgetSimpTxt
 178             widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 179           else :
 180             from monWidgetSimpBase import MonWidgetSimpBase
 181             widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 182
 183         else :
 184           if maDefinition.into != [] and maDefinition.into != None:
 185              #Pas encore traité
 186             from monWidgetPlusieursInto import MonWidgetPlusieursInto
 187             widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 188           else :
 189             from monWidgetPlusieursBase import MonWidgetPlusieursBase
 190             widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 191         return widget
 192
 193
 194 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
 195   itemNode=Node
 196
 197   def init(self) :
 198       self.expandable = 0
 199
 200
 201   #-----------------------------------------------
 202   #
 203   # Methodes liees aux informations sur le Panel
 204   # ou au mot-clef simple
 205   #
 206   #-----------------------------------------------
 207   # is_list
 208   # get_into                a priori inutile --> commentee
 209   # has_into
 210   # wait_into                a priori inutile --> commentee
 211   # GetMinMax
 212   # GetMultiplicite
 213   # GetIntervalle
 214   # GetListeValeurs
 215   # get_liste_possible
 216
 217   def is_list(self):
 218       """
 219           Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
 220           ou s'il n'en attend pas (valeur de retour 0)
 221
 222           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 223           Dans le cas sans validateur, l'information est donnee par l'attribut max
 224           de la definition du mot cle.
 225           Dans le cas avec validateur, il faut combiner l'information precedente avec
 226           celle issue de l'appel de la methode is_list sur le validateur.On utilisera
 227           l'operateur ET pour effectuer cette combinaison (AndVal).
 228       """
 229       is_a_list=0
 230       min,max = self.GetMinMax()
 231       assert (min <= max)
 232       if max > 1 :
 233                 is_a_list=1
 234       # Dans le cas avec validateurs, pour que le mot cle soit considere
 235       # comme acceptant une liste, il faut que max soit superieur a 1
 236       # ET que la methode is_list du validateur retourne 1. Dans les autres cas
 237       # on retournera 0 (n'attend pas de liste)
 238       if self.definition.validators :
 239          is_a_list= self.definition.validators.is_list() * is_a_list
 240       return is_a_list
 241
 242
 243   def has_into(self):
 244       """
 245           Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
 246           ou s'il n'en propose pas (valeur de retour 0)
 247
 248           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 249           Dans le cas sans validateur, l'information est donnee par l'attribut into
 250           de la definition du mot cle.
 251           Dans le cas avec validateurs, pour que le mot cle soit considere
 252           comme proposant un choix, il faut que into soit present OU
 253           que la methode has_into du validateur retourne 1. Dans les autres cas
 254           on retournera 0 (ne propose pas de choix)
 255       """
 256       has_an_into=0
 257       if self.definition.into:
 258                has_an_into=1
 259       elif self.definition.validators :
 260          has_an_into= self.definition.validators.has_into()
 261       return has_an_into
 262
 263
 264   def GetMinMax(self):
 265       """ Retourne les valeurs min et max de la definition de object """
 266       return self.object.get_min_max()
 267
 268   def GetMultiplicite(self):
 269       """ A preciser.
 270           Retourne la multiplicite des valeurs affectees a l'objet
 271           represente par l'item. Pour le moment retourne invariablement 1.
 272       """
 273       return 1
 274
 275   def GetIntervalle(self):
 276       """
 277            Retourne le domaine de valeur attendu par l'objet represente
 278            par l'item.
 279       """
 280       return self.object.getintervalle()
 281
 282   def GetListeValeurs(self) :
 283       """ Retourne la liste des valeurs de object """
 284       valeurs=self.object.get_liste_valeurs()
 285       try :
 286         if "R" in self.object.definition.type:
 287            clef=self.object.GetNomConcept()
 288            if self.appli.dict_reels.has_key(clef):
 289               if type(valeurs) == types.TupleType:
 290                  valeurs_reelles=[]
 291                  for val in valeurs :
 292                     if self.appli.dict_reels[clef].has_key(val) :
 293                        valeurs_reelles.append(self.appli.dict_reels[clef][val])
 294                     else :
 295                        valeurs_reelles.append(val)
 296               else :
 297                  if self.appli.dict_reels[clef].has_key(valeurs):
 298                     valeurs_reelles=self.appli.dict_reels[clef][valeurs]
 299               valeurs=valeurs_reelles
 300       except :
 301         pass
 302       return valeurs
 303
 304   def get_liste_possible(self,listeActuelle=[]):
 305       if hasattr(self.definition.validators,'into'):
 306          valeurspossibles = self.definition.validators.into
 307       else:
 308          valeurspossibles = self.get_definition().into
 309
 310       #On ne garde que les items valides
 311       listevalideitem=[]
 312       if type(valeurspossibles) in (types.ListType,types.TupleType) :
 313          pass
 314       else :
 315          valeurspossibles=(valeurspossibles,)
 316       for item in valeurspossibles:
 317           encorevalide=self.valide_item(item)
 318           if encorevalide :
 319              listevalideitem.append(item)
 320
 321       #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
 322       listevalideliste=[]
 323       for item in listevalideitem:
 324           encorevalide=self.valide_liste_partielle(item,listeActuelle)
 325           if encorevalide :
 326               listevalideliste.append(item)
 327       return listevalideliste
 328
 329   def get_liste_param_possible(self):
 330       liste_param=[]
 331       l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
 332       for param in self.object.jdc.params:
 333           if param.nom not in l1 : continue
 334           encorevalide=self.valide_item(param.valeur)
 335           if encorevalide:
 336              type_param=param.valeur.__class__.__name__
 337              for typ in self.definition.type:
 338                  if typ=='R':
 339                      liste_param.append(param)
 340                  if typ=='I' and type_param=='int':
 341                      liste_param.append(param)
 342                  if typ=='TXM' and type_param=='str':
 343                      liste_param.append(repr(param))
 344                  if ('grma' in repr(typ)) and type_param=='str':
 345                      liste_param.append(param.nom)
 346       return liste_param
 347
 348   #--------------------------------------------------
 349   #
 350   # Methodes liees a la validite des valeurs saisies
 351   #
 352   #---------------------------------------------------
 353   # valide_item
 354   # valide_liste_partielle
 355   # valide_liste_complete
 356   # info_erreur_item
 357   # info_erreur_liste
 358   # IsInIntervalle
 359   # isvalid
 360
 361   def valide_item(self,item):
 362       """
 363         La validation est realisee directement par l'objet
 364       """
 365       return self.object.valide_item(item)
 366
 367   def valide_liste_partielle(self,item,listecourante):
 368       #On protege la liste en entree en la copiant
 369       valeur=listecourante[:]
 370       valeur.append(item)
 371       return self.object.valid_valeur_partielle(valeur)
 372
 373   def valide_liste_complete (self,valeur):
 374       return self.object.valid_valeur(valeur)
 375
 376   def valide_val (self,valeur):
 377       return self.object.valid_val(valeur)
 378
 379   def info_erreur_item(self) :
 380       commentaire=""
 381       if self.definition.validators :
 382          commentaire=self.definition.validators.info_erreur_item()
 383       return commentaire
 384
 385   def aide(self) :
 386       commentaire=""
 387       if self.definition.validators :
 388          commentaire=self.definition.validators.aide()
 389       return commentaire
 390
 391   def info_erreur_liste(self) :
 392       commentaire=""
 393       if self.definition.validators :
 394          commentaire=self.definition.validators.info_erreur_liste()
 395       return commentaire
 396
 397   def IsInIntervalle(self,valeur):
 398       """
 399           Retourne 1 si la valeur est dans l'intervalle permis par
 400           l'objet represente par l'item.
 401       """
 402       return self.valide_item(valeur)
 403
 404   def isvalid(self):
 405     valide=self.object.isvalid()
 406     return valide
 407
 408   #--------------------------------------------------
 409   #
 410   # Autres ...
 411   #
 412   #---------------------------------------------------
 413   # GetIconName
 414   # GetText
 415   # set_valeur_co
 416   # get_sd_avant_du_bon_type
 417   # delete_valeur_co
 418
 419
 420   def GetIconName(self):
 421     if self.isvalid():
 422       return "ast-green-ball"
 423     elif self.object.isoblig():
 424       return "ast-red-ball"
 425     else:
 426       return "ast-yel-ball"
 427     print "invalide"
 428
 429   def GetText(self):
 430     """
 431     Classe SIMPTreeItem
 432     Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
 433     pointe par self
 434     """
 435     text= self.object.GetText()
 436     if text == None : text=""
 437     return text
 438
 439
 440   def set_valeur_co(self,nom_co):
 441       """
 442       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
 443       """
 444       ret = self.object.set_valeur_co(nom_co)
 445       #print "set_valeur_co",ret
 446       return ret
 447
 448   def get_sd_avant_du_bon_type(self):
 449       """
 450       Retourne la liste des noms des SD présentes avant l'étape qui contient
 451       le MCS pointé par self et du type requis par ce MCS
 452       """
 453       a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
 454       return a
 455
 456   def get_sd_avant_du_bon_type_pour_type_de_base(self):
 457       a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
 458       return a
 459
 460
 461
 462
 463   def delete_valeur_co(self,valeur=None):
 464       """
 465            Supprime la valeur du mot cle (de type CO)
 466            il faut propager la destruction aux autres etapes
 467       """
 468       if not valeur : valeur=self.object.valeur
 469       # XXX faut il vraiment appeler del_sdprod ???
 470       #self.object.etape.parent.del_sdprod(valeur)
 471       self.object.etape.parent.delete_concept(valeur)
 472
 473   #-----------------------------------------------
 474   #
 475   # Methodes liees au type de l objet attendu
 476   #
 477   #-----------------------------------------------
 478   # wait_co
 479   # wait_geom
 480   # wait_complex
 481   # wait_reel
 482   # wait_assd
 483   # GetType
 484
 485   def wait_co(self):
 486       """
 487       Méthode booléenne qui retourne 1 si l'objet pointé par self
 488       attend un objet de type ASSD qui n'existe pas encore (type CO()),
 489       0 sinon
 490       """
 491       return self.object.wait_co()
 492
 493   def wait_fichier(self):
 494       maDefinition=self.object.definition
 495       try :
 496         if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
 497            return 1
 498       except :
 499            return 0
 500
 501   def wait_geom(self):
 502       """
 503       Méthode booléenne qui retourne 1 si l'objet pointé par self
 504       attend un objet GEOM, 0 sinon
 505       """
 506       return self.object.wait_geom()
 507
 508   def wait_complex(self):
 509       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 510       attend un complexe, 0 sinon """
 511       if 'C' in self.object.definition.type:
 512           return 1
 513       else:
 514           return 0
 515
 516   def wait_reel(self):
 517       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 518       attend un réel, 0 sinon """
 519       if 'R' in self.object.definition.type:
 520           return 1
 521       else:
 522           return 0
 523
 524   def wait_tuple(self):
 525       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 526       attend un Tuple, 0 sinon """
 527       for ss_type in self.object.definition.type:
 528           if repr(ss_type).find('Tuple') != -1 :
 529              return 1
 530       return 0
 531
 532   def wait_matrice(self):
 533       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 534       attend un Tuple, 0 sinon """
 535       for ss_type in self.object.definition.type:
 536           if repr(ss_type).find('Matrice') != -1 :
 537              return 1
 538       return 0
 539
 540   def wait_assd(self):
 541       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 542       attend un objet de type ASSD ou dérivé, 0 sinon """
 543       return self.object.wait_assd()
 544
 545   def wait_assd_or_type_base(self) :
 546       boo=0
 547       if len(self.object.definition.type) > 1 :
 548          if self.wait_reel() :
 549             boo = 1
 550          if 'I' in self.object.definition.type :
 551             boo = 1
 552       return boo
 553
 554   def wait_Salome(self):
 555       type = self.object.definition.type[0]
 556       if 'grma' in repr(type) : return True
 557       if 'grno' in repr(type) : return True
 558       if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
 559       return False
 560
 561   def GetType(self):
 562       """
 563           Retourne le type de valeur attendu par l'objet représenté par l'item.
 564       """
 565       return self.object.get_type()
 566
 567   #-----------------------------------------------------
 568   #
 569   # Methodes liees  a l evaluation de la valeur saisie
 570   #
 571   #-----------------------------------------------------
 572   # eval_valeur
 573   # eval_valeur_item
 574   # is_CO
 575   # traite_reel
 576
 577   def eval_valeur(self,valeur):
 578       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
 579              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 580              - retourne 'valeur' (chaine de caractéres) sinon
 581       """
 582       newvaleur=self.eval_val(valeur)
 583       return newvaleur,1
 584
 585   def eval_valeur_BAK(self,valeur):
 586       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
 587       de l'objet pointé par self :
 588         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 589         - retourne 'valeur' (chaine de caractéres) sinon
 590         - retourne None en cas d invalidite
 591         - retourne invalide si 1 des objets du tuple l est
 592       """
 593       validite=1
 594       if type(valeur) in (types.ListType,types.TupleType) :
 595          valeurretour=[]
 596          for item in valeur :
 597              newvaleur,validiteitem=self.eval_valeur_item(item)
 598              valeurretour.append(newvaleur)
 599              if validiteitem == 0:
 600                 validite=0
 601       else :
 602          valeurretour,validite= self.eval_valeur_item(valeur)
 603       if validite == 0 :
 604          valeurretour = None
 605       return valeurretour,validite
 606
 607   def eval_valeur_item(self,valeur):
 608       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 609           - va retourner la valeur de retour et la validite
 610             selon le type de l objet attendu
 611           - traite les reels et les parametres
 612       """
 613       #print "eval_valeur_item",valeur
 614       if valeur==None or valeur == "" :
 615          return None,0
 616       validite=1
 617       if self.wait_reel():
 618              valeurinter = self.traite_reel(valeur)
 619              if valeurinter != None :
 620                 valeurretour,validite= self.object.eval_valeur(valeurinter)
 621              else:
 622                 valeurretour,validite= self.object.eval_valeur(valeur)
 623       elif self.wait_geom():
 624              valeurretour,validite = valeur,1
 625       else :
 626              valeurretour,validite= self.object.eval_valeur(valeur)
 627       #print "eval_valeur_item",valeurretour,validite
 628
 629       if validite == 0:
 630          if type(valeur) == types.StringType and self.object.wait_TXM():
 631             essai_valeur="'" + valeur + "'"
 632             valeurretour,validite= self.object.eval_valeur(essai_valeur)
 633
 634       if hasattr(valeurretour,'__class__'):
 635          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 636          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 637             validite=1
 638
 639       #if self.wait_co():
 640          # CCAR : il ne faut pas essayer de creer un concept
 641          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
 642          #try:
 643             #valeurretour=Accas.CO(valeur)
 644          #except:
 645             #valeurretour=None
 646             #validite=0
 647       # on est dans le cas ou on a évalué et ou on n'aurait pas du
 648       if self.object.wait_TXM() :
 649           if type(valeurretour) != types.StringType:
 650              valeurretour=str(valeur)
 651              validite=1
 652       return valeurretour,validite
 653
 654   def is_CO(self,valeur=None):
 655       """
 656          Indique si valeur est un concept produit de la macro
 657          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 658          Si valeur vaut None on teste la valeur du mot cle
 659       """
 660       # Pour savoir si un concept est un nouveau concept de macro
 661       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 662       # ou si son nom de classe est CO.
 663       # Il faut faire les 2 tests car une macro non valide peut etre
 664       # dans un etat pas tres catholique avec des CO pas encore types
 665       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
 666       if not valeur:valeur=self.object.valeur
 667       if valeur in self.object.etape.sdprods:return 1
 668       if type(valeur) is not types.InstanceType:return 0
 669       if valeur.__class__.__name__ == 'CO':return 1
 670       return 0
 671
 672   def is_param(self,valeur) :
 673       for param in self.jdc.params:
 674           if (repr(param) == valeur):
 675              return 1
 676       return 0
 677
 678   def traite_reel(self,valeur):
 679       """
 680       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
 681       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
 682       ou un EVAL ...
 683       """
 684       valeur = string.strip(valeur)
 685       liste_reels = self.get_sd_avant_du_bon_type()
 686       if valeur in liste_reels:
 687           return valeur
 688       if len(valeur) >= 3 :
 689           if valeur[0:4] == 'EVAL' :
 690               # on a trouvé un EVAL --> on retourne directement la valeur
 691               return valeur
 692       if string.find(valeur,'.') == -1 :
 693           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
 694           if (self.is_param(valeur)):
 695               return valeur
 696           else:
 697               if string.find(valeur,'e') != -1:
 698                  # Notation scientifique ?
 699                  try :
 700                     r=eval(valeur)
 701                     return valeur
 702                  except :
 703                     return None
 704               else :
 705                  return valeur+'.'
 706       else:
 707           return valeur
 708
 709
 710 import Accas
 711 treeitem = SIMPTreeItem
 712 objet = Accas.MCSIMP
 713