gui_manager.py @ 60ad1d4e

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

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

SasView

source: sasview/guiframe/gui_manager.py @ 60ad1d4e

Download in other formats: