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