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