gui_manager.py @ 7f291a3

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 7f291a3 was 8d8415f, checked in by Jae Cho <jhjcho@…>, 13 years ago
seems a little faster w/ Show()
Property mode set to `100644`
File size: 102.7 KB

Line
1
2	################################################################################
3	#This software was developed by the University of Tennessee as part of the
4	#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
5	#project funded by the US National Science Foundation.
6	#
7	#See the license text in license.txt
8	#
9	#copyright 2008, University of Tennessee
10	################################################################################
11
12
13	import wx
14	import wx.aui
15	import os
16	import sys
17	import xml
18
19
20	# Try to find a local config
21	import imp
22	path = os.getcwd()
23	if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
24	(os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
25	fObj, path_config, descr = imp.find_module('local_config', [path])
26	try:
27	config = imp.load_module('local_config', fObj, path_config, descr)
28	except:
29	# Didn't find local config, load the default
30	import config
31	finally:
32	if fObj:
33	fObj.close()
34	else:
35	# Try simply importing local_config
36	import local_config as config
37	#path = os.path.sys.path[0]
38	PATH_APP = path
39
40	#import compileall
41	import py_compile
42	c_name = os.path.join(path, 'custom_config.py')
43	if(os.path.isfile("%s/%s.py" % (path, 'custom_config'))):
44	py_compile.compile(file=c_name)
45	#compileall.compile_dir(dir=path, force=True, quiet=0)
46	cfObj, path_cconfig, descr = imp.find_module('custom_config', [path])
47	try:
48	custom_config = imp.load_module('custom_config', cfObj, path, descr)
49	except:
50	custom_config = None
51	finally:
52	if custom_config != None:
53	cfObj.close()
54
55
56	import warnings
57	warnings.simplefilter("ignore")
58
59	import logging
60
61	from sans.guiframe.events import EVT_STATUS
62	from sans.guiframe.events import EVT_APPEND_BOOKMARK
63	from sans.guiframe.events import EVT_PANEL_ON_FOCUS
64	from sans.guiframe.events import EVT_NEW_LOAD_DATA
65	from sans.guiframe.events import StatusEvent
66	from sans.guiframe.events import NewPlotEvent
67	from sans.guiframe.gui_style import GUIFRAME
68	from sans.guiframe.gui_style import GUIFRAME_ID
69	#from sans.guiframe.events import NewLoadedDataEvent
70	from sans.guiframe.data_panel import DataPanel
71	from sans.guiframe.panel_base import PanelBase
72	from sans.guiframe.gui_toolbar import GUIToolBar
73	from DataLoader.loader import Loader
74
75
76	#read some constants from config
77	APPLICATION_STATE_EXTENSION = config.APPLICATION_STATE_EXTENSION
78	APPLICATION_NAME = config.__appname__
79	SPLASH_SCREEN_PATH = config.SPLASH_SCREEN_PATH
80
81	SPLASH_SCREEN_WIDTH = config.SPLASH_SCREEN_WIDTH
82	SPLASH_SCREEN_HEIGHT = config.SPLASH_SCREEN_HEIGHT
83	SS_MAX_DISPLAY_TIME = config.SS_MAX_DISPLAY_TIME
84
85	try:
86	DATALOADER_SHOW = custom_config.DATALOADER_SHOW
87	TOOLBAR_SHOW = custom_config.TOOLBAR_SHOW
88	FIXED_PANEL = custom_config.FIXED_PANEL
89	WELCOME_PANEL_SHOW = custom_config.WELCOME_PANEL_SHOW
90	PLOPANEL_WIDTH = custom_config.PLOPANEL_WIDTH
91	DATAPANEL_WIDTH = custom_config.DATAPANEL_WIDTH
92	GUIFRAME_WIDTH = custom_config.GUIFRAME_WIDTH
93	GUIFRAME_HEIGHT = custom_config.GUIFRAME_HEIGHT
94	DEFAULT_PERSPECTIVE = custom_config.DEFAULT_PERSPECTIVE
95	CLEANUP_PLOT = custom_config.CLEANUP_PLOT
96	except:
97	DATALOADER_SHOW = True
98	TOOLBAR_SHOW = True
99	FIXED_PANEL = True
100	WELCOME_PANEL_SHOW = False
101	PLOPANEL_WIDTH = config.PLOPANEL_WIDTH
102	DATAPANEL_WIDTH = config.DATAPANEL_WIDTH
103	GUIFRAME_WIDTH = config.GUIFRAME_WIDTH
104	GUIFRAME_HEIGHT = config.GUIFRAME_HEIGHT
105	DEFAULT_PERSPECTIVE = None
106	CLEANUP_PLOT = False
107
108	DEFAULT_STYLE = config.DEFAULT_STYLE
109
110
111	PLOPANEL_HEIGTH = config.PLOPANEL_HEIGTH
112	DATAPANEL_HEIGHT = config.DATAPANEL_HEIGHT
113	PLUGIN_STATE_EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS
114	extension_list = []
115	if APPLICATION_STATE_EXTENSION is not None:
116	extension_list.append(APPLICATION_STATE_EXTENSION)
117	EXTENSIONS = PLUGIN_STATE_EXTENSIONS + extension_list
118	try:
119	PLUGINS_WLIST = '\|'.join(config.PLUGINS_WLIST)
120	except:
121	PLUGINS_WLIST = ''
122	APPLICATION_WLIST = config.APPLICATION_WLIST
123	if sys.platform.count("darwin")==0:
124	IS_WIN = True
125	else:
126	IS_WIN = False
127
128	class ViewerFrame(wx.Frame):
129	"""
130	Main application frame
131	"""
132
133	def __init__(self, parent, title,
134	size=(GUIFRAME_WIDTH, GUIFRAME_HEIGHT),
135	gui_style=DEFAULT_STYLE,
136	pos=wx.DefaultPosition):
137	"""
138	Initialize the Frame object
139	"""
140
141	wx.Frame.__init__(self, parent=parent, title=title, pos=pos,size=size)
142	# title
143	self.title = title
144	# Preferred window size
145	self._window_width, self._window_height = size
146	self.__gui_style = gui_style
147	# Logging info
148	logging.basicConfig(level=logging.DEBUG,
149	format='%(asctime)s %(levelname)s %(message)s',
150	filename='sans_app.log',
151	filemode='w')
152	path = os.path.dirname(__file__)
153	temp_path = os.path.join(path,'images')
154	ico_file = os.path.join(temp_path,'ball.ico')
155	if os.path.isfile(ico_file):
156	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
157	else:
158	temp_path = os.path.join(os.getcwd(),'images')
159	ico_file = os.path.join(temp_path,'ball.ico')
160	if os.path.isfile(ico_file):
161	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
162	else:
163	ico_file = os.path.join(os.path.dirname(os.path.sys.path[0]),
164	'images', 'ball.ico')
165	if os.path.isfile(ico_file):
166	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
167	self.path = PATH_APP
168	## Application manager
169	self._input_file = None
170	self.app_manager = None
171	self._mgr = None
172	#add current perpsective
173	self._current_perspective = None
174	self._plotting_plugin = None
175	self._data_plugin = None
176	#Menu bar and item
177	self._menubar = None
178	self._file_menu = None
179	self._data_menu = None
180	self._view_menu = None
181	self._window_menu = None
182	self._data_panel_menu = None
183	self._help_menu = None
184	self._tool_menu = None
185	self._applications_menu_pos = -1
186	self._applications_menu_name = None
187	self._applications_menu = None
188	self._edit_menu = None
189	self._toolbar_menu = None
190	self._save_appl_menu = None
191	#tool bar
192	self._toolbar = None
193	# number of plugins
194	self._num_perspectives = 0
195	# plot duck cleanup option
196	self.cleanup_plots = CLEANUP_PLOT
197	# (un)-focus color
198	#self.color = '#b3b3b3'
199	## Find plug-ins
200	# Modify this so that we can specify the directory to look into
201	self.plugins = []
202	#add local plugin
203	self.plugins += self._get_local_plugins()
204	self.plugins += self._find_plugins()
205	## List of panels
206	self.panels = {}
207	# List of plot panels
208	self.plot_panels = {}
209
210	# Default locations
211	self._default_save_location = os.getcwd()
212
213	# Welcome panel
214	self.defaultPanel = None
215	#panel on focus
216	self.panel_on_focus = None
217	#control_panel on focus
218	self.cpanel_on_focus = None
219	self.loader = Loader()
220	#data manager
221	from data_manager import DataManager
222	self._data_manager = DataManager()
223	self._data_panel = DataPanel(parent=self)
224	if self.panel_on_focus is not None:
225	self._data_panel.set_panel_on_focus(self.panel_on_focus.window_caption)
226	# list of plot panels in schedule to full redraw
227	self.schedule = False
228	#self.callback = True
229	self._idle_count = 0
230	self.schedule_full_draw_list = []
231	self.idletimer = wx.CallLater(1, self._onDrawIdle)
232
233	# Check for update
234	#self._check_update(None)
235	# Register the close event so it calls our own method
236	wx.EVT_CLOSE(self, self.Close)
237	# Register to status events
238	self.Bind(EVT_STATUS, self._on_status_event)
239	#Register add extra data on the same panel event on load
240	self.Bind(EVT_PANEL_ON_FOCUS, self.set_panel_on_focus)
241	self.Bind(EVT_APPEND_BOOKMARK, self.append_bookmark)
242	self.Bind(EVT_NEW_LOAD_DATA, self.on_load_data)
243
244	self.setup_custom_conf()
245
246	def setup_custom_conf(self):
247	"""
248	Set up custom configuration if exists
249	"""
250	if custom_config == None:
251	return
252
253	if not FIXED_PANEL:
254	self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
255	self.__gui_style \|= GUIFRAME.FLOATING_PANEL
256
257	if not DATALOADER_SHOW:
258	self.__gui_style &= (~GUIFRAME.MANAGER_ON)
259
260	if not TOOLBAR_SHOW:
261	self.__gui_style &= (~GUIFRAME.TOOLBAR_ON)
262
263	if WELCOME_PANEL_SHOW:
264	self.__gui_style \|= GUIFRAME.WELCOME_PANEL_ON
265
266	def set_custom_default_perspective(self):
267	"""
268	Set default starting perspective
269	"""
270	if custom_config == None:
271	return
272	for plugin in self.plugins:
273	try:
274	if plugin.sub_menu == DEFAULT_PERSPECTIVE:
275
276	plugin.on_perspective(event=None)
277	#self._check_applications_menu()
278	break
279	except:
280	pass
281	return
282
283	def on_load_data(self, event):
284	"""
285	received an event to trigger load from data plugin
286	"""
287	if self._data_plugin is not None:
288	self._data_plugin.load_data(event)
289
290	def get_current_perspective(self):
291	"""
292	return the current perspective
293	"""
294	return self._current_perspective
295
296	def set_input_file(self, input_file):
297	"""
298	:param input_file: file to read
299	"""
300	self._input_file = input_file
301
302	def get_data_manager(self):
303	"""
304	"""
305	return self._data_manager
306
307	def get_toolbar(self):
308	"""
309	"""
310	return self._toolbar
311
312	def set_panel_on_focus(self, event):
313	"""
314	Store reference to the last panel on focus
315	update the toolbar if available
316	update edit menu if available
317	"""
318	if event != None:
319	self.panel_on_focus = event.panel
320	panel_name = 'No panel on focus'
321	application_name = 'No Selected Analysis'
322	if self.panel_on_focus is not None:
323	if self.panel_on_focus not in self.plot_panels.values():
324	for ID in self.panels.keys():
325	if self.panel_on_focus != self.panels[ID]:
326	self.panels[ID].on_kill_focus(None)
327
328	if self._data_panel is not None and \
329	self.panel_on_focus is not None:
330	panel_name = self.panel_on_focus.window_caption
331	ID = self.panel_on_focus.uid
332	self._data_panel.set_panel_on_focus(ID)
333	#update combo
334	if self.panel_on_focus in self.plot_panels.values():
335	combo = self._data_panel.cb_plotpanel
336	combo_title = str(self.panel_on_focus.window_caption)
337	combo.SetStringSelection(combo_title)
338	combo.SetToolTip( wx.ToolTip(combo_title ))
339	elif self.panel_on_focus != self._data_panel:
340	cpanel = self.panel_on_focus
341	if self.cpanel_on_focus != cpanel:
342	self.cpanel_on_focus = self.panel_on_focus
343	#update toolbar
344	self._update_toolbar_helper()
345	#update edit menu
346	self.enable_edit_menu()
347
348	def reset_bookmark_menu(self, panel):
349	"""
350	Reset Bookmark menu list
351
352	: param panel: a control panel or tap where the bookmark is
353	"""
354	cpanel = panel
355	if self._toolbar != None and cpanel._bookmark_flag:
356	for item in self._toolbar.get_bookmark_items():
357	self._toolbar.remove_bookmark_item(item)
358	self._toolbar.add_bookmark_default()
359	pos = 0
360	for bitem in cpanel.popUpMenu.GetMenuItems():
361	pos += 1
362	if pos < 3:
363	continue
364	id = bitem.GetId()
365	label = bitem.GetLabel()
366	self._toolbar.append_bookmark_item(id, label)
367	wx.EVT_MENU(self, id, cpanel._back_to_bookmark)
368	self._toolbar.Realize()
369
370
371	def build_gui(self):
372	"""
373	"""
374	# set tool bar
375	self._setup_tool_bar()
376	# Set up the layout
377	self._setup_layout()
378
379	# Set up the menu
380	self._setup_menus()
381
382	try:
383	self.load_from_cmd(self._input_file)
384	except:
385	msg = "%s Cannot load file %s\n" %(str(APPLICATION_NAME),
386	str(self._input_file))
387	msg += str(sys.exc_value) + '\n'
388	print msg
389	if self._data_panel is not None:
390	self._data_panel.fill_cbox_analysis(self.plugins)
391	self.post_init()
392	# Set Custom default
393	self.set_custom_default_perspective()
394	# Set up extra custom tool menu
395	self._setup_extra_custom()
396	#self.Show(True)
397	#self._check_update(None)
398
399	def _setup_extra_custom(self):
400	"""
401	Set up toolbar and welcome view if needed
402	"""
403	style = self.__gui_style & GUIFRAME.TOOLBAR_ON
404	if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
405	self._on_toggle_toolbar()
406
407	# Set Custom deafult start page
408	welcome_style = self.__gui_style & GUIFRAME.WELCOME_PANEL_ON
409	if welcome_style == GUIFRAME.WELCOME_PANEL_ON:
410	self.show_welcome_panel(None)
411
412	def _setup_layout(self):
413	"""
414	Set up the layout
415	"""
416	# Status bar
417	from gui_statusbar import StatusBar
418	self.sb = StatusBar(self, wx.ID_ANY)
419	self.SetStatusBar(self.sb)
420	# Add panel
421	default_flag = wx.aui.AUI_MGR_DEFAULT#\| wx.aui.AUI_MGR_ALLOW_ACTIVE_PANE
422	self._mgr = wx.aui.AuiManager(self, flags=default_flag)
423	self._mgr.SetDockSizeConstraint(0.5, 0.5)
424	# border color
425	#self.b_color = wx.aui.AUI_DOCKART_BORDER_COLOUR
426	#self._mgr.GetArtProvider().SetColor(self.b_color, self.color)
427	#self._mgr.SetArtProvider(wx.aui.AuiDockArt(wx.AuiDefaultDockArt))
428	#print "set", self._dockart.GetColour(13)
429	# Load panels
430	self._load_panels()
431	self.set_default_perspective()
432	self._mgr.Update()
433
434	def SetStatusText(self, args, *kwds):
435	"""
436	"""
437	number = self.sb.get_msg_position()
438	wx.Frame.SetStatusText(number=number, args, *kwds)
439
440	def PopStatusText(self, args, *kwds):
441	"""
442	"""
443	field = self.sb.get_msg_position()
444	wx.Frame.PopStatusText(field=field)
445
446	def PushStatusText(self, args, *kwds):
447	"""
448	"""
449	field = self.sb.get_msg_position()
450	wx.Frame.PushStatusText(self, field=field, string=string)
451
452	def add_perspective(self, plugin):
453	"""
454	Add a perspective if it doesn't already
455	exist.
456	"""
457	self._num_perspectives += 1
458	is_loaded = False
459	for item in self.plugins:
460	if plugin.__class__ == item.__class__:
461	msg = "Plugin %s already loaded" % plugin.sub_menu
462	logging.info(msg)
463	is_loaded = True
464	if not is_loaded:
465
466	self.plugins.append(plugin)
467
468
469	def _get_local_plugins(self):
470	"""
471	get plugins local to guiframe and others
472	"""
473	plugins = []
474	#import guiframe local plugins
475	#check if the style contain guiframe.dataloader
476	style1 = self.__gui_style & GUIFRAME.DATALOADER_ON
477	style2 = self.__gui_style & GUIFRAME.PLOTTING_ON
478	if style1 == GUIFRAME.DATALOADER_ON:
479	try:
480	from sans.guiframe.local_perspectives.data_loader import data_loader
481	self._data_plugin = data_loader.Plugin()
482	plugins.append(self._data_plugin)
483	except:
484	msg = "ViewerFrame._get_local_plugins:"
485	msg += "cannot import dataloader plugin.\n %s" % sys.exc_value
486	logging.error(msg)
487	if style2 == GUIFRAME.PLOTTING_ON:
488	try:
489	from sans.guiframe.local_perspectives.plotting import plotting
490	self._plotting_plugin = plotting.Plugin()
491	plugins.append(self._plotting_plugin)
492	except:
493	msg = "ViewerFrame._get_local_plugins:"
494	msg += "cannot import plotting plugin.\n %s" % sys.exc_value
495	logging.error(msg)
496
497	return plugins
498
499	def _find_plugins(self, dir="perspectives"):
500	"""
501	Find available perspective plug-ins
502
503	:param dir: directory in which to look for plug-ins
504
505	:return: list of plug-ins
506
507	"""
508	import imp
509	plugins = []
510	# Go through files in panels directory
511	try:
512	list = os.listdir(dir)
513	## the default panel is the panel is the last plugin added
514	for item in list:
515	toks = os.path.splitext(os.path.basename(item))
516	name = ''
517	if not toks[0] == '__init__':
518	if toks[1] == '.py' or toks[1] == '':
519	name = toks[0]
520	#check the validity of the module name parsed
521	#before trying to import it
522	if name is None or name.strip() == '':
523	continue
524	path = [os.path.abspath(dir)]
525	file = ''
526	try:
527	if toks[1] == '':
528	mod_path = '.'.join([dir, name])
529	module = __import__(mod_path, globals(),
530	locals(), [name])
531	else:
532	(file, path, info) = imp.find_module(name, path)
533	module = imp.load_module( name, file, item, info)
534	if hasattr(module, "PLUGIN_ID"):
535	try:
536	plug = module.Plugin()
537	if plug.set_default_perspective():
538	self._current_perspective = plug
539	plugins.append(plug)
540
541	msg = "Found plug-in: %s" % module.PLUGIN_ID
542	logging.info(msg)
543	except:
544	msg = "Error accessing PluginPanel"
545	msg += " in %s\n %s" % (name, sys.exc_value)
546	config.printEVT(msg)
547	except:
548	msg = "ViewerFrame._find_plugins: %s" % sys.exc_value
549	#print msg
550	logging.error(msg)
551	finally:
552	if not file == None:
553	file.close()
554	except:
555	# Should raise and catch at a higher level and
556	# display error on status bar
557	pass
558
559	return plugins
560
561	def set_welcome_panel(self, panel_class):
562	"""
563	Sets the default panel as the given welcome panel
564
565	:param panel_class: class of the welcome panel to be instantiated
566
567	"""
568	self.defaultPanel = panel_class(self, -1, style=wx.RAISED_BORDER)
569
570	def _get_panels_size(self, p):
571	"""
572	find the proper size of the current panel
573	get the proper panel width and height
574	"""
575	panel_height_min = self._window_height
576	panel_width_min = self._window_width
577	style = self.__gui_style & (GUIFRAME.MANAGER_ON)
578	if self._data_panel is not None and (p == self._data_panel):
579	panel_width_min = DATAPANEL_WIDTH
580	panel_height_min = self._window_height * 0.8
581	return panel_width_min, panel_height_min
582	if hasattr(p, "CENTER_PANE") and p.CENTER_PANE:
583	style = self.__gui_style & (GUIFRAME.PLOTTING_ON\|GUIFRAME.MANAGER_ON)
584	if style == (GUIFRAME.PLOTTING_ON\|GUIFRAME.MANAGER_ON):
585	panel_width_min = self._window_width -\
586	(DATAPANEL_WIDTH +config.PLOPANEL_WIDTH)
587	return panel_width_min, panel_height_min
588	return panel_width_min, panel_height_min
589
590	def _load_panels(self):
591	"""
592	Load all panels in the panels directory
593	"""
594
595	# Look for plug-in panels
596	panels = []
597	for item in self.plugins:
598	if hasattr(item, "get_panels"):
599	ps = item.get_panels(self)
600	panels.extend(ps)
601
602	# Show a default panel with some help information
603	# It also sets the size of the application windows
604	#TODO: Use this for slpash screen
605	if self.defaultPanel is None:
606	self.defaultPanel = DefaultPanel(self, -1, style=wx.RAISED_BORDER)
607	# add a blank default panel always present
608	self.panels["default"] = self.defaultPanel
609	self._mgr.AddPane(self.defaultPanel, wx.aui.AuiPaneInfo().
610	Name("default").
611	CenterPane().
612	#CloseButton(False).
613	#MinimizeButton(False).
614	# This is where we set the size of
615	# the application window
616	BestSize(wx.Size(self._window_width,
617	self._window_height)).
618	Show())
619
620	#add data panel
621	self.panels["data_panel"] = self._data_panel
622	w, h = self._get_panels_size(self._data_panel)
623	self._mgr.AddPane(self._data_panel, wx.aui.AuiPaneInfo().
624	Name(self._data_panel.window_name).
625	Caption(self._data_panel.window_caption).
626	Left().
627	MinimizeButton().
628	CloseButton(IS_WIN).
629	TopDockable(False).
630	BottomDockable(False).
631	LeftDockable(True).
632	RightDockable(False).
633	BestSize(wx.Size(w, h)).
634	Hide())
635
636	style = self.__gui_style & GUIFRAME.MANAGER_ON
637	data_pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
638	if style != GUIFRAME.MANAGER_ON:
639	self._mgr.GetPane(self.panels["data_panel"].window_name).Hide()
640	else:
641	self._mgr.GetPane(self.panels["data_panel"].window_name).Show()
642
643	# Add the panels to the AUI manager
644	for panel_class in panels:
645	p = panel_class
646	id = wx.NewId()
647	#w, h = self._get_panels_size(p)
648	# Check whether we need to put this panel
649	# in the center pane
650	if hasattr(p, "CENTER_PANE") and p.CENTER_PANE:
651	w, h = self._get_panels_size(p)
652	if p.CENTER_PANE:
653	self.panels[str(id)] = p
654	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
655	Name(p.window_name).
656	CenterPane().
657	Center().
658	CloseButton(False).
659	Hide())
660	else:
661	self.panels[str(id)] = p
662	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
663	Name(p.window_name).Caption(p.window_caption).
664	Right().
665	Dock().
666	TopDockable().
667	BottomDockable().
668	LeftDockable().
669	RightDockable().
670	MinimizeButton().
671	Hide())
672
673	def update_data(self, prev_data, new_data):
674	"""
675	"""
676	prev_id, data_state = self._data_manager.update_data(prev_data=prev_data,
677	new_data=new_data)
678
679	self._data_panel.remove_by_id(prev_id)
680	self._data_panel.load_data_list(data_state)
681
682	def update_theory(self, data_id, theory, state=None):
683	"""
684	"""
685	data_state = self._data_manager.update_theory(data_id=data_id,
686	theory=theory,
687	state=state)
688	self._data_panel.load_data_list(data_state)
689
690	def onfreeze(self, theory_id):
691	"""
692	"""
693	data_state_list = self._data_manager.freeze(theory_id)
694	self._data_panel.load_data_list(list=data_state_list)
695	for data_state in data_state_list.values():
696	new_plot = data_state.get_data()
697
698	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
699	title=new_plot.title))
700
701	def freeze(self, data_id, theory_id):
702	"""
703	"""
704	data_state_list = self._data_manager.freeze_theory(data_id=data_id,
705	theory_id=theory_id)
706	self._data_panel.load_data_list(list=data_state_list)
707	for data_state in data_state_list.values():
708	new_plot = data_state.get_data()
709	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
710	title=new_plot.title))
711
712	def delete_data(self, data):
713	"""
714	"""
715	self._current_perspective.delete_data(data)
716
717
718	def get_context_menu(self, plotpanel=None):
719	"""
720	Get the context menu items made available
721	by the different plug-ins.
722	This function is used by the plotting module
723	"""
724	if plotpanel is None:
725	return
726	menu_list = []
727	for item in self.plugins:
728	menu_list.extend(item.get_context_menu(plotpanel=plotpanel))
729	return menu_list
730
731	def popup_panel(self, p):
732	"""
733	Add a panel object to the AUI manager
734
735	:param p: panel object to add to the AUI manager
736
737	:return: ID of the event associated with the new panel [int]
738
739	"""
740	ID = wx.NewId()
741	self.panels[str(ID)] = p
742	count = 0
743	for item in self.panels:
744	if self.panels[item].window_name.startswith(p.window_name):
745	count += 1
746	windowname = p.window_name
747	caption = p.window_caption
748	if count > 0:
749	windowname += str(count+1)
750	caption += (' '+str(count))
751	p.window_name = windowname
752	p.window_caption = caption
753
754	style1 = self.__gui_style & GUIFRAME.FIXED_PANEL
755	style2 = self.__gui_style & GUIFRAME.FLOATING_PANEL
756	if style1 == GUIFRAME.FIXED_PANEL:
757	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
758	Name(windowname).
759	Caption(caption).
760	Position(10).
761	Floatable().
762	Right().
763	Dock().
764	MinimizeButton().
765	Resizable(True).
766	# Use a large best size to make sure the AUI
767	# manager takes all the available space
768	BestSize(wx.Size(PLOPANEL_WIDTH,
769	PLOPANEL_HEIGTH)))
770
771	self._popup_fixed_panel(p)
772
773	elif style2 == GUIFRAME.FLOATING_PANEL:
774	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
775	Name(windowname).Caption(caption).
776	MinimizeButton().
777	Resizable(True).
778	# Use a large best size to make sure the AUI
779	# manager takes all the available space
780	BestSize(wx.Size(PLOPANEL_WIDTH,
781	PLOPANEL_HEIGTH)))
782
783	self._popup_floating_panel(p)
784
785	# Register for showing/hiding the panel
786	wx.EVT_MENU(self, ID, self.on_view)
787	if p not in self.plot_panels.values() and p.group_id != None:
788	self.plot_panels[ID] = p
789	if len(self.plot_panels) == 1:
790	self.panel_on_focus = p
791	self.set_panel_on_focus(None)
792	if self._data_panel is not None and \
793	self._plotting_plugin is not None:
794	ind = self._data_panel.cb_plotpanel.FindString('None')
795	if ind != wx.NOT_FOUND:
796	self._data_panel.cb_plotpanel.Delete(ind)
797	if caption not in self._data_panel.cb_plotpanel.GetItems():
798	self._data_panel.cb_plotpanel.Append(str(caption), p)
799	return ID
800
801	def _setup_menus(self):
802	"""
803	Set up the application menus
804	"""
805	# Menu
806	self._menubar = wx.MenuBar()
807	self._add_menu_file()
808	self._add_menu_edit()
809	self._add_menu_view()
810	#self._add_menu_data()
811	self._add_menu_application()
812	self._add_menu_tool()
813	self._add_current_plugin_menu()
814	self._add_menu_window()
815	self._add_help_menu()
816	self.SetMenuBar(self._menubar)
817
818	def _setup_tool_bar(self):
819	"""
820	add toolbar to the frame
821	"""
822	#set toolbar
823	self._toolbar = GUIToolBar(self, -1)
824	self.SetToolBar(self._toolbar)
825	self._update_toolbar_helper()
826	self._on_toggle_toolbar(event=None)
827
828	def _update_toolbar_helper(self):
829	"""
830	"""
831	application_name = 'No Selected Analysis'
832	panel_name = 'No Panel on Focus'
833	if self._toolbar is None:
834	return
835	if self.cpanel_on_focus is not None:
836	self.reset_bookmark_menu(self.cpanel_on_focus)
837	self._toolbar.update_toolbar(self.cpanel_on_focus)
838	if self._current_perspective is not None:
839	application_name = self._current_perspective.sub_menu
840	if self.cpanel_on_focus is not None:
841	panel_name = self.cpanel_on_focus.window_caption
842
843	self._toolbar.update_button(application_name=application_name,
844	panel_name=panel_name)
845
846	self._toolbar.Realize()
847
848	def _add_menu_tool(self):
849	"""
850	Tools menu
851	Go through plug-ins and find tools to populate the tools menu
852	"""
853	style = self.__gui_style & GUIFRAME.CALCULATOR_ON
854	if style == GUIFRAME.CALCULATOR_ON:
855	self._tool_menu = None
856	for item in self.plugins:
857	if hasattr(item, "get_tools"):
858	for tool in item.get_tools():
859	# Only create a menu if we have at least one tool
860	if self._tool_menu is None:
861	self._tool_menu = wx.Menu()
862	id = wx.NewId()
863	self._tool_menu.Append(id, tool[0], tool[1])
864	wx.EVT_MENU(self, id, tool[2])
865	if self._tool_menu is not None:
866	self._menubar.Append(self._tool_menu, '&Tool')
867
868	def _add_current_plugin_menu(self):
869	"""
870	add current plugin menu
871	Look for plug-in menus
872	Add available plug-in sub-menus.
873	"""
874	if (self._menubar is None) or (self._current_perspective is None):
875	return
876	#replace or add a new menu for the current plugin
877
878	pos = self._menubar.FindMenu(str(self._applications_menu_name))
879	if pos != -1:
880	menu_list = self._current_perspective.populate_menu(self)
881	if menu_list:
882	for (menu, name) in menu_list:
883	hidden_menu = self._menubar.Replace(pos, menu, name)
884	self._applications_menu_name = name
885	#self._applications_menu_pos = pos
886	else:
887	hidden_menu = self._menubar.Remove(pos)
888	self._applications_menu_name = None
889	#get the position of the menu when it first added
890	self._applications_menu_pos = pos
891
892	else:
893	menu_list = self._current_perspective.populate_menu(self)
894	if menu_list:
895	for (menu,name) in menu_list:
896	if self._applications_menu_pos == -1:
897	self._menubar.Append(menu, name)
898	else:
899	self._menubar.Insert(self._applications_menu_pos, menu, name)
900	self._applications_menu_name = name
901
902	def _add_help_menu(self):
903	"""
904	add help menu
905	"""
906	# Help menu
907	self._help_menu = wx.Menu()
908	style = self.__gui_style & GUIFRAME.WELCOME_PANEL_ON
909	if style == GUIFRAME.WELCOME_PANEL_ON or custom_config != None:
910	# add the welcome panel menu item
911	if self.defaultPanel is not None:
912	id = wx.NewId()
913	self._help_menu.Append(id, '&Welcome', '')
914	self._help_menu.AppendSeparator()
915	wx.EVT_MENU(self, id, self.show_welcome_panel)
916	# Look for help item in plug-ins
917	for item in self.plugins:
918	if hasattr(item, "help"):
919	id = wx.NewId()
920	self._help_menu.Append(id,'&%s Help' % item.sub_menu, '')
921	wx.EVT_MENU(self, id, item.help)
922	if config._do_aboutbox:
923	self._help_menu.AppendSeparator()
924	id = wx.NewId()
925	self._help_menu.Append(id,'&About', 'Software information')
926	wx.EVT_MENU(self, id, self._onAbout)
927
928	# Checking for updates needs major refactoring to work with py2exe
929	# We need to make sure it doesn't hang the application if the server
930	# is not up. We also need to make sure there's a proper executable to
931	# run if we spawn a new background process.
932	#id = wx.NewId()
933	#self._help_menu.Append(id,'&Check for update',
934	#'Check for the latest version of %s' % config.__appname__)
935	#wx.EVT_MENU(self, id, self._check_update)
936	self._menubar.Append(self._help_menu, '&Help')
937
938	def _add_menu_view(self):
939	"""
940	add menu items under view menu
941	"""
942	self._view_menu = wx.Menu()
943	style = self.__gui_style & GUIFRAME.MANAGER_ON
944	id = wx.NewId()
945	self._data_panel_menu = self._view_menu.Append(id,
946	'&Show Data Explorer', '')
947	wx.EVT_MENU(self, id, self.show_data_panel)
948	if style == GUIFRAME.MANAGER_ON:
949	self._data_panel_menu.SetText('Hide Data Explorer')
950	else:
951	self._data_panel_menu.SetText('Show Data Explorer')
952	self._view_menu.AppendSeparator()
953	id = wx.NewId()
954	style1 = self.__gui_style & GUIFRAME.TOOLBAR_ON
955	if style1 == GUIFRAME.TOOLBAR_ON:
956	self._toolbar_menu = self._view_menu.Append(id,'&Hide Toolbar', '')
957	else:
958	self._toolbar_menu = self._view_menu.Append(id,'&Show Toolbar', '')
959	wx.EVT_MENU(self, id, self._on_toggle_toolbar)
960
961	if custom_config != None:
962	self._view_menu.AppendSeparator()
963	id = wx.NewId()
964	preference_menu = self._view_menu.Append(id,'Startup Setting', '')
965	wx.EVT_MENU(self, id, self._on_preference_menu)
966
967	self._menubar.Append(self._view_menu, '&View')
968
969	def _on_preference_menu(self, event):
970	"""
971	Build a panel to allow to edit Mask
972	"""
973
974	from sans.guiframe.startup_configuration \
975	import StartupConfiguration as ConfDialog
976
977	self.panel = ConfDialog(parent=self, gui=self.__gui_style)
978	#self.panel.Bind(wx.EVT_CLOSE, self._draw_masked_model)
979	self.panel.ShowModal()
980	#wx.PostEvent(self.parent, event)
981
982	def _draw_masked_model(self,event):
983	"""
984	Draw model image w/mask
985	"""
986	event.Skip()
987
988	is_valid_qrange = self._update_paramv_on_fit()
989
990	if is_valid_qrange:
991	# try re draw the model plot if it exists
992	self._draw_model()
993	self.panel.Destroy() # frame
994	self.set_npts2fit()
995	elif self.model == None:
996	self.panel.Destroy()
997	self.set_npts2fit()
998	msg= "No model is found on updating MASK in the model plot... "
999	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1000	else:
1001	msg = ' Please consider your Q range, too.'
1002	self.panel.ShowMessage(msg)
1003
1004	def _add_menu_window(self):
1005	"""
1006	add a menu window to the menu bar
1007	Window menu
1008	Attach a menu item for each panel in our
1009	panel list that also appears in a plug-in.
1010
1011	Only add the panel menu if there is only one perspective and
1012	it has more than two panels.
1013	Note: the first plug-in is always the plotting plug-in.
1014	The first application
1015	#plug-in is always the second one in the list.
1016	"""
1017	self._window_menu = wx.Menu()
1018	if self._plotting_plugin is not None:
1019	for (menu, name) in self._plotting_plugin.populate_menu(self):
1020	self._window_menu.AppendSubMenu(menu, name)
1021	self._menubar.Append(self._window_menu, '&Graph')
1022
1023	style = self.__gui_style & GUIFRAME.PLOTTING_ON
1024	if style == GUIFRAME.PLOTTING_ON:
1025	self._window_menu.AppendSeparator()
1026	id = wx.NewId()
1027	preferences_menu = wx.Menu()
1028	hint = "All plot panels will floating"
1029	preferences_menu.AppendRadioItem(id, '&Float All', hint)
1030	wx.EVT_MENU(self, id, self.set_plotpanel_floating)
1031	style = self.__gui_style & GUIFRAME.FLOATING_PANEL
1032	f_menu = preferences_menu.FindItemById(id)
1033	if style == GUIFRAME.FLOATING_PANEL:
1034	f_checked = True
1035	else:
1036	f_checked = False
1037	f_menu.Check(f_checked)
1038
1039	id = wx.NewId()
1040	hint = "All plot panels will displayed within the frame"
1041	preferences_menu.AppendRadioItem(id, '&Dock All', hint)
1042	wx.EVT_MENU(self, id, self.set_plotpanel_fixed)
1043	if not f_checked:
1044	d_menu = preferences_menu.FindItemById(id)
1045	d_menu.Check(True)
1046	preferences_menu.AppendSeparator()
1047	id = wx.NewId()
1048	hint = "Clean up the dock area for plots on new-plot"
1049	preferences_menu.AppendCheckItem(id, '&CleanUp Dock on NewPlot', hint)
1050	wx.EVT_MENU(self, id, self.on_cleanup_dock)
1051	flag = self.cleanup_plots
1052	if self.cleanup_plots:
1053	c_menu = preferences_menu.FindItemById(id)
1054	c_menu.Check(True)
1055	self._window_menu.AppendSubMenu(preferences_menu,'&Preferences')
1056	if self._window_menu.GetMenuItemCount() == 0:
1057	pos = self._menubar.FindMenu('Graph')
1058	self._menubar.Remove(pos)
1059	#wx.EVT_MENU(self, id, self.show_preferences_panel)
1060	"""
1061	if len(self.plugins) == 2:
1062	plug = self.plugins[1]
1063	pers = plug.get_perspective()
1064
1065	if len(pers) > 1:
1066	self._window_menu = wx.Menu()
1067	for item in self.panels:
1068	if item == 'default':
1069	continue
1070	panel = self.panels[item]
1071	if panel.window_name in pers:
1072	self._window_menu.Append(int(item),
1073	panel.window_caption,
1074	"Show %s window" % panel.window_caption)
1075	wx.EVT_MENU(self, int(item), self.on_view)
1076	self._menubar.Append(self._window_menu, '&Window')
1077	"""
1078
1079
1080	def _add_menu_application(self):
1081	"""
1082
1083	# Attach a menu item for each defined perspective or application.
1084	# Only add the perspective menu if there are more than one perspectives
1085	add menu application
1086	"""
1087	#style = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
1088	#if style == GUIFRAME.MULTIPLE_APPLICATIONS:
1089	if self._num_perspectives > 1:
1090	plug_data_count = False
1091	plug_no_data_count = False
1092	self._applications_menu = wx.Menu()
1093	pos = 0
1094	separator = self._applications_menu.AppendSeparator()
1095	for plug in self.plugins:
1096	if len(plug.get_perspective()) > 0:
1097	id = wx.NewId()
1098	if plug.use_data():
1099
1100	self._applications_menu.InsertCheckItem(pos, id, plug.sub_menu,
1101	"Switch to analysis: %s" % plug.sub_menu)
1102	plug_data_count = True
1103	pos += 1
1104	else:
1105	plug_no_data_count = True
1106	self._applications_menu.AppendCheckItem(id, plug.sub_menu,
1107	"Switch to analysis: %s" % plug.sub_menu)
1108	wx.EVT_MENU(self, id, plug.on_perspective)
1109	#self._applications_menu.
1110	if (not plug_data_count or not plug_no_data_count):
1111	self._applications_menu.RemoveItem(separator)
1112	self._menubar.Append(self._applications_menu, '&Analysis')
1113	self._check_applications_menu()
1114
1115	def _populate_file_menu(self):
1116	"""
1117	Insert menu item under file menu
1118	"""
1119	for plugin in self.plugins:
1120	if len(plugin.populate_file_menu()) > 0:
1121	for item in plugin.populate_file_menu():
1122	m_name, m_hint, m_handler = item
1123	id = wx.NewId()
1124	self._file_menu.Append(id, m_name, m_hint)
1125	wx.EVT_MENU(self, id, m_handler)
1126	self._file_menu.AppendSeparator()
1127
1128	def _add_menu_file(self):
1129	"""
1130	add menu file
1131	"""
1132
1133	# File menu
1134	self._file_menu = wx.Menu()
1135	#append item from plugin under menu file if necessary
1136	self._populate_file_menu()
1137	style = self.__gui_style & GUIFRAME.DATALOADER_ON
1138	style1 = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
1139
1140	id = wx.NewId()
1141	hint_load_file = "read all analysis states saved previously"
1142	self._save_appl_menu = self._file_menu.Append(id,
1143	'&Open Project', hint_load_file)
1144	wx.EVT_MENU(self, id, self._on_open_state_project)
1145
1146	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1147	# some menu of plugin to be seen under file menu
1148	hint_load_file = "Read a status files and load"
1149	hint_load_file += " them into the analysis"
1150	id = wx.NewId()
1151	self._save_appl_menu = self._file_menu.Append(id,
1152	'&Open Analysis', hint_load_file)
1153	wx.EVT_MENU(self, id, self._on_open_state_application)
1154
1155	self._file_menu.AppendSeparator()
1156	id = wx.NewId()
1157	self._file_menu.Append(id, '&Save Project',
1158	'Save the state of the whole analysis')
1159	wx.EVT_MENU(self, id, self._on_save_project)
1160	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1161	#self._file_menu.AppendSeparator()
1162	id = wx.NewId()
1163	self._save_appl_menu = self._file_menu.Append(id,
1164	'&Save Analysis',
1165	'Save state of the current active analysis panel')
1166	wx.EVT_MENU(self, id, self._on_save_application)
1167
1168	self._file_menu.AppendSeparator()
1169
1170	id = wx.NewId()
1171	self._file_menu.Append(id, '&Quit', 'Exit')
1172	wx.EVT_MENU(self, id, self.Close)
1173	# Add sub menus
1174	self._menubar.Append(self._file_menu, '&File')
1175
1176	def _add_menu_edit(self):
1177	"""
1178	add menu edit
1179	"""
1180	# Edit Menu
1181	self._edit_menu = wx.Menu()
1182	self._edit_menu.Append(GUIFRAME_ID.UNDO_ID, '&Undo',
1183	'Undo the previous action')
1184	wx.EVT_MENU(self, GUIFRAME_ID.UNDO_ID, self.on_undo_panel)
1185	self._edit_menu.Append(GUIFRAME_ID.REDO_ID, '&Redo',
1186	'Redo the previous action')
1187	wx.EVT_MENU(self, GUIFRAME_ID.REDO_ID, self.on_redo_panel)
1188	self._edit_menu.AppendSeparator()
1189	self._edit_menu.Append(GUIFRAME_ID.COPY_ID, '&Copy Params',
1190	'Copy parameter values')
1191	wx.EVT_MENU(self, GUIFRAME_ID.COPY_ID, self.on_copy_panel)
1192	self._edit_menu.Append(GUIFRAME_ID.PASTE_ID, '&Paste Params',
1193	'Paste parameter values')
1194	wx.EVT_MENU(self, GUIFRAME_ID.PASTE_ID, self.on_paste_panel)
1195	self._edit_menu.AppendSeparator()
1196
1197	self._edit_menu.Append(GUIFRAME_ID.PREVIEW_ID, '&Report Results',
1198	'Preview current panel')
1199	wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel)
1200	#self._edit_menu.Append(GUIFRAME_ID.PRINT_ID, '&Print',
1201	# 'Print current panel')
1202	#wx.EVT_MENU(self, GUIFRAME_ID.PRINT_ID, self.on_print_panel)
1203	self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset Page',
1204	'Reset current panel')
1205	wx.EVT_MENU(self, GUIFRAME_ID.RESET_ID, self.on_reset_panel)
1206
1207	self._menubar.Append(self._edit_menu, '&Edit')
1208	self.enable_edit_menu()
1209
1210	def get_style(self):
1211	"""
1212	"""
1213	return self.__gui_style
1214
1215	def _add_menu_data(self):
1216	"""
1217	Add menu item item data to menu bar
1218	"""
1219	if self._data_plugin is not None:
1220	menu_list = self._data_plugin.populate_menu(self)
1221	if menu_list:
1222	for (menu, name) in menu_list:
1223	self._menubar.Append(menu, name)
1224
1225
1226	def _on_toggle_toolbar(self, event=None):
1227	"""
1228	hide or show toolbar
1229	"""
1230	if self._toolbar is None:
1231	return
1232	if self._toolbar.IsShown():
1233	if self._toolbar_menu is not None:
1234	self._toolbar_menu.SetItemLabel('Show Toolbar')
1235	self._toolbar.Hide()
1236	else:
1237	if self._toolbar_menu is not None:
1238	self._toolbar_menu.SetItemLabel('Hide Toolbar')
1239	self._toolbar.Show()
1240	self._toolbar.Realize()
1241
1242	def _on_status_event(self, evt):
1243	"""
1244	Display status message
1245	"""
1246	# This CallAfter fixes many crashes on MAC.
1247	wx.CallAfter(self.sb.set_status, evt)
1248
1249	def on_view(self, evt):
1250	"""
1251	A panel was selected to be shown. If it's not already
1252	shown, display it.
1253
1254	:param evt: menu event
1255
1256	"""
1257	panel_id = str(evt.GetId())
1258	self.on_set_plot_focus(self.panels[panel_id])
1259	self.show_panel(evt.GetId(), 'on')
1260	wx.CallLater(5, self.set_schedule(True))
1261	self.set_plot_unfocus()
1262
1263	def on_close_welcome_panel(self):
1264	"""
1265	Close the welcome panel
1266	"""
1267	if self.defaultPanel is None:
1268	return
1269	default_panel = self._mgr.GetPane(self.panels["default"].window_name)
1270	if default_panel.IsShown():
1271	default_panel.Hide()
1272	# Recover current perspective
1273	perspective = self._current_perspective
1274	perspective.on_perspective(event=None)
1275	self._mgr.Update()
1276	# Show toolbar
1277	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
1278	#if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
1279	# self._on_toggle_toolbar()
1280
1281	def show_welcome_panel(self, event):
1282	"""
1283	Display the welcome panel
1284	"""
1285	if self.defaultPanel is None:
1286	return
1287	for id, panel in self.panels.iteritems():
1288	if id == 'default':
1289	# Show default panel
1290	if not self._mgr.GetPane(self.panels["default"].window_name).IsShown():
1291	self._mgr.GetPane(self.panels["default"].window_name).Show(True)
1292	elif id == "data_panel":
1293	flag = self._mgr.GetPane(self.panels["data_panel"].window_name).IsShown()
1294	self._mgr.GetPane(self.panels["data_panel"].window_name).Show(flag)
1295	elif panel not in self.plot_panels.values() :
1296	self._mgr.GetPane(self.panels[id].window_name).IsShown()
1297	self._mgr.GetPane(self.panels[id].window_name).Hide()
1298	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
1299	#if (style == GUIFRAME.TOOLBAR_ON) & (self._toolbar.IsShown()):
1300	# # self._toolbar.Show(True)
1301	# self._on_toggle_toolbar()
1302
1303	self._mgr.Update()
1304
1305	def show_panel(self, uid, show=None):
1306	"""
1307	Shows the panel with the given id
1308
1309	:param uid: unique ID number of the panel to show
1310
1311	"""
1312	ID = str(uid)
1313	config.printEVT("show_panel: %s" % ID)
1314	if ID in self.panels.keys():
1315	if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():
1316	if show == 'on':
1317	self._mgr.GetPane(self.panels[ID].window_name).Show()
1318	elif self.panels[ID].window_caption.split(" ")[0] == \
1319	"Residuals":
1320	self._mgr.GetPane(self.panels[ID].window_name).Hide()
1321	else:
1322	self._mgr.GetPane(self.panels[ID].window_name).Show()
1323	# Hide default panel
1324	self._mgr.GetPane(self.panels["default"].window_name).Hide()
1325	self._mgr.Update()
1326	self._redraw_idle()
1327
1328	def hide_panel(self, uid):
1329	"""
1330	hide panel except default panel
1331	"""
1332	ID = str(uid)
1333	caption = self.panels[ID].window_caption
1334	config.printEVT("hide_panel: %s" % ID)
1335	if ID in self.panels.keys():
1336	if self._mgr.GetPane(self.panels[ID].window_name).IsShown():
1337	self._mgr.GetPane(self.panels[ID].window_name).Hide()
1338	if self._data_panel is not None and \
1339	ID in self.plot_panels.keys():
1340	self._data_panel.cb_plotpanel.Append(str(caption), p)
1341	# Do not Hide default panel here...
1342	#self._mgr.GetPane(self.panels["default"].window_name).Hide()
1343	self._mgr.Update()
1344
1345	def delete_panel(self, uid):
1346	"""
1347	delete panel given uid
1348	"""
1349	ID = str(uid)
1350	config.printEVT("delete_panel: %s" % ID)
1351	caption = self.panels[ID].window_caption
1352	if ID in self.panels.keys():
1353	self.panel_on_focus = None
1354	panel = self.panels[ID]
1355	self._plotting_plugin.delete_panel(panel.group_id)
1356	self._mgr.DetachPane(panel)
1357	panel.Hide()
1358	panel.clear()
1359	panel.Close()
1360	self._mgr.Update()
1361	#delete uid number not str(uid)
1362	if uid in self.plot_panels.keys():
1363	del self.plot_panels[uid]
1364	return
1365
1366	def clear_panel(self):
1367	"""
1368	"""
1369	for item in self.panels:
1370	try:
1371	self.panels[item].clear_panel()
1372	except:
1373	pass
1374
1375	def create_gui_data(self, data, path=None):
1376	"""
1377	"""
1378	return self._data_manager.create_gui_data(data, path)
1379
1380	def get_data(self, path):
1381	"""
1382	"""
1383	message = ""
1384	log_msg = ''
1385	output = []
1386	error_message = ""
1387	basename = os.path.basename(path)
1388	root, extension = os.path.splitext(basename)
1389	if extension.lower() not in EXTENSIONS:
1390	log_msg = "File Loader cannot "
1391	log_msg += "load: %s\n" % str(basename)
1392	log_msg += "Try Data opening...."
1393	logging.info(log_msg)
1394	self.load_complete(output=output, error_message=error_message,
1395	message=log_msg, path=path)
1396	return
1397
1398	#reading a state file
1399	for plug in self.plugins:
1400	reader, ext = plug.get_extensions()
1401	if reader is not None:
1402	#read the state of the single plugin
1403	if extension == ext:
1404	reader.read(path)
1405	return
1406	elif extension == APPLICATION_STATE_EXTENSION:
1407	reader.read(path)
1408
1409	style = self.__gui_style & GUIFRAME.MANAGER_ON
1410	if style == GUIFRAME.MANAGER_ON:
1411	if self._data_panel is not None:
1412	#data_state = self._data_manager.get_selected_data()
1413	#self._data_panel.load_data_list(data_state)
1414	self._mgr.GetPane(self._data_panel.window_name).Show(True)
1415
1416	def load_from_cmd(self, path):
1417	"""
1418	load data from cmd or application
1419	"""
1420	if path is None:
1421	return
1422	else:
1423	path = os.path.abspath(path)
1424	if not os.path.isfile(path) and not os.path.isdir(path):
1425	return
1426
1427	if os.path.isdir(path):
1428	self.load_folder(path)
1429	return
1430
1431	basename = os.path.basename(path)
1432	root, extension = os.path.splitext(basename)
1433	if extension.lower() not in EXTENSIONS:
1434	self.load_data(path)
1435	else:
1436	self.load_state(path)
1437
1438	self._default_save_location = os.path.dirname(path)
1439
1440	def load_state(self, path):
1441	"""
1442	load data from command line or application
1443	"""
1444	if path and (path is not None) and os.path.isfile(path):
1445	basename = os.path.basename(path)
1446	if APPLICATION_STATE_EXTENSION is not None \
1447	and basename.endswith(APPLICATION_STATE_EXTENSION):
1448	#Hide current plot_panels i
1449	for ID in self.plot_panels.keys():
1450	panel = self._mgr.GetPane(self.plot_panels[ID].window_name)
1451	if panel.IsShown():
1452	panel.Hide()
1453	self.get_data(path)
1454	if self.defaultPanel is not None and \
1455	self._mgr.GetPane(self.panels["default"].window_name).IsShown():
1456	self.on_close_welcome_panel()
1457
1458	def load_data(self, path):
1459	"""
1460	load data from command line
1461	"""
1462	if not os.path.isfile(path):
1463	return
1464	basename = os.path.basename(path)
1465	root, extension = os.path.splitext(basename)
1466	if extension.lower() in EXTENSIONS:
1467	log_msg = "Data Loader cannot "
1468	log_msg += "load: %s\n" % str(path)
1469	log_msg += "Try File opening ...."
1470	print log_msg
1471	return
1472	message = ""
1473	log_msg = ''
1474	output = {}
1475	error_message = ""
1476	try:
1477	print "Loading Data...:\n" + str(path) + "\n"
1478	temp = self.loader.load(path)
1479	if temp.__class__.__name__ == "list":
1480	for item in temp:
1481	data = self.create_gui_data(item, path)
1482	output[data.id] = data
1483	else:
1484	data = self.create_gui_data(temp, path)
1485	output[data.id] = data
1486
1487	self.add_data(data_list=output)
1488	except:
1489	error_message = "Error while loading"
1490	error_message += " Data from cmd:\n %s\n" % str(path)
1491	error_message += str(sys.exc_value) + "\n"
1492	print error_message
1493
1494	def load_folder(self, path):
1495	"""
1496	Load entire folder
1497	"""
1498	if not os.path.isdir(path):
1499	return
1500	if self._data_plugin is None:
1501	return
1502	try:
1503	if path is not None:
1504	self._default_save_location = os.path.dirname(path)
1505	file_list = self._data_plugin.get_file_path(path)
1506	self._data_plugin.get_data(file_list)
1507	else:
1508	return
1509	except:
1510	error_message = "Error while loading"
1511	error_message += " Data folder from cmd:\n %s\n" % str(path)
1512	error_message += str(sys.exc_value) + "\n"
1513	print error_message
1514
1515	def _on_open_state_application(self, event):
1516	"""
1517	"""
1518	path = None
1519	if self._default_save_location == None:
1520	self._default_save_location = os.getcwd()
1521
1522	plug_wlist = self._on_open_state_app_helper()
1523	dlg = wx.FileDialog(self,
1524	"Choose a file",
1525	self._default_save_location, "",
1526	plug_wlist)
1527	if dlg.ShowModal() == wx.ID_OK:
1528	path = dlg.GetPath()
1529	if path is not None:
1530	self._default_save_location = os.path.dirname(path)
1531	dlg.Destroy()
1532	self.load_state(path=path)
1533
1534	def _on_open_state_app_helper(self):
1535	"""
1536	Helps '_on_open_state_application()' to find the extension of
1537	the current perspective/application
1538	"""
1539	# No current perspective or no extension attr
1540	if self._current_perspective is None:
1541	return PLUGINS_WLIST
1542	try:
1543	# Find the extension of the perspective and get that as 1st item in list
1544	ind = None
1545	app_ext = self._current_perspective._extensions
1546	plug_wlist = config.PLUGINS_WLIST
1547	for ext in set(plug_wlist):
1548	if ext.count(app_ext) > 0:
1549	ind = ext
1550	break
1551	# Found the extension
1552	if ind != None:
1553	plug_wlist.remove(ind)
1554	plug_wlist.insert(0, ind)
1555	try:
1556	plug_wlist ='\|'.join(plug_wlist)
1557	except:
1558	plug_wlist = ''
1559
1560	except:
1561	plug_wlist = PLUGINS_WLIST
1562
1563	return plug_wlist
1564
1565	def _on_open_state_project(self, event):
1566	"""
1567	"""
1568	path = None
1569	if self._default_save_location == None:
1570	self._default_save_location = os.getcwd()
1571
1572	dlg = wx.FileDialog(self,
1573	"Choose a file",
1574	self._default_save_location, "",
1575	APPLICATION_WLIST)
1576	if dlg.ShowModal() == wx.ID_OK:
1577	path = dlg.GetPath()
1578	if path is not None:
1579	self._default_save_location = os.path.dirname(path)
1580	dlg.Destroy()
1581
1582	#try:
1583	# os.popen(path)
1584	# #self.Close()
1585	#except:
1586	self.load_state(path=path)
1587
1588	def _on_save_application(self, event):
1589	"""
1590	save the state of the current active application
1591	"""
1592	if self.cpanel_on_focus is not None:
1593	self.cpanel_on_focus.on_save(event)
1594
1595	def _on_save_project(self, event):
1596	"""
1597	save the state of the SansView as *.svs
1598	"""
1599	## Default file location for save
1600	self._default_save_location = os.getcwd()
1601	if self._current_perspective is None:
1602	return
1603	reader, ext = self._current_perspective.get_extensions()
1604	path = None
1605	extension = '*' + APPLICATION_STATE_EXTENSION
1606	dlg = wx.FileDialog(self, "Save Project file",
1607	self._default_save_location, "",
1608	extension,
1609	wx.SAVE)
1610	if dlg.ShowModal() == wx.ID_OK:
1611	path = dlg.GetPath()
1612	self._default_save_location = os.path.dirname(path)
1613	else:
1614	return None
1615	dlg.Destroy()
1616	if path is None:
1617	return
1618	# default cansas xml doc
1619	doc = None
1620	for panel in self.panels.values():
1621	temp = panel.save_project(doc)
1622	if temp is not None:
1623	doc = temp
1624
1625	# Write the XML document
1626	extens = APPLICATION_STATE_EXTENSION
1627	fName = os.path.splitext(path)[0] + extens
1628	if doc != None:
1629	fd = open(fName, 'w')
1630	fd.write(doc.toprettyxml())
1631	fd.close()
1632	else:
1633	msg = "%s cannot read %s\n" % (str(APPLICATION_NAME), str(path))
1634	logging.error(msg)
1635
1636	def on_save_helper(self, doc, reader, panel, path):
1637	"""
1638	Save state into a file
1639	"""
1640	try:
1641	if reader is not None:
1642	# case of a panel with multi-pages
1643	if hasattr(panel, "opened_pages"):
1644	for uid, page in panel.opened_pages.iteritems():
1645	data = page.get_data()
1646	# state must be cloned
1647	state = page.get_state().clone()
1648	if data is not None:
1649	new_doc = reader.write_toXML(data, state)
1650	if doc != None and hasattr(doc, "firstChild"):
1651	child = new_doc.firstChild.firstChild
1652	doc.firstChild.appendChild(child)
1653	else:
1654	doc = new_doc
1655	# case of only a panel
1656	else:
1657	data = panel.get_data()
1658	state = panel.get_state()
1659	if data is not None:
1660	new_doc = reader.write_toXML(data, state)
1661	if doc != None and hasattr(doc, "firstChild"):
1662	child = new_doc.firstChild.firstChild
1663	doc.firstChild.appendChild(child)
1664	else:
1665	doc = new_doc
1666	except:
1667	raise
1668	#pass
1669
1670	return doc
1671
1672	def quit_guiframe(self):
1673	"""
1674	Pop up message to make sure the user wants to quit the application
1675	"""
1676	message = "Do you really want to quit \n"
1677	message += "this application?"
1678	dial = wx.MessageDialog(self, message, 'Question',
1679	wx.YES_NO\|wx.YES_DEFAULT\|wx.ICON_QUESTION)
1680	if dial.ShowModal() == wx.ID_YES:
1681	return True
1682	else:
1683	return False
1684
1685	def Close(self, event=None):
1686	"""
1687	Quit the application
1688	"""
1689	#flag = self.quit_guiframe()
1690	if True:
1691	wx.Exit()
1692	sys.exit()
1693
1694	def _check_update(self, event=None):
1695	"""
1696	Check with the deployment server whether a new version
1697	of the application is available.
1698	A thread is started for the connecting with the server. The thread calls
1699	a call-back method when the current version number has been obtained.
1700	"""
1701	if hasattr(config, "__update_URL__"):
1702	import version
1703	checker = version.VersionThread(config.__update_URL__,
1704	self._process_version,
1705	baggage=event==None)
1706	checker.start()
1707
1708	def _process_version(self, version, standalone=True):
1709	"""
1710	Call-back method for the process of checking for updates.
1711	This methods is called by a VersionThread object once the current
1712	version number has been obtained. If the check is being done in the
1713	background, the user will not be notified unless there's an update.
1714
1715	:param version: version string
1716	:param standalone: True of the update is being checked in
1717	the background, False otherwise.
1718
1719	"""
1720	try:
1721	if cmp(version, config.__version__) > 0:
1722	msg = "Version %s is available! See the Help "
1723	msg += "menu to download it." % version
1724	self.SetStatusText(msg)
1725	if not standalone:
1726	import webbrowser
1727	webbrowser.open(config.__download_page__)
1728	else:
1729	if not standalone:
1730	msg = "You have the latest version"
1731	msg += " of %s" % config.__appname__
1732	self.SetStatusText(msg)
1733	except:
1734	msg = "guiframe: could not get latest application"
1735	msg += " version number\n %s" % sys.exc_value
1736	logging.error(msg)
1737	if not standalone:
1738	msg = "Could not connect to the application server."
1739	msg += " Please try again later."
1740	self.SetStatusText(msg)
1741
1742	def _onAbout(self, evt):
1743	"""
1744	Pop up the about dialog
1745
1746	:param evt: menu event
1747
1748	"""
1749	if config._do_aboutbox:
1750	import aboutbox
1751	dialog = aboutbox.DialogAbout(None, -1, "")
1752	dialog.ShowModal()
1753
1754	def set_manager(self, manager):
1755	"""
1756	Sets the application manager for this frame
1757
1758	:param manager: frame manager
1759	"""
1760	self.app_manager = manager
1761
1762	def post_init(self):
1763	"""
1764	This initialization method is called after the GUI
1765	has been created and all plug-ins loaded. It calls
1766	the post_init() method of each plug-in (if it exists)
1767	so that final initialization can be done.
1768	"""
1769	for item in self.plugins:
1770	if hasattr(item, "post_init"):
1771	item.post_init()
1772
1773	def set_default_perspective(self):
1774	"""
1775	Choose among the plugin the first plug-in that has
1776	"set_default_perspective" method and its return value is True will be
1777	as a default perspective when the welcome page is closed
1778	"""
1779	for item in self.plugins:
1780	if hasattr(item, "set_default_perspective"):
1781	if item.set_default_perspective():
1782	item.on_perspective(event=None)
1783	return
1784
1785	def set_perspective(self, panels):
1786	"""
1787	Sets the perspective of the GUI.
1788	Opens all the panels in the list, and closes
1789	all the others.
1790
1791	:param panels: list of panels
1792	"""
1793	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
1794	#if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
1795	# self._on_toggle_toolbar()
1796	for item in self.panels:
1797	# Check whether this is a sticky panel
1798	if hasattr(self.panels[item], "ALWAYS_ON"):
1799	if self.panels[item].ALWAYS_ON:
1800	continue
1801
1802	if self.panels[item].window_name in panels:
1803	if not self._mgr.GetPane(self.panels[item].window_name).IsShown():
1804	self._mgr.GetPane(self.panels[item].window_name).Show()
1805	else:
1806	# always show the data panel if enable
1807	style = self.__gui_style & GUIFRAME.MANAGER_ON
1808	if (style == GUIFRAME.MANAGER_ON) and self.panels[item] == self._data_panel:
1809	if 'data_panel' in self.panels.keys():
1810	flag = self._mgr.GetPane(self.panels['data_panel'].window_name).IsShown()
1811	self._mgr.GetPane(self.panels['data_panel'].window_name).Show(flag)
1812	else:
1813	if self._mgr.GetPane(self.panels[item].window_name).IsShown():
1814	self._mgr.GetPane(self.panels[item].window_name).Hide()
1815
1816	self._mgr.Update()
1817
1818	def show_data_panel(self, event=None, action=True):
1819	"""
1820	show the data panel
1821	"""
1822	if self._data_panel_menu == None:
1823	return
1824	label = self._data_panel_menu.GetText()
1825	if label == 'Show Data Explorer':
1826	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
1827	#if not pane.IsShown():
1828	if action:
1829	pane.Show(True)
1830	self._mgr.Update()
1831	self.__gui_style = self.__gui_style \| GUIFRAME.MANAGER_ON
1832
1833	self._data_panel_menu.SetText('Hide Data Explorer')
1834	else:
1835	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
1836	#if not pane.IsShown():
1837	if action:
1838	pane.Show(False)
1839	self._mgr.Update()
1840	self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
1841	self._data_panel_menu.SetText('Show Data Explorer')
1842
1843	def add_data_helper(self, data_list):
1844	"""
1845	"""
1846	if self._data_manager is not None:
1847	self._data_manager.add_data(data_list)
1848
1849	def add_data(self, data_list):
1850	"""
1851	receive a dictionary of data from loader
1852	store them its data manager if possible
1853	send to data the current active perspective if the data panel
1854	is not active.
1855	:param data_list: dictionary of data's ID and value Data
1856	"""
1857	#Store data into manager
1858	self.add_data_helper(data_list)
1859	# set data in the data panel
1860	if self._data_panel is not None:
1861	data_state = self._data_manager.get_data_state(data_list.keys())
1862	self._data_panel.load_data_list(data_state)
1863	#if the data panel is shown wait for the user to press a button
1864	#to send data to the current perspective. if the panel is not
1865	#show automatically send the data to the current perspective
1866	style = self.__gui_style & GUIFRAME.MANAGER_ON
1867	if style == GUIFRAME.MANAGER_ON:
1868	#wait for button press from the data panel to set_data
1869	if self._data_panel is not None:
1870	self._mgr.GetPane(self._data_panel.window_name).Show(True)
1871	self._mgr.Update()
1872	else:
1873	#automatically send that to the current perspective
1874	self.set_data(data_id=data_list.keys())
1875	self.on_close_welcome_panel()
1876
1877	def set_data(self, data_id, theory_id=None):
1878	"""
1879	set data to current perspective
1880	"""
1881	list_data, _ = self._data_manager.get_by_id(data_id)
1882	if self._current_perspective is not None:
1883	if self.cleanup_plots:
1884	for uid, panel in self.plot_panels.iteritems():
1885	#panel = self.plot_panels[uid]
1886	window = self._mgr.GetPane(panel.window_name)
1887	# To hide all docked plot panels when set the data
1888	if not window.IsFloating():
1889	self.hide_panel(uid)
1890	self._current_perspective.set_data(list_data.values())
1891	self.on_close_welcome_panel()
1892	else:
1893	msg = "Guiframe does not have a current perspective"
1894	logging.info(msg)
1895
1896	def set_theory(self, state_id, theory_id=None):
1897	"""
1898	"""
1899	_, list_theory = self._data_manager.get_by_id(theory_id)
1900	if self._current_perspective is not None:
1901	try:
1902	self._current_perspective.set_theory(list_theory.values())
1903	except:
1904	msg = "Guiframe set_theory: \n" + str(sys.exc_value)
1905	logging.info(msg)
1906	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1907	else:
1908	msg = "Guiframe does not have a current perspective"
1909	logging.info(msg)
1910
1911	def plot_data(self, state_id, data_id=None,
1912	theory_id=None, append=False):
1913	"""
1914	send a list of data to plot
1915	"""
1916	total_plot_list = []
1917	data_list, _ = self._data_manager.get_by_id(data_id)
1918	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
1919	total_plot_list = data_list.values()
1920	for item in temp_list_theory.values():
1921	theory_data, theory_state = item
1922	total_plot_list.append(theory_data)
1923	GROUP_ID = wx.NewId()
1924	for new_plot in total_plot_list:
1925	if append:
1926	if self.panel_on_focus is None:
1927	message = "cannot append plot. No plot panel on focus!"
1928	message += "please click on any available plot to set focus"
1929	wx.PostEvent(self, StatusEvent(status=message,
1930	info='warning'))
1931	return
1932	else:
1933	if self.enable_add_data(new_plot):
1934	new_plot.group_id = self.panel_on_focus.group_id
1935	else:
1936	message = "Only 1D Data can be append to"
1937	message += " plot panel containing 1D data.\n"
1938	message += "%s not be appended.\n" %str(new_plot.name)
1939	message += "try new plot option.\n"
1940	wx.PostEvent(self, StatusEvent(status=message,
1941	info='warning'))
1942	else:
1943	if self.cleanup_plots:
1944	for id, panel in self.plot_panels.iteritems():
1945	window = self._mgr.GetPane(panel.window_name)
1946	# To hide all docked plot panels when set the data
1947	if not window.IsFloating():
1948	self.hide_panel(id)
1949	#if not append then new plot
1950	from sans.guiframe.dataFitting import Data2D
1951	if issubclass(Data2D, new_plot.__class__):
1952	#for 2 D always plot in a separated new plot
1953	new_plot.group_id = wx.NewId()
1954	else:
1955	# plot all 1D in a new plot
1956	new_plot.group_id = GROUP_ID
1957	title = "PLOT " + str(new_plot.title)
1958	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
1959	title=title,
1960	group_id = new_plot.group_id))
1961
1962	def remove_data(self, data_id, theory_id=None):
1963	"""
1964	Delete data state if data_id is provide
1965	delete theory created with data of id data_id if theory_id is provide
1966	if delete all true: delete the all state
1967	else delete theory
1968	"""
1969	temp = data_id + theory_id
1970	"""
1971	value = [plug.is_in_use(temp) for plug in self.plugins]
1972	if len(value) > 0:
1973	print "value"
1974	return
1975	from data_panel import DataDialog
1976	dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
1977	if dlg.ShowModal() == wx.ID_OK:
1978	selected_data_list = dlg.get_data()
1979	dlg.Destroy()
1980	"""
1981	for plug in self.plugins:
1982	plug.delete_data(temp)
1983	total_plot_list = []
1984	data_list, _ = self._data_manager.get_by_id(data_id)
1985	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
1986	total_plot_list = data_list.values()
1987	for item in temp_list_theory.values():
1988	theory_data, theory_state = item
1989	total_plot_list.append(theory_data)
1990	for new_plot in total_plot_list:
1991	id = new_plot.id
1992	for group_id in new_plot.list_group_id:
1993	wx.PostEvent(self, NewPlotEvent(id=id,
1994	group_id=group_id,
1995	action='remove'))
1996	self._data_manager.delete_data(data_id=data_id,
1997	theory_id=theory_id)
1998
1999
2000	def set_current_perspective(self, perspective):
2001	"""
2002	set the current active perspective
2003	"""
2004	self._current_perspective = perspective
2005	name = "No current analysis selected"
2006	if self._current_perspective is not None:
2007	self._add_current_plugin_menu()
2008	for panel in self.panels.values():
2009	if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
2010	for name in self._current_perspective.get_perspective():
2011	if name == panel.window_name:
2012	panel.on_set_focus(event=None)
2013	break
2014	name = self._current_perspective.sub_menu
2015	if self._data_panel is not None:
2016	self._data_panel.set_active_perspective(name)
2017	self._check_applications_menu()
2018	#Set the SansView title
2019	self._set_title_name(name)
2020
2021
2022	def _set_title_name(self, name):
2023	"""
2024	Set the SansView title w/ the current application name
2025
2026	: param name: application name [string]
2027	"""
2028	# Set SanView Window title w/ application anme
2029	title = self.title + " - " + name + " -"
2030	self.SetTitle(title)
2031
2032	def _check_applications_menu(self):
2033	"""
2034	check the menu of the current application
2035	"""
2036	if self._applications_menu is not None:
2037	for menu in self._applications_menu.GetMenuItems():
2038	if self._current_perspective is not None:
2039	name = self._current_perspective.sub_menu
2040	if menu.IsCheckable():
2041	if menu.GetLabel() == name:
2042	menu.Check(True)
2043	else:
2044	menu.Check(False)
2045
2046	def set_plotpanel_floating(self, event=None):
2047	"""
2048	make the plot panel floatable
2049	"""
2050
2051	self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
2052	self.__gui_style \|= GUIFRAME.FLOATING_PANEL
2053	plot_panel = []
2054	id = event.GetId()
2055	menu = self._window_menu.FindItemById(id)
2056	if self._plotting_plugin is not None:
2057	plot_panel = self._plotting_plugin.plot_panels.values()
2058	for p in plot_panel:
2059	self._popup_floating_panel(p)
2060	menu.Check(True)
2061
2062	def set_plotpanel_fixed(self, event=None):
2063	"""
2064	make the plot panel fixed
2065	"""
2066	self.__gui_style &= (~GUIFRAME.FLOATING_PANEL)
2067	self.__gui_style \|= GUIFRAME.FIXED_PANEL
2068	plot_panel = []
2069	id = event.GetId()
2070	menu = self._window_menu.FindItemById(id)
2071	if self._plotting_plugin is not None:
2072	plot_panel = self._plotting_plugin.plot_panels.values()
2073	for p in plot_panel:
2074	self._popup_fixed_panel(p)
2075	menu.Check(True)
2076
2077	def on_cleanup_dock(self, event=None):
2078	"""
2079	Set Cleanup Dock option
2080	"""
2081	if event == None:
2082	return
2083	id = event.GetId()
2084	menu = self._window_menu.FindItemById(id)
2085	Flag = self.cleanup_plots
2086	if not Flag:
2087	menu.Check(True)
2088	self.cleanup_plots = True
2089	msg = "Cleanup-Dock option set to 'ON'."
2090	else:
2091	menu.Check(False)
2092	self.cleanup_plots = False
2093	msg = "Cleanup-Dock option set to 'OFF'."
2094
2095	wx.PostEvent(self, StatusEvent(status= msg))
2096
2097	def _popup_fixed_panel(self, p):
2098	"""
2099	"""
2100	style = self.__gui_style & GUIFRAME.FIXED_PANEL
2101	if style == GUIFRAME.FIXED_PANEL:
2102	self._mgr.GetPane(p.window_name).Dock()
2103	self._mgr.GetPane(p.window_name).Floatable()
2104	self._mgr.GetPane(p.window_name).Right()
2105	self._mgr.GetPane(p.window_name).TopDockable(False)
2106	self._mgr.GetPane(p.window_name).BottomDockable(False)
2107	self._mgr.GetPane(p.window_name).LeftDockable(False)
2108	self._mgr.GetPane(p.window_name).RightDockable(True)
2109	self._mgr.Update()
2110
2111	def _popup_floating_panel(self, p):
2112	"""
2113	"""
2114	style = self.__gui_style & GUIFRAME.FLOATING_PANEL
2115	if style == GUIFRAME.FLOATING_PANEL:
2116	self._mgr.GetPane(p.window_name).Floatable(True)
2117	self._mgr.GetPane(p.window_name).Float()
2118	self._mgr.GetPane(p.window_name).Dockable(False)
2119	self._mgr.Update()
2120
2121	def enable_add_data(self, new_plot):
2122	"""
2123	Enable append data on a plot panel
2124	"""
2125
2126	if self.panel_on_focus not in self._plotting_plugin.plot_panels.values():
2127	return
2128	is_theory = len(self.panel_on_focus.plots) <= 1 and \
2129	self.panel_on_focus.plots.values()[0].__class__.__name__ == "Theory1D"
2130
2131	is_data2d = hasattr(new_plot, 'data')
2132
2133	is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
2134	and self.panel_on_focus.group_id is not None
2135	has_meta_data = hasattr(new_plot, 'meta_data')
2136
2137	#disable_add_data if the data is being recovered from a saved state file.
2138	is_state_data = False
2139	if has_meta_data:
2140	if 'invstate' in new_plot.meta_data: is_state_data = True
2141	if 'prstate' in new_plot.meta_data: is_state_data = True
2142	if 'fitstate' in new_plot.meta_data: is_state_data = True
2143
2144	return is_data1d and not is_data2d and not is_theory and not is_state_data
2145
2146	def enable_edit_menu(self):
2147	"""
2148	enable menu item under edit menu depending on the panel on focus
2149	"""
2150	if self.cpanel_on_focus is not None and self._edit_menu is not None:
2151	flag = self.cpanel_on_focus.get_undo_flag()
2152	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2153	flag = self.cpanel_on_focus.get_redo_flag()
2154	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2155	flag = self.cpanel_on_focus.get_copy_flag()
2156	self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2157	flag = self.cpanel_on_focus.get_paste_flag()
2158	self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2159	#flag = self.cpanel_on_focus.get_print_flag()
2160	#self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
2161	flag = self.cpanel_on_focus.get_preview_flag()
2162	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2163	flag = self.cpanel_on_focus.get_reset_flag()
2164	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2165	else:
2166	flag = False
2167	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2168	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2169	self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2170	self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2171	#self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
2172	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2173	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2174
2175	def on_undo_panel(self, event=None):
2176	"""
2177	undo previous action of the last panel on focus if possible
2178	"""
2179	if self.cpanel_on_focus is not None:
2180	self.cpanel_on_focus.on_undo(event)
2181
2182	def on_redo_panel(self, event=None):
2183	"""
2184	redo the last cancel action done on the last panel on focus
2185	"""
2186	if self.cpanel_on_focus is not None:
2187	self.cpanel_on_focus.on_redo(event)
2188
2189	def on_copy_panel(self, event=None):
2190	"""
2191	copy the last panel on focus if possible
2192	"""
2193	if self.cpanel_on_focus is not None:
2194	self.cpanel_on_focus.on_copy(event)
2195
2196	def on_paste_panel(self, event=None):
2197	"""
2198	paste clipboard to the last panel on focus
2199	"""
2200	if self.cpanel_on_focus is not None:
2201	self.cpanel_on_focus.on_paste(event)
2202
2203	def on_bookmark_panel(self, event=None):
2204	"""
2205	bookmark panel
2206	"""
2207	if self.cpanel_on_focus is not None:
2208	self.cpanel_on_focus.on_bookmark(event)
2209
2210	def append_bookmark(self, event=None):
2211	"""
2212	Bookmark available information of the panel on focus
2213	"""
2214	self._toolbar.append_bookmark(event)
2215
2216	def on_save_panel(self, event=None):
2217	"""
2218	save possible information on the current panel
2219	"""
2220	if self.cpanel_on_focus is not None:
2221	self.cpanel_on_focus.on_save(event)
2222
2223	def on_preview_panel(self, event=None):
2224	"""
2225	preview information on the panel on focus
2226	"""
2227	if self.cpanel_on_focus is not None:
2228	self.cpanel_on_focus.on_preview(event)
2229
2230	def on_print_panel(self, event=None):
2231	"""
2232	print available information on the last panel on focus
2233	"""
2234	if self.cpanel_on_focus is not None:
2235	self.cpanel_on_focus.on_print(event)
2236
2237	def on_zoom_panel(self, event=None):
2238	"""
2239	zoom on the current panel if possible
2240	"""
2241	if self.cpanel_on_focus is not None:
2242	self.cpanel_on_focus.on_zoom(event)
2243
2244	def on_zoom_in_panel(self, event=None):
2245	"""
2246	zoom in of the panel on focus
2247	"""
2248	if self.cpanel_on_focus is not None:
2249	self.cpanel_on_focus.on_zoom_in(event)
2250
2251	def on_zoom_out_panel(self, event=None):
2252	"""
2253	zoom out on the panel on focus
2254	"""
2255	if self.cpanel_on_focus is not None:
2256	self.cpanel_on_focus.on_zoom_out(event)
2257
2258	def on_drag_panel(self, event=None):
2259	"""
2260	drag apply to the panel on focus
2261	"""
2262	if self.cpanel_on_focus is not None:
2263	self.cpanel_on_focus.on_drag(event)
2264
2265	def on_reset_panel(self, event=None):
2266	"""
2267	reset the current panel
2268	"""
2269	if self.cpanel_on_focus is not None:
2270	self.cpanel_on_focus.on_reset(event)
2271
2272	def enable_undo(self):
2273	"""
2274	enable undo related control
2275	"""
2276	if self.cpanel_on_focus is not None:
2277	self._toolbar.enable_undo(self.cpanel_on_focus)
2278
2279	def enable_redo(self):
2280	"""
2281	enable redo
2282	"""
2283	if self.cpanel_on_focus is not None:
2284	self._toolbar.enable_redo(self.cpanel_on_focus)
2285
2286	def enable_copy(self):
2287	"""
2288	enable copy related control
2289	"""
2290	if self.cpanel_on_focus is not None:
2291	self._toolbar.enable_copy(self.cpanel_on_focus)
2292
2293	def enable_paste(self):
2294	"""
2295	enable paste
2296	"""
2297	if self.cpanel_on_focus is not None:
2298	self._toolbar.enable_paste(self.cpanel_on_focus)
2299
2300	def enable_bookmark(self):
2301	"""
2302	Bookmark
2303	"""
2304	if self.cpanel_on_focus is not None:
2305	self._toolbar.enable_bookmark(self.cpanel_on_focus)
2306
2307	def enable_save(self):
2308	"""
2309	save
2310	"""
2311	if self.cpanel_on_focus is not None:
2312	self._toolbar.enable_save(self.cpanel_on_focus)
2313
2314	def enable_preview(self):
2315	"""
2316	preview
2317	"""
2318	if self.cpanel_on_focus is not None:
2319	self._toolbar.enable_preview(self.cpanel_on_focus)
2320
2321	def enable_print(self):
2322	"""
2323	print
2324	"""
2325	if self.cpanel_on_focus is not None:
2326	self._toolbar.enable_print(self.cpanel_on_focus)
2327
2328	def enable_zoom(self):
2329	"""
2330	zoom
2331	"""
2332	if self.cpanel_on_focus is not None:
2333	self._toolbar.enable_zoom(self.panel_on_focus)
2334
2335	def enable_zoom_in(self):
2336	"""
2337	zoom in
2338	"""
2339	if self.cpanel_on_focus is not None:
2340	self._toolbar.enable_zoom_in(self.panel_on_focus)
2341
2342	def enable_zoom_out(self):
2343	"""
2344	zoom out
2345	"""
2346	if self.cpanel_on_focus is not None:
2347	self._toolbar.enable_zoom_out(self.panel_on_focus)
2348
2349	def enable_drag(self, event=None):
2350	"""
2351	drag
2352	"""
2353	if self.cpanel_on_focus is not None:
2354	self._toolbar.enable_drag(self.panel_on_focus)
2355
2356	def enable_reset(self):
2357	"""
2358	reset the current panel
2359	"""
2360	if self.cpanel_on_focus is not None:
2361	self._toolbar.enable_reset(self.panel_on_focus)
2362
2363	def set_schedule_full_draw(self, panel=None, func='del'):
2364	"""
2365	Add/subtract the schedule full draw list with the panel given
2366
2367	:param panel: plot panel
2368	:param func: append or del [string]
2369	"""
2370
2371	# append this panel in the schedule list if not in yet
2372	if func == 'append':
2373	if not panel in self.schedule_full_draw_list:
2374	self.schedule_full_draw_list.append(panel)
2375	# remove this panel from schedule list
2376	elif func == 'del':
2377	if len(self.schedule_full_draw_list) > 0:
2378	if panel in self.schedule_full_draw_list:
2379	self.schedule_full_draw_list.remove(panel)
2380
2381	# reset the schdule
2382	if len(self.schedule_full_draw_list) == 0:
2383	self.schedule = False
2384	else:
2385	self.schedule = True
2386
2387	def full_draw(self):
2388	"""
2389	Draw the panels with axes in the schedule to full dwar list
2390	"""
2391	count = len(self.schedule_full_draw_list)
2392	#if not self.schedule:
2393	if count < 1:
2394	self.set_schedule(False)
2395	return
2396	else:
2397	ind = 0
2398	# if any of the panel is shown do full_draw
2399	for panel in self.schedule_full_draw_list:
2400	ind += 1
2401	if self._mgr.GetPane(panel.window_name).IsShown():
2402	break
2403	# otherwise, return
2404	if ind == count:
2405	return
2406
2407	#Simple redraw only for a panel shown
2408	def f_draw(panel):
2409	"""
2410	Draw A panel in the full dwar list
2411	"""
2412	try:
2413	# This checking of GetCapture is to stop redrawing
2414	# while any panel is capture.
2415	if self.GetCapture() == None:
2416	# draw if possible
2417	panel.set_resizing(False)
2418	panel.Show(False)
2419	panel.draw_plot()
2420
2421	# Check if the panel is not shown
2422	if not self._mgr.GetPane(panel.window_name).IsShown():
2423	self._mgr.GetPane(panel.window_name).Hide()
2424	else:
2425	panel.Show(True)
2426	except:
2427	pass
2428	#print self.callback,self.schedule,self.schedule_full_draw_list
2429
2430	# Draw all panels
2431	map(f_draw, self.schedule_full_draw_list)
2432
2433	# Reset the attr
2434	if len(self.schedule_full_draw_list) == 0:
2435	self.set_schedule(False)
2436	else:
2437	self.set_schedule(True)
2438	# do not update mgr
2439	#self._mgr.Update()
2440
2441	def set_schedule(self, schedule=False):
2442	"""
2443	Set schedule
2444	"""
2445	self.schedule = schedule
2446
2447	def get_schedule(self):
2448	"""
2449	Get schedule
2450	"""
2451	return self.schedule
2452
2453	def on_set_plot_focus(self, panel):
2454	"""
2455	Set focus on a plot panel
2456	"""
2457	self.set_plot_unfocus()
2458	panel.on_set_focus(None)
2459	# set focusing panel
2460	self.panel_on_focus = panel
2461	self.set_panel_on_focus(None)
2462
2463	def set_plot_unfocus(self):
2464	"""
2465	Un focus all plot panels
2466	"""
2467	for plot in self.plot_panels.values():
2468	plot.on_kill_focus(None)
2469
2470	def _onDrawIdle(self, args, *kwargs):
2471	"""
2472	ReDraw with axes
2473	"""
2474	try:
2475	# check if it is time to redraw
2476	if self.GetCapture() == None:
2477	# Draw plot, changes resizing too
2478	self.full_draw()
2479	except:
2480	pass
2481
2482	# restart idle
2483	self._redraw_idle(args, *kwargs)
2484
2485
2486	def _redraw_idle(self, args, *kwargs):
2487	"""
2488	Restart Idle
2489	"""
2490	# restart idle
2491	self.idletimer.Restart(55, args, *kwargs)
2492
2493
2494	class DefaultPanel(wx.Panel, PanelBase):
2495	"""
2496	Defines the API for a panels to work with
2497	the GUI manager
2498	"""
2499	## Internal nickname for the window, used by the AUI manager
2500	window_name = "default"
2501	## Name to appear on the window title bar
2502	window_caption = "Welcome panel"
2503	## Flag to tell the AUI manager to put this panel in the center pane
2504	CENTER_PANE = True
2505	def __init__(self, parent, args, *kwds):
2506	wx.Panel.__init__(self, parent, args, *kwds)
2507	PanelBase.__init__(self, parent)
2508
2509
2510
2511	# Toy application to test this Frame
2512	class ViewApp(wx.App):
2513	"""
2514	"""
2515	def OnInit(self):
2516	"""
2517	"""
2518	pos, size = self.window_placement((GUIFRAME_WIDTH, GUIFRAME_HEIGHT))
2519	self.frame = ViewerFrame(parent=None,
2520	title=APPLICATION_NAME,
2521	pos=pos,
2522	gui_style = DEFAULT_STYLE,
2523	size=size)
2524	self.frame.Hide()
2525	self.s_screen = None
2526	try:
2527	# make sure the current dir is App dir when it starts
2528	temp_path = os.path.dirname(os.path.sys.path[0])
2529	os.chdir(temp_path)
2530	except:
2531	pass
2532	# Display a splash screen on top of the frame.
2533	if len(sys.argv) > 1 and '--time' in sys.argv[1:]:
2534	log_time("Starting to display the splash screen")
2535	try:
2536	if os.path.isfile(SPLASH_SCREEN_PATH):
2537	self.s_screen = self.display_splash_screen(parent=self.frame,
2538	path=SPLASH_SCREEN_PATH)
2539	else:
2540	self.frame.Show()
2541	except:
2542	if self.s_screen is not None:
2543	self.s_screen.Close()
2544	msg = "Cannot display splash screen\n"
2545	msg += str (sys.exc_value)
2546	logging.error(msg)
2547	self.frame.Show()
2548
2549	if hasattr(self.frame, 'special'):
2550	self.frame.special.SetCurrent()
2551	self.SetTopWindow(self.frame)
2552	try:
2553	self.open_file()
2554	except:
2555	msg = "%s Could not load " % str(APPLICATION_NAME)
2556	msg += "input file from command line.\n"
2557	logging.error(msg)
2558	return True
2559
2560	def open_file(self):
2561	"""
2562	open a state file at the start of the application
2563	"""
2564	input_file = None
2565	if len(sys.argv) >= 2:
2566	cmd = sys.argv[0].lower()
2567	if os.path.isfile(cmd):
2568	basename = os.path.basename(cmd)
2569	app_py = str(APPLICATION_NAME).lower() + '.py'
2570	app_exe = str(APPLICATION_NAME).lower() + '.exe'
2571	app_app = str(APPLICATION_NAME).lower() + '.app'
2572	if basename.lower() in [app_py, app_exe, app_app]:
2573	input_file = sys.argv[1]
2574	if input_file is None:
2575	return
2576	if self.frame is not None:
2577	self.frame.set_input_file(input_file=input_file)
2578
2579
2580	def set_manager(self, manager):
2581	"""
2582	Sets a reference to the application manager
2583	of the GUI manager (Frame)
2584	"""
2585	self.frame.set_manager(manager)
2586
2587	def build_gui(self):
2588	"""
2589	Build the GUI
2590	"""
2591	#try to load file at the start
2592	try:
2593	self.open_file()
2594	except:
2595	raise
2596	self.frame.build_gui()
2597	#if self.s_screen is not None and self.s_screen.IsShown():
2598	# self.s_screen.Close()
2599
2600	def set_welcome_panel(self, panel_class):
2601	"""
2602	Set the welcome panel
2603
2604	:param panel_class: class of the welcome panel to be instantiated
2605
2606	"""
2607	self.frame.set_welcome_panel(panel_class)
2608
2609	def add_perspective(self, perspective):
2610	"""
2611	Manually add a perspective to the application GUI
2612	"""
2613	self.frame.add_perspective(perspective)
2614
2615	def window_placement(self, size):
2616	"""
2617	Determines the position and size of the application frame such that it
2618	fits on the user's screen without obstructing (or being obstructed by)
2619	the Windows task bar. The maximum initial size in pixels is bounded by
2620	WIDTH x HEIGHT. For most monitors, the application
2621	will be centered on the screen; for very large monitors it will be
2622	placed on the left side of the screen.
2623	"""
2624	window_width, window_height = size
2625	screen_size = wx.GetDisplaySize()
2626	window_height = window_height if screen_size[1]>window_height else screen_size[1]-10
2627	window_width = window_width if screen_size[0]> window_width else screen_size[0]-10
2628	xpos = ypos = 0
2629
2630	# Note that when running Linux and using an Xming (X11) server on a PC
2631	# with a dual monitor configuration, the reported display size may be
2632	# that of both monitors combined with an incorrect display count of 1.
2633	# To avoid displaying this app across both monitors, we check for
2634	# screen 'too big'. If so, we assume a smaller width which means the
2635	# application will be placed towards the left hand side of the screen.
2636
2637	_, _, x, y = wx.Display().GetClientArea() # size excludes task bar
2638	if len(sys.argv) > 1 and '--platform' in sys.argv[1:]:
2639	w, h = wx.DisplaySize() # size includes task bar area
2640	# display on left side, not centered on screen
2641	if x > 1920 and x > (2*y): x = x / 2
2642	if x > window_width: xpos = (x - window_width)/2
2643	if y > window_height: ypos = (y - window_height)/2
2644
2645	# Return the suggested position and size for the application frame.
2646	return (xpos, ypos), (min(x, window_width), min(y, window_height))
2647
2648	def display_splash_screen(self, parent,
2649	path=SPLASH_SCREEN_PATH):
2650	"""Displays the splash screen. It will exactly cover the main frame."""
2651
2652	# Prepare the picture. On a 2GHz intel cpu, this takes about a second.
2653	x, y = parent.GetSizeTuple()
2654	image = wx.Image(path, wx.BITMAP_TYPE_PNG)
2655	image.Rescale(SPLASH_SCREEN_WIDTH,
2656	SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
2657	bm = image.ConvertToBitmap()
2658
2659	# Create and show the splash screen. It will disappear only when the
2660	# program has entered the event loop AND either the timeout has expired
2661	# or the user has left clicked on the screen. Thus any processing
2662	# performed in this routine (including sleeping) or processing in the
2663	# calling routine (including doing imports) will prevent the splash
2664	# screen from disappearing.
2665	#
2666	# Note that on Linux, the timeout appears to occur immediately in which
2667	# case the splash screen disappears upon entering the event loop.
2668	s_screen = wx.SplashScreen(bitmap=bm,
2669	splashStyle=(wx.SPLASH_TIMEOUT\|
2670	wx.SPLASH_CENTRE_ON_SCREEN),
2671	style=(wx.SIMPLE_BORDER\|
2672	wx.FRAME_NO_TASKBAR\|
2673	wx.STAY_ON_TOP),
2674
2675	milliseconds=SS_MAX_DISPLAY_TIME,
2676	parent=parent,
2677	id=wx.ID_ANY)
2678	from gui_statusbar import SPageStatusbar
2679	statusBar = SPageStatusbar(s_screen)
2680	s_screen.SetStatusBar(statusBar)
2681	s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
2682	s_screen.Show()
2683	return s_screen
2684
2685
2686	def on_close_splash_screen(self, event):
2687	"""
2688	"""
2689	self.frame.Show(True)
2690	event.Skip()
2691
2692	if __name__ == "__main__":
2693	app = ViewApp(0)
2694	app.MainLoop()
2695
2696

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

SasView

source: sasview/guiframe/gui_manager.py @ 7f291a3

Download in other formats: