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