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_complex(self):
 512       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 513       attend un complexe, 0 sinon """
 514       if 'C' in self.object.definition.type:
 515           return 1
 516       else:
 517           return 0
 518
 519   def wait_reel(self):
 520       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 521       attend un réel, 0 sinon """
 522       if 'R' in self.object.definition.type:
 523           return 1
 524       else:
 525           return 0
 526
 527   def wait_date(self):
 528       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 529       attend un réel, 0 sinon """
 530       if 'DateHHMMAAAA' in self.object.definition.type:
 531           return 1
 532       else:
 533           return 0
 534
 535   def wait_heure(self):
 536       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 537       attend un réel, 0 sinon """
 538       if 'HeureHHMMSS' in self.object.definition.type:
 539           return 1
 540       else:
 541           return 0
 542
 543
 544
 545   def wait_tuple(self):
 546       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 547       attend un Tuple, 0 sinon """
 548       for ss_type in self.object.definition.type:
 549           if repr(ss_type).find('Tuple') != -1 :
 550              return 1
 551       return 0
 552
 553   def wait_matrice(self):
 554       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 555       attend un Tuple, 0 sinon """
 556       for ss_type in self.object.definition.type:
 557           if repr(ss_type).find('Matrice') != -1 :
 558              return 1
 559       return 0
 560
 561   def wait_assd(self):
 562       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 563       attend un objet de type ASSD ou dérivé, 0 sinon """
 564       return self.object.wait_assd()
 565
 566   def wait_assd_or_type_base(self) :
 567       boo=0
 568       if len(self.object.definition.type) > 1 :
 569          if self.wait_reel() :
 570             boo = 1
 571          if 'I' in self.object.definition.type :
 572             boo = 1
 573       return boo
 574
 575   def wait_Salome(self):
 576       type = self.object.definition.type[0]
 577       if 'grma' in repr(type) : return True
 578       if 'grno' in repr(type) : return True
 579       if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
 580       return False
 581
 582   def GetType(self):
 583       """
 584           Retourne le type de valeur attendu par l'objet représenté par l'item.
 585       """
 586       return self.object.get_type()
 587
 588   #-----------------------------------------------------
 589   #
 590   # Methodes liees  a l evaluation de la valeur saisie
 591   #
 592   #-----------------------------------------------------
 593   # eval_valeur
 594   # eval_valeur_item
 595   # is_CO
 596   # traite_reel
 597
 598   def eval_valeur(self,valeur):
 599       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
 600              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 601              - retourne 'valeur' (chaine de caractéres) sinon
 602       """
 603       newvaleur=self.eval_val(valeur)
 604       return newvaleur,1
 605
 606   def eval_valeur_BAK(self,valeur):
 607       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
 608       de l'objet pointé par self :
 609         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 610         - retourne 'valeur' (chaine de caractéres) sinon
 611         - retourne None en cas d invalidite
 612         - retourne invalide si 1 des objets du tuple l est
 613       """
 614       validite=1
 615       if type(valeur) in (types.ListType,types.TupleType) :
 616          valeurretour=[]
 617          for item in valeur :
 618              newvaleur,validiteitem=self.eval_valeur_item(item)
 619              valeurretour.append(newvaleur)
 620              if validiteitem == 0:
 621                 validite=0
 622       else :
 623          valeurretour,validite= self.eval_valeur_item(valeur)
 624       if validite == 0 :
 625          valeurretour = None
 626       return valeurretour,validite
 627
 628   def eval_valeur_item(self,valeur):
 629       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 630           - va retourner la valeur de retour et la validite
 631             selon le type de l objet attendu
 632           - traite les reels et les parametres
 633       """
 634       #print "eval_valeur_item",valeur
 635       if valeur==None or valeur == "" :
 636          return None,0
 637       validite=1
 638       if self.wait_reel():
 639              valeurinter = self.traite_reel(valeur)
 640              if valeurinter != None :
 641                 valeurretour,validite= self.object.eval_valeur(valeurinter)
 642              else:
 643                 valeurretour,validite= self.object.eval_valeur(valeur)
 644       elif self.wait_geom():
 645              valeurretour,validite = valeur,1
 646       else :
 647              valeurretour,validite= self.object.eval_valeur(valeur)
 648       #print "eval_valeur_item",valeurretour,validite
 649
 650       if validite == 0:
 651          if type(valeur) == types.StringType and self.object.wait_TXM():
 652             essai_valeur="'" + valeur + "'"
 653             valeurretour,validite= self.object.eval_valeur(essai_valeur)
 654
 655       if hasattr(valeurretour,'__class__'):
 656          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 657          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 658             validite=1
 659
 660       #if self.wait_co():
 661          # CCAR : il ne faut pas essayer de creer un concept
 662          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
 663          #try:
 664             #valeurretour=Accas.CO(valeur)
 665          #except:
 666             #valeurretour=None
 667             #validite=0
 668       # on est dans le cas ou on a évalué et ou on n'aurait pas du
 669       if self.object.wait_TXM() :
 670           if type(valeurretour) != types.StringType:
 671              valeurretour=str(valeur)
 672              validite=1
 673       return valeurretour,validite
 674
 675   def is_CO(self,valeur=None):
 676       """
 677          Indique si valeur est un concept produit de la macro
 678          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 679          Si valeur vaut None on teste la valeur du mot cle
 680       """
 681       # Pour savoir si un concept est un nouveau concept de macro
 682       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 683       # ou si son nom de classe est CO.
 684       # Il faut faire les 2 tests car une macro non valide peut etre
 685       # dans un etat pas tres catholique avec des CO pas encore types
 686       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
 687       if not valeur:valeur=self.object.valeur
 688       if valeur in self.object.etape.sdprods:return 1
 689       if type(valeur) is not types.InstanceType:return 0
 690       if valeur.__class__.__name__ == 'CO':return 1
 691       return 0
 692
 693   def is_param(self,valeur) :
 694       for param in self.jdc.params:
 695           if (repr(param) == valeur):
 696              return 1
 697       return 0
 698
 699   def traite_reel(self,valeur):
 700       """
 701       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
 702       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
 703       ou un EVAL ...
 704       """
 705       valeur = string.strip(valeur)
 706       liste_reels = self.get_sd_avant_du_bon_type()
 707       if valeur in liste_reels:
 708           return valeur
 709       if len(valeur) >= 3 :
 710           if valeur[0:4] == 'EVAL' :
 711               # on a trouvé un EVAL --> on retourne directement la valeur
 712               return valeur
 713       if string.find(valeur,'.') == -1 :
 714           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
 715           if (self.is_param(valeur)):
 716               return valeur
 717           else:
 718               if string.find(valeur,'e') != -1:
 719                  # Notation scientifique ?
 720                  try :
 721                     r=eval(valeur)
 722                     return valeur
 723                  except :
 724                     return None
 725               else :
 726                  return valeur+'.'
 727       else:
 728           return valeur
 729
 730
 731 import Accas
 732 treeitem = SIMPTreeItem
 733 objet = Accas.MCSIMP
 734