Ihm/I_MCLIST.py

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