import Editeur
from Editeur import eficas_go
-eficas_go.lance_eficas(code='ASTER')
+eficas_go.lance_eficas()
CODE_PATH = None
#CODE_PATH = os.path.join(REPINI,'../../Superv')
+# la variable code donne le nom du code a selectionner
+code="ASTER"
+
# ICONDIR sert à localiser le répertoire contenant les icones
# Par défaut on utilise le répertoire icons dans Editeur
ICONDIR=os.path.join(INSTALLDIR,'Editeur','icons')
VERSION="EFICAS v1.7"
class APPLI:
- def __init__ (self,master,code='ASTER',fichier=None,test=0) :
+ def __init__ (self,master,code=prefs.code,fichier=None,test=0) :
self.code=code
self.top=master
self.top.protocol("WM_DELETE_WINDOW",self.exitEFICAS)
liste = self.GetListeJDCaSauvegarder()
if liste != [] :
# Certains fichiers n'ont pas été sauvegardés ...
- if askyesno("Enregistrer modifications","Enregister les modifications ?") :
+ if askyesno("Enregistrer modifications","Enregistrer les modifications ?") :
test = self.saveall(liste)
if test != 1 :
return
#
__version__="$Name: $"
-__Id__="$Id: compomacro.py,v 1.15 2005/03/10 09:25:30 eficas Exp $"
+__Id__="$Id: compomacro.py,v 1.16 2005/04/13 14:59:31 eficas Exp $"
#
class MACROPanel(panels.OngletPanel):
("Edit","makeEdit"),
]
- def makeEdit(self,appli):
+ def __init__(self,appli, labeltext, object, setfunction):
+ MACROTreeItem.__init__(self,appli, labeltext, object, setfunction)
+ self.views=[]
+
+ def makeEdit(self,appli,node):
print "makeEdit",self.object,self.object.nom
- print self.object.jdc_aux,self.object.jdc_aux.nom
+ print "makeEdit",self.object.jdc_aux,self.object.jdc_aux.nom
+ self.parent_node=node
# 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)
+ self.myjdc=appli.bureau.JDCDisplay_courant
+ self.object.jdc_aux.subscribe(self)
+
+ def notify(self,obj):
+ print "notify",self,obj
+ self.parent_node.update_valid()
+ # Il faudrait redessiner l'arbre de maniere optimale
+ # et pas seulement l'updater
+ for display in self.views:
+ display.tree.update()
- def makeView(self,appli):
+ def makeView(self,appli,node):
nom=self.object.nom
if hasattr(self.object,'fichier_ini'):
if self.object.fichier_ini is None:
nom=nom+' '+"Fichier non défini"
else:
nom=nom+' '+self.object.fichier_ini
- macrodisplay.makeMacroDisplay(appli,self.object,nom)
+ macdisp=macrodisplay.makeMacroDisplay(appli,self.object,nom)
+ self.views.append(macdisp)
class INCLUDE_MATERIAUTreeItem(INCLUDETreeItem): pass
class POURSUITETreeItem(INCLUDETreeItem): pass
import splash
import session
-def lance_eficas(code,fichier=None):
+def lance_eficas(code=None,fichier=None):
"""
Lance l'appli EFICAS
"""
# Analyse des arguments de la ligne de commande
options=session.parse(sys.argv)
+ code=options.code
root = Tkinter.Tk()
splash.init_splash(root,code=code,titre="Lancement d'EFICAS pour %s" %code)
# On a une chaine avec & en tete => on cree un radiobouton
try:
command=getattr(node.item,method[1:])
- menu.add_radiobutton(label=label,command=lambda a=self.appli,c=command:c(a))
+ menu.add_radiobutton(label=label,command=lambda a=self.appli,c=command,n=node:c(a,n))
if radio == None:radio=number_item
except:pass
else:
try:
command=getattr(node.item,method)
- menu.add_command(label=label,command=lambda a=self.appli,c=command:c(a))
+ menu.add_command(label=label,command=lambda a=self.appli,c=command,n=node:c(a,n))
except:pass
# Si au moins un radiobouton existe on invoke le premier
if radio:menu.invoke(radio)
# On a une chaine avec & en tete => on cree un radiobouton
try:
command=getattr(node.item,method[1:])
- menu.add_radiobutton(label=label,command=lambda a=self.appli,c=command:c(a))
+ menu.add_radiobutton(label=label,command=lambda a=self.appli,c=command,n=node:c(a,n))
if radio == None:radio=number_item
except:pass
else:
try:
command=getattr(node.item,method)
- menu.add_command(label=label,command=lambda a=self.appli,c=command:c(a))
+ menu.add_command(label=label,command=lambda a=self.appli,c=command,n=node:c(a,n))
except:pass
# Si au moins un radiobouton existe on invoke le premier
if radio:menu.invoke(radio)
return jdc.get_groups()
def get_liste_cmd(self):
+ print "get_liste_cmd",self.node.item.object
jdc=self.node.item.object.get_jdc_root()
+ print jdc
listeCmd = jdc.get_liste_cmd()
return listeCmd
if catalogue[0] == self.code :
liste_cata_possibles.append(catalogue)
+ if len(liste_cata_possibles)==0:
+ showerror("Import du catalogue","Pas de catalogue defini pour le code %s" % self.code)
+ self.appli.quit()
+ sys.exit(1)
+
if self.version_code is not None:
# La version a ete fixee
for cata in liste_cata_possibles:
self.ask_choix_catalogue()
if self.fic_cata == None :
+ print "Pas de catalogue pour code %s, version %s" %(self.code,self.version_code)
sys.exit(0)
# détermination de fic_cata_c et fic_cata_p
# test si plusieurs catalogues ou non
if len(liste_choix) == 0:
showerror("Aucun catalogue déclaré pour %s" %self.code)
- self.quit()
+ self.appli.quit()
+ sys.exit(1)
elif len(liste_choix) == 1:
self.fic_cata = self.dico_catalogues[liste_choix[0]][2]
self.version_code = liste_choix[0]
import os,traceback
import ConfigParser
+import prefs
# Les valeurs decodees par optparse sont mises dans un objet dictionnaire-like.
# On l'utilise comme environnement de session.
parser.add_option("-j","--jdc",dest="comm",type='string',
action="callback",callback=check_comm,
help="nom du fichier de commandes")
+
parser.add_option("-p","--poursuite", type="string",dest="pours",
action="callback", callback=check_poursuite,
help="nom du fichier poursuite")
+
parser.add_option("-i","--include",
action="callback", callback=check_include,
nargs=2, help="numero d'unite suivi du nom du fichier include")
parser.add_option("-c","--cata", action="store", type="string",dest="cata",
help="version de catalogue a utiliser")
+ parser.add_option("-k","--kode", action="store", type="string",dest="code",
+ help="nom du code a utiliser",default=prefs.code)
+
parser.add_option("-d","--debug", action="store", type="int",dest="debug",
help="niveau de debug")
Met l'état de l'étape à : modifié
Propage la modification au parent
"""
- # Une action
- # doit etre realisée apres init_modif et la validite reevaluée
- # apres cette action. L'état modified de tous les objets doit etre
- # preservé.
+ # 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
+ # de tous les objets entre temps
+ print "init_modif",self,self.parent
self.state = 'modified'
if self.parent:
self.parent.init_modif()
déclencher d'éventuels traitements post-modification
ex : INCLUDE et POURSUITE
"""
+ print "fin_modif",self,self.parent
if self.isvalid() :
d=self.parent.get_contexte_apres(self)
if self.parent:
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"
else:
return 0,"Opérateur réentrant mais concept non existant"
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é"
else:
return 0,"Concept déjà existant et de mauvais type"
# Il suffit de changer son attribut nom pour le nommer
self.sd.nom = nom
self.sdnom=nom
+ self.fin_modif()
return 1,"Nommage du concept effectué"
except:
return 0,"Nommage impossible"+str(sys.exc_info()[1])
else:
self.sd.nom=nom
self.sdnom=nom
+ self.fin_modif()
return 1,"Nommage du concept effectué"
if self.isvalid() :
# Normalement l appel de isvalid a mis a jour le concept produit (son type)
else:
self.sd.nom=nom
self.sdnom=nom
+ self.fin_modif()
return 1,"Nommage du concept effectué"
else:
# Normalement on ne devrait pas passer ici
self.etapes.insert(pos,objet)
self.editmode=0
self.active_etapes()
+ self.fin_modif()
return objet
elif name == "PARAMETRE":
# ajout d'un parametre
self.editmode=0
self.reset_context()
self.active_etapes()
+ self.fin_modif()
return objet
elif name == "PARAMETRE_EVAL":
# ajout d'un parametre EVAL
self.editmode=0
self.reset_context()
self.active_etapes()
+ self.fin_modif()
return objet
elif type(name)==types.InstanceType:
# on est dans le cas où on veut ajouter une commande déjà
self.active_etapes()
self.editmode=0
self.reset_context()
+ print "addentite",self.etapes
+ self.fin_modif()
return objet
else :
# On veut ajouter une nouvelle commande
self.editmode=0
self.reset_context()
self.active_etapes()
+ print "addentite",self.etapes
+ self.fin_modif()
return e
except AsException,e:
self.reset_current_step()
Méthode appelée au moment où une modification va être faite afin de
déclencher d'éventuels traitements pré-modification
"""
+ print "init_modif",self
self.state = 'modified'
def fin_modif(self):
+ print "fin_modif",self
self.isvalid()
pass
ou leve une exception
--> utilisée par ops.POURSUITE et INCLUDE
"""
- #print "get_contexte_jdc"
+ 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)
j.analyse()
# On récupère les étapes internes (pour validation)
self.etapes=j.etapes
+ self.jdc_aux=j
+ print "get_contexte_jdc",id(self.etapes)
except:
traceback.print_exc()
# On force le contexte (etape courante) à self
Cette méthode sert à créer un contexte en interprétant un texte source
Python
"""
- #print "make_contexte_include"
+ 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
+ print "update_fichier_init",unite
self.fichier_err=None
self.old_contexte_fichier_init=self.contexte_fichier_init
+ old_fichier_ini=self.fichier_ini
+
+ print "update_fichier_init",self,self.parent,self.parent.recorded_units
- #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
+ # Nouvelle unite
f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
units={}
if f is not None:
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")
else:
- # Meme unite existante
+ # Unite existante
f,text,units=self.parent.recorded_units[unite]
self.fichier_ini = f
self.fichier_text=text
self.reevalue_sd_jdc()
return
+ if old_fichier_ini == self.fichier_ini:
+ # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
+ return
+
try:
self.make_contexte_include(self.fichier_ini,self.fichier_text)
# Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
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
+ 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
self.contexte_fichier_init={}
self.fichier_unite=unite
self.fichier_err=None
- import Extensions.jdc_include
+ try:
+ import Extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise
self.JdC_aux=Extensions.jdc_include.JdC_include
if f is None:
self.fichier_err=None
self.contexte_fichier_init={}
# On specifie la classe a utiliser pour le JDC auxiliaire
- import Extensions.jdc_include
+ try:
+ import Extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise
self.JdC_aux=Extensions.jdc_include.JdC_include
try:
self.make_contexte_include(self.fichier_ini ,self.fichier_text)
self.fichier_unite = None
self.fichier_text = text
self.fichier_err=None
- import Extensions.jdc_include
+ try:
+ import Extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise
self.JdC_aux=Extensions.jdc_include.JdC_poursuite
self.contexte_fichier_init={}