gui_manager.py @ 7705306

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 7705306 was 7681bac, checked in by Mathieu Doucet <doucetm@…>, 16 years ago
Added docs.
Property mode set to `100644`
File size: 26.2 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):
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=(1000, 1000))
182
183	# Logging info
184	logging.basicConfig(level=logging.DEBUG,
185	format='%(asctime)s %(levelname)s %(message)s',
186	filename='sans_app.log',
187	filemode='w')
188
189	path = os.path.dirname(__file__)
190	ico_file = os.path.join(path,'images/ball.ico')
191	if os.path.isfile(ico_file):
192	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
193	else:
194	ico_file = os.path.join(os.getcwd(),'images/ball.ico')
195	if os.path.isfile(ico_file):
196	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
197
198	## Application manager
199	self.app_manager = None
200
201	## Find plug-ins
202	# Modify this so that we can specify the directory to look into
203	self.plugins = self._find_plugins()
204	self.plugins.append(plotting.Plugin())
205
206	## List of panels
207	self.panels = {}
208
209	## Next available ID for wx gui events
210	#TODO: No longer used - remove all calls to this
211	self.next_id = 20000
212
213	# Default locations
214	self._default_save_location = os.getcwd()
215
216	## Default welcome panel
217	self.defaultPanel = DefaultPanel(self, -1, style=wx.RAISED_BORDER)
218
219	# self.build_gui()
220
221	# Register the close event so it calls our own method
222	wx.EVT_CLOSE(self, self._onClose)
223	# Register to status events
224	self.Bind(EVT_STATUS, self._on_status_event)
225
226	def build_gui(self):
227	# Set up the layout
228	self._setup_layout()
229
230	# Set up the menu
231	self._setup_menus()
232
233	self.Fit()
234
235	def _setup_layout(self):
236	"""
237	Set up the layout
238	"""
239	# Status bar
240	self.sb = self.CreateStatusBar()
241	self.SetStatusText("")
242
243	# Add panel
244	self._mgr = wx.aui.AuiManager(self)
245
246	# Load panels
247	self._load_panels()
248
249	self._mgr.Update()
250
251	def add_perspective(self, plugin):
252	"""
253	Add a perspective if it doesn't already
254	exist.
255	"""
256	is_loaded = False
257	for item in self.plugins:
258	if plugin.__class__==item.__class__:
259	print "Plugin %s already loaded" % plugin.__class__.__name__
260	is_loaded = True
261
262	if not is_loaded:
263	self.plugins.append(plugin)
264
265	def _find_plugins(self, dir="perspectives"):
266	"""
267	Find available perspective plug-ins
268	@param dir: directory in which to look for plug-ins
269	@return: list of plug-ins
270	"""
271	import imp
272	print "Looking for plug-ins in %s" % dir
273	# List of plug-in objects
274
275	#path_exe = os.getcwd()
276	#path_plugs = os.path.join(path_exe, dir)
277	f = open("load.log",'w')
278	f.write(os.getcwd()+'\n\n')
279	#f.write(str(os.listdir(dir))+'\n')
280
281
282	plugins = []
283	# Go through files in panels directory
284	try:
285	list = os.listdir(dir)
286	for item in list:
287	toks = os.path.splitext(os.path.basename(item))
288	name = None
289	if not toks[0] == '__init__':
290
291	if toks[1]=='.py' or toks[1]=='':
292	name = toks[0]
293
294	path = [os.path.abspath(dir)]
295	file = None
296	try:
297	if toks[1]=='':
298	f.write("trying to import \n")
299	mod_path = '.'.join([dir, name])
300	f.write("mod_path= %s\n" % mod_path)
301	module = __import__(mod_path, globals(), locals(), [name])
302	f.write(str(module)+'\n')
303	else:
304	(file, path, info) = imp.find_module(name, path)
305	module = imp.load_module( name, file, item, info )
306	if hasattr(module, "PLUGIN_ID"):
307	try:
308	plugins.append(module.Plugin())
309	print "Found plug-in: %s" % module.PLUGIN_ID
310	except:
311	config.printEVT("Error accessing PluginPanel in %s\n %s" % (name, sys.exc_value))
312
313	except:
314	print sys.exc_value
315	f.write(str(sys.exc_value)+'\n')
316	finally:
317	if not file==None:
318	file.close()
319	except:
320	# Should raise and catch at a higher level and display error on status bar
321	pass
322	f.write(str(plugins)+'\n')
323	f.close()
324	return plugins
325
326
327
328	def _load_panels(self):
329	"""
330	Load all panels in the panels directory
331	"""
332
333	# Look for plug-in panels
334	panels = []
335	for item in self.plugins:
336	if hasattr(item, "get_panels"):
337	ps = item.get_panels(self)
338	panels.extend(ps)
339
340	# Show a default panel with some help information
341	# It also sets the size of the application windows
342	self.panels["default"] = self.defaultPanel
343	self._mgr.AddPane(self.defaultPanel, wx.aui.AuiPaneInfo().
344	Name("default").
345	CenterPane().
346	BestSize(wx.Size(900,800)).
347	MinSize(wx.Size(800,700)).
348	Show())
349
350	# Add the panels to the AUI manager
351	for panel_class in panels:
352	p = panel_class
353	id = wx.NewId()
354
355	# Check whether we need to put this panel
356	# in the center pane
357	if hasattr(p, "CENTER_PANE"):
358	if p.CENTER_PANE:
359	self.panels[str(id)] = p
360	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
361	Name(p.window_name).Caption(p.window_caption).
362	CenterPane().
363	BestSize(wx.Size(600,600)).
364	MinSize(wx.Size(200,200)).
365	Hide())
366
367	else:
368	self.panels[str(id)] = p
369	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
370	Name(p.window_name).Caption(p.window_caption).
371	#Floatable().
372	#Float().
373	Right().
374	Dock().
375	TopDockable().
376	BottomDockable().
377	LeftDockable().
378	RightDockable().
379	MinimizeButton().
380	Hide().
381	#Show().
382	BestSize(wx.Size(400,400)).
383	MinSize(wx.Size(300,200)))
384
385
386	def get_context_menu(self, graph=None):
387	"""
388	Get the context menu items made available
389	by the different plug-ins.
390	This function is used by the plotting module
391	"""
392	menu_list = []
393	for item in self.plugins:
394	if hasattr(item, "get_context_menu"):
395	menu_list.extend(item.get_context_menu(graph))
396
397	return menu_list
398
399	def popup_panel(self, p):
400	"""
401	Add a panel object to the AUI manager
402	@param p: panel object to add to the AUI manager
403	@return: ID of the event associated with the new panel [int]
404	"""
405
406	ID = wx.NewId()
407	self.panels[str(ID)] = p
408
409	count = 0
410	for item in self.panels:
411	if self.panels[item].window_name.startswith(p.window_name):
412	count += 1
413
414	windowname = p.window_name
415	caption = p.window_caption
416	if count>0:
417	windowname += str(count+1)
418	caption += (' '+str(count))
419
420	p.window_name = windowname
421	p.window_caption = caption
422
423	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
424	Name(windowname).Caption(caption).
425	Floatable().
426	#Float().
427	Right().
428	Dock().
429	TopDockable().
430	BottomDockable().
431	LeftDockable().
432	RightDockable().
433	MinimizeButton().
434	#Hide().
435	#Show().
436	BestSize(wx.Size(400,400)).
437	MinSize(wx.Size(200,200)))
438
439	# Register for showing/hiding the panel
440	wx.EVT_MENU(self, ID, self._on_view)
441
442	self._mgr.Update()
443	return ID
444
445	def _setup_menus(self):
446	"""
447	Set up the application menus
448	"""
449	# Menu
450	menubar = wx.MenuBar()
451
452	# File menu
453	filemenu = wx.Menu()
454
455	id = wx.NewId()
456	filemenu.Append(id, '&Open', 'Open a file')
457	wx.EVT_MENU(self, id, self._on_open)
458
459	id = wx.NewId()
460	filemenu.Append(id,'&Quit', 'Exit')
461	wx.EVT_MENU(self, id, self.Close)
462
463	# Add sub menus
464	menubar.Append(filemenu, '&File')
465
466	# Plot menu
467	# Attach a menu item for each panel in our
468	# panel list that also appears in a plug-in.
469	# TODO: clean this up. We should just identify
470	# plug-in panels and add them all.
471
472	# Only add the panel menu if there is more than one panel
473	n_panels = 0
474	for plug in self.plugins:
475	pers = plug.get_perspective()
476	if len(pers)>0:
477	n_panels += 1
478
479	if n_panels>1:
480	viewmenu = wx.Menu()
481	for plug in self.plugins:
482	plugmenu = wx.Menu()
483	pers = plug.get_perspective()
484	if len(pers)>0:
485	for item in self.panels:
486	if item == 'default':
487	continue
488	panel = self.panels[item]
489	if panel.window_name in pers:
490	plugmenu.Append(int(item), panel.window_caption, "Show %s window" % panel.window_caption)
491	wx.EVT_MENU(self, int(item), self._on_view)
492
493	viewmenu.AppendMenu(wx.NewId(), plug.sub_menu, plugmenu, plug.sub_menu)
494
495	menubar.Append(viewmenu, '&Panel')
496
497	# Perspective
498	# Attach a menu item for each defined perspective.
499	# Only add the perspective menu if there are more than one perspectves
500	n_perspectives = 0
501	for plug in self.plugins:
502	if len(plug.get_perspective()) > 0:
503	n_perspectives += 1
504
505	if n_perspectives>1:
506	p_menu = wx.Menu()
507	for plug in self.plugins:
508	if len(plug.get_perspective()) > 0:
509	id = wx.NewId()
510	p_menu.Append(id, plug.sub_menu, "Switch to %s perspective" % plug.sub_menu)
511	wx.EVT_MENU(self, id, plug.on_perspective)
512	menubar.Append(p_menu, '&Perspective')
513
514	# Help menu
515	helpmenu = wx.Menu()
516
517	# Look for help item in plug-ins
518	for item in self.plugins:
519	if hasattr(item, "help"):
520	id = wx.NewId()
521	helpmenu.Append(id,'&%s help' % item.sub_menu, '')
522	wx.EVT_MENU(self, id, item.help)
523
524	if config._do_aboutbox:
525	id = wx.NewId()
526	helpmenu.Append(id,'&About', 'Software information')
527	wx.EVT_MENU(self, id, self._onAbout)
528	id = wx.NewId()
529	helpmenu.Append(id,'&Check for update', 'Check for the latest version of %s' % config.__appname__)
530	wx.EVT_MENU(self, id, self._check_update)
531
532
533
534
535	# Look for plug-in menus
536	# Add available plug-in sub-menus.
537	for item in self.plugins:
538	if hasattr(item, "populate_menu"):
539	for (self.next_id, menu, name) in item.populate_menu(self.next_id, self):
540	menubar.Append(menu, name)
541
542
543	menubar.Append(helpmenu, '&Help')
544
545	self.SetMenuBar(menubar)
546
547
548
549	def _on_status_event(self, evt):
550	"""
551	Display status message
552	"""
553	self.SetStatusText(str(evt.status))
554
555
556	def _on_view(self, evt):
557	"""
558	A panel was selected to be shown. If it's not already
559	shown, display it.
560	@param evt: menu event
561	"""
562	self.show_panel(evt.GetId())
563
564	def show_panel(self, uid):
565	"""
566	Shows the panel with the given id
567	@param uid: unique ID number of the panel to show
568	"""
569	ID = str(uid)
570	config.printEVT("show_panel: %s" % ID)
571	if ID in self.panels.keys():
572	if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():
573	self._mgr.GetPane(self.panels[ID].window_name).Show()
574	# Hide default panel
575	self._mgr.GetPane(self.panels["default"].window_name).Hide()
576
577
578	self._mgr.Update()
579
580	def _on_open(self, event):
581	from data_loader import plot_data
582	path = self.choose_file()
583
584	if path and os.path.isfile(path):
585	plot_data(self, path)
586
587
588
589	def _onClose(self, event):
590	import sys
591	wx.Exit()
592	sys.exit()
593
594	def Close(self, event=None):
595	"""
596	Quit the application
597	"""
598	import sys
599	wx.Frame.Close(self)
600	wx.Exit()
601	sys.exit()
602
603
604	def _check_update(self, event=None):
605	"""
606	Check with the deployment server whether a new version
607	of the application is available
608	"""
609	import urllib
610	try:
611	h = urllib.urlopen(config.__update_URL__)
612	lines = h.readlines()
613	line = ''
614	if len(lines)>0:
615	line = lines[0]
616
617	toks = line.lstrip().rstrip().split('.')
618	toks_current = config.__version__.split('.')
619	update_available = False
620	for i in range(len(toks)):
621	if int(toks[i])>int(toks_current[i]):
622	update_available = True
623	if update_available:
624	#print "Version %s is available" % line.rstrip().lstrip()
625	self.SetStatusText("Version %s is available! See the Help menu to download it." % line.rstrip().lstrip())
626	if event != None:
627	import webbrowser
628	webbrowser.open(config.__download_page__)
629	else:
630	self.SetStatusText("You have the latest version of %s" % config.__appname__)
631	#print "Server version = %s" % line.rstrip().lstrip()
632	except:
633	self.SetStatusText("You have the latest version of %s" % config.__appname__)
634
635
636	def _onAbout(self, evt):
637	"""
638	Pop up the about dialog
639	@param evt: menu event
640	"""
641	if config._do_aboutbox:
642	import aboutbox
643	dialog = aboutbox.DialogAbout(None, -1, "")
644	dialog.ShowModal()
645
646	def set_manager(self, manager):
647	"""
648	Sets the application manager for this frame
649	@param manager: frame manager
650	"""
651	self.app_manager = manager
652
653	def post_init(self):
654	"""
655	This initialization method is called after the GUI
656	has been created and all plug-ins loaded. It calls
657	the post_init() method of each plug-in (if it exists)
658	so that final initialization can be done.
659	"""
660	for item in self.plugins:
661	if hasattr(item, "post_init"):
662	item.post_init()
663
664	def set_perspective(self, panels):
665	"""
666	Sets the perspective of the GUI.
667	Opens all the panels in the list, and closes
668	all the others.
669
670	@param panels: list of panels
671	"""
672	print "gui_mng.set_perspective"
673	for item in self.panels:
674	# Check whether this is a sticky panel
675	if hasattr(self.panels[item], "ALWAYS_ON"):
676	if self.panels[item].ALWAYS_ON:
677	continue
678
679	if self.panels[item].window_name in panels:
680	if not self._mgr.GetPane(self.panels[item].window_name).IsShown():
681	self._mgr.GetPane(self.panels[item].window_name).Show()
682	else:
683	if self._mgr.GetPane(self.panels[item].window_name).IsShown():
684	self._mgr.GetPane(self.panels[item].window_name).Hide()
685
686	self._mgr.Update()
687
688	def choose_file(self):
689	"""
690	Functionality that belongs elsewhere
691	Should add a hook to specify the preferred file type/extension.
692	"""
693	#TODO: clean this up
694	from data_loader import choose_data_file
695	path = choose_data_file(self, self._default_save_location)
696	if not path==None:
697	try:
698	self._default_save_location = os.path.dirname(path)
699	except:
700	pass
701	return path
702
703	def load_ascii_1D(self, path):
704	from data_loader import load_ascii_1D
705	return load_ascii_1D(path)
706
707	class DefaultPanel(wx.Panel):
708	"""
709	Defines the API for a panels to work with
710	the GUI manager
711	"""
712	## Internal nickname for the window, used by the AUI manager
713	window_name = "default"
714	## Name to appear on the window title bar
715	window_caption = "Welcome panel"
716	## Flag to tell the AUI manager to put this panel in the center pane
717	CENTER_PANE = True
718
719
720	# Toy application to test this Frame
721	class ViewApp(wx.App):
722	def OnInit(self):
723	#from gui_manager import ViewerFrame
724	self.frame = ViewerFrame(None, -1, config.__appname__)
725	self.frame.Show(True)
726
727	if hasattr(self.frame, 'special'):
728	print "Special?", self.frame.special.__class__.__name__
729	self.frame.special.SetCurrent()
730	self.SetTopWindow(self.frame)
731	return True
732
733	def set_manager(self, manager):
734	"""
735	Sets a reference to the application manager
736	of the GUI manager (Frame)
737	"""
738	self.frame.set_manager(manager)
739
740	def build_gui(self):
741	"""
742	Build the GUI
743	"""
744	self.frame.build_gui()
745	self.frame.post_init()
746
747	def add_perspective(self, perspective):
748	"""
749	Manually add a perspective to the application GUI
750	"""
751	self.frame.add_perspective(perspective)
752
753
754	if __name__ == "__main__":
755	app = ViewApp(0)
756	app.MainLoop()

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

SasView

source: sasview/guiframe/gui_manager.py @ 7705306

Download in other formats: