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