Ihm/I_MCLIST.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,traceback
  22 from copy import copy
  23 import CONNECTOR
  24
  25 class MCList:
  26   def isMCList(self):
  27     """
  28        Retourne 1 si self est une MCList (liste de mots-clés), 0 sinon (défaut)
  29     """
  30     return 1
  31
  32   def get_index(self,objet):
  33     """
  34         Retourne la position d'objet dans la liste self
  35     """
  36     return self.data.index(objet)
  37
  38   def ajout_possible(self):
  39     """
  40         Méthode booléenne qui retourne 1 si on peut encore ajouter une occurrence
  41         de l'élément que contient self, 0 sinon
  42     """
  43     max = self.data[0].definition.max
  44     if max == '**':
  45       return 1
  46     else:
  47       if len(self) < max :
  48         return 1
  49       else:
  50         return 0
  51
  52   def isrepetable(self):
  53     """
  54        Indique si l'objet est répétable.
  55        Retourne 1 si le mot-clé facteur self peut être répété
  56        Retourne 0 dans le cas contraire
  57     """
  58     if self.data[0].definition.max > 1:
  59        # marche avec '**'
  60        return 1
  61     else :
  62        return 0
  63
  64   def isoblig(self):
  65      """
  66      Une MCList n'est jamais obligatoire (même si le MCFACT qu'elle représente l'est
  67      """
  68      return self.data[0].definition.statut=='o'
  69
  70   def suppentite(self,obj):
  71       """
  72         Supprime le mot cle facteur obj de la MCLIST
  73       """
  74       if obj not in self:
  75          return 0
  76
  77       self.init_modif()
  78       self.remove(obj)
  79       CONNECTOR.Emit(self,"supp",obj)
  80       self.update_condition_bloc()
  81       obj.supprime()
  82       self.etape.modified()
  83       self.fin_modif()
  84       return 1
  85
  86   def addentite(self,obj,pos=None):
  87       """
  88         Ajoute le mot cle facteur obj a la MCLIST a la position pos
  89         Retourne None si l'ajout est impossible
  90       """
  91       if type(obj)==types.StringType :
  92          # on est en mode création d'un motcle
  93          raise "traitement non prevu"
  94
  95       if not self.ajout_possible():
  96          self.jdc.appli.affiche_alerte("Erreur","L'objet %s ne peut pas être ajouté" % obj.nom)
  97          return None
  98
  99       if self.nom != obj.nom:
 100          return None
 101
 102       if obj.isMCList():
 103          obj=obj.data[0]
 104
 105       # Traitement du copier coller seulement
 106       # Les autres cas d'ajout sont traites dans MCFACT
 107       self.init_modif()
 108       obj.verif_existence_sd()
 109       obj.reparent(self.parent)
 110       if pos is None:
 111          self.append(obj)
 112       else:
 113          self.insert(pos,obj)
 114       CONNECTOR.Emit(self,"add",obj)
 115       self.fin_modif()
 116       self.update_condition_bloc()
 117       return obj
 118
 119   def liste_mc_presents(self):
 120     return []
 121
 122   def update_concept(self,sd):
 123     for child in self.data :
 124         child.update_concept(sd)
 125
 126   def delete_concept(self,sd):
 127     """
 128         Inputs :
 129            - sd=concept detruit
 130         Fonction : Mettre a jour les fils de l objet suite à la disparition
 131         du concept sd
 132         Seuls les mots cles simples MCSIMP font un traitement autre
 133         que de transmettre aux fils
 134     """
 135     for child in self.data :
 136       child.delete_concept(sd)
 137
 138   def replace_concept(self,old_sd,sd):
 139     """
 140         Inputs :
 141            - old_sd=concept remplacé
 142            - sd=nouveau concept
 143         Fonction : Mettre a jour les fils de l objet suite au remplacement
 144         du concept old_sd
 145     """
 146     for child in self.data :
 147       child.replace_concept(old_sd,sd)
 148
 149   def get_docu(self):
 150     return self.data[0].definition.get_docu()
 151
 152   def get_liste_mc_inconnus(self):
 153      """
 154      Retourne la liste des mots-clés inconnus dans self
 155      """
 156      l_mc = []
 157      for mcfact in self.data :
 158         if mcfact.isvalid() : continue
 159         l_child = mcfact.get_liste_mc_inconnus()
 160         for mc in l_child:
 161            l = [self]
 162            l.extend(mc)
 163            l_mc.append(l)
 164      return l_mc
 165
 166   def verif_condition_regles(self,liste_presents):
 167     """
 168         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 169         en fonction de la liste des mots-clés présents
 170     """
 171     # Sans objet pour une liste de mots clés facteurs
 172     return []
 173
 174   def deep_update_condition_bloc(self):
 175      """
 176         Parcourt l'arborescence des mcobject et realise l'update
 177         des blocs conditionnels par appel de la methode update_condition_bloc
 178      """
 179      #print "deep_update_condition_bloc",self
 180      for mcfact in self.data :
 181          mcfact.deep_update_condition_bloc()
 182
 183   def update_condition_bloc(self):
 184      """
 185         Propage la mise a jour des conditions au parent.
 186         Une liste ne fait pas de traitement sur les conditions
 187      """
 188      if self.parent: self.parent.update_condition_bloc()
 189
 190   def verif_condition_bloc(self):
 191     """
 192         Evalue les conditions de tous les blocs fils possibles
 193         (en fonction du catalogue donc de la définition) de self et
 194         retourne deux listes :
 195            - la première contient les noms des blocs à rajouter
 196            - la seconde contient les noms des blocs à supprimer
 197     """
 198     # Sans objet pour une liste de mots clés facteurs (a voir !!!)
 199     return [],[]
 200
 201   def init_modif(self):
 202     """
 203        Met l'état de l'objet à modified et propage au parent
 204        qui vaut None s'il n'existe pas
 205     """
 206     self.state = 'modified'
 207     if self.parent:
 208       self.parent.init_modif()
 209
 210   def fin_modif(self):
 211     """
 212       Méthode appelée après qu'une modification a été faite afin de déclencher
 213       d'éventuels traitements post-modification
 214     """
 215     #print "fin_modif",self
 216     CONNECTOR.Emit(self,"valid")
 217     if self.parent:
 218       self.parent.fin_modif()
 219
 220   def get_genealogie(self):
 221      """
 222          Retourne la liste des noms des ascendants.
 223          Un objet MCList n'est pas enregistré dans la genealogie.
 224          XXX Meme si le MCFACT fils ne l'est pas lui non plus ????
 225      """
 226      if self.parent:
 227         return self.parent.get_genealogie()
 228      else:
 229         return []
 230
 231   def get_liste_mc_ordonnee_brute(self,liste,dico):
 232      """
 233          Retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés
 234          d'une entité composée dont le chemin complet est donné sous forme
 235          d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
 236      """
 237      for arg in liste:
 238         objet_cata = dico[arg]
 239         dico=objet_cata.entites
 240      return objet_cata.ordre_mc
 241
 242   def verif_existence_sd(self):
 243      """
 244         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 245         avant étape, sinon enlève la référence à ces concepts
 246      """
 247      for motcle in self.data :
 248          motcle.verif_existence_sd()
 249
 250   def get_fr(self):
 251      """
 252          Retourne la chaine d'aide contenue dans le catalogue
 253          en tenant compte de la langue
 254      """
 255      try :
 256         return self.data[0].get_fr()
 257      except:
 258         return ''
 259
 260   def normalize(self):
 261      """
 262         Retourne l'objet normalisé. Une liste est déjà normalisée
 263      """
 264      return self
 265
 266   def update_mc_global(self):
 267      """
 268         Met a jour les mots cles globaux enregistrés dans l'étape parente
 269         et dans le jdc parent.
 270         Une liste ne peut pas etre globale. Elle se contente de passer
 271         la requete a ses fils.
 272      """
 273      for motcle in self.data :
 274          motcle.update_mc_global()
 275
 276   def delete_mc_global(self):
 277      for motcle in self.data :
 278          motcle.delete_mc_global()
 279
 280   #def __del__(self):
 281   #   print "__del__",self