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       print "llllllllllllllllllllllkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk"
 311       if hasattr(self.definition.validators,'into'):
 312          valeurspossibles = self.definition.validators.into
 313       else:
 314          valeurspossibles = self.get_definition().into
 315
 316       if listeActuelle==[] : return valeurspossibles
 317
 318       #On ne garde que les items valides
 319       listevalideitem=[]
 320       if type(valeurspossibles) in (types.ListType,types.TupleType) :
 321          pass
 322       else :
 323          valeurspossibles=(valeurspossibles,)
 324       for item in valeurspossibles:
 325           encorevalide=self.valide_item(item)
 326           if encorevalide :
 327              listevalideitem.append(item)
 328
 329       #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
 330       listevalideliste=[]
 331       for item in listevalideitem:
 332           encorevalide=self.valide_liste_partielle(item,listeActuelle)
 333           if encorevalide :
 334               listevalideliste.append(item)
 335       print listevalideliste
 336       return listevalideliste
 337
 338   def get_liste_param_possible(self):
 339       liste_param=[]
 340       l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
 341       for param in self.object.jdc.params:
 342           if param.nom not in l1 : continue
 343           encorevalide=self.valide_item(param.valeur)
 344           if encorevalide:
 345              type_param=param.valeur.__class__.__name__
 346              for typ in self.definition.type:
 347                  if typ=='R':
 348                      liste_param.append(param)
 349                  if typ=='I' and type_param=='int':
 350                      liste_param.append(param)
 351                  if typ=='TXM' and type_param=='str':
 352                      liste_param.append(repr(param))
 353                  if ('grma' in repr(typ)) and type_param=='str':
 354                      liste_param.append(param.nom)
 355       return liste_param
 356
 357   #--------------------------------------------------
 358   #
 359   # Methodes liees a la validite des valeurs saisies
 360   #
 361   #---------------------------------------------------
 362   # valide_item
 363   # valide_liste_partielle
 364   # valide_liste_complete
 365   # info_erreur_item
 366   # info_erreur_liste
 367   # IsInIntervalle
 368   # isvalid
 369
 370   def valide_item(self,item):
 371       """
 372         La validation est realisee directement par l'objet
 373       """
 374       return self.object.valide_item(item)
 375
 376   def valide_liste_partielle(self,item,listecourante):
 377       #On protege la liste en entree en la copiant
 378       valeur=listecourante[:]
 379       valeur.append(item)
 380       return self.object.valid_valeur_partielle(valeur)
 381
 382   def valide_liste_complete (self,valeur):
 383       return self.object.valid_valeur(valeur)
 384
 385   def valide_val (self,valeur):
 386       return self.object.valid_val(valeur)
 387
 388   def info_erreur_item(self) :
 389       commentaire=""
 390       if self.definition.validators :
 391          commentaire=self.definition.validators.info_erreur_item()
 392       return commentaire
 393
 394   def aide(self) :
 395       commentaire=""
 396       if self.definition.validators :
 397          commentaire=self.definition.validators.aide()
 398       return commentaire
 399
 400   def info_erreur_liste(self) :
 401       commentaire=""
 402       if self.definition.validators :
 403          commentaire=self.definition.validators.info_erreur_liste()
 404       return commentaire
 405
 406   def IsInIntervalle(self,valeur):
 407       """
 408           Retourne 1 si la valeur est dans l'intervalle permis par
 409           l'objet represente par l'item.
 410       """
 411       return self.valide_item(valeur)
 412
 413   def isvalid(self):
 414     valide=self.object.isvalid()
 415     return valide
 416
 417   #--------------------------------------------------
 418   #
 419   # Autres ...
 420   #
 421   #---------------------------------------------------
 422   # GetIconName
 423   # GetText
 424   # set_valeur_co
 425   # get_sd_avant_du_bon_type
 426   # delete_valeur_co
 427
 428
 429   def GetIconName(self):
 430     if self.isvalid():
 431       return "ast-green-ball"
 432     elif self.object.isoblig():
 433       return "ast-red-ball"
 434     else:
 435       return "ast-yel-ball"
 436     print "invalide"
 437
 438   def GetText(self):
 439     """
 440     Classe SIMPTreeItem
 441     Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
 442     pointe par self
 443     """
 444     text= self.object.GetText()
 445     if text == None : text=""
 446     return text
 447
 448
 449   def set_valeur_co(self,nom_co):
 450       """
 451       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
 452       """
 453       ret = self.object.set_valeur_co(nom_co)
 454       #print "set_valeur_co",ret
 455       return ret
 456
 457   def get_sd_avant_du_bon_type(self):
 458       """
 459       Retourne la liste des noms des SD présentes avant l'étape qui contient
 460       le MCS pointé par self et du type requis par ce MCS
 461       """
 462       a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
 463       return a
 464
 465   def get_sd_avant_du_bon_type_pour_type_de_base(self):
 466       a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
 467       return a
 468
 469
 470
 471
 472   def delete_valeur_co(self,valeur=None):
 473       """
 474            Supprime la valeur du mot cle (de type CO)
 475            il faut propager la destruction aux autres etapes
 476       """
 477       if not valeur : valeur=self.object.valeur
 478       # XXX faut il vraiment appeler del_sdprod ???
 479       #self.object.etape.parent.del_sdprod(valeur)
 480       self.object.etape.parent.delete_concept(valeur)
 481
 482   #-----------------------------------------------
 483   #
 484   # Methodes liees au type de l objet attendu
 485   #
 486   #-----------------------------------------------
 487   # wait_co
 488   # wait_geom
 489   # wait_complex
 490   # wait_reel
 491   # wait_assd
 492   # GetType
 493
 494   def wait_co(self):
 495       """
 496       Méthode booléenne qui retourne 1 si l'objet pointé par self
 497       attend un objet de type ASSD qui n'existe pas encore (type CO()),
 498       0 sinon
 499       """
 500       return self.object.wait_co()
 501
 502   def wait_fichier(self):
 503       maDefinition=self.object.definition
 504       try :
 505         if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
 506            return 1
 507       except :
 508            return 0
 509
 510   def wait_geom(self):
 511       """
 512       Méthode booléenne qui retourne 1 si l'objet pointé par self
 513       attend un objet GEOM, 0 sinon
 514       """
 515       return self.object.wait_geom()
 516
 517   def wait_TXM(self):
 518      return self.object.wait_TXM()
 519
 520
 521   def wait_complex(self):
 522       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 523       attend un complexe, 0 sinon """
 524       if 'C' in self.object.definition.type:
 525           return 1
 526       else:
 527           return 0
 528
 529   def wait_reel(self):
 530       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 531       attend un réel, 0 sinon """
 532       if 'R' in self.object.definition.type:
 533           return 1
 534       else:
 535           return 0
 536
 537   def wait_date(self):
 538       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 539       attend un réel, 0 sinon """
 540       if 'DateHHMMAAAA' in self.object.definition.type:
 541           return 1
 542       else:
 543           return 0
 544
 545   def wait_heure(self):
 546       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 547       attend un réel, 0 sinon """
 548       if 'HeureHHMMSS' in self.object.definition.type:
 549           return 1
 550       else:
 551           return 0
 552
 553
 554
 555   def wait_tuple(self):
 556       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 557       attend un Tuple, 0 sinon """
 558       for ss_type in self.object.definition.type:
 559           if repr(ss_type).find('Tuple') != -1 :
 560              return 1
 561       return 0
 562
 563   def wait_matrice(self):
 564       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 565       attend un Tuple, 0 sinon """
 566       for ss_type in self.object.definition.type:
 567           if repr(ss_type).find('Matrice') != -1 :
 568              return 1
 569       return 0
 570
 571   def wait_assd(self):
 572       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 573       attend un objet de type ASSD ou dérivé, 0 sinon """
 574       return self.object.wait_assd()
 575
 576   def wait_assd_or_type_base(self) :
 577       boo=0
 578       if len(self.object.definition.type) > 1 :
 579          if self.wait_reel() :
 580             boo = 1
 581          if 'I' in self.object.definition.type :
 582             boo = 1
 583       return boo
 584
 585   def wait_Salome(self):
 586       type = self.object.definition.type[0]
 587       if 'grma' in repr(type) : return True
 588       if 'grno' in repr(type) : return True
 589       if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
 590       return False
 591
 592   def GetType(self):
 593       """
 594           Retourne le type de valeur attendu par l'objet représenté par l'item.
 595       """
 596       return self.object.get_type()
 597
 598   #-----------------------------------------------------
 599   #
 600   # Methodes liees  a l evaluation de la valeur saisie
 601   #
 602   #-----------------------------------------------------
 603   # eval_valeur
 604   # eval_valeur_item
 605   # is_CO
 606   # traite_reel
 607
 608   def eval_valeur(self,valeur):
 609       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
 610              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 611              - retourne 'valeur' (chaine de caractéres) sinon
 612       """
 613       newvaleur=self.eval_val(valeur)
 614       return newvaleur,1
 615
 616   def eval_valeur_BAK(self,valeur):
 617       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
 618       de l'objet pointé par self :
 619         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 620         - retourne 'valeur' (chaine de caractéres) sinon
 621         - retourne None en cas d invalidite
 622         - retourne invalide si 1 des objets du tuple l est
 623       """
 624       validite=1
 625       if type(valeur) in (types.ListType,types.TupleType) :
 626          valeurretour=[]
 627          for item in valeur :
 628              newvaleur,validiteitem=self.eval_valeur_item(item)
 629              valeurretour.append(newvaleur)
 630              if validiteitem == 0:
 631                 validite=0
 632       else :
 633          valeurretour,validite= self.eval_valeur_item(valeur)
 634       if validite == 0 :
 635          valeurretour = None
 636       return valeurretour,validite
 637
 638   def eval_valeur_item(self,valeur):
 639       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 640           - va retourner la valeur de retour et la validite
 641             selon le type de l objet attendu
 642           - traite les reels et les parametres
 643       """
 644       #print "eval_valeur_item",valeur
 645       if valeur==None or valeur == "" :
 646          return None,0
 647       validite=1
 648       if self.wait_reel():
 649              valeurinter = self.traite_reel(valeur)
 650              if valeurinter != None :
 651                 valeurretour,validite= self.object.eval_valeur(valeurinter)
 652              else:
 653                 valeurretour,validite= self.object.eval_valeur(valeur)
 654       elif self.wait_geom():
 655              valeurretour,validite = valeur,1
 656       else :
 657              valeurretour,validite= self.object.eval_valeur(valeur)
 658       #print "eval_valeur_item",valeurretour,validite
 659
 660       if validite == 0:
 661          if type(valeur) == types.StringType and self.object.wait_TXM():
 662             essai_valeur="'" + valeur + "'"
 663             valeurretour,validite= self.object.eval_valeur(essai_valeur)
 664
 665       if hasattr(valeurretour,'__class__'):
 666          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 667          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 668             validite=1
 669
 670       #if self.wait_co():
 671          # CCAR : il ne faut pas essayer de creer un concept
 672          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
 673          #try:
 674             #valeurretour=Accas.CO(valeur)
 675          #except:
 676             #valeurretour=None
 677             #validite=0
 678       # on est dans le cas ou on a évalué et ou on n'aurait pas du
 679       if self.object.wait_TXM() :
 680           if type(valeurretour) != types.StringType:
 681              valeurretour=str(valeur)
 682              validite=1
 683       return valeurretour,validite
 684
 685   def is_CO(self,valeur=None):
 686       """
 687          Indique si valeur est un concept produit de la macro
 688          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 689          Si valeur vaut None on teste la valeur du mot cle
 690       """
 691       # Pour savoir si un concept est un nouveau concept de macro
 692       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 693       # ou si son nom de classe est CO.
 694       # Il faut faire les 2 tests car une macro non valide peut etre
 695       # dans un etat pas tres catholique avec des CO pas encore types
 696       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
 697       if not valeur:valeur=self.object.valeur
 698       if valeur in self.object.etape.sdprods:return 1
 699       if type(valeur) is not types.InstanceType:return 0
 700       if valeur.__class__.__name__ == 'CO':return 1
 701       return 0
 702
 703   def is_param(self,valeur) :
 704       for param in self.jdc.params:
 705           if (repr(param) == valeur):
 706              return 1
 707       return 0
 708
 709   def traite_reel(self,valeur):
 710       """
 711       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
 712       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
 713       ou un EVAL ...
 714       """
 715       valeur = string.strip(valeur)
 716       liste_reels = self.get_sd_avant_du_bon_type()
 717       if valeur in liste_reels:
 718           return valeur
 719       if len(valeur) >= 3 :
 720           if valeur[0:4] == 'EVAL' :
 721               # on a trouvé un EVAL --> on retourne directement la valeur
 722               return valeur
 723       if string.find(valeur,'.') == -1 :
 724           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
 725           if (self.is_param(valeur)):
 726               return valeur
 727           else:
 728               if string.find(valeur,'e') != -1:
 729                  # Notation scientifique ?
 730                  try :
 731                     r=eval(valeur)
 732                     return valeur
 733                  except :
 734                     return None
 735               else :
 736                  return valeur+'.'
 737       else:
 738           return valeur
 739
 740
 741 import Accas
 742 treeitem = SIMPTreeItem
 743 objet = Accas.MCSIMP
 744