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