Ihm/I_MCSIMP.py

   1 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   2 # ======================================================================
   3 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   7 # (AT YOUR OPTION) ANY LATER VERSION.
   8 #
   9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  13 #
  14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  17 #
  18 #
  19 # ======================================================================
  20 import types,string
  21 import traceback
  22 from copy import copy
  23 from repr import Repr
  24 myrepr = Repr()
  25 myrepr.maxstring = 100
  26 myrepr.maxother = 100
  27
  28 from Noyau.N_utils import repr_float
  29
  30 # Attention : les classes ASSD,.... peuvent etre surchargées
  31 # dans le package Accas. Il faut donc prendre des précautions si
  32 # on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
  33 # Si on veut créer des objets comme des CO avec les classes du noyau
  34 # ils n'auront pas les conportements des autres packages (pb!!!)
  35 # Il vaut mieux les importer d'Accas mais problème d'import circulaire,
  36 # on ne peut pas les importer au début.
  37 # On fait donc un import local quand c'est nécessaire (peut occasionner
  38 # des pbs de prformance).
  39 from Noyau.N_ASSD import ASSD,assd
  40 from Noyau.N_GEOM import GEOM,geom
  41 from Noyau.N_CO import CO
  42 # fin attention
  43
  44 from Extensions import parametre
  45 import I_OBJECT
  46
  47 class MCSIMP(I_OBJECT.OBJECT):
  48   def GetText(self):
  49     """
  50         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
  51         pointé par self
  52     """
  53     if self.valeur == None :
  54       return None
  55     elif type(self.valeur) == types.FloatType :
  56       # Traitement d'un flottant isolé
  57       #txt = repr_float(self.valeur)
  58       # Normalement str fait un travail correct
  59       txt = str(self.valeur)
  60     elif type(self.valeur) in (types.ListType,types.TupleType) :
  61       # Traitement des listes
  62       txt='('
  63       i=0
  64       for val in self.valeur:
  65         if type(val) == types.FloatType :
  66            # CCAR : Normalement str fait un travail correct
  67            #txt=txt + i*',' + repr_float(val)
  68            txt=txt + i*',' + str(val)
  69         elif isinstance(val,ASSD):
  70            txt = txt + i*',' + val.get_name()
  71     #PN
  72     # ajout du elif
  73         elif type(val) == types.InstanceType and val.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
  74            txt = txt + i*','+ str(val)
  75         else:
  76            txt = txt + i*','+ myrepr.repr(val)
  77         i=1
  78       txt=txt+')'
  79     elif isinstance(self.valeur,ASSD):
  80       # Cas des ASSD
  81       txt=self.getval()
  82     elif type(self.valeur) == types.InstanceType and self.valeur.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
  83       # Cas des PARAMETRES
  84       txt=str(self.valeur)
  85     else:
  86       # Traitement des autres cas
  87       txt = myrepr.repr(self.valeur)
  88
  89     # txt peut etre une longue chaine sur plusieurs lignes.
  90     # Il est possible de tronquer cette chaine au premier \n et
  91     # de limiter la longueur de la chaine a 30 caracteres. Cependant
  92     # ceci provoque une perte d'information pour l'utilisateur
  93     # Pour le moment on retourne la chaine telle que
  94     return txt
  95
  96   def getval(self):
  97     """
  98        Retourne une chaîne de caractère représentant la valeur de self
  99     """
 100     val=self.valeur
 101     if type(val) != types.TupleType :
 102       try:
 103         return val.get_name()
 104       except:
 105         return val
 106     else :
 107       s='( '
 108       for item in val :
 109         try :
 110           s=s+item.get_name()+','
 111         except:
 112           s=s+`item`+','
 113       s=s+' )'
 114       return s
 115
 116   def wait_co(self):
 117     """
 118         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
 119         qui n'existe pas encore (type CO()), 0 sinon
 120     """
 121     for typ in self.definition.type:
 122       if type(typ) == types.ClassType :
 123         if issubclass(typ,CO) :
 124            return 1
 125     return 0
 126
 127   def wait_assd(self):
 128     """
 129         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
 130         ou dérivé, 0 sinon
 131     """
 132     for typ in self.definition.type:
 133       if type(typ) == types.ClassType :
 134         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
 135           return 1
 136     return 0
 137
 138   def wait_assd_or_geom(self):
 139     """
 140          Retourne 1 si le mot-clé simple attend un objet de type
 141          assd, ASSD, geom ou GEOM
 142          Retourne 0 dans le cas contraire
 143     """
 144     for typ in self.definition.type:
 145       if type(typ) == types.ClassType :
 146         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 147           return 1
 148     return 0
 149
 150   def wait_geom(self):
 151     """
 152          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 153          Retourne 0 dans le cas contraire
 154     """
 155     for typ in self.definition.type:
 156       if type(typ) == types.ClassType :
 157         if issubclass(typ,GEOM) : return 1
 158     return 0
 159
 160   def wait_TXM(self):
 161     """
 162          Retourne 1 si le mot-clé simple attend un objet de type TXM
 163          Retourne 0 dans le cas contraire
 164     """
 165     for typ in self.definition.type:
 166       if typ == 'TXM' :return 1
 167     return 0
 168
 169   def get_liste_valeurs(self):
 170     """
 171     """
 172     if self.valeur == None:
 173       return []
 174     elif type(self.valeur) == types.TupleType:
 175       return list(self.valeur)
 176     elif type(self.valeur) == types.ListType:
 177       return self.valeur
 178     else:
 179       return [self.valeur]
 180
 181   def isoblig(self):
 182     return self.definition.statut=='o'
 183
 184   def set_valeur(self,new_valeur,evaluation='oui'):
 185         self.init_modif()
 186         self.valeur = new_valeur
 187         self.val = new_valeur
 188         self.fin_modif()
 189         return 1
 190
 191   def eval_valeur(self,new_valeur):
 192     """
 193         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 194         ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 195     """
 196     sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 197     if sd :
 198       return sd,1
 199     else:
 200       d={}
 201       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 202       from Accas import EVAL
 203       d['EVAL']=EVAL
 204       try :
 205         objet = eval(new_valeur,d)
 206         return objet,1
 207       except Exception:
 208         if CONTEXT.debug : traceback.print_exc()
 209         return None,0
 210
 211   def delete_concept(self,sd):
 212     """
 213         Inputs :
 214            - sd=concept detruit
 215         Fonction :
 216         Met a jour la valeur du mot cle simple suite à la disparition
 217         du concept sd
 218     """
 219     if type(self.valeur) == types.TupleType :
 220       if sd in self.valeur:
 221         self.valeur=list(self.valeur)
 222         self.valeur.remove(sd)
 223         self.init_modif()
 224     elif type(self.valeur) == types.ListType:
 225       if sd in self.valeur:
 226         self.valeur.remove(sd)
 227         self.init_modif()
 228     else:
 229       if self.valeur == sd:
 230         self.valeur=None
 231         self.val=None
 232         self.init_modif()
 233
 234   def replace_concept(self,old_sd,sd):
 235     """
 236         Inputs :
 237            - old_sd=concept remplacé
 238            - sd=nouveau concept
 239         Fonction :
 240         Met a jour la valeur du mot cle simple suite au remplacement
 241         du concept old_sd
 242     """
 243     if type(self.valeur) == types.TupleType :
 244       if old_sd in self.valeur:
 245         self.valeur=list(self.valeur)
 246         i=self.valeur.index(old_sd)
 247         self.valeur[i]=sd
 248         self.init_modif()
 249     elif type(self.valeur) == types.ListType:
 250       if old_sd in self.valeur:
 251         i=self.valeur.index(old_sd)
 252         self.valeur[i]=sd
 253         self.init_modif()
 254     else:
 255       if self.valeur == old_sd:
 256         self.valeur=sd
 257         self.val=sd
 258         self.init_modif()
 259
 260   def set_valeur_co(self,nom_co):
 261       """
 262           Affecte à self l'objet de type CO et de nom nom_co
 263       """
 264       step=self.etape.parent
 265       if nom_co == None or nom_co == '':
 266          new_objet=None
 267       else:
 268          # Pour le moment on importe en local le CO de Accas.
 269          # Si problème de perfs, il faudra faire autrement
 270          from Accas import CO
 271          # Avant de créer un concept il faut s'assurer du contexte : step
 272          # courant
 273          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
 274          if sd:
 275             # Si un concept du meme nom existe deja dans la portée de l'étape
 276             # on ne crée pas le concept
 277             return 0,"un concept de meme nom existe deja"
 278          # Il n'existe pas de concept de meme nom. On peut donc le créer
 279          # Il faut néanmoins que la méthode NommerSdProd de step gère les
 280          # contextes en mode editeur
 281          # Normalement la méthode  du Noyau doit etre surchargée
 282          # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
 283          cs= CONTEXT.get_current_step()
 284          CONTEXT.unset_current_step()
 285          CONTEXT.set_current_step(step)
 286          step.set_etape_context(self.etape)
 287          new_objet = CO(nom_co)
 288          CONTEXT.unset_current_step()
 289          CONTEXT.set_current_step(cs)
 290       self.init_modif()
 291       self.valeur = new_objet
 292       self.val = new_objet
 293       self.fin_modif()
 294       step.reset_context()
 295       # On force l'enregistrement de new_objet en tant que concept produit
 296       # de la macro en appelant get_type_produit avec force=1
 297       self.etape.get_type_produit(force=1)
 298       return 1,"Concept créé"
 299
 300   def verif_existence_sd(self):
 301      """
 302         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 303         avant étape, sinon enlève la référence à ces concepts
 304      """
 305      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
 306      if type(self.valeur) in (types.TupleType,types.ListType) :
 307        l=[]
 308        for sd in self.valeur:
 309          if isinstance(sd,ASSD) :
 310             if sd in l_sd_avant_etape :
 311                l.append(sd)
 312          else:
 313             l.append(sd)
 314        self.valeur=tuple(l)
 315        # Est ce init_modif ou init_modif_up
 316        # Normalement init_modif va avec fin_modif
 317        self.init_modif()
 318        self.fin_modif()
 319      else:
 320        if isinstance(self.valeur,ASSD) :
 321           if self.valeur not in l_sd_avant_etape :
 322              self.valeur = None
 323              self.init_modif()
 324              self.fin_modif()
 325
 326   def get_min_max(self):
 327      """
 328      Retourne les valeurs min et max admissibles pour la valeur de self
 329      """
 330      return self.definition.min,self.definition.max
 331
 332
 333   def get_type(self):
 334      """
 335      Retourne le type attendu par le mot-clé simple
 336      """
 337      return self.definition.type
 338
 339 #--------------------------------------------------------------------------------
 340 # PN : ajout pour Salome des methodes suivantes (jusqu aux méthodes surchargees)
 341 #--------------------------------------------------------------------------------
 342   def get_salome_valeurs(self):
 343        l=[]
 344        if not hasattr(self,'list_salome_valeurs'):
 345            self.list_salome_valeurs=[]
 346        if self.list_salome_valeurs != [] :
 347            for val in self.list_salome_valeurs:
 348                 l.append(val)
 349        return l
 350
 351   def put_salome_valeurs(self,list):
 352        self.list_salome_valeurs=[]
 353        for val in list:
 354            self.list_salome_valeurs.append(val)
 355
 356   def add_salome_valeurs(self,val):
 357       if not hasattr(self,'list_salome_valeurs'):
 358            self.list_salome_valeurs=[]
 359       try:
 360            self.list_salome_valeurs.append(val)
 361       except :
 362            try:
 363               for uneval in val :
 364                   self.list_salome_valeurs.append(uneval)
 365            except :
 366               pass
 367
 368   def has_salome_valeurs(self):
 369       if not hasattr(self,'list_salome_valeurs'):
 370            self.list_salome_valeurs=[]
 371       if self.list_salome_valeurs != []:
 372            return true
 373       else:
 374            return false
 375
 376 #--------------------------------------------------------------------------------
 377 # PN : fin ajout pour Salome
 378 #--------------------------------------------------------------------------------
 379
 380 #ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
 381 # Elles doivent etre reintegrees des que possible
 382