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