1 # CONFIGURATION MANAGEMENT OF EDF VERSION
2 # ======================================================================
3 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
7 # (AT YOUR OPTION) ANY LATER VERSION.
9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
16 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
19 # ======================================================================
20 # ----------------------------------------------------------
21 # Cette classe sert à définir les widgets utilisés par
23 # ----------------------------------------------------------
27 import os,sys,re,string
29 from tkFileDialog import *
30 from tkMessageBox import showinfo,askyesno,showerror,askretrycancel
34 from utils import save_in_file
35 from centerwindow import centerwindow
37 from Noyau.N_utils import repr_float
40 """ Cette classe permet de créer une fenêtre Toplevel dans laquelle
41 on peut afficher un texte et qui permet de le sauver"""
42 def __init__(self,appli,titre="",texte=""):
44 self.fenetre = Toplevel()
45 self.fenetre.configure(width = 800,height=500)
46 self.fenetre.protocol("WM_DELETE_WINDOW", self.quit)
47 self.fenetre.title("Visualisation du "+titre)
48 self.texte = string.replace(texte,'\r\n','\n')
50 fonte=fontes.standardcourier10
51 # définition des frames
52 self.frame_texte = Frame(self.fenetre)
53 self.frame_boutons = Frame(self.fenetre)
54 self.frame_texte.place(relx=0,rely=0,relwidth=1,relheight=0.9)
55 self.frame_boutons.place(relheight=0.1,relx=0,rely=0.9,relwidth=1.)
56 # définition de la zone texte et du scrollbar
57 self.zone_texte = Text(self.frame_texte,font=fonte)
58 self.zone_texte.bind("<Key-Prior>", self.page_up)
59 self.zone_texte.bind("<Key-Next>", self.page_down)
60 self.zone_texte.bind("<Key-Up>", self.unit_up)
61 self.zone_texte.bind("<Key-Down>", self.unit_down)
62 self.scroll_v = Scrollbar (self.frame_texte,command = self.zone_texte.yview)
63 #self.scroll_h = Scrollbar (self.frame_texte,command = self.zone_texte.xview)
64 self.scroll_v.pack(side='right',fill ='y')
65 #self.scroll_h.pack(side='bottom',fill ='x')
66 self.zone_texte.pack(side='top',fill='both',expand=1,padx=5,pady=10)
67 self.zone_texte.configure(yscrollcommand=self.scroll_v.set)
68 # définition des boutons
69 self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit)
70 self.but_save = Button(self.frame_boutons,text = "sauver",command = self.save)
71 self.but_quit.place(relx=0.4,rely=0.5,anchor='center')
72 self.but_save.place(relx=0.6,rely=0.5,anchor='center')
74 self.affiche_texte(self.texte)
75 centerwindow(self.fenetre)
77 def page_up(self,event):
78 event.widget.yview_scroll(-1, "page")
79 def page_down(self,event):
80 event.widget.yview_scroll(1, "page")
81 def unit_up(self,event):
82 event.widget.yview_scroll(-1, "unit")
83 def unit_down(self,event):
84 event.widget.yview_scroll(1, "unit")
87 self.fenetre.grab_set()
88 self.fenetre.wait_window(self.fenetre)
91 self.fenetre.destroy()
93 def efface_scroll(self):
94 """ Efface le scroll lorsqu'il n'est pas nécessaire : ne marche pas"""
95 self.scroll_v.pack_forget()
96 #self.scroll_h.pack_forget()
98 def affiche_texte(self,texte):
99 """ Affiche le texte dans la fenêtre """
101 self.zone_texte.insert(END,texte)
103 self.fenetre.update_idletasks()
104 x0,y0,x1,y1 = self.zone_texte.bbox(END)
105 if (y1-y0) < 300 : self.efface_scroll()
110 """ Permet de sauvegarder le texte dans un fichier dont on a demandé le nom
112 file = asksaveasfilename(defaultextension = '.comm',
113 #initialdir = self.appli.CONFIGURATION.rep_user,
114 initialdir = self.appli.CONFIGURATION.initialdir,
115 title="Sauvegarde du "+self.titre)
117 if not save_in_file(file,self.texte) :
118 showerror("Sauvegarde impossible",
119 "Impossible de sauvegarder le texte dans le fichier spécifié\n"+
120 "Vérifiez les droits d'écriture")
122 showinfo("Sauvegarde effectuée","Sauvegarde effectuée dans le fichier %s" %file)
124 class FenetreDeSelection(Fenetre):
125 """ Classe dérivée de Fenêtre permettant la récupération d'une zone de texte sélectionnée.
\r
126 Cette classe est utilisée pour affecter une liste de valeurs à un mot-clé.
\r
128 def __init__(self,panel,item,appli,titre="",texte=""):
\r
129 Fenetre.__init__(self,appli,titre=titre,texte=texte)
\r
130 self.fenetre.configure(width = 320,height=400)
\r
131 centerwindow(self.fenetre)
134 self.fenetre.title(titre)
135 self.but_save.configure(text="Ajouter",command=self.traite_selection)
\r
136 # séparateur par défaut
\r
137 self.separateur = ";"
\r
138 # création de la zone de saisie du séparateur
\r
139 l_separateurs_autorises = self.get_separateurs_autorises()
\r
140 self.choix_sep = Pmw.ComboBox(self.frame_boutons,
\r
141 label_text = "Séparateur :",
\r
144 selectioncommand = self.choose_separateur,
\r
145 scrolledlist_items = l_separateurs_autorises)
\r
146 self.choix_sep.component('entry').configure(width=6)
\r
147 self.choix_sep.place(relx=0.01,rely=0.5,anchor='w')
\r
148 self.choix_sep.selectitem(self.separateur)
\r
150 self.but_quit.place_forget()
\r
151 self.but_save.place_forget()
\r
152 self.but_save.place(relx=0.6,rely=0.5,anchor='center')
\r
153 self.but_quit.place(relx=0.8,rely=0.5,anchor='center')
\r
155 def get_separateurs_autorises(self):
\r
157 Retourne la liste des séparateurs autorisés
\r
159 return ['espace',';',',']
\r
161 def choose_separateur(self,nom_sep):
\r
163 Affecte à self.separateur le caractère séparateur correspondant à nom_sep
\r
165 if nom_sep == 'espace' :
\r
166 self.separateur = ' '
\r
168 self.separateur = nom_sep
\r
170 def traite_selection(self):
\r
171 """ Cette méthode effectue tous les traitements nécessaires pour vérifier
\r
172 et affecter la liste de valeurs à l'objet réprésenté par self.item
\r
174 # Récupère la liste des chaines de caractères de la zone sélectionnée
\r
175 message,liste = self.recupere_liste()
\r
176 if self.test_probleme(message,"Sélectionnez des données") == 0:
\r
178 # Vérifie que le nombre de données est dans les limites attendues
\r
179 message = self.verif_liste(liste)
\r
180 if self.test_probleme(message,"Vérifiez le nombre de données") == 0:
\r
182 # Crée une liste de valeurs du type attendu
\r
183 message,liste_valeurs = self.creation_liste_valeurs(liste)
\r
184 if self.test_probleme(message,"Vérifiez le type des données") == 0:
\r
186 # Vérifie que chaque valeur est dans le domaine exigé
\r
187 message = self.verif_valeurs(liste_valeurs)
\r
188 if self.test_probleme(message,"Vérifiez le domaine des valeurs") == 0:
\r
190 # Ajoute les valeurs dans la liste de valeurs du mot-clé
\r
191 self.ajouter_valeurs(liste_valeurs)
\r
192 self.appli.affiche_infos("Liste de valeurs acceptée")
\r
194 def test_probleme(self, message, message_eficas):
\r
195 """ Cette méthode affiche un message d'erreur si message != ''
\r
196 et retourne 0, sinon retourne 1 sans rien afficher.
\r
199 showinfo("Problème",message)
\r
200 self.fenetre.tkraise()
\r
201 self.appli.affiche_infos(message_eficas)
\r
206 def recupere_liste(self):
\r
207 """ Cette méthode récupère le texte de la zone sélectionnée, construit et
\r
208 retourne une liste avec les chaines qui se trouvent entre les séparateurs.
\r
209 S'il n'y a pas de données selectionnées, elle retourne un message d'erreur
\r
214 selection=self.fenetre.selection_get()
\r
216 message = "Pas de donnée sélectionnée"
\r
217 return message,None
\r
218 # les retours chariots doivent être interprétés comme des séparateurs
\r
219 selection = string.replace(selection,'\n',self.separateur)
\r
220 # on splitte la sélection suivant le caractère séparateur
\r
221 liste_chaines = string.split(selection,self.separateur)
\r
223 for chaine in liste_chaines:
\r
224 chaine = string.strip(chaine)
\r
225 if chaine != '' : l_chaines.append(chaine)
\r
226 return message,l_chaines
\r
228 def verif_liste(self, liste):
\r
229 """ Cette méthode effectue des tests sur le nombre d'éléments de la liste
\r
230 et retourne 1 si la liste est correcte, sinon 0 et le message d'erreur
\r
234 # nombre d'éléments sélectionnés
\r
235 nombre_elements = len(liste)
\r
236 # nombre d'éléments déja dans la liste du panel
\r
237 nombre_in_liste = len(self.panel.Liste_valeurs.get_liste())
\r
238 multiplicite = self.item.GetMultiplicite()
\r
239 if (nombre_elements % multiplicite) != 0:
\r
240 message = "Vous devez sélectionner "+str(multiplicite)+" * n données"
\r
242 nombre_valeurs = nombre_elements / multiplicite
\r
243 cardinalite = self.item.GetMinMax()
\r
244 if nombre_valeurs < cardinalite[0]:
\r
245 message = "Vous devez sélectionner au moins "+str(cardinalite[0])+" valeurs"
\r
247 if cardinalite[1] != "**" and nombre_valeurs > (long(cardinalite[1])-nombre_in_liste):
\r
248 message = "La liste ne peut avoir plus de "+str(cardinalite[1])+" valeurs"
\r
253 def creation_liste_valeurs(self, liste):
\r
254 """ Cette méthode crée et retourne une liste de valeurs du type attendu
\r
255 par le mot-clé. La liste de valeurs est créée à partir de la liste
\r
256 de chaines de caractères transmise.
\r
258 type_attendu = self.item.GetType()[0]
\r
259 if type_attendu == 'R':
\r
260 return self.convertir(liste, f_conversion= float)
\r
261 elif type_attendu == 'I':
\r
262 return self.convertir(liste, f_conversion= int)
\r
263 elif type_attendu == 'TXM':
\r
264 return self.convertir(liste)
\r
266 message = "Seuls les entiers, les réels et les chaines de caractères sont convertis"
\r
267 return message,None
\r
269 def convertir(self, liste, f_conversion=None):
\r
270 """ Cette méthode essaie de convertir les éléments de la liste avec la
\r
271 fonction f_conversion si elle existe, et retourne la liste des
\r
272 éléments dans le type voulu en cas de succès, sinon retourne None.
\r
276 for chaine in liste:
\r
279 liste_valeurs.append(f_conversion(chaine))
\r
281 message = "Impossible de convertir "+chaine+" dans le type attendu"
\r
282 return message,None
\r
284 liste_valeurs.append(chaine)
\r
285 return message,liste_valeurs
\r
287 def verif_valeurs(self, liste_valeurs):
\r
288 """ Cette méthode teste tous les éléments de la liste, et retourne 1 si chaque
\r
289 élément est dans le domaine voulu.
\r
292 for valeur in liste_valeurs:
\r
293 test = self.item.IsInIntervalle(valeur)
\r
295 intervalle = str(self.item.GetIntervalle()[0])+","+str(self.item.GetIntervalle()[1])
\r
296 message = "La valeur "+str(valeur)+" n'est pas dans l'intervalle ["+intervalle+"]"
\r
300 def ajouter_valeurs(self, liste_valeurs):
\r
301 """ Cette méthode ajoute les nouvelles valeurs à la liste existante."""
\r
302 liste = self.panel.Liste_valeurs.get_liste()
\r
303 liste.extend(liste_valeurs)
\r
304 self.panel.Liste_valeurs.put_liste(liste)
308 Cette classe permet de créer une boîte Dialog dans laquelle
309 on affiche un formulaire à remplir par l'utilisateur
\r
311 def __init__(self,fen_pere,obj_pere=None,titre="",texte="",items=(),mode='query',commande=None):
\r
312 if items in ((),[]) : return
316 self.fen_pere = fen_pere
317 self.obj_pere = obj_pere
319 self.command = commande
323 self.init_validateurs()
326 self.init_items_formulaire()
327 self.fenetre.activate(geometry='centerscreenalways')
329 def init_validateurs(self):
\r
331 Crée le dictionnaire des validateurs des objets reconnus par le formulaire
\r
333 self.d_validateurs = {}
\r
334 self.d_validateurs['rep'] = self.repvalidator
\r
335 self.d_validateurs['file'] = self.filevalidator
\r
336 self.d_validateurs['cata']= self.catavalidator
\r
338 def init_fenetre(self):
\r
340 Crée la fenêtre Dialog
\r
342 if self.mode == 'query':
343 buttons=('Valider','Annuler')
344 defaultbutton = 'Valider'
345 elif self.mode == 'display':
347 buttons=(self.command[0],'OK')
352 self.fenetre = Pmw.Dialog(self.fen_pere,
354 defaultbutton = defaultbutton,
356 command = self.execute)
\r
357 self.fenetre.withdraw()
359 def init_texte(self):
\r
361 Crée le label qui affiche le texte à l'intérieur du panneau
\r
363 fonte=fontes.standard
\r
364 fr_texte = Frame(self.fenetre.interior(),height=60)
\r
365 fr_texte.pack(side='top',fill='x',expand=1)
366 Label(fr_texte,text = self.texte, font=fonte).place(relx=0.5,rely=0.5,anchor='center')
368 def init_items_formulaire(self):
\r
370 Crée et affiche les items dans la boîte de dialogue
\r
374 self.item_widgets = {}
\r
376 for item in self.items:
377 if len(item[0])>length_maxi : length_maxi = len(item[0])
\r
378 window = self.fenetre.interior()
\r
379 for item in self.items :
\r
380 label,nature,nom_var,defaut = item
\r
381 # création de la frame
\r
382 fr_item = Frame(window,height=40,width=700)
\r
383 fr_item.pack(side='top',fill='x',expand=1)
\r
384 # création du label
\r
385 Label(fr_item,text = label).place(relx=0.05,rely=0.4)
\r
386 if nature in ('rep','file','cata'):
387 # création de l'entry
\r
388 e_item = Entry(fr_item)
\r
389 e_item.place(relx=0.5,rely=0.4,relwidth=0.45)
\r
390 self.widgets.append(e_item)
\r
391 self.item_widgets[item] = e_item
\r
392 if defaut : e_item.insert(0,str(defaut))
\r
393 elif nature == 'YesNo':
\r
394 # création de la StringVar
\r
396 setattr(self,'item_'+nom_var,var)
\r
398 # création du radiobouton
\r
399 rb1 = Radiobutton(fr_item,text='OUI',variable=var,value='OUI')
\r
400 rb2 = Radiobutton(fr_item,text='NON',variable=var,value='NON')
\r
401 rb1.place(relx=0.65,rely=0.5,anchor='center')
\r
402 rb2.place(relx=0.80,rely=0.5,anchor='center')
\r
403 self.widgets.append((rb1,rb2))
\r
404 self.item_widgets[item] = var
\r
405 # détermination de la méthode à appliquer sur les boutons
\r
406 if self.mode == 'query':
\r
407 function = self.active
\r
408 elif self.mode == 'display':
\r
409 function = self.inactive
\r
412 # on applique la méthode sur les boutons (activation ou désactivation)
\r
413 for widget in self.widgets :
\r
414 if type(widget) == types.TupleType:
\r
415 for widg in widget :
\r
416 apply(function,(widg,),{})
\r
418 apply(function,(widget,),{})
\r
420 def active(self,widget):
\r
422 Active le widget passé en argument
\r
424 widget.configure(state='normal',bg='white')
\r
426 def inactive(self,widget):
\r
428 Inactive le widget passé en argument
\r
430 if not isinstance(widget,Radiobutton) :
\r
431 widget.configure(state='disabled',bg='gray95')
\r
433 widget.configure(state='disabled')
\r
435 # --------------------------------------------------------------------------------
\r
436 # Validateurs des noms de répertoire, de fichiers et de catalogues
\r
437 # --------------------------------------------------------------------------------
\r
439 def repvalidator(self,text):
441 Teste si text peut faire référence à un répertoire ou non
\r
442 Retourne 1 si valide, 0 sinon
\r
444 return os.path.isdir(text),'Répertoire introuvable : %s' %text
446 def filevalidator(self,text):
448 Teste si text peut faire référence à un fichier ou non
\r
449 Retourne 1 si valide, 0 sinon
\r
451 return os.path.isfile(text),'Fichier introuvable : %s' %text
453 def catavalidator(self,text):
\r
455 Teste si text est un chemin d'accès valide à un catalogue
\r
456 Retourne 1 si valide, 0 sinon
\r
458 return os.path.isfile(text),"Catalogue introuvable : %s" %text
\r
460 # --------------------------------------------------------------------------------
\r
461 # Méthodes callbacks des boutons et de fin
\r
462 # --------------------------------------------------------------------------------
\r
464 def execute(self,txt):
\r
466 Cette commande est activée à chaque clic sur un bouton.
\r
467 Redirige l'action sur la bonne méthode en fonction du bouton activé
\r
471 elif txt in ('OK','Annuler'):
473 elif txt == 'Modifier':
474 self.resultat = apply(self.command[1],(),{})
475 self.fenetre.destroy()
477 print "Nom de bouton inconnu"
482 Commande qui termine le panneau et sauvegarde les nouvelles options
\r
483 dans l'objet resultat (dictionnaire)
\r
486 for item,widget in self.item_widgets.items():
\r
489 valeur = widget.get()
\r
490 if self.d_validateurs.has_key(type_var):
\r
491 test = self.d_validateurs[type_var](valeur)
\r
493 # une entrée n'est pas valide --> on la met en surbrillance et on quitte la méthode
\r
494 # sans tuer la fenêtre bien sûr
\r
495 widget.selection_range(0,END)
\r
497 dico[nom_var] = valeur
498 self.fenetre.destroy()
502 self.fenetre.destroy()
506 """ Cette classe est utilisée pour afficher une liste de choix passée en paramètre
507 en passant les commandes à lancer suivant différents bindings """
508 def __init__(self,parent,page,liste,liste_commandes=[],liste_marques =[],active ='oui',filtre='non',titre=''):
513 self.selection = None
514 self.liste_commandes = liste_commandes
515 self.liste_marques = liste_marques
523 self.make_label_titre()
524 self.make_entry_filtre()
527 self.entry.component('entry').focus()
531 def make_label_titre(self):
532 """ Crée le label correspondant au titre """
533 if self.titre == '' : return
534 fonte_titre = fontes.standard_gras_souligne
535 self.label = Label(self.page,
538 self.label.pack(side='top',pady=2)
540 def make_entry_filtre(self):
541 """ Crée l'entry permettant à l'utilisateur d'entrer un filtre de sélection dans la liste """
542 if self.filtre != 'oui' : return
543 self.entry = Pmw.EntryField(self.page,labelpos='w',
544 label_text="Filtre :",
545 command=self.entry_changed)
546 self.entry.pack(side='top',pady=2)
548 def make_text_box(self):
549 """ Crée la fenêtre texte dans laquelle sera affichée la liste """
550 self.MCbox = Text (self.page,relief='sunken',bg='gray95',bd=2)
551 self.MCscroll = Scrollbar (self.page,command = self.MCbox.yview)
552 self.MCscroll.pack(side='right',fill ='y',pady=2)
553 self.MCbox.pack(fill='y',expand=1,padx=2,pady=2)
554 self.MCbox.configure(yscrollcommand=self.MCscroll.set)
556 def affiche_liste(self):
557 """ Affiche la liste dans la fenêtre"""
559 self.MCbox.config(state=NORMAL)
560 self.MCbox.delete(1.0,END)
561 for objet in self.liste :
562 if type(objet) == types.InstanceType:
567 elif type(objet) in (types.StringType,types.IntType):
569 elif type(objet) == types.FloatType :
570 #mot = repr_float(objet)
574 label = Label(self.MCbox,
576 fg = 'black',bg = 'gray95',justify = 'left')
577 self.dico_labels[mot]=label
578 self.MCbox.window_create(END,
581 self.MCbox.insert(END,'\n')
582 if self.active == 'oui':
583 label.bind(self.liste_commandes[0][0],lambda e,s=self,c=self.liste_commandes[0][1],x=objet,l=label : s.selectitem(x,l,c))
584 label.bind(self.liste_commandes[1][0],lambda e,s=self,c=self.liste_commandes[1][1],x=objet,l=label : s.deselectitem(l,x,c))
585 label.bind(self.liste_commandes[2][0],lambda e,s=self,c=self.liste_commandes[2][1],x=objet,l=label : s.chooseitem(x,l,c))
587 self.liste_marques.index(i)
592 self.MCbox.config(state=DISABLED)
593 self.selection = None
595 def chooseitem(self,mot,label,commande):
596 """ Active la méthode de choix passée en argument"""
599 def selectitem(self,mot,label,commande) :
600 """ Met l'item sélectionné (représenté par son label) en surbrillance
601 et lance la commande associée au double-clic"""
602 if self.selection != None :
603 self.deselectitem(self.selection[1],self.selection[0],self.selection[2],)
604 self.highlightitem(label)
605 self.selection = (mot,label,commande)
606 self.arg_selected = mot
609 def highlightitem(self,label) :
610 """ Met l'item représenté par son label en surbrillance """
611 label.configure(bg='#00008b',fg='white')
613 def markitem(self,label):
614 """ Met l'item (représenté par son label) en rouge """
615 label.configure(bg='gray95',fg='red')
617 def deselectitem(self,label,mot='',commande=None) :
618 """ Remet l'item (représenté par son label) en noir"""
619 label.configure(bg='gray95',fg='black')
620 self.arg_selected = ''
621 if commande != None : commande(mot)
623 def entry_changed(self,event=None):
624 """ Cette méthode est invoquée chaque fois que l'utilisateur modifie le contenu
625 de l'entry et frappe <Return>"""
626 if self.arg_selected != '' : self.deselectitem(self.dico_labels[self.arg_selected])
627 filtre = self.entry.get()+"*"
628 FILTRE = string.upper(filtre)
629 for arg in self.liste :
630 if fnmatch.fnmatch(arg,filtre) or fnmatch.fnmatch(arg,FILTRE) :
631 self.highlightitem(self.dico_labels[arg])
632 index = self.MCbox.index(self.dico_labels[arg])
633 self.MCbox.see(index)
634 self.arg_selected = arg
637 def get_liste_old(self):
642 for val in self.liste:
650 def put_liste(self,liste):
655 """ Cette classe permet d'afficher au lancement d'EFICAS le message
656 d'attente et la barre de progression"""
657 def __init__(self,master,message,barre ='oui'):
658 from Tools.foztools.foztools import Slider
659 fonte=fontes.standard12_gras
661 self.frame = Frame(self.master)
662 self.frame.pack(expand=1,fill='both')
663 self.mess = Label(self.frame,text=message,justify='center',
664 bd=2,relief='groove',font=fonte)
665 self.mess.pack(in_ = self.frame,side='top',expand=1,fill='both')
666 self.progress = Slider(self.frame,value=0,max=100,orientation='horizontal',
667 fillColor='#00008b',width=200,height=30,
668 background='white',labelColor='red')
670 self.progress.frame.pack(in_=self.frame,side='top')
673 self.progress.frame.after(1000,self.update)
675 def configure(self,**options):
676 if options.has_key('message'):
677 self.mess.configure(text=options['message'])
678 if options.has_key('barre'):
679 if options['barre'] == 'oui' :
680 self.progress.frame.pack(in_=self.frame,side='top')
681 elif options['barre'] == 'non' :
682 self.progress.frame.pack_forget()
683 self.master.update_idletasks()
689 def update(self,event=None):
690 """ Permet de faire avancer la barre de progression """
693 bar.value = bar.value+self.increment
695 self.master.after(100,self.update)
699 def configure_barre(self,nb):
700 """ Calcule l'incrément de progression de la barre en fonction
701 du nombre d'opérations à effectuer afin que le compteur
702 soit à 100% à la fin des opérations"""
703 self.increment = 100./nb
704 self.progress.update()
706 class Ask_Format_Fichier :
708 Cette classe permet de créer une fenêtre Toplevel dans laquelle
709 on propose le choix du format de fichier de commandes à ouvrir
\r
711 def __init__(self,appli):
712 self.fenetre = Toplevel()
713 self.fenetre.configure(width = 250,height=150)
714 self.fenetre.protocol("WM_DELETE_WINDOW", self.quit)
715 self.fenetre.title("Choix du format du fichier de commandes")
716 # définition des frames
717 self.frame_texte = Frame(self.fenetre)
718 self.frame_radioboutons = Frame(self.fenetre)
719 self.frame_bouton_ok = Frame(self.fenetre)
720 self.frame_texte.place(relx=0,rely=0,relwidth=1,relheight=0.3)
721 self.frame_radioboutons.place(relheight=0.5,relx=0,rely=0.3,relwidth=1.)
722 self.frame_bouton_ok.place(relheight=0.2,relx=0,rely=0.8,relwidth=1.)
723 # définition de la zone texte et du scrollbar
724 zone_texte = Label(self.frame_texte,text = "Format du fichier à ouvrir :")
725 zone_texte.pack(side='top',fill='both',expand=1,padx=5,pady=10)
726 # définition des radioboutons
727 Radiobutton(self.frame_radioboutons,text='Format Aster (Code_Aster --> v5)',
728 variable=appli.format_fichier,value='Aster').pack(anchor='n')
729 Radiobutton(self.frame_radioboutons,text='Format Python (Code_Aster v6-->)',
730 variable=appli.format_fichier,value='Python').pack(anchor='n')
731 # création du bouton OK
732 Button(self.frame_bouton_ok,text='OK',command=self.quit).pack(anchor='n')
733 # centrage de la fenêtre
734 centerwindow(self.fenetre)
737 self.fenetre.destroy()
739 class BARRE_K2000(Toplevel):
740 def __init__(self,master=None,text = ""):
741 Toplevel.__init__(self,master,relief='groove')
742 self.master.iconify()
743 self.geometry("250x100+0+0")
744 self.protocol("WM_DELETE_WINDOW",self.quit)
745 # frame principale dans self (= Toplevel)
746 self.frame = Frame(self)
747 self.frame.place(relwidth=1,relheight=1)
748 # frame contenant le texte à afficher
749 self.frame_text = Frame(self.frame)
750 self.frame_text.place(relwidth=1,relheight=0.75,rely=0)
751 # frame contenant le canvas de la barre
752 self.frame_canv = Frame(self.frame)
753 self.frame_canv.place(relwidth=1,relheight=0.25,rely=0.75)
754 # canvas dans lequel sera affichée la barre K2000
755 self.canvas = Canvas(self.frame_canv)
756 self.canvas.place(relx=0.5,rely=0.5,relheight=0.8,relwidth=0.8,anchor='center')
757 # on affiche le texte et la barre
758 self.build_text(text)
760 #self.overrideredirect(1)
761 # on active la barre ...
762 self.master.after(1000,self.launch)
763 # on centre la fenêtre
767 def build_text(self,text):
769 Affichage de text dans frame_text
771 self.texte_var = StringVar()
772 self.texte_var.set(text)
773 Label(self.frame_text,textvariable=self.texte_var).place(relx=0.5,rely=0.5,anchor='center')
775 def build_batons(self):
777 Construit la suite de bâtons dans le canvas
783 for i in range(0,40):
784 id = self.canvas.create_rectangle(i*5,0,(i+1)*5,20,fill='gray90',outline='')
785 self.l_batons.append(id)
789 Active la barre K2000 en affichant les bâtons avec des couleurs en dégradé
793 self.master.deiconify()
796 self.black = self.black+1
797 l_bat = self.l_batons[0:self.black+1]
799 elif self.sens == 'G':
800 self.black = self.black-1
801 l_bat = self.l_batons[self.black:]
805 if num_color < 10 : color = 'black'
806 elif num_color > 90 : color = 'white'
807 else: color = 'gray'+`num_color`
808 self.canvas.itemconfigure(bat,fill=color)
810 if self.black == len(self.l_batons) :
812 if self.black == 0 and self.sens == 'G':self.sens = 'D'
813 self.after(80,self.launch)
815 def update_text(self,new_text):
817 Remplace le texte affiché par new_text
819 self.texte_var.set(new_text)
824 class ListeChoixParGroupes(ListeChoix) :
826 Cette classe est utilisée pour afficher une liste de commandes classées par
827 groupes. L'utilisateur peut réaliser des actions de selection
828 qui déclenchent des actions spécifiées par les bindings contenus dans liste_commandes
830 def __init__(self,parent,page,liste_groupes,dict_groupes,liste_commandes=[],liste_marques =[],
831 active ='oui',filtre='non',titre=''):
834 self.liste_groupes = liste_groupes
835 self.dict_groupes = dict_groupes
837 self.selection = None
838 self.liste_commandes = liste_commandes
839 self.liste_marques = liste_marques
846 def affiche_liste(self):
847 """ Affiche la liste dans la fenêtre"""
849 self.MCbox.config(state=NORMAL)
850 self.MCbox.delete(1.0,END)
851 for grp in self.liste_groupes:
852 # On itère sur les groupes
853 if grp == "CACHE":continue
854 liste_commandes=self.dict_groupes[grp]
855 text="GROUPE<<<<<<<< "+grp+" "
856 text=text+">"*max(0,30-len(text))
857 label = Label(self.MCbox,
859 fg = 'black',bg = 'gray95',justify = 'left')
860 # On stocke la relation entre le nom de la commande et le label
861 self.dico_labels[grp]=label
862 self.MCbox.window_create(END,
865 self.MCbox.insert(END,'\n')
866 for cmd in liste_commandes:
867 label = Label(self.MCbox,
869 fg = 'black',bg = 'gray95',justify = 'left')
870 # On stocke la relation entre le nom de la commande et le label
871 self.dico_labels[cmd]=label
872 self.MCbox.window_create(END,
875 self.MCbox.insert(END,'\n')
876 if self.active == 'oui':
877 label.bind(self.liste_commandes[0][0],
878 lambda e,s=self,c=self.liste_commandes[0][1],x=cmd,l=label : s.selectitem(x,l,c))
879 label.bind(self.liste_commandes[1][0],
880 lambda e,s=self,c=self.liste_commandes[1][1],x=cmd,l=label : s.deselectitem(l,x,c))
881 label.bind(self.liste_commandes[2][0],
882 lambda e,s=self,c=self.liste_commandes[2][1],x=cmd,l=label : s.chooseitem(x,l,c))
883 # On marque les items specifies dans liste_marques
884 #if i in self.liste_marques : self.markitem(label)
886 self.MCbox.config(state=DISABLED)
887 self.selection = None
889 def entry_changed(self,event=None):
891 Cette méthode est invoquée chaque fois que l'utilisateur modifie le contenu
892 de l'entry et frappe <Return>
894 if self.arg_selected != '' : self.deselectitem(self.dico_labels[self.arg_selected])
895 filtre = self.entry.get()+"*"
896 FILTRE = string.upper(filtre)
898 # On cherche d'abord dans les noms de groupe
899 # puis dans les noms de commande groupe par groupe
901 for grp in self.liste_groupes:
902 if fnmatch.fnmatch(grp,filtre) or fnmatch.fnmatch(grp,FILTRE) :
903 index = self.MCbox.index(self.dico_labels[grp])
904 self.MCbox.see(index)
905 # On ne selectionne pas le groupe
906 #self.arg_selected = grp
907 # On a trouve un groupe on arrete la recherche
910 for grp in self.liste_groupes:
911 for cmd in self.dict_groupes[grp] :
912 if fnmatch.fnmatch(cmd,filtre) or fnmatch.fnmatch(cmd,FILTRE) :
913 self.highlightitem(self.dico_labels[cmd])
914 index = self.MCbox.index(self.dico_labels[cmd])
915 self.MCbox.see(index)
916 self.arg_selected = cmd
917 # On a trouve une commande on arrete la recherche