InterfaceQT4/composimp.py

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