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 import Accas
  44 # fin attention
  45
  46 from Extensions import parametre
  47 import I_OBJECT
  48 import CONNECTOR
  49
  50 class MCSIMP(I_OBJECT.OBJECT):
  51
  52   def GetNomConcept(self):
  53       p=self
  54       while p.parent :
  55          try :
  56             nomconcept=p.get_sdname()
  57             return nomconcept
  58          except:
  59             try :
  60                nomconcept= p.object.get_sdname()
  61                return nomconcept
  62             except :
  63                pass
  64          p=p.parent
  65       return ""
  66
  67   def GetText(self):
  68     """
  69         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
  70         pointé par self
  71     """
  72
  73     if self.valeur == None :
  74       return None
  75     elif type(self.valeur) == types.FloatType :
  76       # Traitement d'un flottant isolé
  77       # txt = repr_float(self.valeur)
  78       # Normalement str fait un travail correct
  79       txt = str(self.valeur)
  80       clefobj=self.GetNomConcept()
  81       if self.jdc.appli.dict_reels.has_key(clefobj):
  82         if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur):
  83            txt=self.jdc.appli.dict_reels[clefobj][self.valeur]
  84     elif type(self.valeur) in (types.ListType,types.TupleType) :
  85       # Traitement des listes
  86       txt='('
  87       i=0
  88       for val in self.valeur:
  89         if type(val) == types.FloatType :
  90            # CCAR : Normalement str fait un travail correct
  91            #txt=txt + i*',' + repr_float(val)
  92            clefobj=self.GetNomConcept()
  93            if self.jdc.appli.dict_reels.has_key(clefobj):
  94               if self.jdc.appli.dict_reels[clefobj].has_key(val):
  95                  txt=txt + i*',' +self.jdc.appli.dict_reels[clefobj][val]
  96               else :
  97                  txt=txt + i*',' + str(val)
  98            else :
  99               txt=txt + i*',' + str(val)
 100         elif isinstance(val,ASSD):
 101            txt = txt + i*',' + val.get_name()
 102     #PN
 103     # ajout du elif
 104         elif type(val) == types.InstanceType and val.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
 105            txt = txt + i*','+ str(val)
 106         else:
 107            txt = txt + i*','+ myrepr.repr(val)
 108         i=1
 109       txt=txt+')'
 110     elif isinstance(self.valeur,ASSD):
 111       # Cas des ASSD
 112       txt=self.getval()
 113     elif type(self.valeur) == types.InstanceType and self.valeur.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
 114       # Cas des PARAMETRES
 115       txt=str(self.valeur)
 116     else:
 117       # Traitement des autres cas
 118       txt = myrepr.repr(self.valeur)
 119
 120     # txt peut etre une longue chaine sur plusieurs lignes.
 121     # Il est possible de tronquer cette chaine au premier \n et
 122     # de limiter la longueur de la chaine a 30 caracteres. Cependant
 123     # ceci provoque une perte d'information pour l'utilisateur
 124     # Pour le moment on retourne la chaine telle que
 125     return txt
 126
 127   def getval(self):
 128     """
 129        Retourne une chaîne de caractère représentant la valeur de self
 130     """
 131     val=self.valeur
 132     if type(val) == types.FloatType :
 133       clefobj=self.GetNomConcept()
 134       if self.jdc.appli.dict_reels.has_key(clefobj):
 135         if self.jdc.appli.dict_reels[clefobj].has_key(val):
 136            return self.jdc.appli.dict_reels[clefobj][val]
 137     if type(val) != types.TupleType :
 138       try:
 139         return val.get_name()
 140       except:
 141         return val
 142     else :
 143       s='( '
 144       for item in val :
 145         try :
 146           s=s+item.get_name()+','
 147         except:
 148           s=s+`item`+','
 149       s=s+' )'
 150       return s
 151
 152   def wait_co(self):
 153     """
 154         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
 155         qui n'existe pas encore (type CO()), 0 sinon
 156     """
 157     for typ in self.definition.type:
 158       if type(typ) == types.ClassType :
 159         if issubclass(typ,CO) :
 160            return 1
 161     return 0
 162
 163   def wait_assd(self):
 164     """
 165         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
 166         ou dérivé, 0 sinon
 167     """
 168     for typ in self.definition.type:
 169       if type(typ) == types.ClassType :
 170         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
 171           return 1
 172     return 0
 173
 174   def wait_assd_or_geom(self):
 175     """
 176          Retourne 1 si le mot-clé simple attend un objet de type
 177          assd, ASSD, geom ou GEOM
 178          Retourne 0 dans le cas contraire
 179     """
 180     for typ in self.definition.type:
 181       if type(typ) == types.ClassType :
 182         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 183           return 1
 184     return 0
 185
 186   def wait_geom(self):
 187     """
 188          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 189          Retourne 0 dans le cas contraire
 190     """
 191     for typ in self.definition.type:
 192       if type(typ) == types.ClassType :
 193         if issubclass(typ,GEOM) : return 1
 194     return 0
 195
 196   def wait_TXM(self):
 197     """
 198          Retourne 1 si le mot-clé simple attend un objet de type TXM
 199          Retourne 0 dans le cas contraire
 200     """
 201     for typ in self.definition.type:
 202       if typ == 'TXM' :return 1
 203     return 0
 204
 205   def get_liste_valeurs(self):
 206     """
 207     """
 208     if self.valeur == None:
 209       return []
 210     elif type(self.valeur) == types.TupleType:
 211       return list(self.valeur)
 212     elif type(self.valeur) == types.ListType:
 213       return self.valeur
 214     else:
 215       return [self.valeur]
 216
 217   def isoblig(self):
 218     return self.definition.statut=='o'
 219
 220   def valid_valeur(self,new_valeur):
 221       """
 222         Verifie que la valeur passee en argument (new_valeur) est valide
 223         sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
 224       """
 225       old_valeur=self.valeur
 226       old_val=self.val
 227       self.valeur = new_valeur
 228       self.val = new_valeur
 229       self.state="modified"
 230       validite=self.isvalid()
 231       self.valeur = old_valeur
 232       self.val = old_valeur
 233       self.state="modified"
 234       self.isvalid()
 235       return validite
 236
 237   def valid_valeur_partielle(self,new_valeur):
 238       """
 239         Verifie que la valeur passee en argument (new_valeur) est partiellement valide
 240         sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
 241       """
 242       old_valeur=self.valeur
 243       old_val=self.val
 244
 245       self.valeur = new_valeur
 246       self.val = new_valeur
 247       self.state="modified"
 248       validite=0
 249       if self.isvalid():
 250          validite=1
 251       elif self.definition.validators :
 252          validite=self.definition.validators.valide_liste_partielle(new_valeur)
 253
 254       if validite==0:
 255          min,max=self.get_min_max()
 256          if len(new_valeur) < min :
 257             validite=1
 258
 259       self.valeur = old_valeur
 260       self.val = old_valeur
 261       self.state="modified"
 262       self.isvalid()
 263       return validite
 264
 265   def update_condition_bloc(self):
 266       """ Met a jour les blocs conditionnels dependant du mot cle simple self
 267       """
 268       if self.definition.position == 'global' :
 269          self.etape.deep_update_condition_bloc()
 270       elif self.definition.position == 'global_jdc' :
 271          self.jdc.deep_update_condition_bloc()
 272       else:
 273          self.parent.update_condition_bloc()
 274
 275   def set_valeur(self,new_valeur,evaluation='oui'):
 276         #print "set_valeur",new_valeur
 277         self.init_modif()
 278         self.valeur = new_valeur
 279         self.val = new_valeur
 280         self.update_condition_bloc()
 281         self.fin_modif()
 282         return 1
 283
 284   def eval_valeur(self,new_valeur):
 285     """
 286         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 287         ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 288     """
 289     sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
 290     #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 291     #print sd
 292     if sd :
 293       return sd,1
 294     lsd = self.jdc.cherche_list_avant(self.etape,new_valeur)
 295     if lsd :
 296       return lsd,1
 297     else:
 298       d={}
 299       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 300       d['EVAL']=Accas.EVAL
 301       try :
 302         objet = eval(new_valeur,d)
 303         return objet,1
 304       except Exception:
 305         itparam=self.cherche_item_parametre(new_valeur)
 306         if itparam:
 307              return itparam,1
 308         if CONTEXT.debug : traceback.print_exc()
 309         return None,0
 310
 311   def cherche_item_parametre (self,new_valeur):
 312         try:
 313           nomparam=new_valeur[0:new_valeur.find("[")]
 314           indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
 315           for p in self.jdc.params:
 316              if p.nom == nomparam :
 317                 if int(indice) < len(p.get_valeurs()):
 318                    itparam=parametre.ITEM_PARAMETRE(p,int(indice))
 319                    return itparam
 320           return None
 321         except:
 322           return None
 323
 324   def update_concept(self,sd):
 325     if type(self.valeur) in (types.ListType,types.TupleType) :
 326        if sd in self.valeur:self.fin_modif()
 327     else:
 328        if sd == self.valeur:self.fin_modif()
 329
 330   def delete_concept(self,sd):
 331     """
 332         Inputs :
 333            - sd=concept detruit
 334         Fonction :
 335         Met a jour la valeur du mot cle simple suite à la disparition
 336         du concept sd
 337     """
 338     #print "delete_concept",sd
 339     if type(self.valeur) == types.TupleType :
 340       if sd in self.valeur:
 341         self.init_modif()
 342         self.valeur=list(self.valeur)
 343         self.valeur.remove(sd)
 344         self.fin_modif()
 345     elif type(self.valeur) == types.ListType:
 346       if sd in self.valeur:
 347         self.init_modif()
 348         self.valeur.remove(sd)
 349         self.fin_modif()
 350     else:
 351       if self.valeur == sd:
 352         self.init_modif()
 353         self.valeur=None
 354         self.val=None
 355         self.fin_modif()
 356
 357   def replace_concept(self,old_sd,sd):
 358     """
 359         Inputs :
 360            - old_sd=concept remplacé
 361            - sd=nouveau concept
 362         Fonction :
 363         Met a jour la valeur du mot cle simple suite au remplacement
 364         du concept old_sd
 365     """
 366     #print "replace_concept",old_sd,sd
 367     if type(self.valeur) == types.TupleType :
 368       if old_sd in self.valeur:
 369         self.init_modif()
 370         self.valeur=list(self.valeur)
 371         i=self.valeur.index(old_sd)
 372         self.valeur[i]=sd
 373         self.fin_modif()
 374     elif type(self.valeur) == types.ListType:
 375       if old_sd in self.valeur:
 376         self.init_modif()
 377         i=self.valeur.index(old_sd)
 378         self.valeur[i]=sd
 379         self.fin_modif()
 380     else:
 381       if self.valeur == old_sd:
 382         self.init_modif()
 383         self.valeur=sd
 384         self.val=sd
 385         self.fin_modif()
 386
 387   def set_valeur_co(self,nom_co):
 388       """
 389           Affecte à self l'objet de type CO et de nom nom_co
 390       """
 391       #print "set_valeur_co",nom_co
 392       step=self.etape.parent
 393       if nom_co == None or nom_co == '':
 394          new_objet=None
 395       else:
 396          # Avant de créer un concept il faut s'assurer du contexte : step
 397          # courant
 398          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
 399          if sd:
 400             # Si un concept du meme nom existe deja dans la portée de l'étape
 401             # on ne crée pas le concept
 402             return 0,"un concept de meme nom existe deja"
 403          # Il n'existe pas de concept de meme nom. On peut donc le créer
 404          # Il faut néanmoins que la méthode NommerSdProd de step gère les
 405          # contextes en mode editeur
 406          # Normalement la méthode  du Noyau doit etre surchargée
 407          # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
 408          cs= CONTEXT.get_current_step()
 409          CONTEXT.unset_current_step()
 410          CONTEXT.set_current_step(step)
 411          step.set_etape_context(self.etape)
 412          new_objet = Accas.CO(nom_co)
 413          CONTEXT.unset_current_step()
 414          CONTEXT.set_current_step(cs)
 415       self.init_modif()
 416       self.valeur = new_objet
 417       self.val = new_objet
 418       self.fin_modif()
 419       step.reset_context()
 420       # On force l'enregistrement de new_objet en tant que concept produit
 421       # de la macro en appelant get_type_produit avec force=1
 422       self.etape.get_type_produit(force=1)
 423       #print "set_valeur_co",new_objet
 424       return 1,"Concept créé"
 425
 426   def verif_existence_sd(self):
 427      """
 428         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 429         avant étape, sinon enlève la référence à ces concepts
 430      """
 431      #print "verif_existence_sd"
 432      # Attention : possible probleme avec include
 433      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
 434      if type(self.valeur) in (types.TupleType,types.ListType) :
 435        l=[]
 436        self.init_modif()
 437        for sd in self.valeur:
 438          if isinstance(sd,ASSD) :
 439             if sd in l_sd_avant_etape :
 440                l.append(sd)
 441          else:
 442             l.append(sd)
 443        self.valeur=tuple(l)
 444        self.fin_modif()
 445      else:
 446        if isinstance(self.valeur,ASSD) :
 447           if self.valeur not in l_sd_avant_etape :
 448              self.init_modif()
 449              self.valeur = None
 450              self.fin_modif()
 451
 452   def get_min_max(self):
 453      """
 454      Retourne les valeurs min et max admissibles pour la valeur de self
 455      """
 456      return self.definition.min,self.definition.max
 457
 458
 459   def get_type(self):
 460      """
 461      Retourne le type attendu par le mot-clé simple
 462      """
 463      return self.definition.type
 464
 465   def delete_mc_global(self):
 466       """ Retire self des declarations globales
 467       """
 468       if self.definition.position == 'global' :
 469          etape = self.get_etape()
 470          if etape :
 471             del etape.mc_globaux[self.nom]
 472       elif self.definition.position == 'global_jdc' :
 473          del self.jdc.mc_globaux[self.nom]
 474
 475   def update_mc_global(self):
 476      """
 477         Met a jour les mots cles globaux enregistrés dans l'étape parente
 478         et dans le jdc parent.
 479         Un mot cle simple peut etre global.
 480      """
 481      if self.definition.position == 'global' :
 482         etape = self.get_etape()
 483         if etape :
 484            etape.mc_globaux[self.nom]=self
 485      elif self.definition.position == 'global_jdc' :
 486         if self.jdc:
 487            self.jdc.mc_globaux[self.nom]=self
 488
 489 #--------------------------------------------------------------------------------
 490 # PN : ajout pour Salome des methodes suivantes (jusqu aux méthodes surchargees)
 491 #--------------------------------------------------------------------------------
 492   def get_salome_valeurs(self):
 493        l=[]
 494        if not hasattr(self,'list_salome_valeurs'):
 495            self.list_salome_valeurs=[]
 496        if self.list_salome_valeurs != [] :
 497            for val in self.list_salome_valeurs:
 498                 l.append(val)
 499        return l
 500
 501   def put_salome_valeurs(self,list):
 502        self.list_salome_valeurs=[]
 503        for val in list:
 504            self.list_salome_valeurs.append(val)
 505
 506   def add_salome_valeurs(self,val):
 507       if not hasattr(self,'list_salome_valeurs'):
 508            self.list_salome_valeurs=[]
 509       try:
 510            self.list_salome_valeurs.append(val)
 511       except :
 512            try:
 513               for uneval in val :
 514                   self.list_salome_valeurs.append(uneval)
 515            except :
 516               pass
 517
 518   def has_salome_valeurs(self):
 519       if not hasattr(self,'list_salome_valeurs'):
 520            self.list_salome_valeurs=[]
 521       if self.list_salome_valeurs != []:
 522            return true
 523       else:
 524            return false
 525
 526 #--------------------------------------------------------------------------------
 527 # PN : fin ajout pour Salome
 528 #--------------------------------------------------------------------------------
 529
 530 #ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
 531 # Elles doivent etre reintegrees des que possible
 532
 533
 534   def isvalid(self,cr='non'):
 535       """
 536          Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
 537
 538            - 0 si l'objet est invalide
 539            - 1 si l'objet est valide
 540
 541          Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
 542          la méthode construit également un comte-rendu de validation
 543          dans self.cr qui doit avoir été créé préalablement.
 544       """
 545       if self.state == 'unchanged':
 546         return self.valid
 547       else:
 548         valid = 1
 549         v=self.valeur
 550         #  verification presence
 551         if self.isoblig() and v == None :
 552           if cr == 'oui' :
 553             self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
 554           valid = 0
 555
 556         if v is None:
 557            valid=0
 558            if cr == 'oui' :
 559               self.cr.fatal("None n'est pas une valeur autorisée")
 560         else:
 561            # type,into ...
 562            if v.__class__.__name__ in ('PARAMETRE' , 'EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
 563               verif_type=1
 564            else:
 565               verif_type=self.verif_type(val=v,cr=None)
 566               # cas des tuples avec un ITEM_PARAMETRE
 567               if verif_type == 0:
 568                  if type(v) == types.TupleType :
 569                    new_val=[]
 570                    for i in v:
 571                      if i.__class__.__name__  not in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
 572                           new_val.append(i)
 573                    if new_val != [] :
 574                      verif_type=self.verif_type(val=new_val,cr=cr)
 575                    else :
 576                      # Cas d une liste de paramétre
 577                      verif_type= 1
 578                  else:
 579                      verif_type=self.verif_type(val=v,cr=cr)
 580            valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
 581            #
 582            # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
 583            #
 584            if valid and self.definition.validators and not self.definition.validators.verif(self.valeur):
 585               if cr == 'oui' :
 586                  self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
 587               valid=0
 588            # fin des validateurs
 589            #
 590         # cas d un item Parametre
 591         if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
 592            valid=self.valeur.isvalid()
 593            if valid == 0:
 594               if cr == 'oui' :
 595                  self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
 596
 597         self.set_valid(valid)
 598         return self.valid
 599
 600