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