InterfaceQT4/composimp.py

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