Extensions/commande_comm.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 import os,traceback,string
  21 import re
  22
  23 from Noyau.N_CR import CR
  24 from Noyau.N_Exception import AsException
  25 from Noyau import N_OBJECT
  26 from Ihm import I_OBJECT
  27 from Extensions.i18n import tr
  28
  29 class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
  30     """
  31     Cette classe sert à définir les objets de type Commande commentarisée
  32     """
  33     nature = "COMMANDE_COMMENTARISEE"
  34     idracine='_comm'
  35
  36     def __init__(self,texte='',parent=None,reg='oui'):
  37         self.valeur = texte
  38         if not parent :
  39             self.jdc = self.parent = CONTEXT.get_current_step()
  40         else:
  41             self.jdc = self.parent = parent
  42         if hasattr(self.parent,'etape'):
  43           self.etape = self.parent.etape
  44         else :
  45           self.etape = None
  46         self.definition=self
  47         self.nom = ''
  48         self.niveau = self.parent.niveau
  49         self.actif=1
  50         self.state="unchanged"
  51         #self.appel = N_utils.callee_where(niveau=2)
  52         if reg=='oui' : self.register()
  53
  54     def isvalid(self):
  55         return 1
  56
  57     def report(self):
  58         """
  59         Génère l'objet rapport (classe CR)
  60         """
  61         self.cr=CR()
  62         if not self.isvalid(): self.cr.warn(tr("Objet commande commentarisé invalide"))
  63         return self.cr
  64
  65     def copy(self):
  66         """
  67         Retourne une copie de self cad un objet COMMANDE_COMM
  68         """
  69         # XXX self.texte ne semble pas exister ???
  70         return COMMANDE_COMM(self.texte,parent = self.parent,reg='non')
  71
  72     def init_modif(self):
  73         self.state = 'modified'
  74         self.parent.init_modif()
  75
  76     def set_valeur(self,new_valeur):
  77         """
  78         Remplace la valeur de self(si elle existe) par new_valeur)
  79         """
  80         self.valeur = new_valeur
  81         self.init_modif()
  82
  83     def get_valeur(self) :
  84         """
  85         Retourne la valeur de self, cad le texte de la commande commentarisée
  86         """
  87         return self.valeur
  88
  89     def register(self):
  90         """
  91         Enregistre la commande commenatrisée dans la liste des étapes de son parent lorsque celui-ci
  92         est un JDC
  93         """
  94         self.parent.register(self)
  95
  96     def isoblig(self):
  97         """
  98         Indique si self est obligatoire ou non : retourne toujours 0
  99         """
 100         return 0
 101
 102     def ident(self):
 103         """
 104         Retourne le nom interne associé à self
 105         Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 106         """
 107         return self.nom
 108
 109     def isrepetable(self):
 110         """
 111         Indique si self est répétable ou non : retourne toujours 1
 112         """
 113         return 1
 114
 115     def get_attribut(self,nom_attribut) :
 116         """
 117         Retourne l'attribut de nom nom_attribut de self (ou hérité)
 118         """
 119         if hasattr(self,nom_attribut) :
 120           return getattr(self,nom_attribut)
 121         else :
 122           return None
 123
 124     def get_fr(self):
 125         """
 126         Retourne l'attribut fr de self.definition
 127         """
 128         if self.jdc.code=='ASTER' : return self.definition.fr
 129         try :
 130           return getattr(self.definition,self.jdc.lang)
 131         except:
 132           return ''
 133
 134     def liste_mc_presents(self):
 135         return []
 136
 137     def supprime(self):
 138         """
 139         Méthode qui supprime toutes les boucles de références afin que l'objet puisse
 140         être correctement détruit par le garbage collector
 141         """
 142         self.parent = None
 143         self.etape = None
 144         self.jdc = None
 145         self.niveau = None
 146         self.definition = None
 147         self.valeur = None
 148         self.val = None
 149         self.appel = None
 150
 151     def supprime_sdprods(self):
 152         pass
 153
 154     def update_context(self,d):
 155         """
 156         Update le dictionnaire d avec les concepts ou objets produits par self
 157         --> ne fait rien pour une commande en  commentaire
 158         """
 159         pass
 160
 161     def delete_concept(self,sd):
 162         pass
 163
 164     def replace_concept (self,old_sd,sd):
 165         pass
 166
 167     def get_sdprods(self,nom_sd):
 168         return None
 169
 170     def uncomment(self):
 171         """
 172         Cette méthode a pour but de décommentariser l'objet courant,
 173         cad de retourner un tuple contenant :
 174           - l'objet CMD associé
 175           - le nom de la sdprod éventuellement produite (sinon None)
 176         """
 177         # on récupère le contexte avant la commande commentarisée
 178         context_ini = self.jdc.get_contexte_avant(self)
 179         try:
 180             # on essaie de créer un objet JDC...
 181             CONTEXT.unset_current_step()
 182             if re.search('Fin Commentaire',self.valeur) :
 183                self.valeur=self.valeur.replace('Fin Commentaire','')
 184             J=self.jdc.__class__(procedure=self.valeur,
 185                                  definition=self.jdc.definition,
 186                                  cata=self.jdc.cata,
 187                                  cata_ord_dico=self.jdc.cata_ordonne_dico,
 188                                  context_ini = context_ini,
 189                                 )
 190             J.analyse()
 191         except Exception,e:
 192             traceback.print_exc()
 193             #self.jdc.set_context()
 194             raise AsException(tr("Erreur"),e.__str__())
 195         if len(J.cr.crfatal)>0 :
 196             # des erreurs fatales ont été rencontrées
 197             #self.jdc.set_context()
 198             print 'erreurs fatales !!!'
 199             raise AsException(tr("Erreurs fatales"),string.join(J.cr.crfatal))
 200         if not J.etapes :
 201             # des erreurs ont été rencontrées
 202             raise AsException(tr("Impossible reconstruire commande\n"),str(J.cr))
 203         #self.jdc.set_context()
 204
 205         new_etape = J.etapes[0]
 206         if new_etape.sd :
 207             nom_sd = new_etape.sd.nom
 208         else:
 209             nom_sd = None
 210         #new_etape=new_etape.copy()
 211         #print "uncomment",new_etape.sd
 212
 213         pos=self.parent.etapes.index(self)
 214         # L'ordre d'appel est important : suppentite fait le menage des concepts dans les etapes suivantes
 215         self.parent.addentite(new_etape,pos)
 216         self.parent.suppentite(self)
 217         return new_etape,nom_sd
 218
 219     def active(self):
 220         """
 221         Rend l'etape courante active
 222         """
 223         self.actif = 1
 224
 225     def inactive(self):
 226         """
 227         Rend l'etape courante inactive
 228         """
 229         self.actif = 0
 230
 231     def isactif(self):
 232         """
 233         Booléenne qui retourne 1 si self est valide, 0 sinon
 234         """
 235         return self.actif
 236
 237     def verif_condition_bloc(self):
 238       """
 239           Evalue les conditions de tous les blocs fils possibles
 240           (en fonction du catalogue donc de la définition) de self et
 241           retourne deux listes :
 242             - la première contient les noms des blocs à rajouter
 243             - la seconde contient les noms des blocs à supprimer
 244       """
 245       return [],[]
 246
 247     def verif_condition_regles(self,liste_presents):
 248       """
 249           Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 250           en fonction de la liste des mots-clés présents
 251       """
 252       return []
 253
 254     def reparent(self,parent):
 255       """
 256           Cette methode sert a reinitialiser la parente de l'objet
 257       """
 258       self.parent=parent
 259       self.jdc=parent.get_jdc_root()
 260       self.etape=self
 261
 262     def verif_existence_sd(self):
 263       """
 264          Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 265          avant étape, sinon enlève la référence à ces concepts
 266          --> sans objet pour les commandes commentarisées
 267       """
 268       pass
 269
 270     def control_sdprods(self,d):
 271       """sans objet pour les commandes commentarisées"""
 272       pass
 273
 274     def close(self):
 275       pass
 276
 277     def reset_context(self):
 278       pass
 279