# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
+# Copyright (C) 2007-2013 EDF R&D
#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-# ======================================================================
"""
"""
# Modules Python
import string,types
from copy import copy
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+
# Objet re pour controler les identificateurs Python
concept_re=re.compile(r'[a-zA-Z_]\w*$')
-# import rajoutés suite à l'ajout de Build_sd --> à résorber
+# import rajoute suite a l'ajout de Build_sd --> a resorber
import traceback
import Noyau
from Noyau import N_Exception
from Noyau.N_Exception import AsException
import Validation
-# fin import à résorber
+# fin import a resorber
# Modules EFICAS
import I_MCCOMPO
return self.nom
def get_sdname(self):
- if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
+ #print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
+ if CONTEXT.debug :
+ print "SDNAME ", self.reuse, self.sd, self.sd.get_name()
sdname=''
if self.reuse != None:
sdname= self.reuse.get_name()
else:
if self.sd:sdname=self.sd.get_name()
if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
- # dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
+ # dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide
return ''
return sdname
def init_modif(self):
"""
- Met l'état de l'étape à : modifié
+ Met l'etat de l'etape a : modifie
Propage la modification au parent
"""
- # init_modif doit etre appelé avant de réaliser une modification
- # La validité devra etre recalculée apres cette modification
- # mais dans l'appel à fin_modif pour préserver l'état modified
+ # init_modif doit etre appele avant de realiser une modification
+ # La validite devra etre recalculee apres cette modification
+ # mais dans l'appel a fin_modif pour preserver l'etat modified
# de tous les objets entre temps
#print "init_modif",self,self.parent
self.state = 'modified'
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
+ Methode appelee une fois qu'une modification a ete faite afin de
+ declencher d'eventuels traitements post-modification
ex : INCLUDE et POURSUITE
+ Ne pas mettre de traitement qui risque d'induire des recursions (soit a peu pres rien)
"""
- #print "fin_modif",self,self.parent
- if self.nom == "DETRUIRE":
- #Il n'est pas conseillé de mettre des traitements dans fin_modif. Ceci est une
- # exception qu'il faut supprimer à terme.
- #une commande DETRUIRE a été modifiée. Il faut verifier les commandes
- #suivantes
- #ATTENTION: aux eventuelles recursions
- self.parent.control_context_apres(self)
- pass
-
CONNECTOR.Emit(self,"valid")
if self.parent:
self.parent.fin_modif()
def nomme_sd(self,nom) :
"""
- Cette méthode a pour fonction de donner un nom (nom) au concept
- produit par l'étape (self).
- - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
- - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
+ Cette methode a pour fonction de donner un nom (nom) au concept
+ produit par l'etape (self).
+ - si le concept n'existe pas, on essaye de le creer a condition que l'etape soit valide ET non reentrante)
+ - si il existe dea, on le renomme et on repercute les changements dans les autres etapes
Les valeurs de retour sont :
- - 0 si le nommage n'a pas pu etre mené à son terme,
+ - 0 si le nommage n'a pas pu etre menea son terme,
- 1 dans le cas contraire
"""
# Le nom d'un concept doit etre un identificateur Python (toujours vrai ?)
if not concept_re.match(nom):
- return 0,"Un nom de concept doit etre un identificateur Python"
+ return 0, tr("Un nom de concept doit etre un identificateur Python")
- if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
- return 0,"Nom de concept trop long (maxi 8 caractères)"
+ #if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
+ # return 0, tr("Nom de concept trop long (maxi 8 caracteres)")
self.init_modif()
#
# On verifie d'abord si les mots cles sont valides
#
- if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
+ if not self.isvalid(sd='non') : return 0,"Nommage du concept refuse : l'operateur n'est pas valide"
#
- # Cas particulier des opérateurs obligatoirement réentrants
+ # Cas particulier des operateurs obligatoirement reentrants
#
if self.definition.reentrant == 'o':
self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
if self.sd != None :
self.sdnom=self.sd.nom
self.fin_modif()
- return 1,"Concept existant"
+ return 1, tr("Concept existant")
else:
- return 0,"Opérateur réentrant mais concept non existant"
+ return 0, tr("Operateur reentrant mais concept non existant")
#
- # Cas particulier des opérateurs facultativement réentrants
+ # Cas particulier des operateurs facultativement reentrants
#
old_reuse=None
if self.definition.reentrant == 'f' :
sd = self.jdc.get_sd_avant_etape(nom,self)
if sd != None :
- # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
if isinstance(sd,self.get_type_produit()) :
self.sd = self.reuse = sd
self.sdnom = sd.nom
self.fin_modif()
- return 1,"Opérateur facultativement réentrant et concept existant trouvé"
+ return 1, tr("Operateur reentrant et concept existant trouve")
else:
- return 0,"Concept déjà existant et de mauvais type"
+ return 0, tr("Concept deja existant et de mauvais type")
else :
# il faut enlever le lien vers une SD existante car si on passe ici
- # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
- # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
+ # cela signifie que l'operateur n'est pas utilise en mode reentrant.
+ # Si on ne fait pas cela, on risque de modifier une SD produite par un autre operateur
if self.reuse :
old_reuse=self.reuse
self.sd = self.reuse = self.sdnom = None
#
- # On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
- # mais est utilisé en mode non réentrant
+ # On est dans le cas ou l'operateur n'est pas reentrant ou est facultativement reentrant
+ # mais est utilise en mode non reentrant
#
if self.sd == None :
#Pas de concept produit preexistant
if old_reuse:
self.sd=self.reuse=old_reuse
self.sdnom=old_reuse.nom
- return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
+ return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
else:
# Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
- # On peut donc créer le concept retourné.
- # Il est créé sans nom mais enregistré dans la liste des concepts existants
+ # On peut donc creer le concept retourne
+ # Il est cree sans nom mais enregistre dans la liste des concepts existants
try:
self.get_sd_prod()
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sdnom=nom
self.parent.update_concept_after_etape(self,self.sd)
self.fin_modif()
- return 1,"Nommage du concept effectué"
+ return 1, tr("Nommage du concept effectue")
except:
- return 0,"Nommage impossible"+str(sys.exc_info()[1])
+ return 0, tr("Nommage impossible %s", str(sys.exc_info()[1]))
else :
#Un concept produit preexiste
old_nom=self.sd.nom
if string.find(old_nom,'sansnom') :
- # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
- # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
- # on peut donc le nommer sans test préalable
+ # Dans le cas ou old_nom == sansnom, isvalid retourne 0 alors que ...
+ # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide
+ # on peut donc le nommer sans test prealable
if self.parent.get_sd_autour_etape(nom,self):
- return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
+ return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
else:
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sd.nom=nom
self.sdnom=nom
self.parent.update_concept_after_etape(self,self.sd)
self.fin_modif()
- return 1,"Nommage du concept effectué"
+ return 1, tr("Nommage du concept effectue")
if self.isvalid() :
# Normalement l appel de isvalid a mis a jour le concept produit (son type)
- # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
- # deja attribué
+ # Il suffit de specifier l attribut nom de sd pour le nommer si le nom n est pas
+ # deja attribue
if self.parent.get_sd_autour_etape(nom,self):
- return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
+ return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
else:
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sd.nom=nom
self.sdnom=nom
self.parent.update_concept_after_etape(self,self.sd)
self.fin_modif()
- return 1,"Nommage du concept effectué"
+ return 1, tr("Nommage du concept effectue")
else:
# Normalement on ne devrait pas passer ici
- return 0,'Normalement on ne devrait pas passer ici'
+ return 0, 'Normalement on ne devrait pas passer ici'
def get_sdprods(self,nom_sd):
"""
"""
Rend l'etape courante active.
Il faut ajouter la sd si elle existe au contexte global du JDC
- et à la liste des sd
+ et a la liste des sd
"""
if self.actif:return
self.actif = 1
"""
Fonction:
Lors d'une destruction d'etape, detruit tous les concepts produits
- Un opérateur n a qu un concept produit
+ Un operateur n a qu un concept produit
Une procedure n'en a aucun
- Une macro en a en général plus d'un
+ Une macro en a en general plus d'un
"""
#print "supprime_sdprods",self
if self.reuse is self.sd :return
- # l'étape n'est pas réentrante
- # le concept retourné par l'étape est à supprimer car il était
- # créé par l'étape
+ # l'etape n'est pas reentrante
+ # le concept retourne par l'etape est a supprimer car il etait
+ # cree par l'etape
if self.sd != None :
self.parent.del_sdprod(self.sd)
self.parent.delete_concept(self.sd)
Fonction :
Mettre a jour les mots cles de l etape et eventuellement
le concept produit si reuse
- suite à la disparition du concept sd
+ suite a la disparition du concept sd
Seuls les mots cles simples MCSIMP font un traitement autre
que de transmettre aux fils
"""
def get_noms_sd_oper_reentrant(self):
"""
- Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
+ Retourne la liste des noms de concepts utilisesa l'interieur de la commande
qui sont du type que peut retourner cette commande
"""
liste_sd = self.get_sd_utilisees()
def get_genealogie(self):
"""
Retourne la liste des noms des ascendants de l'objet self
- en s'arretant à la première ETAPE rencontrée
+ en s'arretant a la premiere ETAPE rencontree
"""
return [self.nom]
def verif_existence_sd(self):
"""
- Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la referea ces concepts
"""
#print "verif_existence_sd",self.sd
for motcle in self.mc_liste :
def update_mc_global(self):
"""
- Met a jour les mots cles globaux enregistrés dans l'étape
+ Met a jour les mots cles globaux enregistres dans l'etape
et dans le jdc parent.
Une etape ne peut pas etre globale. Elle se contente de passer
- la requete a ses fils apres avoir reinitialisé le dictionnaire
+ la requete a ses fils apres avoir reinitialise le dictionnaire
des mots cles globaux.
"""
self.mc_globaux={}
def get_objet_commentarise(self,format):
"""
- Cette méthode retourne un objet commande commentarisée
+ Cette methode retourne un objet commande commentarisee
representant la commande self
"""
import generator
g=generator.plugins[format]()
texte_commande = g.gener(self,format='beautifie')
- # Il faut enlever la première ligne vide de texte_commande que
+ # Il faut enlever la premiere ligne vide de texte_commande que
# rajoute le generator
#rebut,texte_commande = string.split(texte_commande,'\n',1)
- # on construit l'objet COMMANDE_COMM repésentatif de self mais non
- # enregistré dans le jdc (pas ajouté dans jdc.etapes)
+ # on construit l'objet COMMANDE_COMM repesentatif de self mais non
+ # enregistre dans le jdc (pas ajoute dans jdc.etapes)
parent=self.parent
pos=self.parent.etapes.index(self)
+ # on ajoute une fin à la commande pour pouvoir en commenter 2
+ texte_commande+='\nFin Commentaire'
commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
reg='non',
parent=parent)
return commande_comment
+ def modified(self):
+ """Le contenu de l'etape (mots cles, ...) a ete modifie"""
+ if self.nom=="DETRUIRE":
+ self.parent.control_context_apres(self)
+
+
#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
def Build_sd(self,nom):
"""
try:
sd=Noyau.N_ETAPE.ETAPE.Build_sd(self,nom)
- except AsException,e:
+ except AsException,e :
# Une erreur s'est produite lors de la construction du concept
# Comme on est dans EFICAS, on essaie de poursuivre quand meme
- # Si on poursuit, on a le choix entre deux possibilités :
- # 1. on annule la sd associée à self
+ # Si on poursuit, on a le choix entre deux possibilites :
+ # 1. on annule la sd associee a self
# 2. on la conserve mais il faut la retourner
# En plus il faut rendre coherents sdnom et sd.nom
self.sd=None
return self.sd
-#ATTENTION SURCHARGE: cette methode doit etre gardée en synchronisation avec Noyau
+#ATTENTION SURCHARGE: cette methode doit etre gardee en synchronisation avec Noyau
def make_register(self):
"""
- Initialise les attributs jdc, id, niveau et réalise les
- enregistrements nécessaires
+ Initialise les attributs jdc, id, niveau et realise les
+ enregistrements necessaires
Pour EFICAS, on tient compte des niveaux
Surcharge la methode make_register du package Noyau
"""
self.id= self.parent.register(self)
self.UserError=self.jdc.UserError
if self.definition.niveau :
- # La définition est dans un niveau. En plus on
+ # La definition est dans un niveau. En plus on
# l'enregistre dans le niveau
self.nom_niveau_definition = self.definition.niveau.nom
self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
self.niveau.register(self)
else:
- # La définition est au niveau global
+ # La definition est au niveau global
self.nom_niveau_definition = 'JDC'
self.niveau=self.parent
else:
def report(self):
cr= Validation.V_ETAPE.ETAPE.report(self)
- #rafraichissement de la validité de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
+ #rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
self.isvalid()
+ if not self.isvalid() and self.nom == "INCLUDE" :
+ self.cr.fatal(('Etape : %s ligne : %r %s'),
+ self.nom, self.appel[0], tr("\n Include Invalide. \n ne sera pas pris en compte"))
return cr