Extensions/jdc_include.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
  21 """
  22    Ce module contient la classe JDC_INCLUDE qui sert a inclure
  23    dans un jeu de commandes une partie de jeu de commandes
  24    au moyen de la fonctionnalite INCLUDE ou INCLUDE_MATERIAU
  25    Quand l'utilisateur veut inclure un fichier il faut versifier
  26    que le jeu de commandes inclus est valide et compatible
  27    avec le contexte avant et apres l'insertion
  28 """
  29 from __future__ import absolute_import
  30 import string
  31 from Accas import JDC,ASSD,AsException,JDC_CATA
  32 from Ihm import CONNECTOR
  33
  34 class JDC_POURSUITE(JDC):
  35     def __init__(self,definition=None,procedure=None,cata=None,
  36                       cata_ord_dico=None,parent=None,
  37                       nom='SansNom',appli=None,context_ini=None,
  38                       jdc_pere=None,etape_include=None,prefix_include=None,
  39                       recorded_units=None,old_recorded_units=None,**args):
  40
  41         JDC.__init__(self, definition=definition,
  42                            procedure=procedure,
  43                            cata=cata,
  44                            cata_ord_dico=cata_ord_dico,
  45                            parent=parent,
  46                            nom=nom,
  47                            appli=appli,
  48                            context_ini=context_ini,
  49                            **args
  50                            )
  51         self.jdc_pere=jdc_pere
  52         self.etape_include=etape_include
  53         self.prefix_include=prefix_include
  54         if recorded_units is not None:self.recorded_units=recorded_units
  55         if old_recorded_units is not None:self.old_recorded_units=old_recorded_units
  56
  57     def o_register(self,sd):
  58         return self.jdc_pere.o_register(sd)
  59
  60     def nommerSDProd(self,sd,sdnom,restrict='non'):
  61         """
  62             Nomme la SD apres avoir verifie que le nommage est possible : nom
  63             non utilise
  64             Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
  65             Si le nom est deja utilise, leve une exception
  66             Met le concept cree dans le contexe global g_context
  67         """
  68         #print "nommerSDProd",sd,sdnom,restrict
  69         if self.prefix_include:
  70             if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
  71
  72         if sdnom != '' and sdnom[0] == '_':
  73             # Si le nom du concept commence par le caractere _ on lui attribue
  74             # un identificateur automatique comme dans JEVEUX (voir gcncon)
  75             #
  76             # nom commencant par __ : il s'agit de concepts qui seront detruits
  77             # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes
  78             # ATTENTION : il faut traiter differemment les concepts dont le nom
  79             # commence par _ mais qui sont des concepts nommes automatiquement par
  80             # une eventuelle sous macro.
  81             if sdnom[1] in string.digits:
  82             # Ce concept provient probablement d'une sous macro (cas improbable)
  83             #pas de renommage
  84                 pass
  85             elif sdnom[1] == '_':
  86                 #cas d'un concept a ne pas conserver apres execution de la commande
  87                 sdnom=sd.id[2:]
  88                 pass
  89             else:
  90                 sdnom=sd.id[2:]
  91                 pass
  92
  93         o=self.sdsDict.get(sdnom,None)
  94         if isinstance(o,ASSD):
  95             raise AsException(tr("Nom de concept deja defini : %s" ,sdnom))
  96
  97         # On pourrait verifier que le jdc_pere apres l'etape etape_include
  98         # ne contient pas deja un concept de ce nom
  99         #if self.jdc_pere.getSdApresEtapeAvecDetruire(sdnom,etape=self.etape_include):
 100             # Il existe un concept apres self => impossible d'inserer
 101         #   raise AsException("Nom de concept deja defini : %s" % sdnom)
 102         # On a choisi de ne pas faire ce test ici mais de le faire en bloc
 103         # si necessaire apres en appelant la methode verifContexte
 104
 105         # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
 106         # Ajoute a la creation (appel de regSD).
 107         self.sdsDict[sdnom]=sd
 108         sd.nom=sdnom
 109
 110         # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
 111         if restrict == 'non':
 112             self.g_context[sdnom]=sd
 113
 114     def getVerifContexte(self):
 115         #print "getVerifContexte"
 116         j_context=self.getContexteAvant(None)
 117         self.verifContexte(j_context)
 118         return j_context
 119
 120     def forceContexte(self,contexte):
 121         for nom_sd,sd in list(contexte.items()):
 122             if not isinstance(sd,ASSD):continue
 123             autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
 124                                                            etape=self.etape_include)
 125             if autre_sd is None:continue
 126             if sd is not autre_sd:
 127                 # Il existe un autre concept de meme nom produit par une etape apres self
 128                 # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
 129                 if sd.etape:
 130                     sd.etape.supprimeSdprod(sd)
 131
 132         return contexte
 133
 134     def verifContexte(self,context):
 135         """
 136            Cette methode verifie si le contexte passe en argument (context)
 137            peut etre insere dans le jdc pere de l'include.
 138            Elle verifie que les concepts contenus dans ce contexte n'entrent
 139            pas en conflit avec les concepts produits dans le jdc pere
 140            apres l'include.
 141            Si le contexte ne peut pas etre insere, la methode leve une
 142            exception sinon elle retourne le contexte inchange
 143         """
 144         #print "verifContexte"
 145         for nom_sd,sd in list(context.items()):
 146             if not isinstance(sd,ASSD):continue
 147             autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
 148                                                            etape=self.etape_include)
 149             if autre_sd is None:continue
 150             if sd is not autre_sd:
 151                 # Il existe un concept produit par une etape apres self
 152                 # => impossible d'inserer
 153                 raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
 154                                 "%s existe deja dans le jeu de commandes." % nom_sd)
 155
 156         return context
 157
 158     def getListeCmd(self):
 159         """
 160             Retourne la liste des commandes du catalogue
 161         """
 162         if self.jdc_pere is None:
 163             return JDC.getListeCmd(self)
 164         return self.jdc_pere.getListeCmd()
 165
 166     def getGroups(self):
 167         """
 168             Retourne la liste des commandes du catalogue par groupes
 169         """
 170         if self.jdc_pere is None:
 171             return JDC.getGroups(self)
 172         return self.jdc_pere.getGroups()
 173
 174     def initModif(self):
 175         """
 176            Met l'etat de l'etape a : modifie
 177            Propage la modification au parent
 178
 179            Attention : initModif doit etre appele avant de realiser une modification
 180            La validite devra etre recalculee apres cette modification
 181            mais par un appel a finModif pour preserver l'etat modified
 182            de tous les objets entre temps
 183         """
 184         #print "jdc_include.initModif",self,self.etape_include
 185         self.state = 'modified'
 186         if self.etape_include:
 187             self.etape_include.initModif()
 188
 189     def finModif(self):
 190         """
 191             Methode appelee une fois qu'une modification a ete faite afin de
 192             declencher d'eventuels traitements post-modification
 193             ex : INCLUDE et POURSUITE
 194         """
 195         #print "jdc_include.finModif",self,self.etape_include
 196         CONNECTOR.Emit(self,"valid")
 197         if self.etape_include:
 198             self.etape_include.finModif()
 199
 200     def supprime(self):
 201         """
 202             On ne supprime rien directement pour un jdc auxiliaire d'include ou de poursuite
 203             Utiliser supprime_aux
 204         """
 205         pass
 206
 207     def supprime_aux(self):
 208         #print "supprime_aux",self
 209         JDC.supprime(self)
 210         self.jdc_pere=None
 211         self.etape_include=None
 212     #   self.cata_ordonne_dico={}
 213         self.appli=None
 214     #   self.context_ini={}
 215     #   self.procedure=None
 216
 217     def getContexteAvant(self,etape):
 218         """
 219            Retourne le dictionnaire des concepts connus avant etape
 220            On tient compte des concepts produits par le jdc pere
 221            en reactualisant le contexte initial context_ini
 222            On tient compte des commandes qui modifient le contexte
 223            comme DETRUIRE ou les macros
 224            Si etape == None, on retourne le contexte en fin de JDC
 225         """
 226         #print "jdc_include.getContexteAvant",etape,etape and etape.nom
 227         if self.etape_include:
 228             new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
 229             self.context_ini=new_context
 230         d= JDC.getContexteAvant(self,etape)
 231         return d
 232
 233     def resetContext(self):
 234         #print "jdc_include.resetContext",self,self.nom
 235         if self.etape_include:
 236             self.etape_include.parent.resetContext()
 237             new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
 238             self.context_ini=new_context
 239         JDC.resetContext(self)
 240
 241     def getSdApresEtape(self,nom_sd,etape,avec='non'):
 242         """
 243              Cette methode retourne la SD de nom nom_sd qui est eventuellement
 244              definie apres etape
 245              Si avec vaut 'non' exclut etape de la recherche
 246         """
 247         if self.etape_include:
 248             sd=self.etape_include.parent.getSdApresEtape(nom_sd,self.etape_include,'non')
 249             if sd:return sd
 250         return JDC.getSdApresEtape(self,nom_sd,etape,avec)
 251
 252     def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
 253         """
 254              On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
 255              Il peut etre detruit, remplace ou conserve
 256              Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
 257              definie apres etape en tenant compte des concepts detruits
 258              Si avec vaut 'non' exclut etape de la recherche
 259         """
 260         #print "jdc_include.getSdApresEtapeAvecDetruire",nom_sd,sd,id(sd)
 261         autre_sd=JDC.getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec)
 262         # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
 263         # la recherche en retournant None
 264         # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
 265         # la recherche en retournant le concept nouvellement defini
 266         # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
 267         if autre_sd is None or autre_sd is not sd :return autre_sd
 268         return self.etape_include.parent.getSdApresEtapeAvecDetruire(nom_sd,sd,self.etape_include,'non')
 269
 270     def deleteConcept(self,sd):
 271         """
 272             Fonction : Mettre a jour les etapes du JDC suite a la disparition du
 273             concept sd
 274             Seuls les mots cles simples MCSIMP font un traitement autre
 275             que de transmettre aux fils
 276         """
 277         # Nettoyage des etapes de l'include
 278         JDC.deleteConcept(self,sd)
 279         # Nettoyage des etapes du parent
 280         if self.etape_include:
 281             self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
 282
 283     def deleteConceptAfterEtape(self,etape,sd):
 284         """
 285             Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite a
 286             la disparition du concept sd
 287         """
 288         # Nettoyage des etapes de l'include
 289         JDC.deleteConceptAfterEtape(self,etape,sd)
 290         # Nettoyage des etapes du parent
 291         if self.etape_include:
 292             self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
 293
 294     def updateConceptAfterEtape(self,etape,sd):
 295         """
 296             Fonction : mettre a jour les etapes du JDC suite a une modification
 297             du concept sd (principalement renommage)
 298         """
 299         JDC.updateConceptAfterEtape(self,etape,sd)
 300         if self.etape_include:
 301             self.etape_include.parent.updateConceptAfterEtape(self.etape_include,sd)
 302
 303     def replaceConceptAfterEtape(self,etape,old_sd,sd):
 304         """
 305             Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite au
 306             remplacement du concept old_sd par sd
 307         """
 308         # Nettoyage des etapes de l'include
 309         JDC.replaceConceptAfterEtape(self,etape,old_sd,sd)
 310         # Nettoyage des etapes du parent
 311         if self.etape_include:
 312             self.etape_include.parent.replaceConceptAfterEtape(self.etape_include,old_sd,sd)
 313
 314     def changeFichier(self,fichier):
 315         if self.etape_include:
 316             self.etape_include.fichier_ini=fichier
 317         self.finModif()
 318
 319     def controlContextApres(self,etape):
 320         """
 321            Cette methode verifie que les etapes apres l'etape etape
 322            ont bien des concepts produits acceptables (pas de conflit de
 323            nom principalement)
 324            Si des concepts produits ne sont pas acceptables ils sont supprimes.
 325            Effectue les verifications sur les etapes du jdc mais aussi sur les
 326            jdc parents s'ils existent.
 327         """
 328         #print "jdc_include.controlContextApres",self,etape
 329         #Regularise les etapes du jdc apres l'etape etape
 330         self.controlJdcContextApres(etape)
 331         if self.etape_include:
 332             #print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
 333             # il existe un jdc pere. On propage la regularisation
 334             self.etape_include.parent.controlContextApres(self.etape_include)
 335
 336 class JDC_INCLUDE(JDC_POURSUITE):
 337     def getListeCmd(self):
 338         """
 339             Retourne la liste des commandes du catalogue
 340         """
 341         if self.jdc_pere is None:
 342             return JDC.getListeCmd(self)
 343         return [e for e in self.jdc_pere.getListeCmd() if e not in ("DEBUT","POURSUITE","FIN") ]
 344
 345     def activeEtapes(self):
 346         for e in self.etapes:
 347             e.active()
 348
 349 class JDC_CATA_INCLUDE(JDC_CATA):
 350     class_instance=JDC_INCLUDE
 351
 352 class JDC_CATA_POURSUITE(JDC_CATA):
 353     class_instance=JDC_POURSUITE
 354
 355 from Accas import AU_MOINS_UN,A_CLASSER
 356
 357 import prefs
 358 c=prefs.code
 359 JdC_include=JDC_CATA_INCLUDE(code=c, execmodul=None)
 360
 361 JdC_poursuite=JDC_CATA_POURSUITE(code='ASTER', execmodul=None,
 362                                  regles = (AU_MOINS_UN('DEBUT','POURSUITE'),
 363                                            AU_MOINS_UN('FIN'),
 364                                            A_CLASSER(('DEBUT','POURSUITE'),'FIN')
 365                                           )
 366                                )