import Editeur
from Editeur import eficas_go
-if len(sys.argv) > 1 :
- # on veut ouvrir un fichier directement au lancement d'Eficas
- eficas_go.lance_eficas(code='ASTER',fichier = sys.argv[1])
-else:
- # on veut ouvrir Eficas 'vide'
- eficas_go.lance_eficas(code='ASTER')
+eficas_go.lance_eficas(code='ASTER')
#
# ======================================================================
-import os
+import os,sys
# REPINI sert à localiser le fichier editeur.ini
# Obligatoire
]
}
+userprefs=os.path.expanduser("~/Eficas_install/prefs.py")
+if os.path.isfile(userprefs):
+ try:
+ execfile(userprefs)
+ except:
+ pass
import properties
from widgets import Fenetre
from Misc import MakeNomComplet
+import session
VERSION="EFICAS v1.7"
class APPLI:
def __init__ (self,master,code='ASTER',fichier=None,test=0) :
- self.top=master
self.code=code
+ self.top=master
self.top.protocol("WM_DELETE_WINDOW",self.exitEFICAS)
self.top.minsize(900,500)
self.top.geometry("900x500")
self.top.title(VERSION + ' pour '+self.code)
self.top.withdraw()
self.initializeTk(master)
+ Pmw.initialise(master)
+
self.dict_reels={}
self.liste_simp_reel=[]
# L'attribut test permet d'activer les panneaux de splash et d'erreur (test=0)
# Si test est different de 0, les panneaux ne sont pas activés
self.test=test
- Pmw.initialise(master)
+
+ # Lecture des parametres de configuration (fichier global editeur.ini
+ # et utilisateur eficas.ini)
self.lecture_parametres()
+
self.format_fichier = Tkinter.StringVar()
self.message=''
+ # Avant la creation du bureau qui lit le catalogue
+ self.version_code=session.d_env.cata
+
+ # Creation de la menubar, toolbar, messagebar
self.cree_composants_graphiques()
- self.load_appli_composants() # Creation du BUREAU
+ # Creation des autres composants graphiques dont le bureau (parametrable par prefs.py)
+ self.load_appli_composants()
+
# PN : ajout d un attribut pour indiquer si
# l appli a ete lance depuis Salome
self.salome=0
if (self.test == 0):
splash.fini_splash()
- self.affiche_FAQ()
- # AY : cas ou le nom du fichier a été passé en argument
- if fichier :
- fich=str(MakeNomComplet.FILENAME(fichier))
- if not os.path.isfile(fich):
- showerror("Fichier inexistant", "Fichier %s en argument n'existe pas" % fich)
- else:
- self.bureau.openJDC( fich)
- # AY : fin
+ #self.affiche_FAQ()
+ cwd=os.getcwd()
+ # Ouverture des fichiers de commandes donnes sur la ligne de commande
+ 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
def cree_composants_graphiques(self):
"""
- Cree les constituants de l'application :
+ Cree les constituants graphiques fixes de l'application :
- menubar
- toolbar
- - bureau
- statusbar
"""
if (self.test == 0):
self.statusbar=statusbar.STATUSBAR(self.top)
def load_appli_composants(self):
+ """
+ Cree les autres constituants graphiques de l'application :
+ - bureau
+ - readercata
+ - ...
+ Cette creation est parametrable par fichier prefs.py
+ """
if (self.test == 0):
splash._splash.configure(text = "Chargement des appli_composants")
for mname in self.appli_composants:
def affiche_FAQ(self):
import faq
- #faq.affiche(self.top)
+ faq.affiche(self.top)
def affiche_infos(self,message):
self.statusbar.affiche_infos(message)
self.ShowJDC(J,self.JDCName)
self.appli.toolbar.active_boutons()
- def ShowJDC(self,JDC,nom,label_onglet=None):
+ def ShowJDC(self,JDC,nom,label_onglet=None,JDCDISPLAY=JDCDISPLAY):
"""
Lance l'affichage du JDC cad création du JDCDisplay
Rajoute le JDCDisplay à la liste des JDCDisplay si label_onglet == None cad si on crée
"""
self.JDC=JDC
self.JDCName = self.JDC.nom = nom
- #XXX CCAR: pour le moment mis en commentaire
- #self.JDC.set_context()
if label_onglet == None :
+ # On veut un nouvel onglet
label_onglet = self.GetLabelJDC()
self.nb.add(label_onglet,tab_text = nom,tab_width=20)
new = 'oui'
texte_cr = str(cr)
self.visu_texte_cr = Fenetre(self.appli,titre=titre,texte=texte_cr)
- def openJDC(self,file=None):
+ def openJDC(self,file=None,units=None):
"""
Demande à l'utilisateur quel JDC existant il veut ouvrir
"""
if not hasattr(self,'initialdir'):
#self.initialdir = self.appli.CONFIGURATION.rep_user
self.initialdir = self.appli.CONFIGURATION.initialdir
+
if file.__class__.__name__ in ('Event',):
file=None
+
if not file :
file = askopenfilename(title="Ouverture d'un fichier de commandes Aster",
defaultextension=".comm",
self.fileName = file
e=extension_fichier(file)
self.JDCName=stripPath(file)
- self.initialdir = os.path.dirname(file)
+ self.initialdir = os.path.dirname(os.path.abspath(file))
else :
return
- #XXX CCAR: pour le moment mis en commentaire
- #if self.JDCDisplay_courant:self.JDCDisplay_courant.jdc.unset_context()
format=self.appli.format_fichier.get()
# Il faut convertir le contenu du fichier en fonction du format
nom = self.JDCName,
rep_mat=self.appli.CONFIGURATION.rep_mat,
)
+ if units is not None:
+ J.recorded_units=units
+ J.old_recorded_units=units
+
J.analyse()
txt_exception = J.cr.get_mess_exception()
if txt_exception :
return range(len(self.object.etapes))
def additem(self,name,pos):
+ print self.object
if isinstance(name,Objecttreeitem.ObjectTreeItem) :
cmd=self.object.addentite(name.getObject(),pos)
else :
cmd = self.object.addentite(name,pos)
+ print cmd
item = self.make_objecttreeitem(self.appli,cmd.nom + " : ", cmd)
return item
""" Retourne la liste des noms des étapes de self.object"""
return self.object.get_l_noms_etapes()
+ def get_liste_cmd(self):
+ print "get_liste_cmd"
+ print self.object.niveau.definition
+ listeCmd = self.object.niveau.definition.get_liste_cmd()
+ return listeCmd
+
import Accas
treeitem =JDCTreeItem
#
__version__="$Name: $"
-__Id__="$Id: compomacro.py,v 1.14 2004/09/20 09:24:14 eficas Exp $"
+__Id__="$Id: compomacro.py,v 1.15 2005/03/10 09:25:30 eficas Exp $"
#
class MACROPanel(panels.OngletPanel):
# Si probleme a la lecture-conversion on arrete le traitement
if not text:
return
- self.node.item.object.recorded_units={}
+ #self.node.item.object.recorded_units={}
try:
self.node.item.object.make_contexte_include(new_fic,text)
panel=MACROPanel
class INCLUDETreeItem(MACROTreeItem):
- rmenu_specs=[("View","makeView")]
+ rmenu_specs=[("View","makeView"),
+ ("Edit","makeEdit"),
+ ]
+
+ def makeEdit(self,appli):
+ print "makeEdit",self.object,self.object.nom
+ print self.object.jdc_aux,self.object.jdc_aux.nom
+ # On cree un nouvel onglet dans le bureau
+ appli.bureau.ShowJDC(self.object.jdc_aux,self.object.jdc_aux.nom,
+ label_onglet=None,
+ JDCDISPLAY=macrodisplay.MACRODISPLAY)
def makeView(self,appli):
nom=self.object.nom
un ecran Splash pour faire patentier l'utilisateur
"""
# Modules Python
+import sys
import Tkinter
# Modules Eficas
import import_code
import splash
+import session
def lance_eficas(code,fichier=None):
"""
Lance l'appli EFICAS
"""
+ # Analyse des arguments de la ligne de commande
+ options=session.parse(sys.argv)
root = Tkinter.Tk()
splash.init_splash(root,code=code,titre="Lancement d'EFICAS pour %s" %code)
splash._splash.configure(text="Chargement d'EFICAS en cours.\n Veuillez patienter ...")
import eficas
- if fichier :
- eficas.EFICAS(root,code=code,fichier = fichier)
- else:
- eficas.EFICAS(root,code=code)
+ eficas.EFICAS(root,code=code)
root.mainloop()
if hasattr(node.item,"panel"):
self.panel_courant=node.item.panel(self,self.pane.pane('selected'),node)
else:
+ print node.item
raise Exception("Le noeud sélectionné n'a pas de panel associé")
else:
self.panel_courant = panels.Panel_Inactif(self,self.pane.pane('selected'),node)
import images
import tooltip
import Objecttreeitem
+import compojdc
+import treewidget
from widgets import Fenetre
-class MACRO2TreeItem(Objecttreeitem.ObjectTreeItem):
+#class MACRO2TreeItem(Objecttreeitem.ObjectTreeItem):
+class MACRO2TreeItem(compojdc.JDCTreeItem):
def IsExpandable(self):
return 1
def makeMacroDisplay(appli,jdc,nom_jdc):
return MacroDisplay(appli,jdc,nom_jdc)
+class TREEITEMINCANVAS:
+ def __init__(self,object,nom="",parent=None,appli=None,sel=None,rmenu=None):
+ print "TREEITEMINCANVAS",object
+ self.object=object
+ self.nom=nom
+ self.appli=appli
+ self.parent=parent
+
+ self.item=MACRO2TreeItem(self.appli,self.nom,self.object)
+ self.canvas=Pmw.ScrolledCanvas(self.parent,borderframe=1,canvas_background='gray95')
+ self.canvas.pack(padx=10,pady=10,fill = 'both', expand = 1)
+ if not sel:
+ def sel(event=None):
+ return
+ self.tree=treewidget.Tree(self.appli,self.item,self.canvas,command=sel,rmenu=rmenu)
+ self.tree.draw()
+
+ def mainloop(self):
+ self.parent.mainloop()
+
+ def update(self):
+ """Cette methode est utilisee pour signaler une mise a jour des objets associes"""
+ self.tree.update()
+
+import jdcdisplay
+
+class MACRODISPLAY(jdcdisplay.JDCDISPLAY):
+ def __init__(self,jdc,nom_jdc,appli=None,parent=None):
+ print "MACRODISPLAY",jdc
+ self.jdc=jdc
+ self.nom_jdc=nom_jdc
+ self.fichier=None
+ self.panel_courant=None
+ self.appli=appli
+ self.parent=parent
+ self.node_selected = None
+ self.modified='n'
+
+ self.pane=Pmw.PanedWidget(self.parent,orient='horizontal')
+ self.pane.add('treebrowser',min=0.4,size=0.5)
+ self.pane.add('selected',min=0.4)
+ self.pane.pack(expand=1,fill='both')
+ self.tree=TREEITEMINCANVAS(jdc,nom_jdc,self.pane.pane('treebrowser'),
+ self.appli,self.select_node,self.make_rmenu)
+
Liste = ListeChoix(self,frame2,liste_cmd,liste_commandes = liste_commandes,
filtre='oui',titre = "Commandes",optionReturn="oui")
else:
- liste_groupes=self.node.item.object.niveau.definition.liste_groupes
- dict_groupes=self.node.item.object.niveau.definition.dict_groupes
+ liste_commandes=liste_commandes+(("<Return>",self.defCmd),)
+ liste_groupes,dict_groupes=self.get_groups()
Liste = ListeChoixParGroupes(self,frame2,liste_groupes,dict_groupes,
liste_commandes = liste_commandes,
filtre='oui',titre = "Commandes",optionReturn="oui")
Liste = ListeChoix(self,page,liste_cmd,liste_commandes = liste_commandes,
filtre='oui',titre = "Commandes",optionReturn="oui")
else:
- liste_groupes=self.node.item.object.niveau.definition.liste_groupes
- dict_groupes=self.node.item.object.niveau.definition.dict_groupes
+ liste_commandes=liste_commandes+(("<Return>",self.defCmd),)
+ liste_groupes,dict_groupes=self.get_groups()
Liste = ListeChoixParGroupes(self,page,liste_groupes,dict_groupes,
liste_commandes = liste_commandes,
filtre='oui',titre = "Commandes",optionReturn="oui")
listeCmd = self.cata.listCmd()
return listeCmd
+ def get_groups(self):
+ jdc=self.node.item.object.get_jdc_root()
+ return jdc.get_groups()
+
def get_liste_cmd(self):
- listeCmd = self.node.item.object.niveau.definition.get_liste_cmd()
+ jdc=self.node.item.object.get_jdc_root()
+ listeCmd = jdc.get_liste_cmd()
return listeCmd
def deselectCmd(self,name):
self.parent=parent
self.code=self.appli.code
self.appli.format_fichier.set('python')
+ self.version_code=self.appli.version_code
+ self.fic_cata=None
self.OpenCata()
self.cataitem=None
if self.appli.test == 0 :
splash._splash.configure(text = message1)
self.configure_barre(4)
+
liste_cata_possibles=[]
for catalogue in self.appli.CONFIGURATION.catalogues:
if catalogue[0] == self.code :
liste_cata_possibles.append(catalogue)
- if len(liste_cata_possibles)==1:
+
+ if self.version_code is not None:
+ # La version a ete fixee
+ for cata in liste_cata_possibles:
+ if self.version_code == cata[1]:
+ self.fic_cata = cata[2]
+ self.appli.format_fichier.set(cata[3])
+ elif len(liste_cata_possibles)==1:
self.fic_cata = liste_cata_possibles[0][2]
self.code = self.appli.CONFIGURATION.catalogues[0][0]
self.version_code = liste_cata_possibles[0][1]
self.appli.format_fichier.set(liste_cata_possibles[0][3])
- elif len(liste_cata_possibles)==0:
- # aucun catalogue défini dans le fichier Accas/editeur.ini
- if self.code == 'ASTER' :
- self.fic_cata = os.path.join(prefs.CODE_PATH,'Cata','cata.py')
- elif self.code == 'SATURNE' :
- self.fic_cata = os.path.join(prefs.CODE_PATH,'Cata','cata_saturne.py')
- elif self.code == 'DESCARTES':
- self.fic_cata = os.path.join(prefs.CODE_PATH,'Cata','cata_descartes.py')
- else :
- print 'Code inconnu'
- sys.exit(0)
else:
# plusieurs catalogues sont disponibles : il faut demander à l'utilisateur
# lequel il veut utiliser ...
self.ask_choix_catalogue()
+
if self.fic_cata == None :
- self.parent.destroy()
sys.exit(0)
+
# détermination de fic_cata_c et fic_cata_p
self.fic_cata_c = self.fic_cata + 'c'
self.fic_cata_p = os.path.splitext(self.fic_cata)[0]+'_pickled.py'
"""
Réalise l'import du catalogue dont le chemin d'accès est donné par cata
"""
- import imp
if self.appli.test == 0 :
splash._splash.configure(text = "Chargement du catalogue")
nom_cata = os.path.splitext(os.path.basename(cata))[0]
sys.path[:0] = [rep_cata]
try :
o=__import__(nom_cata)
- #f,p,d = imp.find_module(nom_cata)
- #o = imp.load_module(nom_cata,f,p,d)
return o
except Exception,e:
traceback.print_exc()
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.18 2004/11/17 16:08:34 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.19 2005/02/25 11:38:03 eficas Exp $"
#
Fonte_Standard = fontes.standard
Interface avec ACCAS : création de l'objet de nom name et
du noeud associé. Retourne le noeud fils ainsi créé
"""
+ print "full_creation",name,pos,self.item
item = self.item.additem(name,pos)
if item == None or item == 0:
# impossible d'ajouter le noeud de nom : name
index = self.MCbox.index(self.dico_labels[arg])
self.MCbox.see(index)
self.arg_selected = arg
+ self.dico_labels[self.arg_selected].focus_set()
break
- try :
- self.dico_labels[self.arg_selected].focus_set()
- except :
- pass
+
+ #try :
+ #self.dico_labels[self.arg_selected].focus_set()
+ #except :
+ #pass
def get_liste_old(self):
return self.liste
Cette classe est utilisée pour afficher une liste de commandes classées par
groupes. L'utilisateur peut réaliser des actions de selection
qui déclenchent des actions spécifiées par les bindings contenus dans liste_commandes
+ Exemple de binding:
+ liste_commandes = (("<Enter>",self.selectCmd),
+ ("<Leave>",self.deselectCmd),
+ ("<Double-Button-1>",self.defCmd))
+ Il s'agit d'une liste de doublets dont le premier element est un evenement et le
+ deuxieme un callback a appeler sur l'evenement en question.
+
"""
def __init__(self,parent,page,liste_groupes,dict_groupes,liste_commandes=[],liste_marques =[],
- active ='oui',filtre='non',titre=''):
+ active ='oui',filtre='non',titre='',optionReturn=None):
self.parent = parent
self.page = page
self.liste_groupes = liste_groupes
self.active = active
self.titre = titre
self.filtre = filtre
+ self.optionReturn = optionReturn
self.init()
def affiche_liste(self):
window=label,
stretch = 1)
self.MCbox.insert(END,'\n')
+
+ def null(*tp,**args): return
+
if self.active == 'oui':
- label.bind(self.liste_commandes[0][0],
- lambda e,s=self,c=self.liste_commandes[0][1],x=cmd,l=label : s.selectitem(x,l,c))
- label.bind(self.liste_commandes[1][0],
- lambda e,s=self,c=self.liste_commandes[1][1],x=cmd,l=label : s.deselectitem(l,x,c))
- label.bind(self.liste_commandes[2][0],
- lambda e,s=self,c=self.liste_commandes[2][1],x=cmd,l=label : s.chooseitem(x,l,c))
- label.bind("<Key-Down>", self.selectNextItem(event))
+ # Traitement par defaut des evenements
+ label.bind("<Enter>",lambda e,s=self,c=null,x=cmd,l=label: s.selectitem(x,l,c))
+ label.bind("<Leave>",lambda e,s=self,c=null,x=cmd,l=label: s.deselectitem(l,x,c))
+ label.bind("<Double-Button-1>",lambda e,s=self,c=null,x=cmd,l=label: s.chooseitem(x,l,c))
+ label.bind("<Return>",lambda e,s=self,c=null,x=cmd,l=label: s.chooseitem(x,l,c))
+ label.bind("<Key-Right>",lambda e,s=self,c=null,x=cmd,l=label,gr=grp: s.selectNextItem(x,l,c,gr,x))
+ label.bind("<Key-Down>",lambda e,s=self,c=null,x=cmd,l=label,gr=grp: s.selectNextItem(x,l,c,gr,x))
+ label.bind("<Key-Left>",lambda e,s=self,c=null,x=cmd,l=label,gr=grp: s.selectPrevItem(x,l,c,gr,x))
+ label.bind("<Key-Up>",lambda e,s=self,c=null,x=cmd,l=label,gr=grp: s.selectPrevItem(x,l,c,gr,x))
+
+ # Si des callbacks sont definis on les utilise
+ for event,callback in self.liste_commandes:
+ if event == "<Enter>":
+ label.bind("<Enter>",lambda e,s=self,c=callback,x=cmd,l=label: s.selectitem(x,l,c))
+ elif event == "<Leave>":
+ label.bind("<Leave>",lambda e,s=self,c=callback,x=cmd,l=label: s.deselectitem(l,x,c))
+ elif event == "<Double-Button-1>":
+ label.bind("<Double-Button-1>",lambda e,s=self,c=callback,x=cmd,l=label: s.chooseitem(x,l,c))
+ elif event == "<Return>":
+ label.bind("<Return>",lambda e,s=self,c=callback,x=cmd,l=label: s.chooseitem(x,l,c))
+ elif event == "<Key-Right>":
+ label.bind("<Key-Right>",lambda e,s=self,c=callback,x=cmd,l=label,gr=grp:s.selectNextItem(x,l,c,gr,x))
+ elif event == "<Key-Down>":
+ label.bind("<Key-Down>",lambda e,s=self,c=callback,x=cmd,l=label,gr=grp:s.selectNextItem(x,l,c,gr,x))
+ elif event == "<Key-Left>":
+ label.bind("<Key-Left>",lambda e,s=self,c=callback,x=cmd,l=label,gr=grp:s.selectPrevItem(x,l,c,gr,x))
+ elif event == "<Key-Up>":
+ label.bind("<Key-Up>",lambda e,s=self,c=callback,x=cmd,l=label,gr=grp:s.selectPrevItem(x,l,c,gr,x))
+ else:
+ label.bind(event,lambda e,s=self,c=callback,x=cmd,l=label: c())
for marque in self.liste_marques:
try:
self.MCbox.config(state=DISABLED)
self.selection = None
+ def selectPrevItem(self,mot,label,callback,group,cmd):
+ g=self.liste_groupes.index(group)
+ liste_commandes=self.dict_groupes[group]
+ c=liste_commandes.index(cmd)
+ if c > 0:
+ co=liste_commandes[c-1]
+ else:
+ # debut de liste. On passe au groupe precedent
+ if g > 0:
+ gr=self.liste_groupes[g-1]
+ co=self.dict_groupes[gr][-1]
+ else:
+ # debut des groupes. On ne fait rien
+ return
+
+ # On a trouve l'item precedent
+ self.clear_marque()
+ labelsuivant=self.dico_labels[co]
+ if self.selection != None :
+ self.deselectitem(self.selection[1],self.selection[0],self.selection[2],)
+ self.selection = (co,labelsuivant,self.selection[2])
+ index = self.MCbox.index(labelsuivant)
+ self.MCbox.see(index)
+ self.arg_selected=co
+ self.highlightitem(labelsuivant)
+ labelsuivant.focus_set()
+ callback(co)
+
+ def selectNextItem(self,mot,label,callback,group,cmd):
+ g=self.liste_groupes.index(group)
+ liste_commandes=self.dict_groupes[group]
+ c=liste_commandes.index(cmd)
+ try:
+ co=liste_commandes[c+1]
+ except:
+ # fin de liste. On passe au groupe suivant
+ try:
+ gr=self.liste_groupes[g+1]
+ co=self.dict_groupes[gr][0]
+ except:
+ # fin des groupes. On ne fait rien
+ return
+ # On a trouve l'item suivant
+ self.clear_marque()
+ labelsuivant=self.dico_labels[co]
+ if self.selection != None :
+ self.deselectitem(self.selection[1],self.selection[0],self.selection[2],)
+ self.selection = (co,labelsuivant,self.selection[2])
+ index = self.MCbox.index(labelsuivant)
+ self.MCbox.see(index)
+ self.arg_selected=co
+ self.highlightitem(labelsuivant)
+ labelsuivant.focus_set()
+ callback(co)
+
def entry_changed(self,event=None):
"""
Cette méthode est invoquée chaque fois que l'utilisateur modifie le contenu
de l'entry et frappe <Return>
"""
if self.arg_selected != '' : self.deselectitem(self.dico_labels[self.arg_selected])
+
filtre = self.entry.get()+"*"
FILTRE = string.upper(filtre)
#
#
for grp in self.liste_groupes:
if fnmatch.fnmatch(grp,filtre) or fnmatch.fnmatch(grp,FILTRE) :
+ self.highlightitem(self.dico_labels[grp])
index = self.MCbox.index(self.dico_labels[grp])
self.MCbox.see(index)
# On ne selectionne pas le groupe
#self.arg_selected = grp
+ self.dico_labels[grp].focus_set()
# On a trouve un groupe on arrete la recherche
return
index = self.MCbox.index(self.dico_labels[cmd])
self.MCbox.see(index)
self.arg_selected = cmd
+ self.dico_labels[self.arg_selected].focus_set()
# On a trouve une commande on arrete la recherche
return
return context
+ def get_liste_cmd(self):
+ """
+ Retourne la liste des commandes du catalogue
+ """
+ return self.jdc_pere.get_liste_cmd()
+
+ def get_groups(self):
+ """
+ Retourne la liste des commandes du catalogue par groupes
+ """
+ return self.jdc_pere.get_groups()
+
+
class JDC_INCLUDE(JDC_POURSUITE):
def active_etapes(self):
"""
return []
+ def get_liste_cmd(self):
+ """
+ Retourne la liste des commandes du catalogue
+ """
+ return self.niveau.definition.get_liste_cmd()
+
+ def get_groups(self):
+ """
+ Retourne la liste des groupes
+ """
+ return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
+
def set_etape_context(self,etape):
"""
Positionne l'etape qui sera utilisee dans NommerSdProd pour
print etape.nom+".state: ",etape.state
def change_unit(self,unit,etape,old_unit):
- if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
+ #print "change_unit",unit,etape,old_unit
+ #print id(self.recorded_units),self.recorded_units
+ #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
self.record_unit(unit,etape)
def record_unit(self,unit,etape):
"""Enregistre les unites logiques incluses et les infos relatives a l'etape"""
+ #print "record_unit",unit,etape
if unit is None:
# Cas de POURSUITE
self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
else:
self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
+ #print id(self.recorded_units),self.recorded_units
+ #print self.recorded_units.get(None,(None,"",{}))[2]
+ #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
#ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
def register(self,etape):
ou leve une exception
--> utilisée par ops.POURSUITE et INCLUDE
"""
+ #print "get_contexte_jdc"
try:
# on essaie de créer un objet JDC auxiliaire avec un contexte initial
context_ini = self.parent.get_contexte_avant(self)
# En principe si la memorisation est faite au bon moment il n'est pas necessaire
# de prendre cette precaution mais ce n'est pas vrai partout.
old_recorded_units=self.recorded_units.copy()
- self.recorded_units.clear()
+ #print "get_contexte_jdc",id(self.recorded_units)
+ #self.recorded_units.clear()
- j=self.JdC_aux( procedure=text,cata=self.jdc.cata,
- nom=fichier,
- context_ini = context_ini,
+ j=self.JdC_aux( procedure=text, nom=fichier,
appli=self.jdc.appli,
+ cata=self.jdc.cata,
+ cata_ord_dico=self.jdc.cata_ordonne_dico,
+ context_ini = context_ini,
jdc_pere=self.jdc,etape_include=self,
prefix_include=prefix_include,
recorded_units=self.recorded_units,
# On recupere le contexte courant
self.current_context=j.current_context
self.index_etape_courante=j.index_etape_courante
+ self.jdc_aux=j
# XXX j.supprime() ???
# On rétablit le contexte (etape courante) à self
Cette méthode sert à créer un contexte en interprétant un texte source
Python
"""
+ #print "make_contexte_include"
# on récupère le contexte d'un nouveau jdc dans lequel on interprete text
contexte = self.get_contexte_jdc(fichier,text)
if contexte == None :
les noms des fichiers
Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
"""
-
+ #print "update_fichier_init",unite
self.fichier_err=None
self.old_contexte_fichier_init=self.contexte_fichier_init
- if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
+ #print self,self.parent,self.parent.recorded_units
+ #if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
+ if not self.parent.recorded_units.has_key(unite):
# Changement d'unite ou Nouvelle unite
f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
units={}
"""Retourne le nom du fichier et le source correspondant a l'unite unite
Initialise en plus recorded_units
"""
- units={}
+ #print "get_file_memo",unite,fic_origine,self,self.parent
+ #print self.parent.old_recorded_units
+ #print self.parent.recorded_units
+ if unite is None:
+ units={}
+ else:
+ units=self.parent.recorded_units
if self.parent.old_recorded_units.has_key(unite):
f,text,units=self.parent.old_recorded_units[unite]
+ #print id(self.recorded_units)
self.recorded_units=units
+ #print id(self.recorded_units)
return f,text
elif self.jdc :
f,text=self.jdc.get_file(unite=unite,fic_origine=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)
Sinon on retourne None. Les concepts produits par l'INCLUDE sont
pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
"""
-
+ #print "make_include",unite
# On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
# car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
del self.unite
