"""
if not corps :
corps = self.corps
- if not arguments :
- arguments = self.arguments
+ if not arguments :
+ arguments = self.arguments
formule=(self.get_nom(),self.type_retourne,arguments,corps)
# on récupère la liste des constantes et des autres fonctions prédéfinies
# et qui peuvent être utilisées dans le corps de la formule courante
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,
- sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
- utilisé dans le corps de la fonction
+ sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
+ utilisé dans le corps de la fonction
"""
self.init_modif()
"""
Lance la vérification du corps de formule présent dans entry_exp
"""
- new_nom = self.entry_nom.get()
+ new_nom = self.entry_nom.get()
new_typ = self.option_menu_typ.getcurselection()
new_arg = self.entry_arg.get()
new_exp = self.entry_exp.get()
"""
Lance la vérification de FORMULE passée en argument
"""
- return self.object.verif_formule(formule=formule)
+ return self.object.verif_formule(formule=formule)
import Accas
treeitem =FORMULETreeItem
Pour installer EFICAS a partir de la distribution : <nom_distrib>.tgz
faire :
- tar xzvf <nom_distrib>.tgz
+ tar xzvf <nom_distrib>.tgz
ce qui a pour effet de créer un répertoire de nom <nom_distrib>.
2- Utilisation d'Eficas
Pour utiliser Eficas, aller dans le répertoire Aster et faire :
- python eficas_aster.py
+ python eficas_aster.py
#('ASTER','v8',os.path.join(rep_cata,'cataSTA8'),'python','defaut'),
('ASTER','v8.2',os.path.join(rep_cata,'cataSTA81'),'python','defaut'),
#('ASTER','v75',os.path.join(rep_cata,'cataSTA75'),'python','defaut'),
- ('HOMARD','v1',os.path.join(rep_homard,'homard_cata_V73.py'),'homard'),
+ ('HOMARD','v1',os.path.join(rep_homard,'homard_cata_V73.py'),'homard'),
)
for file in `cat ./Batch/${version}/aTester`
do
#echo $file
- grep "VISU_EFICAS='NON'" $file > /dev/null 2>/dev/null
- rc=$?
- if [ "$rc" != "0" ]
- then
- grep INCLUDE $file | grep -v "#" | grep -v INCLUDE_MATERIAU > /dev/null 2>/dev/null
- rc=$?
- if [ "$rc" != "0" ]
- then
- cr=`./test_eficas.py $file`
- if [ "${cr}" == "" ]
- then
- echo $file >> ./Batch/${version}/bad_${passe}
- else
- nomfeuille=`basename $file`
- boncr="DEBUT CR validation : "${nomfeuille}" FIN CR validation :"${nomfeuille}
- cr=`echo $cr`
- if [ "${cr}" != "$boncr" ]
- then
- echo $file >> ./Batch/${version}/bad_${passe}
- echo $cr >>./Batch/${version}/bad_${passe}
- echo $file >>./Batch/${version}/badfile_${passe}
- else
- echo $file >> ./Batch/${version}/ok_${passe}
- fi
- fi
- else
- echo $file >> ./Batch/${version}/nt_${passe}
- fi
- else
- echo $file >> ./Batch/${version}/nt_${passe}
- fi
+ grep "VISU_EFICAS='NON'" $file > /dev/null 2>/dev/null
+ rc=$?
+ if [ "$rc" != "0" ]
+ then
+ grep INCLUDE $file | grep -v "#" | grep -v INCLUDE_MATERIAU > /dev/null 2>/dev/null
+ rc=$?
+ if [ "$rc" != "0" ]
+ then
+ cr=`./test_eficas.py $file`
+ if [ "${cr}" == "" ]
+ then
+ echo $file >> ./Batch/${version}/bad_${passe}
+ else
+ nomfeuille=`basename $file`
+ boncr="DEBUT CR validation : "${nomfeuille}" FIN CR validation :"${nomfeuille}
+ cr=`echo $cr`
+ if [ "${cr}" != "$boncr" ]
+ then
+ echo $file >> ./Batch/${version}/bad_${passe}
+ echo $cr >>./Batch/${version}/bad_${passe}
+ echo $file >>./Batch/${version}/badfile_${passe}
+ else
+ echo $file >> ./Batch/${version}/ok_${passe}
+ fi
+ fi
+ else
+ echo $file >> ./Batch/${version}/nt_${passe}
+ fi
+ else
+ echo $file >> ./Batch/${version}/nt_${passe}
+ fi
done
# 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
from Noyau.N_CR import CR
#
-__Id__="$Id: analyse_catalogue.py,v 1.3 2002/09/10 15:59:37 eficas Exp $"
+__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=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):
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):
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)
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
# une fonction portant son nom
# Exemple de particularisation d un panel :
# Supposons que l on veuille particulariser la commande
-# - LIRE_MAILLAGE_UNITE
+# - LIRE_MAILLAGE_UNITE
# le panel initial a pour classe UNIQUE_BASE_Panel
# il suffit d'ajouter dans la classe derivée SALOME_UNIQUE_BASE_Panel
# une fonction SALOME_LIRE_MAILLAGE_UNITE
class SALOME_SHELLPanel (SHELLPanel):
- ""
+ ""
class SALOME_FONCTION_Panel (FONCTION_Panel):
- ""
+ ""
class SALOME_PLUSIEURS_INTO_Panel (PLUSIEURS_INTO_Panel):
- ""
+ ""
class SALOME_PLUSIEURS_ASSD_Panel (PLUSIEURS_ASSD_Panel):
- ""
+ ""
class SALOME_UNIQUE_INTO_Panel (UNIQUE_INTO_Panel):
- ""
+ ""
class SALOME_UNIQUE_SDCO_Panel (UNIQUE_SDCO_Panel):
- ""
+ ""
class SALOME_UNIQUE_ASSD_Panel (UNIQUE_ASSD_Panel):
- ""
+ ""
class SALOME_UNIQUE_COMP_Panel (UNIQUE_COMP_Panel):
- ""
+ ""
class SALOME_UNIQUE_ASSD_Panel_Reel (UNIQUE_ASSD_Panel_Reel):
- ""
+ ""
# ------------------------------------------------------------------------------#
# classe SALOME_PLUSIEURS_BASE_Panel
#
# Commandes modifiées :
-# - AFFE_CHAR_MECA_DDL_IMPO_GROUP_NO
+# - AFFE_CHAR_MECA_DDL_IMPO_GROUP_NO
# Methodes surchargées :
-# - makeValeurPage(self,page)
+# - makeValeurPage(self,page)
#
# ------------------------------------------------------------------------------#
class SALOME_PLUSIEURS_BASE_OR_UNELISTE_Panel(PLUSIEURS_BASE_OR_UNELISTE_Panel):
- ""
+ ""
newr=[]
#try:
if ( 1 == 1 ) :
- for entree in liste_in :
- travail=[]
- travail.append(entree)
- entryname_list=SMESH_utils.entryToName(salome.myStudy,travail)
+ for entree in liste_in :
+ travail=[]
+ travail.append(entree)
+ entryname_list=SMESH_utils.entryToName(salome.myStudy,travail)
entreeName=entryname_list[0]
- if dict_geom_numgroupe.has_key(entreeName):
- r=dict_geom_numgroupe[entreeName]
- else:
+ if dict_geom_numgroupe.has_key(entreeName):
+ r=dict_geom_numgroupe[entreeName]
+ else:
r=SMESH_utils.getAsterGroupNo(salome.myStudy,travail)
- dict_geom_numgroupe[entreeName]=r
+ dict_geom_numgroupe[entreeName]=r
for i in r :
newr.append(i)
#except:
else :
- print "pas de groupe de noeuds associé"
- showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de noeuds")
+ print "pas de groupe de noeuds associé"
+ showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de noeuds")
return newr
def convertit_group_maille_from_salome(self,liste_in):
#try:
if [ 1 == 1 ]:
print liste_in
- for entree in liste_in :
- travail=[]
- travail.append(entree)
- entryname_list=SMESH_utils.entryToName(salome.myStudy,travail)
+ for entree in liste_in :
+ travail=[]
+ travail.append(entree)
+ entryname_list=SMESH_utils.entryToName(salome.myStudy,travail)
entreeName=entryname_list[0]
- if dict_geom_numgroupe.has_key(entreeName):
- r=dict_geom_numgroupe[entreeName]
- else:
+ if dict_geom_numgroupe.has_key(entreeName):
+ r=dict_geom_numgroupe[entreeName]
+ else:
r=SMESH_utils.getAsterGroupMa(salome.myStudy,travail)
- dict_geom_numgroupe[entreeName]=r
- if r != None :
+ dict_geom_numgroupe[entreeName]=r
+ if r != None :
for i in r :
newr.append(i)
#except:
else :
- print "pas de groupe de maille associé"
- showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de maille")
+ print "pas de groupe de maille associé"
+ showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de maille")
return newr
def convertit_entrees_en_valeurs(self,entrychaine):
print 'CS_pbruno BBBBBBBBBBBBBBBBBBB'
if (self.clef_fonction.find("GROUP_NO") < self.clef_fonction.find("GROUP_MA")) :
print 'CS_pbruno CCCCCCCCCCCCCCCCCCCCCCCCCC'
- valeur=self.convertit_group_maille_from_salome(entrychaine)
- else :
+ valeur=self.convertit_group_maille_from_salome(entrychaine)
+ else :
print 'CS_pbruno DDDDDDDDDDDDDDDDDDDDDDDDD'
- valeur=self.convertit_group_no_from_salome(entrychaine)
- elif self.clef_fonction.find("GROUP_NO") != -1 :
+ valeur=self.convertit_group_no_from_salome(entrychaine)
+ elif self.clef_fonction.find("GROUP_NO") != -1 :
print 'CS_pbruno EEEEEEEEEEEEEEEEEEEEEEEEE'
- valeur=self.convertit_group_no_from_salome(entrychaine)
- else :
+ valeur=self.convertit_group_no_from_salome(entrychaine)
+ else :
print 'CS_pbruno FFFFFFFFFFFFFFFFFFFFFFFF'
- if self.clef_fonction.find("GROUP_MA") != -1 :
+ if self.clef_fonction.find("GROUP_MA") != -1 :
print 'CS_pbruno GGGGGGGGGGGGGGGGGGGGGGGGGGG'
- valeur=self.convertit_group_maille_from_salome(entrychaine)
- else :
+ valeur=self.convertit_group_maille_from_salome(entrychaine)
+ else :
print 'CS_pbruno HHHHHHHHHHHHHHHHHHHHHH'
- print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
- print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster"
- print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+ print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+ print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster"
+ print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
valeur=[]
print "VALEUR", valeur
return valeur
valeur = self.convertit_entrees_en_valeurs(entrychaine)
for i in valeur :
if i in liste_valeurs :
- liste_valeurs.remove(i)
+ liste_valeurs.remove(i)
print "enleve" , i
except:
# la valeur sélectionnée n'est pas dans la liste
self.sortie.delete(0,END)
for entryname in entryname_list:
try:
- liste_valeurs_salome.remove(entryname)
- except:
- print "la valeur ", entryname, "n est pas dans la liste"
- entryname=entryname + " "
+ liste_valeurs_salome.remove(entryname)
+ except:
+ print "la valeur ", entryname, "n est pas dans la liste"
+ entryname=entryname + " "
self.sortie.insert(0,entryname)
self.selected_valeur = None
self.Liste_valeurs.put_liste(liste_valeurs)
groups={}
liste_valeurs = self.Liste_valeurs.get_liste()
for valeur in liste_valeurs_salome:
- r=dict_geom_numgroupe[valeur]
+ r=dict_geom_numgroupe[valeur]
for i in r :
if i not in liste_valeurs :
- liste_valeurs.append(i)
+ liste_valeurs.append(i)
self.Liste_valeurs.put_liste(liste_valeurs)
liste_valeurs = self.Liste_valeurs.get_liste()
for i in touteslesvaleurs:
if i not in liste_valeurs:
- valeur.append(i)
-
+ valeur.append(i)
+
if valeur==[]:
- entryname_list=[]
+ entryname_list=[]
liste_valeurs_salome = self.Liste_valeurs_salome.get_liste()
- for entryname in entryname_list:
- if entryname not in liste_valeurs_salome:
+ for entryname in entryname_list:
+ if entryname not in liste_valeurs_salome:
liste_valeurs_salome.append(entryname)
- entryname=entryname + " "
+ entryname=entryname + " "
self.entrygroupe.insert(0,entryname)
self.Liste_valeurs_salome.put_liste(liste_valeurs_salome)
("<Button-3>",self.deselectValeur),
("<Double-Button-1>",self.sup_valeur_sans_into))
self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs,
- liste_commandes = liste_commandes_valeurs,
+ liste_commandes = liste_commandes_valeurs,
titre="Valeur(s) actuelle(s)")
# PN : pour ajouter les validators
l_salome_valeurs=self.node.item.get_salome_valeurs()
self.Liste_valeurs_salome=ListeChoix(self,self.frame_valeurs_salome,l_salome_valeurs,
- liste_commandes = liste_commandes_valeurs,
- titre="Valeur(s) Salome actuelle(s) ")
+ liste_commandes = liste_commandes_valeurs,
+ titre="Valeur(s) Salome actuelle(s) ")
self.Liste_valeurs_salome.affiche_liste()
# classe SALOME_UNIQUE_BASE_Panel
#
# Commandes modifiées :
-# - LIRE_MAILLAGE_UNITE
+# - LIRE_MAILLAGE_UNITE
# Methodes surchargées :
-# - makeValeurPage(self,page)
+# - makeValeurPage(self,page)
#
# ------------------------------------------------------------------------------#
SO = None
if SO is not None:
- myBuilder = salome.myStudy.NewBuilder()
+ myBuilder = salome.myStudy.NewBuilder()
ok, AtName = myBuilder.FindAttribute(SO,"AttributeName")
- if ok:
- EntryName=AtName.Value()
+ if ok:
+ EntryName=AtName.Value()
if EntryName != '':
self.entry2.insert(0,EntryName)
# unite=self.node.item.get_valeur()
# entrychaine=salome.sg.getAllSelected()
# if entrychaine != '':
-# self.entry2.delete(0,END)
+# self.entry2.delete(0,END)
# try:
# SO = salome.myStudy.FindObjectID(entrychaine[0])
# SO = None
# if SO != None:
-# myBuilder = salome.myStudy.NewBuilder()
+# myBuilder = salome.myStudy.NewBuilder()
# boo,FileAttr = myBuilder.FindAttribute(SO,"AttributeComment")
#
# FileName=''
if SALOME_UNIQUE_BASE_Panel.dict_fichier_unite.has_key(unite):
associe=SALOME_UNIQUE_BASE_Panel.dict_fichier_unite[unite][1:]
- self.entry2.delete(0,END)
- if associe != "" :
+ self.entry2.delete(0,END)
+ if associe != "" :
self.entry2.insert(0,associe)
else:
- self.entry2.delete(0,END)
+ self.entry2.delete(0,END)
# aide associée au panneau
self.frame_valeur.update()
#______________________________________________________________________________________
dict_classes_salome = { SHELLPanel : SALOME_SHELLPanel,
FONCTION_Panel : SALOME_FONCTION_Panel,
- PLUSIEURS_INTO_Panel : SALOME_PLUSIEURS_INTO_Panel,
- PLUSIEURS_ASSD_Panel : SALOME_PLUSIEURS_ASSD_Panel,
- PLUSIEURS_BASE_Panel : SALOME_PLUSIEURS_BASE_Panel,
- PLUSIEURS_BASE_OR_UNELISTE_Panel : SALOME_PLUSIEURS_BASE_OR_UNELISTE_Panel,
- UNIQUE_INTO_Panel : SALOME_UNIQUE_INTO_Panel,
- UNIQUE_SDCO_Panel : SALOME_UNIQUE_SDCO_Panel,
- UNIQUE_ASSD_Panel : SALOME_UNIQUE_ASSD_Panel,
- UNIQUE_ASSD_Panel_Reel : SALOME_UNIQUE_ASSD_Panel_Reel,
- UNIQUE_COMP_Panel : SALOME_UNIQUE_COMP_Panel,
- UNIQUE_BASE_Panel : SALOME_UNIQUE_BASE_Panel}
+ PLUSIEURS_INTO_Panel : SALOME_PLUSIEURS_INTO_Panel,
+ PLUSIEURS_ASSD_Panel : SALOME_PLUSIEURS_ASSD_Panel,
+ PLUSIEURS_BASE_Panel : SALOME_PLUSIEURS_BASE_Panel,
+ PLUSIEURS_BASE_OR_UNELISTE_Panel : SALOME_PLUSIEURS_BASE_OR_UNELISTE_Panel,
+ UNIQUE_INTO_Panel : SALOME_UNIQUE_INTO_Panel,
+ UNIQUE_SDCO_Panel : SALOME_UNIQUE_SDCO_Panel,
+ UNIQUE_ASSD_Panel : SALOME_UNIQUE_ASSD_Panel,
+ UNIQUE_ASSD_Panel_Reel : SALOME_UNIQUE_ASSD_Panel_Reel,
+ UNIQUE_COMP_Panel : SALOME_UNIQUE_COMP_Panel,
+ UNIQUE_BASE_Panel : SALOME_UNIQUE_BASE_Panel}
dict_geom_numgroupe = { }
dict_geom_numface = { }
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é"
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.29 2005/11/29 17:39:50 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.30 2005/12/07 10:20:33 eficas Exp $"
#
Fonte_Standard = fontes.standard
def page_down(self,event):
event.widget.yview_scroll(1, "page")
-
+
def unit_up(self,event):
event.widget.yview_scroll(-1, "unit")
def tag_move_nodes(self,y):
""" Marque pour deplacement tous les noeuds au dela de l'ordonnée y """
- #print "tag_move_nodes",y
+ #print "tag_move_nodes",y
self.canvas.dtag(ALL,'move')
# on marque tous les ids au dela de y
x0, y0, x1, y1 = self.canvas.bbox(ALL)
- if y > y1: # pas d'objet a deplacer
- return
+ if y > y1: # pas d'objet a deplacer
+ return
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 """
- #print "move_nodes",y,dy
- self.tag_move_nodes(y)
+ #print "move_nodes",y,dy
+ self.tag_move_nodes(y)
# on déplace tous les items de dy
self.canvas.move('move',0,dy)
en y et au dela
Retourne la position du premier des noeuds deplaces
"""
- #print "draw_node",new_node,x,y
+ #print "draw_node",new_node,x,y
self.tag_move_nodes(y)
#if new_node.item.isactif():
#new_node.state = 'expanded'
except:
self.children[0].select()
except :
- if self.parent is self.tree:
- pass
- else :
+ 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
- try :
- if index > -1 :
- self.parent.children[index].select()
- if self.parent.children[index].state=="expanded":
- print len(self.parent.children[index].children)
- if len(self.parent.children[index].children)!=0 :
- max=len(self.parent.children[index].children) - 1
- self.parent.children[index].children[max].select()
- else :
- self.parent.children[index].select()
- else :
- self.parent.children[index].select()
- elif self.parent is self.tree:
- pass
- else :
+ try :
+ if index > -1 :
+ self.parent.children[index].select()
+ if self.parent.children[index].state=="expanded":
+ print len(self.parent.children[index].children)
+ if len(self.parent.children[index].children)!=0 :
+ max=len(self.parent.children[index].children) - 1
+ self.parent.children[index].children[max].select()
+ else :
+ self.parent.children[index].select()
+ else :
+ self.parent.children[index].select()
+ elif self.parent is self.tree:
+ pass
+ else :
self.parent.select()
except:
- if self.parent is self.tree:
- pass
- else :
+ if self.parent is self.tree:
+ pass
+ else :
self.parent.select_previous()
try :
if index > -1 :
self.parent.children[index].select()
- elif self.parent is self.tree:
- pass
- else :
+ elif self.parent is self.tree:
+ pass
+ else :
self.parent.select()
except:
- if self.parent is self.tree:
- pass
- else :
+ if self.parent is self.tree:
+ pass
+ else :
self.parent.select_previous()
def select_previous(self):
self.parent.children[index].select()
except:
#self.parent.select()
- if self.parent is self.tree:
- pass
- else :
+ if self.parent is self.tree:
+ pass
+ else :
self.parent.select_previous()
def popup(self,event=None):
def deplieReplieNode(self):
if self.state == 'expanded':
- self.collapse()
- else :
- self.expand_node()
+ self.collapse()
+ else :
+ self.expand_node()
def collapse(self,event = None):
""" Collapse self et descendants et retrace self """
self.icone_id=None
self.label=None
self.text=None
- self.displayed=0
+ self.displayed=0
def efface(self):
""" Efface du canvas les id associés à self : cad les siens et ceux
try:
self.canvas.addtag_overlapping('move',bbox1[0],self.y +10,bbox1[2],bbox1[3])
except:
- print "Erreur dans move :"
+ print "Erreur dans move :"
print self
print self.item
print self.item.getObject()
try:
child.trace_ligne()
except:
- print "Erreur dans trace_ligne :"
+ print "Erreur dans trace_ligne :"
print child
print child.item.getObject()
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
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
- --> sans objet pour les commandes commentarisées
+ avant étape, sinon enlève la référence à ces concepts
+ --> sans objet pour les commandes commentarisées
"""
pass
-
+
def control_sdprods(self,d):
"""sans objet pour les commandes commentarisées"""
pass
texte = reste
return operateur,reste
elif texte[0] == '-':
- # Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
- try :
- args,reste = self.cherche_args(texte[1:])
- except InterpreteurException,e:
+ # Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
+ try :
+ args,reste = self.cherche_args(texte[1:])
+ except InterpreteurException,e:
raise InterpreteurException,str(e)
- if not args :
- # Il ne s'agit pas de '-' comme opérateur unaire --> on retourne None
- return None,texte
- else:
- identificateur = '-'
- args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
+ if not args :
+ # Il ne s'agit pas de '-' comme opérateur unaire --> on retourne None
+ return None,texte
+ else:
+ identificateur = '-'
+ args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
formule_operateur = (identificateur,'',self.t_formule[2],args)
operateur = Interpreteur_Formule(formule = formule_operateur,
constantes = self.new_constantes,
# retour = self.valeur * other
# except :
# try :
-# retour = eval(self.valeur) * eval(other)
-# except :
-# try :
-# retour = self.valeur * eval(other)
-# except :
-# print other
+# retour = eval(self.valeur) * eval(other)
+# except :
+# try :
+# retour = self.valeur * eval(other)
+# except :
+# print other
# print "******* Probleme : a la multiplication _mul__"
# return retour
#
# retour = self.valeur * other
# except :
# try :
-# retour = eval(self.valeur) * eval(other)
-# except :
+# retour = eval(self.valeur) * eval(other)
+# except :
# print "******* Probleme : a la multiplication __rmul__"
# return retour
#
# retour = eval(self.valeur) / other
# except :
# try :
-# retour = self.valeur / other
+# retour = self.valeur / other
# except :
-# print "******* Probleme : a la division"
+# print "******* Probleme : a la division"
# return retour
#
#
# def cos(self):
# try :
-# retour=cos(self.valeur)
+# retour=cos(self.valeur)
# return retour
# except:
# print "pb pour cosinus"
#
# def sin(self):
# try :
-# retour=sin(self.valeur)
+# retour=sin(self.valeur)
# return retour
# except:
# print "pb pour sinus"
#
# def tan(self):
# try :
-# retour=tan(self.valeur)
+# retour=tan(self.valeur)
# return retour
# except:
# print "pb pour tangente"
#
# def log(self):
# try :
-# retour=log(self.valeur)
+# retour=log(self.valeur)
# return retour
# except:
# print "pb pour log"
#
# def sqrt(self):
# try :
-# retour=sqrt(self.valeur)
+# retour=sqrt(self.valeur)
# return retour
# except:
# print "pb pour sqrt"
return val
l_new_val.append(v)
return tuple(l_new_val)
- # PN : commente le print
+ # PN : commente le print
#else:
# on a réussi à évaluer val en autre chose qu'un tuple ...
#print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
if type(valeur).__name__ == 'list':
self.dict_valeur=[]
for i in range(len(valeur)):
- self.dict_valeur.append(valeur[i])
+ self.dict_valeur.append(valeur[i])
return val
def get_valeurs(self):
if self.item < 0:
isvalid = 0
try:
- longueur= len(self.param_pere.dict_valeur) - 1
+ longueur= len(self.param_pere.dict_valeur) - 1
except:
longueur=0
if self.item > longueur :
# Cas particulier des opérateurs obligatoirement réentrants
#
if self.definition.reentrant == 'o':
- self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
+ self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
if self.sd != None :
self.sdnom=self.sd.nom
self.fin_modif()
if self.definition.reentrant == 'f' :
sd = self.jdc.get_sd_avant_etape(nom,self)
if sd != None :
- # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
- if isinstance(sd,self.get_type_produit()) :
+ # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
+ if isinstance(sd,self.get_type_produit()) :
self.sd = self.reuse = sd
self.sdnom = sd.nom
self.fin_modif()
return 1,"Opérateur facultativement réentrant et concept existant trouvé"
- else:
- return 0,"Concept déjà existant et de mauvais type"
+ else:
+ return 0,"Concept déjà existant et de mauvais type"
else :
# il faut enlever le lien vers une SD existante car si on passe ici
- # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
- # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
- if self.reuse :
+ # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
+ # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
+ if self.reuse :
old_reuse=self.reuse
- self.sd = self.reuse = self.sdnom = None
+ self.sd = self.reuse = self.sdnom = None
#
# On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
# mais est utilisé en mode non réentrant
old_nom=self.sd.nom
if string.find(old_nom,'sansnom') :
# Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
- # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
- # on peut donc le nommer sans test préalable
+ # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
+ # on peut donc le nommer sans test préalable
if self.parent.get_sd_autour_etape(nom,self):
return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
else:
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
- self.sd.nom=nom
+ self.sd.nom=nom
self.sdnom=nom
self.parent.update_concept_after_etape(self,self.sd)
self.fin_modif()
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
+ avant étape, sinon enlève la référence à ces concepts
"""
#print "verif_existence_sd",self.sd
for motcle in self.mc_liste :
if len(self.mc_liste) == 0:
# pas de fils pour self --> la FORMULE est incomplète
return None,None,None
- type_retourne="REEL"
+ type_retourne="REEL"
if len(self.mc_liste) > 0:
child = self.mc_liste[0] # child est un MCSIMP
corps = child.getval()
- else:
- corps = None
+ else:
+ corps = None
if len(self.mc_liste) > 1:
- child = self.mc_liste[1]
+ child = self.mc_liste[1]
l_args= child.getval()
- else :
- l_args=None
+ else :
+ l_args=None
return type_retourne,l_args,corps
def get_nom(self):
#for argument in l_arguments:
# argument = string.strip(argument)
# try:
- # nom=argument
+ # nom=argument
# typ,nom = string.split(argument,':')
# #pas de vérification sur le nom de l'argument
# #vérification du type de l'argument
"""
if not corps :
corps = self.corps
- if not arguments :
- arguments = self.arguments
+ if not arguments :
+ arguments = self.arguments
formule=(self.get_nom(),self.type_retourne,arguments,corps)
# on récupère la liste des constantes et des autres fonctions prédéfinies
# et qui peuvent être utilisées dans le corps de la formule courante
return 0,"Pas de nom donné à la FORMULE"
if len(nom) > 8 :
return 0,"Un nom de FORMULE ne peut dépasser 8 caractères"
- if nom[0] > "0" and nom[0] < "9" :
- return 0,"Un nom de FORMULE ne peut pas commencer par un chiffre"
+ if nom[0] > "0" and nom[0] < "9" :
+ return 0,"Un nom de FORMULE ne peut pas commencer par un chiffre"
sd = self.parent.get_sd_autour_etape(nom,self)
if sd :
return 0,"Un concept de nom %s existe déjà !" %nom
def verif_formule_python(self,formule=None):
"""
- Pour l instant ne fait qu un compile python
- il serait possible d ajouter des tests sur les arguments
- ou le type retourne mais ...
- """
+ Pour l instant ne fait qu un compile python
+ il serait possible d ajouter des tests sur les arguments
+ ou le type retourne mais ...
+ """
if not formule :
formule = (None,None,None,None)
test_nom,erreur_nom = self.verif_nom(formule[0])
else:
args = None
test_arguments,erreur_arguments = self.verif_arguments(args)
- corps=formule[3]
- erreur_formule= ''
- test_formule=1
- try :
- compile(corps,'<string>','eval')
- except :
- erreur_formule= "le corps de la formule n'est pas une formule python valide"
- test_formule=0
+ corps=formule[3]
+ erreur_formule= ''
+ test_formule=1
+ try :
+ compile(corps,'<string>','eval')
+ except :
+ erreur_formule= "le corps de la formule n'est pas une formule python valide"
+ test_formule=0
erreur = ''
test = test_nom*test_arguments*test_formule
if not test :
self.build_mc()
self.mc_liste=[]
if len(formule) < 4 :
- return O
+ return O
arguments=formule[3]
- if arguments[0] == '(' :
- arguments=[1,-1 ]
- if arguments[-1] == '(' :
- arguments=[0,-2 ]
- self.arguments=tuple(arguments.split(','))
+ if arguments[0] == '(' :
+ arguments=[1,-1 ]
+ if arguments[-1] == '(' :
+ arguments=[0,-2 ]
+ self.arguments=tuple(arguments.split(','))
- i=1
- for k,v in self.definition.entites.items():
- child=self.definition.entites[k](None,nom=k,parent=self)
- new_valeur=formule[i+1]
- if i+1 == 3 :
- child.valeur = self.arguments
- else :
- child.valeur = new_valeur
- child.state = 'modified'
- self.mc_liste.append(child)
- i=i+1
-
+ i=1
+ for k,v in self.definition.entites.items():
+ child=self.definition.entites[k](None,nom=k,parent=self)
+ new_valeur=formule[i+1]
+ if i+1 == 3 :
+ child.valeur = self.arguments
+ else :
+ child.valeur = new_valeur
+ child.state = 'modified'
+ self.mc_liste.append(child)
+ i=i+1
+
self.corps = formule[2]
self.type_retourne = formule[1]
- sd = self.get_sd_prod()
+ sd = self.get_sd_prod()
if sd:
sd.nom = formule[0]
self.init_modif()
- return 1
+ return 1
def active(self):
"""
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,
- sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
- utilisé dans le corps de la fonction
+ sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
+ utilisé dans le corps de la fonction
"""
self.init_modif()
def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
"""
Retourne la liste des concepts avant etape d'1 type de base acceptable
- Attention different de la routine précédente : 1 seul type passé en parametre
- Teste sur issubclass et par sur le type permis
+ Attention different de la routine précédente : 1 seul type passé en parametre
+ Teste sur issubclass et par sur le type permis
"""
d=self.get_contexte_avant(etape)
l=[]
d=self.get_contexte_avant(etape)
for k,v in d.items():
if issubclass(v.__class__,LASSD):
- if k == valeur :
- return k
- # Attention pour enlever les . a la fin des pretendus reels
- if k == valeur[0:-1] :
- return v
+ if k == valeur :
+ return k
+ # Attention pour enlever les . a la fin des pretendus reels
+ if k == valeur[0:-1] :
+ return v
return None
def est_permis(self,v,types_permis):
objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
self.etapes.insert(pos,objet)
- # il faut vérifier que les concepts utilisés par objet existent bien
- # à ce niveau d'arborescence
- objet.verif_existence_sd()
+ # il faut vérifier que les concepts utilisés par objet existent bien
+ # à ce niveau d'arborescence
+ objet.verif_existence_sd()
objet.update_mc_global()
self.active_etapes()
self.editmode=0
l_mc = []
for etape in self.etapes :
if etape.isactif() :
- if not etape.isvalid() :
- l = etape.get_liste_mc_inconnus()
- if l : l_mc.extend(l)
+ if not etape.isvalid() :
+ l = etape.get_liste_mc_inconnus()
+ if l : l_mc.extend(l)
return l_mc
def get_genealogie(self):
else :
# dans ce cas on est en mode copie d'un motcle
objet = name
- # Appel de la methode qui fait le menage dans les references
- # sur les concepts produits (verification que les concepts existent
- # dans le contexte de la commande courante).
- objet.verif_existence_sd()
+ # Appel de la methode qui fait le menage dans les references
+ # sur les concepts produits (verification que les concepts existent
+ # dans le contexte de la commande courante).
+ objet.verif_existence_sd()
# On verifie que l'ajout d'objet est autorise
if self.ispermis(objet) == 0:
self.jdc.send_message("L'objet %s ne peut être un fils de %s" %(objet.nom,
- self.nom))
+ self.nom))
self.fin_modif()
return 0
# on normalize l'objet
objet=objet.normalize()
# Le mot cle n'existe pas encore. On l'ajoute a la position
- # demandee (pos)
+ # demandee (pos)
if pos == None :
self.mc_liste.append(objet)
else :
l_mc = []
if self.reste_val != {}:
for k,v in self.reste_val.items() :
- l_mc.append([self,k,v])
+ l_mc.append([self,k,v])
for child in self.mc_liste :
if child.isvalid() : continue
l_child = child.get_liste_mc_inconnus()
for mc in l_child:
- l = [self]
- l.extend(mc)
- l_mc.append(l)
+ l = [self]
+ l.extend(mc)
+ l_mc.append(l)
return l_mc
def deep_update_condition_bloc(self):
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
+ avant étape, sinon enlève la référence à ces concepts
"""
for motcle in self.mc_liste :
motcle.verif_existence_sd()
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
+ avant étape, sinon enlève la référence à ces concepts
"""
for motcle in self.data :
motcle.verif_existence_sd()
#PN
# ajout du elif
elif type(val) == types.InstanceType and val.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
- txt = txt + i*','+ str(val)
+ txt = txt + i*','+ str(val)
else:
txt = txt + i*','+ myrepr.repr(val)
i=1
objet = eval(new_valeur,d)
return objet,1
except Exception:
- itparam=self.cherche_item_parametre(new_valeur)
- if itparam:
- return itparam,1
- try :
- object=eval(new_valeur.valeur,d)
- except :
- pass
+ itparam=self.cherche_item_parametre(new_valeur)
+ if itparam:
+ return itparam,1
+ try :
+ object=eval(new_valeur.valeur,d)
+ except :
+ pass
if CONTEXT.debug : traceback.print_exc()
return None,0
def cherche_item_parametre (self,new_valeur):
try:
- nomparam=new_valeur[0:new_valeur.find("[")]
- indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
- for p in self.jdc.params:
- if p.nom == nomparam :
- if int(indice) < len(p.get_valeurs()):
- itparam=parametre.ITEM_PARAMETRE(p,int(indice))
- return itparam
- return None
- except:
- return None
+ nomparam=new_valeur[0:new_valeur.find("[")]
+ indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
+ for p in self.jdc.params:
+ if p.nom == nomparam :
+ if int(indice) < len(p.get_valeurs()):
+ itparam=parametre.ITEM_PARAMETRE(p,int(indice))
+ return itparam
+ return None
+ except:
+ return None
def update_concept(self,sd):
if type(self.valeur) in (types.ListType,types.TupleType) :
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
+ avant étape, sinon enlève la référence à ces concepts
"""
#print "verif_existence_sd"
# Attention : possible probleme avec include
self.init_modif()
for sd in self.valeur:
if isinstance(sd,ASSD) :
- if sd in l_sd_avant_etape :
- l.append(sd)
- else:
- l.append(sd)
+ if sd in l_sd_avant_etape :
+ l.append(sd)
+ else:
+ l.append(sd)
self.valeur=tuple(l)
self.fin_modif()
else:
if isinstance(self.valeur,ASSD) :
- if self.valeur not in l_sd_avant_etape :
+ if self.valeur not in l_sd_avant_etape :
self.init_modif()
- self.valeur = None
+ self.valeur = None
self.fin_modif()
def get_min_max(self):
self.cr.fatal("None n'est pas une valeur autorisée")
else:
# type,into ...
- #PN ??? je n ose pas y toucher ???
- #if v.__class__.__name__ in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
- if ((issubclass(v.__class__,param2.Formula)) or
- (v.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
- verif_type=self.verif_typeihm(v)
- else:
- verif_type=self.verif_type(val=v,cr=None)
- # cas des tuples avec un ITEM_PARAMETRE
+ #PN ??? je n ose pas y toucher ???
+ #if v.__class__.__name__ in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
+ if ((issubclass(v.__class__,param2.Formula)) or
+ (v.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
+ verif_type=self.verif_typeihm(v)
+ else:
+ verif_type=self.verif_type(val=v,cr=None)
+ # cas des tuples avec un ITEM_PARAMETRE
if verif_type == 0:
if type(v) == types.TupleType :
- new_val=[]
- for i in v:
- if ((issubclass(i.__class__,param2.Formula)) or
- (i.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
- if self.verif_typeihm(val=i,cr=cr) == 0:
- verif_type = 0
- break
- else:
- new_val.append(i)
- if new_val != [] :
- verif_type=self.verif_type(val=new_val,cr=cr)
- else :
- # Cas d une liste de paramétre
- verif_type=self.verif_typeliste(val=v,cr=cr)
- else:
- verif_type=self.verif_type(val=v,cr=cr)
+ new_val=[]
+ for i in v:
+ if ((issubclass(i.__class__,param2.Formula)) or
+ (i.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
+ if self.verif_typeihm(val=i,cr=cr) == 0:
+ verif_type = 0
+ break
+ else:
+ new_val.append(i)
+ if new_val != [] :
+ verif_type=self.verif_type(val=new_val,cr=cr)
+ else :
+ # Cas d une liste de paramétre
+ verif_type=self.verif_typeliste(val=v,cr=cr)
+ else:
+ verif_type=self.verif_type(val=v,cr=cr)
valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
#
# On verifie les validateurs s'il y en a et si necessaire (valid == 1)
valid=0
# fin des validateurs
#
- # cas d un item Parametre
- if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
- valid=self.valeur.isvalid()
- if valid == 0:
+ # cas d un item Parametre
+ if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
+ valid=self.valeur.isvalid()
+ if valid == 0:
if cr == 'oui' :
- self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
+ self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
self.set_valid(valid)
return self.valid
def verif_typeihm(self,val,cr='non'):
try :
val.eval()
- return 1
+ return 1
except :
- pass
+ pass
return self.verif_type(val,cr)
def verif_typeliste(self,val,cr='non') :
verif=0
for v in val :
- verif=verif+self.verif_typeihm(v,cr)
+ verif=verif+self.verif_typeihm(v,cr)
return verif
-
+
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: MakeNomComplet.py,v 1.2 2003/03/07 14:30:48 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: MakeNomComplet.py,v 1.3 2004/09/10 15:52:03 eficas Exp $" )
developpeur.sortie.write( "\n" )
try :
- print basename( "/toto/main.py" )
- print "ERREUR"
+ print basename( "/toto/main.py" )
+ print "ERREUR"
sys.exit(5)
except Exception,e :
print str(e)
- print "OKAY"
+ print "OKAY"
pass
print "FIN NORMALE DE "+__name__
sys.exit(0)
# -*- coding: utf-8 -*-
-# $Header: /home/eficas/CVSROOT/EficasV1/Tools/foztools/foztools.py,v 1.1.1.1 2002/03/26 09:08:47 eficas Exp $
+# $Header: /home/eficas/CVSROOT/EficasV1/Tools/foztools/foztools.py,v 1.2 2004/09/10 15:52:08 eficas Exp $
###########################################################################
# This is a set of Python widgets, built on top of pythonTk. They are
#
###########################################################################
-__version__ = "$Revision: 1.1.1.1 $"
+__version__ = "$Revision: 1.2 $"
import Tkinter
Tk=Tkinter
class Slider:
def __init__(self, master=None, orientation="horizontal", min=0, max=100,
- width=100, height=25, autoLabel="true", appearance="sunken",
- fillColor="blue", background="black", labelColor="yellow",
- labelText="", labelFormat="%d%%", value=50, bd=2):
- # preserve various values
- self.master=master
- self.orientation=orientation
- self.min=min
- self.max=max
- self.width=width
- self.height=height
- self.autoLabel=autoLabel
- self.fillColor=fillColor
- self.labelColor=labelColor
- self.background=background
- self.labelText=labelText
- self.labelFormat=labelFormat
- self.value=value
- self.frame=Tk.Frame(master, relief=appearance, bd=bd)
- self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
- highlightthickness=0, background=background)
- self.scale=self.canvas.create_rectangle(0, 0, width, height,
- fill=fillColor)
- self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
- height / 2, text=labelText,
- anchor="c", fill=labelColor)
- self.update()
- self.canvas.pack(side='top', fill='x', expand='no')
+ width=100, height=25, autoLabel="true", appearance="sunken",
+ fillColor="blue", background="black", labelColor="yellow",
+ labelText="", labelFormat="%d%%", value=50, bd=2):
+ # preserve various values
+ self.master=master
+ self.orientation=orientation
+ self.min=min
+ self.max=max
+ self.width=width
+ self.height=height
+ self.autoLabel=autoLabel
+ self.fillColor=fillColor
+ self.labelColor=labelColor
+ self.background=background
+ self.labelText=labelText
+ self.labelFormat=labelFormat
+ self.value=value
+ self.frame=Tk.Frame(master, relief=appearance, bd=bd)
+ self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
+ highlightthickness=0, background=background)
+ self.scale=self.canvas.create_rectangle(0, 0, width, height,
+ fill=fillColor)
+ self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
+ height / 2, text=labelText,
+ anchor="c", fill=labelColor)
+ self.update()
+ self.canvas.pack(side='top', fill='x', expand='no')
def update(self):
- # Trim the values to be between min and max
- value=self.value
- if value > self.max:
- value = self.max
- if value < self.min:
- value = self.min
- # Preserve the new value
- c=self.canvas
- # Adjust the rectangle
- if self.orientation == "horizontal":
- c.coords(self.scale,
- 0, 0,
- float(value) / self.max * self.width, self.height)
- else:
- c.coords(self.scale,
- 0, self.height - (float(value) / self.max*self.height),
- self.width, self.height)
- # Now update the colors
- c.itemconfig(self.scale, fill=self.fillColor)
- c.itemconfig(self.label, fill=self.labelColor)
- # And update the label
- if self.autoLabel=="true":
- c.itemconfig(self.label, text=self.labelFormat % value)
- else:
- c.itemconfig(self.label, text=self.labelFormat % self.labelText)
- c.update_idletasks()
+ # Trim the values to be between min and max
+ value=self.value
+ if value > self.max:
+ value = self.max
+ if value < self.min:
+ value = self.min
+ # Preserve the new value
+ c=self.canvas
+ # Adjust the rectangle
+ if self.orientation == "horizontal":
+ c.coords(self.scale,
+ 0, 0,
+ float(value) / self.max * self.width, self.height)
+ else:
+ c.coords(self.scale,
+ 0, self.height - (float(value) / self.max*self.height),
+ self.width, self.height)
+ # Now update the colors
+ c.itemconfig(self.scale, fill=self.fillColor)
+ c.itemconfig(self.label, fill=self.labelColor)
+ # And update the label
+ if self.autoLabel=="true":
+ c.itemconfig(self.label, text=self.labelFormat % value)
+ else:
+ c.itemconfig(self.label, text=self.labelFormat % self.labelText)
+ c.update_idletasks()
class Indicator:
def __init__(self, master=None, width=25, height=25, appearance="sunken",
- onColor="green", offColor="black", onLabelColor="black",
- offLabelColor="green", onLabelText="", offLabelText="",
- on=1, bd=2):
- # preserve various values
- self.master=master
- self.onColor=onColor
- self.offColor=offColor
- self.onLabelColor=onLabelColor
- self.offLabelColor=offLabelColor
- self.onLabelText=onLabelText
- self.offLabelText=offLabelText
- self.on=on
- self.frame=Tk.Frame(master, relief=appearance, bd=bd)
- self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
- highlightthickness=0)
- self.light=self.canvas.create_rectangle(0, 0, width, height,
- fill=onLabelColor)
- self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
- height / 2, text=onLabelText,
- anchor="c", fill=onLabelColor)
- self.update()
- self.canvas.pack(side="top", fill='x', expand='no')
+ onColor="green", offColor="black", onLabelColor="black",
+ offLabelColor="green", onLabelText="", offLabelText="",
+ on=1, bd=2):
+ # preserve various values
+ self.master=master
+ self.onColor=onColor
+ self.offColor=offColor
+ self.onLabelColor=onLabelColor
+ self.offLabelColor=offLabelColor
+ self.onLabelText=onLabelText
+ self.offLabelText=offLabelText
+ self.on=on
+ self.frame=Tk.Frame(master, relief=appearance, bd=bd)
+ self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
+ highlightthickness=0)
+ self.light=self.canvas.create_rectangle(0, 0, width, height,
+ fill=onLabelColor)
+ self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
+ height / 2, text=onLabelText,
+ anchor="c", fill=onLabelColor)
+ self.update()
+ self.canvas.pack(side="top", fill='x', expand='no')
def update(self):
- c=self.canvas
- # now update the status
- if self.on:
- c.itemconfig(self.light, fill=self.onColor)
- c.itemconfig(self.label, fill=self.onLabelColor)
- c.itemconfig(self.label, text=self.onLabelText)
- else:
- c.itemconfig(self.light, fill=self.offColor)
- c.itemconfig(self.label, fill=self.offLabelColor)
+ c=self.canvas
+ # now update the status
+ if self.on:
+ c.itemconfig(self.light, fill=self.onColor)
+ c.itemconfig(self.label, fill=self.onLabelColor)
+ c.itemconfig(self.label, text=self.onLabelText)
+ else:
+ c.itemconfig(self.light, fill=self.offColor)
+ c.itemconfig(self.label, fill=self.offLabelColor)
c.itemconfig(self.label, text=self.offLabelText)
- c.update_idletasks()
+ c.update_idletasks()
def toggle(self):
- self.on=not self.on
- self.update()
+ self.on=not self.on
+ self.update()
def turnon(self):
- self.on=1
- self.update()
+ self.on=1
+ self.update()
def turnoff(self):
- self.on=0
- self.update()
+ self.on=0
+ self.update()
class Blinker(Indicator):
def __init__(self, master=None, blinkrate=1, enabled=1, width=25,
- height=25, appearance="sunken", onColor="green",
- offColor="black", onLabelColor="black", offLabelColor="green",
- onLabelText="", offLabelText="", on=1, bd=2):
- self.blinkrate=blinkrate
- self.enabled=enabled
- Indicator.__init__(self, master, width=width, height=height,
- appearance=appearance, onColor=onColor,
- offColor=offColor, onLabelColor=onLabelColor,
- offLabelColor=offLabelColor,
- onLabelText=onLabelText,
- offLabelText=offLabelText, on=on, bd=bd)
+ height=25, appearance="sunken", onColor="green",
+ offColor="black", onLabelColor="black", offLabelColor="green",
+ onLabelText="", offLabelText="", on=1, bd=2):
+ self.blinkrate=blinkrate
+ self.enabled=enabled
+ Indicator.__init__(self, master, width=width, height=height,
+ appearance=appearance, onColor=onColor,
+ offColor=offColor, onLabelColor=onLabelColor,
+ offLabelColor=offLabelColor,
+ onLabelText=onLabelText,
+ offLabelText=offLabelText, on=on, bd=bd)
def update(self):
- if self.enabled:
- self.on=not self.on
+ if self.enabled:
+ self.on=not self.on
Indicator.update(self)
- self.frame.after(self.blinkrate * 1000, self.update)
+ self.frame.after(self.blinkrate * 1000, self.update)
def main():
class Test:
- def __init__(self):
- win = Tk.Frame()
- win.master.title("Slider Demo")
- self.progress1=Slider(win, fillColor="red", labelColor="yellow",
- value=0, width=200, height=15,
- appearance="sunken", autoLabel="false",
- labelFormat="%s",
- labelText="Gary.Foster@corp.sun.com",
- orientation="horizontal", bd=3)
- self.progress2=Slider(win, fillColor="blue", labelColor="black",
- background="white", value=250, width=50,
- height=200, appearance="raised", max=250,
- labelFormat="%d", orientation="vertical", bd=4)
- self.progress1.frame.pack()
- self.progress2.frame.pack()
- win.pack()
- self.progress1.frame.after(1000, self.update)
- self.increment1=1
- self.increment2=-1
+ def __init__(self):
+ win = Tk.Frame()
+ win.master.title("Slider Demo")
+ self.progress1=Slider(win, fillColor="red", labelColor="yellow",
+ value=0, width=200, height=15,
+ appearance="sunken", autoLabel="false",
+ labelFormat="%s",
+ labelText="Gary.Foster@corp.sun.com",
+ orientation="horizontal", bd=3)
+ self.progress2=Slider(win, fillColor="blue", labelColor="black",
+ background="white", value=250, width=50,
+ height=200, appearance="raised", max=250,
+ labelFormat="%d", orientation="vertical", bd=4)
+ self.progress1.frame.pack()
+ self.progress2.frame.pack()
+ win.pack()
+ self.progress1.frame.after(1000, self.update)
+ self.increment1=1
+ self.increment2=-1
- def update(self, event=None):
- bar1=self.progress1
- bar2=self.progress2
+ def update(self, event=None):
+ bar1=self.progress1
+ bar2=self.progress2
- bar1.value=bar1.value+self.increment1
- if bar1.value > bar1.max:
- self.increment1=-1
- bar1.fillColor="green"
- bar1.labelColor="red"
- if bar1.value < bar1.min:
- self.increment1=1
- bar1.fillColor="red"
- bar1.labelColor="yellow"
- bar1.update()
- bar1.frame.after(100, self.update)
+ bar1.value=bar1.value+self.increment1
+ if bar1.value > bar1.max:
+ self.increment1=-1
+ bar1.fillColor="green"
+ bar1.labelColor="red"
+ if bar1.value < bar1.min:
+ self.increment1=1
+ bar1.fillColor="red"
+ bar1.labelColor="yellow"
+ bar1.update()
+ bar1.frame.after(100, self.update)
- bar2.value=bar2.value+self.increment2
- if bar2.value > bar2.max:
- self.increment2=-1
- if bar2.value < bar2.min:
- self.increment2=1
- bar2.update()
+ bar2.value=bar2.value+self.increment2
+ if bar2.value > bar2.max:
+ self.increment2=-1
+ if bar2.value < bar2.min:
+ self.increment2=1
+ bar2.update()
t = Test()
Tk.mainloop()
# -*- coding: utf-8 -*-
"""
- $Id: __init__.py,v 1.4 2003/03/06 14:36:11 eficas Exp $
+ $Id: __init__.py,v 1.5 2004/09/10 15:52:08 eficas Exp $
Le package UTILITES contient les fonctions permettant
d'instrumenter un script :
##__all__ = [ "ici" , "message" , "scrute" , "pause" , "appels" ]
try :
- from developpeur import *
+ from developpeur import *
except :
- pass
+ pass
from ici import *
from execute import *
from pause import *
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: appels.py,v 1.2 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: appels.py,v 1.3 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
for e in trace[2:-1] :
fic,numero,fonc,inst = e
position=fic+":"+str(numero)+":"
- if len(position)>lmax : lmax=len(position)
+ if len(position)>lmax : lmax=len(position)
lmax += 1 # Pour eloigner les informations du nom du fichier
for e in trace[1:-1] :
return
else :
- APPELS = NULL
+ APPELS = NULL
import os
def hostname() :
- return os.uname()[1]
+ return os.uname()[1]
group_eficas=108
group_salome=107
DEVELOPPEUR=d_dev[ os.getuid() ]
import sys
sortie=sys.stderr
- sortie.write( "import de "+__name__+" : $Id: developpeur.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+ sortie.write( "import de "+__name__+" : $Id: developpeur.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
sortie.write( "\n" )
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
if DEVELOPPEUR :
import scrute
import types
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: execute.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: execute.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
developpeur.sortie.flush()
import sys
sortie=sys.stderr
-sortie.write( "import de "+__name__+" : $Id: funcname.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+sortie.write( "import de "+__name__+" : $Id: funcname.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
sortie.write( "\n" )
def get_nombre_de_blancs( str ) :
####print "RECHERCHE de la classe de "+filename+" ligne : ",lineno
if lineno>0 :
try :
- f=open( filename , 'r' )
- except Exception,e :
- print ">>>>",str(e)
- sys.stdout.flush()
- sys.exit(17)
+ f=open( filename , 'r' )
+ except Exception,e :
+ print ">>>>",str(e)
+ sys.stdout.flush()
+ sys.exit(17)
s = f.read()
f.close()
elif re.search( "^class ", line ) != None :
classname = re.sub( "^class *" , "" , line )
classname = re.sub( " *[(:].*$" , "" , classname )
- current_func = ""
+ current_func = ""
elif current_func != "" and re.search( "^[^ \t]", line ) != None :
- current_func = ""
- classname = ""
+ current_func = ""
+ classname = ""
k = k+1
if current_func == "" : current_func="__main__"
return classname ,current_func
def __init__ ( self , *args ) :
- # le premier argument est optionnel (c'est un nom de fonction
+ # le premier argument est optionnel (c'est un nom de fonction
# qu'on peut reconstituer avec le nom du fichier et le numéro de ligne.
k=0
self.name = None
assert(args[k]!=None)
assert(args[k]!="")
- self.filename = args[k] # recuperation du nom du fichier source
+ self.filename = args[k] # recuperation du nom du fichier source
k = k+1
assert(args[k]>0)
- self.lineno = args[k] # recupération du numero de ligne
+ self.lineno = args[k] # recupération du numero de ligne
self.classname,funcname = get_classname( self.filename, self.lineno )
if self.name == None : self.name = funcname
if __name__ == "__main__" :
- print 'FUNCNAME("","funcname.py", 68)='+str(FUNCNAME("","funcname.py", 63) )
- print 'FUNCNAME("funcname.py", 68)='+str(FUNCNAME("funcname.py", 63) )
+ print 'FUNCNAME("","funcname.py", 68)='+str(FUNCNAME("","funcname.py", 63) )
+ print 'FUNCNAME("funcname.py", 68)='+str(FUNCNAME("funcname.py", 63) )
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: ici.py,v 1.2 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: ici.py,v 1.3 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
else :
- ICI = NULL
+ ICI = NULL
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: message.py,v 1.2 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: message.py,v 1.3 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: modification.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: modification.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import ici
une attente.
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: pause.py,v 1.2 2003/03/06 14:36:12 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: pause.py,v 1.3 2004/09/10 15:52:09 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: scrute.py,v 1.2 2003/03/06 14:36:12 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: scrute.py,v 1.3 2004/09/10 15:52:09 eficas Exp $" )
developpeur.sortie.write( "\n" )
import re
import linecache
nom = string.strip(nom)
if valeur[-1] == '\n': valeur = valeur[:-1]
valeur = string.strip(valeur)
- ## traitement des "
- if valeur[0]=='"':
- valeur=valeur[1:-1]
- if valeur[-1]=='"':
- valeur=valeur[0:-2]
+ ## traitement des "
+ if valeur[0]=='"':
+ valeur=valeur[1:-1]
+ if valeur[-1]=='"':
+ valeur=valeur[0:-2]
return nom+' = PARAMETRE(nom=\''+nom+'\',valeur="'+valeur+'")\n\n'
commande_courante = None
else:
#--> poursuite d'une affectation
- # PN -- pour Empecher une erreur pas propre
- if affectation_courante != None :
+ # PN -- pour Empecher une erreur pas propre
+ if affectation_courante != None :
affectation_courante.append_text(ligne)
#affectation_courante.append_text(ligne)
valeur=valeur+texte[nouvelindice]
nouvelindice=nouvelindice+1
if nouvelindice == len(texte) :
- nouvelindice=nouvelindice -1
+ nouvelindice=nouvelindice -1
break
if mot in self.appli.liste_simp_reel:
if valeur[0] != "'":
else :
nouvelindice=nouvelindice+1
if nouvelindice == len(texte) :
- nouvelindice=nouvelindice -1
+ nouvelindice=nouvelindice -1
break
if tuple :
valeur=texte[indiceC+1:nouvelindice+1]
def formate_etape(self,liste):
"""
Enrichissement de la chaine de caracteres representant l'etape (attribut
- texte_etape de l'objet Formatage).
+ texte_etape de l'objet Formatage).
Les elements a ajouter sont dans l'argument liste de la methode.
- L'objet "liste" à traiter a été produit par le module generator. En particulier
- les parenthèses et les virgules ont été produites par ce module
+ L'objet "liste" à traiter a été produit par le module generator. En particulier
+ les parenthèses et les virgules ont été produites par ce module
"""
l_patterns_fin_etape = ( ');' , ');\n' )
l_patterns_fin_mcf = ( ')' , '),' )
self.lmots_clef_calcules = ('SuivFron','TypeBila','ModeHOMA','CCAssoci', 'CCNoChaI','HOMaiN__','HOMaiNP1','CCNumOrI', 'CCNumPTI')
self.lmot_clef = ('CCMaiN__', 'CCNoMN__', 'CCIndica', 'CCSolN__', 'CCFronti', 'CCNoMFro', 'CCMaiNP1',
'CCNoMNP1', 'CCSolNP1', 'TypeRaff', 'TypeDera', 'NiveauMa', 'SeuilHau', 'SeuilHRe',
- 'SeuilHPE', 'NiveauMi', 'SeuilBas', 'SeuilBRe', 'SeuilBPE', 'ListeStd', 'NumeIter',
- 'Langue ', 'CCGroFro', 'CCNoChaI', 'CCNumOrI', 'CCNumPTI', 'SuivFron', 'TypeBila',
- 'ModeHOMA', 'HOMaiN__', 'HOMaiNP1','CCCoChaI')
+ 'SeuilHPE', 'NiveauMi', 'SeuilBas', 'SeuilBRe', 'SeuilBPE', 'ListeStd', 'NumeIter',
+ 'Langue ', 'CCGroFro', 'CCNoChaI', 'CCNumOrI', 'CCNumPTI', 'SuivFron', 'TypeBila',
+ 'ModeHOMA', 'HOMaiN__', 'HOMaiNP1','CCCoChaI')
# Bizarre demander a Gerald :
-# CVSolNP1
+# CVSolNP1
self.assoc['CCMaiN__']='FICHIER_MED_MAILLAGE_N'
self.assoc['CCNoMN__']='NOM_MED_MAILLAGE_N'
self.assoc['CCIndica']='FICHIER_MED_MAILLAGE_N'
b_eval = 0
a_eval=self.dico_mot_depend[mot]
try :
- b_eval=eval(self.dico_mot_depend[mot])
+ b_eval=eval(self.dico_mot_depend[mot])
except :
- for l in a_eval.split(" or "):
+ for l in a_eval.split(" or "):
try:
- b_eval=eval(l)
- if not (b_eval == 0 ):
- break
+ b_eval=eval(l)
+ if not (b_eval == 0 ):
+ break
except :
- pass
+ pass
return b_eval
self.textehomard=[]
for mot in self.lmot_clef:
-# on verifie d'abord que le mot clef doit bien être calculé
+# on verifie d'abord que le mot clef doit bien être calculé
if self.dico_mot_depend.has_key(mot) :
if self.cherche_dependance(mot) == 0 :
- continue
+ continue
if mot not in self.lmots_clef_calcules :
- clef_eficas=self.assoc[mot]
+ clef_eficas=self.assoc[mot]
if self.dico_mot_clef.has_key(clef_eficas):
- val=self.dico_mot_clef[clef_eficas]
+ val=self.dico_mot_clef[clef_eficas]
if val != None:
- try :
- ligne=mot+' '+val
- except:
- ligne=mot+' '+repr(val)
- ligne.rjust(32)
+ try :
+ ligne=mot+' '+val
+ except:
+ ligne=mot+' '+repr(val)
+ ligne.rjust(32)
self.textehomard.append(ligne)
else:
val=apply(HomardGenerator.__dict__[mot],(self,))
if val != None:
mot.rjust(8)
- ligne=mot+' '+val
- ligne.rjust(32)
+ ligne=mot+' '+val
+ ligne.rjust(32)
self.textehomard.append(ligne)
def get_homard(self):
def SuivFron(self):
val="non"
- if self.dico_mot_clef.has_key('NOM_MED_MAILLAGE_FRONTIERE'):
- if self.dico_mot_clef['NOM_MED_MAILLAGE_FRONTIERE'] != None:
- val="oui"
+ if self.dico_mot_clef.has_key('NOM_MED_MAILLAGE_FRONTIERE'):
+ if self.dico_mot_clef['NOM_MED_MAILLAGE_FRONTIERE'] != None:
+ val="oui"
return val
def TypeBila(self):
retour=None
dict_val={'NOMBRE':7,'INTERPENETRATION':3,'QUALITE':5,'CONNEXITE':11,'TAILLE':13}
for mot in ('NOMBRE','QUALITE','INTERPENETRATION','CONNEXITE','TAILLE'):
- if self.dico_mot_clef.has_key(mot):
- if (self.dico_mot_clef[mot] == "OUI"):
- inttypeBilan=inttypeBilan*dict_val[mot]
+ if self.dico_mot_clef.has_key(mot):
+ if (self.dico_mot_clef[mot] == "OUI"):
+ inttypeBilan=inttypeBilan*dict_val[mot]
retour = repr(inttypeBilan)
- return retour
+ return retour
def ModeHOMA(self):
intModeHOMA=1
- if self.dico_mot_clef.has_key('INFORMATION'):
- if self.dico_mot_clef['INFORMATION'] == "OUI":
- intModeHOMA=2
+ if self.dico_mot_clef.has_key('INFORMATION'):
+ if self.dico_mot_clef['INFORMATION'] == "OUI":
+ intModeHOMA=2
return repr(intModeHOMA)
-
+
def CCAssoci(self):
return 'MED'
def CCNoChaI(self):
- if not (self.dico_mot_clef.has_key('NOM_MED')):
- return None
- if (self.dico_mot_clef['NOM_MED']== None):
- return None
- if not (self.dico_mot_clef.has_key('COMPOSANTE')):
- return None
+ if not (self.dico_mot_clef.has_key('NOM_MED')):
+ return None
+ if (self.dico_mot_clef['NOM_MED']== None):
+ return None
+ if not (self.dico_mot_clef.has_key('COMPOSANTE')):
+ return None
if (self.dico_mot_clef['COMPOSANTE']== None):
return None
chaine=self.dico_mot_clef['COMPOSANTE']+' '+self.dico_mot_clef['NOM_MED']
def HOMaiN__(self):
chaine=None
if self.dico_mot_clef.has_key('NITER'):
- if self.dico_mot_clef['NITER'] != None :
+ if self.dico_mot_clef['NITER'] != None :
num="M"+repr(self.dico_mot_clef['NITER'])
- chaine=num+" "+num+".hom"
+ chaine=num+" "+num+".hom"
return chaine
def HOMaiNP1(self):
chaine=None
if self.dico_mot_clef.has_key('NITER'):
- if self.dico_mot_clef['NITER'] != None :
+ if self.dico_mot_clef['NITER'] != None :
num="M"+repr(self.dico_mot_clef['NITER']+1)
- chaine=num+" "+num+".hom"
+ chaine=num+" "+num+".hom"
return chaine
def CCNumOrI(self):
chaine=repr(1)
if self.dico_mot_clef.has_key('NUME_ORDRE'):
if self.dico_mot_clef['NUME_ORDRE'] != None :
- chaine=repr(self.dico_mot_clef['NUME_ORDRE'])
+ chaine=repr(self.dico_mot_clef['NUME_ORDRE'])
return chaine
def CCNumPTI(self):
chaine=repr(1)
if self.dico_mot_clef.has_key('NUME_PAS_TEMPS'):
if self.dico_mot_clef['NUME_PAS_TEMPS'] != None :
- chaine=repr(self.dico_mot_clef['NUME_PAS_TEMPS'])
+ chaine=repr(self.dico_mot_clef['NUME_PAS_TEMPS'])
return chaine
if nom == '' : nom = 'sansnom'
l.append(nom + ' = FORMULE(')
for v in obj.mc_liste:
- text=self.generator(v)
- l.append(v.nom+'='+text)
+ text=self.generator(v)
+ l.append(v.nom+'='+text)
l.append(');')
return l
# mais seulement le nom dans le cas d'un paramètre
s = val.nom
elif isinstance(val,Extensions.parametre.PARAMETRE):
- s = val.nom
+ s = val.nom
else:
s = self.generator(val)
elif type(val) == types.FloatType :
else :
# Pour les autres types on utilise repr
if isinstance(val,Extensions.parametre.PARAMETRE):
- s = val.nom
+ s = val.nom
else:
s = `val`
s= s + ','
l.append(nom + ' = FORMULE(')
for v in obj.mc_liste:
text=self.generator(v)
- l.append(v.nom+'='+text)
+ l.append(v.nom+'='+text)
l.append(');')
return l
