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