Extensions/parametre.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 """
  21     Ce module contient la classe PARAMETRE qui sert à définir
  22     des objets paramètres qui sont compréhensibles et donc affichables
  23     par EFICAS.
  24     Ces objets sont créés à partir de la modification du fichier de commandes
  25     de l'utilisateur par le parseur de fichiers Python
  26 """
  27
  28 # import de modules Python
  29 import string,types
  30 from math import *
  31 import traceback
  32
  33 # import de modules Eficas
  34 from Noyau.N_CR import CR
  35 from Noyau import N_OBJECT
  36 from Ihm import I_OBJECT
  37 from param2 import *
  38 from Ihm import CONNECTOR
  39 from Extensions.i18n import tr
  40
  41 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
  42   """
  43      Cette classe permet de créer des objets de type PARAMETRE
  44      cad des affectations directes dans le jeu de commandes (ex: a=10.)
  45      qui sont interprétées par le parseur de fichiers Python.
  46      Les objets ainsi créés constituent des paramètres pour le jdc
  47   """
  48
  49   nature = 'PARAMETRE'
  50   idracine = 'param'
  51
  52   def __init__(self,nom,valeur=None):
  53     self.nom = nom
  54     # La classe PARAMETRE n'a pas de définition : on utilise self pour
  55     # complétude
  56     self.definition=self
  57     # parent ne peut être qu'un objet de type JDC
  58     self.jdc = self.parent = CONTEXT.get_current_step()
  59     self.niveau=self.parent.niveau
  60     self.actif=1
  61     self.state='undetermined'
  62     self.register()
  63     self.dict_valeur=[]
  64     #self.valeur = self.interprete_valeur(valeur)
  65     #self.val=valeur
  66     self.valeur = valeur
  67     self.val=repr(valeur)
  68
  69   def interprete_valeur(self,val):
  70     """
  71     Essaie d'interpréter val (chaîne de caractères)comme :
  72     - un entier
  73     - un réel
  74     - une chaîne de caractères
  75     - une liste d'items d'un type qui précède
  76     Retourne la valeur interprétée
  77     """
  78     #if not val : return None
  79     valeur = None
  80
  81     if type(val) == types.ListType:
  82     # Un premier traitement a ete fait lors de la saisie
  83     # permet de tester les parametres qui sont des listes
  84        l_new_val = []
  85        for v in val :
  86            try :
  87                valeur=eval(str(v))
  88                l_new_val.append(v)
  89            except :
  90                return None
  91        return l_new_val
  92
  93     if type(val) == types.StringType:
  94        # on tente l'evaluation dans un contexte fourni par le parent s'il existe
  95        if self.parent:
  96           valeur=self.parent.eval_in_context(val,self)
  97        else:
  98           try :
  99               valeur = eval(val)
 100           except:
 101               #traceback.print_exc()
 102               pass
 103     #PN je n ose pas modifier je rajoute
 104     # refus des listes heterogenes : ne dvrait pas etre la
 105     if valeur != None :
 106         if type(valeur) == types.TupleType:
 107             l_new_val = []
 108             typ = None
 109             for v in valeur :
 110                 if not typ:
 111                     typ = type(v)
 112                 else:
 113                     if type(v) != typ :
 114                         # la liste est hétérogène --> on refuse d'interpréter
 115                         #  self comme une liste
 116                         # on retourne la string initiale
 117                         print 'liste hétérogène ',val
 118                         return val
 119                 l_new_val.append(v)
 120             return tuple(l_new_val)
 121
 122     if valeur != None :
 123        if type(valeur).__name__ == 'list':
 124           self.dict_valeur=[]
 125           for i in range(len(valeur)):
 126              self.dict_valeur.append(valeur[i])
 127        return valeur
 128     # on retourne val comme une string car on n'a pas su l'interpréter
 129     return val
 130
 131   def get_valeurs(self):
 132     valeurretour=[]
 133     if self.dict_valeur != []:
 134        for val in self.dict_valeur:
 135            valeurretour.append(val)
 136     else:
 137         valeurretour.append(self.valeur)
 138     return valeurretour
 139
 140   def set_valeur(self,new_valeur):
 141     """
 142     Remplace la valeur de self par new_valeur interprétée
 143     """
 144     self.valeur = self.interprete_valeur(new_valeur)
 145     self.val=repr(self.valeur)
 146     self.parent.update_concept_after_etape(self,self)
 147     self.init_modif()
 148
 149   def set_nom(self,new_nom):
 150     """
 151     Change le nom du parametre
 152     """
 153     self.init_modif()
 154     self.nom=new_nom
 155     self.fin_modif()
 156
 157   def init_modif(self):
 158     """
 159     Méthode qui déclare l'objet courant comme modifié et propage
 160     cet état modifié à ses ascendants
 161     """
 162     self.state = 'modified'
 163     if self.parent:
 164       self.parent.init_modif()
 165
 166   def get_jdc_root(self):
 167     if self.parent:
 168       return self.parent.get_jdc_root()
 169     else:
 170       return self
 171
 172   def register(self):
 173     """
 174     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
 175     """
 176     self.parent.register_parametre(self)
 177     self.parent.register(self)
 178
 179   def isvalid(self,cr='non'):
 180     """
 181     Retourne 1 si self est valide, 0 sinon
 182     Un paramètre est considéré comme valide si :
 183       - il a un nom
 184       - il a une valeur
 185     """
 186     if self.nom == '' :
 187         if cr == 'oui':
 188            self.cr.fatal(tr("Pas de nom donne au parametre "))
 189         return 0
 190     else:
 191         if self.valeur == None :
 192             if cr == 'oui' :
 193                self.cr.fatal(tr("Le parametre %s ne peut valoir None" , self.nom))
 194             return 0
 195     return 1
 196
 197   def isoblig(self):
 198     """
 199     Indique si self est obligatoire ou non : retourne toujours 0
 200     """
 201     return 0
 202
 203   def isrepetable(self):
 204     """
 205     Indique si self est répétable ou non : retourne toujours 1
 206     """
 207     return 1
 208
 209   def liste_mc_presents(self):
 210     return []
 211
 212   def supprime(self):
 213     """
 214     Méthode qui supprime toutes les boucles de références afin que
 215     l'objet puisse être correctement détruit par le garbage collector
 216     """
 217     self.parent = None
 218     self.jdc = None
 219     self.definition=None
 220     self.niveau=None
 221
 222   def active(self):
 223     """
 224     Rend l'etape courante active.
 225     Il faut ajouter le paramètre au contexte global du JDC
 226     """
 227     self.actif = 1
 228     try:
 229         self.jdc.append_param(self)
 230     except:
 231         pass
 232     CONNECTOR.Emit(self,"add",None)
 233     CONNECTOR.Emit(self,"valid")
 234
 235   def inactive(self):
 236     """
 237     Rend l'etape courante inactive
 238     Il faut supprimer le paramètre du contexte global du JDC
 239     """
 240     self.actif = 0
 241     self.jdc.del_param(self)
 242     self.jdc.delete_concept_after_etape(self,self)
 243     CONNECTOR.Emit(self,"supp",None)
 244     CONNECTOR.Emit(self,"valid")
 245
 246   def isactif(self):
 247     """
 248     Booléenne qui retourne 1 si self est actif, 0 sinon
 249     """
 250     return self.actif
 251
 252   def set_attribut(self,nom_attr,new_valeur):
 253     """
 254     Remplace la valeur de self.nom_attr par new_valeur)
 255     """
 256     if hasattr(self,nom_attr):
 257       setattr(self,nom_attr,new_valeur)
 258       self.init_modif()
 259
 260   def supprime_sdprods(self):
 261     """
 262     Il faut supprimer le paramètre qui a été entré dans la liste des
 263     paramètres du JDC
 264     """
 265     self.jdc.delete_param(self)
 266     self.parent.delete_concept(self)
 267
 268   def update_context(self,d):
 269     """
 270     Update le dictionnaire d avec le paramètre que produit self
 271     """
 272     d[self.nom]=self
 273
 274   def __repr__(self):
 275     """
 276         Donne un echo de self sous la forme nom = valeur
 277     """
 278     if type(self.valeur) == types.StringType:
 279          if self.valeur.find('\n') == -1:
 280             # pas de retour chariot, on utilise repr
 281             return self.nom+' = '+ repr(self.valeur)
 282          elif self.valeur.find('"""') == -1:
 283             # retour chariot mais pas de triple ", on formatte
 284             return self.nom+' = """'+self.valeur+'"""'
 285          else:
 286             return self.nom+' = '+ repr(self.valeur)
 287     else:
 288        if type(self.valeur) == types.ListType :
 289           aRetourner=self.nom+' = ['
 290           for l in self.valeur :
 291             aRetourner=aRetourner+str(l) +","
 292           aRetourner=aRetourner[0:-1]+']'
 293           return aRetourner
 294        return self.nom+' = '+ str(self.valeur)
 295
 296   def __str__(self):
 297     """
 298         Retourne le nom du paramètre comme représentation de self
 299     """
 300     return self.nom
 301
 302   def get_sdprods(self,nom_sd):
 303      """
 304          Retourne les concepts produits par la commande
 305      """
 306      return None
 307
 308   def report(self):
 309     """ Génère l'objet rapport (classe CR) """
 310     self.cr=CR()
 311     self.isvalid(cr='oui')
 312     return self.cr
 313
 314   def ident(self):
 315     """
 316     Retourne le nom interne associé à self
 317     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 318     """
 319     return self.nom
 320
 321   def delete_concept(self,sd):
 322     pass
 323
 324   def replace_concept(self,old_sd,sd):
 325     pass
 326
 327   def verif_condition_bloc(self):
 328     """
 329         Evalue les conditions de tous les blocs fils possibles
 330         (en fonction du catalogue donc de la définition) de self et
 331         retourne deux listes :
 332           - la première contient les noms des blocs à rajouter
 333           - la seconde contient les noms des blocs à supprimer
 334     """
 335     return [],[]
 336
 337   def verif_condition_regles(self,liste_presents):
 338     """
 339         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 340         en fonction de la liste des mots-clés présents
 341     """
 342     return []
 343
 344   def verif_existence_sd(self):
 345      pass
 346
 347   def control_sdprods(self,d):
 348       """sans objet """
 349       pass
 350
 351   def close(self):
 352       pass
 353
 354   def reset_context(self):
 355       pass
 356
 357   def eval(self):
 358       if isinstance(self.valeur,Formula):
 359          return self.valeur.eval()
 360       else:
 361          return self.valeur
 362
 363   def __adapt__(self,validator):
 364       return validator.adapt(self.eval())
 365
 366 class COMBI_PARAMETRE :
 367   def __init__(self,chainevaleur,valeur):
 368       self.chainevaleur=chainevaleur
 369       self.valeur=valeur
 370
 371   def __repr__(self):
 372       return self.chainevaleur
 373
 374   def isvalid(self):
 375       if self.valeur and self.chainevaleur:
 376          return 1
 377
 378 class ITEM_PARAMETRE :
 379   def __init__(self,param_pere,item=None):
 380       self.param_pere = param_pere
 381       self.item = item
 382
 383
 384   def __repr__(self):
 385     return self.param_pere.nom+'['+str(self.item)+']'
 386
 387
 388   def isvalid(self):
 389       isvalid = 1
 390       if self.item < 0:
 391          isvalid =  0
 392       try:
 393          longueur= len(self.param_pere.dict_valeur) - 1
 394       except:
 395          longueur=0
 396       if self.item > longueur :
 397          isvalid= 0
 398       return isvalid