from Noyau import N_MACRO_ETAPE
from Validation import V_MACRO_ETAPE
from Ihm import I_MACRO_ETAPE
+from A_ASSD import CO
class MACRO_ETAPE(I_MACRO_ETAPE.MACRO_ETAPE,
V_MACRO_ETAPE.MACRO_ETAPE,
N_MACRO_ETAPE.MACRO_ETAPE):
+ typeCO=CO
def __init__(self,oper=None,reuse=None,args={}):
N_MACRO_ETAPE.MACRO_ETAPE.__init__(self,oper,reuse,args)
V_MACRO_ETAPE.MACRO_ETAPE.__init__(self)
--- /dev/null
+DEBUT()
+print "***********************************"
+print "*********COUCOU1*******************"
+print "***********************************"
+INCLUDE(UNITE=11)
+FIN()
--- /dev/null
+mm=LIRE_MAILLAGE()
--- /dev/null
+MMA=LIRE_MAILLAGE()
+
+mo=AFFE_MODELE(MAILLAGE=MMA,
+ AFFE=_F(TOUT='OUI',
+ PHENOMENE='MECANIQUE',
+ MODELISATION='3D',),);
+
+MACRO_MATR_ASSE(MODELE=mo,
+ NUME_DDL=CO('numdl'),
+ MATR_ASSE=_F(MATRICE=CO('mm'),
+ OPTION='RIGI_MECA',),);
+
+mm=FACT_LDLT(reuse =mm,
+ MATR_ASSE=mm,);
+
--- /dev/null
+MA=LIRE_MAILLAGE()
--- /dev/null
+[jdc]
+jdc=a
+[a]
+comm=p3.comm
+poursuite=b
+11=incl.11
+17=incl.17
+16=incl.16
+25=incl.25
+[b]
+comm=p2.comm
+poursuite=c
+11=pincl.11
+[c]
+comm=p1.comm
+poursuite=d
+11=qincl.11
+[d]
+comm=d0.comm
+11=rincl.11
POURSUITE()
-#import traceback
-#traceback.print_stack()
-print "=================================="
-print "coucou1"
-print "=================================="
+print "+++++++++++++++++++++++++++++++++++"
+print "+++++++++COUCOU3+++++++++++++++++++"
+print "+++++++++++++++++++++++++++++++++++"
+INCLUDE(UNITE=11)
FIN()
POURSUITE()
-#import traceback
-#traceback.print_stack()
-print "=================================="
-print "coucou2"
-print "=================================="
+print "+++++++++++++++++++++++++++++++++++"
+print "+++++++++COUCOU3+++++++++++++++++++"
+print "+++++++++++++++++++++++++++++++++++"
+INCLUDE(UNITE=11)
FIN()
-DEBUT()
-#import traceback
-#traceback.print_stack()
-print "=================================="
-print "coucou3"
-print "=================================="
+POURSUITE()
+print "+++++++++++++++++++++++++++++++++++"
+print "+++++++++COUCOU4+++++++++++++++++++"
+print "+++++++++++++++++++++++++++++++++++"
+INCLUDE(UNITE=17)
+INCLUDE(UNITE=11)
FIN()
--- /dev/null
+MAA=LIRE_MAILLAGE()
--- /dev/null
+MAAA=LIRE_MAILLAGE()
--- /dev/null
+MAAAA=LIRE_MAILLAGE()
-# -*- coding: utf-8 -*-
-#@ MODIF properties Accas DATE 10/10/2002 AUTEUR gcbhhhh M.ADMINISTRATEUR
+#@ MODIF properties Accas DATE 01/06/2005 AUTEUR gcbhhhh M.ADMINISTRATEUR
# CONFIGURATION MANAGEMENT OF EDF VERSION
# RESPONSABLE D6BHHHH J-P.LEFEBVRE
# ======================================================================
# IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR
# DE LA VERSION DU CODE_ASTER ASSOCIE
#----------------------------------------------------------------------
-version = "7.4.0"
-date = "22/11/2004"
+version = "8.0.23"
+date = "01/06/2005"
return self.sublist
def GetSubList_BAK(self):
+ raise "OBSOLETE"
sublist = []
for obj in self._object.data:
def setfunction(value, object=obj):
from Misc import MakeNomComplet
import session
-VERSION="EFICAS v1.7"
+VERSION="EFICAS v1.8"
class APPLI:
def __init__ (self,master,code=prefs.code,fichier=None,test=0) :
# PN : ajout d un attribut pour indiquer si
# l appli a ete lance depuis Salome
self.salome=0
+
+ # Fermer le splash et deiconifier la fenetre principale si on n'est pas en test
if (self.test == 0):
splash.fini_splash()
#self.affiche_FAQ()
- cwd=os.getcwd()
# Ouverture des fichiers de commandes donnes sur la ligne de commande
+ cwd=os.getcwd()
for study in session.d_env.studies:
os.chdir(cwd)
d=session.get_unit(study,self)
self.bureau.openJDC(study["comm"],d)
+
def send_message(self,message):
self.message=message
from utils import extension_fichier,stripPath,save_in_file
from widgets import Fenetre,Ask_Format_Fichier
from fenetre_mc_inconnus import fenetre_mc_inconnus
+from Ihm import CONNECTOR
import comploader
self.JDC = self.JDCDisplay_courant.jdc
#self.JDC.set_context()
self.JDCName = self.JDC.nom
+ #print "selectJDC",numero_jdc,self.JDCDisplay_courant,self.JDCName
def newJDC(self,event=None):
"""
self.nb.selectpage(label_onglet)
self.nb.setnaturalsize()
texte = "Jeu de commandes :" + self.JDCName+" ouvert"
+ CONNECTOR.Connect(JDC,"close",self.onClose,(self.JDCDisplay_courant,))
self.appli.affiche_infos(texte)
+ def onClose(self,jdcdisplay):
+ #print "onClose",jdcdisplay
+ CONNECTOR.Disconnect(jdcdisplay.jdc,"close",self.onClose,(jdcdisplay,))
+ self.closeJDCDISPLAY(jdcdisplay)
+
+ def closeJDCDISPLAY(self,jdc):
+ """
+ Ferme le jdcdisplay spécifié par l'argument jdc
+ """
+ if jdc is self.JDCDisplay_courant:
+ # on ferme le jdcdisplay courant
+ self.closeSelectedJDC()
+ else:
+ # on ferme un autre jdcdisplay que le courant
+ old_JDCDisplay=self.JDCDisplay_courant
+ old_page=self.nb.getcurselection()
+
+ self.JDCDisplay_courant=jdc
+ self.JDC=jdc.jdc
+ numero_jdc=self.liste_JDCDisplay.index(jdc)
+ self.nb.selectpage(numero_jdc)
+ #print numero_jdc
+
+ self.closeSelectedJDC()
+ self.JDCDisplay_courant=old_JDCDisplay
+ self.JDC=old_JDCDisplay.jdc
+ self.nb.selectpage(old_page)
+
def closeJDC (self,event=None) :
+ """
+ Ferme le JDC associé au JDCDISPLAY selectionné
+ """
+ if self.JDCDisplay_courant :
+ self.JDCDisplay_courant.jdc.close()
+
+ def closeSelectedJDC (self) :
"""
Ferme le JDC courant et détruit l'onglet associé dans le notebook self.nb
"""
- if self.JDCDisplay_courant == None:
- return
if self.JDCDisplay_courant.modified == 'o' :
message = "Voulez-vous sauvegarder le jeu de commandes "+self.JDC.nom+" courant ?"
reponse = askyesno(title="Sauvegarde du jdc courant",
if txt_exception :
# des exceptions ont été levées à la création du JDC
# --> on affiche les erreurs mais pas le JDC
+ self.JDC=J
self.appli.affiche_infos("Erreur fatale au chargement de %s" %file)
- showerror("Erreur fatale au chargement d'un fichier",txt_exception)
+ if self.appli.test == 0 :
+ showerror("Erreur fatale au chargement d'un fichier",txt_exception)
else:
self.ShowJDC(J,self.JDCName)
self.appli.toolbar.active_boutons()
Lance la suppression du noeud courant
"""
if not self.JDCDisplay_courant : return
- if self.JDCDisplay_courant.modified == 'n' :
- self.JDCDisplay_courant.init_modif()
+ self.JDCDisplay_courant.init_modif()
self.JDCDisplay_courant.node_selected.delete()
def visuJDC_py(self,event=None):
"""
test = 1
for JDCDisplay in liste :
+ self.JDCDisplay_courant=JDCDisplay
self.JDC = JDCDisplay.jdc
test = test * self.saveJDC(echo = 'non')
return test
return 0
def GetSubList_BAK(self):
+ raise "OBSOLETE"
sublist=[]
for obj in self.object.mc_liste:
def setfunction(value, object=obj):
return sublist
def additem_BAK(self,name,pos):
+ raise "OBSOLETE"
if isinstance(name,Objecttreeitem.ObjectTreeItem) :
objet = self.object.addentite(name.getObject(),pos)
else :
return item
def verif_condition_bloc_BAK(self):
+ raise "OBSOLETE"
return self.object.verif_condition_bloc()
import Accas
return listeCmd
def additem_BAK(self,name,pos):
+ raise "OBSOLETE"
cmd=self.addentite(name,pos)
item = self.make_objecttreeitem(self.appli,cmd.nom + " : ", cmd)
return item
def verif_condition_bloc_BAK(self):
+ raise "OBSOLETE"
# retourne la liste des sous-items dont la condition est valide
# sans objet pour le JDC
return [],[]
from widgets import askopenfilename
from widgets import Fenetre,FenetreYesNo
from widgets import showinfo,showerror
+from Ihm import CONNECTOR
#
__version__="$Name: $"
-__Id__="$Id: compomacro.py,v 1.19 2005/05/19 12:18:47 eficas Exp $"
+__Id__="$Id: compomacro.py,v 1.20 2005/05/24 10:34:16 eficas Exp $"
#
class MACROPanel(panels.OngletPanel):
dont a besoin la macro
"""
titre = Tkinter.Label(page,text="La commande %s requiert un fichier " %self.node.item.get_nom())
- titre.place(relx=0.5,rely=0.3,anchor='center')
- Tkinter.Label(page,text="Fichier :").place(relx=0.1,rely=0.5,relwidth=0.2)
- self.entry = Tkinter.Entry(page,relief='sunken',bg='white')
- self.entry.place(relx=0.35,rely=0.5,relwidth=0.55)
- Tkinter.Button(page,text='Valider',command = self.change_fichier_init).place(relx=0.3,rely=0.8)
- Tkinter.Button(page,text='Browse',command = self.browse_fichier_init).place(relx=0.5,rely=0.8)
- Tkinter.Button(page,text='Annuler',command = self.annule_fichier_init).place(relx=0.7,rely=0.8)
+ titre.place(relx=0.5,rely=0.2,anchor='center')
+ frameMain=Tkinter.Frame(page)
+ frameMain.place(relx=0.5,rely=0.4,anchor='center',relwidth=1.)
+ Tkinter.Label(frameMain,text="Fichier :").pack(side='left',padx=5)
+ self.entry = Tkinter.Entry(frameMain,relief='sunken',bg='white')
+ self.entry.pack(side='left',padx=5,fill='x',expand=1)
+ frameButtons=Tkinter.Frame(page)
+ but1=Tkinter.Button(frameButtons,text='Valider',command = self.change_fichier_init)
+ but2=Tkinter.Button(frameButtons,text='Browse',command = self.browse_fichier_init)
+ but3=Tkinter.Button(frameButtons,text='Annuler',command = self.annule_fichier_init)
+ but1.grid(row=0,column=0,padx=5,pady=5)
+ but2.grid(row=0,column=1,padx=5,pady=5)
+ but3.grid(row=0,column=2,padx=5,pady=5)
+ frameButtons.place(relx=0.5,rely=0.6,anchor='center')
+
if hasattr(self.node.item.object,'fichier_ini'):
if self.node.item.object.fichier_ini :
self.entry.insert(0,self.node.item.object.fichier_ini)
#print "makeEdit",self.object,self.object.nom
#print "makeEdit",self.object.jdc_aux,self.object.jdc_aux.nom
#print "makeEdit",self.object.jdc_aux.context_ini
+ if self.object.jdc_aux is None:
+ showerror("Include vide","L'include doit etre correctement initialisé avant d'etre édité")
+ return
self.parent_node=node
# On cree un nouvel onglet dans le bureau
appli.bureau.ShowJDC(self.object.jdc_aux,self.object.jdc_aux.nom,
self.myjdc=appli.bureau.JDCDisplay_courant
self.myjdc.fichier=self.object.fichier_ini
+ def onClose(self):
+ #print "onClose",self
+ self.appli.bureau.closeJDCDISPLAY(self.myjdc)
+
def makeView(self,appli,node):
+ if self.object.jdc_aux is None:
+ showerror("Include vide","L'include doit etre correctement initialisé avant d'etre édité")
+ return
nom=self.object.nom
if hasattr(self.object,'fichier_ini'):
if self.object.fichier_ini is None:
else:
nom=nom+' '+self.object.fichier_ini
macdisp=macrodisplay.makeMacroDisplay(appli,self,nom)
+ CONNECTOR.Connect(self.object.jdc_aux,"close",self.onCloseView,(macdisp,))
+
+ def onCloseView(self,macdisp):
+ #print "onCloseView",self,macdisp
+ macdisp.quit()
class INCLUDEPanel(MACROPanel):
def makeFichierPage(self,page):
on crée ou supprime les noeuds concernés
(self est d'un niveau inférieur ou égal à l'ETAPE)
"""
+ raise "OBSOLETE"
return 0
def replace_enfant_BAK(self,item):
""" Retourne le noeud fils à éventuellement remplacer """
+ raise "OBSOLETE"
return None
return self.sublist
def GetSubList_BAK(self):
+ raise "OBSOLETE"
if self.isactif():
liste=self.object.mc_liste
else:
return commande_comment
def additem_BAK(self,name,pos):
+ raise "OBSOLETE"
mcent=self.addentite(name,pos)
self.expandable=1
return item
def GetSubList_BAK(self):
+ raise "OBSOLETE"
sublist=[]
for obj in self.object.mc_liste:
def setfunction(value, object=obj):
return sublist
def verif_condition_bloc_BAK(self):
+ raise "OBSOLETE"
return self.object.verif_condition_bloc()
- def replace_child(self,old_item,new_item):
+ def replace_child_BAK(self,old_item,new_item):
"""
Remplace old_item.getObject() par new_item.getObject() dans
les fils de self.object
return self.object.valid_valeur_partielle(valeur)
def valide_liste_partielle_BAK(self,item,listecourante):
+ raise "OBSOLETE"
valeuravant=self.object.valeur
valeur=listecourante
valeur.append(item)
return self.object.valid_valeur(valeur)
def valide_liste_complete_BAK (self,valeur):
+ raise "OBSOLETE"
valeuravant=self.object.valeur
retour=self.object.set_valeur(valeur)
validite=0
else:
texte="Le fichier %s contient une commande %s\n" %(fic_origine,'POURSUITE')
texte = texte+'Donnez le nom du fichier dont vous \n voulez faire une poursuite'
+ if self.test == 1: raise Exception("Erreur: "+texte)
w = Label(self.dialog.interior(),
text = texte)
w.pack(padx = 10, pady = 10)
def __init__(self,l_mc):
self.l_mc = l_mc
self.fenetre = Toplevel()
+ self.fenetre.withdraw()
self.fenetre.geometry("400x400+0+0")
self.fenetre.title("Mots-clés inconnus dans le fichier de commandes")
self.init()
self.init_liste_mc()
self.init_boutons()
centerwindow(self.fenetre)
+ self.fenetre.deiconify()
def init(self) :
"""
if radio:menu.invoke(radio)
def quit(self):
- try:
- self.macroitem.views.remove(self)
- except:
- pass
self.fenetre.destroy()
def makeMacroDisplay(appli,macroitem,nom_item):
self.bouton_cata.place(relx=0.5,rely = 0.5,relheight = 0.8,anchor='center')
self.bouton_doc.place(relx=0.75,rely = 0.5,relheight = 0.8,anchor='center')
else:
- self.bouton_sup.place(relx=0.25,rely = 0.5,relheight = 0.8,anchor='center')
- self.bouton_doc.place(relx=0.5,rely = 0.5,relheight = 0.8,anchor='center')
+ self.bouton_sup.place(relx=0.3,rely = 0.5,relheight = 0.8,anchor='center')
+ self.bouton_doc.place(relx=0.7,rely = 0.5,relheight = 0.8,anchor='center')
def show_catalogue(self):
try:
Suppression du noeud courant
"""
# On signale au parent du panel (le JDCDisplay) une modification
- if self.parent.modified == 'n' : self.parent.init_modif()
+ self.parent.init_modif()
self.node.delete()
def affiche(self):
self.parent.appli.affiche_infos('')
def get_liste_cmd_BAK(self):
+ raise "OBSOLETE"
listeCmd = self.cata.listCmd()
return listeCmd
try :
pos=self.node.parent.children.index(self.node)
commande_comment = self.node.item.get_objet_commentarise()
+ # On signale au parent du panel (le JDCDisplay) une modification
+ self.parent.init_modif()
self.node.parent.children[pos].select()
- #self.parent.appli.bureau.JDCDisplay_courant.ReplaceObjectNode(self.node,commande_comment,None)
except Exception,e:
traceback.print_exc()
widgets.showerror("TOO BAD",str(e))
self.progress = None
self.destroy()
if self.main:
- self.main.update()
- self.main.deiconify()
centerwindow(self.main,parent='sans')
+ self.main.deiconify()
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.20 2005/04/13 14:59:31 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.21 2005/05/19 12:18:48 eficas Exp $"
#
Fonte_Standard = fontes.standard
def delete_node_child_BAK(self,child):
""" Supprime child des enfants de self et les id associés """
+ raise "OBSOLETE"
child.efface()
self.children.remove(child)
self.canvas.update()
Supprime child des enfants de self, tous les id associés
ET l'objet associé
"""
+ raise "OBSOLETE"
if self.item.suppitem(child.item):
self.delete_node_child(child)
return 1
Affiche la valeur de l'objet pointé par self
"""
valeur = self.node.item.get_valeur()
- if valeur == None or valeur == '' : return # pas de valeur à afficher ...
+ if valeur == None or valeur == '' : # pas de valeur à afficher ...
+ self.entry.delete(0,END)
+ self.entry.focus()
+ return
+
valeur_texte=self.get_valeur_texte(valeur)
if valeur_texte != "":
valeur=valeur_texte
if self.parent.modified == 'n' : self.parent.init_modif()
anc_val = self.node.item.get_valeur()
valeurentree = self.get_valeur()
- self.erase_valeur()
valeur,validite=self.node.item.eval_valeur(valeurentree)
if not validite :
commentaire = "impossible d'évaluer : %s " %`valeurentree`
+ self.display_valeur()
self.parent.appli.affiche_infos(commentaire)
return
self.parent.appli.affiche_infos("Valeur du mot-clé non autorisée : "+mess)
elif self.node.item.isvalid() :
self.parent.appli.affiche_infos('Valeur du mot-clé enregistrée')
- #if self.node.item.get_position()=='global':
- #self.node.etape.verif_all()
- #elif self.node.item.get_position()=='global_jdc':
- #self.node.racine.verif_all()
- #else :
- #self.node.parent.verif()
- #self.node.update()
- #self.node.parent.select()
else :
cr = self.node.item.get_cr()
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
self.reset_old_valeur(anc_val,mess=mess)
+ self.display_valeur()
def __init__(self,appli,titre="",texte=""):
self.appli=appli
self.fenetre = Toplevel()
+ self.fenetre.withdraw()
self.fenetre.configure(width = 800,height=500)
self.fenetre.protocol("WM_DELETE_WINDOW", self.quit)
self.fenetre.title("Visualisation du "+titre)
# affichage du texte
self.affiche_texte(self.texte)
centerwindow(self.fenetre)
+ self.fenetre.deiconify()
def page_up(self,event):
event.widget.yview_scroll(-1, "page")
#pass
def get_liste_BAK(self):
+ raise "OBSOLETE"
return self.liste
# PN attention à la gestion des paramétres
def control_sdprods(self,d):
"""sans objet pour les commandes commentarisées"""
pass
+ def close(self):
+ pass
"""sans objet """
pass
+ def close(self):
+ pass
+
self.g_context[sdnom]=sd
def get_verif_contexte(self):
+ #print "get_verif_contexte"
j_context=self.get_contexte_avant(None)
self.verif_contexte(j_context)
return j_context
#print "verif_contexte"
for nom_sd,sd in context.items():
if not isinstance(sd,ASSD):continue
- if self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
- etape=self.etape_include):
+ autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
+ etape=self.etape_include)
+ if sd and sd is not autre_sd:
# Il existe un concept produit par une etape apres self
# => impossible d'inserer
raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
définie apres etape en tenant compte des concepts detruits
Si avec vaut 'non' exclut etape de la recherche
"""
+ #print "jdc_include.get_sd_apres_etape_avec_detruire",nom_sd,sd,id(sd)
autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec)
+ #print autre_sd,id(autre_sd)
+ # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
+ # la recherche en retournant None
+ # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
+ # la recherche en retournant le concept nouvellement defini
+ # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
if autre_sd is None or autre_sd is not sd :return autre_sd
return self.etape_include.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,self.etape_include,'non')
# Nettoyage des etapes du parent
self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd)
-
-
class JDC_INCLUDE(JDC_POURSUITE):
def active_etapes(self):
for e in self.etapes:
"""sans objet """
pass
+ def close(self):
+ pass
+
class ITEM_PARAMETRE :
self.parent.del_sdprod(self.sd)
self.parent.delete_concept(self.sd)
+ def close(self):
+ return
+
def delete_concept(self,sd):
"""
Inputs :
self.editmode=0
raise AsException("Impossible d ajouter la commande "+name)
+ def close(self):
+ #print "JDC.close",self
+ for etape in self.etapes:
+ if hasattr(etape,"close"):etape.close()
+ CONNECTOR.Emit(self,"close")
+
def set_current_step(self):
CONTEXT.unset_current_step()
CONTEXT.set_current_step(self)
définie apres etape en tenant compte des concepts detruits
Si avec vaut 'non' exclut etape de la recherche
"""
+ #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
ietap=self.etapes.index(etape)
if avec == 'non':ietap=ietap+1
d={nom_sd:sd}
e.update_context(d)
autre_sd=d.get(nom_sd,None)
if autre_sd is None:
- # Le concept a ete detruit
+ # Le concept a ete detruit. On interrompt la recherche car il n'y a
+ # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
return None
if autre_sd is not sd :
- # L'etape produit un concept de meme nom
+ # L'etape produit un concept different de meme nom. La situation n'est
+ # pas saine (sauf peut etre si reuse ???)
if hasattr(e,'reuse') and e.reuse == autre_sd:
# Le concept etant reutilise, on interrompt la recherche.
# On considere qu'il n'y a pas de nouveau concept defini
# meme si dans les etapes suivantes le concept est detruit
# et un concept de meme nom créé.
+ # AVERIFIER : avec reuse le concept devrait etre le meme
+ # le passage par ici est tres improbable
return None
else:
- # Le concept est produit par l'etape
+ # Le concept est produit par l'etape (Il y a conflit potentiel).
+ # Le concept est redefini par une etape posterieure.
return autre_sd
- # On n'a rien trouve. Pas de concept de nom nom_sd
- return None
+ # Pas de destruction du concept ni de redefinition. On retourne le
+ # concept initial
+ return sd
def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
"""
# Il faut la désenregistrer
etape.niveau.unregister(etape)
etape.supprime_sdprods()
+ etape.close()
self.active_etapes()
# Apres suppression de l'etape il faut controler que les etapes
# On met g_context à blanc
self.g_context={}
+ def close(self):
+ #print "MACRO_ETAPE.close",self
+ if hasattr(self,"jdc_aux") and self.jdc_aux:
+ # La macro a un jdc auxiliaire inclus. On demande sa fermeture
+ self.jdc_aux.close()
+
def delete_concept(self,sd):
"""
Fonction : Mettre a jour les mots cles de l etape et eventuellement
def force_fichier_init(self):
"""
- Force le fichier init en erreur
+ Force le remplacement du fichier init meme si le remplacant est en erreur
"""
- j_context=self.jdc_aux.get_contexte_avant(None)
+ # Reinitialisation complete du compte-rendu d'erreurs
+ self.jdc_aux.cr=self.jdc_aux.CR()
# On remplit le dictionnaire des concepts produits inclus
# en retirant les concepts présents dans le contexte initial
# On ajoute egalement le concept produit dans le sds_dict du parent
# sans verification car on est sur (verification integrée) que
# le nommage est possible
+ j_context=self.jdc_aux.get_contexte_avant(None)
self.g_context.clear()
context_ini=self.jdc_aux.context_ini
for k,v in j_context.items():
self.index_etape_courante=self.jdc_aux.index_etape_courante
self.contexte_fichier_init = j_context
- # On conserve la memoire du nouveau fichier
- # mais on n'utilise pas les concepts crees par ce fichier
- # on met l'etape en erreur : fichier_err=string.join(l)
+ # On enregistre la modification de fichier
self.init_modif()
self.state="undetermined"
- # On enregistre la modification de fichier
self.record_unite()
- #self.etapes=[]
- #self.g_context={}
# Le contexte du parent doit etre reinitialise car les concepts produits ont changé
self.parent.reset_context()
+ # On remplace les anciens concepts par les nouveaux (y compris ajouts
+ # et suppression) et on propage les modifications aux etapes precedentes et suivantes
+ # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
+ # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
+ # necessaires
self.old_contexte_fichier_init=self.old_context
- #self.contexte_fichier_init={}
self.reevalue_sd_jdc()
self.fin_modif()
except:
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
self.fichier_err = string.join(l)
- #self.etapes=[]
self.g_context={}
-
+ self.etapes=[]
+ self.jdc_aux=None
self.old_contexte_fichier_init=old_context
self.contexte_fichier_init={}
self.reevalue_sd_jdc()
#if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
if not self.parent.recorded_units.has_key(unite):
- # Nouvelle unite
- f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
- units={}
+ # Le numero d'unite a ete change. Le nouveau numero ne fait pas partie des numeros
+ # enregistres.
+ f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
if f is not None:
self.fichier_ini = f
self.fichier_text=text
- self.recorded_units=units
- if self.fichier_ini is None and self.jdc.appli:
- self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
- message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
+ #print "update_fichier_init",self.recorded_units
else:
# Unite existante
f,text,units=self.parent.recorded_units[unite]
self.fichier_err="Le fichier associé n'est pas défini"
self.parent.change_unit(unite,self,self.fichier_unite)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.contexte_fichier_init={}
self.parent.reset_context()
self.reevalue_sd_jdc()
self.fichier_err=string.join(l)
self.parent.change_unit(unite,self,self.fichier_unite)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.contexte_fichier_init={}
# Le contexte du parent doit etre reinitialise car les concepts
#print self.parent.old_recorded_units
#print self.parent.recorded_units
if unite is None:
+ # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
units={}
else:
+ # On est dans le cas d'un include. On reutilise toutes les unites de parent
units=self.parent.recorded_units
- if self.parent.old_recorded_units.has_key(unite):
- f,text,units=self.parent.old_recorded_units[unite]
+
+ #if self.parent.old_recorded_units.has_key(unite):
+ if self.parent.recorded_units.has_key(unite):
+ f,text,units=self.parent.recorded_units[unite]
+ #f,text,units=self.parent.old_recorded_units[unite]
#print id(self.recorded_units)
self.recorded_units=units
#print id(self.recorded_units)
f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
else:
f,text=None,None
+
self.recorded_units=units
if f is None and self.jdc.appli:
self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
def get_file(self,unite=None,fic_origine=''):
"""Retourne le nom du fichier et le source correspondant a l'unite unite
- Initialise en plus recorded_units
"""
- #print "get_file",unite
- units={}
if self.jdc :
f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
else:
f,text=None,None
- self.recorded_units=units
return f,text
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
)
self.parent.record_unit(unite,self)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.fichier_err = string.join(l)
self.contexte_fichier_init={}
raise
self.fichier_err = string.join(l)
self.parent.record_unit(self.fichier_unite,self)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.contexte_fichier_init={}
raise
)
self.parent.record_unit(None,self)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.fichier_err = string.join(l)
self.contexte_fichier_init={}
raise
# et on leve une exception si une erreur a été enregistrée
self.update_fichier_init(None)
if self.fichier_err is not None: raise Exception(self.fichier_err)
-
-#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
- def type_sdprod(self,co,t):
- """
- Cette methode a pour fonction de typer le concept co avec le type t
- dans les conditions suivantes
- 1- co est un concept produit de self
- 2- co est un concept libre : on le type et on l attribue à self
- Elle enregistre egalement les concepts produits (on fait l hypothese
- que la liste sdprods a été correctement initialisee, vide probablement)
- """
- #print "type_sdprod",co,t
- if not hasattr(co,'etape'):
- # Le concept vaut None probablement. On ignore l'appel
- return
- #
- # On cherche a discriminer les differents cas de typage d'un concept
- # produit par une macro qui est specifie dans un mot cle simple.
- # On peut passer plusieurs fois par type_sdprod ce qui explique
- # le nombre important de cas.
- #
- # Cas 1 : Le concept est libre. Il vient d'etre cree par CO(nom)
- # Cas 2 : Le concept est produit par la macro. On est deja passe par type_sdprod.
- # Cas semblable a Cas 1.
- # Cas 3 : Le concept est produit par la macro englobante (parent). On transfere
- # la propriete du concept de la macro parent a la macro courante (self)
- # en verifiant que le type est valide
- # Cas 4 : La concept est la propriete d'une etape fille. Ceci veut dire qu'on est
- # deja passe par type_sdprod et que la propriete a ete transfere a une
- # etape fille. Cas semblable a Cas 3.
- # Cas 5 : Le concept est produit par une etape externe a la macro.
- #
- if co.etape == None:
- # Cas 1 : le concept est libre
- # On l'attache a la macro et on change son type dans le type demande
- # Recherche du mot cle simple associe au concept
- mcs=self.get_mcs_with_co(co)
- if len(mcs) != 1:
- raise AsException("""Erreur interne.
-Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
- mcs=mcs[0]
- #
- # Attention : la seule modif est ici : Accas.CO au lieu de CO
- #
- if not Accas.CO in mcs.definition.type:
- raise AsException("""Erreur interne.
-Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
- co.etape=self
- co.__class__ = t
- self.sdprods.append(co)
-
- elif co.etape== self:
- # Cas 2 : le concept est produit par la macro (self)
- # On est deja passe par type_sdprod (Cas 1 ou 3).
- # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
- # Le type du concept doit etre coherent avec le type demande (seulement derive)
- if not isinstance(co,t):
- raise AsException("""Erreur interne.
-Le type demande (%s) et le type du concept (%s) devraient etre derives""" %(t,co.__class__))
- self.sdprods.append(co)
-
- elif co.etape== self.parent:
- # Cas 3 : le concept est produit par la macro parente (self.parent)
- # on transfere la propriete du concept a la macro fille
- # et on change le type du concept comme demande
- # Au prealable, on verifie que le concept existant (co) est une instance
- # possible du type demande (t)
- # Cette règle est normalement cohérente avec les règles de vérification des mots-clés
- if not isinstance(co,t):
- raise AsException("""
-Impossible de changer le type du concept produit (%s) en (%s).
-Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)""" % (co,t,co.__class__,t))
- mcs=self.get_mcs_with_co(co)
- if len(mcs) != 1:
- raise AsException("""Erreur interne.
-Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
- mcs=mcs[0]
- if not Accas.CO in mcs.definition.type:
- raise AsException("""Erreur interne.
-Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
- co.etape=self
- # On ne change pas le type car il respecte la condition isinstance(co,t)
- #co.__class__ = t
- self.sdprods.append(co)
-
- elif self.issubstep(co.etape):
- # Cas 4 : Le concept est propriété d'une sous etape de la macro (self).
- # On est deja passe par type_sdprod (Cas 3 ou 1).
- # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
- # Le type du concept et t doivent etre derives.
- # Il n'y a aucune raison pour que la condition ne soit pas verifiee.
- if not isinstance(co,t):
- raise AsException("""Erreur interne.
-Le type demande (%s) et le type du concept (%s) devraient etre derives""" %(t,co.__class__))
- self.sdprods.append(co)
-
- else:
- # Cas 5 : le concept est produit par une autre étape
- # On ne fait rien
- return
-
"""
return None
+ def supprime_sdprods(self):
+ """
+ Fonction: Lors d'une destruction d'etape, detruit tous les concepts produits
+ Une procedure n'en a aucun
+ """
+ return
+
def delete_concept(self,sd):
"""
Inputs :
-#@ MODIF N_FONCTION Noyau DATE 20/10/2004 AUTEUR DURAND C.DURAND
+#@ MODIF N_FONCTION Noyau DATE 17/05/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
self.expression=None
def __call__(self,*val):
- context={}
+ if hasattr(self.parent,'contexte_fichier_init'):
+ context=self.parent.contexte_fichier_init
+ else : context={}
i=0
for param in self.nompar :
context[param]=val[i]
-#@ MODIF N_MACRO_ETAPE Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
+#@ MODIF N_MACRO_ETAPE Noyau DATE 31/05/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
"""
nature = "COMMANDE"
+ typeCO=CO
def __init__(self,oper=None,reuse=None,args={}):
"""
Attributs :
raise AsException("""Erreur interne.
Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
mcs=mcs[0]
- if not CO in mcs.definition.type:
+ if not self.typeCO in mcs.definition.type:
raise AsException("""Erreur interne.
Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
co.etape=self
raise AsException("""Erreur interne.
Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
mcs=mcs[0]
- if not CO in mcs.definition.type:
+ if not self.typeCO in mcs.definition.type:
raise AsException("""Erreur interne.
Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
co.etape=self
return self.is_object_from(valeur,type_permis)
else:
print "Type non encore géré %s" %`type_permis`
- #print self.nom,self.parent.nom,self.jdc.fichier
+ print self.nom,self.parent.nom,self.jdc.fichier
def isinintervalle(self,valeur,cr='non'):
"""
