#
__version__="$Name: $"
-__Id__="$Id: cata_reduit.py,v 1.6 2004/09/20 09:24:11 eficas Exp $"
+__Id__="$Id: cata.py,v 1.1 2004/11/19 09:06:23 eficas Exp $"
#
JdC = JDC_CATA(code='ASTER',
execmodul=None,
VERIF=SIMP(statut='f',typ='TXM',max=2,into=("MAILLE","NOEUD")),
) ;
+GLOB_OPER=OPER(nom="GLOB_OPER",op=18,sd_prod=modele,docu="U4.41.01-g",
+ FORMAT =SIMP(statut='f',typ='TXM',position='global',
+ into=("TABLEAU","AGRAF","XMGRACE",),),
+ b_unit1 =BLOC(condition = "FORMAT == 'TABLEAU'",
+ TOTO1 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),),
+ ),
+ b_unit2 =BLOC(condition = "FORMAT == None",
+ TOTO2 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),),
+ ),
+ )
+
PLS_BASE_SIMPLE=OPER(nom="PLS_BASE_SIMPLE",op=19,sd_prod=cara_elem,
fr="Exemple de PLUSIEURS_BASE_Panel sans validator",
docu="U4.42.01-g",reentrant='n',
Ce module sert à lancer EFICAS configuré pour Code_Aster
"""
# Modules Python
-import sys
# Modules Eficas
import prefs
-if hasattr(prefs,'encoding'):
- # Hack pour changer le codage par defaut des strings
- import sys
- reload(sys)
- sys.setdefaultencoding(prefs.encoding)
- del sys.setdefaultencoding
- # Fin hack
-
-sys.path[:0]=[prefs.INSTALLDIR]
-
-import Editeur
from Editeur import eficas_go
eficas_go.lance_eficas()
execfile(userprefs)
except:
pass
+
+sys.path[:0]=[INSTALLDIR]
def __init__(self, appli, labeltext, object, setfunction=None):
self.labeltext = labeltext
self.appli = appli
+ # L'objet délegué est stocké dans l'attribut object
+ # L'objet associé à l'item est stocké dans l'attribut _object
+ # Il peut etre obtenu par appel à la méthode getObject
+ # Attention : le délégué peut etre différent de l'objet associé (MCLIST)
+ # Dans le cas d'une MCListe de longueur 1, l'objet associé est la MCListe
+ # et l'objet délégué est le MCFACT (object = _object.data[0])
Delegate.__init__(self,object)
# On cache l'objet initial (pour destruction eventuelle
# ultérieure)
self._object = object
self.setfunction = setfunction
self.expandable = 1
+ self.sublist=[]
self.init()
def init(self):
else:
return 1
+ def update(self,item):
+ """
+ Met a jour l'item courant a partir d'un autre item passe en argument
+ Ne fait rien par defaut
+ """
+ pass
+
def GetLabelText(self):
""" Retourne 3 valeurs :
- le texte à afficher dans le noeud représentant l'item
# l contient les anciens mots-clés + le nouveau dans l'ordre
return l.index(nom_fils)
+ def append_child(self,name,pos=None):
+ """
+ Permet d'ajouter un item fils à self
+ """
+ if pos == 'first':
+ index = 0
+ elif pos == 'last':
+ index = len(self.liste_mc_presents())
+ elif type(pos) == types.IntType :
+ # la position est fixée
+ index = pos
+ elif type(pos) == types.InstanceType:
+ # pos est un item. Il faut inserer name apres pos
+ index = self.get_index(pos) +1
+ elif type(name) == types.InstanceType:
+ index = self.get_index_child(name.nom)
+ else:
+ index = self.get_index_child(name)
+ return self.addobject(name,index)
+
+ def append_brother(self,name,pos='after'):
+ """
+ Permet d'ajouter un frère à self
+ par défaut on l'ajoute après self
+ """
+ index = self._object.parent.get_index(self.getObject())
+ if pos == 'before':
+ index = index
+ elif pos == 'after':
+ index = index +1
+ else:
+ print str(pos)," n'est pas un index valide pour append_brother"
+ return
+ return self.parent.addobject(name,index)
+
def get_nom_etape(self):
"""Retourne le nom de self """
return self.object.get_nom_etape()
return 0
def GetSubList(self):
+ isublist=iter(self.sublist)
+ liste=self._object.data
+ iliste=iter(liste)
+ self.sublist=[]
+
+ while(1):
+ old_obj=obj=None
+ for item in isublist:
+ old_obj=item.getObject()
+ if old_obj in liste:break
+
+ for obj in iliste:
+ if obj is old_obj:break
+ # nouvel objet : on cree un nouvel item
+ def setfunction(value, object=obj):
+ object=value
+ it = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ self.sublist.append(it)
+ if old_obj is None and obj is None:break
+ if old_obj is obj: self.sublist.append(item)
+ return self.sublist
+
+ def GetSubList_BAK(self):
sublist = []
for obj in self._object.data:
def setfunction(value, object=obj):
# Modules Eficas
import splash
import prefs
+import styles
+from styles import style
import fontes
import tooltip
import properties
root.option_add('*Listbox*Font',fontes.standard)
def initializeTk_colors_common(self, root):
- root.option_add('*background', 'grey')
- root.option_add('*foreground', 'black')
- root.option_add('*EntryField.Entry.background', 'white')
- root.option_add('*Entry*background', 'white')
- root.option_add('*Listbox*background', 'white')
- root.option_add('*Listbox*selectBackground', '#00008b')
- root.option_add('*Listbox*selectForeground', 'white')
+ root.option_add('*background', style.background)
+ root.option_add('*foreground', style.foreground)
+ root.option_add('*EntryField.Entry.background', style.entry_background)
+ root.option_add('*Entry*background', style.entry_background)
+ root.option_add('*Listbox*background', style.list_background)
+ root.option_add('*Listbox*selectBackground', style.list_select_background)
+ root.option_add('*Listbox*selectForeground', style.list_select_foreground)
def initializeTk_mac(self, root):
self.initializeTk_colors_common(root)
--- /dev/null
+class STYLE:
+ background='gray'
+ foreground='black'
+ entry_background='white'
+ list_background='white'
+ list_select_background='#00008b'
+ list_select_foreground='white'
+ tooltip_background="yellow"
+
+ standard = ("Times",10)
+ standard_italique = ("Times",10,'italic')
+ standard_gras = ("Times",10,'bold')
+ standard_gras_souligne = ("Times",10,'bold','underline')
+
+ canvas = ('times',8)
+ canvas_italique = ('times',8,'italic')
+ canvas_gras = ("Times",8,'bold')
+ canvas_gras_italique = ("Times",10,'bold','italic')
+
+ standard12 = ("Times",12)
+ standard12_gras = ("Times",12,'bold')
+ standard12_gras_italique = ( "times",12,'bold','italic')
+
+ standardcourier10 = ("Courier",10)
+
+style=STYLE()
if not hasattr(self,'JDC') : return
titre="rapport de validation du jeu de commandes courant"
cr = self.JDC.report()
- self.update_jdc_courant()
+ #self.update_jdc_courant()
elif mode == 'CATA':
from Noyau.N_CR import CR
cr = CR()
if format == 'homard':
self.jdc_homard=g.get_homard()
if not g.cr.estvide():
- print g.cr
self.appli.affiche_infos("Erreur à la generation")
showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
return
Lance la suppression du noeud courant
"""
if not self.JDCDisplay_courant : return
- try:
- if self.JDCDisplay_courant.modified == 'n' :
- self.JDCDisplay_courant.init_modif()
- pere = self.JDCDisplay_courant.node_selected.parent
- # Le noeud n'est pas au 1er niveau
- if pere.parent.parent != None:
- self.JDCDisplay_courant.node_selected.delete()
- pere.select()
- else:
- noeudselecte = self.JDCDisplay_courant.node_selected
- parent = noeudselecte.parent
- enfants = parent.children
- index = enfants.index(noeudselecte)
- self.JDCDisplay_courant.node_selected.delete()
- try:
- enfants[index].select()
- except :
- enfants[index-1].select()
- except AttributeError:
- pass
+ if self.JDCDisplay_courant.modified == 'n' :
+ self.JDCDisplay_courant.init_modif()
+ self.JDCDisplay_courant.node_selected.delete()
def visuJDC_py(self,event=None):
"""
g=generator.plugins[format]()
jdc_formate=g.gener(self.JDC,format='beautifie')
if not g.cr.estvide():
- print g.cr
self.appli.affiche_infos("Erreur à la generation")
showerror("Erreur à la generation","EFICAS ne sait pas convertir ce JDC")
return
#
#
# ======================================================================
+import traceback
from Tkinter import *
import Pmw
import string
Réalise la décommentarisation de self
"""
try:
+ pos=self.node.parent.children.index(self.node)
commande,nom = self.node.item.uncomment()
+ self.node.parent.children[pos].select()
except Exception,e:
showerror("Erreur !",str(e))
return
- self.parent.appli.bureau.JDCDisplay_courant.ReplaceObjectNode(self.node,commande,nom)
+ #self.parent.appli.bureau.JDCDisplay_courant.ReplaceObjectNode(self.node,commande,nom)
class COMMANDE_COMMTreeItem(Objecttreeitem.ObjectTreeItem):
panel = COMMANDE_COMMPanel
try:
commande,nom = self.object.uncomment()
except Exception,e:
+ traceback.print_exc()
raise e
return commande,nom
return keys
def GetSubList(self):
- sublist=[]
- for obj in self.object.mc_liste:
- def setfunction(value, object=obj):
- object.setval(value)
- item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
- sublist.append(item)
- return sublist
+ """
+ Reactualise la liste des items fils stockes dans self.sublist
+ """
+ liste=self.object.mc_liste
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setfunction(value, object=obj):
+ object.setval(value)
+ item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ sublist[pos]=item
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
def additem(self,name,pos):
- if isinstance(name,Objecttreeitem.ObjectTreeItem) :
- objet = self.object.addentite(name.getObject(),pos)
- else :
- objet = self.object.addentite(name,pos)
- self.expandable = 1
- if objet == 0 :
- # on ne peut ajouter l'élément de nom name
- return 0
- def setfunction(value, object=objet):
- object.setval(value)
- item = self.make_objecttreeitem(self.appli,objet.nom + " : ", objet, setfunction)
- return item
+ #print "compofact.additem",name,pos
+ objet = self.object.addentite(name,pos)
+ return objet
def suppitem(self,item) :
"""
self.appli.affiche_infos('Pb interne : impossible de supprimer ce mot-clé')
return 0
- def verif_condition_bloc(self):
+ def GetSubList_BAK(self):
+ sublist=[]
+ for obj in self.object.mc_liste:
+ def setfunction(value, object=obj):
+ object.setval(value)
+ item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ sublist.append(item)
+ return sublist
+
+ def additem_BAK(self,name,pos):
+ if isinstance(name,Objecttreeitem.ObjectTreeItem) :
+ objet = self.object.addentite(name.getObject(),pos)
+ else :
+ objet = self.object.addentite(name,pos)
+ self.expandable = 1
+ if objet == 0 :
+ # on ne peut ajouter l'élément de nom name
+ return 0
+ def setfunction(value, object=objet):
+ object.setval(value)
+ item = self.make_objecttreeitem(self.appli,objet.nom + " : ", objet, setfunction)
+ return item
+
+ def verif_condition_bloc_BAK(self):
return self.object.verif_condition_bloc()
import Accas
import treewidget
class Node(treewidget.Node):
def verif_all_children(self):
+ raise "OBSOLETE"
if not self.children : self.build_children()
for child in self.children :
child.verif_all_children()
def replace_enfant(self,item):
""" Retourne le noeud fils à éventuellement remplacer """
+ raise "OBSOLETE"
return None
def doPaste_Commande(self,objet_a_copier):
Réalise la copie de l'objet passé en argument qui est nécessairement
une commande
"""
+ #child = self.item.append_child(objet_a_copier,pos='first')
child = self.append_child(objet_a_copier,pos='first',retour='oui')
+ #if child is None : return 0
return child
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
+ cmd = self._object.addentite(name,pos)
+ return cmd
def suppitem(self,item) :
# item = item de l'ETAPE à supprimer du JDC
return 0
def GetSubList(self):
- sublist=[]
+ """
+ Retourne la liste des items fils de l'item jdc.
+ Cette liste est conservee et mise a jour a chaque appel
+ """
if self.object.etapes_niveaux != []:
liste = self.object.etapes_niveaux
else:
liste = self.object.etapes
- key=0
- for value in liste:
- def setfunction(value, key=key, object=liste):
- object[key] = value
- item = self.make_objecttreeitem(self.appli,value.ident() + " : ", value, setfunction)
- sublist.append(item)
- key=key+1
- return sublist
-
- def verif_condition_bloc(self):
- # retourne la liste des sous-items dont la condition est valide
- # sans objet pour le JDC
- return [],[]
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj)
+ sublist[pos]=item
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
def get_l_noms_etapes(self):
""" 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
+ #print "get_liste_cmd",self.object.niveau.definition
listeCmd = self.object.niveau.definition.get_liste_cmd()
return listeCmd
+ def additem_BAK(self,name,pos):
+ cmd=self.addentite(name,pos)
+ item = self.make_objecttreeitem(self.appli,cmd.nom + " : ", cmd)
+ return item
+
+ def verif_condition_bloc_BAK(self):
+ # retourne la liste des sous-items dont la condition est valide
+ # sans objet pour le JDC
+ return [],[]
+
import Accas
treeitem =JDCTreeItem
#
__version__="$Name: $"
-__Id__="$Id: compomacro.py,v 1.17 2005/04/18 10:20:36 eficas Exp $"
+__Id__="$Id: compomacro.py,v 1.18 2005/04/18 14:21:08 eficas Exp $"
#
class MACROPanel(panels.OngletPanel):
"""
Effectue le changement de fichier d'initialisation s'il est valide
"""
- if not hasattr(self.node.item.object,'fichier_ini'):
- self.node.item.object.fichier_ini=None
- self.node.item.object.fichier_text=None
- self.node.item.object.fichier_err="Le fichier n'est pas defini"
- self.node.item.object.contexte_fichier_init={}
- self.node.item.object.recorded_units={}
- self.node.item.object.fichier_unite="PasDefini"
- import Extensions.jdc_include
- self.node.item.object.JdC_aux=Extensions.jdc_include.JdC_include
-
- old_fic = self.node.item.object.fichier_ini
- old_text = self.node.item.object.fichier_text
- old_err = self.node.item.object.fichier_err
- old_context=self.node.item.object.contexte_fichier_init
- old_units=self.node.item.object.recorded_units
- old_etapes=self.node.item.object.etapes
-
new_fic = self.entry.get()
if not os.path.isfile(new_fic) :
showinfo("Fichier introuvable","Le fichier que vous avez saisi\n"+
# Si probleme a la lecture-conversion on arrete le traitement
if not text:
return
- #self.node.item.object.recorded_units={}
try:
- self.node.item.object.make_contexte_include(new_fic,text)
+ self.node.item.object.change_fichier_init(new_fic,text)
+ self.parent.appli.affiche_infos("Fichier %s modifié" %self.node.item.get_nom())
except:
# Erreurs lors de l'evaluation de text dans un JDC auxiliaire
self.parent.appli.affiche_infos("Fichier invalide")
if reponse:
# On retablit l'ancien fichier
self.entry.delete(0,Tkinter.END)
- self.node.item.object.fichier_ini=old_fic
- self.node.item.object.fichier_text=old_text
- self.node.item.object.fichier_err=old_err
- self.node.item.object.contexte_fichier_init=old_context
- self.node.item.object.recorded_units=old_units
- self.node.item.object.etapes=old_etapes
+ self.node.item.object.restore_fichier_init()
self.parent.appli.affiche_infos("Fichier invalide ... Ancien fichier restauré")
- if old_fic:
- self.entry.insert(0,self.node.item.object.fichier_ini)
+ fic=self.node.item.object.fichier_ini
+ if fic:
+ self.entry.insert(0,fic)
else:
- # 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)
- self.node.item.object.init_modif()
- self.node.item.object.fichier_ini=new_fic
- self.node.item.object.fichier_text=text
- self.node.item.object.fichier_err=string.join(l)
- # On enregistre la modification de fichier
- self.node.item.object.record_unite()
- #self.node.item.object.etapes=[]
- self.node.item.object.g_context={}
- # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
- self.node.item.object.parent.reset_context()
-
- self.node.item.object.old_contexte_fichier_init=old_context
- self.node.item.object.contexte_fichier_init={}
- self.node.item.object.reevalue_sd_jdc()
-
- self.node.item.object.fin_modif()
+ self.node.item.object.force_fichier_init()
self.parent.appli.affiche_infos("Fichier invalide ... Nouveau fichier mémorisé")
- self.node.update()
- return
-
- # L'evaluation de text dans un JDC auxiliaire s'est bien passé
- # on peut poursuivre le traitement
- self.node.item.object.init_modif()
- self.node.item.object.state="undetermined"
- self.node.item.object.fichier_ini = new_fic
- self.node.item.object.fichier_text=text
- self.node.item.object.fichier_err=None
- # On enregistre la modification de fichier
- self.node.item.object.record_unite()
- # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
- self.node.item.object.parent.reset_context()
-
- # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
- self.node.item.object.old_contexte_fichier_init=old_context
- self.node.item.object.reevalue_sd_jdc()
-
- self.node.item.object.fin_modif()
- self.parent.appli.affiche_infos("Fichier %s modifié" %self.node.item.get_nom())
- self.node.update()
def annule_fichier_init(self,event=None):
""" Restaure dans self.entry le nom de fichier_init"""
def __init__(self,appli, labeltext, object, setfunction):
MACROTreeItem.__init__(self,appli, labeltext, object, setfunction)
- self.views=[]
+
+ def iscopiable(self):
+ """
+ Retourne 1 si l'objet est copiable, 0 sinon
+ """
+ return 0
def makeEdit(self,appli,node):
- print "makeEdit",self.object,self.object.nom
- print "makeEdit",self.object.jdc_aux,self.object.jdc_aux.nom
+ #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
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()
+ self.myjdc.fichier=self.object.fichier_ini
def makeView(self,appli,node):
nom=self.object.nom
else:
nom=nom+' '+self.object.fichier_ini
macdisp=macrodisplay.makeMacroDisplay(appli,self,nom)
- self.views.append(macdisp)
-class INCLUDE_MATERIAUTreeItem(INCLUDETreeItem): pass
class POURSUITETreeItem(INCLUDETreeItem): pass
+class INCLUDE_MATERIAUTreeItem(INCLUDETreeItem):
+ rmenu_specs=[("View","makeView"),
+ ]
+ def iscopiable(self):
+ """
+ Retourne 1 si l'objet est copiable, 0 sinon
+ """
+ return 1
+
+
def treeitem(appli, labeltext, object, setfunction=None):
""" Factory qui retourne l'item adapté au type de macro :
INCLUDE, POURSUITE, MACRO
import Pmw
import Objecttreeitem
import panels
+import traceback
class MCLISTPanel(panels.Panel):
def init(self):
self.label = Label(self,text = texte)
self.label.place(relx=0.5,rely=0.4,anchor='center')
if test_ajout:
- Button(self,text="AJOUTER",command=self.ajout_occurrence).place(relx=0.5,rely=0.6,anchor='center')
+ self.but=Button(self,text="AJOUTER",command=self.ajout_occurrence)
+ self.but.place(relx=0.5,rely=0.6,anchor='center')
#Button(self,text="NON",command=None).place(relx=0.6,rely=0.6,anchor='center')
def ajout_occurrence(self,event=None):
self.node.parent.append_child(self.node.item.get_nom())
-
import compofact
import treewidget
class Node(treewidget.Node):
def doPaste(self,node_selected):
objet_a_copier = self.item.get_copie_objet()
child=node_selected.doPaste_MCF(objet_a_copier)
+ #print "doPaste",child
return child
def doPaste_MCF(self,objet_a_copier):
if self.item.isMCList() :
# le noeud courant est une MCList
- child = self.parent.append_child(objet_a_copier,pos='first',retour='oui')
- elif self.item.isMCFact():
+ child = self.append_child(objet_a_copier,pos='first',retour='oui')
+ #child = self.parent.append_child(objet_a_copier,pos='first',retour='oui')
+ elif self.item.isMCFact() :
# le noeud courant est un MCFACT
if self.parent.item.isMCList():
# le noeud selectionne est un MCFACT dans une MCList
"Vous ne pouvez coller le mot-clé facteur copié à ce niveau de l'arborescence !")
self.appli.affiche_infos("Copie refusée")
child=None
+ #print "doPaste_MCF",child
return child
def replace_enfant(self,item):
""" Retourne le noeud fils à éventuellement remplacer """
+ raise "OBSOLETE"
if self.item.isMCList():return None
return self.get_node_fils(item.get_nom())
def verif_condition(self):
+ raise "OBSOLETE"
if self.item.isMCList():
self.children[-1].verif_condition()
else:
""" Dans le cas d'une MCList il faut vérifier qu'elle n'est pas vide
ou réduite à un seul élément suite à une destruction
"""
+ raise "OBSOLETE"
# self représente une MCList
if len(self.item) == 0 :
# la liste est vide : il faut la supprimer
Supprime child des enfants de self, tous les id associés
ET l'objet associé
"""
+ raise "OBSOLETE"
if self.item.isMCList():
if self.item.suppitem(child.item):
self.delete_node_child(child)
def GetSubList(self):
self.updateDelegate()
- if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.GetSubList(self)
- else:
+ if len(self._object) <= 1:
+ self._object.data[0].alt_parent=self._object
return compofact.FACTTreeItem.GetSubList(self)
+ liste=self._object.data
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setfunction(value, object=obj):
+ object=value
+ item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ sublist[pos]=item
+ #Attention : on ajoute une information supplementaire pour l'actualisation de
+ # la validite. L'attribut parent d'un MCFACT pointe sur le parent de la MCLISTE
+ # et pas sur la MCLISTE elle meme ce qui rompt la chaine de remontee des
+ # informations de validite. alt_parent permet de remedier a ce defaut.
+ obj.alt_parent=self._object
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
+
def GetIconName(self):
if self._object.isvalid():
return "ast-green-los"
"""
return len(self._object) > 1
+ def get_copie_objet(self):
+ return self._object.data[0].copy()
+
def additem(self,obj,pos):
- """
- Ajoute un objet MCFACT à la MCList (self.object) à la position pos
- """
+ #print "compomclist.additem",obj,pos
if len(self._object) <= 1:
- return compofact.FACTTreeItem.additem(self,obj,pos)
-
- if type(obj)==types.StringType :
- # on est en mode création d'un motcle
- raise "traitement non prevu"
-
- if not self._object.ajout_possible():
- return None
-
- if self._object.nom != obj.nom:
- return None
+ return compofact.FACTTreeItem.additem(self,obj,pos)
- self.object.init_modif()
- obj.verif_existence_sd()
- obj.reparent(self.object.parent)
- self.object.insert(pos,obj)
- self.object.fin_modif()
-
- item = self.make_objecttreeitem(self.appli, obj.nom + ":", obj)
- return item
+ o= self.object.addentite(obj,pos)
+ return o
def suppitem(self,item):
"""
Retire un objet MCFACT de la MCList (self.object)
"""
+ #print "compomclist.suppitem",item
obj=item.getObject()
if len(self._object) <= 1:
return compofact.FACTTreeItem.suppitem(self,item)
- self.object.init_modif()
- self.object.remove(obj)
- if len(self._object) == 1:
- self.updateDelegate()
- message = "Mot-clé " + obj.nom + " supprimé"
- self.appli.affiche_infos(message)
- return 1
+ if self.object.suppentite(obj):
+ if len(self._object) == 1: self.updateDelegate()
+ message = "Mot-clé " + obj.nom + " supprimé"
+ self.appli.affiche_infos(message)
+ return 1
+ else:
+ self.appli.affiche_infos('Impossible de supprimer ce mot-clé')
+ return 0
+
import Accas
objet = Accas.MCList
import treewidget
class Node(treewidget.Node):
- def verif_condition(self):
+ def verif_condition_BAK(self):
"""
on lance la vérification des conditions de chaque bloc de self
on crée ou supprime les noeuds concernés
"""
return 0
- def replace_enfant(self,item):
+ def replace_enfant_BAK(self,item):
""" Retourne le noeud fils à éventuellement remplacer """
return None
def isactif(self):
return self.object.isactif()
- def IsExpandable_old(self):
- return self.object.isactif()
-
def IsExpandable(self):
return 1
#
__version__="$Name: $"
-__Id__="$Id: componuplet.py,v 1.4 2003/10/16 14:31:22 eficas Exp $"
+__Id__="$Id: componuplet.py,v 1.5 2004/09/10 15:51:49 eficas Exp $"
#
myrepr = Repr()
#obj.set_valeur(val,evaluation='non')
obj.set_valeur(val)
self.parent.appli.affiche_infos(mess)
- self.node.parent.verif()
- self.node.update()
+ #self.node.parent.verif()
+ #self.node.update()
def valid_valeur(self,e,obj=None,mess='Valeur du mot-cl\351 enregistr\351e'):
"""
e.widget.delete(0,Tkinter.END)
e.widget.insert(0,anc_val)
- self.node.parent.verif()
- self.node.update()
+ #self.node.parent.verif()
+ #self.node.update()
def gen_aide(self,obj):
return ""
raise "NUPLET"
def verif_condition_bloc(self):
+ raise "OBSOLETE"
return self.object.verif_condition_bloc()
import Accas
Réalise la copie de l'objet passé en argument qui est nécessairement
une commande
"""
+ parent=self.parent
+ #child = parent.item.append_child(objet_a_copier,self.item.getObject())
child = self.append_brother(objet_a_copier,retour='oui')
+ #if child is None:return 0
return child
def doPaste_MCF(self,objet_a_copier):
return ""
def additem(self,name,pos):
- if isinstance(name,Objecttreeitem.ObjectTreeItem) :
- mcent = self.object.addentite(name.getObject(),pos)
- else :
- mcent = self.object.addentite(name,pos)
- self.expandable=1
- if mcent == 0 :
- # on ne peut ajouter l'élément de nom name
- return 0
- def setfunction(value, object=mcent):
- object.setval(value)
- item = self.make_objecttreeitem(self.appli,mcent.nom + " : ", mcent, setfunction)
- return item
+ #print "compooper.additem",name,pos
+ mcent = self._object.addentite(name,pos)
+ return mcent
def suppitem(self,item) :
# item : item du MOCLE de l'ETAPE à supprimer
return keys
def GetSubList(self):
+ """
+ Reactualise la liste des items fils stockes dans self.sublist
+ """
+ if self.isactif():
+ liste=self.object.mc_liste
+ else:
+ liste=[]
+
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setfunction(value, object=obj):
+ object.setval(value)
+ item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ sublist[pos]=item
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
+
+ def GetSubList_BAK(self):
+ if self.isactif():
+ liste=self.object.mc_liste
+ else:
+ liste=[]
+
sublist=[]
- for obj in self.object.mc_liste:
- def setfunction(value, object=obj):
- object.setval(value)
- item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
- sublist.append(item)
- return sublist
+ isublist=iter(self.sublist)
+ iliste=iter(liste)
+
+ while(1):
+ old_obj=obj=None
+ for item in isublist:
+ old_obj=item.getObject()
+ if old_obj in liste:break
+
+ for obj in iliste:
+ if obj is old_obj:break
+ # nouvel objet : on cree un nouvel item
+ def setfunction(value, object=obj):
+ object.setval(value)
+ it = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ sublist.append(it)
+
+ if old_obj is None and obj is None:break
+ if old_obj is obj:
+ sublist.append(item)
+
+ self.sublist=sublist
+ return self.sublist
def isvalid(self):
return self.object.isvalid()
"""
return 1
- def verif_condition_bloc(self):
- return self.object.verif_condition_bloc()
+ def update(self,item):
+ if item.sd and item.sd.nom:
+ self.nomme_sd(item.sd.nom)
def nomme_sd(self,nom):
""" Lance la méthode de nommage de la SD """
parent=self.object.parent)
commande_comment.niveau = self.object.niveau
commande_comment.jdc = commande_comment.parent = self.object.jdc
+
+ pos=self.object.parent.etapes.index(self.object)
+ self.object.parent.suppentite(self.object)
+ self.object.parent.addentite(commande_comment,pos)
+
return commande_comment
+ def additem_BAK(self,name,pos):
+ mcent=self.addentite(name,pos)
+
+ self.expandable=1
+ if mcent == 0 :
+ # on ne peut ajouter l'élément de nom name
+ return 0
+ def setfunction(value, object=mcent):
+ object.setval(value)
+ item = self.make_objecttreeitem(self.appli,mcent.nom + " : ", mcent, setfunction)
+ return item
+
+ def GetSubList_BAK(self):
+ sublist=[]
+ for obj in self.object.mc_liste:
+ def setfunction(value, object=obj):
+ object.setval(value)
+ item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ sublist.append(item)
+ return sublist
+
+ def verif_condition_bloc_BAK(self):
+ return self.object.verif_condition_bloc()
+
def replace_child(self,old_item,new_item):
"""
Remplace old_item.getObject() par new_item.getObject() dans
les fils de self.object
"""
+ raise "OBSOLETE"
old_itemobject=old_item.getObject()
index = self.object.mc_liste.index(old_itemobject)
self.object.init_modif()
return valide
def valide_liste_partielle(self,item,listecourante):
+ valeur=listecourante
+ valeur.append(item)
+ valeur = tuple(valeur)
+ return self.object.valid_valeur_partielle(valeur)
+
+ def valide_liste_partielle_BAK(self,item,listecourante):
valeuravant=self.object.valeur
valeur=listecourante
valeur.append(item)
return validite
def valide_liste_complete (self,valeur):
+ return self.object.valid_valeur(valeur)
+
+ def valide_liste_complete_BAK (self,valeur):
valeuravant=self.object.valeur
retour=self.object.set_valeur(valeur)
validite=0
def isvalid(self):
valide=self.object.isvalid()
- return self.object.isvalid()
+ return valide
#--------------------------------------------------
#
"""
Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
"""
- return self.object.set_valeur_co(nom_co)
+ ret = self.object.set_valeur_co(nom_co)
+ #print "set_valeur_co",ret
+ return ret
def get_sd_avant_du_bon_type(self):
"""
le MCS pointé par self et du type requis par ce MCS
"""
a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
- return self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,
- self.object.definition.type)
+ return a
#def verif(self):
# pass
selon le type de l objet attendu
- traite les reels et les parametres
"""
+ #print "eval_valeur_item",valeur
if valeur==None or valeur == "" :
return None,0
validite=1
valeurretour,validite = valeur,1
else :
valeurretour,validite= self.object.eval_valeur(valeur)
+ #print "eval_valeur_item",valeurretour,validite
+
if validite == 0:
if type(valeur) == types.StringType and self.object.wait_TXM():
essai_valeur="'" + valeur + "'"
valeurretour,validite= self.object.eval_valeur(essai_valeur)
+
if hasattr(valeurretour,'__class__'):
#if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
if valeurretour.__class__.__name__ in ('PARAMETRE',):
validite=1
- if self.wait_co():
- try:
- valeurretour=Accas.CO(valeur)
- except:
- valeurretour=None
- validite=0
+
+ #if self.wait_co():
+ # CCAR : il ne faut pas essayer de creer un concept
+ # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
+ #try:
+ #valeurretour=Accas.CO(valeur)
+ #except:
+ #valeurretour=None
+ #validite=0
# on est dans le cas où on a évalué et où on n'aurait pas du
if self.object.wait_TXM() :
if type(valeurretour) != types.StringType:
# ======================================================================
"""
Ce module permet de lancer l'application EFICAS en affichant
- un ecran Splash pour faire patentier l'utilisateur
+ un ecran Splash pour faire patienter l'utilisateur
"""
# Modules Python
import sys
import Tkinter
# Modules Eficas
+import prefs
+if hasattr(prefs,'encoding'):
+ # Hack pour changer le codage par defaut des strings
+ import sys
+ reload(sys)
+ sys.setdefaultencoding(prefs.encoding)
+ del sys.setdefaultencoding
+ # Fin hack
+
+import styles
import import_code
import splash
import session
"""
# Modules Python
import types
+import traceback
import Tkinter
import Pmw
"""
if node is not self.node_selected :
self.create_panel(node)
- # on conserve la trace du noeud sélectionné et de celui d'avant
- if self.node_selected :
- self.ancien_node = self.node_selected
- self.node_selected = node
- else:
- self.ancien_node = self.node_selected = node
+ self.node_selected = node
+ ## on conserve la trace du noeud sélectionné et de celui d'avant
+ #if self.node_selected :
+ #self.ancien_node = self.node_selected
+ #self.node_selected = node
+ #else:
+ #self.ancien_node = self.node_selected = node
def create_panel(self,node):
"""
z.show_stats()
z.show_cycles()
+ if node is None:
+ self.panel_courant=None
+ return self.panel_courant
if node.item.isactif():
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)
else:
self.init_modif()
node.delete()
- if nom_sd:
- child.item.nomme_sd(nom_sd)
- child.update()
+ #if nom_sd:
+ #child.item.nomme_sd(nom_sd)
+ child.select()
+ #child.update()
def doCut(self):
"""
try:
child=self.appli.noeud_a_editer.doPaste(self.node_selected)
except:
+ traceback.print_exc()
showinfo("Action de coller impossible",
"L'action de coller apres un tel objet n'est pas permise")
return
showerror("Copie refusée",self.appli.message)
self.appli.message = ''
self.appli.affiche_infos("Copie refusée")
+ return
# il faut déclarer le JDCDisplay_courant modifié
self.init_modif()
# suppression éventuelle du noeud sélectionné
# si possible on renomme l objet comme le noeud couper
if self.edit == "couper":
- try :
- nom = self.appli.noeud_a_editer.item.object.sd.nom
- self.appli.noeud_a_editer.delete()
- test,mess = child.item.nomme_sd(nom)
- child.verif()
- child.racine.update()
- except :
- self.appli.noeud_a_editer.delete()
+ #nom = self.appli.noeud_a_editer.item.object.sd.nom
+ item=self.appli.noeud_a_editer.item
+ self.appli.noeud_a_editer.delete()
+ child.item.update(item)
+ #test,mess = child.item.nomme_sd(nom)
+ child.select()
# on rend la copie à nouveau possible en libérant le flag edit
self.edit="copier"
import treewidget
from widgets import Fenetre
-#class MACRO2TreeItem(Objecttreeitem.ObjectTreeItem):
class MACRO2TreeItem(compojdc.JDCTreeItem):
- def IsExpandable(self):
- return 1
-
- def GetText(self):
- return " "
-
- def GetIconName(self):
- if self.object.isvalid():
- return "ast-green-square"
- else:
- return "ast-red-square"
-
- def keys(self):
- return range(len(self.object.etapes))
-
- def GetSubList(self):
- sublist=[]
- for key in self.keys():
- liste = self.object.etapes
- try:
- value = liste[key]
- except KeyError:
- continue
- def setfunction(value, key=key, object=liste):
- object[key] = value
- item = self.make_objecttreeitem(self.appli,value.ident() + " : ", value, setfunction)
- sublist.append(item)
- return sublist
-
- def verif_condition_bloc(self):
- # retourne la liste des sous-items dont la condition est valide
- # sans objet pour le JDC
- return [],[]
-
- def get_l_noms_etapes(self):
- """ Retourne la liste des noms des étapes de self.object"""
- return self.object.get_l_noms_etapes()
+ pass
class MacroDisplay:
def __init__(self,appli,macroitem,nom_jdc):
class TREEITEMINCANVAS:
def __init__(self,object,nom="",parent=None,appli=None,sel=None,rmenu=None):
- print "TREEITEMINCANVAS",object
+ #print "TREEITEMINCANVAS",object
self.object=object
self.nom=nom
self.appli=appli
class MACRODISPLAY(jdcdisplay.JDCDISPLAY):
def __init__(self,jdc,nom_jdc,appli=None,parent=None):
- print "MACRODISPLAY",jdc
+ #print "MACRODISPLAY",jdc
self.jdc=jdc
self.nom_jdc=nom_jdc
self.fichier=None
if self.parent.modified == 'n' : self.parent.init_modif()
self.node.item.set_valeur(name)
self.parent.appli.affiche_infos(mess)
- 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()
+ #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()
def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
"""
if validite :
self.node.item.set_valeur(valeur)
self.parent.appli.affiche_infos(mess)
- 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()
- if self.node.item.isvalid():
- self.node.parent.select()
+ #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()
+ #if self.node.item.isvalid():
+ # self.node.parent.select()
else :
self.parent.appli.affiche_infos(commentaire)
from Tkinter import *
import Pmw
import time
+import traceback
import widgets
from widgets import ListeChoix
self.creer_boutons()
self.init()
+ def __del__(self):
+ """ appele a la destruction du panel """
+ #print "PANEL DETRUIT"
+
def destroy(self):
Frame.destroy(self)
self.panneau=None
if name == SEPARATEUR:return
if self.parent.modified == 'n' : self.parent.init_modif()
if name != "COMMENTAIRE":
+ #parent=self.node.parent
+ #new_obj = parent.item.append_child(name,self.node.item.getObject())
+ #parent.children[parent.children.index(self.node)+1].select()
new_node = self.node.append_brother(name,'after')
else :
new_node = self.ajout_commentaire()
if name == SEPARATEUR:return
if self.parent.modified == 'n' : self.parent.init_modif()
if name != "COMMENTAIRE":
+ #new_obj = self.node.item.append_child(name,'first')
+ #self.node.children[0].select()
new_node = self.node.append_child(name,'first')
else :
new_node = self.ajout_commentaire_first()
def deselectMC(self,name):
self.parent.appli.affiche_infos('')
- def get_liste_cmd_old(self):
+ def get_liste_cmd_BAK(self):
listeCmd = self.cata.listCmd()
return listeCmd
return jdc.get_groups()
def get_liste_cmd(self):
- print "get_liste_cmd",self.node.item.object
+ #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 nom == '' : return # si pas de nom, on ressort sans rien faire ...
if self.parent.modified == 'n' : self.parent.init_modif()
test,mess = self.node.item.nomme_sd(nom)
- self.node.verif()
- self.node.racine.update()
+ #self.node.verif()
+ #self.node.racine.update()
self.parent.appli.affiche_infos(mess)
def changed(self):
# On traite par une exception le cas où l'utilisateur final cherche à désactiver
# (commentariser) un commentaire.
try :
+ pos=self.node.parent.children.index(self.node)
commande_comment = self.node.item.get_objet_commentarise()
- self.parent.appli.bureau.JDCDisplay_courant.ReplaceObjectNode(self.node,commande_comment,None)
+ 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))
return
--- /dev/null
+import os
+import prefs
+import basestyle
+from basestyle import STYLE,style
+
+inistylefile=os.path.join(prefs.REPINI,"style.py")
+if os.path.isfile(inistylefile):
+ execfile(inistylefile)
+
+userstylefile=os.path.expanduser("~/Eficas_install/style.py")
+if os.path.isfile(userstylefile):
+ execfile(userstylefile)
+
+import fontes
+for attr in dir(style):
+ if attr[0]=='_':continue
+ if not hasattr(fontes,attr):continue
+ setattr(fontes,attr,getattr(style,attr))
import fontes
import images
+from Ihm import CONNECTOR
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.19 2005/02/25 11:38:03 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.20 2005/04/13 14:59:31 eficas Exp $"
#
Fonte_Standard = fontes.standard
self.node_selected.select_previous()
def full_creation(self,name,index):
+ raise "OBSOLETE"
# A changer lorsqu'il y aura plusieurs jdc ouverts en même temps
self.children[0].full_creation(name,index)
def verif_all(self):
+ raise "OBSOLETE"
+ traceback.print_stack()
for child in self.children :
self.verif_all_children()
def __init__(self,parent,item,command=None,rmenu=None):
self.parent = parent
self.item = item
+ self.connections=[]
+ self.connect()
+
self.command = command
self.rmenu=rmenu
self.tree = self.parent.tree
self.lasty = 0
self.children = None
self.id = []
+ if self.parent is self.tree:
+ self.racine=self
+ else:
+ self.racine = self.parent.racine
+
# etape = noeud d'étape auquel appartient self
# = self si c'est lui-même
- if isinstance(self.parent,Tree) :
+ #if isinstance(self.parent,Tree) :
# on est sur un noeud de JDC
- self.racine=self
- self.etape=None
- self.nature='JDC'
- elif isinstance(self.parent.parent,Tree) :
+ #self.etape=None
+ #elif isinstance(self.parent.parent,Tree) :
# on est sur un noeud d'étape
- self.racine = self.parent
- self.etape=self
- self.nature = 'ETAPE'
- else :
+ #self.etape=self
+ #else :
# on est sur un noeud de mot-clé
- self.racine = self.parent.racine
- self.etape=self.parent.etape
- self.nature = 'MOTCLE'
+ #self.etape=self.parent.etape
+
+ def reconnect(self):
+ self.disconnect()
+ self.connect()
+
+ def connect(self):
+ self.connections.append(self.item._object)
+ CONNECTOR.Connect(self.item._object,"add",self.onAdd,())
+ CONNECTOR.Connect(self.item._object,"supp",self.onSupp,())
+ CONNECTOR.Connect(self.item._object,"valid",self.onValid,())
+ if self.item.object is not self.item._object:
+ CONNECTOR.Connect(self.item.object,"add",self.onAdd,())
+ CONNECTOR.Connect(self.item.object,"supp",self.onSupp,())
+ CONNECTOR.Connect(self.item.object,"valid",self.onValid,())
+ self.connections.append(self.item.object)
+
+ def disconnect(self):
+ for c in self.connections:
+ CONNECTOR.Disconnect(c,"add",self.onAdd,())
+ CONNECTOR.Disconnect(c,"supp",self.onSupp,())
+ CONNECTOR.Disconnect(c,"valid",self.onValid,())
+ self.connections=[]
+
+ def __del__(self):
+ """ appele a la destruction du noeud """
+ #print "NOEUD DETRUIT",self,self.item.GetLabelText()[0]
+
+ def force_select(self):
+ if self.selected:
+ # le noeud est selectionné. On force la reconstruction du panel associé
+ if self.command:apply(self.command,(None,))
+ self.select()
+
+ def onValid(self):
+ #print "onValid : l'item a changé de validité ",self.item,self.item.object,self.item.object.isvalid()
+ self.update_node_valid()
+ self.update_label_texte()
+ self.update_texte()
+
+ def onAdd(self,objet):
+ #print "onAdd : un objet a été ajouté aux fils de l'item ",self.item.object,objet
+ self.expand_node()
+ old_nodes=self.children
+ self.update_nodes()
+ #print "onAdd:nodes",self.children
+ self.redraw_children(old_nodes)
+ self.force_select()
+
+ def onSupp(self,objet):
+ #print "onSupp : un objet a été supprimé des fils de l'item ",self.item.object,objet
+ self.expand_node()
+ old_nodes=self.children
+ self.update_nodes()
+ #print "onSupp:nodes",self.children
+ self.redraw_children(old_nodes)
+ self.force_select()
+
+ def update_nodes(self):
+ #print "update_nodes",self
+ newnodes=[]
+ inodes=iter(self.children)
+ sublist=self.item._GetSubList()
+ iliste=iter(sublist)
+ #print "update_nodes",self.children
+ #print "update_nodes",sublist
+
+ while(1):
+ old_item=item=None
+ for node in inodes:
+ old_item=node.item
+ if old_item in sublist:break
+ #print "item supprime",old_item
+ for item in iliste:
+ if item is old_item:break
+ #print "item ajoute",item
+ child = item.itemNode(self,item,self.command,self.rmenu)
+ newnodes.append(child)
+
+ if old_item is None and item is None:break
+ if old_item is item:
+ #print "item conserve",item
+ newnodes.append(node)
+
+ self.children=newnodes
+ self.reconnect()
+
+ def supprime(self):
+ self.disconnect()
+ self.efface_node()
+
+ #self.label_id=None
+ #self.text_id=None
+ #self.label=None
+ #self.text=None
+ #self.image_id=None
+ #self.icone_id=None
+ #self.etape=None
+ ####self.parent=None
+ #self.command = None
+ #self.rmenu=None
+ #self.tree = None
+ #self.appli=None
+ #self.canvas = None
+
+ if not self.children : return
+ for child in self.children:
+ child.supprime()
+ self.children=None
+
+ def redraw_children(self,old_nodes):
+ #print "redraw_children",old_nodes
+ #print self.children
+ y = self.y + 20
+ x = self.x + 15
+ supp_nodes=[]
+
+ inodes=iter(old_nodes)
+ iliste=iter(self.children)
+ # on parcourt la liste des anciens noeuds (node)
+ # et la liste des nouveaux noeuds (new_node) en parallele (iterateurs)
+
+ while(1):
+ new_node=node=None
+ for node in inodes:
+ #print "ancien noeud",node
+ if node in self.children:break # ancien noeud toujours present
+ #print "noeud supprime",node,node.item.GetLabelText()[0]
+ dy=node.y-node.lasty -20
+ #print "deplacer noeuds",y,dy
+ node.move_nodes(y,dy)
+ node.supprime()
+ #supp_nodes.append(node)
+
+ for new_node in iliste:
+ #print "nouveau noeud",new_node
+ if new_node in old_nodes: break # nouveau noeud deja present
+ #print "noeud ajoute",new_node,new_node.item.GetLabelText()[0]
+ y=self.draw_node(new_node,x,y)
+
+ if node is None and new_node is None : break
+
+ if node is new_node: # ancien noeud
+ #print "noeud conserve",node
+ node.update_label_texte()
+ y=y+node.lasty-node.y +20
+
+ self.racine.update_coords()
+ self.canvas.delete('line')
+ self.racine.trace_ligne()
+ self.tree.resizescrollregion()
+ # Mettre à 1 pour verifier les cycles entre objets node
+ #withCyclops=0
+ #if withCyclops:
+ #from Misc import Cyclops
+ #z = Cyclops.CycleFinder()
+ #print supp_nodes
+ #for o in supp_nodes:
+ #z.register(o)
+ #del supp_nodes
+ #del o
+ #z.find_cycles()
+ #z.show_stats()
+ #z.show_cycles()
+
+ def tag_move_nodes(self,y):
+ """ Marque pour deplacement tous les noeuds au dela de l'ordonnée y """
+ self.canvas.dtag(ALL,'move')
+ # on marque tous les ids au dela de y
+ x0, y0, x1, y1 = self.canvas.bbox(ALL)
+ self.canvas.addtag_overlapping('move',x0,y,x1,y1)
+
+ def move_nodes(self,y,dy):
+ """ Déplace de l'incrément dy les noeuds au dela de l'ordonnée y """
+ self.tag_move_nodes(y)
+ # on déplace tous les items de dy
+ self.canvas.move('move',0,dy)
+
+ def draw_node(self,new_node,x,y):
+ """ Dessine le noeud new_node en x,y en deplacant les noeuds existants
+ en y et au dela
+ Retourne la position du premier des noeuds deplaces
+ """
+ self.tag_move_nodes(y)
+ #if new_node.item.isactif():
+ #new_node.state = 'expanded'
+ new_node.state = 'expanded'
+ new_node.draw(x,y)
+ dy=(new_node.get_nb_children()+1)*20
+ #print "deplacer noeuds",y,dy
+ self.canvas.move('move',0,dy)
+ return new_node.lasty+20
def build_children(self):
""" Construit la liste des enfants de self """
Rend le noeud courant (self) sélectionné et déselectionne
tous les autres
"""
+ #print "SELECT",self
+ #traceback.print_stack()
if not self.children : self.build_children()
+ #if self.selected and self.tree.node_selected is self: return
self.tree.deselectall()
self.selected = 1
self.tree.node_selected = self
for child in self.children:
if child.item.get_nom() == name: return child
return None
+
#-----------------------------------------------
# Méthodes d'affichage d'un noeud
#-----------------------------------------------
callback = self.expand
image = self.geticonimage(name=iconname)
self.icone_id = self.canvas.create_image(self.x, self.y, image=image)
- self.canvas.tag_bind(self.icone_id, "<1>", callback)
+ self.callback_id=self.canvas.tag_bind(self.icone_id, "<1>", callback)
self.id.append(self.icone_id)
# création de la ligne horizontale
self.ligne_id = self.canvas.create_line(self.x,self.y,self.x+10,self.y)
image = self.geticonimage()
if image != None :
self.image_id = self.canvas.create_image(self.x+15,self.y,image = image)
- self.canvas.tag_bind(self.image_id,"<1>",self.select)
- self.canvas.tag_bind(self.image_id,"<3>",self.popup)
+ self.select_id2=self.canvas.tag_bind(self.image_id,"<1>",self.select)
+ self.popup_id2=self.canvas.tag_bind(self.image_id,"<3>",self.popup)
self.id.append(self.image_id)
else:
self.image_id = None
self.label_id = self.canvas.create_window(textx,texty,window=self.label,anchor='w')
self.id.append(self.label_id)
# bindings sur le widget label
- self.label.bind("<1>", self.select)
- self.label.bind("<3>", self.popup)
- self.label.bind("<Enter>",self.enter)
- self.label.bind("<Leave>",self.leave)
+ self.select_id=self.label.bind("<1>", self.select)
+ self.popup_id=self.label.bind("<3>", self.popup)
+ self.enter_id=self.label.bind("<Enter>",self.enter)
+ self.leave_id=self.label.bind("<Leave>",self.leave)
# valeur de cet objet à afficher
x0, y0, x1, y1 = self.canvas.bbox(self.label_id)
textx = max(x1, 200) + 10
if not self.children : return
for child in self.children:
child.state='collapsed'
- child.displayed = 0
child.collapse_children()
def collapse(self,event = None):
self.redraw(-nb)
self.select()
- def expand(self,event = None):
+ def expand_node(self,event = None):
""" Expanse self et le retrace """
- if not self.item.isactif() : return
+ if self.state == 'expanded':return
+ #if not self.item.isactif() : return
if not self.children : self.build_children()
self.state = 'expanded'
nb = self.get_nb_children()
self.redraw(nb)
+
+ def expand(self,event = None):
+ """ Expanse self et le retrace """
+ self.expand_node()
self.select()
def redraw(self,nb):
coords = self.canvas.coords(self.label_id)
self.x = coords[0]-15
self.y = coords[1]
+ self.lasty = self.y
if self.state == 'expanded' :
for child in self.children:
if child.displayed != 0:
child.update_coords()
+ self.lasty = child.lasty
def update_icone(self):
""" Met à jour les icônes de tous les noeuds : teste la validité de l'objet
if child.displayed != 0:
child.update_icone()
+ def update_label_texte(self):
+ # nom,fonte et couleur de l'objet du noeud à afficher
+ labeltext,fonte,couleur = self.item.GetLabelText()
+ if labeltext == '' : labeltext = ' '
+ if fonte == None : fonte = Fonte_Standard
+ if couleur == None : couleur = 'black'
+ self.label.configure(text=labeltext,font=fonte)
+ if self.state == 'expanded' :
+ for child in self.children:
+ if child.displayed != 0 : child.update_label_texte()
+
def update_texte(self):
""" Met à jour les noms des SD et valeurs des mots-clés """
text = self.item.GetText()
for child in self.children:
if child.displayed != 0 : child.update_texte()
- def update_valid(self) :
- """Cette methode a pour but de mettre a jour la validite du noeud
- et de propager la demande de mise à jour à son parent
+ def update_node_valid(self) :
+ """Cette methode remet a jour la validite du noeud (icone)
+ Elle appelle isvalid
"""
if self.image_id != None :
image = self.geticonimage()
self.canvas.itemconfig(self.image_id,image=image)
+
+ def update_valid(self) :
+ """Cette methode a pour but de mettre a jour la validite du noeud
+ et de propager la demande de mise à jour à son parent
+ """
+ self.update_node_valid()
self.parent.update_valid()
def update(self,event=None) :
La métode isvalid est en général appelée par l intermédiaire de
update_icone -> geticonimage -> GetIconName
"""
+ #print "update",self
+ #traceback.print_stack()
self.racine.update_coords()
self.racine.trace_ligne()
self.racine.update_icone()
self.racine.update_texte()
self.tree.resizescrollregion()
+ def efface_node(self):
+ if self.displayed != 0:
+ self.label.unbind("<1>", self.select_id)
+ self.label.unbind("<3>", self.popup_id)
+ self.label.unbind("<Enter>",self.enter_id)
+ self.label.unbind("<Leave>",self.leave_id)
+ self.canvas.tag_unbind(self.image_id,"<1>",self.select_id2)
+ self.canvas.tag_unbind(self.image_id,"<3>",self.popup_id2)
+ if self.item.IsExpandable():
+ self.canvas.tag_unbind(self.icone_id, "<1>", self.callback_id)
+ self.label.destroy()
+ self.text.destroy()
+
+ for id in self.id :
+ self.canvas.delete(id)
+ self.id=[]
+ self.label_id=None
+ self.text_id=None
+ self.image_id=None
+ self.icone_id=None
+ self.label=None
+ self.text=None
+ self.displayed=0
+
def efface(self):
""" Efface du canvas les id associés à self : cad les siens et ceux
de ses enfants """
- for id in self.id :
- self.canvas.delete(id)
+ self.efface_node()
if not self.children : return
for child in self.children:
child.efface()
def trace_ligne(self):
""" Dessine les lignes verticales entre frères et entre père et premier fils"""
if self.state=='collapsed' : return
- #if self.displayed == 0 : return
if len(self.children)==0 : return
# on est bien dans le cas d'un noeud expansé avec enfants ...
# il faut rechercher l'ordonnée du dernier fils de self
#------------------------------------------------------------------
def replace_node(self,node1,node2):
""" Remplace le noeud 1 par le noeud 2 dans la liste des enfants de self"""
+ raise "OBSOLETE"
index= self.children.index(node1)
self.delete_node_child(node1)
self.children.insert(index,node2)
def replace_enfant(self,item):
""" Retourne le noeud fils à éventuellement remplacer """
+ raise "OBSOLETE"
return self.get_node_fils(item.get_nom())
def full_creation(self,name,pos=None):
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
+ raise "OBSOLETE"
+ #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
self.children.insert(pos,child)
return child
- def append_brother(self,name,pos='after',retour='non'):
+ def append_brother_BAK(self,name,pos='after',retour='non'):
"""
Permet d'ajouter un frère à self
par défaut on l'ajoute après self
Méthode externe
"""
+ raise "OBSOLETE"
# on veut ajouter le frère de nom name directement avant ou après self
index = self.parent.children.index(self)
if pos == 'before':
des conditions en fonction du contexte
Attention : fils peut être un nom ou déjà un object (cas d'une copie)
"""
+ raise "OBSOLETE"
if not self.children : self.build_children()
if pos == None :
if type(fils) == types.InstanceType:
self.verif_condition()
return child
+ def append_brother(self,name,pos='after',retour='non'):
+ """
+ Permet d'ajouter un objet frère à l'objet associé au noeud self
+ par défaut on l'ajoute immédiatement après
+ Méthode externe
+ """
+ # on veut ajouter le frère de nom name directement avant ou après self
+ index = self.parent.children.index(self)
+ if pos == 'before':
+ index = index
+ elif pos == 'after':
+ index = index +1
+ else:
+ print str(pos)," n'est pas un index valide pour append_brother"
+ return 0
+ return self.parent.append_child(name,pos=index)
+
def append_child(self,name,pos=None,verif='oui',retour='non'):
+ """
+ Methode pour ajouter un objet fils à l'objet associé au noeud self.
+ On peut l'ajouter en début de liste (pos='first'), en fin (pos='last')
+ ou en position intermédiaire.
+ Si pos vaut None, on le place à la position du catalogue.
+ """
+ #print "append_child",self,self.children
+ if pos == 'first':
+ index = 0
+ elif pos == 'last':
+ index = len(self.children)
+ elif type(pos) == types.IntType :
+ # position fixee
+ index = pos
+ elif type(pos) == types.InstanceType:
+ # pos est un item. Il faut inserer name apres pos
+ index = self.item.get_index(pos) +1
+ elif type(name) == types.InstanceType:
+ index = self.item.get_index_child(name.nom)
+ else:
+ index = self.item.get_index_child(name)
+ obj=self.item.additem(name,index)
+ #print obj
+ if obj is None:obj=0
+ if obj == 0:return 0
+ #print "append_child",index,self.children
+ child=self.children[index]
+ child.select()
+ return child
+
+ def append_child_BAK(self,name,pos=None,verif='oui',retour='non'):
"""
Permet d'ajouter un fils à self
on peut l'ajouter en fin de liste (défaut) ou en début
Méthode externe
"""
+ raise "OBSOLETE"
if pos == 'first':
index = 0
elif pos == 'last':
child.select()
if retour == 'oui': return child
- def delete_node_child(self,child):
+ def delete_node_child_BAK(self,child):
""" Supprime child des enfants de self et les id associés """
child.efface()
- child.displayed = 0
self.children.remove(child)
self.canvas.update()
- def delete_child(self,child):
+ def delete_child_BAK(self,child):
"""
Supprime child des enfants de self, tous les id associés
ET l'objet associé
return 0
def delete(self):
+ """
+ Méthode externe pour la destruction de l'objet associé au noeud
+ La mise à jour des noeuds est faite par onSupp sur notification
+ """
+ index = self.parent.children.index(self) - 1
+ if index < 0 : index =0
+ #print index
+
+ ret=self.parent.item.suppitem(self.item)
+ if ret == 0:return
+
+ brothers=self.parent.children
+ if brothers:
+ toselect=brothers[index]
+ else:
+ toselect=self.parent
+ toselect.select()
+
+ def delete_BAK(self):
""" Méthode externe pour la destruction du noeud ET de l'objet
Gère l'update du canvas"""
+ raise "OBSOLETE"
pere = self.parent
nbold = pere.get_nb_children()
Réalise la copie de l'objet passé en argument qui est nécessairement
une commande
"""
+ raise "OBSOLETE"
child = self.append_brother(objet_a_copier,retour='oui')
return child
# Méthodes de vérification du contexte et de validité du noeud
#--------------------------------------------------------------
def verif_all(self):
+ raise "OBSOLETE"
+ traceback.print_stack()
self.verif_all_children()
def verif_all_children(self):
+ raise "OBSOLETE"
+ traceback.print_stack()
if not self.children : self.build_children()
self.verif()
for child in self.children :
Lance la vérification des conditions des blocs de self et le cas
échéant redessine self
"""
+ raise "OBSOLETE"
+ traceback.print_stack()
nbold = self.get_nb_children()
test = self.verif_condition()
nbnew = self.get_nb_children()
on crée ou supprime les noeuds concernés
(self est d'un niveau inférieur ou égal à l'ETAPE)
"""
+ raise "OBSOLETE"
+ traceback.print_stack()
test = 0
l_bloc_arajouter,l_bloc_aenlever = self.verif_condition_bloc()
if len(l_bloc_arajouter) > 0:
return test
def verif_condition_bloc(self):
+ raise "OBSOLETE"
+ traceback.print_stack()
return self.item.verif_condition_bloc()
def verif_condition_regles(self,l_mc_presents):
+ raise "OBSOLETE"
+ traceback.print_stack()
return self.item.verif_condition_regles(l_mc_presents)
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()
+ #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()
else :
cr = self.node.item.get_cr()
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
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()
+ #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()
"""
if self.parent.modified == 'n' : self.parent.init_modif()
valeur = self.get_valeur()
+ #print "valid_valeur",valeur
self.erase_valeur()
anc_val = self.node.item.get_valeur()
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
self.reset_old_valeur(anc_val,mess=mess)
return
- 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()
+ #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()
def valid_nom_concept_co(self,event=None):
"""
Lit le nom donné par l'utilisateur au concept de type CO qui doit être
la valeur du MCS courant et stocke cette valeur
"""
+ #print "valid_nom_concept_co"
if self.parent.modified == 'n' : self.parent.init_modif()
anc_val = self.node.item.get_valeur()
if anc_val != None:
# et le recalcul du contexte
self.node.item.object.etape.parent.reset_context()
nom_concept = self.entry_co.get()
+ #print "valid_nom_concept_co",nom_concept
test,mess=self.node.item.set_valeur_co(nom_concept)
if not test:
# On n'a pas pu créer le concept
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
self.reset_old_valeur(anc_val,mess=mess)
return
- 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()
- if self.node.item.isvalid():
- self.node.parent.select()
- self.node.update()
+ #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()
+ #if self.node.item.isvalid():
+ #self.node.parent.select()
+ #self.node.update()
def ask_new_concept(self):
"""
Affiche la valeur de l'objet pointé par self
"""
valeur = self.node.item.get_valeur()
+ #print "display_valeur",valeur
if valeur == None or valeur == '':
self.valeur_choisie.set('')
return # pas de valeur à afficher ...
# il faut configurer le bouton si la valeur est un objet CO
# sinon afficher le nom du concept dans self.valeur_choisie
if self.node.item.is_CO():
+ #print "display_valeur.is_CO"
self.b_co.invoke('OUI')
self.entry_co.insert(0,valeur.nom)
else:
self.parent.appli.affiche_infos(mess)
# On met a jour le display dans le panneau
self.display_valeur()
- 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()
+ #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()
if self.node.item.isvalid():
self.node.parent.select()
- self.node.update()
+ #self.node.update()
#except :
#pass
- def get_liste_old(self):
+ def get_liste_BAK(self):
return self.liste
# PN attention à la gestion des paramétres
from Noyau.N_CR import CR
from Noyau.N_Exception import AsException
+from Noyau import N_OBJECT
+from Ihm import I_OBJECT
-class COMMANDE_COMM:
+class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
Cette classe sert à définir les objets de type Commande commentarisée
"""
#self.jdc.set_context()
print 'erreurs fatales !!!'
raise AsException("Erreurs fatales",string.join(J.cr.crfatal))
+ if not J.etapes :
+ # des erreurs ont été rencontrées
+ raise AsException("Impossible reconstruire commande\n",str(J.cr))
#self.jdc.set_context()
+
new_etape = J.etapes[0]
if new_etape.sd :
nom_sd = new_etape.sd.nom
else:
nom_sd = None
- return (new_etape.copy(),nom_sd)
+ #new_etape=new_etape.copy()
+ #print "uncomment",new_etape.sd
+
+ pos=self.parent.etapes.index(self)
+ self.parent.addentite(new_etape,pos)
+ self.parent.suppentite(self)
+ return new_etape,nom_sd
def active(self):
"""
"""
from Noyau.N_CR import CR
+from Noyau import N_OBJECT
+from Ihm import I_OBJECT
-class COMMENTAIRE :
+class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
Cette classe permet de créer des objets de type COMMENTAIRE
"""
avec le contexte avant et apres l'insertion
"""
from Accas import JDC,ASSD,AsException,JDC_CATA
+from Ihm import CONNECTOR
-class NOTIFIER:
- def __init__(self):
- self.subscribers=[]
-
- def subscribe(self,obj):
- if not obj in self.subscribers:
- self.subscribers.append(obj)
-
- def notify(self):
- for obj in self.subscribers:
- obj.notify(self)
-
-class JDC_POURSUITE(JDC,NOTIFIER):
+class JDC_POURSUITE(JDC):
def __init__(self,definition=None,procedure=None,cata=None,
cata_ord_dico=None,parent=None,
nom='SansNom',appli=None,context_ini=None,
jdc_pere=None,etape_include=None,prefix_include=None,
recorded_units=None,old_recorded_units=None,**args):
- NOTIFIER.__init__(self)
JDC.__init__(self, definition=definition,
procedure=procedure,
cata=cata,
Si le nom est deja utilise, leve une exception
Met le concept créé dans le contexe global g_context
"""
+ #print "NommerSdprod",sd,sdnom,restrict
if self.prefix_include:
if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
o=self.sds_dict.get(sdnom,None)
Si le contexte ne peut pas etre inséré, la méthode leve une
exception sinon elle retourne le contexte inchangé
"""
+ #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,
mais par un appel à fin_modif pour préserver l'état modified
de tous les objets entre temps
"""
- print "init_modif",self,self.etape_include
+ #print "jdc_include.init_modif",self,self.etape_include
self.state = 'modified'
self.etape_include.init_modif()
déclencher d'éventuels traitements post-modification
ex : INCLUDE et POURSUITE
"""
- print "fin_modif",self,self.etape_include
+ #print "jdc_include.fin_modif",self,self.etape_include
+
+ # Mise a jour du contexte en fin d'include
+ # On suppose que toutes les modifications sont valides
+ # On recupere le contexte final dans j_context
+ j_context=self.get_contexte_avant(None) #get_verif_contexte ???
+ # On remplit le dictionnaire des concepts produits de l'etape macro INCLUDE
+ # sans y mettre les concepts présents dans le contexte initial (context_ini)
+ # On ajoute egalement les concepts produits dans le sds_dict du parent
+ # sans verification car on est sur (verification integrée) que
+ # le nommage est possible
+ self.etape_include.g_context.clear()
+ for k,v in j_context.items():
+ if not self.context_ini.has_key(k) or self.context_ini[k] != v:
+ self.etape_include.g_context[k]=v
+ self.etape_include.parent.sds_dict[k]=v
+
+ CONNECTOR.Emit(self,"valid")
self.etape_include.fin_modif()
- self.notify()
+ #print "jdc_include.fin_modif.context_ini",self.context_ini
def supprime(self):
"""
"""
pass
+ def get_contexte_avant(self,etape):
+ """
+ Retourne le dictionnaire des concepts connus avant etape
+ On tient compte des concepts produits par le jdc pere
+ en reactualisant le contexte initial context_ini
+ On tient compte des commandes qui modifient le contexte
+ comme DETRUIRE ou les macros
+ Si etape == None, on retourne le contexte en fin de JDC
+ """
+ self.context_ini = self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
+ return JDC.get_contexte_avant(self,etape)
+
+ #def get_sd_avant_etape(self,nom_sd,etape):
+ #sd=self.etape_include.parent.get_sd_avant_etape(nom_sd,self.etape_include)
+ #if sd:return sd
+ #return JDC.get_sd_avant_etape(self,nom_sd,etape)
+
+ #def get_sd_avant_du_bon_type(self,etape,types_permis):
+ #"""
+ # Retourne la liste des concepts avant etape d'un type acceptable
+ #"""
+ #l1=self.etape_include.parent.get_sd_avant_du_bon_type(self.etape_include,types_permis)
+ #l2=JDC.get_sd_avant_du_bon_type(self,etape,types_permis)
+ #return l1+l2
+
+ def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
+ """
+ Cette méthode retourne la SD de nom nom_sd qui est éventuellement
+ définie apres etape
+ Si avec vaut 'non' exclut etape de la recherche
+ """
+ sd=self.etape_include.parent.get_sd_apres_etape(nom_sd,self.etape_include,'non')
+ if sd:return sd
+ return JDC.get_sd_apres_etape(self,nom_sd,etape,avec)
+
+ def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
+ """
+ On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
+ Il peut etre detruit, remplacé ou conservé
+ Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
+ définie apres etape en tenant compte des concepts detruits
+ Si avec vaut 'non' exclut etape de la recherche
+ """
+ autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec)
+ 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')
+
+ def delete_concept(self,sd):
+ """
+ Fonction : Mettre a jour les etapes du JDC suite à la disparition du
+ concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ # Nettoyage des etapes de l'include
+ JDC.delete_concept(self,sd)
+ # Nettoyage des etapes du parent
+ self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
+
+ def delete_concept_after_etape(self,etape,sd):
+ """
+ Fonction : Mettre à jour les étapes du JDC qui sont après etape suite à
+ la disparition du concept sd
+ """
+ # Nettoyage des etapes de l'include
+ JDC.delete_concept_after_etape(self,etape,sd)
+ # Nettoyage des etapes du parent
+ self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
+
+ def replace_concept_after_etape(self,etape,old_sd,sd):
+ """
+ Fonction : Mettre à jour les étapes du JDC qui sont après etape suite au
+ remplacement du concept old_sd par sd
+ """
+ # Nettoyage des etapes de l'include
+ JDC.replace_concept_after_etape(self,etape,old_sd,sd)
+ # 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):
# import de modules Eficas
from Noyau.N_CR import CR
+from Noyau import N_OBJECT
+from Ihm import I_OBJECT
-class PARAMETRE :
+class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
Cette classe permet de créer des objets de type PARAMETRE
cad des affectations directes dans le jeu de commandes (ex: a=10.)
--- /dev/null
+# -*- coding: iso-8859-15 -*-
+# 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.
+#
+# 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.
+#
+# 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.
+#
+#
+# ======================================================================
+"""
+ La classe CONNECTOR sert à enregistrer les observateurs d'objets et à délivrer
+ les messages émis à ces objets.
+
+ Le principe général est le suivant : un objet (subscriber) s'enregistre aupres du
+ connecteur global (theconnector) pour observer un objet emetteur de messages (publisher)
+ sur un canal donné (channel). Il demande à etre notifie par appel d'une fonction (listener).
+ La séquence est donc :
+
+ - enregistrement du subscriber pour le publisher : theconnector.Connect(publisher,channel,listener,args)
+ - émission du message par le publisher : theconnector.Emit(publisher,channel,cargs)
+
+ args et cargs sont des tuples contenant les arguments de la fonction listener qui sera appelée
+ comme suit::
+
+ listener(cargs+args)
+"""
+import traceback
+from copy import copy
+
+class CONNECTOR:
+
+ def __init__(self):
+ self.connections={}
+
+ def Connect(self, object, channel, function, args):
+ ###print "Connect",object, channel, function, args
+ idx = id(object)
+ if self.connections.has_key(idx):
+ channels = self.connections[idx]
+ else:
+ channels = self.connections[idx] = {}
+
+ if channels.has_key(channel):
+ receivers = channels[channel]
+ else:
+ receivers = channels[channel] = []
+
+ info = (function, args)
+ if info in receivers:
+ receivers.remove(info)
+ receivers.append(info)
+ ###print "Connect",receivers
+
+
+ def Disconnect(self, object, channel, function, args):
+ try:
+ receivers = self.connections[id(object)][channel]
+ except KeyError:
+ raise ConnectorError, \
+ 'no receivers for channel %s of %s' % (channel, object)
+ try:
+ receivers.remove((function, args))
+ except ValueError:
+ raise ConnectorError,\
+ 'receiver %s%s is not connected to channel %s of %s' \
+ % (function, args, channel, object)
+
+ if not receivers:
+ # the list of receivers is empty now, remove the channel
+ channels = self.connections[id(object)]
+ del channels[channel]
+ if not channels:
+ # the object has no more channels
+ del self.connections[id(object)]
+
+ def Emit(self, object, channel, *args):
+ ###print "Emit",object, channel, args
+ try:
+ receivers = self.connections[id(object)][channel]
+ except KeyError:
+ return
+ ###print "Emit",object, channel, receivers
+ # Attention : copie pour eviter les pbs lies aux deconnexion reconnexion
+ # pendant l'execution des emit
+ for func, fargs in copy(receivers):
+ try:
+ apply(func, args + fargs)
+ except:
+ traceback.print_exc()
+
+_the_connector =CONNECTOR()
+Connect = _the_connector.Connect
+Emit = _the_connector.Emit
+Disconnect = _the_connector.Disconnect
+
+if __name__ == "__main__":
+ class A:pass
+ class B:
+ def add(self,a):
+ print "add",a
+
+ a=A()
+ b=B()
+ Connect(a,"add",b.add,())
+ Emit(a,"add",1)
# Modules EFICAS
import I_MCCOMPO
+import CONNECTOR
class ETAPE(I_MCCOMPO.MCCOMPO):
# 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
+ #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
+ #print "fin_modif",self,self.parent
+ #if hasattr(self,'jdc_aux'):print "fin_modif",self.jdc_aux.context_ini
if self.isvalid() :
+ #if hasattr(self,'jdc_aux'):print "fin_modif",self.jdc_aux.context_ini
d=self.parent.get_contexte_apres(self)
+ #print d
+ #if hasattr(self,'jdc_aux'):print "fin_modif",self.jdc_aux.context_ini
+ CONNECTOR.Emit(self,"valid")
if self.parent:
self.parent.fin_modif()
"""
if self.actif:return
self.actif = 1
- if not self.sd : return
- try:
- self.jdc.append_sdprod(self.sd)
- except:
- pass
+ if self.sd :
+ try:
+ self.jdc.append_sdprod(self.sd)
+ except:
+ pass
+ CONNECTOR.Emit(self,"add",None)
+ CONNECTOR.Emit(self,"valid")
def inactive(self):
"""
et de la liste des sd
"""
self.actif = 0
- if not self.sd : return
- self.jdc.del_sdprod(self.sd)
- self.jdc.delete_concept_after_etape(self,self.sd)
+ if self.sd :
+ self.jdc.del_sdprod(self.sd)
+ self.jdc.delete_concept_after_etape(self,self.sd)
+ CONNECTOR.Emit(self,"supp",None)
+ CONNECTOR.Emit(self,"valid")
def control_sdprods(self,d):
"""
deja definis dans le contexte
"""
if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init,(self,d))
+ try:
+ apply(self.definition.op_init,(self,d))
+ except:
+ #traceback.print_exc()
+ pass
+
if self.sd:
if d.has_key(self.sd.nom):
# Le concept est deja defini
Une procedure n'en a aucun
Une macro en a en général plus d'un
"""
+ #print "supprime_sdprods",self
if not self.is_reentrant() :
# l'étape n'est pas réentrante
# le concept retourné par l'étape est à supprimer car il était
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
"""
+ #print "verif_existence_sd",self.sd
for motcle in self.mc_liste :
motcle.verif_existence_sd()
if self.parent :
self.jdc = self.parent.get_jdc_root()
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
# l'enregistre dans le niveau
self.jdc = self.parent =None
self.id=None
self.niveau=None
+ self.UserError="UserError"
from Noyau.N_ETAPE import ETAPE
from Noyau.N_Exception import AsException
from Extensions import commentaire,parametre,parametre_eval
+import CONNECTOR
class JDC(I_OBJECT.OBJECT):
"""
self.recorded_units={}
self.old_recorded_units={}
+ def get_index(self,objet):
+ """
+ Retourne la position d'objet dans la liste self
+ """
+ return self.etapes.index(objet)
+
def get_sd_avant_du_bon_type(self,etape,types_permis):
"""
Retourne la liste des concepts avant etape d'un type acceptable
self.etapes.insert(pos,objet)
self.editmode=0
self.active_etapes()
+ CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
elif name == "PARAMETRE":
self.editmode=0
self.reset_context()
self.active_etapes()
+ CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
elif name == "PARAMETRE_EVAL":
self.editmode=0
self.reset_context()
self.active_etapes()
+ CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
elif type(name)==types.InstanceType:
# on est donc nécessairement en mode editeur ...
objet = name
# Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
+ #if hasattr(objet,'sd'):print "addentite",objet.sd
objet.reparent(self)
+ #if hasattr(objet,'sd'):print "addentite",objet.sd
self.set_current_step()
if isinstance(objet,ETAPE):
if objet.nom_niveau_definition == 'JDC':
self.etapes.insert(pos,objet)
# il faut vérifier que les concepts utilisés par objet existent bien
# à ce niveau d'arborescence
+ #if hasattr(objet,'sd'):print "addentite",objet.sd
objet.verif_existence_sd()
self.active_etapes()
self.editmode=0
self.reset_context()
- print "addentite",self.etapes
+ #print "addentite",self.etapes
+ CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
else :
self.editmode=0
self.reset_context()
self.active_etapes()
- print "addentite",self.etapes
+ #print "addentite",self.etapes
+ CONNECTOR.Emit(self,"add",e)
self.fin_modif()
return e
except AsException,e:
Retourne 1 si la suppression a pu être effectuée,
Retourne 0 dans le cas contraire
"""
+ #print "suppentite",self
self.init_modif()
# On memorise le contexte avant l'etape a supprimer
d=self.get_contexte_avant(etape)
index_etape=self.etapes.index(etape)
+ #print "suppentite",index_etape,d
self.etapes.remove(etape)
if etape.niveau is not self:
e.control_sdprods(d)
self.reset_context()
+ CONNECTOR.Emit(self,"supp",etape)
self.fin_modif()
return 1
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
+ #print "init_modif",self
self.state = 'modified'
def fin_modif(self):
- print "fin_modif",self
+ #print "fin_modif",self
+ CONNECTOR.Emit(self,"valid")
self.isvalid()
pass
+ def deep_update_condition_bloc(self):
+ # pour le moment, on ne fait rien
+ raise "Not implemented"
+
+ def update_condition_bloc(self):
+ # pour le moment, on ne fait rien
+ raise "Not implemented"
+
def get_liste_mc_inconnus(self):
"""
Retourne une liste contenant les mots-clés inconnus à la relecture du JDC
"""
Supprime la SD sd de la liste des sd et des dictionnaires de contexte
"""
+ #print "del_sdprod",self,sd
+ #print "del_sdprod",self.sds
+ #print "del_sdprod",self.g_context
+ #print "del_sdprod",self.sds_dict
if sd in self.sds : self.sds.remove(sd)
if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
if self.sds_dict.has_key(sd.nom) : del self.sds_dict[sd.nom]
Seuls les mots cles simples MCSIMP font un traitement autre
que de transmettre aux fils
"""
+ #print "delete_concept",self,sd
for etape in self.etapes :
etape.delete_concept(sd)
import Noyau, Validation.V_MACRO_ETAPE
from Noyau import N_Exception
from Noyau.N_Exception import AsException
+import Accas # attention aux imports circulaires
# fin import à résorber
class MACRO_ETAPE(I_ETAPE.ETAPE):
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)
+ # Attention get_contexte_avant retourne un dictionnaire qui contient
+ # le contexte courant. Ce dictionnaire est reactualise regulierement.
+ # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
+ context_ini = self.parent.get_contexte_avant(self).copy()
# Indispensable avant de creer un nouveau JDC
CONTEXT.unset_current_step()
# On récupère les étapes internes (pour validation)
self.etapes=j.etapes
self.jdc_aux=j
- print "get_contexte_jdc",id(self.etapes)
+ #print "get_contexte_jdc",id(self.etapes)
except:
traceback.print_exc()
# On force le contexte (etape courante) à self
# Si aucune erreur rencontrée
# On recupere le contexte de l'include verifie
+ #print "context_ini",j.context_ini
+ #print "g_context",j.g_context
try:
j_context=j.get_verif_contexte()
except:
CONTEXT.set_current_step(self)
raise
+ #print "context_ini",j.context_ini
+
# 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
# On rétablit le contexte (etape courante) à self
CONTEXT.unset_current_step()
CONTEXT.set_current_step(self)
+ #print "context_ini",self.jdc_aux.context_ini
return j_context
Avec la liste des SD qui ont été supprimées, propage la
disparition de ces SD dans toutes les étapes et descendants
"""
+ #print "reevalue_sd_jdc"
l_sd_supp,l_sd_repl = self.diff_contextes()
for sd in l_sd_supp:
self.parent.delete_concept_after_etape(self,sd)
def supprime_sdprods(self):
"""
- Fonction:
- Lors d'une destruction d'etape, detruit tous les concepts produits
+ Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
Un opérateur n a qu un concept produit
Une procedure n'en a aucun
Une macro en a en général plus d'un
"""
+ #print "supprime_sdprods"
if not self.is_reentrant() :
# l'étape n'est pas réentrante
# le concept retourné par l'étape est à supprimer car il était
self.parent.delete_concept(co)
# On met g_context à blanc
self.g_context={}
+
+ def 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
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ #print "delete_concept",sd
+ I_ETAPE.ETAPE.delete_concept(self,sd)
+ for etape in self.etapes:
+ etape.delete_concept(sd)
+
+ def replace_concept(self,old_sd,sd):
+ """
+ Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
+ suite au remplacement du concept old_sd par sd
+ """
+ #print "replace_concept",old_sd,sd
+ I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
+ for etape in self.etapes:
+ etape.replace_concept(sd)
+ def change_fichier_init(self,new_fic,text):
+ """
+ Tente de changer le fichier include. Le precedent include est conservé
+ dans old_xxx
+ """
+ if not hasattr(self,'fichier_ini'):
+ self.fichier_ini=None
+ self.fichier_text=None
+ self.fichier_err="Le fichier n'est pas defini"
+ self.contexte_fichier_init={}
+ self.recorded_units={}
+ self.jdc_aux=None
+ self.fichier_unite="PasDefini"
+ import Extensions.jdc_include
+ self.JdC_aux=Extensions.jdc_include.JdC_include
+
+ self.old_fic = self.fichier_ini
+ self.old_text = self.fichier_text
+ self.old_err = self.fichier_err
+ self.old_context=self.contexte_fichier_init
+ self.old_units=self.recorded_units
+ self.old_etapes=self.etapes
+ self.old_jdc_aux=self.jdc_aux
+
+ self.fichier_ini = new_fic
+ self.fichier_text=text
+
+ try:
+ self.make_contexte_include(new_fic,text)
+ except:
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ self.fichier_err=string.join(l)
+ raise
+
+ # L'evaluation de text dans un JDC auxiliaire s'est bien passé
+ # on peut poursuivre le traitement
+ self.init_modif()
+ self.state="undetermined"
+ self.fichier_err=None
+ # On enregistre la modification de fichier
+ self.record_unite()
+ # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
+ self.parent.reset_context()
+
+ # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
+ self.old_contexte_fichier_init=self.old_context
+ self.reevalue_sd_jdc()
+
+ self.fin_modif()
+
+ def restore_fichier_init(self):
+ """
+ Restaure le fichier init enregistre dans old_xxx
+ """
+ self.fichier_ini=self.old_fic
+ self.fichier_text=self.old_text
+ self.fichier_err=self.old_err
+ self.contexte_fichier_init=self.old_context
+ self.recorded_units=self.old_units
+ self.etapes=self.old_etapes
+ self.jdc_aux=self.old_jdc_aux
+
+ def force_fichier_init(self):
+ """
+ Force le fichier init en erreur
+ """
+ # 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)
+ self.init_modif()
+ # 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()
+
+ self.old_contexte_fichier_init=self.old_context
+ self.contexte_fichier_init={}
+ self.reevalue_sd_jdc()
+
+ self.fin_modif()
+
def make_contexte_include(self,fichier,text):
"""
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 :
# contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
self.contexte_fichier_init = contexte
- def reevalue_fichier_init(self):
+ def reevalue_fichier_init_OBSOLETE(self):
"""Recalcule les concepts produits par le fichier enregistre"""
+ #print "reevalue_fichier_init"
old_context=self.contexte_fichier_init
try:
self.make_contexte_include(self.fichier_ini ,self.fichier_text)
self.fichier_err = None
self.old_contexte_fichier_init=old_context
self.reevalue_sd_jdc()
+ #print "reevalue_fichier_init",self.jdc_aux.context_ini
def update_fichier_init(self,unite):
"""Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
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
if old_fichier_ini == self.fichier_ini:
# Le fichier inclus n'a pas changé. On ne recrée pas le contexte
+ #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
return
try:
# Si des concepts ont disparu lors du changement de fichier, on
# demande leur suppression
self.reevalue_sd_jdc()
+ #print "update_fichier_init",self.jdc_aux.context_ini
def record_unite(self):
if self.nom == "POURSUITE":
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
try:
self.make_contexte_include(self.fichier_ini ,self.fichier_text)
self.parent.record_unit(unite,self)
+ #print "make_include.context_ini",self.jdc_aux.context_ini
except:
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
if self.jdc.appli:
def make_poursuite(self):
""" Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
"""
- print "make_poursuite"
+ #print "make_poursuite"
if not hasattr(self,'fichier_ini') :
# Si le fichier n'est pas defini on le demande
f,text=self.get_file_memo(fic_origine=self.parent.nom)
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
+
"""
import string,types
from copy import copy
+import traceback
from Noyau.N_MCLIST import MCList
from Noyau.N_MCSIMP import MCSIMP
from Noyau.N_MCBLOC import MCBLOC
import I_OBJECT
+import CONNECTOR
+
class MCCOMPO(I_OBJECT.OBJECT):
def getlabeltext(self):
"""
l.append(k)
return l
+ def get_index_child(self,nom_fils):
+ """
+ Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
+ Permet de savoir à quelle position il faut ajouter un nouveau mot-clé
+ """
+ cata_ordonne = self.jdc.cata_ordonne_dico
+ liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),cata_ordonne)
+ liste_noms_mc_presents = self.liste_mc_presents()
+ index=0
+ for nom in liste_noms_mc_ordonnee:
+ if nom == nom_fils:break
+ if nom not in liste_noms_mc_presents :continue
+ index=index+1
+ return index
+
def ordonne_liste_mc(self,liste_mc_a_ordonner,liste_noms_mc_ordonnee):
"""
Retourne liste_mc_a_ordonner ordonnée suivant l'ordre
return 0
try :
+ self.mc_liste.remove(objet)
+ CONNECTOR.Emit(self,"supp",objet)
+
if hasattr(objet.definition,'position'):
- if objet.definition.position == 'global' :
+ if objet.definition.position == 'global' :
self.delete_mc_global(objet)
- elif objet.definition.position == 'global_jdc' :
+ self.etape.deep_update_condition_bloc()
+ elif objet.definition.position == 'global_jdc' :
self.delete_mc_global_jdc(objet)
- self.mc_liste.remove(objet)
+ self.jdc.deep_update_condition_bloc()
+ else:
+ self.update_condition_bloc()
+
self.fin_modif()
return 1
except:
Ajoute le mot-cle name à la liste des mots-cles de
l'objet MCCOMPOSE
"""
+ #print "I_MCCOMPO.addentite",name,pos
self.init_modif()
if type(name)==types.StringType :
# on est en mode création d'un motcle
# On cherche s'il existe deja un mot cle de meme nom
old_obj = self.get_child(objet.nom,restreint = 'oui')
+ #print "addentite",old_obj
+ #if old_obj:print "addentite",old_obj.isrepetable(),old_obj.isMCList(),old_obj.ajout_possible()
if not old_obj :
+ #print self.mc_liste,objet
# Le mot cle n'existe pas encore. On l'ajoute a la position
# demandee (pos)
if pos == None :
self.mc_liste.append(objet)
else :
self.mc_liste.insert(pos,objet)
+ #print self.mc_liste,objet
# Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
objet.reparent(self)
+ CONNECTOR.Emit(self,"add",objet)
self.fin_modif()
return objet
else:
# Il ne faut pas oublier de reaffecter le parent d'obj
objet.reparent(self)
self.mc_liste.remove(old_obj)
+ CONNECTOR.Emit(self,"supp",old_obj)
self.mc_liste.insert(index,new_obj)
+ CONNECTOR.Emit(self,"add",new_obj)
self.fin_modif()
return new_obj
else :
# une liste d'objets de même type existe déjà
- if not old_obj.ajout_possible():
- self.jdc.send_message("L'objet %s ne peut pas être répété" %objet.nom)
- self.fin_modif()
- return 0
- if objet.isMCList():
- objet=objet.data[0]
- old_obj.append(objet)
- # Il ne faut pas oublier de reaffecter le parent d'obj
- objet.reparent(self)
- self.fin_modif()
+ old_obj.addentite(objet)
return old_obj
def ispermis(self,fils):
if fils.parent.nom != self.nom : return 0
return 1
- def liste_mc_presents(self):
- """
- Retourne la liste des noms des mots-clés fils de self présents
- construite à partir de self.mc_liste
- """
- l=[]
- for v in self.mc_liste:
- k=v.nom
- l.append(k)
- return l
-
def delete_concept(self,sd):
"""
Inputs :
l_mc.append(l)
return l_mc
+ def deep_update_condition_bloc(self):
+ """
+ Parcourt l'arborescence des mcobject et realise l'update
+ des blocs conditionnels par appel de la methode update_condition_bloc
+ """
+ #print "deep_update_condition_bloc",self
+ self.update_condition_bloc()
+ for mcobj in self.mc_liste:
+ if hasattr(mcobj,"deep_update_condition_bloc"):
+ mcobj.deep_update_condition_bloc()
+
+ def update_condition_bloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ """
+ #print "update_condition_bloc",self
+ dict = self.cree_dict_condition(self.mc_liste,condition=1)
+ for k,v in self.definition.entites.items():
+ if v.label != 'BLOC' :continue
+ globs= self.jdc and self.jdc.condition_context or {}
+ bloc=self.get_child(k,restreint = 'oui')
+ presence=v.verif_presence(dict,globs)
+ if presence and not bloc:
+ # le bloc doit être présent
+ # mais le bloc n'est pas présent et il doit être créé
+ #print "AJOUT BLOC",k
+ pos=self.get_index_child(k)
+ self.addentite(k,pos)
+ if not presence and bloc:
+ # le bloc devrait être absent
+ # le bloc est présent : il faut l'enlever
+ #print "SUPPRESSION BLOC",k,bloc
+ self.suppentite(bloc)
+
def verif_condition_bloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
"""
liste_ajouts = []
liste_retraits = []
- dict = self.cree_dict_condition(self.mc_liste)
+ dict = self.cree_dict_condition(self.mc_liste,condition=1)
for k,v in self.definition.entites.items():
if v.label=='BLOC' :
globs= self.jdc and self.jdc.condition_context or {}
#
#
# ======================================================================
+import CONNECTOR
import I_MCCOMPO
+
class MCFACT(I_MCCOMPO.MCCOMPO):
def isrepetable(self):
"""
except:
return "Erreur - mot clé facteur de nom: "+self.nom
+ def init_modif(self):
+ """
+ Met l'état de l'objet à modified et propage au parent
+ qui vaut None s'il n'existe pas
+ """
+ self.state = 'modified'
+ parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent
+ if parent:
+ parent.init_modif()
+
+ def fin_modif(self):
+ """
+ Méthode appelée après qu'une modification a été faite afin de déclencher
+ d'éventuels traitements post-modification
+ """
+ #print "fin_modif",self
+ # pour les objets autres que les commandes, aucun traitement spécifique
+ # on remonte l'info de fin de modif au parent
+ CONNECTOR.Emit(self,"valid")
+ parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent
+ if parent:
+ parent.fin_modif()
+
#
#
# ======================================================================
+import types,traceback
from copy import copy
+import CONNECTOR
class MCList:
def isMCList(self):
Une MCList n'est jamais obligatoire (même si le MCFACT qu'elle représente l'est
"""
return self.data[0].definition.statut=='o'
- #return 0
+
+ def suppentite(self,obj):
+ """
+ Supprime le mot cle facteur obj de la MCLIST
+ """
+ self.init_modif()
+ self.remove(obj)
+ CONNECTOR.Emit(self,"supp",obj)
+ self.fin_modif()
+ return 1
+
+ def addentite(self,obj,pos=None):
+ """
+ Ajoute le mot cle facteur obj a la MCLIST a la position pos
+ Retourne None si l'ajout est impossible
+ """
+ if type(obj)==types.StringType :
+ # on est en mode création d'un motcle
+ raise "traitement non prevu"
+
+ if not self.ajout_possible():
+ self.jdc.send_message("L'objet %s ne peut pas être ajouté" % obj.nom)
+ return None
+
+ if self.nom != obj.nom:
+ return None
+
+ if obj.isMCList():
+ obj=obj.data[0]
+
+ # Traitement du copier coller seulement
+ # Les autres cas d'ajout sont traites dans MCFACT
+ self.init_modif()
+ obj.verif_existence_sd()
+ obj.reparent(self.parent)
+ if pos is None:
+ self.append(obj)
+ else:
+ self.insert(pos,obj)
+ CONNECTOR.Emit(self,"add",obj)
+ self.fin_modif()
+ return obj
def liste_mc_presents(self):
return []
# Sans objet pour une liste de mots clés facteurs
return []
+ def deep_update_condition_bloc(self):
+ """
+ Parcourt l'arborescence des mcobject et realise l'update
+ des blocs conditionnels par appel de la methode update_condition_bloc
+ """
+
+ #print "deep_update_condition_bloc",self
+ for mcfact in self.data :
+ mcfact.deep_update_condition_bloc()
+
def verif_condition_bloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
- la première contient les noms des blocs à rajouter
- la seconde contient les noms des blocs à supprimer
"""
- # Sans objet pour une liste de mots clés facteurs
+ # Sans objet pour une liste de mots clés facteurs (a voir !!!)
return [],[]
def init_modif(self):
Méthode appelée après qu'une modification a été faite afin de déclencher
d'éventuels traitements post-modification
"""
+ #print "fin_modif",self
+ CONNECTOR.Emit(self,"valid")
if self.parent:
self.parent.fin_modif()
from Noyau.N_ASSD import ASSD,assd
from Noyau.N_GEOM import GEOM,geom
from Noyau.N_CO import CO
+import Accas
# fin attention
from Extensions import parametre
import I_OBJECT
+import CONNECTOR
class MCSIMP(I_OBJECT.OBJECT):
def isoblig(self):
return self.definition.statut=='o'
+ def valid_valeur(self,new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est valide
+ sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ """
+ old_valeur=self.valeur
+ old_val=self.val
+ self.valeur = new_valeur
+ self.val = new_valeur
+ self.state="modified"
+ validite=self.isvalid()
+ self.valeur = old_valeur
+ self.val = old_valeur
+ self.state="modified"
+ self.isvalid()
+ return validite
+
+ def valid_valeur_partielle(self,new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est partiellement valide
+ sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ """
+ old_valeur=self.valeur
+ old_val=self.val
+
+ self.valeur = new_valeur
+ self.val = new_valeur
+ self.state="modified"
+ validite=0
+ if self.isvalid():
+ validite=1
+ elif self.definition.validators :
+ validite=self.definition.validators.valide_liste_partielle(new_valeur)
+
+ if validite==0:
+ min,max=self.get_min_max()
+ if len(new_valeur) < min :
+ validite=1
+
+ self.valeur = old_valeur
+ self.val = old_valeur
+ self.state="modified"
+ self.isvalid()
+ return validite
+
def set_valeur(self,new_valeur,evaluation='oui'):
+ #print "set_valeur",new_valeur
self.init_modif()
self.valeur = new_valeur
self.val = new_valeur
+ if self.definition.position == 'global' :
+ self.etape.deep_update_condition_bloc()
+ elif self.definition.position == 'global_jdc' :
+ self.jdc.deep_update_condition_bloc()
+ else:
+ self.parent.update_condition_bloc()
self.fin_modif()
return 1
Essaie d'évaluer new_valeur comme une SD, une déclaration Python
ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
"""
- sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
+ #print "eval_valeur",new_valeur
+ sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
+ #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
if sd :
return sd,1
else:
d={}
# On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
- from Accas import EVAL
- d['EVAL']=EVAL
+ d['EVAL']=Accas.EVAL
try :
objet = eval(new_valeur,d)
return objet,1
Met a jour la valeur du mot cle simple suite à la disparition
du concept sd
"""
+ #print "delete_concept",sd
if type(self.valeur) == types.TupleType :
if sd in self.valeur:
+ self.init_modif()
self.valeur=list(self.valeur)
self.valeur.remove(sd)
- self.init_modif()
+ self.fin_modif()
elif type(self.valeur) == types.ListType:
if sd in self.valeur:
- self.valeur.remove(sd)
self.init_modif()
+ self.valeur.remove(sd)
+ self.fin_modif()
else:
if self.valeur == sd:
+ self.init_modif()
self.valeur=None
self.val=None
- self.init_modif()
+ self.fin_modif()
def replace_concept(self,old_sd,sd):
"""
Met a jour la valeur du mot cle simple suite au remplacement
du concept old_sd
"""
+ #print "replace_concept",old_sd,sd
if type(self.valeur) == types.TupleType :
if old_sd in self.valeur:
+ self.init_modif()
self.valeur=list(self.valeur)
i=self.valeur.index(old_sd)
self.valeur[i]=sd
- self.init_modif()
+ self.fin_modif()
elif type(self.valeur) == types.ListType:
if old_sd in self.valeur:
+ self.init_modif()
i=self.valeur.index(old_sd)
self.valeur[i]=sd
- self.init_modif()
+ self.fin_modif()
else:
if self.valeur == old_sd:
+ self.init_modif()
self.valeur=sd
self.val=sd
- self.init_modif()
+ self.fin_modif()
def set_valeur_co(self,nom_co):
"""
Affecte à self l'objet de type CO et de nom nom_co
"""
+ #print "set_valeur_co",nom_co
step=self.etape.parent
if nom_co == None or nom_co == '':
new_objet=None
else:
- # Pour le moment on importe en local le CO de Accas.
- # Si problème de perfs, il faudra faire autrement
- from Accas import CO
# Avant de créer un concept il faut s'assurer du contexte : step
# courant
sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
step.set_etape_context(self.etape)
- new_objet = CO(nom_co)
+ new_objet = Accas.CO(nom_co)
CONTEXT.unset_current_step()
CONTEXT.set_current_step(cs)
self.init_modif()
# On force l'enregistrement de new_objet en tant que concept produit
# de la macro en appelant get_type_produit avec force=1
self.etape.get_type_produit(force=1)
+ #print "set_valeur_co",new_objet
return 1,"Concept créé"
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
"""
+ #print "verif_existence_sd"
+ # Attention : possible probleme avec include
l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
if type(self.valeur) in (types.TupleType,types.ListType) :
l=[]
+ self.init_modif()
for sd in self.valeur:
if isinstance(sd,ASSD) :
if sd in l_sd_avant_etape :
else:
l.append(sd)
self.valeur=tuple(l)
- # Est ce init_modif ou init_modif_up
- # Normalement init_modif va avec fin_modif
- self.init_modif()
self.fin_modif()
else:
if isinstance(self.valeur,ASSD) :
if self.valeur not in l_sd_avant_etape :
- self.valeur = None
self.init_modif()
+ self.valeur = None
self.fin_modif()
def get_min_max(self):
lang=prefs.lang
except:
lang='fr'
-
+
+import CONNECTOR
class OBJECT:
from Noyau.N_CO import CO
Méthode appelée après qu'une modification a été faite afin de déclencher
d'éventuels traitements post-modification
"""
+ #print "fin_modif",self
# pour les objets autres que les commandes, aucun traitement spécifique
# on remonte l'info de fin de modif au parent
+ CONNECTOR.Emit(self,"valid")
if self.parent:
self.parent.fin_modif()
Si format vaut 'standard', retourne un texte obtenu par concaténation de la liste
Si format vaut 'beautifie', retourne le meme texte beautifié
"""
- self.appli=obj.appli
+ self.appli=obj.get_jdc_root().appli
+ #self.appli=obj.appli
liste= self.generator(obj)
if format == 'brut':
self.text=liste
"""
Méthode particulière pour les objets de type FORMULE
"""
- print "coucou"
l=[]
nom = obj.get_nom()
if nom == '' : nom = 'sansnom'
