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