# 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)
+ # On cache l'objet initial (pour destruction eventuelle
+ # ultérieure)
self._object = object
self.setfunction = setfunction
self.expandable = 1
DEBUT();
MA=DEFI_MATERIAU(ELAS=_F(E=210000000000,
- NU=0.3,),);
+ NU=0.3,),);
INFO_MED=2,);
MODE=AFFE_MODELE(MAILLAGE=MAIL,
- AFFE=_F(TOUT='OUI',
- PHENOMENE='MECANIQUE',
- MODELISATION= '3D',),);
+ AFFE=_F(TOUT='OUI',
+ PHENOMENE='MECANIQUE',
+ MODELISATION= '3D',),);
MATER=MA,),);
CHAR=AFFE_CHAR_MECA(MODELE=MODE,
- FACE_IMPO=(
- _F(GROUP_MA='ABB1A1',
- DX=0,
- DY=0,
- DZ=0,),),
- PRES_REP=(
- _F(GROUP_MA='CDD1C1',
- PRES=10000,),),);
+ FACE_IMPO=(
+ _F(GROUP_MA='ABB1A1',
+ DX=0,
+ DY=0,
+ DZ=0,),),
+ PRES_REP=(
+ _F(GROUP_MA='CDD1C1',
+ PRES=10000,),),);
RESU=MECA_STATIQUE(MODELE=MODE,
CHAM_MATER=MATE,
# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
+# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# 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
#
# 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.
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
#
#
# ======================================================================
from Noyau.N_CR import CR
#
-__Id__="$Id: analyse_catalogue.py,v 1.3 2002/09/10 15:59:37 eficas Exp $"
-__version__="$Name: $"
+__Id__="$Id: analyse_catalogue.py,v 1.4 2004/09/10 15:51:47 eficas Exp $"
+__version__="$Name: $"
#
l_noms_commandes = ['OPER','PROC','MACRO','FORM']
l_noms_composes=['FACT','BLOC','NUPL','FORM']
l_noms=l_noms_composes+l_noms_simples
def elimine_commentaires(text):
- """ Elimine les lignes de commentaires dans text
- Attention : supprime sauvagement tous les caractères entre # et le retour chariot ..."""
- comments = re.compile(r'#[^\n]*')
- return comments.sub('',text)
+ """ Elimine les lignes de commentaires dans text
+ Attention : supprime sauvagement tous les caractères entre # et le retour chariot ..."""
+ comments = re.compile(r'#[^\n]*')
+ return comments.sub('',text)
def cherche_nom(text):
- Whitespace = r'[ \f\t]*'
- Name = r'[a-zA-Z_]\w*'
- myexpr = '('+Name+')'+Whitespace+'='+Whitespace+'$'
- a=re.search(myexpr,text)
- return a.group(1)
+ Whitespace = r'[ \f\t]*'
+ Name = r'[a-zA-Z_]\w*'
+ myexpr = '('+Name+')'+Whitespace+'='+Whitespace+'$'
+ a=re.search(myexpr,text)
+ return a.group(1)
def cherche_args(text):
- text = strip(text)
- longueur = len(text)
- if text[0] != '(':
- return 'erreur !'
- else :
- nbpar = 1
- for i in range(1,longueur) :
- if text[i] =='(':
- nbpar = nbpar + 1
- elif text[i] == ')':
- nbpar = nbpar - 1
- else :
- continue
- if nbpar == 0:
- break
- if nbpar != 0 :
- return 'erreur !','erreur !'
- else :
- try :
- return text[1:i],text[i+1:] # on enlève les première et dernière parenthèses
- except :
- return text[1:i],''
+ text = strip(text)
+ longueur = len(text)
+ if text[0] != '(':
+ return 'erreur !'
+ else :
+ nbpar = 1
+ for i in range(1,longueur) :
+ if text[i] =='(':
+ nbpar = nbpar + 1
+ elif text[i] == ')':
+ nbpar = nbpar - 1
+ else :
+ continue
+ if nbpar == 0:
+ break
+ if nbpar != 0 :
+ return 'erreur !','erreur !'
+ else :
+ try :
+ return text[1:i],text[i+1:] # on enlève les première et dernière parenthèses
+ except :
+ return text[1:i],''
class ENTITE :
- def cherche_enfants(self):
- try :
- self.text = strip(self.text)
- liste = re.split('=',self.text,1)
- if len(liste)>1 :
- arg1=liste[0]
- reste=liste[1]
- reste = strip(reste)
- if reste[0:4] in l_noms :
- nom_mc = cherche_nom(arg1+'=')
- arg_mc, self.text = cherche_args(reste[4:])
- self.cree_mc(nom_mc,arg_mc,reste[0:4])
- else :
- self.text = reste
- self.cherche_enfants()
- else :
- # pas de = rencontré
- return
- except Exception,e:
- self.cr.fatal("Erreur rencontrée dans recherche_enfants :%s" %str(e))
-
- def cree_mc(self,nom_mc,arg_mc,test):
- if test in l_noms_composes :
- mc = FACT_CATA(nom_mc,arg_mc,self)
- self.children.append(mc)
- elif test in l_noms_simples :
- mc = SIMP_CATA(nom_mc,self)
- self.children.append(mc)
- else :
- print 'erreur dans la création du mot-clé :',nom_mc
-
- def construit_liste_dico(self):
- l=[]
- d={}
- if len(self.children)==0:
- self.ordre_mc = l
- self.entites = d
- return
- try :
- for child in self.children:
- l.append(child.nom)
- d[child.nom]=child
- self.ordre_mc = l
- self.entites = d
- except:
- print 'erreur :',self.nom,self.__class__
-
+ def cherche_enfants(self):
+ try :
+ self.text = strip(self.text)
+ liste = re.split('=',self.text,1)
+ if len(liste)>1 :
+ arg1=liste[0]
+ reste=liste[1]
+ reste = strip(reste)
+ if reste[0:4] in l_noms :
+ nom_mc = cherche_nom(arg1+'=')
+ arg_mc, self.text = cherche_args(reste[4:])
+ self.cree_mc(nom_mc,arg_mc,reste[0:4])
+ else :
+ self.text = reste
+ self.cherche_enfants()
+ else :
+ # pas de = rencontré
+ return
+ except Exception,e:
+ self.cr.fatal("Erreur rencontrée dans recherche_enfants :%s" %str(e))
+
+ def cree_mc(self,nom_mc,arg_mc,test):
+ if test in l_noms_composes :
+ mc = FACT_CATA(nom_mc,arg_mc,self)
+ self.children.append(mc)
+ elif test in l_noms_simples :
+ mc = SIMP_CATA(nom_mc,self)
+ self.children.append(mc)
+ else :
+ print 'erreur dans la création du mot-clé :',nom_mc
+
+ def construit_liste_dico(self):
+ l=[]
+ d={}
+ if len(self.children)==0:
+ self.ordre_mc = l
+ self.entites = d
+ return
+ try :
+ for child in self.children:
+ l.append(child.nom)
+ d[child.nom]=child
+ self.ordre_mc = l
+ self.entites = d
+ except:
+ print 'erreur :',self.nom,self.__class__
+
class COMMANDE_CATA(ENTITE) :
- def __init__(self,nom,args,parent):
- self.nom = nom
- self.args = args
- self.children = []
- self.text = args
- self.cr = CR()
- self.cr.debut = "Début commande %s" %self.nom
- self.cr.fin = "Fin commande %s" %self.nom
- self.cherche_enfants()
- self.construit_liste_dico()
- parent.cr.add(self.cr)
-
- def affiche(self):
- texte_cmd = '\n'
- texte_cmd = texte_cmd + 'Commande :' + self.nom + '\n'
- for child in self.children :
- texte_cmd = texte_cmd + child.affiche(1)
- return texte_cmd
+ def __init__(self,nom,args,parent):
+ self.nom = nom
+ self.args = args
+ self.children = []
+ self.text = args
+ self.cr = CR()
+ self.cr.debut = "Début commande %s" %self.nom
+ self.cr.fin = "Fin commande %s" %self.nom
+ self.cherche_enfants()
+ self.construit_liste_dico()
+ parent.cr.add(self.cr)
+
+ def affiche(self):
+ texte_cmd = '\n'
+ texte_cmd = texte_cmd + 'Commande :' + self.nom + '\n'
+ for child in self.children :
+ texte_cmd = texte_cmd + child.affiche(1)
+ return texte_cmd
class SIMP_CATA :
- def __init__(self,nom,parent):
- self.nom = nom
- self.cr = CR()
- self.cr.debut = "Début mot-clé simple %s" %self.nom
- self.cr.fin = "Fin mot-clé simple %s" %self.nom
- parent.cr.add(self.cr)
+ def __init__(self,nom,parent):
+ self.nom = nom
+ self.cr = CR()
+ self.cr.debut = "Début mot-clé simple %s" %self.nom
+ self.cr.fin = "Fin mot-clé simple %s" %self.nom
+ parent.cr.add(self.cr)
- def affiche(self,ind):
- sep = ' '*5
- return sep*ind+self.nom+'\n'
+ def affiche(self,ind):
+ sep = ' '*5
+ return sep*ind+self.nom+'\n'
class FACT_CATA(ENTITE) :
- def __init__(self,nom,args,parent):
- self.nom=nom
- self.args=args
- self.children = []
- self.text=args
- self.cr = CR()
- self.cr.debut = "Début mot-clé facteur ou bloc %s" %self.nom
- self.cr.fin = "Fin mot-clé facteur ou bloc %s" %self.nom
- self.cherche_enfants()
- self.construit_liste_dico()
- parent.cr.add(self.cr)
-
- def affiche(self,ind):
- sep = ' '*5
- text = ''
- text = text + sep*ind+self.nom+'\n'
- for child in self.children :
- text = text + child.affiche(ind+1)
- return text
-
+ def __init__(self,nom,args,parent):
+ self.nom=nom
+ self.args=args
+ self.children = []
+ self.text=args
+ self.cr = CR()
+ self.cr.debut = "Début mot-clé facteur ou bloc %s" %self.nom
+ self.cr.fin = "Fin mot-clé facteur ou bloc %s" %self.nom
+ self.cherche_enfants()
+ self.construit_liste_dico()
+ parent.cr.add(self.cr)
+
+ def affiche(self,ind):
+ sep = ' '*5
+ text = ''
+ text = text + sep*ind+self.nom+'\n'
+ for child in self.children :
+ text = text + child.affiche(ind+1)
+ return text
+
class CATALOGUE_CATA:
- def __init__(self,parent,fichier):
- self.parent = parent
- self.fichier=fichier
- self.cr = CR()
- self.cr.debut = "Début compte-rendu catalogue %s" %self.fichier
- self.cr.fin = "Fin compte-rendu catalogue %s" %self.fichier
- self.ouvrir_fichier()
- self.liste_commandes=[]
- self.liste_textes_commandes=[]
-
- def ouvrir_fichier(self):
- try :
- f=open(self.fichier,'r')
- self.texte_complet=f.read()
- f.close()
- except e:
- print "Impossible d'ouvrir le fichier :",self.fichier
- print e
- self.cr.fatal("Impossible d'ouvrir le fichier :%s" %self.fichier)
-
- def constr_list_txt_cmd(self,text):
- text = elimine_commentaires(text)
- pattern = '\) *;'
- liste=re.split(pattern,text)
- for i in range(0,len(liste)-1):
- self.liste_textes_commandes.append(liste[i]+')')
-
- def analyse_commande_old(self,text):
- #if strip(text) == '' or strip(text) ==')': return
- liste = re.split('OPER *\(',text,1)
- if len(liste) < 2 :
- liste = re.split('PROC *\(',text,1)
- if len(liste) < 2 :
- liste = re.split('MACRO *\(',text,1)
- if len(liste) < 2 :
- print "le texte à analyser n'est pas celui d'une commande ou d'un opérateur",text
- self.cr.fatal("le texte à analyser n'est pas celui d'une commande ou d'un opérateur :%s" %text)
- return
- debut = liste[0]
- fin = liste[1]
- nom_cmd = cherche_nom(debut)
- if nom_cmd == 'erreur !':
- print "Erreur dans la recherche du nom de la commande :",debut
- args_cmd,toto = cherche_args('('+fin)
- if args_cmd == 'erreur !':
- print "Erreur dans la recherche des args de la commande :",debut
- cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
- self.liste_commandes.append(cmd)
-
- def analyse_commande(self,text):
- #if strip(text) == '' or strip(text) ==')': return
- for nom_cmd in l_noms_commandes:
- liste = re.split(nom_cmd+' *\(',text,1)
- if len(liste) == 2 : break
- if len(liste) < 2 :
- print "le texte à analyser n'est pas celui d'une commande connue :"+str(l_noms_commandes),text
- self.cr.fatal("le texte à analyser n'est pas celui d'une commande ou d'un opérateur :%s" %text)
- return
- debut = liste[0]
- fin = liste[1]
- nom_cmd = cherche_nom(debut)
- if nom_cmd == 'erreur !':
- print "Erreur dans la recherche du nom de la commande :",debut
- args_cmd,toto = cherche_args('('+fin)
- if args_cmd == 'erreur !':
- print "Erreur dans la recherche des args de la commande :",debut
+ def __init__(self,parent,fichier):
+ self.parent = parent
+ self.fichier=fichier
+ self.cr = CR()
+ self.cr.debut = "Début compte-rendu catalogue %s" %self.fichier
+ self.cr.fin = "Fin compte-rendu catalogue %s" %self.fichier
+ self.ouvrir_fichier()
+ self.liste_commandes=[]
+ self.liste_textes_commandes=[]
+
+ def ouvrir_fichier(self):
+ try :
+ f=open(self.fichier,'r')
+ self.texte_complet=f.read()
+ f.close()
+ except e:
+ print "Impossible d'ouvrir le fichier :",self.fichier
+ print e
+ self.cr.fatal("Impossible d'ouvrir le fichier :%s" %self.fichier)
+
+ def constr_list_txt_cmd(self,text):
+ text = elimine_commentaires(text)
+ pattern = '\) *;'
+ liste=re.split(pattern,text)
+ for i in range(0,len(liste)-1):
+ self.liste_textes_commandes.append(liste[i]+')')
+
+ def analyse_commande_old(self,text):
+ #if strip(text) == '' or strip(text) ==')': return
+ liste = re.split('OPER *\(',text,1)
+ if len(liste) < 2 :
+ liste = re.split('PROC *\(',text,1)
+ if len(liste) < 2 :
+ liste = re.split('MACRO *\(',text,1)
+ if len(liste) < 2 :
+ print "le texte à analyser n'est pas celui d'une commande ou d'un opérateur",text
+ self.cr.fatal("le texte à analyser n'est pas celui d'une commande ou d'un opérateur :%s" %text)
+ return
+ debut = liste[0]
+ fin = liste[1]
+ nom_cmd = cherche_nom(debut)
+ if nom_cmd == 'erreur !':
+ print "Erreur dans la recherche du nom de la commande :",debut
+ args_cmd,toto = cherche_args('('+fin)
+ if args_cmd == 'erreur !':
+ print "Erreur dans la recherche des args de la commande :",debut
+ cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
+ self.liste_commandes.append(cmd)
+
+ def analyse_commande(self,text):
+ #if strip(text) == '' or strip(text) ==')': return
+ for nom_cmd in l_noms_commandes:
+ liste = re.split(nom_cmd+' *\(',text,1)
+ if len(liste) == 2 : break
+ if len(liste) < 2 :
+ print "le texte à analyser n'est pas celui d'une commande connue :"+str(l_noms_commandes),text
+ self.cr.fatal("le texte à analyser n'est pas celui d'une commande ou d'un opérateur :%s" %text)
+ return
+ debut = liste[0]
+ fin = liste[1]
+ nom_cmd = cherche_nom(debut)
+ if nom_cmd == 'erreur !':
+ print "Erreur dans la recherche du nom de la commande :",debut
+ args_cmd,toto = cherche_args('('+fin)
+ if args_cmd == 'erreur !':
+ print "Erreur dans la recherche des args de la commande :",debut
print fin
- cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
- self.liste_commandes.append(cmd)
-
- def analyse_texte(self,texte):
- self.constr_list_txt_cmd(texte)
- try:
- self.parent.configure_barre(len(self.liste_textes_commandes))
- except:
- pass
- for texte_commande in self.liste_textes_commandes :
- try:
- self.parent.update_barre()
- except:
- pass
- self.analyse_commande(texte_commande)
- self.construit_liste_dico()
-
- def ecrit_lcmd(self):
- f=open('U:\\EFICAS\\Accas\\cata.txt','w')
- for cmd in self.liste_commandes :
- f.write(cmd.affiche())
- f.close()
-
- def construit_liste_dico(self):
- l=[]
- d={}
- for cmd in self.liste_commandes:
- l.append(cmd.nom)
- d[cmd.nom]=cmd
- self.ordre_mc = l
- self.entites = d
-
- def report(self):
- """ retourne l'objet rapport du catalogue de commande """
- return self.cr
+ cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
+ self.liste_commandes.append(cmd)
+
+ def analyse_texte(self,texte):
+ self.constr_list_txt_cmd(texte)
+ try:
+ self.parent.configure_barre(len(self.liste_textes_commandes))
+ except:
+ pass
+ for texte_commande in self.liste_textes_commandes :
+ try:
+ self.parent.update_barre()
+ except:
+ pass
+ self.analyse_commande(texte_commande)
+ self.construit_liste_dico()
+
+ def ecrit_lcmd(self):
+ f=open('U:\\EFICAS\\Accas\\cata.txt','w')
+ for cmd in self.liste_commandes :
+ f.write(cmd.affiche())
+ f.close()
+
+ def construit_liste_dico(self):
+ l=[]
+ d={}
+ for cmd in self.liste_commandes:
+ l.append(cmd.nom)
+ d[cmd.nom]=cmd
+ self.ordre_mc = l
+ self.entites = d
+
+ def report(self):
+ """ retourne l'objet rapport du catalogue de commande """
+ return self.cr
def analyse_catalogue(parent,nom_cata):
- cata = CATALOGUE_CATA(parent,nom_cata)
- cata.analyse_texte(cata.texte_complet)
- return cata
+ cata = CATALOGUE_CATA(parent,nom_cata)
+ cata.analyse_texte(cata.texte_complet)
+ return cata
def analyse_catalogue_commande(parent,nom_cata):
- cata = CATALOGUE_CATA(parent,nom_cata)
- cata.analyse_commande(cata.texte_complet)
- cata.construit_liste_dico()
- return cata
+ cata = CATALOGUE_CATA(parent,nom_cata)
+ cata.analyse_commande(cata.texte_complet)
+ cata.construit_liste_dico()
+ return cata
def make_cata_pickle(fic_cata):
- """
- Lance l'analyse de l'ordre des mots-clés dans le catalogue dont le nom
- est passé en argument et sauvegarde ces infos dans le fichier pickle relu
- par Eficas
- """
- fic_cata_p = os.path.splitext(fic_cata)[0]+'_pickled.py'
- cata_ordonne = analyse_catalogue(None,fic_cata)
- f = open(fic_cata_p,'w+')
- p = cPickle.Pickler(f)
- p.dump(cata_ordonne.entites)
- f.close()
-
+ """
+ Lance l'analyse de l'ordre des mots-clés dans le catalogue dont le nom
+ est passé en argument et sauvegarde ces infos dans le fichier pickle relu
+ par Eficas
+ """
+ fic_cata_p = os.path.splitext(fic_cata)[0]+'_pickled.py'
+ cata_ordonne = analyse_catalogue(None,fic_cata)
+ f = open(fic_cata_p,'w+')
+ p = cPickle.Pickler(f)
+ p.dump(cata_ordonne.entites)
+ f.close()
+
if __name__ == "__main__" :
- import profile
- profile.run("analyse_catalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
+ import profile
+ profile.run("analyse_catalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
-
-
+
+
# Creation de la menubar, toolbar, messagebar
self.cree_composants_graphiques()
# Creation des autres composants graphiques dont le bureau (parametrable par prefs.py)
- self.load_appli_composants()
+ self.load_appli_composants()
self.listeFichiers=listeFichiers.listeFichiers(self)
self.listePatrons=listePatrons.listePatrons(self)
self.dir=None
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('*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)
radio=None
for item in itemlist:
number_item=number_item + 1
- raccourci_label=""
+ raccourci_label=""
if not item :
#menu.add_separator()
- pass
+ pass
else:
if len(item)==3:
raccourci=item[2]
- raccourci_label=" "+raccourci
+ raccourci_label=" "+raccourci
newitem=(item[0],item[1])
else :
- if len(item)==4:
+ if len(item)==4:
raccourci=item[2]
- raccourci_label=" "+item[3]
+ raccourci_label=" "+item[3]
newitem=(item[0],item[1])
- else :
- raccourci=""
+ else :
+ raccourci=""
newitem=item
item=newitem
label,method=item
button_defs = (('New24',"newJDC","Création d'un nouveau fichier",'always'),
('Open24',"openJDC","Ouverture d'un fichier existant",'always'),
('Save24',"saveJDC","Sauvegarde du fichier courant",'always'),
- ('Fermer24',"closeJDC","Fermeture du fichier courant",'always'),
+ ('Fermer24',"closeJDC","Fermeture du fichier courant",'always'),
('Zoom24',"visuJDC","Visualisation du fichier de commandes",'always'),
None,
('Copy24',"copy","Copie l'objet courant",'jdc'),
titre="compte-rendu d'erreurs, EFICAS ne sait pas convertir ce fichier",
texte = str(p.cr)).wait()
return
- if enregistre == "oui" :
- self.appli.listeFichiers.aOuvert(file)
+ if enregistre == "oui" :
+ self.appli.listeFichiers.aOuvert(file)
else:
# Il n'existe pas c'est une erreur
self.appli.affiche_infos("Type de fichier non reconnu")
else:
self.ShowJDC(J,self.JDCName,enregistre=enregistre)
self.appli.toolbar.active_boutons()
- # si le JDC ne contient rien (vide), on retourne ici
- if len(self.JDC.etapes) == 0 : return
- # dans le cas où le JDC est invalide, on affiche son CR
+ # si le JDC ne contient rien (vide), on retourne ici
+ if len(self.JDC.etapes) == 0 : return
+ # dans le cas où le JDC est invalide, on affiche son CR
if not self.JDC.isvalid():
- self.appli.top.update()
- self.visuCR(mode='JDC')
+ self.appli.top.update()
+ self.visuCR(mode='JDC')
def deplieReplieNode(self):
self.JDCDisplay_courant.tree.tree.deplieReplieNode()
self.jdc_fini = string.replace(jdc_formate,'\r\n','\n')
if echo =='oui' or self.JDCDisplay_courant.fichier == None:
- ok = self.asknomsauvegardeJDC()
+ ok = self.asknomsauvegardeJDC()
elif self.JDCDisplay_courant.fichier != None :
# le JDC a déjà un nom : on sauvegarde directement sans demander
# un autre nom au développeur
if not save_in_file(self.JDCDisplay_courant.fichier,self.jdc_fini,self.appli.dir) :
showinfo("Erreur","Problème à la sauvegarde du fichier :" + `self.JDCDisplay_courant.fichier`)
#return 0
- ok = 0
+ ok = 0
else :
if self.appli.format_fichier.get() == 'homard':
self.save_homard(self.JDCDisplay_courant.fichier,self.jdc_homard)
if ok and hasattr( self.appli, 'salome'):
# eficas a été lancé à partir deSalome
#1)ajout dans l'arbre d'étude du nom du jdc
- ok, msg = self.appli.addJdcInSalome( self.JDCDisplay_courant.fichier )
+ ok, msg = self.appli.addJdcInSalome( self.JDCDisplay_courant.fichier )
#2)CS_pbruno ??
- from panelsSalome import SALOME_UNIQUE_BASE_Panel
- if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
- print 'CS_pbruno if len(SALOMchier_unite) > 0 :???????'
- self.appli.creeConfigTxt( self.appli.CONFIGURATION.initialdir, SALOME_UNIQUE_BASE_Panel.dict_fichier_unite )
+ from panelsSalome import SALOME_UNIQUE_BASE_Panel
+ if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
+ print 'CS_pbruno if len(SALOMchier_unite) > 0 :???????'
+ self.appli.creeConfigTxt( self.appli.CONFIGURATION.initialdir, SALOME_UNIQUE_BASE_Panel.dict_fichier_unite )
- #3)création/mise à jours d'un maillage dans Salome
- self.appli.createOrUpdateMesh()
+ #3)création/mise à jours d'un maillage dans Salome
+ self.appli.createOrUpdateMesh()
return ok
def asknomsauvegardeJDC(self):
self.appli.salome.rangeInStudy(file_homard,"_CONF")
# ---------------------------------------------------------------------------
-# Méthodes liées aux mots-clés inconnus
+# Méthodes liées aux mots-clés inconnus
# ---------------------------------------------------------------------------
def mc_inconnus(self):
p.readfile(fichier)
text=p.convert('exec',self)
if not p.cr.estvide():
- print ("Erreur à la conversion")
- print str(p.cr)
+ print ("Erreur à la conversion")
+ print str(p.cr)
return
# On se met dans le repertoire ou se trouve le fichier de commandes
def modifieJDC(self,texte):
if texte == None or texte == "" : return
format="python"
- lignes=string.split(texte,";")
- textedecoup=""
- for l in lignes :
- textedecoup=textedecoup+l+'\n'
+ lignes=string.split(texte,";")
+ textedecoup=""
+ for l in lignes :
+ textedecoup=textedecoup+l+'\n'
if convert.plugins.has_key(format):
p=convert.plugins[format]()
p.settext(textedecoup)
text=p.convert('exec',self)
- print text
+ print text
if not p.cr.estvide():
- print ("Erreur à la conversion")
- print str(p.cr)
+ print ("Erreur à la conversion")
+ print str(p.cr)
return
self.J2=self.cata[0].JdC(procedure=text,appli=self,
cata=self.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
nom = self.JDCName+"2",
rep_mat=self.CONFIGURATION.rep_mat,
)
- self.J2.definition.code = "MODIF"
+ self.J2.definition.code = "MODIF"
self.J2.analyse()
self.jdc_fini = string.replace(jdc_formate,'\r\n','\n')
if not save_in_file(fichierSortie,self.jdc_fini) :
- self.affiche_infos("Problème à la sauvegarde du fichier")
+ self.affiche_infos("Problème à la sauvegarde du fichier")
return 0
else :
self.affiche_infos("sauvegarde effectuée")
args = self.node.item.get_args()
if args:
texte_args=""
- for i in args :
- if texte_args != "" :
- texte_args = texte_args +","
- texte_args=texte_args + i
+ for i in args :
+ if texte_args != "" :
+ texte_args = texte_args +","
+ texte_args=texte_args + i
self.entry_arg.insert(END,texte_args)
corps = self.node.item.get_corps()
if corps :
"""
Lance la vérification du corps de formule présent dans entry_exp
"""
- new_nom = self.entry_nom.get()
- new_typ="REEL"
+ new_nom = self.entry_nom.get()
+ new_typ="REEL"
new_arg = self.entry_arg.get()
new_exp = self.entry_exp.get()
if new_exp == '':
Ce nom dépend de la validité de l'objet
"""
if self.object.isactif():
- self.object.state="modified"
+ self.object.state="modified"
if self.object.isvalid():
return "ast-green-square"
else:
"""
args=""
for mot in self.object.mc_liste:
- if mot.nom == 'NOM_PARA':
- args=mot.valeur
- break
+ if mot.nom == 'NOM_PARA':
+ args=mot.valeur
+ break
if args :
if args[0] == "(" and args[-1] ==")":
- args=args[1:-1]
- # transforme en tuple si ce n est pas déjà le casa
- try :
- args=string.split(args,',')
- except :
- pass
+ args=args[1:-1]
+ # transforme en tuple si ce n est pas déjà le casa
+ try :
+ args=string.split(args,',')
+ except :
+ pass
return args
def get_corps(self):
"""
corps=""
for mot in self.object.mc_liste:
- if mot.nom == 'VALE':
- corps=mot.valeur
- break
+ if mot.nom == 'VALE':
+ corps=mot.valeur
+ break
return corps
"""
Lance la vérification de FORMULE passée en argument
"""
- return self.object.verif_formule(formule=formule)
+ return self.object.verif_formule(formule=formule)
def verif_formule_python(self,formule):
"""
Lance la vérification de FORMULE passée en argument
"""
- return self.object.verif_formule_python(formule=formule)
+ return self.object.verif_formule_python(formule=formule)
import Accas
treeitem =FORMULETreeItem
class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
""" La classe MCListTreeItem joue le role d'un adaptateur pour les objets
du noyau Accas instances de la classe MCLIST.
- Elle adapte ces objets pour leur permettre d'etre intégrés en tant que
- noeuds dans un arbre graphique (voir treewidget.py et ObjectTreeItem.py).
- Cette classe délègue les appels de méthode et les accès
- aux attributs à l'objet du noyau soit manuellement soit
- automatiquement (voir classe Delegate et attribut object).
+ Elle adapte ces objets pour leur permettre d'etre intégrés en tant que
+ noeuds dans un arbre graphique (voir treewidget.py et ObjectTreeItem.py).
+ Cette classe délègue les appels de méthode et les accès
+ aux attributs à l'objet du noyau soit manuellement soit
+ automatiquement (voir classe Delegate et attribut object).
"""
itemNode=Node
self.updateDelegate()
def updateDelegate(self):
- if len(self._object) > 1:
- self.setdelegate(self._object)
- else:
- self.setdelegate(self._object.data[0])
+ if len(self._object) > 1:
+ self.setdelegate(self._object)
+ else:
+ self.setdelegate(self._object.data[0])
def panel(self,jdcdisplay,pane,node):
""" Retourne une instance de l'objet panneau associe a l'item (self)
FACTPanel.
Si la liste est plus longue on utilise le panneau MCLISTPanel.
"""
- if len(self._object) > 1:
+ if len(self._object) > 1:
return MCLISTPanel(jdcdisplay,pane,node)
- else:
- return compofact.FACTPanel(jdcdisplay,pane,node)
+ else:
+ return compofact.FACTPanel(jdcdisplay,pane,node)
def IsExpandable(self):
- if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.IsExpandable(self)
- else:
- return compofact.FACTTreeItem.IsExpandable(self)
+ if len(self._object) > 1:
+ return Objecttreeitem.SequenceTreeItem.IsExpandable(self)
+ else:
+ return compofact.FACTTreeItem.IsExpandable(self)
def GetSubList(self):
self.updateDelegate()
- if len(self._object) <= 1:
+ if len(self._object) <= 1:
self._object.data[0].alt_parent=self._object
- return compofact.FACTTreeItem.GetSubList(self)
+ return compofact.FACTTreeItem.GetSubList(self)
liste=self._object.data
sublist=[None]*len(liste)
return self.object.get_docu()
def iscopiable(self):
- if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.iscopiable(self)
- else:
- return compofact.FACTTreeItem.iscopiable(self)
+ if len(self._object) > 1:
+ return Objecttreeitem.SequenceTreeItem.iscopiable(self)
+ else:
+ return compofact.FACTTreeItem.iscopiable(self)
def isMCFact(self):
"""
Retourne 1 si l'objet pointé par self est un MCFact, 0 sinon
"""
- return len(self._object) <= 1
+ return len(self._object) <= 1
def isMCList(self):
"""
Retourne 1 si l'objet pointé par self est une MCList, 0 sinon
"""
- return len(self._object) > 1
-
+ return len(self._object) > 1
+
def get_copie_objet(self):
return self._object.data[0].copy()
def additem(self,obj,pos):
#print "compomclist.additem",obj,pos
- if len(self._object) <= 1:
+ if len(self._object) <= 1:
return compofact.FACTTreeItem.additem(self,obj,pos)
o= self.object.addentite(obj,pos)
def suppitem(self,item):
"""
- Retire un objet MCFACT de la MCList (self.object)
- """
+ 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)
+ if len(self._object) <= 1:
+ return compofact.FACTTreeItem.suppitem(self,item)
if self.object.suppentite(obj):
- if len(self._object) == 1: self.updateDelegate()
+ if len(self._object) == 1: self.updateDelegate()
message = "Mot-clé " + obj.nom + " supprimé"
self.appli.affiche_infos(message)
return 1
self.appli.affiche_infos('Impossible de supprimer ce mot-clé')
return 0
-
+
import Accas
objet = Accas.MCList
panneau.pack(expand=1,fill='both')
self.bouton_com.pack_forget()
self.makeJDCPage(panneau.pane('left'))
- self.enlevebind()
+ self.enlevebind()
import treewidget
self.valeur_choisie.set(choix)
except:
traceback.print_exc()
-
+
def choose_valeur_from_list(self,command):
try:
from uniqueassdpanel import UNIQUE_ASSD_Panel
from uniqueassdpanel import UNIQUE_ASSD_Panel_Reel
if 'R' in self.GetType():
- self.panel = UNIQUE_ASSD_Panel_Reel
+ self.panel = UNIQUE_ASSD_Panel_Reel
else :
self.panel = UNIQUE_ASSD_Panel
else:
self.panel = UNIQUE_COMP_Panel
else:
# on attend un entier, un réel ou une string
- from uniquebasepanel import UNIQUE_BASE_Panel
+ from uniquebasepanel import UNIQUE_BASE_Panel
self.panel = UNIQUE_BASE_Panel
# cas particulier des fonctions
genea = self.get_genealogie()
if hasattr( self.appli, 'salome' ):
import panelsSalome
- self.select_noeud_maille=0
- self.clef_fonction="SALOME"
- for i in range(0,len( genea )) :
- self.clef_fonction=self.clef_fonction+"_"+ genea[i]
- if genea[i] == "GROUP_NO" or genea[i] == "GROUP_MA":
- self.select_noeud_maille=1
+ self.select_noeud_maille=0
+ self.clef_fonction="SALOME"
+ for i in range(0,len( genea )) :
+ self.clef_fonction=self.clef_fonction+"_"+ genea[i]
+ if genea[i] == "GROUP_NO" or genea[i] == "GROUP_MA":
+ self.select_noeud_maille=1
recherche=panelsSalome.dict_classes_salome[self.panel]
if hasattr(recherche,self.clef_fonction):
#
#-----------------------------------------------
# is_list
- # get_into a priori inutile --> commentee
+ # get_into a priori inutile --> commentee
# has_into
- # wait_into a priori inutile --> commentee
+ # wait_into a priori inutile --> commentee
# GetMinMax
# GetMultiplicite
# GetIntervalle
min,max = self.GetMinMax()
assert (min <= max)
if max > 1 :
- is_a_list=1
+ is_a_list=1
# Dans le cas avec validateurs, pour que le mot cle soit considéré
# comme acceptant une liste, il faut que max soit supérieur a 1
# ET que la méthode is_list du validateur retourne 1. Dans les autres cas
Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
Dans le cas sans validateur, l'information est donnée par l'attribut into
de la definition du mot cle.
- Dans le cas avec validateurs, pour que le mot cle soit considéré
+ Dans le cas avec validateurs, pour que le mot cle soit considéré
comme proposant un choix, il faut que into soit présent OU
que la méthode has_into du validateur retourne 1. Dans les autres cas
on retournera 0 (ne propose pas de choix)
"""
has_an_into=0
if self.definition.into:
- has_an_into=1
+ has_an_into=1
elif self.definition.validators :
has_an_into= self.definition.validators.has_into()
return has_an_into
def get_liste_possible(self,listeActuelle=[]):
if hasattr(self.definition.validators,'into'):
- self.get_definition().into=self.definition.validators.into
+ self.get_definition().into=self.definition.validators.into
valeurspossibles = self.get_definition().into
# CCAR : Ne serait-il pas preferable d'appeler get_into ?
#valeurspossibles=self.get_into(listeActuelle)
#
liste_param=[]
for param in self.object.jdc.params:
- encorevalide=self.valide_item(param.valeur)
+ encorevalide=self.valide_item(param.valeur)
if encorevalide:
- type_param=param.valeur.__class__.__name__
- for typ in self.definition.type:
- if typ=='R':
- liste_param.append(param)
- if typ=='I' and type_param=='int':
- liste_param.append(param)
- if typ=='TXM' and type_param=='str':
- liste_param.append(repr(param))
+ type_param=param.valeur.__class__.__name__
+ for typ in self.definition.type:
+ if typ=='R':
+ liste_param.append(param)
+ if typ=='I' and type_param=='int':
+ liste_param.append(param)
+ if typ=='TXM' and type_param=='str':
+ liste_param.append(repr(param))
return liste_param
#--------------------------------------------------
def valide_item(self,item):
"""
- On fait un try except pour les erreurs de type (exple
- on rentre 1 pour une chaine de caracteres
+ On fait un try except pour les erreurs de type (exple
+ on rentre 1 pour une chaine de caracteres
"""
valide=1
if self.definition.validators :
try :
valide=self.definition.validators.verif_item(item)
except :
- valide = 0
+ valide = 0
return valide
def valide_liste_partielle(self,item,listecourante):
# Autres ...
#
#---------------------------------------------------
- # SetText a priori inutilisee --> commentee
+ # SetText a priori inutilisee --> commentee
# GetIconName
# GetText
# getval a priori inutilisee --> commentee
# set_valeur_co
# get_sd_avant_du_bon_type
- # verif a priori inutilisee --> commentee
+ # verif a priori inutilisee --> commentee
# delete_valeur_co
#def SetText(self, text):
boo=0
if len(self.object.definition.type) > 1 :
if self.wait_reel() :
- boo = 1
- if 'I' in self.object.definition.type :
- boo = 1
+ boo = 1
+ if 'I' in self.object.definition.type :
+ boo = 1
return boo
newvaleur,validiteitem=self.eval_valeur_item(item)
valeurretour.append(newvaleur)
if validiteitem == 0:
- validite=0
+ validite=0
else :
valeurretour,validite= self.eval_valeur_item(valeur)
if validite == 0 :
- valeurretour = None
+ valeurretour = None
return valeurretour,validite
def eval_valeur_item(self,valeur):
""" Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
- - va retourner la valeur de retour et la validite
+ - va retourner la valeur de retour et la validite
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
+ return None,0
validite=1
if self.wait_reel():
valeurinter = self.traite_reel(valeur)
- if valeurinter != None :
+ if valeurinter != None :
valeurretour,validite= self.object.eval_valeur(valeurinter)
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():
+ if type(valeur) == types.StringType and self.object.wait_TXM():
essai_valeur="'" + valeur + "'"
valeurretour,validite= self.object.eval_valeur(essai_valeur)
#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:
+ if type(valeurretour) != types.StringType:
valeurretour=str(valeur)
validite=1
return valeurretour,validite
def is_param(self,valeur) :
for param in self.jdc.params:
- if (repr(param) == valeur):
- return 1
+ if (repr(param) == valeur):
+ return 1
return 0
def traite_reel(self,valeur):
if string.find(valeur,'.') == -1 :
# aucun '.' n'a été trouvé dans valeur --> on en rajoute un à la fin
if (self.is_param(valeur)):
- return valeur
+ return valeur
else:
- if string.find(valeur,'e') != -1:
- # Notation scientifique ?
- try :
- r=eval(valeur)
- return valeur
- except :
- return None
- else :
+ if string.find(valeur,'e') != -1:
+ # Notation scientifique ?
+ try :
+ r=eval(valeur)
+ return valeur
+ except :
+ return None
+ else :
return valeur+'.'
else:
return valeur
if generator.plugins.has_key(format):
g=generator.plugins[format]()
jdc_formate=g.gener(J,format='beautifie')
- print "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"
- print jdc_formate
jdc_fini = string.replace(jdc_formate,'\r\n','\n')
- print jdc_fini
utils.save_in_file(fileName+".comm",jdc_fini,None)
def convertir(texte):
-------------------------------------------------------------------------------------------------------------
- FAQs et Limitations d'EFICAS
+ FAQs et Limitations d'EFICAS
-------------------------------------------------------------------------------------------------------------
1. Mots réservés :
- Tous les mots du langage Python sont des mots réservés.
- On ne peut donc pas appeler une variable ou un concept 'fin' ou 'dir'
- Pour la liste complète de ces mots-clés, veuillez vous référer à la
- documentation Python
+ Tous les mots du langage Python sont des mots réservés.
+ On ne peut donc pas appeler une variable ou un concept 'fin' ou 'dir'
+ Pour la liste complète de ces mots-clés, veuillez vous référer à la
+ documentation Python
2. Concepts réentrants :
- Ne pas indiquer par un '&' devant son nom qu'un concept est utilisé comme
- concept réentrant. En effet EFICAS le sait !
+ Ne pas indiquer par un '&' devant son nom qu'un concept est utilisé comme
+ concept réentrant. En effet EFICAS le sait !
3. Carte commentaire :
- La carte commentaire est désormais le '#' (dièse) au lieu du '%' (pourcent)
+ La carte commentaire est désormais le '#' (dièse) au lieu du '%' (pourcent)
Les commentaires sont gérés comme des objets de même niveau que les
commandes ; il n'est plus possible de placer des commentaires "dans"
une commande. Attention, lors de la traduction d'un fichier de version 5
4. Nommer le concept produit par un opérateur :
- Vous ne pouvez nommer le concept produit d'un opérateur que lorsque
- celui-ci aura été entièrement et correctement rempli.
+ Vous ne pouvez nommer le concept produit d'un opérateur que lorsque
+ celui-ci aura été entièrement et correctement rempli.
5. Règle de rémanence dans les mots-clés facteurs répétés :
- La règle de rémanence qui permettait pour certains mots-clés facteurs
- et pour certains de leurs mots-clés simples de ne pas répeter la valeur
- de ces derniers dans toutes les occurrences du mot-clé facteur n'est pas
- connue d'EFICAS.
- En conséquence, vous devez répéter les mots-clés simples concernés dans
- toutes les occurrences des mots-clés facteurs.
+ La règle de rémanence qui permettait pour certains mots-clés facteurs
+ et pour certains de leurs mots-clés simples de ne pas répeter la valeur
+ de ces derniers dans toutes les occurrences du mot-clé facteur n'est pas
+ connue d'EFICAS.
+ En conséquence, vous devez répéter les mots-clés simples concernés dans
+ toutes les occurrences des mots-clés facteurs.
6. Besoin d'aide ?
-
- La documentation d'utilisation d'EFICAS a pris un peu de retard sur le produit ...
- Néanmoins, vous disposez sur la plupart des panneaux contextuels ( les panneaux à
- droite de l'arbre) d'une aide en ligne que vous pouvez activer en maintenant le
- bouton droit de votre souris enfoncé.
+
+ La documentation d'utilisation d'EFICAS a pris un peu de retard sur le produit ...
+ Néanmoins, vous disposez sur la plupart des panneaux contextuels ( les panneaux à
+ droite de l'arbre) d'une aide en ligne que vous pouvez activer en maintenant le
+ bouton droit de votre souris enfoncé.
self.mc_courant = None
self.var_quit = IntVar(0)
self.entry_courante = None
-
+
def init_frames(self):
"""
Création des 2 frames devant contenir le label et la liste des MC inconnus
self.fenetre.update_idletasks()
Label(self.frame1,
text = txt,
- wraplength = int(self.frame1.winfo_width()*0.8),
- justify = 'center').place(relx=0.5,rely=0.5,anchor='center')
+ wraplength = int(self.frame1.winfo_width()*0.8),
+ justify = 'center').place(relx=0.5,rely=0.5,anchor='center')
def init_liste_mc(self):
for mc in self.l_mc :
# mc est une liste :
# mc contient comme premiers arguments l'étape et éventuellement les blocs, mcfact ...
- # et contient comme 2 derniers éléments le nom du mot-clé et sa valeur
- path_mc = self.get_path(mc[0:-2])
- nom_mc = mc[-2]
- lab=Label(self.frame2,text = path_mc)
- lab.grid(row=i,column=1,sticky=W)
- e = Entry(self.frame2)
- e.grid(row=i,column=0,sticky=W)
- e.insert(END,nom_mc)
- #e.bind("<Button-1>",lambda event,en=e,m=mc,s=self : s.select_mc(m,en))
- #e.bind("<Return>",lambda e,s=self : s.modifie_mc())
- e.configure(relief='flat',state='disabled')
+ # et contient comme 2 derniers éléments le nom du mot-clé et sa valeur
+ path_mc = self.get_path(mc[0:-2])
+ nom_mc = mc[-2]
+ lab=Label(self.frame2,text = path_mc)
+ lab.grid(row=i,column=1,sticky=W)
+ e = Entry(self.frame2)
+ e.grid(row=i,column=0,sticky=W)
+ e.insert(END,nom_mc)
+ #e.bind("<Button-1>",lambda event,en=e,m=mc,s=self : s.select_mc(m,en))
+ #e.bind("<Return>",lambda e,s=self : s.modifie_mc())
+ e.configure(relief='flat',state='disabled')
self.widgets.append((e,lab))
i=i+1
def init_boutons(self):
"""
- Construit les boutons Modifier,Supprimer et Fermer
- Les deux premiers sont inactifs tant qu'aucun mot-clé n'est sélectionné
- """
- self.b_mod = Button(self.frame3,
- text = "Modifier",
- disabledforeground = 'grey35',
- state='disabled',
- command = self.modifie_mc)
- self.b_sup = Button(self.frame3,
- text = "Supprimer",
- disabledforeground = 'grey35',
- state='disabled',
- command = self.supprime_mc)
- self.b_quit = Button(self.frame3,
- text = "Fermer",
- command = self.quit)
- #self.b_mod.place(relx=0.25,rely=0.5,anchor='center')
- #self.b_sup.place(relx=0.50,rely=0.5,anchor='center')
- #self.b_quit.place(relx=0.75,rely=0.5,anchor='center')
- self.b_quit.place(relx=0.50,rely=0.5,anchor='center')
-
+ Construit les boutons Modifier,Supprimer et Fermer
+ Les deux premiers sont inactifs tant qu'aucun mot-clé n'est sélectionné
+ """
+ self.b_mod = Button(self.frame3,
+ text = "Modifier",
+ disabledforeground = 'grey35',
+ state='disabled',
+ command = self.modifie_mc)
+ self.b_sup = Button(self.frame3,
+ text = "Supprimer",
+ disabledforeground = 'grey35',
+ state='disabled',
+ command = self.supprime_mc)
+ self.b_quit = Button(self.frame3,
+ text = "Fermer",
+ command = self.quit)
+ #self.b_mod.place(relx=0.25,rely=0.5,anchor='center')
+ #self.b_sup.place(relx=0.50,rely=0.5,anchor='center')
+ #self.b_quit.place(relx=0.75,rely=0.5,anchor='center')
+ self.b_quit.place(relx=0.50,rely=0.5,anchor='center')
+
def wait_new_list(self):
"""
- Cette méthode rend cette toplevel bloquante.
- Dès que la variable var_quit est modifiée, on continue l'exécution de cette
- méthode (et on quitte)
- """
- self.fenetre.wait_variable(self.var_quit)
- self.fenetre.destroy()
- return self.new_l_mc
-
+ Cette méthode rend cette toplevel bloquante.
+ Dès que la variable var_quit est modifiée, on continue l'exécution de cette
+ méthode (et on quitte)
+ """
+ self.fenetre.wait_variable(self.var_quit)
+ self.fenetre.destroy()
+ return self.new_l_mc
+
def get_path(self,l_o):
"""
- Construit la chaîne de caractère contenant le chemin d'accès complet du mot-clé
- """
- txt = ''
- for o in l_o :
- txt = txt + o.nom+'/'
- # on enlève le dernier slash en trop
- txt = txt[0:-1]
- return txt
+ Construit la chaîne de caractère contenant le chemin d'accès complet du mot-clé
+ """
+ txt = ''
+ for o in l_o :
+ txt = txt + o.nom+'/'
+ # on enlève le dernier slash en trop
+ txt = txt[0:-1]
+ return txt
def select_mc(self,mc,entry):
"""
- Enregistre le mot-clé passé en argument comme mot-clé courant
- Active les boutons Modifier et Supprimer
- """
- self.desactive_entry()
- self.mc_courant = mc
- self.entry_courante = entry
- self.active_boutons()
- self.active_entry()
+ Enregistre le mot-clé passé en argument comme mot-clé courant
+ Active les boutons Modifier et Supprimer
+ """
+ self.desactive_entry()
+ self.mc_courant = mc
+ self.entry_courante = entry
+ self.active_boutons()
+ self.active_entry()
def modifie_mc(self):
"""
- Modifie le nom du mot-clé en prenant la nouvelle valeur lue dans entry_courante
- """
- new_nom_mc = self.entry_courante.get()
- index = self.l_mc.index(self.mc_courant)
- new_mc = self.new_l_mc[index]
- new_mc[-2] = new_nom_mc
- objet_pere = self.mc_courant[-3]
-
- self.desactive_boutons()
- self.desactive_entry()
+ Modifie le nom du mot-clé en prenant la nouvelle valeur lue dans entry_courante
+ """
+ new_nom_mc = self.entry_courante.get()
+ index = self.l_mc.index(self.mc_courant)
+ new_mc = self.new_l_mc[index]
+ new_mc[-2] = new_nom_mc
+ objet_pere = self.mc_courant[-3]
+
+ self.desactive_boutons()
+ self.desactive_entry()
def supprime_mc(self):
"""
- Supprime le mot-clé courant de la liste
- """
- index = self.l_mc.index(self.mc_courant)
- self.new_l_mc[index] = None
+ Supprime le mot-clé courant de la liste
+ """
+ index = self.l_mc.index(self.mc_courant)
+ self.new_l_mc[index] = None
e,lab=self.widgets[index]
e.grid_remove()
lab.grid_remove()
- self.desactive_boutons()
- self.desactive_entry()
-
+ self.desactive_boutons()
+ self.desactive_entry()
+
def desactive_boutons(self):
"""
- Désactive les boutons Modifier et Supprimer
- """
- self.b_mod.configure(state='disabled')
- self.b_sup.configure(state='disabled')
-
+ Désactive les boutons Modifier et Supprimer
+ """
+ self.b_mod.configure(state='disabled')
+ self.b_sup.configure(state='disabled')
+
def active_boutons(self):
"""
- Active les boutons Modifier et Supprimer
- """
- self.b_mod.configure(state='normal')
- self.b_sup.configure(state='normal')
+ Active les boutons Modifier et Supprimer
+ """
+ self.b_mod.configure(state='normal')
+ self.b_sup.configure(state='normal')
def desactive_entry(self):
"""
- Désactive l'entry courante si elle existe
- """
- if self.entry_courante :
- self.entry_courante.configure(state='disabled',relief='flat')
-
+ Désactive l'entry courante si elle existe
+ """
+ if self.entry_courante :
+ self.entry_courante.configure(state='disabled',relief='flat')
+
def active_entry(self):
"""
- Active l'entry courante si elle existe
- """
- if self.entry_courante :
- self.entry_courante.configure(state='normal',relief='sunken')
-
+ Active l'entry courante si elle existe
+ """
+ if self.entry_courante :
+ self.entry_courante.configure(state='normal',relief='sunken')
+
def quit(self):
"""
- Permet de fermer la fenêtre
- """
- self.var_quit.set(1)
+ Permet de fermer la fenêtre
+ """
+ self.var_quit.set(1)
if __name__ == '__main__':
fenetre_mc_inconnus(('toto','titi'))
"""
genea=self.node.item.get_genealogie()
if "VALE" in genea:
- self.nb_valeurs=2
+ self.nb_valeurs=2
if "VALE_C" in genea:
- self.nb_valeurs=3
+ self.nb_valeurs=3
# On récupère la bulle d'aide du panneau, l'objet, l'aide,min et max (cardinalité de la liste),
# et la liste des valeurs déjà affectées à l'objet courant
bulle_aide=self.get_bulle_aide()
text = aide,
justify='center',
anchor='center',
- wraplength=int(self.frame_aide.winfo_width()*0.8))
+ wraplength=int(self.frame_aide.winfo_width()*0.8))
self.aide.place(relx=0.5,rely=0.5,anchor='center',relwidth=1)
self.Liste_valeurs.affiche_liste()
# boutons Accepter et Annuler
l_valeurs=[]
l1_valeurs = self.Liste_valeurs.get_liste()
for val in l1_valeurs :
- for item in val :
- l_valeurs.append(item)
+ for item in val :
+ l_valeurs.append(item)
self.accepte_modifs_valeur(min,max,l_valeurs)
doublevaleur_entree=doublevaleur_entree[1:-1]
if doublevaleur_entree[-1]==')' :
doublevaleur_entree=doublevaleur_entree[0:-2]
- val1=doublevaleur_entree.split(',')[0]
- val2=doublevaleur_entree.split(',')[1]
+ val1=doublevaleur_entree.split(',')[0]
+ val2=doublevaleur_entree.split(',')[1]
saisie=(val1,val2)
if (self.nb_valeurs==3):
- val3=doublevaleur_entree.split(',')[2]
+ val3=doublevaleur_entree.split(',')[2]
saisie=(val1,val2,val3)
self.entry.delete(0,END)
except :
commentaire = "%s n est pas un tuple de la forme (x,y)" %`doublevaleur_entree`
if (self.nb_valeurs==3):
- commentaire = "%s n est pas un tuple de la forme (x,y,z)" %`doublevaleur_entree`
+ commentaire = "%s n est pas un tuple de la forme (x,y,z)" %`doublevaleur_entree`
self.parent.appli.affiche_infos(commentaire)
return
# et seulement d un tuple
try:
- val=doublevaleur_entree.split(',')[self.nb_valeurs]
+ val=doublevaleur_entree.split(',')[self.nb_valeurs]
commentaire = "%s n est pas un tuple de la forme (x,y)" %`doublevaleur_entree`
if (self.nb_valeurs==3):
- commentaire = "%s n est pas un tuple de la forme (x,y,z)" %`doublevaleur_entree`
+ commentaire = "%s n est pas un tuple de la forme (x,y,z)" %`doublevaleur_entree`
self.parent.appli.affiche_infos(commentaire)
self.parent.appli.affiche_infos(commentaire)
return
except :
# c est la le cas normal
- pass
+ pass
# on verifie la validite des valeurs sont correctes
valeur,validite=self.node.item.eval_valeur(saisie)
if not validite :
commentaire = "impossible d'évaluer : %s " %`doublevaleur_entree`
self.parent.appli.affiche_infos(commentaire)
- return
+ return
# on verifie la validite de la liste
liste=[]
l1_valeurs = self.Liste_valeurs.get_liste()
for val in l1_valeurs :
- for item in val :
- liste.append(item)
+ for item in val :
+ liste.append(item)
validite_liste=self.node.item.valide_liste_partielle(valeur[0],liste)
if not validite_liste:
commentaire = "impossible d'ajouter %s a la liste " %`doublevaleur_entree`
self.parent.appli.affiche_infos(commentaire)
- return
+ return
# liste a deja ete modifiee par l appel precedent a valide_liste_partielle
# et contient deja valeur[0]
validite_liste=self.node.item.valide_liste_partielle(valeur[1],liste)
if not validite_liste:
commentaire = "impossible d'ajouter %s a la liste " %`doublevaleur_entree`
self.parent.appli.affiche_infos(commentaire)
- return
+ return
# si une valeur est selectionnee on insere apres
# sinon on ajoute la valeur à la fin
try:
affiche="("
separe=""
- for val in valeur:
- affiche=affiche+separe+str(val)
- separe=","
+ for val in valeur:
+ affiche=affiche+separe+str(val)
+ separe=","
affiche=affiche+")"
self.entry.delete(0,END)
- self.entry.insert(0,affiche)
+ self.entry.insert(0,affiche)
except :
- self.entry.delete(0,END)
+ self.entry.delete(0,END)
# Surcharge de select in file pour prendre en compte la saisie de tuple
def select_in_file(self):
item=self.appli.noeud_a_editer.item
self.appli.noeud_a_editer.delete()
child.item.update(item)
- #test,mess = child.item.nomme_sd(nom)
+ #test,mess = child.item.nomme_sd(nom)
child.select()
# on rend la copie à nouveau possible en libérant le flag edit
self.appli.edit="copier"
self.traite_liste()
def init_Fichier(self):
- index=0
+ index=0
+ try :
+ f=open(self.monFichier)
+ while ( index < 5) :
+ ligne=f.readline()
+ if ligne != "" :
+ l=(ligne.split("\n"))[0]
+ self.liste_Fichiers.append(l)
+ index=index+1
+ except :
+ pass
try :
- f=open(self.monFichier)
- while ( index < 5) :
- ligne=f.readline()
- if ligne != "" :
- l=(ligne.split("\n"))[0]
- self.liste_Fichiers.append(l)
- index=index+1
- except :
- pass
- try :
- f.close()
- except :
- pass
+ f.close()
+ except :
+ pass
def sauve_Fichier(self):
try :
- if len(self.liste_Fichiers) == 0 :
- return
- f=open(self.monFichier,'w')
- index=0
- while ( index < len(self.liste_Fichiers)):
- ligne=self.liste_Fichiers[index]+"\n"
- f.write(ligne)
- index=index+1
- except :
- pass
- try :
- f.close()
- except :
- pass
+ if len(self.liste_Fichiers) == 0 :
+ return
+ f=open(self.monFichier,'w')
+ index=0
+ while ( index < len(self.liste_Fichiers)):
+ ligne=self.liste_Fichiers[index]+"\n"
+ f.write(ligne)
+ index=index+1
+ except :
+ pass
+ try :
+ f.close()
+ except :
+ pass
def traite_liste(self):
index=0
- for index in range(self.nbfich):
+ for index in range(self.nbfich):
self.menuFichier.delete(9)
- self.nbfich = 0
- index = 0
- while( index < len(self.liste_Fichiers)) :
- self.ajout_item(index)
- index=index+1
-
+ self.nbfich = 0
+ index = 0
+ while( index < len(self.liste_Fichiers)) :
+ self.ajout_item(index)
+ index=index+1
+
def ajout_item(self,index):
if self.premiere and (len(self.liste_Fichiers)!=0):
- self.premiere=0
- self.menuFichier.add_separator()
- label=self.liste_Fichiers[index]
+ self.premiere=0
+ self.menuFichier.add_separator()
+ label=self.liste_Fichiers[index]
self.menuFichier.insert_command(8,label=label,command= lambda self=self, l=label:self.coucou (l));
- self.nbfich=self.nbfich+1
+ self.nbfich=self.nbfich+1
def coucou(self,label):
self.appli.bureau.openJDC(file=label)
def aOuvert(self,file):
if file not in self.liste_Fichiers :
- if (len(self.liste_Fichiers) > 4) :
- f=self.liste_Fichiers[0]
- self.liste_Fichiers.remove(f)
- self.liste_Fichiers.insert(len(self.liste_Fichiers),file)
- else:
- self.liste_Fichiers.remove(file)
- self.liste_Fichiers.insert(len(self.liste_Fichiers),file)
- self.traite_liste()
- self.sauve_Fichier()
+ if (len(self.liste_Fichiers) > 4) :
+ f=self.liste_Fichiers[0]
+ self.liste_Fichiers.remove(f)
+ self.liste_Fichiers.insert(len(self.liste_Fichiers),file)
+ else:
+ self.liste_Fichiers.remove(file)
+ self.liste_Fichiers.insert(len(self.liste_Fichiers),file)
+ self.traite_liste()
+ self.sauve_Fichier()
def traite_liste(self):
for file in os.listdir(self.rep_patrons):
- for i in range(len(sous_menu)):
- clef=sous_menu[i].keys()[0]
- chaine=sous_menu[i][clef]
- if re.search(chaine,file) :
- if clef in self.liste.keys():
- self.liste[clef].append(file)
- else :
- self.liste[clef]=[file]
- break
+ for i in range(len(sous_menu)):
+ clef=sous_menu[i].keys()[0]
+ chaine=sous_menu[i][clef]
+ if re.search(chaine,file) :
+ if clef in self.liste.keys():
+ self.liste[clef].append(file)
+ else :
+ self.liste[clef]=[file]
+ break
def ajout_menu(self):
menuFichier=self.appli.menubar.menubar
- menu_cascade=Tkinter.Menu(menuFichier,tearoff=0)
- menuFichier.add_cascade(label="Patrons",menu=menu_cascade)
+ menu_cascade=Tkinter.Menu(menuFichier,tearoff=0)
+ menuFichier.add_cascade(label="Patrons",menu=menu_cascade)
for ss_menu in self.liste.keys():
- ssmenu=Tkinter.Menu(menu_cascade,tearoff=0)
- menu_cascade.add_cascade(label=ss_menu,menu=ssmenu)
- for fichier in self.liste[ss_menu]:
+ ssmenu=Tkinter.Menu(menu_cascade,tearoff=0)
+ menu_cascade.add_cascade(label=ss_menu,menu=ssmenu)
+ for fichier in self.liste[ss_menu]:
ssmenu.add_command(label=fichier,command= lambda self=self, l=fichier:self.ouvre(l));
def ouvre(self,label):
def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
"""
Enregistre val comme valeur de self.node.item.object
- en evaluant l item et en le validant
+ en evaluant l item et en le validant
Si name n'est pas renseigné, la valeur
"""
if self.parent.modified == 'n' : self.parent.init_modif()
if valeurentree == '': valeurentree=None
valeur,validite=self.node.item.eval_valeur(valeurentree)
if not validite :
- valeur= self.entry.get()
- commentaire = "impossible d'évaluer : %s " %`valeurentree`
- self.parent.appli.affiche_infos(commentaire)
-
+ valeur= self.entry.get()
+ commentaire = "impossible d'évaluer : %s " %`valeurentree`
+ self.parent.appli.affiche_infos(commentaire)
+
if validite :
if self.node.item.is_list() :
validite=self.node.item.valide_liste_complete(valeur)
commentaire=self.node.item.info_erreur_liste()
else :
- validite=self.node.item.valide_item(valeur)
+ validite=self.node.item.valide_item(valeur)
commentaire=self.node.item.info_erreur_item()
if validite :
if not self.parent.appli.dict_reels.has_key(clefobj):
self.parent.appli.dict_reels[clefobj] = {}
self.parent.appli.dict_reels[clefobj][clef]=texte_valeur
- self.parent.appli.dict_reels[clefobj]
+ self.parent.appli.dict_reels[clefobj]
self.node.item.object.fin_modif()
except:
pass
("Affichage commandes",(("alphabétique",'&affichage_alpha'),("groupes",'&affichage_grp'))),
#("Couleur",(("fond",'change_fond'),("barre",'change_barre'))),
# ("Catalogue développeur",'choix_cata_developpeur'),
- ('Paramètres Eficas','affichage_fichier_ini'),
-
+ ('Paramètres Eficas','affichage_fichier_ini'),
+
]
)
]
affichage_commandes="groupes"
if hasattr(panels,'panneauCommande'):
panel=panels.panneauCommande
- parent=panel.parent
- if parent != None :
- parent.create_panel(parent.node_selected)
- # si on a un panel avec plusieurs onglets
- # on affiche Commande
- try :
- parent.panel_courant.nb.selectpage("Commande")
- except :
- pass
+ parent=panel.parent
+ if parent != None :
+ parent.create_panel(parent.node_selected)
+ # si on a un panel avec plusieurs onglets
+ # on affiche Commande
+ try :
+ parent.panel_courant.nb.selectpage("Commande")
+ except :
+ pass
def affichage_alpha(self):
affichage_commandes="alphabetic"
if hasattr(panels,'panneauCommande'):
panel=panels.panneauCommande
- parent=panel.parent
- if parent != None :
- parent.create_panel(parent.node_selected)
- # si on a un panel avec plusieurs onglets
- # on affiche Commande
- try :
- parent.panel_courant.nb.selectpage("Commande")
- except :
- pass
+ parent=panel.parent
+ if parent != None :
+ parent.create_panel(parent.node_selected)
+ # si on a un panel avec plusieurs onglets
+ # on affiche Commande
+ try :
+ parent.panel_courant.nb.selectpage("Commande")
+ except :
+ pass
def change_fond(self):
from tkColorChooser import askcolor
# On termine la suppression de facon brutale (objets Tk et non Tk)
for k in self.__dict__.keys():
# il est plus prudent de ne pas détruire le lien sur le Node
- # si on voulait mettre l'attribut node à None, il faudrait
- # que tous les appels à node.parent.select() apparaissent après
- # toutes les autres actions liées au panel (node.item.isglobal(), ...)
+ # si on voulait mettre l'attribut node à None, il faudrait
+ # que tous les appels à node.parent.select() apparaissent après
+ # toutes les autres actions liées au panel (node.item.isglobal(), ...)
if k != 'node' : setattr(self,k,None)
def creer_boutons(self):
def commande_up(self,num):
#print "commande_up de panels pour ", num
try :
- OngletPanel.panelbind.selectpage(num)
+ OngletPanel.panelbind.selectpage(num)
pageNew=OngletPanel.panelbind.page(num)
pageNew.focus_set()
except :
- pass
+ pass
def affiche(self):
page=self.nb.getcurselection()
self.nb.page(page).focus_set()
if page == 'Concept':
try:
-# _any est un pointeur sur entry
-# component est une methode de pmw
-# a priori, jamais ok
+# _any est un pointeur sur entry
+# component est une methode de pmw
+# a priori, jamais ok
self._any.component('entry').focus_set()
except:
pass
def add_eval_valeur_sans_into(self,valeurentree=None):
if valeurentree == None:
- valeurentree = self.get_valeur()
+ valeurentree = self.get_valeur()
valeur,validite=self.node.item.eval_valeur(valeurentree)
if not validite :
commentaire = "impossible d'évaluer : %s " %`valeurentree`
text = aide,
justify='center',
anchor='center',
- wraplength=int(self.frame_aide.winfo_width()*0.8))
+ wraplength=int(self.frame_aide.winfo_width()*0.8))
self.aide.place(relx=0.5,rely=0.5,anchor='center',relwidth=1)
self.Liste_valeurs.affiche_liste()
if len(l_valeurs) > 0 :
liste_marque=l_valeurs[-1]
self.Liste_valeurs.surligne(liste_marque)
- self.selectValeur(liste_marque)
+ self.selectValeur(liste_marque)
# boutons Accepter et Annuler
bouton_accepter = Button(self.frame_boutons,
text='Valider',
def affiche_parametre(self) :
if self.node.item.get_liste_param_possible() != [ ]:
txtparam=""
- for param in self.node.item.get_liste_param_possible():
- txtparam=txtparam+repr(param)+"\n"
- if txtparam=="":
- showerror("Aucun parametre ","Pas de parametre de ce type")
- else :
- try :
- self.self.fenetreparam.destroy()
- except:
- pass
- self.fenetreparam=FenetreDeParametre( self, self.node.item, self.parent.appli, txtparam)
+ for param in self.node.item.get_liste_param_possible():
+ txtparam=txtparam+repr(param)+"\n"
+ if txtparam=="":
+ showerror("Aucun parametre ","Pas de parametre de ce type")
+ else :
+ try :
+ self.self.fenetreparam.destroy()
+ except:
+ pass
+ self.fenetreparam=FenetreDeParametre( self, self.node.item, self.parent.appli, txtparam)
def valid_valeur(self):
self.add_valeur_plusieurs_base()
atraiter=[]
if type(valeur) in (types.ListType,types.TupleType) :
- indice = 0
+ indice = 0
while (indice < len(valeur)):
- v=valeur[indice]
- if self.node.item.wait_complex :
- if (v== 'RI' or v == 'MP'):
- try :
- t=tuple([v,valeur[indice+1],valeur[indice+2]])
- atraiter.append(t)
- indice=indice+3
- except :
- validite=0
- commentaire = "Veuillez entrer le complexe sous forme aster ou sous forme python"
- self.parent.appli.affiche_infos(commentaire)
- return
- else : # ce n'est pas un tuple à la mode aster
- atraiter.append(v)
- indice = indice + 1
+ v=valeur[indice]
+ if self.node.item.wait_complex :
+ if (v== 'RI' or v == 'MP'):
+ try :
+ t=tuple([v,valeur[indice+1],valeur[indice+2]])
+ atraiter.append(t)
+ indice=indice+3
+ except :
+ validite=0
+ commentaire = "Veuillez entrer le complexe sous forme aster ou sous forme python"
+ self.parent.appli.affiche_infos(commentaire)
+ return
+ else : # ce n'est pas un tuple à la mode aster
+ atraiter.append(v)
+ indice = indice + 1
else: # on n'attend pas un complexe
- atraiter.append(v)
- indice=indice+1
+ atraiter.append(v)
+ indice=indice+1
else:
- atraiter.append(valeur)
+ atraiter.append(valeur)
for valeur in atraiter :
encorevalide=self.node.item.valide_item(valeur)
- # qdsjfkllllllllllllllllll
+ # qdsjfkllllllllllllllllll
if encorevalide :
listecourante=self.Liste_valeurs.get_liste()
encorevalide=self.node.item.valide_liste_partielle(valeur,listecourante)
selection_texte = f.read()
f.close()
self.ajout_valeurs = FenetreDeSelection(self,
- self.node.item,
- self.parent.appli,
- titre="Sélection de valeurs",
- texte=selection_texte)
+ self.node.item,
+ self.parent.appli,
+ titre="Sélection de valeurs",
+ texte=selection_texte)
except:
traceback.print_exc()
showinfo("Erreur de fichier","impossible d'ouvir le fichier "+nom_fichier)
#else:
# self.entry = Entry(frame,relief='sunken')
# self.entry.place(relx=0.28,rely=0.2,relwidth=0.6)
- # self.entry.place(relx=0.28,rely=y,relwidth=0.6)
+ # self.entry.place(relx=0.28,rely=y,relwidth=0.6)
# self.entry.bind("<Return>",lambda e,c=command:c())
# self.entry.bind("<KP_Enter>",lambda e,c=command:c())
# self.entry.focus()
if hasattr(self,'entry'):
# Traitement d'une entree unique
valeurentree = self.entry.get()
- if (valeurentree == None or valeurentree ==""):
- return None,0,""
- if (valeurentree[0] != "(") and (valeurentree.find(',') < len(valeurentree)):
- valeurs=[]
- for v in valeurentree.split(','):
- vsimple,validite=self.node.item.eval_valeur(v)
- # Pn If ajoute pour le panneau "double"
- #if isinstance(vsimple,LASSD) :
- # commentaire = "impossible de mélanger reels et liste prédéfinie"
- # validite = 0
- # break
- if validite :
- valeurs.append(vsimple)
- else:
- commentaire = "impossible d'évaluer : %s " %`valeurentree`
- break
- valeur=valeurs
+ if (valeurentree == None or valeurentree ==""):
+ return None,0,""
+ if (valeurentree[0] != "(") and (valeurentree.find(',') < len(valeurentree)):
+ valeurs=[]
+ for v in valeurentree.split(','):
+ vsimple,validite=self.node.item.eval_valeur(v)
+ # Pn If ajoute pour le panneau "double"
+ #if isinstance(vsimple,LASSD) :
+ # commentaire = "impossible de mélanger reels et liste prédéfinie"
+ # validite = 0
+ # break
+ if validite :
+ valeurs.append(vsimple)
+ else:
+ commentaire = "impossible d'évaluer : %s " %`valeurentree`
+ break
+ valeur=valeurs
else:
valeur,validite=self.node.item.eval_valeur(valeurentree)
if not validite and commentaire == "":
liste_noms_sd = self.tri(liste_noms_sd)
self.listbox = Pmw.ScrolledListBox(self.frame_haut,
items=liste_noms_sd,
- labelpos='n',
- #label_text="Structures de données du type\n requis parl'objet courant :",
- label_text="Listes du type\n requis parl'objet courant :",
- listbox_height = 6,
- dblclickcommand=lambda s=self,c=UNIQUE_ASSD_Panel.valid_valeur : s.choose_valeur_from_list(c))
+ labelpos='n',
+ #label_text="Structures de données du type\n requis parl'objet courant :",
+ label_text="Listes du type\n requis parl'objet courant :",
+ listbox_height = 6,
+ dblclickcommand=lambda s=self,c=UNIQUE_ASSD_Panel.valid_valeur : s.choose_valeur_from_list(c))
self.listbox.place(relx=0.00,rely=0.00,relwidth=0.4)
# On eneleve le label pour gagner de la place
self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs,
liste_commandes = liste_commandes_valeurs,
titre="Valeur(s) non-prédéfinies(s)",
- fonte_titre=None
- )
+ fonte_titre=None
+ )
for fram in (self.frame1,self.frame2,self.frame_bas,self.frame_haut,self.frame_valeurs,
self.frame_fleches,self.frame_choix):
a=(3+8j)
d_types = { 'TXM' : type('A'),
'R' : type(3.),
- 'I' : type(0),
- 'C' : type(a)}
+ 'I' : type(0),
+ 'C' : type(a)}
# On enleve seulement ceux qu'on peut
# Sur certaines listes, il est possible qu'on ne
typecherche = None
for t in typespossibles:
if t in d_types.keys() :
- typecherche = d_types[t]
- break
+ typecherche = d_types[t]
+ break
for liste in liste_noms_sd:
valeur,validite=self.node.item.eval_valeur(liste)
- for mc in valeur.etape.mc_liste :
- try :
- if type(mc.valeur) in (types.ListType,types.TupleType) :
- typeliste=type(mc.valeur[0])
- else :
- typeliste=type(mc.valeur)
- if type(mc.valeur[0]) == typecherche:
- listefinale.append(liste)
- except:
- listefinale.append(liste)
+ for mc in valeur.etape.mc_liste :
+ try :
+ if type(mc.valeur) in (types.ListType,types.TupleType) :
+ typeliste=type(mc.valeur[0])
+ else :
+ typeliste=type(mc.valeur)
+ if type(mc.valeur[0]) == typecherche:
+ listefinale.append(liste)
+ except:
+ listefinale.append(liste)
return listefinale
text = aide,
justify='center',
anchor='center')
- #wraplength=int(self.frame_aide.winfo_width()*0.8))
+ #wraplength=int(self.frame_aide.winfo_width()*0.8))
self.aide.place(relx=0.3,rely=0.5,anchor='center',relwidth=1)
def get_aide(self):
'C' : 'complexes'}
type = mc.type[0]
if not d_aides.has_key(type) :
- if mc.min == mc.max:
- return str(mc.min)+" valeur(s) est(sont) attendue(s)"
+ if mc.min == mc.max:
+ return str(mc.min)+" valeur(s) est(sont) attendue(s)"
else :
- return "entrez entre "+str(mc.min)+" et "+str(mc.max)+" valeurs"
+ return "entrez entre "+str(mc.min)+" et "+str(mc.max)+" valeurs"
if mc.min == mc.max:
- commentaire="Une liste de "+str(mc.min)+" "+d_aides[type]+" est attendue"
+ commentaire="Une liste de "+str(mc.min)+" "+d_aides[type]+" est attendue"
else :
- commentaire="Entre "+str(mc.min)+" et "+str(mc.max)+" valeurs de type "+d_aides[type]+" sont attendues"
+ commentaire="Entre "+str(mc.min)+" et "+str(mc.max)+" valeurs de type "+d_aides[type]+" sont attendues"
aideval=self.node.item.aide()
commentaire=commentaire + "\n" + aideval
return commentaire
else :
testtype = self.node.item.object.verif_type(valeur)
if not testtype :
- if valeur.__class__.__name__ in ( 'PARAMETRE', 'ITEM_PARAMETRE') :
- testtype = 1
- else :
+ if valeur.__class__.__name__ in ( 'PARAMETRE', 'ITEM_PARAMETRE') :
+ testtype = 1
+ else :
commentaire ="Type de la valeur incorrecte"
encorevalide=-2
-
+
if (encorevalide ==0) :
commentaire=self.node.item.info_erreur_item()
if (encorevalide == -1) :
commentaire=self.node.item.info_erreur_liste()
- # On traite le cas ou la liste n est pas valide pour un pb de cardinalite
+ # On traite le cas ou la liste n est pas valide pour un pb de cardinalite
min,max = self.node.item.GetMinMax()
if len(self.Liste_valeurs.get_liste()) >= max :
commentaire="La liste a déjà atteint le nombre maximum d'éléments,ajout refusé"
text='',
justify='left',
relief='sunken',
- height=2,
+ height=2,
bg='gray95')
self.label.pack(side='left',expand=1,fill='both')
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.30 2005/12/07 10:20:33 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.30.6.1 2006/03/07 11:21:44 eficas Exp $"
#
Fonte_Standard = fontes.standard
if self.displayed == 1 : self.dehighlight()
def make_visible(self):
- """ Rend l'objet self visible cad déplace le scroll pour que self soit dans
- la fenêtre de visu
+ """ Rend l'objet self visible cad déplace le scroll pour que self
+ soit dans la fenêtre de visu
"""
lchild=self.last_child()
self.tree.see((self.image_id,lchild.image_id))
def select_next(self,ind=0):
""" on doit chercher à sélectionner dans l'ordre:
- - son premier fils s'il est affiché
- - son frère cadet s'il existe
- - son oncle (benjamin de son père)
- - ... appel récursif ...
+ - son premier fils s'il est affiché
+ - son frère cadet s'il existe
+ - son oncle (benjamin de son père)
+ - ... appel récursif ...
"""
if self.state=='expanded' and len(self.children) > ind:
self.children[ind].select()
except:
self.children[0].select()
except :
- if self.parent is self.tree:
- pass
- else :
- self.parent.select_next(index)
+ if self.parent is self.tree:
+ pass
+ else :
+ self.parent.select_next(index)
def select_mot_prev(self):
index = self.parent.children.index(self) - 1
if (min == 1 and min == max and len(liste_noms_sd)==1 ):
if self.valeur_choisie.get() != liste_noms_sd[0]:
if ('R' not in self.node.item.get_type()) :
- self.valeur_choisie.set(liste_noms_sd[0])
+ self.valeur_choisie.set(liste_noms_sd[0])
self.valid_valeur_automatique()
-
+
self.frame_valeur = Frame(page)
self.frame_valeur.pack(fill='both',expand=1)
self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
self.display_valeur()
if self.__class__.__name__ == 'UNIQUE_ASSD_Panel_Reel' :
Label(self.frame_valeur,text='Valeur Réelle').place(relx=0.1,rely=0.9)
- self.entry = Entry(self.frame_valeur,relief='sunken')
+ self.entry = Entry(self.frame_valeur,relief='sunken')
self.entry.place(relx=0.28,rely=0.9,relwidth=0.6)
self.entry.bind("<Return>",lambda e,c=self.valid_valeur_reel:c())
self.entry.bind("<KP_Enter>",lambda e,c=self.valid_valeur_reel:c())
"""
mc = self.node.item.get_definition()
try :
- type = mc.type[0].__name__
+ type = mc.type[0].__name__
except :
type = str(mc.type[0])
if len(mc.type)>1 :
for typ in mc.type[1:] :
- try :
- l=typ.__name__
- except:
- l=str(typ)
+ try :
+ l=typ.__name__
+ except:
+ l=str(typ)
type = type + ' ou '+l
commentaire="Un objet de type "+type+" est attendu"
aideval=self.node.item.aide()
self.frame_valeur.update()
self.aide = Label(self.frame_valeur,
text = aide,
- wraplength=int(self.frame_valeur.winfo_width()*0.8),
- justify='center')
+ wraplength=int(self.frame_valeur.winfo_width()*0.8),
+ justify='center')
self.aide.place(relx=0.5,rely=0.7,anchor='n')
# bouton parametre
bouton_parametres = Button(self.frame_valeur, text="Parametres", command=self.affiche_parametre)
def affiche_parametre(self) :
if self.node.item.get_liste_param_possible() != [ ]:
- txtparam=""
- for param in self.node.item.get_liste_param_possible():
- txtparam=txtparam+repr(param)+"\n"
- if txtparam=="":
- showerror("Aucun parametre ","Pas de parametre de ce type")
- else :
- try :
- self.fenetreparam.destroy()
- except :
- pass
- self.fenetreparam=FenetreDeParametre( self, self.node.item, self.parent.appli, txtparam)
+ txtparam=""
+ for param in self.node.item.get_liste_param_possible():
+ txtparam=txtparam+repr(param)+"\n"
+ if txtparam=="":
+ showerror("Aucun parametre ","Pas de parametre de ce type")
+ else :
+ try :
+ self.fenetreparam.destroy()
+ except :
+ pass
+ self.fenetreparam=FenetreDeParametre( self, self.node.item, self.parent.appli, txtparam)
def destroy(self):
try :
- self.fenetreparam.destroy()
+ self.fenetreparam.destroy()
except :
- pass
+ pass
Widget.destroy(self)
def get_aide(self):
self.aide = Label(self.frame_valeur,
text = aide,
wraplength=int(self.frame_valeur.winfo_width()*0.8),
- justify='center')
+ justify='center')
self.aide.place(relx=0.5,rely=0.9,anchor='n')
# affichage de la valeur du MCS
self.display_valeur()
l.append(string.atof(self.entry1.get()))
l.append(string.atof(self.entry2.get()))
except :
- return None
+ return None
return `tuple(l)`
def erase_valeur(self):
self.frame_valeur.update()
self.aide = Label(self.frame_valeur,
text = aide,
- wraplength=int(self.frame_valeur.winfo_width()*0.8),
- justify='center')
+ wraplength=int(self.frame_valeur.winfo_width()*0.8),
+ justify='center')
self.aide.place(relx=0.5,rely=0.85,anchor='n')
# affichage de la valeur courante
self.display_valeur()
self.but_save.place(relx=0.6,rely=0.5,anchor='center')
# affichage du texte
self.affiche_texte(self.texte)
- self.zone_texte.config(state=DISABLED)
+ self.zone_texte.config(state=DISABLED)
centerwindow(self.fenetre)
self.fenetre.deiconify()
def destroy(self):
try :
- self.fenetre.destroy()
- except :
- pass
+ self.fenetre.destroy()
+ except :
+ pass
class FenetreYesNo(Fenetre):
def __init__(self,appli,titre="",texte="",yes="Yes",no="No"):
"""
def __init__(self,panel,item,appli,titre="",texte="",cardinal=1):
Fenetre.__init__(self,appli,titre=titre,texte=texte)
- self.frame_boutons.place_forget()
+ self.frame_boutons.place_forget()
self.frame_texte.place_forget()
self.frame_texte.place(relx=0,rely=0,relwidth=1,relheight=0.8)
self.frame_boutons.place(relheight=0.2,relx=0,rely=0.8,relwidth=1.)
# Replacement
self.but_quit.place_forget()
self.but_save.place_forget()
- self.but_all = Button(self.frame_boutons,text = "Tout Sélectionner", command=self.tout)
+ self.but_all = Button(self.frame_boutons,text = "Tout Sélectionner", command=self.tout)
self.but_save.place(relx=0.6,rely=0.6,anchor='center')
self.but_quit.place(relx=0.8,rely=0.6,anchor='center')
self.but_all.place(relx=0.7,rely=0.2,anchor='center')
- self.choose_separateur('espace')
+ self.choose_separateur('espace')
def get_separateurs_autorises(self):
def tout(self):
liste=[]
- texte=self.texte.splitlines()
- for l in texte :
- for mot in string.split(l,self.separateur):
- if mot != '' and mot != ' ' and mot != self.separateur :
- liste.append(mot)
- self.traite_selection(liste)
+ texte=self.texte.splitlines()
+ for l in texte :
+ for mot in string.split(l,self.separateur):
+ if mot != '' and mot != ' ' and mot != self.separateur :
+ liste.append(mot)
+ self.traite_selection(liste)
def traite_selection(self,liste=None):
""" Cette méthode effectue tous les traitements nécessaires pour vérifier
et affecter la liste de valeurs à l'objet réprésenté par self.item
"""
# Récupère la liste des chaines de caractères de la zone sélectionnée
- message=""
- if liste == None:
+ message=""
+ if liste == None:
message,liste = self.recupere_liste()
if self.test_probleme(message,"Sélectionnez des données") == 0:
return
éléments dans le type voulu en cas de succès, sinon retourne None.
"""
liste_valeurs = []
- message = ""
+ message = ""
for chaine in liste:
if f_conversion:
try:
self.affiche_texte(self.texte)
self.zone_texte.config(state="disabled")
- # définition des boutons
- self.frame_boutons = Frame(self.fenetre)
- self.frame_boutons.place(relheight=0.3,relx=0,rely=0.65,relwidth=1.)
- self.label1 = Label(self.frame_boutons,text="surligner la")
- self.label2 = Label(self.frame_boutons,text="ligne entière")
- self.label1.place(relx=0.1,rely=0)
- self.label2.place(relx=0.1,rely=0.5)
- self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit)
- self.but_save = Button(self.frame_boutons,text = "Choisir",command = self.Choisir)
- self.but_save.place(relx=0.6,rely=0,relheight=1)
- self.but_quit.place(relx=0.8,rely=0,relheight=1)
+ # définition des boutons
+ self.frame_boutons = Frame(self.fenetre)
+ self.frame_boutons.place(relheight=0.3,relx=0,rely=0.65,relwidth=1.)
+ self.label1 = Label(self.frame_boutons,text="surligner la")
+ self.label2 = Label(self.frame_boutons,text="ligne entière")
+ self.label1.place(relx=0.1,rely=0)
+ self.label2.place(relx=0.1,rely=0.5)
+ self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit)
+ self.but_save = Button(self.frame_boutons,text = "Choisir",command = self.Choisir)
+ self.but_save.place(relx=0.6,rely=0,relheight=1)
+ self.but_quit.place(relx=0.8,rely=0,relheight=1)
def Choisir(self):
"Selectionner un parametre")
l_param = ""
for param in selection.splitlines():
- nomparam=param[0:param.find("=")-1]
+ nomparam=param[0:param.find("=")-1]
if nomparam != '' :
- l_param=l_param+nomparam+','
- self.parent.entry.delete(0,Tkinter.END)
- self.parent.entry.insert(0,l_param[0:-1])
- self.parent.valid_valeur()
- self.quit()
+ l_param=l_param+nomparam+','
+ self.parent.entry.delete(0,Tkinter.END)
+ self.parent.entry.insert(0,l_param[0:-1])
+ self.parent.valid_valeur()
+ self.quit()
class Formulaire:
"""
if len(item[0])>length_maxi : length_maxi = len(item[0])
window = self.fenetre.interior()
for item in self.items :
- if len(item) == 4 :
+ if len(item) == 4 :
label,nature,nom_var,defaut = item
- chaine="Yes"
- chaine2="No"
- else :
+ chaine="Yes"
+ chaine2="No"
+ else :
label,nature,nom_var,defaut,chaine,chaine2 = item
# création de la frame
fr_item = Frame(window,height=40,width=700)
self.titre = titre
self.filtre = filtre
self.optionReturn = optionReturn
- self.fonte_titre=fonte_titre
+ self.fonte_titre=fonte_titre
self.init()
def init(self):
mot="("
premier=1
for val in objet:
- if (not premier):
- mot=mot+","
+ if (not premier):
+ mot=mot+","
else:
premier=0
valtexte = self.parent.get_valeur_texte(val)
try:
self.dico_labels[self.arg_selected].configure(bg='gray95',fg='black')
self.arg_selected = ''
- except :
- pass
+ except :
+ pass
def surligne(self,marque):
try :
- self.highlightitem(self.dico_labels[marque])
+ self.highlightitem(self.dico_labels[marque])
self.arg_selected = marque
- except:
- pass
+ except:
+ pass
def chooseitemsurligne(self,mot,label,commande):
""" Active la méthode de choix passée en argument"""
def selectNextItem(self,mot,label):
index=self.liste.index(mot)
indexsuivant=index+1
- if indexsuivant > len(self.liste) -1:
- indexsuivant=0
+ if indexsuivant > len(self.liste) -1:
+ indexsuivant=0
motsuivant=self.liste[indexsuivant]
labelsuivant=self.dico_labels[motsuivant]
#index = self.MCbox.index(labelsuivant)
self.dontselect=1
def selectthis(self,mot,label,commande) :
- self.clear_marque()
+ self.clear_marque()
if self.selection != None :
self.deselectitem(self.selection[1],self.selection[0],self.selection[2],)
self.highlightitem(label)
return lign
def remove_selected_item(self):
- try :
+ try :
index=self.MCbox.index(self.selection[1])
- except :
+ except :
index=self.MCbox.index(self.dico_labels[self.arg_selected] )
lign,col=map(int,string.split(index,'.'))
del self.liste[lign-1]
for val in self.liste:
# try:
# v = eval(val)
-# l.append(v)
+# l.append(v)
# except:
l.append(val)
return l
