X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MCCOMPO.py;h=a9976a1ce0cee12c8d5750e7c0bfb123b926112c;hb=94531d13450fad5a118e4d39d9693f46eb7e59a0;hp=e392d1b040be53b194b308d813323942144689ca;hpb=58b5829ebf53f3e8fd09707bb5abcdb154107d47;p=tools%2Feficas.git diff --git a/Ihm/I_MCCOMPO.py b/Ihm/I_MCCOMPO.py index e392d1b0..a9976a1c 100644 --- a/Ihm/I_MCCOMPO.py +++ b/Ihm/I_MCCOMPO.py @@ -1,101 +1,108 @@ -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2017 EDF R&D # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. # +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -# ====================================================================== """ """ -import string,types +from __future__ import absolute_import +from __future__ import print_function +import string,types,sys from copy import copy +import traceback -from Noyau.N_MCLIST import MCList +import Validation +from Extensions.i18n import tr from Noyau.N_MCSIMP import MCSIMP from Noyau.N_MCFACT import MCFACT from Noyau.N_MCBLOC import MCBLOC -import I_OBJECT +from Noyau.N_MCLIST import MCList +from . import I_OBJECT + +from . import CONNECTOR class MCCOMPO(I_OBJECT.OBJECT): - def getlabeltext(self): + def getLabelText(self): """ - Retourne le label de self suivant qu'il s'agit d'un MCFACT, - d'un MCBLOC ou d'un MCFACT appartenant à une MCList : - utilisée pour l'affichage dans l'arbre + Retourne le label de self + utilise pour l'affichage dans l'arbre """ - objet = self.parent.get_child(self.nom) - # objet peut-être self ou une MCList qui contient self ... - if isinstance(objet,MCList) : - index = objet.get_index(self)+1 # + 1 à cause de la numérotation qui commence à 0 - label = self.nom +'_'+`index`+':' - return label - else: - return self.nom + return self.nom - def get_liste_mc_ordonnee(self,liste,dico): + def getListeMcOrdonnee(self,liste,dico): """ - Retourne la liste ordonnée (suivant le catalogue) des mots-clés - d'une entité composée dont le chemin complet est donné sous forme + Retourne la liste ordonnee (suivant le catalogue) des mots-cles + d'une entite composee dont le chemin complet est donne sous forme d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... - il faut encore réarranger cette liste (certains mots-clés déjà - présents ne doivent plus être proposés, règles ...) + il faut encore rearranger cette liste (certains mots-cles deja + presents ne doivent plus etre proposes, regles ...) """ - return self.filtre_liste_mc(self.get_liste_mc_ordonnee_brute(liste,dico)) + return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste,dico)) - def get_liste_mc_ordonnee_brute(self,liste,dico): + def getListeMcOrdonneeBrute(self,liste,dico): """ - Retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés - d'une entité composée dont le chemin complet est donné sous forme + Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles + d'une entite composee dont le chemin complet est donne sous forme d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... """ for arg in liste: objet_cata = dico[arg] - dico=objet_cata.dico - return objet_cata.liste + dico=objet_cata.entites + l=[] + specifique=0 + for obj in list(dico.keys()) : + if not(hasattr(dico[obj],'cache')) or dico[obj].cache==0 : + l.append(obj) + else : + specifique=1 + if specifique == 1 : return l + return objet_cata.ordre_mc - def filtre_liste_mc(self,liste_brute): + def filtreListeMc(self,liste_brute): """ - Cette méthode est appelée par EFICAS afin de présenter à - l'utilisateur la liste des enfants possibles de self actualisée - en fonction du contexte de self. En clair, sont supprimés de la - liste des possibles (fournie par la définition), les mots-clés - exclus par les règles de self et les mots-clés ne pouvant plus - être répétés + Cette methode est appelee par EFICAS afin de presenter a + l'utilisateur la liste des enfants possibles de self actualisee + en fonction du contexte de self. En clair, sont supprimes de la + liste des possibles (fournie par la definition), les mots-cles + exclus par les regles de self et les mots-cles ne pouvant plus + etre repetes """ liste = copy(liste_brute) - liste_mc_presents = self.liste_mc_presents() - # on enlève les mots-clés non permis par les règles + listeMcPresents = self.listeMcPresents() + # on enleve les mots-cles non permis par les regles for regle in self.definition.regles: - # la méthode purge_liste est à développer pour chaque règle qui - # influe sur la liste de choix à proposer à l'utilisateur + # la methode purgeListe est a developper pour chaque regle qui + # influe sur la liste de choix a proposer a l'utilisateur # --> EXCLUS,UN_PARMI,PRESENT_ABSENT - liste = regle.purge_liste(liste,liste_mc_presents) - # on enlève les mots-clés dont l'occurrence est déjà atteinte + liste = regle.purgeListe(liste,listeMcPresents) + # on enleve les mots-cles dont l'occurrence est deja atteinte liste_copy = copy(liste) for k in liste_copy: - objet = self.get_child(k,restreint = 'oui') + objet = self.getChild(k,restreint = 'oui') if objet != None : - # l'objet est déjà présent : il faut distinguer plusieurs cas + # l'objet est deja present : il faut distinguer plusieurs cas if isinstance(objet,MCSIMP): - # un mot-clé simple ne peut pas être répété + # un mot-cle simple ne peut pas etre repete liste.remove(k) elif isinstance(objet,MCBLOC): - # un bloc conditionnel ne doit pas apparaître dans la liste de choix + # un bloc conditionnel ne doit pas apparaitre dans la liste de choix liste.remove(k) elif isinstance(objet,MCFACT): - # un mot-clé facteur ne peut pas être répété plus de self.max fois + # un mot-cle facteur ne peut pas etre repete plus de self.max fois if objet.definition.max == 1: liste.remove(k) elif isinstance(objet,MCList): @@ -106,22 +113,22 @@ class MCCOMPO(I_OBJECT.OBJECT): except: pass else : - #XXX CCAR : les MCNUPLET ne sont pas traités - if CONTEXT.debug : print ' ',k,' est un objet de type inconnu :',type(objet) + #XXX CCAR : les MCNUPLET ne sont pas traites + if CONTEXT.debug : print(' ',k,' est un objet de type inconnu :',type(objet)) else : - # l'objet est absent : on enlève de la liste les blocs + # l'objet est absent : on enleve de la liste les blocs if self.definition.entites[k].statut=='c' : liste.remove(k) if self.definition.entites[k].label=='BLOC': liste.remove(k) - # Pour corriger les exces qui pourraient etre commis dans la methode purge_liste + # Pour corriger les exces qui pourraient etre commis dans la methode purgeListe # des regles, on essaie de compenser comme suit : # on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte - for k in liste_mc_presents: + for k in listeMcPresents: if k in liste:continue - objet = self.get_child(k,restreint = 'oui') + objet = self.getChild(k,restreint = 'oui') if isinstance(objet,MCFACT): - # un mot-clé facteur ne peut pas être répété plus de self.max fois + # un mot-cle facteur ne peut pas etre repete plus de self.max fois if objet.definition.max > 1: liste.append(k) elif isinstance(objet,MCList): @@ -130,286 +137,308 @@ class MCCOMPO(I_OBJECT.OBJECT): liste.append(k) return liste - def liste_mc_presents(self): + def listeMcPresents(self): """ - Retourne la liste des noms des mots-clés fils de self présents construite - à partir de self.mc_liste + Retourne la liste des noms des mots-cles fils de self presents construite + a partir de self.mcListe """ l=[] - for v in self.mc_liste: + for v in self.mcListe: k=v.nom l.append(k) return l - def ordonne_liste_mc(self,liste_mc_a_ordonner,liste_noms_mc_ordonnee): + def getIndexChild(self,nom_fils): + """ + Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils + Permet de savoir a quelle position il faut ajouter un nouveau mot-cle + """ + cata_ordonne = self.jdc.cata_ordonne_dico + liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(self.getGenealogie(),cata_ordonne) + liste_noms_mc_presents = self.listeMcPresents() + index=0 + for nom in liste_noms_mc_ordonnee: + if nom == nom_fils:break + if nom not in liste_noms_mc_presents :continue + index=index+1 + return index + + def findRangObjetDsArbre(self,objet) : + # uniquement pour Pyxb + # parcourt les Blocs + leRang=0 + pos=self.mcListe.index(objet) + i=0 + while (i+1) < pos : + leRang= leRang + self.mcListe[i].longueurDsArbre() + i=i+1 + return leRang + + + def ordonneListeMc(self,listeMc_a_ordonner,liste_noms_mc_ordonnee): """ - Retourne liste_mc_a_ordonner ordonnée suivant l'ordre - donné par liste_noms_mc_ordonnee + Retourne listeMc_a_ordonner ordonnee suivant l'ordre + donne par liste_noms_mc_ordonnee """ liste = [] - # on transforme liste_a_ordonner en un dictionnaire (plus facile à consulter) + # on transforme liste_a_ordonner en un dictionnaire (plus facile a consulter) d_mc = {} - for mc in liste_mc_a_ordonner: + for mc in listeMc_a_ordonner: d_mc[mc.nom]=mc - # on construit la liste des objets ordonnés + # on construit la liste des objets ordonnes for nom_mc in liste_noms_mc_ordonnee: - if d_mc.has_key(nom_mc): + if nom_mc in d_mc: liste.append(d_mc.get(nom_mc)) # on la retourne return liste - def suppentite(self,objet) : + def suppEntite(self,objet) : """ Supprime le fils 'objet' de self : - Retourne 1 si la suppression a pu être effectuée, + Retourne 1 si la suppression a pu etre effectuee, Retourne 0 dans le cas contraire """ - self.init_modif() - if not objet in self.mc_liste: - # Impossible de supprimer objet. Il n'est pas dans mc_liste - self.fin_modif() + if not objet in self.mcListe: + # Impossible de supprimer objet. Il n'est pas dans mcListe return 0 - try : - if hasattr(objet.definition,'position'): - if objet.definition.position == 'global' : - self.delete_mc_global(objet) - elif objet.definition.position == 'global_jdc' : - self.delete_mc_global_jdc(objet) - self.mc_liste.remove(objet) - self.fin_modif() - return 1 - except: - self.fin_modif() - return 0 + self.initModif() + #objet.deletePyxbObject() + self.mcListe.remove(objet) + CONNECTOR.Emit(self,"supp",objet) + objet.deleteMcGlobal() + objet.updateConditionBloc() + objet.supprime() + self.etape.modified() + self.finModif() + return 1 - def isoblig(self): - return self.definition.statut=='o' + def isOblig(self): + return 0 - def addentite(self,name,pos=None): + def addEntite(self,name,pos=None): """ - Ajoute le mot-cle name à la liste des mots-cles de + Ajoute le mot-cle name a la liste des mots-cles de l'objet MCCOMPOSE """ - self.init_modif() - if type(name)==types.StringType : - # on est en mode création d'un motcle + self.initModif() + if type(name)==bytes or type(name) == str : + # on est en mode creation d'un motcle if self.ispermis(name) == 0 : return 0 objet=self.definition.entites[name](val=None,nom=name,parent=self) - if hasattr(objet.definition,'position'): - if objet.definition.position == 'global' : - self.append_mc_global(objet) - elif objet.definition.position == 'global_jdc' : - self.append_mc_global_jdc(objet) else : # dans ce cas on est en mode copie d'un motcle - objet = name - objet.verif_existence_sd() - # si un objet de même nom est déjà présent dans la liste - # et si l'objet est répétable - # il faut créer une MCList et remplacer l'objet de la liste - # par la MCList - test1 = objet.isrepetable() - old_obj = self.get_child(objet.nom,restreint = 'oui') - test2 = self.ispermis(objet) - #print "test1,test2=",test1,test2 - if test1 == 0 and old_obj : - self.jdc.send_message("L'objet %s ne peut pas être répété" %objet.nom) - self.fin_modif() - return 0 - if test2 == 0: - self.jdc.send_message("L'objet %s ne peut être un fils de %s" %(objet.nom,self.nom)) - self.fin_modif() + # Appel de la methode qui fait le menage dans les references + # sur les concepts produits (verification que les concepts existent + # dans le contexte de la commande courante). + objet.verifExistenceSd() + + # On verifie que l'ajout d'objet est autorise + if self.ispermis(objet) == 0: + self.jdc.appli.afficheAlerte(tr("Erreur"), + tr("L'objet %(v_1)s ne peut etre un fils de %(v_2)s",\ + {'v_1': objet.nom, 'v_2': self.nom})) + self.finModif() return 0 - if test1 : - if old_obj : - #if not isinstance(old_obj,MCList): - if not old_obj.isMCList(): - # un objet de même nom existe déjà mais ce n'est pas une MCList - # Il faut en créer une - # L'objet existant (old_obj) est certainement un MCFACT - # qui pointe vers un constructeur - # de MCList : definition.liste_instance - #print "un objet de même type existe déjà" - index = self.mc_liste.index(old_obj) - #XXX remplacé par definition.list_instance : new_obj = MCList() - new_obj = old_obj.definition.list_instance() - new_obj.init(objet.nom,self) - new_obj.append(old_obj) - new_obj.append(objet) - # Il ne faut pas oublier de reaffecter le parent d'obj - objet.reparent(self) - self.mc_liste.remove(old_obj) - self.mc_liste.insert(index,new_obj) - self.fin_modif() - return new_obj - else : - # une liste d'objets de même type existe déjà - #print "une liste d'objets de même type existe déjà" - old_obj.append(objet) - # Il ne faut pas oublier de reaffecter le parent d'obj - objet.reparent(self) - self.fin_modif() + + # On cherche s'il existe deja un mot cle de meme nom + old_obj = self.getChild(objet.nom,restreint = 'oui') + if not old_obj : + # on normalize l'objet + objet=objet.normalize() + # Le mot cle n'existe pas encore. On l'ajoute a la position + # demandee (pos) + if pos == None : + self.mcListe.append(objet) + else : + self.mcListe.insert(pos,objet) + # Il ne faut pas oublier de reaffecter le parent d'obj (si copie) + objet.reparent(self) + #objet.addPyxbObject(self.findRangObjetDsArbre(objet)) + CONNECTOR.Emit(self,"add",objet) + objet.updateMcGlobal() + objet.updateConditionBloc() + self.finModif() + return objet + else: + # Le mot cle existe deja. Si le mot cle est repetable, + # on cree une liste d'objets. Dans le cas contraire, + # on emet un message d'erreur. + if not old_obj.isRepetable(): + self.jdc.appli.afficheAlerte(tr("Erreur"),tr("L'objet %s ne peut pas etre repete", objet.nom)) + self.finModif() + return 0 + else: + # une liste d'objets de meme type existe deja + old_obj.addEntite(objet) + self.finModif() return old_obj - if pos == None : - self.mc_liste.append(objet) - else : - self.mc_liste.insert(pos,objet) - # Il ne faut pas oublier de reaffecter le parent d'obj (si copie) - objet.reparent(self) - self.fin_modif() - return objet def ispermis(self,fils): """ Retourne 1 si l'objet de nom nom_fils - est bien permis, cad peut bien être un fils de self, + est bien permis, cad peut bien etre un fils de self, Retourne 0 sinon """ - if type(fils) == types.StringType : + if type(fils) == bytes or type(fils) == str : # on veut juste savoir si self peut avoir un fils de nom 'fils' - if self.definition.entites.has_key(fils): + if fils in self.definition.entites: return 1 else : return 0 - elif type(fils) == types.InstanceType: + #elif type(fils) == types.InstanceType: + elif isinstance(fils,object): # fils est un objet (commande,mcf,mclist) # on est dans le cas d'une tentative de copie de l'objet - # on veut savoir si l'objet peut bien être un fils de self : - # la vérification du nom de suffit pas (plusieurs commandes - # ont le même mot-clé facteur AFFE ... et c'est l'utilisateur - # qui choisit le père d'où un risque d'erreur) - if not self.definition.entites.has_key(fils.nom): + # on veut savoir si l'objet peut bien etre un fils de self : + # la verification du nom de suffit pas (plusieurs commandes + # ont le meme mot-cle facteur AFFE ... et c'est l'utilisateur + # qui choisit le pere d'ou un risque d'erreur) + if not fils.nom in self.definition.entites: return 0 else: if fils.parent.nom != self.nom : return 0 return 1 - def liste_mc_presents(self): - """ - Retourne la liste des noms des mots-clés fils de self présents - construite à partir de self.mc_liste - """ - l=[] - for v in self.mc_liste: - k=v.nom - l.append(k) - return l + def updateConcept(self,sd): + for child in self.mcListe : + child.updateConcept(sd) - def delete_concept(self,sd): + def deleteConcept(self,sd): """ Inputs : - sd=concept detruit + - sd=concept detruit Fonction : - Mettre a jour les fils de l objet suite à la disparition du - concept sd - Seuls les mots cles simples MCSIMP font un traitement autre que - de transmettre aux fils - """ - for child in self.mc_liste : - child.delete_concept(sd) - - def delete_mc_global(self,mc): - """ - Supprime le mot-clé mc de la liste des mots-clés globaux de l'étape + Mettre a jour les fils de l objet suite a la disparition du + concept sd + Seuls les mots cles simples MCSIMP font un traitement autre que + de transmettre aux fils """ - etape = self.get_etape() - if etape : - nom = mc.nom - del etape.mc_globaux[nom] + for child in self.mcListe : + child.deleteConcept(sd) - def delete_mc_global_jdc(self,mc): - """ - Supprime le mot-clé mc de la liste des mots-clés globaux du jdc + def replaceConcept(self,old_sd,sd): """ - nom = mc.nom - del self.jdc.mc_globaux[nom] - - def copy(self): - """ Retourne une copie de self """ - objet = self.makeobjet() - # FR : attention !!! avec makeobjet, objet a le même parent que self - # ce qui n'est pas du tout bon dans le cas d'une copie !!!!!!! - # FR : peut-on passer par là autrement que dans le cas d'une copie ??? - # FR --> je suppose que non - # XXX CCAR : le pb c'est qu'on vérifie ensuite quel parent avait l'objet - # Il me semble preferable de changer le parent a la fin quand la copie est acceptee - objet.valeur = copy(self.valeur) - objet.val = copy(self.val) - objet.mc_liste=[] - for obj in self.mc_liste: - new_obj = obj.copy() - new_obj.reparent(objet) - objet.mc_liste.append(new_obj) - return objet - - def get_sd_utilisees(self): - """ - Retourne la liste des concepts qui sont utilisés à l'intérieur de self - ( comme valorisation d'un MCS) + Inputs : + - old_sd=concept remplace + - sd = nouveau concept + Fonction : + Mettre a jour les fils de l objet suite au remplacement du + concept old_sd """ - l=[] - for child in self.mc_liste: - l.extend(child.get_sd_utilisees()) - return l + for child in self.mcListe : + child.replaceConcept(old_sd,sd) - def get_liste_mc_inconnus(self): + def getListeMcInconnus(self): """ - Retourne la liste des mots-clés inconnus dans self + Retourne la liste des mots-cles inconnus dans self """ l_mc = [] if self.reste_val != {}: for k,v in self.reste_val.items() : - l_mc.append([self,k,v]) - for child in self.mc_liste : - if child.isvalid() : continue - l_child = child.get_liste_mc_inconnus() + l_mc.append([self,k,v]) + for child in self.mcListe : + if child.isValid() : continue + l_child = child.getListeMcInconnus() for mc in l_child: - l = [self] - l.extend(mc) - l_mc.append(l) + l = [self] + l.extend(mc) + l_mc.append(l) return l_mc - def verif_condition_bloc(self): + def deepUpdateConditionBloc(self): + """ + Parcourt l'arborescence des mcobject et realise l'update + des blocs conditionnels par appel de la methode updateConditionBloc + """ + self._updateConditionBloc() + for mcobj in self.mcListe: + if hasattr(mcobj,"deepUpdateConditionBloc"): + mcobj.deepUpdateConditionBloc() + + def updateConditionBloc(self): + """ + Realise l'update des blocs conditionnels fils de self + et propage au parent + """ + self._updateConditionBloc() + if self.parent:self.parent.updateConditionBloc() + + def _updateConditionBloc(self): + """ + Realise l'update des blocs conditionnels fils de self + """ + dict = self.creeDictCondition(self.mcListe,condition=1) + for k,v in self.definition.entites.items(): + if v.label != 'BLOC' :continue + globs= self.jdc and self.jdc.condition_context or {} + bloc=self.getChild(k,restreint = 'oui') + presence=v.verifPresence(dict,globs) + if presence and not bloc: + # le bloc doit etre present + # mais le bloc n'est pas present et il doit etre cree + #print "AJOUT BLOC",k + pos=self.getIndexChild(k) + self.addEntite(k,pos) + if not presence and bloc: + # le bloc devrait etre absent + # le bloc est present : il faut l'enlever + #print "SUPPRESSION BLOC",k,bloc + self.suppEntite(bloc) + + def verifConditionBloc(self): """ Evalue les conditions de tous les blocs fils possibles - (en fonction du catalogue donc de la définition) de self + (en fonction du catalogue donc de la definition) de self et retourne deux listes : - - la première contient les noms des blocs à rajouter - - la seconde contient les noms des blocs à supprimer + - la premiere contient les noms des blocs a rajouter + - la seconde contient les noms des blocs a supprimer """ liste_ajouts = [] liste_retraits = [] - dict = self.cree_dict_valeurs(self.mc_liste) + dict = self.creeDictCondition(self.mcListe,condition=1) for k,v in self.definition.entites.items(): - #dict = self.cree_dict_valeurs(self.mc_liste) if v.label=='BLOC' : - if v.verif_presence(dict) : - # le bloc doit être présent - if not self.get_child(k,restreint = 'oui'): - # le bloc n'est pas présent et il doit être créé + globs= self.jdc and self.jdc.condition_context or {} + if v.verifPresence(dict,globs): + # le bloc doit etre present + if not self.getChild(k,restreint = 'oui'): + # le bloc n'est pas present et il doit etre cree liste_ajouts.append(k) else : - # le bloc doit être absent - if self.get_child(k,restreint = 'oui'): - # le bloc est présent : il faut l'enlever + # le bloc doit etre absent + if self.getChild(k,restreint = 'oui'): + # le bloc est present : il faut l'enlever liste_retraits.append(k) return liste_ajouts,liste_retraits - def reparent(self,parent): + def verifExistenceSd(self): """ - Cette methode sert a reinitialiser la parente de l'objet + Verifie que les structures de donnees utilisees dans self existent bien dans le contexte + avant etape, sinon enleve la reference a ces concepts """ - self.parent=parent - self.jdc=parent.get_jdc_root() - self.etape=parent.etape - for mocle in self.mc_liste: - mocle.reparent(self) + for motcle in self.mcListe : + motcle.verifExistenceSd() - def verif_existence_sd(self): + def updateMcGlobal(self): """ - Vérifie que les structures de données utilisées dans self existent bien dans le contexte - avant étape, sinon enlève la référence à ces concepts + Met a jour les mots cles globaux enregistres dans l'etape parente + et dans le jdc parent. + Un mot cle compose ne peut pas etre global. Il se contente de passer + la requete a ses fils. """ - for motcle in self.mc_liste : - motcle.verif_existence_sd() + for motcle in self.mcListe : + motcle.updateMcGlobal() + + def deleteMcGlobal(self): + for motcle in self.mcListe : + motcle.deleteMcGlobal() + try : + motcle.updateMcGlobal() + except : + pass + + def initModifUp(self): + Validation.V_MCCOMPO.MCCOMPO.initModifUp(self) + CONNECTOR.Emit(self,"valid") +