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