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