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