Ihm/I_MCLIST.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   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.delObjPyxb()
  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.editor.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 deleteRef(self):
 131         for child in self.data :
 132             child.deleteRef()
 133
 134     def deleteConcept(self,sd):
 135         """
 136             Inputs :
 137                - sd=concept detruit
 138             Fonction : Mettre a jour les fils de l objet suite a la disparition
 139             du concept sd
 140             Seuls les mots cles simples MCSIMP font un traitement autre
 141             que de transmettre aux fils
 142         """
 143         for child in self.data :
 144             child.deleteConcept(sd)
 145
 146     def replaceConcept(self,old_sd,sd):
 147         """
 148             Inputs :
 149                - old_sd=concept remplace
 150                - sd=nouveau concept
 151             Fonction : Mettre a jour les fils de l objet suite au remplacement
 152             du concept old_sd
 153         """
 154         for child in self.data :
 155             child.replaceConcept(old_sd,sd)
 156
 157     def getDocu(self):
 158         return self.data[0].definition.getDocu()
 159
 160     def getListeMcInconnus(self):
 161         """
 162         Retourne la liste des mots-cles inconnus dans self
 163         """
 164         l_mc = []
 165         for mcfact in self.data :
 166             if mcfact.isValid() : continue
 167             l_child = mcfact.getListeMcInconnus()
 168             for mc in l_child:
 169                 l = [self]
 170                 l.extend(mc)
 171                 l_mc.append(l)
 172         return l_mc
 173
 174     def verifConditionRegles(self,liste_presents):
 175         """
 176             Retourne la liste des mots-cles a rajouter pour satisfaire les regles
 177             en fonction de la liste des mots-cles presents
 178         """
 179         # Sans objet pour une liste de mots cles facteurs
 180         return []
 181
 182     def deepUpdateConditionBloc(self):
 183         """
 184            Parcourt l'arborescence des mcobject et realise l'update
 185            des blocs conditionnels par appel de la methode updateConditionBloc
 186         """
 187         #print "deepUpdateConditionBloc",self
 188         for mcfact in self.data :
 189             mcfact.deepUpdateConditionBloc()
 190
 191     def updateConditionBloc(self):
 192         """
 193            Propage la mise a jour des conditions au parent.
 194            Une liste ne fait pas de traitement sur les conditions
 195         """
 196         if self.parent: self.parent.updateConditionBloc()
 197
 198     def verifConditionBloc(self):
 199         """
 200             Evalue les conditions de tous les blocs fils possibles
 201             (en fonction du catalogue donc de la definition) de self et
 202             retourne deux listes :
 203                - la premiere contient les noms des blocs a rajouter
 204                - la seconde contient les noms des blocs a supprimer
 205         """
 206         # Sans objet pour une liste de mots cles facteurs (a voir !!!)
 207         return [],[]
 208
 209     def initModif(self):
 210         """
 211            Met l'etat de l'objet a modified et propage au parent
 212            qui vaut None s'il n'existe pas
 213         """
 214         self.state = 'modified'
 215         if self.parent:
 216             self.parent.initModif()
 217
 218     def finModif(self):
 219         """
 220           Methode appelee apres qu'une modification a ete faite afin de declencher
 221           d'eventuels traitements post-modification
 222         """
 223         #print "finModif",self
 224         CONNECTOR.Emit(self,"valid")
 225         if self.parent:
 226             self.parent.finModif()
 227
 228     def getGenealogiePrecise(self):
 229         if self.parent:
 230             return self.parent.getGenealogiePrecise()
 231         else:
 232             return []
 233
 234     def getGenealogie(self):
 235         """
 236             Retourne la liste des noms des ascendants.
 237             Un objet MCList n'est pas enregistre dans la genealogie.
 238             XXX Meme si le MCFACT fils ne l'est pas lui non plus ????
 239         """
 240         if self.parent:
 241             return self.parent.getGenealogie()
 242         else:
 243             return []
 244
 245     def getListeMcOrdonneeBrute(self,liste,dico):
 246         """
 247             Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
 248             d'une entite composee dont le chemin complet est donne sous forme
 249             d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
 250         """
 251         for arg in liste:
 252             objet_cata = dico[arg]
 253             dico=objet_cata.entites
 254         return objet_cata.ordre_mc
 255
 256     def verifExistenceSd(self):
 257         """
 258            Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
 259            avant etape, sinon enleve la reference a ces concepts
 260         """
 261         for motcle in self.data :
 262             motcle.verifExistenceSd()
 263
 264     def getFr(self):
 265         """
 266             Retourne la chaine d'aide contenue dans le catalogue
 267             en tenant compte de la langue
 268         """
 269         try :
 270             return self.data[0].getFr()
 271         except:
 272             return ''
 273
 274     def normalize(self):
 275         """
 276            Retourne l'objet normalise. Une liste est deja normalisee
 277         """
 278         return self
 279
 280     def updateMcGlobal(self):
 281         """
 282            Met a jour les mots cles globaux enregistres dans l'etape parente
 283            et dans le jdc parent.
 284            Une liste ne peut pas etre globale. Elle se contente de passer
 285            la requete a ses fils.
 286         """
 287         for motcle in self.data :
 288             motcle.updateMcGlobal()
 289
 290     def deleteMcGlobal(self):
 291         for motcle in self.data :
 292             motcle.deleteMcGlobal()
 293
 294
 295     #def __del__(self):
 296     #   print "__del__",self