]> SALOME platform Git repositories - tools/eficas.git/blob - Ihm/I_MCLIST.py
Salome HOME
8dc1e87aa1a376bd8162ec0a46765b8411f346b7
[tools/eficas.git] / 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_precise(self):
223      if self.parent: 
224         return self.parent.get_genealogie_precise()
225      else:
226         return []
227
228   def get_genealogie(self):
229      """
230          Retourne la liste des noms des ascendants.
231          Un objet MCList n'est pas enregistré dans la genealogie.
232          XXX Meme si le MCFACT fils ne l'est pas lui non plus ????
233      """
234      if self.parent: 
235         return self.parent.get_genealogie()
236      else:
237         return []
238
239   def get_liste_mc_ordonnee_brute(self,liste,dico):
240      """
241          Retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés
242          d'une entité composée dont le chemin complet est donné sous forme
243          d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
244      """
245      for arg in liste:
246         objet_cata = dico[arg]
247         dico=objet_cata.entites
248      return objet_cata.ordre_mc
249
250   def verif_existence_sd(self):
251      """
252         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
253         avant étape, sinon enlève la référence à ces concepts
254      """
255      for motcle in self.data :
256          motcle.verif_existence_sd()
257
258   def get_fr(self):
259      """
260          Retourne la chaine d'aide contenue dans le catalogue
261          en tenant compte de la langue
262      """
263      try :
264         return self.data[0].get_fr()
265      except:
266         return ''
267
268   def normalize(self):
269      """
270         Retourne l'objet normalisé. Une liste est déjà normalisée
271      """
272      return self
273
274   def update_mc_global(self):
275      """
276         Met a jour les mots cles globaux enregistrés dans l'étape parente
277         et dans le jdc parent.
278         Une liste ne peut pas etre globale. Elle se contente de passer
279         la requete a ses fils.
280      """
281      for motcle in self.data :
282          motcle.update_mc_global()
283
284   def delete_mc_global(self):
285      for motcle in self.data :
286          motcle.delete_mc_global()
287
288   #def __del__(self):
289   #   print "__del__",self