gui_manager.py @ f2d9e76

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 f2d9e76 was f2d9e76, checked in by Jae Cho <jhjcho@…>, 13 years ago
added option to clean up duck area
Property mode set to `100644`
File size: 99.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	# Set up extra custom tool menu
379	self._setup_extra_custom()
380	# Set up the menu
381	self._setup_menus()
382
383	try:
384	self.load_from_cmd(self._input_file)
385	except:
386	msg = "%s Cannot load file %s\n" %(str(APPLICATION_NAME),
387	str(self._input_file))
388	msg += str(sys.exc_value) + '\n'
389	print msg
390	if self._data_panel is not None:
391	self._data_panel.fill_cbox_analysis(self.plugins)
392	self.post_init()
393	# Set Custom default
394	self.set_custom_default_perspective()
395
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():
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	'&Data Explorer ON', '')
947	wx.EVT_MENU(self, id, self.show_data_panel)
948	if style == GUIFRAME.MANAGER_ON:
949	self._data_panel_menu.SetText('Data Explorer OFF')
950	else:
951	self._data_panel_menu.SetText('Data Explorer ON')
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.PREVIEW_ID, '&Report',
1190	'Preview current panel')
1191	wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel)
1192	self._edit_menu.Append(GUIFRAME_ID.PRINT_ID, '&Print',
1193	'Print current panel')
1194	wx.EVT_MENU(self, GUIFRAME_ID.PRINT_ID, self.on_print_panel)
1195	self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset',
1196	'Reset current panel')
1197	wx.EVT_MENU(self, GUIFRAME_ID.RESET_ID, self.on_reset_panel)
1198
1199	self._menubar.Append(self._edit_menu, '&Edit')
1200	self.enable_edit_menu()
1201
1202	def get_style(self):
1203	"""
1204	"""
1205	return self.__gui_style
1206
1207	def _add_menu_data(self):
1208	"""
1209	Add menu item item data to menu bar
1210	"""
1211	if self._data_plugin is not None:
1212	menu_list = self._data_plugin.populate_menu(self)
1213	if menu_list:
1214	for (menu, name) in menu_list:
1215	self._menubar.Append(menu, name)
1216
1217
1218	def _on_toggle_toolbar(self, event=None):
1219	"""
1220	hide or show toolbar
1221	"""
1222	if self._toolbar is None:
1223	return
1224	if self._toolbar.IsShown():
1225	if self._toolbar_menu is not None:
1226	self._toolbar_menu.SetItemLabel('Show Toolbar')
1227	self._toolbar.Hide()
1228	else:
1229	if self._toolbar_menu is not None:
1230	self._toolbar_menu.SetItemLabel('Hide Toolbar')
1231	self._toolbar.Show()
1232	self._toolbar.Realize()
1233
1234	def _on_status_event(self, evt):
1235	"""
1236	Display status message
1237	"""
1238	self.sb.set_status(event=evt)
1239
1240	def on_view(self, evt):
1241	"""
1242	A panel was selected to be shown. If it's not already
1243	shown, display it.
1244
1245	:param evt: menu event
1246
1247	"""
1248	panel_id = str(evt.GetId())
1249	self.on_set_plot_focus(self.panels[panel_id])
1250	self.show_panel(evt.GetId(), 'on')
1251	wx.CallLater(5, self.set_schedule(True))
1252	self.set_plot_unfocus()
1253
1254	def on_close_welcome_panel(self):
1255	"""
1256	Close the welcome panel
1257	"""
1258	if self.defaultPanel is None:
1259	return
1260	default_panel = self._mgr.GetPane(self.panels["default"].window_name)
1261	if default_panel.IsShown():
1262	default_panel.Hide()
1263	# Recover current perspective
1264	perspective = self._current_perspective
1265	perspective.on_perspective(event=None)
1266	self._mgr.Update()
1267	# Show toolbar
1268	style = self.__gui_style & GUIFRAME.TOOLBAR_ON
1269	if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
1270	self._on_toggle_toolbar()
1271
1272	def show_welcome_panel(self, event):
1273	"""
1274	Display the welcome panel
1275	"""
1276	if self.defaultPanel is None:
1277	return
1278	for id, panel in self.panels.iteritems():
1279	if id == 'default':
1280	# Show default panel
1281	if not self._mgr.GetPane(self.panels["default"].window_name).IsShown():
1282	self._mgr.GetPane(self.panels["default"].window_name).Show(True)
1283	elif id == "data_panel":
1284	flag = self._mgr.GetPane(self.panels["data_panel"].window_name).IsShown()
1285	self._mgr.GetPane(self.panels["data_panel"].window_name).Show(flag)
1286	elif panel not in self.plot_panels.values() :
1287	self._mgr.GetPane(self.panels[id].window_name).IsShown()
1288	self._mgr.GetPane(self.panels[id].window_name).Hide()
1289	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
1290	#if (style == GUIFRAME.TOOLBAR_ON) & (self._toolbar.IsShown()):
1291	# # self._toolbar.Show(True)
1292	# self._on_toggle_toolbar()
1293
1294	self._mgr.Update()
1295
1296	def show_panel(self, uid, show=None):
1297	"""
1298	Shows the panel with the given id
1299
1300	:param uid: unique ID number of the panel to show
1301
1302	"""
1303	ID = str(uid)
1304	config.printEVT("show_panel: %s" % ID)
1305	if ID in self.panels.keys():
1306	if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():
1307	if show == 'on':
1308	self._mgr.GetPane(self.panels[ID].window_name).Show()
1309	elif self.panels[ID].window_caption.split(" ")[0] == \
1310	"Residuals":
1311	self._mgr.GetPane(self.panels[ID].window_name).Hide()
1312	else:
1313	self._mgr.GetPane(self.panels[ID].window_name).Show()
1314	# Hide default panel
1315	self._mgr.GetPane(self.panels["default"].window_name).Hide()
1316	self._mgr.Update()
1317	self._redraw_idle()
1318
1319	def hide_panel(self, uid):
1320	"""
1321	hide panel except default panel
1322	"""
1323	ID = str(uid)
1324	caption = self.panels[ID].window_caption
1325	config.printEVT("hide_panel: %s" % ID)
1326	if ID in self.panels.keys():
1327	if self._mgr.GetPane(self.panels[ID].window_name).IsShown():
1328	self._mgr.GetPane(self.panels[ID].window_name).Hide()
1329	if self._data_panel is not None and \
1330	ID in self.plot_panels.keys():
1331	self._data_panel.cb_plotpanel.Append(str(caption), p)
1332	# Do not Hide default panel here...
1333	#self._mgr.GetPane(self.panels["default"].window_name).Hide()
1334	self._mgr.Update()
1335
1336	def delete_panel(self, uid):
1337	"""
1338	delete panel given uid
1339	"""
1340	ID = str(uid)
1341	config.printEVT("delete_panel: %s" % ID)
1342	caption = self.panels[ID].window_caption
1343	if ID in self.panels.keys():
1344	self.panel_on_focus = None
1345	panel = self.panels[ID]
1346	self._plotting_plugin.delete_panel(panel.group_id)
1347	self._mgr.DetachPane(panel)
1348	panel.Hide()
1349	panel.clear()
1350	panel.Close()
1351	self._mgr.Update()
1352	#delete uid number not str(uid)
1353	if uid in self.plot_panels.keys():
1354	del self.plot_panels[uid]
1355	return
1356
1357	def clear_panel(self):
1358	"""
1359	"""
1360	for item in self.panels:
1361	try:
1362	self.panels[item].clear_panel()
1363	except:
1364	pass
1365
1366	def create_gui_data(self, data, path=None):
1367	"""
1368	"""
1369	return self._data_manager.create_gui_data(data, path)
1370
1371	def get_data(self, path):
1372	"""
1373	"""
1374	message = ""
1375	log_msg = ''
1376	output = []
1377	error_message = ""
1378	basename = os.path.basename(path)
1379	root, extension = os.path.splitext(basename)
1380	if extension.lower() not in EXTENSIONS:
1381	log_msg = "File Loader cannot "
1382	log_msg += "load: %s\n" % str(basename)
1383	log_msg += "Try Data opening...."
1384	logging.info(log_msg)
1385	self.load_complete(output=output, error_message=error_message,
1386	message=log_msg, path=path)
1387	return
1388
1389	#reading a state file
1390	for plug in self.plugins:
1391	reader, ext = plug.get_extensions()
1392	if reader is not None:
1393	#read the state of the single plugin
1394	if extension == ext:
1395	reader.read(path)
1396	return
1397	elif extension == APPLICATION_STATE_EXTENSION:
1398	reader.read(path)
1399
1400	style = self.__gui_style & GUIFRAME.MANAGER_ON
1401	if style == GUIFRAME.MANAGER_ON:
1402	if self._data_panel is not None:
1403	#data_state = self._data_manager.get_selected_data()
1404	#self._data_panel.load_data_list(data_state)
1405	self._mgr.GetPane(self._data_panel.window_name).Show(True)
1406
1407	def load_from_cmd(self, path):
1408	"""
1409	load data from cmd or application
1410	"""
1411	if path is None:
1412	return
1413	else:
1414	path = os.path.abspath(path)
1415	if not os.path.isfile(path):
1416	return
1417	basename = os.path.basename(path)
1418	root, extension = os.path.splitext(basename)
1419	if extension.lower() not in EXTENSIONS:
1420	self.load_data(path)
1421	else:
1422	self.load_state(path)
1423
1424	def load_state(self, path):
1425	"""
1426	load data from command line or application
1427	"""
1428	if path and (path is not None) and os.path.isfile(path):
1429	basename = os.path.basename(path)
1430	if APPLICATION_STATE_EXTENSION is not None \
1431	and basename.endswith(APPLICATION_STATE_EXTENSION):
1432	#Hide current plot_panels i
1433	for ID in self.plot_panels.keys():
1434	panel = self._mgr.GetPane(self.plot_panels[ID].window_name)
1435	if panel.IsShown():
1436	panel.Hide()
1437	self.get_data(path)
1438	if self.defaultPanel is not None and \
1439	self._mgr.GetPane(self.panels["default"].window_name).IsShown():
1440	self.on_close_welcome_panel()
1441
1442	def load_data(self, path):
1443	"""
1444	load data from command line
1445	"""
1446	if not os.path.isfile(path):
1447	return
1448	basename = os.path.basename(path)
1449	root, extension = os.path.splitext(basename)
1450	if extension.lower() in EXTENSIONS:
1451	log_msg = "Data Loader cannot "
1452	log_msg += "load: %s\n" % str(path)
1453	log_msg += "Try File opening ...."
1454	print log_msg
1455	return
1456	message = ""
1457	log_msg = ''
1458	output = {}
1459	error_message = ""
1460	try:
1461	print "Loading Data...:\n" + str(path) + "\n"
1462	temp = self.loader.load(path)
1463	if temp.__class__.__name__ == "list":
1464	for item in temp:
1465	data = self.create_gui_data(item, path)
1466	output[data.id] = data
1467	else:
1468	data = self.create_gui_data(temp, path)
1469	output[data.id] = data
1470
1471	self.add_data(data_list=output)
1472	except:
1473	error_message = "Error while loading"
1474	error_message += " Data from cmd:\n %s\n" % str(path)
1475	error_message += str(sys.exc_value) + "\n"
1476	print error_message
1477
1478
1479	def _on_open_state_application(self, event):
1480	"""
1481	"""
1482	path = None
1483	if self._default_save_location == None:
1484	self._default_save_location = os.getcwd()
1485
1486	plug_wlist = self._on_open_state_app_helper()
1487	dlg = wx.FileDialog(self,
1488	"Choose a file",
1489	self._default_save_location, "",
1490	plug_wlist)
1491	if dlg.ShowModal() == wx.ID_OK:
1492	path = dlg.GetPath()
1493	if path is not None:
1494	self._default_save_location = os.path.dirname(path)
1495	dlg.Destroy()
1496	self.load_state(path=path)
1497
1498	def _on_open_state_app_helper(self):
1499	"""
1500	Helps '_on_open_state_application()' to find the extension of
1501	the current perspective/application
1502	"""
1503	# No current perspective or no extension attr
1504	if self._current_perspective is None:
1505	return PLUGINS_WLIST
1506	try:
1507	# Find the extension of the perspective and get that as 1st item in list
1508	ind = None
1509	app_ext = self._current_perspective._extensions
1510	plug_wlist = config.PLUGINS_WLIST
1511	for ext in set(plug_wlist):
1512	if ext.count(app_ext) > 0:
1513	ind = ext
1514	break
1515	# Found the extension
1516	if ind != None:
1517	plug_wlist.remove(ind)
1518	plug_wlist.insert(0, ind)
1519	try:
1520	plug_wlist ='\|'.join(plug_wlist)
1521	except:
1522	plug_wlist = ''
1523
1524	except:
1525	plug_wlist = PLUGINS_WLIST
1526
1527	return plug_wlist
1528
1529	def _on_open_state_project(self, event):
1530	"""
1531	"""
1532	path = None
1533	if self._default_save_location == None:
1534	self._default_save_location = os.getcwd()
1535
1536	dlg = wx.FileDialog(self,
1537	"Choose a file",
1538	self._default_save_location, "",
1539	APPLICATION_WLIST)
1540	if dlg.ShowModal() == wx.ID_OK:
1541	path = dlg.GetPath()
1542	if path is not None:
1543	self._default_save_location = os.path.dirname(path)
1544	dlg.Destroy()
1545
1546	#try:
1547	# os.popen(path)
1548	# #self.Close()
1549	#except:
1550	self.load_state(path=path)
1551
1552	def _on_save_application(self, event):
1553	"""
1554	save the state of the current active application
1555	"""
1556	if self.cpanel_on_focus is not None:
1557	self.cpanel_on_focus.on_save(event)
1558
1559	def _on_save_project(self, event):
1560	"""
1561	save the state of the SansView as *.svs
1562	"""
1563	## Default file location for save
1564	self._default_save_location = os.getcwd()
1565	if self._current_perspective is None:
1566	return
1567	reader, ext = self._current_perspective.get_extensions()
1568	path = None
1569	extension = '*' + APPLICATION_STATE_EXTENSION
1570	dlg = wx.FileDialog(self, "Save Project file",
1571	self._default_save_location, "",
1572	extension,
1573	wx.SAVE)
1574	if dlg.ShowModal() == wx.ID_OK:
1575	path = dlg.GetPath()
1576	self._default_save_location = os.path.dirname(path)
1577	else:
1578	return None
1579	dlg.Destroy()
1580	if path is None:
1581	return
1582	# default cansas xml doc
1583	doc = None
1584	for panel in self.panels.values():
1585	temp = panel.save_project(doc)
1586	if temp is not None:
1587	doc = temp
1588
1589	# Write the XML document
1590	extens = APPLICATION_STATE_EXTENSION
1591	fName = os.path.splitext(path)[0] + extens
1592	if doc != None:
1593	fd = open(fName, 'w')
1594	fd.write(doc.toprettyxml())
1595	fd.close()
1596	else:
1597	msg = "%s cannot read %s\n" % (str(APPLICATION_NAME), str(path))
1598	logging.error(msg)
1599
1600	def on_save_helper(self, doc, reader, panel, path):
1601	"""
1602	Save state into a file
1603	"""
1604	try:
1605	if reader is not None:
1606	# case of a panel with multi-pages
1607	if hasattr(panel, "opened_pages"):
1608	for uid, page in panel.opened_pages.iteritems():
1609	data = page.get_data()
1610	# state must be cloned
1611	state = page.get_state().clone()
1612	if data is not None:
1613	new_doc = reader.write_toXML(data, state)
1614	if doc != None and hasattr(doc, "firstChild"):
1615	child = new_doc.firstChild.firstChild
1616	doc.firstChild.appendChild(child)
1617	else:
1618	doc = new_doc
1619	# case of only a panel
1620	else:
1621	data = panel.get_data()
1622	state = panel.get_state()
1623	if data is not None:
1624	new_doc = reader.write_toXML(data, state)
1625	if doc != None and hasattr(doc, "firstChild"):
1626	child = new_doc.firstChild.firstChild
1627	doc.firstChild.appendChild(child)
1628	else:
1629	doc = new_doc
1630	except:
1631	raise
1632	#pass
1633
1634	return doc
1635
1636	def quit_guiframe(self):
1637	"""
1638	Pop up message to make sure the user wants to quit the application
1639	"""
1640	message = "Do you really want to quit \n"
1641	message += "this application?"
1642	dial = wx.MessageDialog(self, message, 'Question',
1643	wx.YES_NO\|wx.YES_DEFAULT\|wx.ICON_QUESTION)
1644	if dial.ShowModal() == wx.ID_YES:
1645	return True
1646	else:
1647	return False
1648
1649	def Close(self, event=None):
1650	"""
1651	Quit the application
1652	"""
1653	#flag = self.quit_guiframe()
1654	if True:
1655	wx.Exit()
1656	sys.exit()
1657
1658	def _check_update(self, event=None):
1659	"""
1660	Check with the deployment server whether a new version
1661	of the application is available.
1662	A thread is started for the connecting with the server. The thread calls
1663	a call-back method when the current version number has been obtained.
1664	"""
1665	if hasattr(config, "__update_URL__"):
1666	import version
1667	checker = version.VersionThread(config.__update_URL__,
1668	self._process_version,
1669	baggage=event==None)
1670	checker.start()
1671
1672	def _process_version(self, version, standalone=True):
1673	"""
1674	Call-back method for the process of checking for updates.
1675	This methods is called by a VersionThread object once the current
1676	version number has been obtained. If the check is being done in the
1677	background, the user will not be notified unless there's an update.
1678
1679	:param version: version string
1680	:param standalone: True of the update is being checked in
1681	the background, False otherwise.
1682
1683	"""
1684	try:
1685	if cmp(version, config.__version__) > 0:
1686	msg = "Version %s is available! See the Help "
1687	msg += "menu to download it." % version
1688	self.SetStatusText(msg)
1689	if not standalone:
1690	import webbrowser
1691	webbrowser.open(config.__download_page__)
1692	else:
1693	if not standalone:
1694	msg = "You have the latest version"
1695	msg += " of %s" % config.__appname__
1696	self.SetStatusText(msg)
1697	except:
1698	msg = "guiframe: could not get latest application"
1699	msg += " version number\n %s" % sys.exc_value
1700	logging.error(msg)
1701	if not standalone:
1702	msg = "Could not connect to the application server."
1703	msg += " Please try again later."
1704	self.SetStatusText(msg)
1705
1706	def _onAbout(self, evt):
1707	"""
1708	Pop up the about dialog
1709
1710	:param evt: menu event
1711
1712	"""
1713	if config._do_aboutbox:
1714	import aboutbox
1715	dialog = aboutbox.DialogAbout(None, -1, "")
1716	dialog.ShowModal()
1717
1718	def set_manager(self, manager):
1719	"""
1720	Sets the application manager for this frame
1721
1722	:param manager: frame manager
1723	"""
1724	self.app_manager = manager
1725
1726	def post_init(self):
1727	"""
1728	This initialization method is called after the GUI
1729	has been created and all plug-ins loaded. It calls
1730	the post_init() method of each plug-in (if it exists)
1731	so that final initialization can be done.
1732	"""
1733	for item in self.plugins:
1734	if hasattr(item, "post_init"):
1735	item.post_init()
1736
1737	def set_default_perspective(self):
1738	"""
1739	Choose among the plugin the first plug-in that has
1740	"set_default_perspective" method and its return value is True will be
1741	as a default perspective when the welcome page is closed
1742	"""
1743	for item in self.plugins:
1744	if hasattr(item, "set_default_perspective"):
1745	if item.set_default_perspective():
1746	item.on_perspective(event=None)
1747	return
1748
1749	def set_perspective(self, panels):
1750	"""
1751	Sets the perspective of the GUI.
1752	Opens all the panels in the list, and closes
1753	all the others.
1754
1755	:param panels: list of panels
1756	"""
1757	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
1758	#if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
1759	# self._on_toggle_toolbar()
1760	for item in self.panels:
1761	# Check whether this is a sticky panel
1762	if hasattr(self.panels[item], "ALWAYS_ON"):
1763	if self.panels[item].ALWAYS_ON:
1764	continue
1765
1766	if self.panels[item].window_name in panels:
1767	if not self._mgr.GetPane(self.panels[item].window_name).IsShown():
1768	self._mgr.GetPane(self.panels[item].window_name).Show()
1769	else:
1770	# always show the data panel if enable
1771	style = self.__gui_style & GUIFRAME.MANAGER_ON
1772	if (style == GUIFRAME.MANAGER_ON) and self.panels[item] == self._data_panel:
1773	if 'data_panel' in self.panels.keys():
1774	flag = self._mgr.GetPane(self.panels['data_panel'].window_name).IsShown()
1775	self._mgr.GetPane(self.panels['data_panel'].window_name).Show(flag)
1776	else:
1777	if self._mgr.GetPane(self.panels[item].window_name).IsShown():
1778	self._mgr.GetPane(self.panels[item].window_name).Hide()
1779
1780	self._mgr.Update()
1781
1782	def show_data_panel(self, event=None, action=True):
1783	"""
1784	show the data panel
1785	"""
1786	if self._data_panel_menu == None:
1787	return
1788	label = self._data_panel_menu.GetText()
1789	if label == 'Data Explorer ON':
1790	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
1791	#if not pane.IsShown():
1792	if action:
1793	pane.Show(True)
1794	self._mgr.Update()
1795	self.__gui_style = self.__gui_style \| GUIFRAME.MANAGER_ON
1796
1797	self._data_panel_menu.SetText('Data Explorer OFF')
1798	else:
1799	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
1800	#if not pane.IsShown():
1801	if action:
1802	pane.Show(False)
1803	self._mgr.Update()
1804	self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
1805	self._data_panel_menu.SetText('Data Explorer ON')
1806
1807	def add_data_helper(self, data_list):
1808	"""
1809	"""
1810	if self._data_manager is not None:
1811	self._data_manager.add_data(data_list)
1812
1813	def add_data(self, data_list):
1814	"""
1815	receive a dictionary of data from loader
1816	store them its data manager if possible
1817	send to data the current active perspective if the data panel
1818	is not active.
1819	:param data_list: dictionary of data's ID and value Data
1820	"""
1821	#Store data into manager
1822	self.add_data_helper(data_list)
1823	# set data in the data panel
1824	if self._data_panel is not None:
1825	data_state = self._data_manager.get_data_state(data_list.keys())
1826	self._data_panel.load_data_list(data_state)
1827	#if the data panel is shown wait for the user to press a button
1828	#to send data to the current perspective. if the panel is not
1829	#show automatically send the data to the current perspective
1830	style = self.__gui_style & GUIFRAME.MANAGER_ON
1831	if style == GUIFRAME.MANAGER_ON:
1832	#wait for button press from the data panel to set_data
1833	if self._data_panel is not None:
1834	self._mgr.GetPane(self._data_panel.window_name).Show(True)
1835	self._mgr.Update()
1836	else:
1837	#automatically send that to the current perspective
1838	self.set_data(data_id=data_list.keys())
1839	self.on_close_welcome_panel()
1840
1841	def set_data(self, data_id, theory_id=None):
1842	"""
1843	set data to current perspective
1844	"""
1845	list_data, _ = self._data_manager.get_by_id(data_id)
1846	if self._current_perspective is not None:
1847	if self.cleanup_plots:
1848	for uid, panel in self.plot_panels.iteritems():
1849	#panel = self.plot_panels[uid]
1850	window = self._mgr.GetPane(panel.window_name)
1851	# To hide all docked plot panels when set the data
1852	if not window.IsFloating():
1853	self.hide_panel(uid)
1854	self._current_perspective.set_data(list_data.values())
1855	self.on_close_welcome_panel()
1856	else:
1857	msg = "Guiframe does not have a current perspective"
1858	logging.info(msg)
1859
1860	def set_theory(self, state_id, theory_id=None):
1861	"""
1862	"""
1863	_, list_theory = self._data_manager.get_by_id(theory_id)
1864	if self._current_perspective is not None:
1865	try:
1866	self._current_perspective.set_theory(list_theory.values())
1867	except:
1868	msg = "Guiframe set_theory: \n" + str(sys.exc_value)
1869	logging.info(msg)
1870	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1871	else:
1872	msg = "Guiframe does not have a current perspective"
1873	logging.info(msg)
1874
1875	def plot_data(self, state_id, data_id=None,
1876	theory_id=None, append=False):
1877	"""
1878	send a list of data to plot
1879	"""
1880	total_plot_list = []
1881	data_list, _ = self._data_manager.get_by_id(data_id)
1882	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
1883	total_plot_list = data_list.values()
1884	for item in temp_list_theory.values():
1885	theory_data, theory_state = item
1886	total_plot_list.append(theory_data)
1887	GROUP_ID = wx.NewId()
1888	for new_plot in total_plot_list:
1889	if append:
1890	if self.panel_on_focus is None:
1891	message = "cannot append plot. No plot panel on focus!"
1892	message += "please click on any available plot to set focus"
1893	wx.PostEvent(self, StatusEvent(status=message,
1894	info='warning'))
1895	return
1896	else:
1897	if self.enable_add_data(new_plot):
1898	new_plot.group_id = self.panel_on_focus.group_id
1899	else:
1900	message = "Only 1D Data can be append to"
1901	message += " plot panel containing 1D data.\n"
1902	message += "%s not be appended.\n" %str(new_plot.name)
1903	message += "try new plot option.\n"
1904	wx.PostEvent(self, StatusEvent(status=message,
1905	info='warning'))
1906	else:
1907	if self.cleanup_plots:
1908	for id, panel in self.plot_panels.iteritems():
1909	window = self._mgr.GetPane(panel.window_name)
1910	# To hide all docked plot panels when set the data
1911	if not window.IsFloating():
1912	self.hide_panel(id)
1913	#if not append then new plot
1914	from sans.guiframe.dataFitting import Data2D
1915	if issubclass(Data2D, new_plot.__class__):
1916	#for 2 D always plot in a separated new plot
1917	new_plot.group_id = wx.NewId()
1918	else:
1919	# plot all 1D in a new plot
1920	new_plot.group_id = GROUP_ID
1921	title = "PLOT " + str(new_plot.title)
1922	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
1923	title=title,
1924	group_id = new_plot.group_id))
1925
1926	def remove_data(self, data_id, theory_id=None):
1927	"""
1928	Delete data state if data_id is provide
1929	delete theory created with data of id data_id if theory_id is provide
1930	if delete all true: delete the all state
1931	else delete theory
1932	"""
1933	temp = data_id + theory_id
1934	"""
1935	value = [plug.is_in_use(temp) for plug in self.plugins]
1936	if len(value) > 0:
1937	print "value"
1938	return
1939	from data_panel import DataDialog
1940	dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
1941	if dlg.ShowModal() == wx.ID_OK:
1942	selected_data_list = dlg.get_data()
1943	dlg.Destroy()
1944	"""
1945	for plug in self.plugins:
1946	plug.delete_data(temp)
1947	total_plot_list = []
1948	data_list, _ = self._data_manager.get_by_id(data_id)
1949	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
1950	total_plot_list = data_list.values()
1951	for item in temp_list_theory.values():
1952	theory_data, theory_state = item
1953	total_plot_list.append(theory_data)
1954	for new_plot in total_plot_list:
1955	id = new_plot.id
1956	for group_id in new_plot.list_group_id:
1957	wx.PostEvent(self, NewPlotEvent(id=id,
1958	group_id=group_id,
1959	action='remove'))
1960	self._data_manager.delete_data(data_id=data_id,
1961	theory_id=theory_id)
1962
1963
1964	def set_current_perspective(self, perspective):
1965	"""
1966	set the current active perspective
1967	"""
1968	self._current_perspective = perspective
1969	name = "No current analysis selected"
1970	if self._current_perspective is not None:
1971	self._add_current_plugin_menu()
1972	for panel in self.panels.values():
1973	if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
1974	for name in self._current_perspective.get_perspective():
1975	if name == panel.window_name:
1976	panel.on_set_focus(event=None)
1977	break
1978	name = self._current_perspective.sub_menu
1979	if self._data_panel is not None:
1980	self._data_panel.set_active_perspective(name)
1981	self._check_applications_menu()
1982	#Set the SansView title
1983	self._set_title_name(name)
1984
1985
1986	def _set_title_name(self, name):
1987	"""
1988	Set the SansView title w/ the current application name
1989
1990	: param name: application name [string]
1991	"""
1992	# Set SanView Window title w/ application anme
1993	title = self.title + " - " + name + " -"
1994	self.SetTitle(title)
1995
1996	def _check_applications_menu(self):
1997	"""
1998	check the menu of the current application
1999	"""
2000	if self._applications_menu is not None:
2001	for menu in self._applications_menu.GetMenuItems():
2002	if self._current_perspective is not None:
2003	name = self._current_perspective.sub_menu
2004	if menu.IsCheckable():
2005	if menu.GetLabel() == name:
2006	menu.Check(True)
2007	else:
2008	menu.Check(False)
2009
2010	def set_plotpanel_floating(self, event=None):
2011	"""
2012	make the plot panel floatable
2013	"""
2014
2015	self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
2016	self.__gui_style \|= GUIFRAME.FLOATING_PANEL
2017	plot_panel = []
2018	id = event.GetId()
2019	menu = self._window_menu.FindItemById(id)
2020	if self._plotting_plugin is not None:
2021	plot_panel = self._plotting_plugin.plot_panels.values()
2022	for p in plot_panel:
2023	self._popup_floating_panel(p)
2024	menu.Check(True)
2025
2026	def set_plotpanel_fixed(self, event=None):
2027	"""
2028	make the plot panel fixed
2029	"""
2030	self.__gui_style &= (~GUIFRAME.FLOATING_PANEL)
2031	self.__gui_style \|= GUIFRAME.FIXED_PANEL
2032	plot_panel = []
2033	id = event.GetId()
2034	menu = self._window_menu.FindItemById(id)
2035	if self._plotting_plugin is not None:
2036	plot_panel = self._plotting_plugin.plot_panels.values()
2037	for p in plot_panel:
2038	self._popup_fixed_panel(p)
2039	menu.Check(True)
2040
2041	def on_cleanup_dock(self, event=None):
2042	"""
2043	Set Cleanup Dock option
2044	"""
2045	if event == None:
2046	return
2047	id = event.GetId()
2048	menu = self._window_menu.FindItemById(id)
2049	Flag = self.cleanup_plots
2050	if not Flag:
2051	menu.Check(True)
2052	self.cleanup_plots = True
2053	msg = "Cleanup-Dock option set to 'ON'."
2054	else:
2055	menu.Check(False)
2056	self.cleanup_plots = False
2057	msg = "Cleanup-Dock option set to 'OFF'."
2058
2059	wx.PostEvent(self, StatusEvent(status= msg))
2060
2061	def _popup_fixed_panel(self, p):
2062	"""
2063	"""
2064	style = self.__gui_style & GUIFRAME.FIXED_PANEL
2065	if style == GUIFRAME.FIXED_PANEL:
2066	self._mgr.GetPane(p.window_name).Dock()
2067	self._mgr.GetPane(p.window_name).Floatable()
2068	self._mgr.GetPane(p.window_name).Right()
2069	self._mgr.GetPane(p.window_name).TopDockable(False)
2070	self._mgr.GetPane(p.window_name).BottomDockable(False)
2071	self._mgr.GetPane(p.window_name).LeftDockable(False)
2072	self._mgr.GetPane(p.window_name).RightDockable(True)
2073	self._mgr.Update()
2074
2075	def _popup_floating_panel(self, p):
2076	"""
2077	"""
2078	style = self.__gui_style & GUIFRAME.FLOATING_PANEL
2079	if style == GUIFRAME.FLOATING_PANEL:
2080	self._mgr.GetPane(p.window_name).Floatable(True)
2081	self._mgr.GetPane(p.window_name).Float()
2082	self._mgr.GetPane(p.window_name).Dockable(False)
2083	self._mgr.Update()
2084
2085	def enable_add_data(self, new_plot):
2086	"""
2087	Enable append data on a plot panel
2088	"""
2089
2090	if self.panel_on_focus not in self._plotting_plugin.plot_panels.values():
2091	return
2092	is_theory = len(self.panel_on_focus.plots) <= 1 and \
2093	self.panel_on_focus.plots.values()[0].__class__.__name__ == "Theory1D"
2094
2095	is_data2d = hasattr(new_plot, 'data')
2096
2097	is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
2098	and self.panel_on_focus.group_id is not None
2099	has_meta_data = hasattr(new_plot, 'meta_data')
2100
2101	#disable_add_data if the data is being recovered from a saved state file.
2102	is_state_data = False
2103	if has_meta_data:
2104	if 'invstate' in new_plot.meta_data: is_state_data = True
2105	if 'prstate' in new_plot.meta_data: is_state_data = True
2106	if 'fitstate' in new_plot.meta_data: is_state_data = True
2107
2108	return is_data1d and not is_data2d and not is_theory and not is_state_data
2109
2110	def enable_edit_menu(self):
2111	"""
2112	enable menu item under edit menu depending on the panel on focus
2113	"""
2114	if self.cpanel_on_focus is not None and self._edit_menu is not None:
2115	flag = self.cpanel_on_focus.get_undo_flag()
2116	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2117	flag = self.cpanel_on_focus.get_redo_flag()
2118	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2119	flag = self.cpanel_on_focus.get_print_flag()
2120	self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
2121	flag = self.cpanel_on_focus.get_preview_flag()
2122	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2123	flag = self.cpanel_on_focus.get_reset_flag()
2124	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2125	else:
2126	flag = False
2127	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2128	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2129	self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
2130	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2131	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2132
2133	def on_undo_panel(self, event=None):
2134	"""
2135	undo previous action of the last panel on focus if possible
2136	"""
2137	if self.cpanel_on_focus is not None:
2138	self.cpanel_on_focus.on_undo(event)
2139
2140	def on_redo_panel(self, event=None):
2141	"""
2142	redo the last cancel action done on the last panel on focus
2143	"""
2144	if self.cpanel_on_focus is not None:
2145	self.cpanel_on_focus.on_redo(event)
2146
2147	def on_bookmark_panel(self, event=None):
2148	"""
2149	bookmark panel
2150	"""
2151	if self.cpanel_on_focus is not None:
2152	self.cpanel_on_focus.on_bookmark(event)
2153
2154	def append_bookmark(self, event=None):
2155	"""
2156	Bookmark available information of the panel on focus
2157	"""
2158	self._toolbar.append_bookmark(event)
2159
2160	def on_save_panel(self, event=None):
2161	"""
2162	save possible information on the current panel
2163	"""
2164	if self.cpanel_on_focus is not None:
2165	self.cpanel_on_focus.on_save(event)
2166
2167	def on_preview_panel(self, event=None):
2168	"""
2169	preview information on the panel on focus
2170	"""
2171	if self.cpanel_on_focus is not None:
2172	self.cpanel_on_focus.on_preview(event)
2173
2174	def on_print_panel(self, event=None):
2175	"""
2176	print available information on the last panel on focus
2177	"""
2178	if self.cpanel_on_focus is not None:
2179	self.cpanel_on_focus.on_print(event)
2180
2181	def on_zoom_panel(self, event=None):
2182	"""
2183	zoom on the current panel if possible
2184	"""
2185	if self.cpanel_on_focus is not None:
2186	self.cpanel_on_focus.on_zoom(event)
2187
2188	def on_zoom_in_panel(self, event=None):
2189	"""
2190	zoom in of the panel on focus
2191	"""
2192	if self.cpanel_on_focus is not None:
2193	self.cpanel_on_focus.on_zoom_in(event)
2194
2195	def on_zoom_out_panel(self, event=None):
2196	"""
2197	zoom out on the panel on focus
2198	"""
2199	if self.cpanel_on_focus is not None:
2200	self.cpanel_on_focus.on_zoom_out(event)
2201
2202	def on_drag_panel(self, event=None):
2203	"""
2204	drag apply to the panel on focus
2205	"""
2206	if self.cpanel_on_focus is not None:
2207	self.cpanel_on_focus.on_drag(event)
2208
2209	def on_reset_panel(self, event=None):
2210	"""
2211	reset the current panel
2212	"""
2213	if self.cpanel_on_focus is not None:
2214	self.cpanel_on_focus.on_reset(event)
2215
2216	def enable_undo(self):
2217	"""
2218	enable undo related control
2219	"""
2220	if self.cpanel_on_focus is not None:
2221	self._toolbar.enable_undo(self.cpanel_on_focus)
2222
2223	def enable_redo(self):
2224	"""
2225	enable redo
2226	"""
2227	if self.cpanel_on_focus is not None:
2228	self._toolbar.enable_redo(self.cpanel_on_focus)
2229
2230	def enable_bookmark(self):
2231	"""
2232	Bookmark
2233	"""
2234	if self.cpanel_on_focus is not None:
2235	self._toolbar.enable_bookmark(self.cpanel_on_focus)
2236
2237	def enable_save(self):
2238	"""
2239	save
2240	"""
2241	if self.cpanel_on_focus is not None:
2242	self._toolbar.enable_save(self.cpanel_on_focus)
2243
2244	def enable_preview(self):
2245	"""
2246	preview
2247	"""
2248	if self.cpanel_on_focus is not None:
2249	self._toolbar.enable_preview(self.cpanel_on_focus)
2250
2251	def enable_print(self):
2252	"""
2253	print
2254	"""
2255	if self.cpanel_on_focus is not None:
2256	self._toolbar.enable_print(self.cpanel_on_focus)
2257
2258	def enable_zoom(self):
2259	"""
2260	zoom
2261	"""
2262	if self.cpanel_on_focus is not None:
2263	self._toolbar.enable_zoom(self.panel_on_focus)
2264
2265	def enable_zoom_in(self):
2266	"""
2267	zoom in
2268	"""
2269	if self.cpanel_on_focus is not None:
2270	self._toolbar.enable_zoom_in(self.panel_on_focus)
2271
2272	def enable_zoom_out(self):
2273	"""
2274	zoom out
2275	"""
2276	if self.cpanel_on_focus is not None:
2277	self._toolbar.enable_zoom_out(self.panel_on_focus)
2278
2279	def enable_drag(self, event=None):
2280	"""
2281	drag
2282	"""
2283	if self.cpanel_on_focus is not None:
2284	self._toolbar.enable_drag(self.panel_on_focus)
2285
2286	def enable_reset(self):
2287	"""
2288	reset the current panel
2289	"""
2290	if self.cpanel_on_focus is not None:
2291	self._toolbar.enable_reset(self.panel_on_focus)
2292
2293	def set_schedule_full_draw(self, panel=None, func='del'):
2294	"""
2295	Add/subtract the schedule full draw list with the panel given
2296
2297	:param panel: plot panel
2298	:param func: append or del [string]
2299	"""
2300
2301	# append this panel in the schedule list if not in yet
2302	if func == 'append':
2303	if not panel in self.schedule_full_draw_list:
2304	self.schedule_full_draw_list.append(panel)
2305	# remove this panel from schedule list
2306	elif func == 'del':
2307	if len(self.schedule_full_draw_list) > 0:
2308	if panel in self.schedule_full_draw_list:
2309	self.schedule_full_draw_list.remove(panel)
2310
2311	# reset the schdule
2312	if len(self.schedule_full_draw_list) == 0:
2313	self.schedule = False
2314	else:
2315	self.schedule = True
2316
2317	def full_draw(self):
2318	"""
2319	Draw the panels with axes in the schedule to full dwar list
2320	"""
2321	count = len(self.schedule_full_draw_list)
2322	#if not self.schedule:
2323	if count < 1:
2324	self.set_schedule(False)
2325	return
2326	else:
2327	ind = 0
2328	# if any of the panel is shown do full_draw
2329	for panel in self.schedule_full_draw_list:
2330	ind += 1
2331	if self._mgr.GetPane(panel.window_name).IsShown():
2332	break
2333	# otherwise, return
2334	if ind == count:
2335	return
2336
2337	#Simple redraw only for a panel shown
2338	def f_draw(panel):
2339	"""
2340	Draw A panel in the full dwar list
2341	"""
2342	try:
2343	# This checking of GetCapture is to stop redrawing
2344	# while any panel is capture.
2345	if self.GetCapture() == None:
2346	# draw if possible
2347	panel.set_resizing(False)
2348	panel.draw_plot()
2349	# Check if the panel is not shown
2350	if not self._mgr.GetPane(panel.window_name).IsShown():
2351	self._mgr.GetPane(panel.window_name).Hide()
2352	except:
2353	pass
2354	#print self.callback,self.schedule,self.schedule_full_draw_list
2355
2356	# Draw all panels
2357	map(f_draw, self.schedule_full_draw_list)
2358
2359	# Reset the attr
2360	if len(self.schedule_full_draw_list) == 0:
2361	self.set_schedule(False)
2362	else:
2363	self.set_schedule(True)
2364	# do not update mgr
2365	#self._mgr.Update()
2366
2367	def set_schedule(self, schedule=False):
2368	"""
2369	Set schedule
2370	"""
2371	self.schedule = schedule
2372
2373	def get_schedule(self):
2374	"""
2375	Get schedule
2376	"""
2377	return self.schedule
2378
2379	def on_set_plot_focus(self, panel):
2380	"""
2381	Set focus on a plot panel
2382	"""
2383	self.set_plot_unfocus()
2384	panel.on_set_focus(None)
2385	# set focusing panel
2386	self.panel_on_focus = panel
2387	self.set_panel_on_focus(None)
2388
2389	def set_plot_unfocus(self):
2390	"""
2391	Un focus all plot panels
2392	"""
2393	for plot in self.plot_panels.values():
2394	plot.on_kill_focus(None)
2395
2396	def _onDrawIdle(self, args, *kwargs):
2397	"""
2398	ReDraw with axes
2399	"""
2400	# check if it is time to redraw
2401	if self.GetCapture() == None:
2402	# Draw plot, changes resizing too
2403	self.full_draw()
2404
2405	# restart idle
2406	self._redraw_idle(args, *kwargs)
2407
2408
2409	def _redraw_idle(self, args, *kwargs):
2410	"""
2411	Restart Idle
2412	"""
2413	# restart idle
2414	self.idletimer.Restart(55, args, *kwargs)
2415
2416
2417	class DefaultPanel(wx.Panel, PanelBase):
2418	"""
2419	Defines the API for a panels to work with
2420	the GUI manager
2421	"""
2422	## Internal nickname for the window, used by the AUI manager
2423	window_name = "default"
2424	## Name to appear on the window title bar
2425	window_caption = "Welcome panel"
2426	## Flag to tell the AUI manager to put this panel in the center pane
2427	CENTER_PANE = True
2428	def __init__(self, parent, args, *kwds):
2429	wx.Panel.__init__(self, parent, args, *kwds)
2430	PanelBase.__init__(self, parent)
2431
2432
2433
2434	# Toy application to test this Frame
2435	class ViewApp(wx.App):
2436	"""
2437	"""
2438	def OnInit(self):
2439	"""
2440	"""
2441	pos, size = self.window_placement((GUIFRAME_WIDTH, GUIFRAME_HEIGHT))
2442	self.frame = ViewerFrame(parent=None,
2443	title=APPLICATION_NAME,
2444	pos=pos,
2445	gui_style = DEFAULT_STYLE,
2446	size=size)
2447	self.frame.Hide()
2448	self.s_screen = None
2449	try:
2450	# make sure the current dir is App dir when it starts
2451	temp_path = os.path.dirname(os.path.sys.path[0])
2452	os.chdir(temp_path)
2453	except:
2454	pass
2455	# Display a splash screen on top of the frame.
2456	if len(sys.argv) > 1 and '--time' in sys.argv[1:]:
2457	log_time("Starting to display the splash screen")
2458	try:
2459	if os.path.isfile(SPLASH_SCREEN_PATH):
2460	self.s_screen = self.display_splash_screen(parent=self.frame,
2461	path=SPLASH_SCREEN_PATH)
2462	else:
2463	self.frame.Show()
2464	except:
2465	if self.s_screen is not None:
2466	self.s_screen.Close()
2467	msg = "Cannot display splash screen\n"
2468	msg += str (sys.exc_value)
2469	logging.error(msg)
2470	self.frame.Show()
2471
2472	if hasattr(self.frame, 'special'):
2473	self.frame.special.SetCurrent()
2474	self.SetTopWindow(self.frame)
2475	try:
2476	self.open_file()
2477	except:
2478	msg = "%s Could not load " % str(APPLICATION_NAME)
2479	msg += "input file from command line.\n"
2480	logging.error(msg)
2481	return True
2482
2483	def open_file(self):
2484	"""
2485	open a state file at the start of the application
2486	"""
2487	input_file = None
2488	if len(sys.argv) >= 2:
2489	cmd = sys.argv[0].lower()
2490	if os.path.isfile(cmd):
2491	basename = os.path.basename(cmd)
2492	app_py = str(APPLICATION_NAME).lower() + '.py'
2493	app_exe = str(APPLICATION_NAME).lower() + '.exe'
2494	if basename.lower() in [app_py, app_exe]:
2495	input_file = sys.argv[1]
2496	if input_file is None:
2497	return
2498	if self.frame is not None:
2499	self.frame.set_input_file(input_file=input_file)
2500
2501
2502	def set_manager(self, manager):
2503	"""
2504	Sets a reference to the application manager
2505	of the GUI manager (Frame)
2506	"""
2507	self.frame.set_manager(manager)
2508
2509	def build_gui(self):
2510	"""
2511	Build the GUI
2512	"""
2513	#try to load file at the start
2514	try:
2515	self.open_file()
2516	except:
2517	raise
2518	self.frame.build_gui()
2519	#if self.s_screen is not None and self.s_screen.IsShown():
2520	# self.s_screen.Close()
2521
2522	def set_welcome_panel(self, panel_class):
2523	"""
2524	Set the welcome panel
2525
2526	:param panel_class: class of the welcome panel to be instantiated
2527
2528	"""
2529	self.frame.set_welcome_panel(panel_class)
2530
2531	def add_perspective(self, perspective):
2532	"""
2533	Manually add a perspective to the application GUI
2534	"""
2535	self.frame.add_perspective(perspective)
2536
2537	def window_placement(self, size):
2538	"""
2539	Determines the position and size of the application frame such that it
2540	fits on the user's screen without obstructing (or being obstructed by)
2541	the Windows task bar. The maximum initial size in pixels is bounded by
2542	WIDTH x HEIGHT. For most monitors, the application
2543	will be centered on the screen; for very large monitors it will be
2544	placed on the left side of the screen.
2545	"""
2546	window_width, window_height = size
2547	screen_size = wx.GetDisplaySize()
2548	window_height = window_height if screen_size[1]>window_height else screen_size[1]-50
2549	window_width = window_width if screen_size[0]> window_width else screen_size[0]-50
2550	xpos = ypos = 0
2551
2552	# Note that when running Linux and using an Xming (X11) server on a PC
2553	# with a dual monitor configuration, the reported display size may be
2554	# that of both monitors combined with an incorrect display count of 1.
2555	# To avoid displaying this app across both monitors, we check for
2556	# screen 'too big'. If so, we assume a smaller width which means the
2557	# application will be placed towards the left hand side of the screen.
2558
2559	_, _, x, y = wx.Display().GetClientArea() # size excludes task bar
2560	if len(sys.argv) > 1 and '--platform' in sys.argv[1:]:
2561	w, h = wx.DisplaySize() # size includes task bar area
2562	if x > 1920: x = 1280 # display on left side, not centered on screen
2563	if x > window_width: xpos = (x - window_width)/2
2564	if y > window_height: ypos = (y - window_height)/2
2565
2566	# Return the suggested position and size for the application frame.
2567	return (xpos, ypos), (min(x, window_width), min(y, window_height))
2568
2569	def display_splash_screen(self, parent,
2570	path=SPLASH_SCREEN_PATH):
2571	"""Displays the splash screen. It will exactly cover the main frame."""
2572
2573	# Prepare the picture. On a 2GHz intel cpu, this takes about a second.
2574	x, y = parent.GetSizeTuple()
2575	image = wx.Image(path, wx.BITMAP_TYPE_PNG)
2576	image.Rescale(SPLASH_SCREEN_WIDTH,
2577	SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
2578	bm = image.ConvertToBitmap()
2579
2580	# Create and show the splash screen. It will disappear only when the
2581	# program has entered the event loop AND either the timeout has expired
2582	# or the user has left clicked on the screen. Thus any processing
2583	# performed in this routine (including sleeping) or processing in the
2584	# calling routine (including doing imports) will prevent the splash
2585	# screen from disappearing.
2586	#
2587	# Note that on Linux, the timeout appears to occur immediately in which
2588	# case the splash screen disappears upon entering the event loop.
2589	s_screen = wx.SplashScreen(bitmap=bm,
2590	splashStyle=(wx.SPLASH_TIMEOUT\|
2591	wx.SPLASH_CENTRE_ON_SCREEN),
2592	style=(wx.SIMPLE_BORDER\|
2593	wx.FRAME_NO_TASKBAR\|
2594	wx.STAY_ON_TOP),
2595
2596	milliseconds=SS_MAX_DISPLAY_TIME,
2597	parent=parent,
2598	id=wx.ID_ANY)
2599	from gui_statusbar import SPageStatusbar
2600	statusBar = SPageStatusbar(s_screen)
2601	s_screen.SetStatusBar(statusBar)
2602	s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
2603	s_screen.Show()
2604	return s_screen
2605
2606
2607	def on_close_splash_screen(self, event):
2608	"""
2609	"""
2610	self.frame.Show(True)
2611	event.Skip()
2612
2613	if __name__ == "__main__":
2614	app = ViewApp(0)
2615	app.MainLoop()
2616
2617

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

SasView

source: sasview/guiframe/gui_manager.py @ f2d9e76

Download in other formats: