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