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