InterfaceQT4/composimp.py

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