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