Ihm/I_MCLIST.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2017   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 getIndex(self,objet):
  35     """
  36         Retourne la position d'objet dans la liste self
  37     """
  38     return self.data.index(objet)
  39
  40   def ajoutPossible(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.initModif()
  80       self.remove(obj)
  81       CONNECTOR.Emit(self,"supp",obj)
  82       self.updateConditionBloc()
  83       #obj.deletePyxbObject()
  84       obj.supprime()
  85       self.etape.modified()
  86       self.finModif()
  87       return 1
  88
  89   def addEntite(self,obj,pos=None):
  90       """
  91         Ajoute le mot cle facteur obj a la MCLIST a la position pos
  92         Retourne None si l'ajout est impossible
  93       """
  94       if type(obj)==bytes or type(obj) == str :
  95          # on est en mode creation d'un motcle
  96                   raise EficasException(tr("traitement non-prevu"))
  97
  98       if not self.ajoutPossible():
  99          self.jdc.appli.afficheAlerte(tr("Erreur"),
 100                                        tr("L'objet %s ne peut pas etre ajoute", obj.nom))
 101          return None
 102
 103       if self.nom != obj.nom:
 104          return None
 105
 106       if obj.isMCList():
 107          obj=obj.data[0]
 108
 109       # traitement du copier coller seulement
 110       # Les autres cas d'ajout sont traites dans MCFACT
 111       self.initModif()
 112       obj.verifExistenceSd()
 113       obj.reparent(self.parent)
 114       if pos is None:
 115          self.append(obj)
 116       else:
 117          self.insert(pos,obj)
 118       CONNECTOR.Emit(self,"add",obj)
 119       self.finModif()
 120       self.updateConditionBloc()
 121       return obj
 122
 123   def listeMcPresents(self):
 124     return []
 125
 126   def updateConcept(self,sd):
 127     for child in self.data :
 128         child.updateConcept(sd)
 129
 130   def deleteConcept(self,sd):
 131     """
 132         Inputs :
 133            - sd=concept detruit
 134         Fonction : Mettre a jour les fils de l objet suite a la disparition
 135         du concept sd
 136         Seuls les mots cles simples MCSIMP font un traitement autre
 137         que de transmettre aux fils
 138     """
 139     for child in self.data :
 140       child.deleteConcept(sd)
 141
 142   def replaceConcept(self,old_sd,sd):
 143     """
 144         Inputs :
 145            - old_sd=concept remplace
 146            - sd=nouveau concept
 147         Fonction : Mettre a jour les fils de l objet suite au remplacement
 148         du concept old_sd
 149     """
 150     for child in self.data :
 151       child.replaceConcept(old_sd,sd)
 152
 153   def getDocu(self):
 154     return self.data[0].definition.getDocu()
 155
 156   def getListeMcInconnus(self):
 157      """
 158      Retourne la liste des mots-cles inconnus dans self
 159      """
 160      l_mc = []
 161      for mcfact in self.data :
 162         if mcfact.isValid() : continue
 163         l_child = mcfact.getListeMcInconnus()
 164         for mc in l_child:
 165            l = [self]
 166            l.extend(mc)
 167            l_mc.append(l)
 168      return l_mc
 169
 170   def verifConditionRegles(self,liste_presents):
 171     """
 172         Retourne la liste des mots-cles a rajouter pour satisfaire les regles
 173         en fonction de la liste des mots-cles presents
 174     """
 175     # Sans objet pour une liste de mots cles facteurs
 176     return []
 177
 178   def deepUpdateConditionBloc(self):
 179      """
 180         Parcourt l'arborescence des mcobject et realise l'update
 181         des blocs conditionnels par appel de la methode updateConditionBloc
 182      """
 183      #print "deepUpdateConditionBloc",self
 184      for mcfact in self.data :
 185          mcfact.deepUpdateConditionBloc()
 186
 187   def updateConditionBloc(self):
 188      """
 189         Propage la mise a jour des conditions au parent.
 190         Une liste ne fait pas de traitement sur les conditions
 191      """
 192      if self.parent: self.parent.updateConditionBloc()
 193
 194   def verifConditionBloc(self):
 195     """
 196         Evalue les conditions de tous les blocs fils possibles
 197         (en fonction du catalogue donc de la definition) de self et
 198         retourne deux listes :
 199            - la premiere contient les noms des blocs a rajouter
 200            - la seconde contient les noms des blocs a supprimer
 201     """
 202     # Sans objet pour une liste de mots cles facteurs (a voir !!!)
 203     return [],[]
 204
 205   def initModif(self):
 206     """
 207        Met l'etat de l'objet a modified et propage au parent
 208        qui vaut None s'il n'existe pas
 209     """
 210     self.state = 'modified'
 211     if self.parent:
 212       self.parent.initModif()
 213
 214   def finModif(self):
 215     """
 216       Methode appelee apres qu'une modification a ete faite afin de declencher
 217       d'eventuels traitements post-modification
 218     """
 219     #print "finModif",self
 220     CONNECTOR.Emit(self,"valid")
 221     if self.parent:
 222       self.parent.finModif()
 223
 224   def getGenealogiePrecise(self):
 225      if self.parent:
 226         return self.parent.getGenealogiePrecise()
 227      else:
 228         return []
 229
 230   def getGenealogie(self):
 231      """
 232          Retourne la liste des noms des ascendants.
 233          Un objet MCList n'est pas enregistre dans la genealogie.
 234          XXX Meme si le MCFACT fils ne l'est pas lui non plus ????
 235      """
 236      if self.parent:
 237         return self.parent.getGenealogie()
 238      else:
 239         return []
 240
 241   def getListeMcOrdonneeBrute(self,liste,dico):
 242      """
 243          Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
 244          d'une entite composee dont le chemin complet est donne sous forme
 245          d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
 246      """
 247      for arg in liste:
 248         objet_cata = dico[arg]
 249         dico=objet_cata.entites
 250      return objet_cata.ordre_mc
 251
 252   def verifExistenceSd(self):
 253      """
 254         Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
 255         avant etape, sinon enleve la reference a ces concepts
 256      """
 257      for motcle in self.data :
 258          motcle.verifExistenceSd()
 259
 260   def getFr(self):
 261      """
 262          Retourne la chaine d'aide contenue dans le catalogue
 263          en tenant compte de la langue
 264      """
 265      try :
 266         return self.data[0].getFr()
 267      except:
 268         return ''
 269
 270   def normalize(self):
 271      """
 272         Retourne l'objet normalise. Une liste est deja normalisee
 273      """
 274      return self
 275
 276   def updateMcGlobal(self):
 277      """
 278         Met a jour les mots cles globaux enregistres dans l'etape parente
 279         et dans le jdc parent.
 280         Une liste ne peut pas etre globale. Elle se contente de passer
 281         la requete a ses fils.
 282      """
 283      for motcle in self.data :
 284          motcle.updateMcGlobal()
 285
 286   def deleteMcGlobal(self):
 287      for motcle in self.data :
 288          motcle.deleteMcGlobal()
 289
 290   #def __del__(self):
 291   #   print "__del__",self