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