Ihm/I_MCSIMP.py

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