gui_manager.py @ 9a3adab

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 9a3adab was d0802c3, checked in by Mathieu Doucet <doucetm@…>, 16 years ago
Handle over application window size. Allow plot clearing.
Property mode set to `100644`
File size: 26.7 KB

Line
1	"""
2	This software was developed by the University of Tennessee as part of the
3	Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
4	project funded by the US National Science Foundation.
5
6	See the license text in license.txt
7
8	copyright 2008, University of Tennessee
9
10	How-to build an application using guiframe:
11
12	1- Write a main application script along the lines of dummyapp.py
13	2- Write a config script along the lines of config.py, and name it local_config.py
14	3- Write your plug-ins and place them in a directory called "perspectives".
15	- Look at local_perspectives/plotting for an example of a plug-in.
16	- A plug-in should define a class called Plugin. See abstract class below.
17
18	"""
19	import wx
20	import wx.aui
21	import os, sys
22	try:
23	# Try to find a local config
24	import imp
25	path = os.getcwd()
26	if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
27	(os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
28	fObj, path, descr = imp.find_module('local_config', [path])
29	config = imp.load_module('local_config', fObj, path, descr)
30	else:
31	# Try simply importing local_config
32	import local_config as config
33	except:
34	# Didn't find local config, load the default
35	import config
36
37	from sans.guicomm.events import EVT_STATUS
38
39	import warnings
40	warnings.simplefilter("ignore")
41
42	import logging
43
44	class Plugin:
45	"""
46	This class defines the interface for a Plugin class
47	that can be used by the gui_manager.
48
49	Plug-ins should be placed in a sub-directory called "perspectives".
50	For example, a plug-in called Foo should be place in "perspectives/Foo".
51	That directory contains at least two files:
52	perspectives/Foo/__init.py contains two lines:
53
54	PLUGIN_ID = "Foo plug-in 1.0"
55	from Foo import *
56
57	perspectives/Foo/Foo.py contains the definition of the Plugin
58	class for the Foo plug-in. The interface of that Plugin class
59	should follow the interface of the class you are looking at.
60	"""
61
62	def __init__(self):
63	"""
64	Abstract class for gui_manager Plugins.
65	"""
66	## Plug-in name. It will appear on the application menu.
67	self.sub_menu = "Plugin"
68
69	## Reference to the parent window. Filled by get_panels() below.
70	self.parent = None
71
72	## List of panels that you would like to open in AUI windows
73	# for your plug-in. This defines your plug-in "perspective"
74	self.perspective = []
75
76	raise RuntimeError, "gui_manager.Plugin is an abstract class"
77
78	def populate_menu(self, id, parent):
79	"""
80	Create and return the list of application menu
81	items for the plug-in.
82
83	@param id: deprecated. Un-used.
84	@param parent: parent window
85	@return: plug-in menu
86	"""
87	import wx
88	# Create a menu
89	plug_menu = wx.Menu()
90
91	# Always get event IDs from wx
92	id = wx.NewId()
93
94	# Fill your menu
95	plug_menu.Append(id, '&Do something')
96	wx.EVT_MENU(owner, id, self._on_do_something)
97
98	# Returns the menu and a name for it.
99	return [(id, plug_menu, "name of the application menu")]
100
101
102	def get_panels(self, parent):
103	"""
104	Create and return the list of wx.Panels for your plug-in.
105	Define the plug-in perspective.
106
107	Panels should inherit from DefaultPanel defined below,
108	or should present the same interface. They must define
109	"window_caption" and "window_name".
110
111	@param parent: parent window
112	@return: list of panels
113	"""
114	## Save a reference to the parent
115	self.parent = parent
116
117	# Define a panel
118	mypanel = DefaultPanel(self.parent, -1)
119
120	# If needed, add its name to the perspective list
121	self.perspective.append(self.control_panel.window_name)
122
123	# Return the list of panels
124	return [mypanel]
125
126	def get_context_menu(self, graph=None):
127	"""
128	This method is optional.
129
130	When the context menu of a plot is rendered, the
131	get_context_menu method will be called to give you a
132	chance to add a menu item to the context menu.
133
134	A ref to a Graph object is passed so that you can
135	investigate the plot content and decide whether you
136	need to add items to the context menu.
137
138	This method returns a list of menu items.
139	Each item is itself a list defining the text to
140	appear in the menu, a tool-tip help text, and a
141	call-back method.
142
143	@param graph: the Graph object to which we attach the context menu
144	@return: a list of menu items with call-back function
145	"""
146	return [["Menu text",
147	"Tool-tip help text",
148	self._on_context_do_something]]
149
150	def get_perspective(self):
151	"""
152	Get the list of panel names for this perspective
153	"""
154	return self.perspective
155
156	def on_perspective(self, event):
157	"""
158	Call back function for the perspective menu item.
159	We notify the parent window that the perspective
160	has changed.
161	@param event: menu event
162	"""
163	self.parent.set_perspective(self.perspective)
164
165	def post_init(self):
166	"""
167	Post initialization call back to close the loose ends
168	"""
169	pass
170
171
172	class ViewerFrame(wx.Frame):
173	"""
174	Main application frame
175	"""
176	def __init__(self, parent, id, title, window_height=800, window_width=800):
177	"""
178	Initialize the Frame object
179	"""
180	from local_perspectives.plotting import plotting
181	wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition, size=(800, 700))
182
183	# Preferred window size
184	self._window_height = window_height
185	self._window_width = window_width
186
187	# Logging info
188	logging.basicConfig(level=logging.DEBUG,
189	format='%(asctime)s %(levelname)s %(message)s',
190	filename='sans_app.log',
191	filemode='w')
192
193	path = os.path.dirname(__file__)
194	ico_file = os.path.join(path,'images/ball.ico')
195	if os.path.isfile(ico_file):
196	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
197	else:
198	ico_file = os.path.join(os.getcwd(),'images/ball.ico')
199	if os.path.isfile(ico_file):
200	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
201
202	## Application manager
203	self.app_manager = None
204
205	## Find plug-ins
206	# Modify this so that we can specify the directory to look into
207	self.plugins = self._find_plugins()
208	self.plugins.append(plotting.Plugin())
209
210	## List of panels
211	self.panels = {}
212
213	## Next available ID for wx gui events
214	#TODO: No longer used - remove all calls to this
215	self.next_id = 20000
216
217	# Default locations
218	self._default_save_location = os.getcwd()
219
220	## Default welcome panel
221	self.defaultPanel = DefaultPanel(self, -1, style=wx.RAISED_BORDER)
222
223	# self.build_gui()
224
225	# Register the close event so it calls our own method
226	wx.EVT_CLOSE(self, self._onClose)
227	# Register to status events
228	self.Bind(EVT_STATUS, self._on_status_event)
229
230	def build_gui(self):
231	# Set up the layout
232	self._setup_layout()
233
234	# Set up the menu
235	self._setup_menus()
236
237	self.Fit()
238
239	def _setup_layout(self):
240	"""
241	Set up the layout
242	"""
243	# Status bar
244	self.sb = self.CreateStatusBar()
245	self.SetStatusText("")
246
247	# Add panel
248	self._mgr = wx.aui.AuiManager(self)
249
250	# Load panels
251	self._load_panels()
252
253	self._mgr.Update()
254
255	def add_perspective(self, plugin):
256	"""
257	Add a perspective if it doesn't already
258	exist.
259	"""
260	is_loaded = False
261	for item in self.plugins:
262	if plugin.__class__==item.__class__:
263	print "Plugin %s already loaded" % plugin.__class__.__name__
264	is_loaded = True
265
266	if not is_loaded:
267	self.plugins.append(plugin)
268
269	def _find_plugins(self, dir="perspectives"):
270	"""
271	Find available perspective plug-ins
272	@param dir: directory in which to look for plug-ins
273	@return: list of plug-ins
274	"""
275	import imp
276	print "Looking for plug-ins in %s" % dir
277	# List of plug-in objects
278
279	#path_exe = os.getcwd()
280	#path_plugs = os.path.join(path_exe, dir)
281	f = open("load.log",'w')
282	f.write(os.getcwd()+'\n\n')
283	#f.write(str(os.listdir(dir))+'\n')
284
285
286	plugins = []
287	# Go through files in panels directory
288	try:
289	list = os.listdir(dir)
290	for item in list:
291	toks = os.path.splitext(os.path.basename(item))
292	name = None
293	if not toks[0] == '__init__':
294
295	if toks[1]=='.py' or toks[1]=='':
296	name = toks[0]
297
298	path = [os.path.abspath(dir)]
299	file = None
300	try:
301	if toks[1]=='':
302	f.write("trying to import \n")
303	mod_path = '.'.join([dir, name])
304	f.write("mod_path= %s\n" % mod_path)
305	module = __import__(mod_path, globals(), locals(), [name])
306	f.write(str(module)+'\n')
307	else:
308	(file, path, info) = imp.find_module(name, path)
309	module = imp.load_module( name, file, item, info )
310	if hasattr(module, "PLUGIN_ID"):
311	try:
312	plugins.append(module.Plugin())
313	print "Found plug-in: %s" % module.PLUGIN_ID
314	except:
315	config.printEVT("Error accessing PluginPanel in %s\n %s" % (name, sys.exc_value))
316
317	except:
318	print sys.exc_value
319	f.write(str(sys.exc_value)+'\n')
320	finally:
321	if not file==None:
322	file.close()
323	except:
324	# Should raise and catch at a higher level and display error on status bar
325	pass
326	f.write(str(plugins)+'\n')
327	f.close()
328	return plugins
329
330
331
332	def _load_panels(self):
333	"""
334	Load all panels in the panels directory
335	"""
336
337	# Look for plug-in panels
338	panels = []
339	for item in self.plugins:
340	if hasattr(item, "get_panels"):
341	ps = item.get_panels(self)
342	panels.extend(ps)
343
344	# Show a default panel with some help information
345	# It also sets the size of the application windows
346	self.panels["default"] = self.defaultPanel
347	self._mgr.AddPane(self.defaultPanel, wx.aui.AuiPaneInfo().
348	Name("default").
349	CenterPane().
350	# This is where we set the size of the application window
351	BestSize(wx.Size(self._window_width, self._window_height)).
352	MinSize(wx.Size(self._window_width, self._window_height)).
353	Show())
354
355	# Add the panels to the AUI manager
356	for panel_class in panels:
357	p = panel_class
358	id = wx.NewId()
359
360	# Check whether we need to put this panel
361	# in the center pane
362	if hasattr(p, "CENTER_PANE"):
363	if p.CENTER_PANE:
364	self.panels[str(id)] = p
365	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
366	Name(p.window_name).Caption(p.window_caption).
367	CenterPane().
368	BestSize(wx.Size(500,500)).
369	MinSize(wx.Size(200,200)).
370	Hide())
371
372	else:
373	self.panels[str(id)] = p
374	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
375	Name(p.window_name).Caption(p.window_caption).
376	#Floatable().
377	#Float().
378	Right().
379	Dock().
380	TopDockable().
381	BottomDockable().
382	LeftDockable().
383	RightDockable().
384	MinimizeButton().
385	Hide().
386	#Show().
387	BestSize(wx.Size(400,400)).
388	MinSize(wx.Size(300,300)))
389
390
391
392	def get_context_menu(self, graph=None):
393	"""
394	Get the context menu items made available
395	by the different plug-ins.
396	This function is used by the plotting module
397	"""
398	menu_list = []
399	for item in self.plugins:
400	if hasattr(item, "get_context_menu"):
401	menu_list.extend(item.get_context_menu(graph))
402
403	return menu_list
404
405	def popup_panel(self, p):
406	"""
407	Add a panel object to the AUI manager
408	@param p: panel object to add to the AUI manager
409	@return: ID of the event associated with the new panel [int]
410	"""
411
412	ID = wx.NewId()
413	self.panels[str(ID)] = p
414
415	count = 0
416	for item in self.panels:
417	if self.panels[item].window_name.startswith(p.window_name):
418	count += 1
419
420	windowname = p.window_name
421	caption = p.window_caption
422	if count>0:
423	windowname += str(count+1)
424	caption += (' '+str(count))
425
426	p.window_name = windowname
427	p.window_caption = caption
428
429	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
430	Name(windowname).Caption(caption).
431	Floatable().
432	#Float().
433	Right().
434	Dock().
435	TopDockable().
436	BottomDockable().
437	LeftDockable().
438	RightDockable().
439	MinimizeButton().
440	#Hide().
441	#Show().
442	BestSize(wx.Size(400,400)).
443	MinSize(wx.Size(350,350)))
444	pane = self._mgr.GetPane(windowname)
445	self._mgr.MaximizePane(pane)
446	self._mgr.RestoreMaximizedPane()
447
448
449	# Register for showing/hiding the panel
450	wx.EVT_MENU(self, ID, self._on_view)
451
452	self._mgr.Update()
453	return ID
454
455	def _setup_menus(self):
456	"""
457	Set up the application menus
458	"""
459	# Menu
460	menubar = wx.MenuBar()
461
462	# File menu
463	filemenu = wx.Menu()
464
465	id = wx.NewId()
466	filemenu.Append(id, '&Open', 'Open a file')
467	wx.EVT_MENU(self, id, self._on_open)
468
469	id = wx.NewId()
470	filemenu.Append(id,'&Quit', 'Exit')
471	wx.EVT_MENU(self, id, self.Close)
472
473	# Add sub menus
474	menubar.Append(filemenu, '&File')
475
476	# Plot menu
477	# Attach a menu item for each panel in our
478	# panel list that also appears in a plug-in.
479	# TODO: clean this up. We should just identify
480	# plug-in panels and add them all.
481
482	# Only add the panel menu if there is more than one panel
483	n_panels = 0
484	for plug in self.plugins:
485	pers = plug.get_perspective()
486	if len(pers)>0:
487	n_panels += 1
488
489	if n_panels>1:
490	viewmenu = wx.Menu()
491	for plug in self.plugins:
492	plugmenu = wx.Menu()
493	pers = plug.get_perspective()
494	if len(pers)>0:
495	for item in self.panels:
496	if item == 'default':
497	continue
498	panel = self.panels[item]
499	if panel.window_name in pers:
500	plugmenu.Append(int(item), panel.window_caption, "Show %s window" % panel.window_caption)
501	wx.EVT_MENU(self, int(item), self._on_view)
502
503	viewmenu.AppendMenu(wx.NewId(), plug.sub_menu, plugmenu, plug.sub_menu)
504
505	menubar.Append(viewmenu, '&Panel')
506
507	# Perspective
508	# Attach a menu item for each defined perspective.
509	# Only add the perspective menu if there are more than one perspectves
510	n_perspectives = 0
511	for plug in self.plugins:
512	if len(plug.get_perspective()) > 0:
513	n_perspectives += 1
514
515	if n_perspectives>1:
516	p_menu = wx.Menu()
517	for plug in self.plugins:
518	if len(plug.get_perspective()) > 0:
519	id = wx.NewId()
520	p_menu.Append(id, plug.sub_menu, "Switch to %s perspective" % plug.sub_menu)
521	wx.EVT_MENU(self, id, plug.on_perspective)
522	menubar.Append(p_menu, '&Perspective')
523
524	# Help menu
525	helpmenu = wx.Menu()
526
527	# Look for help item in plug-ins
528	for item in self.plugins:
529	if hasattr(item, "help"):
530	id = wx.NewId()
531	helpmenu.Append(id,'&%s help' % item.sub_menu, '')
532	wx.EVT_MENU(self, id, item.help)
533
534	if config._do_aboutbox:
535	id = wx.NewId()
536	helpmenu.Append(id,'&About', 'Software information')
537	wx.EVT_MENU(self, id, self._onAbout)
538	id = wx.NewId()
539	helpmenu.Append(id,'&Check for update', 'Check for the latest version of %s' % config.__appname__)
540	wx.EVT_MENU(self, id, self._check_update)
541
542
543
544
545	# Look for plug-in menus
546	# Add available plug-in sub-menus.
547	for item in self.plugins:
548	if hasattr(item, "populate_menu"):
549	for (self.next_id, menu, name) in item.populate_menu(self.next_id, self):
550	menubar.Append(menu, name)
551
552
553	menubar.Append(helpmenu, '&Help')
554
555	self.SetMenuBar(menubar)
556
557
558
559	def _on_status_event(self, evt):
560	"""
561	Display status message
562	"""
563	self.SetStatusText(str(evt.status))
564
565
566	def _on_view(self, evt):
567	"""
568	A panel was selected to be shown. If it's not already
569	shown, display it.
570	@param evt: menu event
571	"""
572	self.show_panel(evt.GetId())
573
574	def show_panel(self, uid):
575	"""
576	Shows the panel with the given id
577	@param uid: unique ID number of the panel to show
578	"""
579	ID = str(uid)
580	config.printEVT("show_panel: %s" % ID)
581	if ID in self.panels.keys():
582	if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():
583	self._mgr.GetPane(self.panels[ID].window_name).Show()
584	# Hide default panel
585	self._mgr.GetPane(self.panels["default"].window_name).Hide()
586
587
588	self._mgr.Update()
589
590	def _on_open(self, event):
591	from data_loader import plot_data
592	path = self.choose_file()
593
594	if path and os.path.isfile(path):
595	plot_data(self, path)
596
597
598
599	def _onClose(self, event):
600	import sys
601	wx.Exit()
602	sys.exit()
603
604	def Close(self, event=None):
605	"""
606	Quit the application
607	"""
608	import sys
609	wx.Frame.Close(self)
610	wx.Exit()
611	sys.exit()
612
613
614	def _check_update(self, event=None):
615	"""
616	Check with the deployment server whether a new version
617	of the application is available
618	"""
619	import urllib
620	try:
621	h = urllib.urlopen(config.__update_URL__)
622	lines = h.readlines()
623	line = ''
624	if len(lines)>0:
625	line = lines[0]
626
627	toks = line.lstrip().rstrip().split('.')
628	toks_current = config.__version__.split('.')
629	update_available = False
630	for i in range(len(toks)):
631	if int(toks[i])>int(toks_current[i]):
632	update_available = True
633	if update_available:
634	#print "Version %s is available" % line.rstrip().lstrip()
635	self.SetStatusText("Version %s is available! See the Help menu to download it." % line.rstrip().lstrip())
636	if event != None:
637	import webbrowser
638	webbrowser.open(config.__download_page__)
639	else:
640	self.SetStatusText("You have the latest version of %s" % config.__appname__)
641	#print "Server version = %s" % line.rstrip().lstrip()
642	except:
643	self.SetStatusText("You have the latest version of %s" % config.__appname__)
644
645
646	def _onAbout(self, evt):
647	"""
648	Pop up the about dialog
649	@param evt: menu event
650	"""
651	if config._do_aboutbox:
652	import aboutbox
653	dialog = aboutbox.DialogAbout(None, -1, "")
654	dialog.ShowModal()
655
656	def set_manager(self, manager):
657	"""
658	Sets the application manager for this frame
659	@param manager: frame manager
660	"""
661	self.app_manager = manager
662
663	def post_init(self):
664	"""
665	This initialization method is called after the GUI
666	has been created and all plug-ins loaded. It calls
667	the post_init() method of each plug-in (if it exists)
668	so that final initialization can be done.
669	"""
670	for item in self.plugins:
671	if hasattr(item, "post_init"):
672	item.post_init()
673
674	def set_perspective(self, panels):
675	"""
676	Sets the perspective of the GUI.
677	Opens all the panels in the list, and closes
678	all the others.
679
680	@param panels: list of panels
681	"""
682	print "gui_mng.set_perspective"
683	for item in self.panels:
684	# Check whether this is a sticky panel
685	if hasattr(self.panels[item], "ALWAYS_ON"):
686	if self.panels[item].ALWAYS_ON:
687	continue
688
689	if self.panels[item].window_name in panels:
690	if not self._mgr.GetPane(self.panels[item].window_name).IsShown():
691	self._mgr.GetPane(self.panels[item].window_name).Show()
692	else:
693	if self._mgr.GetPane(self.panels[item].window_name).IsShown():
694	self._mgr.GetPane(self.panels[item].window_name).Hide()
695
696	self._mgr.Update()
697
698	def choose_file(self):
699	"""
700	Functionality that belongs elsewhere
701	Should add a hook to specify the preferred file type/extension.
702	"""
703	#TODO: clean this up
704	from data_loader import choose_data_file
705	path = choose_data_file(self, self._default_save_location)
706	if not path==None:
707	try:
708	self._default_save_location = os.path.dirname(path)
709	except:
710	pass
711	return path
712
713	def load_ascii_1D(self, path):
714	from data_loader import load_ascii_1D
715	return load_ascii_1D(path)
716
717	class DefaultPanel(wx.Panel):
718	"""
719	Defines the API for a panels to work with
720	the GUI manager
721	"""
722	## Internal nickname for the window, used by the AUI manager
723	window_name = "default"
724	## Name to appear on the window title bar
725	window_caption = "Welcome panel"
726	## Flag to tell the AUI manager to put this panel in the center pane
727	CENTER_PANE = True
728
729
730	# Toy application to test this Frame
731	class ViewApp(wx.App):
732	def OnInit(self):
733	#from gui_manager import ViewerFrame
734	self.frame = ViewerFrame(None, -1, config.__appname__)
735	self.frame.Show(True)
736
737	if hasattr(self.frame, 'special'):
738	print "Special?", self.frame.special.__class__.__name__
739	self.frame.special.SetCurrent()
740	self.SetTopWindow(self.frame)
741	return True
742
743	def set_manager(self, manager):
744	"""
745	Sets a reference to the application manager
746	of the GUI manager (Frame)
747	"""
748	self.frame.set_manager(manager)
749
750	def build_gui(self):
751	"""
752	Build the GUI
753	"""
754	self.frame.build_gui()
755	self.frame.post_init()
756
757	def add_perspective(self, perspective):
758	"""
759	Manually add a perspective to the application GUI
760	"""
761	self.frame.add_perspective(perspective)
762
763
764	if __name__ == "__main__":
765	app = ViewApp(0)
766	app.MainLoop()

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/guiframe/gui_manager.py @ 9a3adab

Download in other formats: