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