X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Extensions%2Fjdc_include.py;h=07a6c94e330e8c7b2512679abdcaabc124ba4960;hb=36ca867c4099d6a804374b8f6a2b897d9ea69a09;hp=0707c5329ea1c2923f97f5deb4903fc295415e6f;hpb=69fda3d1696021785c524ad10b71b18585160981;p=tools%2Feficas.git diff --git a/Extensions/jdc_include.py b/Extensions/jdc_include.py index 0707c532..07a6c94e 100644 --- a/Extensions/jdc_include.py +++ b/Extensions/jdc_include.py @@ -1,3 +1,4 @@ +# -*- coding: utf-8 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -27,14 +28,14 @@ avec le contexte avant et apres l'insertion """ 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, - recorded_units=None,**args): + recorded_units=None,old_recorded_units=None,**args): JDC.__init__(self, definition=definition, procedure=procedure, @@ -50,6 +51,7 @@ class JDC_POURSUITE(JDC): 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 NommerSdprod(self,sd,sdnom,restrict='non'): """ @@ -57,19 +59,22 @@ 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 créé 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 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 + # 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(sdnom,etape=self.etape_include): + #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) + # 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). @@ -80,6 +85,173 @@ class JDC_POURSUITE(JDC): if restrict == 'non': self.g_context[sdnom]=sd + def get_verif_contexte(self): + j_context=self.get_contexte_avant(None) + self.verif_contexte(j_context) + return j_context + + def verif_contexte(self,context): + """ + Cette methode verifie si le contexte passé en argument (context) + peut etre inséré 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 inséré, la méthode leve une + exception sinon elle retourne le contexte inchangé + """ + #print "verif_contexte" + for nom_sd,sd in context.items(): + if not isinstance(sd,ASSD):continue + if self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd, + etape=self.etape_include): + # 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 déjà dans le jeu de commandes." % nom_sd) + + return context + + def get_liste_cmd(self): + """ + Retourne la liste des commandes du catalogue + """ + return self.jdc_pere.get_liste_cmd() + + def get_groups(self): + """ + Retourne la liste des commandes du catalogue par groupes + """ + return self.jdc_pere.get_groups() + + def init_modif(self): + """ + Met l'état de l'étape à : modifié + Propage la modification au parent + + Attention : init_modif doit etre appelé avant de réaliser une modification + La validité devra etre recalculée apres cette modification + mais par un appel à fin_modif pour préserver l'état modified + de tous les objets entre temps + """ + #print "jdc_include.init_modif",self,self.etape_include + self.state = 'modified' + self.etape_include.init_modif() + + def fin_modif(self): + """ + Méthode appelée une fois qu'une modification a été faite afin de + déclencher d'éventuels traitements post-modification + ex : INCLUDE et POURSUITE + """ + #print "jdc_include.fin_modif",self,self.etape_include + + # Mise a jour du contexte en fin d'include + # On suppose que toutes les modifications sont valides + # On recupere le contexte final dans j_context + j_context=self.get_contexte_avant(None) #get_verif_contexte ??? + # On remplit le dictionnaire des concepts produits de l'etape macro INCLUDE + # sans y mettre les concepts présents dans le contexte initial (context_ini) + # On ajoute egalement les concepts produits dans le sds_dict du parent + # sans verification car on est sur (verification integrée) que + # le nommage est possible + self.etape_include.g_context.clear() + for k,v in j_context.items(): + if not self.context_ini.has_key(k) or self.context_ini[k] != v: + self.etape_include.g_context[k]=v + self.etape_include.parent.sds_dict[k]=v + + CONNECTOR.Emit(self,"valid") + self.etape_include.fin_modif() + #print "jdc_include.fin_modif.context_ini",self.context_ini + + def supprime(self): + """ + On ne supprime rien pour un jdc auxiliaire d'include ou de poursuite + """ + pass + + 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 + """ + self.context_ini = self.etape_include.parent.get_contexte_avant(self.etape_include).copy() + return JDC.get_contexte_avant(self,etape) + + #def get_sd_avant_etape(self,nom_sd,etape): + #sd=self.etape_include.parent.get_sd_avant_etape(nom_sd,self.etape_include) + #if sd:return sd + #return JDC.get_sd_avant_etape(self,nom_sd,etape) + + #def get_sd_avant_du_bon_type(self,etape,types_permis): + #""" + # Retourne la liste des concepts avant etape d'un type acceptable + #""" + #l1=self.etape_include.parent.get_sd_avant_du_bon_type(self.etape_include,types_permis) + #l2=JDC.get_sd_avant_du_bon_type(self,etape,types_permis) + #return l1+l2 + + def get_sd_apres_etape(self,nom_sd,etape,avec='non'): + """ + Cette méthode retourne la SD de nom nom_sd qui est éventuellement + définie apres etape + Si avec vaut 'non' exclut etape de la recherche + """ + 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, remplacé ou conservé + Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement + définie apres etape en tenant compte des concepts detruits + Si avec vaut 'non' exclut etape de la recherche + """ + autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec) + 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 à 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 + self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd) + + def delete_concept_after_etape(self,etape,sd): + """ + Fonction : Mettre à jour les étapes du JDC qui sont après etape suite à + la disparition du concept sd + """ + # Nettoyage des etapes de l'include + JDC.delete_concept_after_etape(self,etape,sd) + # Nettoyage des etapes du parent + self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd) + + def replace_concept_after_etape(self,etape,old_sd,sd): + """ + Fonction : Mettre à jour les étapes du JDC qui sont après 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 + self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd) + + + class JDC_INCLUDE(JDC_POURSUITE): def active_etapes(self): for e in self.etapes: