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