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