X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Extensions%2Fjdc_include.py;h=2e5a9ab7c932e1b07477c99d870c97ebb48a4acc;hb=db67610817b210277c799d3650f895c433d9a798;hp=b24069378fe51bfc2170cce5a4c86226365a6340;hpb=578058947e04a832de2c3fbaad40acc063c283d5;p=tools%2Feficas.git diff --git a/Extensions/jdc_include.py b/Extensions/jdc_include.py index b2406937..2e5a9ab7 100644 --- a/Extensions/jdc_include.py +++ b/Extensions/jdc_include.py @@ -1,3 +1,23 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2013 EDF R&D +# +# 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. +# +# 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 +# + """ Ce module contient la classe JDC_INCLUDE qui sert a inclure dans un jeu de commandes une partie de jeu de commandes @@ -6,14 +26,17 @@ que le jeu de commandes inclus est valide et compatible avec le contexte avant et apres l'insertion """ +from __future__ import absolute_import +import string from Accas import JDC,ASSD,AsException,JDC_CATA - +from Ihm import CONNECTOR class JDC_POURSUITE(JDC): def __init__(self,definition=None,procedure=None,cata=None, cata_ord_dico=None,parent=None, nom='SansNom',appli=None,context_ini=None, - jdc_pere=None,etape_include=None,prefix_include=None,**args): + jdc_pere=None,etape_include=None,prefix_include=None, + recorded_units=None,old_recorded_units=None,**args): JDC.__init__(self, definition=definition, procedure=procedure, @@ -28,6 +51,11 @@ class JDC_POURSUITE(JDC): self.jdc_pere=jdc_pere self.etape_include=etape_include self.prefix_include=prefix_include + if recorded_units is not None:self.recorded_units=recorded_units + if old_recorded_units is not None:self.old_recorded_units=old_recorded_units + + def o_register(self,sd): + return self.jdc_pere.o_register(sd) def NommerSdprod(self,sd,sdnom,restrict='non'): """ @@ -35,21 +63,44 @@ class JDC_POURSUITE(JDC): non utilise Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU) Si le nom est deja utilise, leve une exception - Met le concept créé dans le concept global g_context + Met le concept cree dans le contexe global g_context """ + #print "NommerSdprod",sd,sdnom,restrict if self.prefix_include: if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom + + if sdnom != '' and sdnom[0] == '_': + # Si le nom du concept commence par le caractere _ on lui attribue + # un identificateur automatique comme dans JEVEUX (voir gcncon) + # + # nom commencant par __ : il s'agit de concepts qui seront detruits + # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes + # ATTENTION : il faut traiter differemment les concepts dont le nom + # commence par _ mais qui sont des concepts nommes automatiquement par + # une eventuelle sous macro. + if sdnom[1] in string.digits: + # Ce concept provient probablement d'une sous macro (cas improbable) + #pas de renommage + pass + elif sdnom[1] == '_': + #cas d'un concept a ne pas conserver apres execution de la commande + sdnom=sd.id[2:] + pass + else: + sdnom=sd.id[2:] + pass + o=self.sds_dict.get(sdnom,None) if isinstance(o,ASSD): - raise AsException("Nom de concept deja defini : %s" % sdnom) - # Il faut verifier en plus que le jdc_pere apres l'etape etape_include - # ne contient pas deja un concept de ce nom + raise AsException(tr("Nom de concept deja defini : %s" ,sdnom)) - mysd= self.jdc_pere.get_sd_apres_etape(sdnom,etape=self.etape_include) - if mysd: - #if self.jdc_pere.get_sd_apres_etape(sdnom,etape=self.etape_include): + # On pourrait verifier que le jdc_pere apres l'etape etape_include + # ne contient pas deja un concept de ce nom + #if self.jdc_pere.get_sd_apres_etape_avec_detruire(sdnom,etape=self.etape_include): # Il existe un concept apres self => impossible d'inserer - raise AsException("Nom de concept deja defini : %s" % sdnom) + # raise AsException("Nom de concept deja defini : %s" % sdnom) + # On a choisi de ne pas faire ce test ici mais de le faire en bloc + # si necessaire apres en appelant la methode verif_contexte # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja. # Ajoute a la creation (appel de reg_sd). @@ -60,7 +111,237 @@ class JDC_POURSUITE(JDC): if restrict == 'non': self.g_context[sdnom]=sd + def get_verif_contexte(self): + #print "get_verif_contexte" + j_context=self.get_contexte_avant(None) + self.verif_contexte(j_context) + return j_context + + def force_contexte(self,contexte): + for nom_sd,sd in list(contexte.items()): + if not isinstance(sd,ASSD):continue + autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd, + etape=self.etape_include) + if autre_sd is None:continue + if sd is not autre_sd: + # Il existe un autre concept de meme nom produit par une etape apres self + # on detruit ce concept pour pouvoir inserer les etapes du jdc_include + if sd.etape: + sd.etape.supprime_sdprod(sd) + + return contexte + + def verif_contexte(self,context): + """ + Cette methode verifie si le contexte passe en argument (context) + peut etre insere dans le jdc pere de l'include. + Elle verifie que les concepts contenus dans ce contexte n'entrent + pas en conflit avec les concepts produits dans le jdc pere + apres l'include. + Si le contexte ne peut pas etre insere, la methode leve une + exception sinon elle retourne le contexte inchange + """ + #print "verif_contexte" + for nom_sd,sd in list(context.items()): + if not isinstance(sd,ASSD):continue + autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd, + etape=self.etape_include) + if autre_sd is None:continue + if sd is not autre_sd: + # Il existe un concept produit par une etape apres self + # => impossible d'inserer + raise Exception("Impossible d'inclure le fichier. Un concept de nom " + + "%s existe deja dans le jeu de commandes." % nom_sd) + + return context + + def get_liste_cmd(self): + """ + Retourne la liste des commandes du catalogue + """ + if self.jdc_pere is None: + return JDC.get_liste_cmd(self) + return self.jdc_pere.get_liste_cmd() + + def get_groups(self): + """ + Retourne la liste des commandes du catalogue par groupes + """ + if self.jdc_pere is None: + return JDC.get_groups(self) + return self.jdc_pere.get_groups() + + def init_modif(self): + """ + Met l'etat de l'etape a : modifie + Propage la modification au parent + + Attention : init_modif doit etre appele avant de realiser une modification + La validite devra etre recalculee apres cette modification + mais par un appel a fin_modif pour preserver l'etat modified + de tous les objets entre temps + """ + #print "jdc_include.init_modif",self,self.etape_include + self.state = 'modified' + if self.etape_include: + self.etape_include.init_modif() + + def fin_modif(self): + """ + Methode appelee une fois qu'une modification a ete faite afin de + declencher d'eventuels traitements post-modification + ex : INCLUDE et POURSUITE + """ + #print "jdc_include.fin_modif",self,self.etape_include + CONNECTOR.Emit(self,"valid") + if self.etape_include: + self.etape_include.fin_modif() + + def supprime(self): + """ + On ne supprime rien directement pour un jdc auxiliaire d'include ou de poursuite + Utiliser supprime_aux + """ + pass + + def supprime_aux(self): + #print "supprime_aux",self + JDC.supprime(self) + self.jdc_pere=None + self.etape_include=None + # self.cata_ordonne_dico={} + self.appli=None + # self.context_ini={} + # self.procedure=None + + def get_contexte_avant(self,etape): + """ + Retourne le dictionnaire des concepts connus avant etape + On tient compte des concepts produits par le jdc pere + en reactualisant le contexte initial context_ini + On tient compte des commandes qui modifient le contexte + comme DETRUIRE ou les macros + Si etape == None, on retourne le contexte en fin de JDC + """ + #print "jdc_include.get_contexte_avant",etape,etape and etape.nom + if self.etape_include: + new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy() + self.context_ini=new_context + d= JDC.get_contexte_avant(self,etape) + return d + + def reset_context(self): + #print "jdc_include.reset_context",self,self.nom + if self.etape_include: + self.etape_include.parent.reset_context() + new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy() + self.context_ini=new_context + JDC.reset_context(self) + + def get_sd_apres_etape(self,nom_sd,etape,avec='non'): + """ + Cette methode retourne la SD de nom nom_sd qui est eventuellement + definie apres etape + Si avec vaut 'non' exclut etape de la recherche + """ + if self.etape_include: + sd=self.etape_include.parent.get_sd_apres_etape(nom_sd,self.etape_include,'non') + if sd:return sd + return JDC.get_sd_apres_etape(self,nom_sd,etape,avec) + + def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'): + """ + On veut savoir ce que devient le concept sd de nom nom_sd apres etape. + Il peut etre detruit, remplace ou conserve + Cette methode retourne la SD sd de nom nom_sd qui est eventuellement + definie apres etape en tenant compte des concepts detruits + Si avec vaut 'non' exclut etape de la recherche + """ + #print "jdc_include.get_sd_apres_etape_avec_detruire",nom_sd,sd,id(sd) + autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec) + # si autre_sd vaut None le concept sd a ete detruit. On peut terminer + # la recherche en retournant None + # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer + # la recherche en retournant le concept nouvellement defini + # Sinon, on poursuit la recherche dans les etapes du niveau superieur. + if autre_sd is None or autre_sd is not sd :return autre_sd + return self.etape_include.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,self.etape_include,'non') + + def delete_concept(self,sd): + """ + Fonction : Mettre a jour les etapes du JDC suite a la disparition du + concept sd + Seuls les mots cles simples MCSIMP font un traitement autre + que de transmettre aux fils + """ + # Nettoyage des etapes de l'include + JDC.delete_concept(self,sd) + # Nettoyage des etapes du parent + if self.etape_include: + self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd) + + def delete_concept_after_etape(self,etape,sd): + """ + Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite a + la disparition du concept sd + """ + # Nettoyage des etapes de l'include + JDC.delete_concept_after_etape(self,etape,sd) + # Nettoyage des etapes du parent + if self.etape_include: + self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd) + + def update_concept_after_etape(self,etape,sd): + """ + Fonction : mettre a jour les etapes du JDC suite a une modification + du concept sd (principalement renommage) + """ + JDC.update_concept_after_etape(self,etape,sd) + if self.etape_include: + self.etape_include.parent.update_concept_after_etape(self.etape_include,sd) + + def replace_concept_after_etape(self,etape,old_sd,sd): + """ + Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite au + remplacement du concept old_sd par sd + """ + # Nettoyage des etapes de l'include + JDC.replace_concept_after_etape(self,etape,old_sd,sd) + # Nettoyage des etapes du parent + if self.etape_include: + self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd) + + def changefichier(self,fichier): + if self.etape_include: + self.etape_include.fichier_ini=fichier + self.fin_modif() + + def control_context_apres(self,etape): + """ + Cette methode verifie que les etapes apres l'etape etape + ont bien des concepts produits acceptables (pas de conflit de + nom principalement) + Si des concepts produits ne sont pas acceptables ils sont supprimes. + Effectue les verifications sur les etapes du jdc mais aussi sur les + jdc parents s'ils existent. + """ + #print "jdc_include.control_context_apres",self,etape + #Regularise les etapes du jdc apres l'etape etape + self.control_jdc_context_apres(etape) + if self.etape_include: + #print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom + # il existe un jdc pere. On propage la regularisation + self.etape_include.parent.control_context_apres(self.etape_include) + class JDC_INCLUDE(JDC_POURSUITE): + def get_liste_cmd(self): + """ + Retourne la liste des commandes du catalogue + """ + if self.jdc_pere is None: + return JDC.get_liste_cmd(self) + return [e for e in self.jdc_pere.get_liste_cmd() if e not in ("DEBUT","POURSUITE","FIN") ] + def active_etapes(self): for e in self.etapes: e.active() @@ -73,7 +354,9 @@ class JDC_CATA_POURSUITE(JDC_CATA): from Accas import AU_MOINS_UN,A_CLASSER -JdC_include=JDC_CATA_INCLUDE(code='ASTER', execmodul=None) +import prefs +c=prefs.code +JdC_include=JDC_CATA_INCLUDE(code=c, execmodul=None) JdC_poursuite=JDC_CATA_POURSUITE(code='ASTER', execmodul=None, regles = (AU_MOINS_UN('DEBUT','POURSUITE'),