gui_manager.py @ bb008fd

magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249unittest-saveload

Last change on this file since bb008fd was bb008fd, checked in by smk78, 6 years ago
Redirect Help >> Tutorial to Documentation tutorials page
Property mode set to `100644`
File size: 126.5 KB

Line
1	"""
2	Gui manager: manages the widgets making up an application
3	"""
4	################################################################################
5	# This software was developed by the University of Tennessee as part of the
6	# Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
7	# project funded by the US National Science Foundation.
8	#
9	# See the license text in license.txtz
10	#
11	# copyright 2008, University of Tennessee
12	################################################################################
13
14
15	import wx
16	import wx.aui
17	import os
18	import sys
19	import time
20	import imp
21	import warnings
22	import re
23	import logging
24	import traceback
25	import urllib
26	import json
27
28	from matplotlib import _pylab_helpers
29
30	from sas import get_local_config, get_custom_config, get_app_dir, get_user_dir
31	from sas.sasgui.guiframe.events import EVT_CATEGORY
32	from sas.sasgui.guiframe.events import EVT_STATUS
33	from sas.sasgui.guiframe.events import EVT_APPEND_BOOKMARK
34	from sas.sasgui.guiframe.events import EVT_PANEL_ON_FOCUS
35	from sas.sasgui.guiframe.events import EVT_NEW_LOAD_DATA
36	from sas.sasgui.guiframe.events import EVT_NEW_COLOR
37	from sas.sasgui.guiframe.events import StatusEvent
38	from sas.sasgui.guiframe.events import NewPlotEvent
39	from sas.sasgui.guiframe.gui_style import GUIFRAME
40	from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
41	from sas.sasgui.guiframe.data_panel import DataPanel
42	from sas.sasgui.guiframe.panel_base import PanelBase
43	from sas.sasgui.guiframe.gui_toolbar import GUIToolBar
44	from sas.sasgui.guiframe.data_processor import GridFrame
45	from sas.sasgui.guiframe.events import EVT_NEW_BATCH
46	from sas.sasgui.guiframe.CategoryManager import CategoryManager
47	from sas.sascalc.dataloader.loader import Loader
48	from sas.sasgui.guiframe.proxy import Connection
49
50	logger = logging.getLogger(__name__)
51	warnings.simplefilter("ignore")
52
53	config = get_local_config()
54	custom_config = get_custom_config()
55
56	# read some constants from config
57	APPLICATION_STATE_EXTENSION = config.APPLICATION_STATE_EXTENSION
58	APPLICATION_NAME = config.__appname__
59	SPLASH_SCREEN_PATH = config.SPLASH_SCREEN_PATH
60	WELCOME_PANEL_ON = config.WELCOME_PANEL_ON
61	SPLASH_SCREEN_WIDTH = config.SPLASH_SCREEN_WIDTH
62	SPLASH_SCREEN_HEIGHT = config.SPLASH_SCREEN_HEIGHT
63	SS_MAX_DISPLAY_TIME = config.SS_MAX_DISPLAY_TIME
64	if not WELCOME_PANEL_ON:
65	WELCOME_PANEL_SHOW = False
66	else:
67	WELCOME_PANEL_SHOW = True
68	try:
69	DATALOADER_SHOW = custom_config.DATALOADER_SHOW
70	TOOLBAR_SHOW = custom_config.TOOLBAR_SHOW
71	FIXED_PANEL = custom_config.FIXED_PANEL
72	if WELCOME_PANEL_ON:
73	WELCOME_PANEL_SHOW = custom_config.WELCOME_PANEL_SHOW
74	PLOPANEL_WIDTH = custom_config.PLOPANEL_WIDTH
75	DATAPANEL_WIDTH = custom_config.DATAPANEL_WIDTH
76	GUIFRAME_WIDTH = custom_config.GUIFRAME_WIDTH
77	GUIFRAME_HEIGHT = custom_config.GUIFRAME_HEIGHT
78	CONTROL_WIDTH = custom_config.CONTROL_WIDTH
79	CONTROL_HEIGHT = custom_config.CONTROL_HEIGHT
80	DEFAULT_PERSPECTIVE = custom_config.DEFAULT_PERSPECTIVE
81	CLEANUP_PLOT = custom_config.CLEANUP_PLOT
82	# custom open_path
83	open_folder = custom_config.DEFAULT_OPEN_FOLDER
84	if open_folder is not None and os.path.isdir(open_folder):
85	DEFAULT_OPEN_FOLDER = os.path.abspath(open_folder)
86	else:
87	DEFAULT_OPEN_FOLDER = get_app_dir()
88	SAS_OPENCL = custom_config.SAS_OPENCL
89	except:
90	DATALOADER_SHOW = True
91	TOOLBAR_SHOW = True
92	FIXED_PANEL = True
93	WELCOME_PANEL_SHOW = False
94	PLOPANEL_WIDTH = config.PLOPANEL_WIDTH
95	DATAPANEL_WIDTH = config.DATAPANEL_WIDTH
96	GUIFRAME_WIDTH = config.GUIFRAME_WIDTH
97	GUIFRAME_HEIGHT = config.GUIFRAME_HEIGHT
98	CONTROL_WIDTH = -1
99	CONTROL_HEIGHT = -1
100	DEFAULT_PERSPECTIVE = None
101	CLEANUP_PLOT = False
102	DEFAULT_OPEN_FOLDER = get_app_dir()
103	DEFAULT_OPEN_FOLDER = PATH_APP
104	SAS_OPENCL = None
105	DEFAULT_STYLE = config.DEFAULT_STYLE
106
107	PLUGIN_STATE_EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS
108	OPEN_SAVE_MENU = config.OPEN_SAVE_PROJECT_MENU
109	VIEW_MENU = config.VIEW_MENU
110	EDIT_MENU = config.EDIT_MENU
111	extension_list = []
112	if APPLICATION_STATE_EXTENSION is not None:
113	extension_list.append(APPLICATION_STATE_EXTENSION)
114	EXTENSIONS = PLUGIN_STATE_EXTENSIONS + extension_list
115	try:
116	PLUGINS_WLIST = '\|'.join(config.PLUGINS_WLIST)
117	except:
118	PLUGINS_WLIST = ''
119	APPLICATION_WLIST = config.APPLICATION_WLIST
120	IS_WIN = True
121	IS_LINUX = False
122	CLOSE_SHOW = True
123	TIME_FACTOR = 2
124	MDI_STYLE = wx.DEFAULT_FRAME_STYLE
125	NOT_SO_GRAPH_LIST = ["BoxSum"]
126	PARENT_FRAME = wx.MDIParentFrame
127	CHILD_FRAME = wx.MDIChildFrame
128	if sys.platform.count("win32") < 1:
129	IS_WIN = False
130	TIME_FACTOR = 2
131	if int(str(wx.__version__).split('.')[0]) == 2:
132	if int(str(wx.__version__).split('.')[1]) < 9:
133	CLOSE_SHOW = False
134	if sys.platform.count("darwin") < 1:
135	IS_LINUX = True
136	PARENT_FRAME = wx.Frame
137	CHILD_FRAME = wx.Frame
138
139	class ViewerFrame(PARENT_FRAME):
140	"""
141	Main application frame
142	"""
143
144	def __init__(self, parent, title,
145	size=(GUIFRAME_WIDTH, GUIFRAME_HEIGHT),
146	gui_style=DEFAULT_STYLE,
147	style=wx.DEFAULT_FRAME_STYLE,
148	pos=wx.DefaultPosition):
149	"""
150	Initialize the Frame object
151	"""
152	PARENT_FRAME.__init__(self, parent=parent, title=title,
153	pos=pos, size=size)
154	# title
155	self.title = title
156	self.__gui_style = gui_style
157	path = os.path.dirname(__file__)
158	temp_path = os.path.join(path, '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	temp_path = os.path.join(os.getcwd(), 'images')
164	ico_file = os.path.join(temp_path, 'ball.ico')
165	if os.path.isfile(ico_file):
166	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
167	else:
168	ico_file = os.path.join(os.path.dirname(os.path.sys.path[0]),
169	'images', 'ball.ico')
170	if os.path.isfile(ico_file):
171	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
172	self.path = get_app_dir()
173	self.application_name = APPLICATION_NAME
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._data_panel_menu = None
188	self._help_menu = None
189	self._tool_menu = None
190	self._applications_menu_pos = -1
191	self._applications_menu_name = None
192	self._applications_menu = None
193	self._edit_menu = None
194	self._toolbar_menu = None
195	self._save_appl_menu = None
196	# tool bar
197	self._toolbar = None
198	# Status bar
199	self.sb = None
200	# number of plugins
201	self._num_perspectives = 0
202	# plot duck cleanup option
203	self.cleanup_plots = CLEANUP_PLOT
204	# Find plug-ins
205	# Modify this so that we can specify the directory to look into
206	self.plugins = []
207	# add local plugin
208	self.plugins += self._get_local_plugins()
209	self.plugins += self._find_plugins()
210	# List of panels
211	self.panels = {}
212	# List of plot panels
213	self.plot_panels = {}
214	# default Graph number fot the plotpanel caption
215	self.graph_num = 0
216
217	# Default locations
218	self._default_save_location = DEFAULT_OPEN_FOLDER
219	# Welcome panel
220	self.defaultPanel = None
221	self.welcome_panel_class = None
222	# panel on focus
223	self.panel_on_focus = None
224	# control_panel on focus
225	self.cpanel_on_focus = None
226
227	self.loader = Loader()
228	# data manager
229	self.batch_on = False
230	from sas.sasgui.guiframe.data_manager import DataManager
231	self._data_manager = DataManager()
232	self._data_panel = None # DataPanel(parent=self)
233	if self.panel_on_focus is not None:
234	self._data_panel.set_panel_on_focus(
235	self.panel_on_focus.window_caption)
236	# list of plot panels in schedule to full redraw
237	self.schedule = False
238	# self.callback = True
239	self._idle_count = 0
240	self.schedule_full_draw_list = []
241	self.idletimer = wx.CallLater(TIME_FACTOR, self._onDrawIdle)
242
243	self.batch_frame = GridFrame(parent=self)
244	self.batch_frame.Hide()
245	self.on_batch_selection(event=None)
246	self.add_icon()
247
248	# Register the close event so it calls our own method
249	wx.EVT_CLOSE(self, self.WindowClose)
250	# Register to status events
251	self.Bind(EVT_STATUS, self._on_status_event)
252	# Register add extra data on the same panel event on load
253	self.Bind(EVT_PANEL_ON_FOCUS, self.set_panel_on_focus)
254	self.Bind(EVT_APPEND_BOOKMARK, self.append_bookmark)
255	self.Bind(EVT_NEW_LOAD_DATA, self.on_load_data)
256	self.Bind(EVT_NEW_BATCH, self.on_batch_selection)
257	self.Bind(EVT_NEW_COLOR, self.on_color_selection)
258	self.Bind(EVT_CATEGORY, self.on_change_categories)
259	self.setup_custom_conf()
260	# Preferred window size
261	self._window_width, self._window_height = size
262
263	def add_icon(self):
264	"""
265	get list of child and attempt to add the default icon
266	"""
267
268	list_children = self.GetChildren()
269	for frame in list_children:
270	self.put_icon(frame)
271
272	def put_icon(self, frame):
273	"""
274	Put icon on the tap of a panel
275	"""
276	if hasattr(frame, "IsIconized"):
277	if not frame.IsIconized():
278	try:
279	icon = self.GetIcon()
280	frame.SetIcon(icon)
281	except:
282	logger.error("ViewerFrame.put_icon: could not set icon")
283
284	def get_client_size(self):
285	"""
286	return client size tuple
287	"""
288	width, height = self.GetClientSizeTuple()
289	height -= 45
290	# Adjust toolbar height
291	toolbar = self.GetToolBar()
292	if toolbar is not None:
293	_, tb_h = toolbar.GetSizeTuple()
294	height -= tb_h
295	return width, height
296
297	def on_change_categories(self, evt):
298	# ILL
299	fitpanel = None
300	for item in self.plugins:
301	if hasattr(item, "get_panels"):
302	if hasattr(item, "fit_panel"):
303	fitpanel = item.fit_panel
304
305	if fitpanel is not None:
306	for i in range(0, fitpanel.GetPageCount()):
307	fitpanel.GetPage(i)._populate_listbox()
308
309	def on_set_batch_result(self, data_outputs, data_inputs=None,
310	plugin_name=""):
311	"""
312	Display data into a grid in batch mode and show the grid
313	"""
314	t = time.localtime(time.time())
315	time_str = time.strftime("%b %d %H;%M of %Y", t)
316	details = "File Generated by %s : %s" % (APPLICATION_NAME,
317	str(plugin_name))
318	details += "on %s.\n" % time_str
319	ext = ".csv"
320	file_name = "Batch_" + str(plugin_name) + "_" + time_str + ext
321	file_name = self._default_save_location + str(file_name)
322
323	self.open_with_localapp(file_name=file_name,
324	details=details,
325	data_inputs=data_inputs,
326	data_outputs=data_outputs)
327
328	def open_with_localapp(self, data_inputs=None, details="", file_name=None,
329	data_outputs=None):
330	"""
331	Display value of data into the application grid
332	:param data_inputs: dictionary of string and list of items
333	:param details: descriptive string
334	:param file_name: file name
335	:param data_outputs: Data outputs
336	"""
337	self.batch_frame.set_data(data_inputs=data_inputs,
338	data_outputs=data_outputs,
339	details=details,
340	file_name=file_name)
341	self.show_batch_frame(None)
342
343	def on_read_batch_tofile(self, base):
344	"""
345	Open a file dialog , extract the file to read and display values
346	into a grid
347	"""
348	path = None
349	if self._default_save_location is None:
350	self._default_save_location = os.getcwd()
351	wildcard = "(.csv; .txt)\|.csv; .txt"
352	dlg = wx.FileDialog(base,
353	"Choose a file",
354	self._default_save_location, "",
355	wildcard)
356	if dlg.ShowModal() == wx.ID_OK:
357	path = dlg.GetPath()
358	if path is not None:
359	self._default_save_location = os.path.dirname(path)
360	dlg.Destroy()
361	try:
362	self.read_batch_tofile(file_name=path)
363	except:
364	msg = "Error occurred when reading the file; %s\n" % path
365	msg += "%s\n" % sys.exc_value
366	wx.PostEvent(self, StatusEvent(status=msg,
367	info="error"))
368
369	def read_batch_tofile(self, file_name):
370	"""
371	Extract value from file name and Display them into a grid
372	"""
373	if file_name is None or file_name.strip() == "":
374	return
375	data = {}
376	fd = open(file_name, 'r')
377	_, ext = os.path.splitext(file_name)
378	separator = None
379	if ext.lower() == ".csv":
380	separator = ","
381	fd_buffer = fd.read()
382	lines = fd_buffer.split('\n')
383	fd.close()
384	column_names_line = ""
385	index = None
386	details = ""
387	for index in range(len(lines)):
388	line = lines[index]
389	line.strip()
390	count = 0
391	if separator is None:
392	line.replace('\t', ' ')
393	# found the first line containing the label
394	col_name_toks = line.split()
395	for item in col_name_toks:
396	if item.strip() != "":
397	count += 1
398	else:
399	line = " "
400	elif line.find(separator) != -1:
401	if line.count(separator) >= 2:
402	# found the first line containing the label
403	col_name_toks = line.split(separator)
404	for item in col_name_toks:
405	if item.strip() != "":
406	count += 1
407	else:
408	details += line
409	if count >= 2:
410	column_names_line = line
411	break
412
413	if column_names_line.strip() == "" or index is None:
414	return
415
416	col_name_toks = column_names_line.split(separator)
417	c_index = 0
418	for col_index in range(len(col_name_toks)):
419	c_name = col_name_toks[col_index]
420	if c_name.strip() != "":
421	# distinguish between column name and value
422	try:
423	float(c_name)
424	col_name = "Column %s" % str(col_index + 1)
425	index_min = index
426	except:
427	col_name = c_name
428	index_min = index + 1
429	data[col_name] = [lines[row].split(separator)[c_index]
430	for row in range(index_min, len(lines) - 1)]
431	c_index += 1
432
433	self.open_with_localapp(data_outputs=data, data_inputs=None,
434	file_name=file_name, details=details)
435
436	def write_batch_tofile(self, data, file_name, details=""):
437	"""
438	Helper to write result from batch into cvs file
439	"""
440	self._default_save_location = os.path.dirname(file_name)
441	name = os.path.basename(file_name)
442	if data is None or file_name is None or file_name.strip() == "":
443	return
444	_, ext = os.path.splitext(name)
445	try:
446	fd = open(file_name, 'w')
447	except Exception:
448	# On Permission denied: IOError
449	temp_dir = get_user_dir()
450	temp_file_name = os.path.join(temp_dir, name)
451	fd = open(temp_file_name, 'w')
452	separator = "\t"
453	if ext.lower() == ".csv":
454	separator = ","
455	fd.write(str(details))
456	for col_name in data.keys():
457	fd.write(str(col_name))
458	fd.write(separator)
459	fd.write('\n')
460	max_list = [len(value) for value in data.values()]
461	if len(max_list) == 0:
462	return
463	max_index = max(max_list)
464	index = 0
465	while index < max_index:
466	for value_list in data.values():
467	if index < len(value_list):
468	fd.write(str(value_list[index]))
469	fd.write(separator)
470	else:
471	fd.write('')
472	fd.write(separator)
473	fd.write('\n')
474	index += 1
475	fd.close()
476
477	def open_with_externalapp(self, data, file_name, details=""):
478	"""
479	Display data in the another application , by default Excel
480	"""
481	if not os.path.exists(file_name):
482	self.write_batch_tofile(data=data, file_name=file_name,
483	details=details)
484	try:
485	from win32com.client import Dispatch
486	excel_app = Dispatch('Excel.Application')
487	excel_app.Workbooks.Open(file_name)
488	excel_app.Visible = 1
489	except:
490	msg = "Error occured when calling Excel.\n"
491	msg += "Check that Excel installed in this machine or \n"
492	msg += "check that %s really exists.\n" % str(file_name)
493	wx.PostEvent(self, StatusEvent(status=msg,
494	info="error"))
495
496	def on_batch_selection(self, event=None):
497	"""
498	:param event: contains parameter enable. When enable is set to True
499	the application is in Batch mode otherwise the application is
500	in Single mode.
501	"""
502	if event is not None:
503	self.batch_on = event.enable
504	for plug in self.plugins:
505	plug.set_batch_selection(self.batch_on)
506
507	def on_color_selection(self, event):
508	"""
509	:param event: contains parameters for id and color
510	"""
511	color, event_id = event.color, event.id
512	for plug in self.plugins:
513	plug.add_color(color, event_id)
514
515	def setup_custom_conf(self):
516	"""
517	Set up custom configuration if exists
518	"""
519	if custom_config is None:
520	return
521
522	if not FIXED_PANEL:
523	self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
524	self.__gui_style \|= GUIFRAME.FLOATING_PANEL
525
526	if not DATALOADER_SHOW:
527	self.__gui_style &= (~GUIFRAME.MANAGER_ON)
528
529	if not TOOLBAR_SHOW:
530	self.__gui_style &= (~GUIFRAME.TOOLBAR_ON)
531
532	if WELCOME_PANEL_SHOW:
533	self.__gui_style \|= GUIFRAME.WELCOME_PANEL_ON
534
535	def set_custom_default_perspective(self):
536	"""
537	Set default starting perspective
538	"""
539	if custom_config is None:
540	return
541	for plugin in self.plugins:
542	try:
543	if plugin.sub_menu == DEFAULT_PERSPECTIVE:
544
545	plugin.on_perspective(event=None)
546	frame = plugin.get_frame()
547	frame.Show(True)
548	# break
549	else:
550	frame = plugin.get_frame()
551	frame.Show(False)
552	except:
553	pass
554	return
555
556	def on_load_data(self, event):
557	"""
558	received an event to trigger load from data plugin
559	"""
560	if self._data_plugin is not None:
561	self._data_plugin.load_data(event)
562
563	def get_current_perspective(self):
564	"""
565	return the current perspective
566	"""
567	return self._current_perspective
568
569	def get_save_location(self):
570	"""
571	return the _default_save_location
572	"""
573	return self._default_save_location
574
575	def set_input_file(self, input_file):
576	"""
577	:param input_file: file to read
578	"""
579	self._input_file = input_file
580
581	def get_data_manager(self):
582	"""
583	return the data manager.
584	"""
585	return self._data_manager
586
587	def get_toolbar(self):
588	"""
589	return the toolbar.
590	"""
591	return self._toolbar
592
593	def set_panel_on_focus(self, event):
594	"""
595	Store reference to the last panel on focus
596	update the toolbar if available
597	update edit menu if available
598	"""
599	if event is not None:
600	self.panel_on_focus = event.panel
601	if self.panel_on_focus is not None:
602	# Disable save application if the current panel is in batch mode
603	try:
604	flag = self.panel_on_focus.get_save_flag()
605	if self._save_appl_menu is not None:
606	self._save_appl_menu.Enable(flag)
607
608	if self.panel_on_focus not in self.plot_panels.values():
609	for ID in self.panels.keys():
610	if self.panel_on_focus != self.panels[ID]:
611	self.panels[ID].on_kill_focus(None)
612
613	if self._data_panel is not None and \
614	self.panel_on_focus is not None:
615	self.set_panel_on_focus_helper()
616	# update toolbar
617	self._update_toolbar_helper()
618	# update edit menu
619	self.enable_edit_menu()
620	except wx._core.PyDeadObjectError:
621	pass
622
623	def disable_app_menu(self, p_panel=None):
624	"""
625	Disables all menus in the menubar
626	"""
627	return
628
629	def send_focus_to_datapanel(self, name):
630	"""
631	Send focusing on ID to data explorer
632	"""
633	if self._data_panel is not None:
634	self._data_panel.set_panel_on_focus(name)
635
636	def set_panel_on_focus_helper(self):
637	"""
638	Helper for panel on focus with data_panel
639	"""
640	caption = self.panel_on_focus.window_caption
641	self.send_focus_to_datapanel(caption)
642	# update combo
643	if self.panel_on_focus in self.plot_panels.values():
644	combo = self._data_panel.cb_plotpanel
645	combo_title = str(self.panel_on_focus.window_caption)
646	combo.SetStringSelection(combo_title)
647	combo.SetToolTip(wx.ToolTip(combo_title))
648	elif self.panel_on_focus != self._data_panel:
649	cpanel = self.panel_on_focus
650	if self.cpanel_on_focus != cpanel:
651	cpanel.on_tap_focus()
652	self.cpanel_on_focus = self.panel_on_focus
653
654	def reset_bookmark_menu(self, panel):
655	"""
656	Reset Bookmark menu list
657
658	: param panel: a control panel or tap where the bookmark is
659	"""
660	cpanel = panel
661	if self._toolbar is not None and cpanel._bookmark_flag:
662	for item in self._toolbar.get_bookmark_items():
663	self._toolbar.remove_bookmark_item(item)
664	self._toolbar.add_bookmark_default()
665	pos = 0
666	for bitem in cpanel.popUpMenu.GetMenuItems():
667	pos += 1
668	if pos < 3:
669	continue
670	id = bitem.GetId()
671	label = bitem.GetLabel()
672	self._toolbar.append_bookmark_item(id, label)
673	wx.EVT_MENU(self, id, cpanel._back_to_bookmark)
674	self._toolbar.Realize()
675
676	def build_gui(self):
677	"""
678	Build the GUI by setting up the toolbar, menu and layout.
679	"""
680	# set tool bar
681	self._setup_tool_bar()
682
683	# Create the menu bar. To be filled later.
684	# WX 3.0 needs us to create the menu bar first.
685	self._menubar = wx.MenuBar()
686	if wx.VERSION_STRING >= '3.0.0.0':
687	self.SetMenuBar(self._menubar)
688	self._add_menu_file()
689	self._add_menu_edit()
690	self._add_menu_view()
691	self._add_menu_tool()
692	# Set up the layout
693	self._setup_layout()
694	self._add_menu_application()
695
696	# Set up the menu
697	self._add_current_plugin_menu()
698	self._add_help_menu()
699	# Append item from plugin under menu file if necessary
700	self._populate_file_menu()
701
702	if not wx.VERSION_STRING >= '3.0.0.0':
703	self.SetMenuBar(self._menubar)
704
705	try:
706	self.load_from_cmd(self._input_file)
707	except:
708	msg = "%s Cannot load file %s\n" % (str(APPLICATION_NAME),
709	str(self._input_file))
710	msg += str(sys.exc_value) + '\n'
711	logger.error(msg)
712	if self._data_panel is not None and len(self.plugins) > 0:
713	self._data_panel.fill_cbox_analysis(self.plugins)
714	self.post_init()
715	# Set Custom default
716	self.set_custom_default_perspective()
717	# Set up extra custom tool menu
718	self._setup_extra_custom()
719	self._check_update(None)
720
721	def _setup_extra_custom(self):
722	"""
723	Set up toolbar and welcome view if needed
724	"""
725	style = self.__gui_style & GUIFRAME.TOOLBAR_ON
726	if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
727	self._on_toggle_toolbar()
728
729	# Set Custom deafult start page
730	welcome_style = self.__gui_style & GUIFRAME.WELCOME_PANEL_ON
731	if welcome_style == GUIFRAME.WELCOME_PANEL_ON:
732	self.show_welcome_panel(None)
733
734	def _setup_layout(self):
735	"""
736	Set up the layout
737	"""
738	# Status bar
739	from sas.sasgui.guiframe.gui_statusbar import StatusBar
740	self.sb = StatusBar(self, wx.ID_ANY)
741	self.SetStatusBar(self.sb)
742	# Load panels
743	self._load_panels()
744
745	def SetStatusText(self, args, *kwds):
746	"""
747	"""
748	number = self.sb.get_msg_position()
749	wx.Frame.SetStatusText(self, number=number, args, *kwds)
750
751	def PopStatusText(self, args, *kwds):
752	"""
753	"""
754	field = self.sb.get_msg_position()
755	wx.Frame.PopStatusText(self, field=field)
756
757	def PushStatusText(self, args, *kwds):
758	"""
759	.. todo:: No message is passed. What is this supposed to do?
760	"""
761	field = self.sb.get_msg_position()
762	wx.Frame.PushStatusText(self, field=field,
763	string=
764	"FIXME - PushStatusText called without text")
765
766	def add_perspective(self, plugin):
767	"""
768	Add a perspective if it doesn't already
769	exist.
770	"""
771	self._num_perspectives += 1
772	is_loaded = False
773	for item in self.plugins:
774	item.set_batch_selection(self.batch_on)
775	if plugin.__class__ == item.__class__:
776	msg = "Plugin %s already loaded" % plugin.sub_menu
777	logger.info(msg)
778	is_loaded = True
779	if not is_loaded:
780	self.plugins.append(plugin)
781	msg = "Plugin %s appended" % plugin.sub_menu
782	logger.info(msg)
783
784	def _get_local_plugins(self):
785	"""
786	get plugins local to guiframe and others
787	"""
788	plugins = []
789	# import guiframe local plugins
790	# check if the style contain guiframe.dataloader
791	style1 = self.__gui_style & GUIFRAME.DATALOADER_ON
792	style2 = self.__gui_style & GUIFRAME.PLOTTING_ON
793	if style1 == GUIFRAME.DATALOADER_ON:
794	try:
795	from sas.sasgui.guiframe.local_perspectives.data_loader \
796	import data_loader
797	self._data_plugin = data_loader.Plugin()
798	plugins.append(self._data_plugin)
799	except:
800	msg = "ViewerFrame._get_local_plugins:"
801	msg += "cannot import dataloader plugin.\n %s" % sys.exc_value
802	logger.error(msg)
803	if style2 == GUIFRAME.PLOTTING_ON:
804	try:
805	from sas.sasgui.guiframe.local_perspectives.plotting \
806	import plotting
807	self._plotting_plugin = plotting.Plugin()
808	plugins.append(self._plotting_plugin)
809	except:
810	msg = "ViewerFrame._get_local_plugins:"
811	msg += "cannot import plotting plugin.\n %s" % sys.exc_value
812	logger.error(msg)
813
814	return plugins
815
816	def _find_plugins(self, dir="perspectives"):
817	"""
818	Find available perspective plug-ins
819
820	:param dir: directory in which to look for plug-ins
821
822	:returns: list of plug-ins
823
824	"""
825	plugins = []
826	# Go through files in panels directory
827	try:
828	if os.path.isdir(dir):
829	file_list = os.listdir(dir)
830	else:
831	file_list = []
832	# the default panel is the panel is the last plugin added
833	for item in file_list:
834	toks = os.path.splitext(os.path.basename(item))
835	name = ''
836	if not toks[0] == '__init__':
837	if toks[1] == '.py' or toks[1] == '':
838	name = toks[0]
839	# check the validity of the module name parsed
840	# before trying to import it
841	if name is None or name.strip() == '':
842	continue
843	path = [os.path.abspath(dir)]
844	file = None
845	try:
846	if toks[1] == '':
847	mod_path = '.'.join([dir, name])
848	module = __import__(mod_path, globals(),
849	locals(), [name])
850	else:
851	(file, path, info) = imp.find_module(name, path)
852	module = imp.load_module(name, file, item, info)
853	if hasattr(module, "PLUGIN_ID"):
854	try:
855	plugins.append(module.Plugin())
856	msg = "Found plug-in: %s" % module.PLUGIN_ID
857	logger.info(msg)
858	except:
859	msg = "Error accessing PluginPanel"
860	msg += " in %s\n %s" % (name, sys.exc_value)
861	config.printEVT(msg)
862	except:
863	msg = "ViewerFrame._find_plugins: %s" % sys.exc_value
864	logger.error(msg)
865	finally:
866	if file is not None:
867	file.close()
868	except:
869	# Should raise and catch at a higher level and
870	# display error on status bar
871	logger.error(sys.exc_value)
872
873	return plugins
874
875	def _get_panels_size(self, p):
876	"""
877	find the proper size of the current panel
878	get the proper panel width and height
879	"""
880	self._window_width, self._window_height = self.get_client_size()
881	# Default size
882	if DATAPANEL_WIDTH < 0:
883	panel_width = int(self._window_width * 0.25)
884	else:
885	panel_width = DATAPANEL_WIDTH
886	panel_height = int(self._window_height)
887	if self._data_panel is not None and (p == self._data_panel):
888	return panel_width, panel_height
889	if hasattr(p, "CENTER_PANE") and p.CENTER_PANE:
890	panel_width = self._window_width * 0.45
891	if CONTROL_WIDTH > 0:
892	panel_width = CONTROL_WIDTH
893	if CONTROL_HEIGHT > 0:
894	panel_height = CONTROL_HEIGHT
895	return panel_width, panel_height
896	elif p == self.defaultPanel:
897	return self._window_width, panel_height
898	return panel_width, panel_height
899
900	def _load_panels(self):
901	"""
902	Load all panels in the panels directory
903	"""
904	# Look for plug-in panels
905	panels = []
906	if wx.VERSION_STRING >= '3.0.0.0':
907	mac_pos_y = 85
908	else:
909	mac_pos_y = 40
910	for item in self.plugins:
911	if hasattr(item, "get_panels"):
912	ps = item.get_panels(self)
913	panels.extend(ps)
914
915	# Set up welcome panel
916	# TODO: this needs serious simplification
917	if self.welcome_panel_class is not None:
918	welcome_panel = MDIFrame(self, None, 'None', (100, 200))
919	self.defaultPanel = self.welcome_panel_class(welcome_panel, -1,
920	style=wx.RAISED_BORDER)
921	welcome_panel.set_panel(self.defaultPanel)
922	self.defaultPanel.set_frame(welcome_panel)
923	welcome_panel.Show(False)
924
925	self.panels["default"] = self.defaultPanel
926	size_t_bar = 70
927	if IS_LINUX:
928	size_t_bar = 115
929	if self.defaultPanel is not None:
930	w, h = self._get_panels_size(self.defaultPanel)
931	frame = self.defaultPanel.get_frame()
932	frame.SetSize((self._window_width, self._window_height))
933	if not IS_WIN:
934	frame.SetPosition((0, mac_pos_y + size_t_bar))
935	frame.Show(True)
936	# add data panel
937	win = MDIFrame(self, None, 'None', (100, 200))
938	data_panel = DataPanel(parent=win, id=-1)
939	win.set_panel(data_panel)
940	self.panels["data_panel"] = data_panel
941	self._data_panel = data_panel
942	d_panel_width, h = self._get_panels_size(self._data_panel)
943	win.SetSize((d_panel_width, h))
944	is_visible = self.__gui_style & \
945	GUIFRAME.MANAGER_ON == GUIFRAME.MANAGER_ON
946	if IS_WIN:
947	win.SetPosition((0, 0))
948	else:
949	win.SetPosition((0, mac_pos_y + size_t_bar))
950	win.Show(is_visible)
951	# Add the panels to the AUI manager
952	for panel_class in panels:
953	frame = panel_class.get_frame()
954	wx_id = wx.NewId()
955	# Check whether we need to put this panel in the center pane
956	if hasattr(panel_class, "CENTER_PANE") and panel_class.CENTER_PANE:
957	w, h = self._get_panels_size(panel_class)
958	if panel_class.CENTER_PANE:
959	self.panels[str(wx_id)] = panel_class
960	_, pos_y = frame.GetPositionTuple()
961	frame.SetPosition((d_panel_width + 1, pos_y))
962	frame.SetSize((w, h))
963	frame.Show(False)
964	elif panel_class == self._data_panel:
965	panel_class.frame.Show(is_visible)
966	continue
967	else:
968	self.panels[str(wx_id)] = panel_class
969	frame.SetSize((w, h))
970	frame.Show(False)
971	if IS_WIN:
972	frame.SetPosition((d_panel_width + 1, 0))
973	else:
974	frame.SetPosition((d_panel_width + 1, mac_pos_y + size_t_bar))
975
976	if not IS_WIN:
977	win_height = mac_pos_y
978	if IS_LINUX:
979	if wx.VERSION_STRING >= '3.0.0.0':
980	win_height = mac_pos_y + 10
981	else:
982	win_height = mac_pos_y + 55
983	self.SetMaxSize((-1, win_height))
984	else:
985	self.SetSize((self._window_width, win_height))
986
987	def update_data(self, prev_data, new_data):
988	"""
989	Update the data.
990	"""
991	prev_id, data_state = self._data_manager.update_data(
992	prev_data=prev_data, new_data=new_data)
993
994	self._data_panel.remove_by_id(prev_id)
995	self._data_panel.load_data_list(data_state)
996
997	def update_theory(self, data_id, theory, state=None):
998	"""
999	Update the theory
1000	"""
1001	data_state = self._data_manager.update_theory(data_id=data_id,
1002	theory=theory,
1003	state=state)
1004	wx.CallAfter(self._data_panel.load_data_list, data_state)
1005
1006	def onfreeze(self, theory_id):
1007	"""
1008	Saves theory/model and passes to data loader.
1009
1010	..warning:: This seems to be the exact same code as the next
1011	function called simply freeze. This probably needs fixing
1012	"""
1013	data_state_list = self._data_manager.freeze(theory_id)
1014	self._data_panel.load_data_list(list=data_state_list)
1015	for data_state in data_state_list.values():
1016	new_plot = data_state.get_data()
1017
1018	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
1019	title=new_plot.title))
1020
1021	def freeze(self, data_id, theory_id):
1022	"""
1023	Saves theory/model and passes to data loader.
1024
1025	..warning:: This seems to be the exact same code as the next
1026	function called simply freeze. This probably needs fixing
1027	"""
1028	data_state_list = self._data_manager.freeze_theory(data_id=data_id,
1029	theory_id=theory_id)
1030	self._data_panel.load_data_list(list=data_state_list)
1031	for data_state in data_state_list.values():
1032	new_plot = data_state.get_data()
1033	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
1034	title=new_plot.title))
1035
1036	def delete_data(self, data):
1037	"""
1038	Delete the data.
1039	"""
1040	self._current_perspective.delete_data(data)
1041
1042	def get_context_menu(self, plotpanel=None):
1043	"""
1044	Get the context menu items made available
1045	by the different plug-ins.
1046	This function is used by the plotting module
1047	"""
1048	if plotpanel is None:
1049	return
1050	menu_list = []
1051	for item in self.plugins:
1052	menu_list.extend(item.get_context_menu(plotpanel=plotpanel))
1053	return menu_list
1054
1055	def get_current_context_menu(self, plotpanel=None):
1056	"""
1057	Get the context menu items made available
1058	by the current plug-in.
1059	This function is used by the plotting module
1060	"""
1061	if plotpanel is None:
1062	return
1063	menu_list = []
1064	item = self._current_perspective
1065	if item is not None:
1066	menu_list.extend(item.get_context_menu(plotpanel=plotpanel))
1067	return menu_list
1068
1069	def on_panel_close(self, event):
1070	"""
1071	Gets called when the close event for a panel runs.
1072	This will check which panel has been closed and
1073	delete it.
1074	"""
1075	frame = event.GetEventObject()
1076	for ID in self.plot_panels.keys():
1077	if self.plot_panels[ID].window_name == frame.name:
1078	self.disable_app_menu(self.plot_panels[ID])
1079	self.delete_panel(ID)
1080	break
1081	if self.cpanel_on_focus is not None:
1082	self.cpanel_on_focus.SetFocus()
1083
1084	def popup_panel(self, p):
1085	"""
1086	Add a panel object to the AUI manager
1087
1088	:param p: panel object to add to the AUI manager
1089
1090	:returns: ID of the event associated with the new panel [int]
1091
1092	"""
1093	ID = wx.NewId()
1094	self.panels[str(ID)] = p
1095	# Check and set the size
1096	if PLOPANEL_WIDTH < 0:
1097	p_panel_width = int(self._window_width * 0.45)
1098	else:
1099	p_panel_width = PLOPANEL_WIDTH
1100	p_panel_height = int(p_panel_width * 0.76)
1101	p.frame.SetSize((p_panel_width, p_panel_height))
1102	self.graph_num += 1
1103	if p.window_caption.split()[0] in NOT_SO_GRAPH_LIST:
1104	windowcaption = p.window_caption
1105	else:
1106	windowcaption = 'Graph'
1107	windowname = p.window_name
1108
1109	# Append nummber
1110	captions = self._get_plotpanel_captions()
1111	# FIXME: Fix this awful loop
1112	while (1):
1113	caption = windowcaption + '%s' % str(self.graph_num)
1114	if caption not in captions:
1115	break
1116	self.graph_num += 1
1117	# protection from forever-loop: max num = 1000
1118	if self.graph_num > 1000:
1119	break
1120	if p.window_caption.split()[0] not in NOT_SO_GRAPH_LIST:
1121	p.window_caption = caption
1122	p.window_name = windowname + str(self.graph_num)
1123
1124	p.frame.SetTitle(p.window_caption)
1125	p.frame.name = p.window_name
1126	if not IS_WIN:
1127	p.frame.Center()
1128	x_pos, _ = p.frame.GetPositionTuple()
1129	p.frame.SetPosition((x_pos, 112))
1130	p.frame.Show(True)
1131
1132	# Register for showing/hiding the panel
1133	wx.EVT_MENU(self, ID, self.on_view)
1134	if p not in self.plot_panels.values() and p.group_id is not None:
1135	self.plot_panels[ID] = p
1136	if len(self.plot_panels) == 1:
1137	self.panel_on_focus = p
1138	self.set_panel_on_focus(None)
1139	if self._data_panel is not None and \
1140	self._plotting_plugin is not None:
1141	ind = self._data_panel.cb_plotpanel.FindString('None')
1142	if ind != wx.NOT_FOUND:
1143	self._data_panel.cb_plotpanel.Delete(ind)
1144	if caption not in self._data_panel.cb_plotpanel.GetItems():
1145	self._data_panel.cb_plotpanel.Append(str(caption), p)
1146	return ID
1147
1148	def _get_plotpanel_captions(self):
1149	"""
1150	Get all the plotpanel cations
1151
1152	: return: list of captions
1153	"""
1154	captions = []
1155	for Id in self.plot_panels.keys():
1156	captions.append(self.plot_panels[Id].window_caption)
1157
1158	return captions
1159
1160	def _setup_tool_bar(self):
1161	"""
1162	add toolbar to the frame
1163	"""
1164	self._toolbar = GUIToolBar(self)
1165	# The legacy code doesn't work well for wx 3.0
1166	# but the old code produces better results with wx 2.8
1167	if not IS_WIN and wx.VERSION_STRING >= '3.0.0.0':
1168	sizer = wx.BoxSizer(wx.VERTICAL)
1169	sizer.Add(self._toolbar, 0, wx.EXPAND)
1170	self.SetSizer(sizer)
1171	else:
1172	self.SetToolBar(self._toolbar)
1173	self._update_toolbar_helper()
1174	self._on_toggle_toolbar(event=None)
1175
1176	def _update_toolbar_helper(self):
1177	"""
1178	Helping to update the toolbar
1179	"""
1180	application_name = 'No Selected Analysis'
1181	panel_name = 'No Panel on Focus'
1182	c_panel = self.cpanel_on_focus
1183	if self._toolbar is None:
1184	return
1185	if c_panel is not None:
1186	self.reset_bookmark_menu(self.cpanel_on_focus)
1187	if self._current_perspective is not None:
1188	application_name = self._current_perspective.sub_menu
1189	c_panel_state = c_panel
1190	if c_panel is not None:
1191	panel_name = c_panel.window_caption
1192	if not c_panel.IsShownOnScreen():
1193	c_panel_state = None
1194	self._toolbar.update_toolbar(c_panel_state)
1195	self._toolbar.update_button(application_name=application_name,
1196	panel_name=panel_name)
1197	self._toolbar.Realize()
1198
1199	def _add_menu_tool(self):
1200	"""
1201	Tools menu
1202	Go through plug-ins and find tools to populate the tools menu
1203	"""
1204	style = self.__gui_style & GUIFRAME.CALCULATOR_ON
1205	if style == GUIFRAME.CALCULATOR_ON:
1206	self._tool_menu = None
1207	for item in self.plugins:
1208	if hasattr(item, "get_tools"):
1209	for tool in item.get_tools():
1210	# Only create a menu if we have at least one tool
1211	if self._tool_menu is None:
1212	self._tool_menu = wx.Menu()
1213	if tool[0].lower().count('python') > 0:
1214	self._tool_menu.AppendSeparator()
1215	id = wx.NewId()
1216	self._tool_menu.Append(id, tool[0], tool[1])
1217	wx.EVT_MENU(self, id, tool[2])
1218	if self._tool_menu is not None:
1219	self._menubar.Append(self._tool_menu, '&Tools')
1220
1221	def _add_current_plugin_menu(self):
1222	"""
1223	add current plugin menu
1224	Look for plug-in menus
1225	Add available plug-in sub-menus.
1226	"""
1227	if self._menubar is None or self._current_perspective is None \
1228	or self._menubar.GetMenuCount() == 0:
1229	return
1230	# replace or add a new menu for the current plugin
1231	pos = self._menubar.FindMenu(str(self._applications_menu_name))
1232	if pos == -1 and self._applications_menu_pos > 0:
1233	pos = self._applications_menu_pos
1234	if pos != -1:
1235	menu_list = self._current_perspective.populate_menu(self)
1236	if menu_list:
1237	for (menu, name) in menu_list:
1238	self._menubar.Replace(pos, menu, name)
1239	self._applications_menu_name = name
1240	self._applications_menu_pos = pos
1241	else:
1242	self._menubar.Remove(pos)
1243	self._applications_menu_name = None
1244	self._applications_menu_pos = -1
1245	else:
1246	menu_list = self._current_perspective.populate_menu(self)
1247	if menu_list:
1248	for (menu, name) in menu_list:
1249	if self._applications_menu_pos == -1:
1250	# Find the Analysis position and insert just after it
1251	analysis_pos = self._menubar.FindMenu("Analysis")
1252	if analysis_pos == -1:
1253	self._menubar.Append(menu, name)
1254	self._applications_menu_pos = -1
1255	else:
1256	self._menubar.Insert(analysis_pos+1, menu, name)
1257	self._applications_menu_pos = analysis_pos + 1
1258	else:
1259	self._menubar.Insert(self._applications_menu_pos,
1260	menu, name)
1261	self._applications_menu_name = name
1262
1263	def _on_marketplace_click(self, event):
1264	"""
1265	Click event for the help menu item linking to the Marketplace.
1266	"""
1267	import webbrowser
1268	webbrowser.open_new(config.marketplace_url)
1269
1270	def _add_help_menu(self):
1271	"""
1272	add help menu to menu bar. Includes welcome page, about page,
1273	tutorial PDF and documentation pages.
1274	"""
1275	self._help_menu = wx.Menu()
1276
1277	wx_id = wx.NewId()
1278	self._help_menu.Append(wx_id, '&Documentation', '')
1279	wx.EVT_MENU(self, wx_id, self._onSphinxDocs)
1280
1281	if config._do_tutorial and (IS_WIN or sys.platform == 'darwin'):
1282	wx_id = wx.NewId()
1283	self._help_menu.Append(wx_id, '&Tutorials', 'Software tutorials')
1284	wx.EVT_MENU(self, wx_id, self._onTutorial)
1285
1286	if config._do_acknowledge:
1287	wx_id = wx.NewId()
1288	self._help_menu.Append(wx_id, '&Acknowledge',
1289	'Acknowledging SasView')
1290	wx.EVT_MENU(self, wx_id, self._onAcknowledge)
1291
1292	if config._do_aboutbox:
1293	logger.info("Doing help menu")
1294	wx_id = wx.NewId()
1295	self._help_menu.Append(wx_id, '&About', 'Software information')
1296	wx.EVT_MENU(self, wx_id, self._onAbout)
1297
1298	if config.marketplace_url:
1299	wx_id = wx.NewId()
1300	self._help_menu.Append(wx_id, '&Model marketplace', '')
1301	wx.EVT_MENU(self, wx_id, self._on_marketplace_click)
1302
1303	# Checking for updates
1304	wx_id = wx.NewId()
1305	self._help_menu.Append(wx_id, '&Check for update',
1306	'Check for the latest version of %s' %
1307	config.__appname__)
1308	wx.EVT_MENU(self, wx_id, self._check_update)
1309	self._menubar.Append(self._help_menu, '&Help')
1310
1311	def _add_menu_view(self):
1312	"""
1313	add menu items under view menu
1314	"""
1315	if not VIEW_MENU:
1316	return
1317	self._view_menu = wx.Menu()
1318
1319	wx_id = wx.NewId()
1320	hint = "Display the Grid Window for batch results etc."
1321	self._view_menu.Append(wx_id, '&Show Grid Window', hint)
1322	wx.EVT_MENU(self, wx_id, self.show_batch_frame)
1323
1324	self._view_menu.AppendSeparator()
1325	style = self.__gui_style & GUIFRAME.MANAGER_ON
1326	wx_id = wx.NewId()
1327	self._data_panel_menu = self._view_menu.Append(wx_id,
1328	'&Show Data Explorer',
1329	'')
1330	wx.EVT_MENU(self, wx_id, self.show_data_panel)
1331	if style == GUIFRAME.MANAGER_ON:
1332	self._data_panel_menu.SetText('Hide Data Explorer')
1333	else:
1334	self._data_panel_menu.SetText('Show Data Explorer')
1335
1336	self._view_menu.AppendSeparator()
1337	wx_id = wx.NewId()
1338	style1 = self.__gui_style & GUIFRAME.TOOLBAR_ON
1339	if style1 == GUIFRAME.TOOLBAR_ON:
1340	self._toolbar_menu = self._view_menu.Append(wx_id, '&Hide Toolbar',
1341	'')
1342	else:
1343	self._toolbar_menu = self._view_menu.Append(wx_id, '&Show Toolbar',
1344	'')
1345	wx.EVT_MENU(self, wx_id, self._on_toggle_toolbar)
1346
1347	if custom_config is not None:
1348	self._view_menu.AppendSeparator()
1349	wx_id = wx.NewId()
1350	hint_ss = "Select the current/default configuration "
1351	hint_ss += "as a startup setting"
1352	preference_menu = self._view_menu.Append(wx_id, 'Startup Setting',
1353	hint_ss)
1354	wx.EVT_MENU(self, wx_id, self._on_preference_menu)
1355
1356	wx_id = wx.NewId()
1357	self._view_menu.AppendSeparator()
1358	self._view_menu.Append(wx_id, 'Category Manager',
1359	'Edit model categories')
1360	wx.EVT_MENU(self, wx_id, self._on_category_manager)
1361
1362	self._menubar.Append(self._view_menu, '&View')
1363
1364	def show_batch_frame(self, event=None):
1365	"""
1366	show the grid of result
1367	"""
1368	# Show(False) before Show(True) in order to bring it to the front
1369	self.batch_frame.Show(False)
1370	self.batch_frame.Show(True)
1371
1372	def on_category_panel(self, event):
1373	"""
1374	On cat panel
1375	"""
1376	self._on_category_manager(event)
1377
1378	def _on_category_manager(self, event):
1379	"""
1380	Category manager frame
1381	"""
1382	frame = CategoryManager(self, -1, 'Model Category Manager')
1383	icon = self.GetIcon()
1384	frame.SetIcon(icon)
1385
1386	def _on_preference_menu(self, event):
1387	"""
1388	Build a panel to allow to edit Mask
1389	"""
1390	from sas.sasgui.guiframe.startup_configuration \
1391	import StartupConfiguration as ConfDialog
1392
1393	dialog = ConfDialog(parent=self, gui=self.__gui_style)
1394	result = dialog.ShowModal()
1395	if result == wx.ID_OK:
1396	dialog.write_custom_config()
1397	# post event for info
1398	wx.PostEvent(self, StatusEvent(status="Wrote custom configuration",
1399	info='info'))
1400	dialog.Destroy()
1401
1402	def _add_menu_application(self):
1403	"""
1404	# Attach a menu item for each defined perspective or application.
1405	# Only add the perspective menu if there are more than one perspectives
1406	add menu application
1407	"""
1408	if self._num_perspectives > 1:
1409	plug_data_count = False
1410	plug_no_data_count = False
1411	self._applications_menu = wx.Menu()
1412	pos = 0
1413	separator = self._applications_menu.AppendSeparator()
1414	for plug in self.plugins:
1415	if len(plug.get_perspective()) > 0:
1416	id = wx.NewId()
1417	if plug.use_data():
1418	self._applications_menu.InsertCheckItem(pos, id,
1419	plug.sub_menu,
1420	"Switch to analysis: %s" % plug.sub_menu)
1421	plug_data_count = True
1422	pos += 1
1423	else:
1424	plug_no_data_count = True
1425	self._applications_menu.AppendCheckItem(id,
1426	plug.sub_menu,
1427	"Switch to analysis: %s" % plug.sub_menu)
1428	wx.EVT_MENU(self, id, plug.on_perspective)
1429
1430	if not plug_data_count or not plug_no_data_count:
1431	self._applications_menu.RemoveItem(separator)
1432	# Windows introduces a "Window" menu item during the layout process
1433	# somehow. We want it to be next to the last item with Help as
1434	# last. However Analysis gets stuck after Window in normal ordering
1435	# so force it to be next after the Tools menu item. Should we add
1436	# another menu item will need to check if this is still where we
1437	# want Analysis. This is NOT an issue on the Mac which does not
1438	# have the extra Window menu item.
1439	# March 2016 Code Camp -- PDB
1440	Tools_pos = self._menubar.FindMenu("Tools")
1441	self._menubar.Insert(Tools_pos+1, self._applications_menu,
1442	'&Analysis')
1443	self._check_applications_menu()
1444
1445	def _populate_file_menu(self):
1446	"""
1447	Insert menu item under file menu
1448	"""
1449	for plugin in self.plugins:
1450	if len(plugin.populate_file_menu()) > 0:
1451	for item in plugin.populate_file_menu():
1452	m_name, m_hint, m_handler = item
1453	wx_id = wx.NewId()
1454	self._file_menu.Append(wx_id, m_name, m_hint)
1455	wx.EVT_MENU(self, wx_id, m_handler)
1456	self._file_menu.AppendSeparator()
1457
1458	style1 = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
1459	if OPEN_SAVE_MENU:
1460	wx_id = wx.NewId()
1461	hint_load_file = "read all analysis states saved previously"
1462	self._save_appl_menu = self._file_menu.Append(wx_id,
1463	'&Open Project',
1464	hint_load_file)
1465	wx.EVT_MENU(self, wx_id, self._on_open_state_project)
1466
1467	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1468	# some menu of plugin to be seen under file menu
1469	hint_load_file = "Read a status files and load"
1470	hint_load_file += " them into the analysis"
1471	wx_id = wx.NewId()
1472	self._save_appl_menu = self._file_menu.Append(wx_id,
1473	'&Open Analysis',
1474	hint_load_file)
1475	wx.EVT_MENU(self, wx_id, self._on_open_state_application)
1476	if OPEN_SAVE_MENU:
1477	self._file_menu.AppendSeparator()
1478	wx_id = wx.NewId()
1479	self._file_menu.Append(wx_id, '&Save Project',
1480	'Save the state of the whole analysis')
1481	wx.EVT_MENU(self, wx_id, self._on_save_project)
1482	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1483	wx_id = wx.NewId()
1484	txt = '&Save Analysis'
1485	txt2 = 'Save state of the current active analysis panel'
1486	self._save_appl_menu = self._file_menu.Append(wx_id, txt, txt2)
1487	wx.EVT_MENU(self, wx_id, self._on_save_application)
1488	if not sys.platform == 'darwin':
1489	self._file_menu.AppendSeparator()
1490	wx_id = wx.NewId()
1491	self._file_menu.Append(wx_id, '&Quit', 'Exit')
1492	wx.EVT_MENU(self, wx_id, self.Close)
1493
1494	def _add_menu_file(self):
1495	"""
1496	add menu file
1497	"""
1498	# File menu
1499	self._file_menu = wx.Menu()
1500	# Add sub menus
1501	self._menubar.Append(self._file_menu, '&File')
1502
1503	def _add_menu_edit(self):
1504	"""
1505	add menu edit
1506	"""
1507	if not EDIT_MENU:
1508	return
1509	# Edit Menu
1510	self._edit_menu = wx.Menu()
1511	self._edit_menu.Append(GUIFRAME_ID.UNDO_ID, '&Undo',
1512	'Undo the previous action')
1513	wx.EVT_MENU(self, GUIFRAME_ID.UNDO_ID, self.on_undo_panel)
1514	self._edit_menu.Append(GUIFRAME_ID.REDO_ID, '&Redo',
1515	'Redo the previous action')
1516	wx.EVT_MENU(self, GUIFRAME_ID.REDO_ID, self.on_redo_panel)
1517	self._edit_menu.AppendSeparator()
1518	self._edit_menu.Append(GUIFRAME_ID.COPY_ID, '&Copy Params',
1519	'Copy parameter values')
1520	wx.EVT_MENU(self, GUIFRAME_ID.COPY_ID, self.on_copy_panel)
1521	self._edit_menu.Append(GUIFRAME_ID.PASTE_ID, '&Paste Params',
1522	'Paste parameter values')
1523	wx.EVT_MENU(self, GUIFRAME_ID.PASTE_ID, self.on_paste_panel)
1524
1525	self._edit_menu.AppendSeparator()
1526
1527	self._edit_menu_copyas = wx.Menu()
1528	# Sub menu for Copy As...
1529	self._edit_menu_copyas.Append(GUIFRAME_ID.COPYEX_ID,
1530	'Copy current tab to Excel',
1531	'Copy parameter values in tabular format')
1532	wx.EVT_MENU(self, GUIFRAME_ID.COPYEX_ID, self.on_copy_panel)
1533
1534	self._edit_menu_copyas.Append(GUIFRAME_ID.COPYLAT_ID,
1535	'Copy current tab to LaTeX',
1536	'Copy parameter values in tabular format')
1537	wx.EVT_MENU(self, GUIFRAME_ID.COPYLAT_ID, self.on_copy_panel)
1538
1539	self._edit_menu.AppendMenu(GUIFRAME_ID.COPYAS_ID, 'Copy Params as...',
1540	self._edit_menu_copyas,
1541	'Copy parameter values in various formats')
1542
1543	self._edit_menu.AppendSeparator()
1544
1545	self._edit_menu.Append(GUIFRAME_ID.PREVIEW_ID, '&Report Results',
1546	'Preview current panel')
1547	wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel)
1548
1549	self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset Page',
1550	'Reset current panel')
1551	wx.EVT_MENU(self, GUIFRAME_ID.RESET_ID, self.on_reset_panel)
1552
1553	self._menubar.Append(self._edit_menu, '&Edit')
1554	self.enable_edit_menu()
1555
1556	def get_style(self):
1557	"""
1558	Return the gui style
1559	"""
1560	return self.__gui_style
1561
1562	def _add_menu_data(self):
1563	"""
1564	Add menu item item data to menu bar
1565	"""
1566	if self._data_plugin is not None:
1567	menu_list = self._data_plugin.populate_menu(self)
1568	if menu_list:
1569	for (menu, name) in menu_list:
1570	self._menubar.Append(menu, name)
1571
1572	def _on_toggle_toolbar(self, event=None):
1573	"""
1574	hide or show toolbar
1575	"""
1576	if self._toolbar is None:
1577	return
1578	if self._toolbar.IsShown():
1579	if self._toolbar_menu is not None:
1580	self._toolbar_menu.SetItemLabel('Show Toolbar')
1581	self._toolbar.Hide()
1582	else:
1583	if self._toolbar_menu is not None:
1584	self._toolbar_menu.SetItemLabel('Hide Toolbar')
1585	self._toolbar.Show()
1586	self._toolbar.Realize()
1587
1588	def _on_status_event(self, evt):
1589	"""
1590	Display status message
1591	"""
1592	# This CallAfter fixes many crashes on MAC.
1593	wx.CallAfter(self.sb.set_status, evt)
1594
1595	def on_view(self, evt):
1596	"""
1597	A panel was selected to be shown. If it's not already
1598	shown, display it.
1599
1600	:param evt: menu event
1601
1602	"""
1603	panel_id = str(evt.GetId())
1604	self.on_set_plot_focus(self.panels[panel_id])
1605	wx.CallLater(5 * TIME_FACTOR, self.set_schedule(True))
1606	self.set_plot_unfocus()
1607
1608	def show_welcome_panel(self, event):
1609	"""
1610	Display the welcome panel
1611	"""
1612	if self.defaultPanel is None:
1613	return
1614	frame = self.panels['default'].get_frame()
1615	if frame is None:
1616	return
1617	# Show default panel
1618	if not frame.IsShown():
1619	frame.Show(True)
1620
1621	def on_close_welcome_panel(self):
1622	"""
1623	Close the welcome panel
1624	"""
1625	if self.defaultPanel is None:
1626	return
1627	default_panel = self.panels["default"].frame
1628	if default_panel.IsShown():
1629	default_panel.Show(False)
1630
1631	def delete_panel(self, uid):
1632	"""
1633	delete panel given uid
1634	"""
1635	ID = str(uid)
1636	config.printEVT("delete_panel: %s" % ID)
1637	if ID in self.panels.keys():
1638	self.panel_on_focus = None
1639	panel = self.panels[ID]
1640
1641	if hasattr(panel, "connect"):
1642	panel.connect.disconnect()
1643	self._plotting_plugin.delete_panel(panel.group_id)
1644
1645	if panel in self.schedule_full_draw_list:
1646	self.schedule_full_draw_list.remove(panel)
1647
1648	# delete uid number not str(uid)
1649	if ID in self.plot_panels.keys():
1650	del self.plot_panels[ID]
1651	if ID in self.panels.keys():
1652	del self.panels[ID]
1653	else:
1654	logger.error("delete_panel: No such plot id as %s" % ID)
1655
1656	def create_gui_data(self, data, path=None):
1657	"""
1658	"""
1659	return self._data_manager.create_gui_data(data, path)
1660
1661	def get_data(self, path):
1662	"""
1663	"""
1664	log_msg = ''
1665	basename = os.path.basename(path)
1666	_, extension = os.path.splitext(basename)
1667	if extension.lower() not in EXTENSIONS:
1668	log_msg = "File Loader cannot "
1669	log_msg += "load: %s\n" % str(basename)
1670	log_msg += "Try Data opening...."
1671	logger.error(log_msg)
1672	return
1673
1674	# reading a state file
1675	for plug in self.plugins:
1676	reader, ext = plug.get_extensions()
1677	if reader is not None:
1678	# read the state of the single plugin
1679	if extension == ext:
1680	reader.read(path)
1681	return
1682	elif extension == APPLICATION_STATE_EXTENSION:
1683	try:
1684	reader.read(path)
1685	except:
1686	msg = "DataLoader Error: Encounted Non-ASCII character"
1687	msg += "\n(%s)" % sys.exc_value
1688	wx.PostEvent(self, StatusEvent(status=msg,
1689	info="error",
1690	type="stop"))
1691	return
1692
1693	style = self.__gui_style & GUIFRAME.MANAGER_ON
1694	if style == GUIFRAME.MANAGER_ON:
1695	if self._data_panel is not None:
1696	self._data_panel.frame.Show(True)
1697
1698	def load_from_cmd(self, path):
1699	"""
1700	load data from cmd or application
1701	"""
1702	if path is None:
1703	return
1704	else:
1705	path = os.path.abspath(path)
1706	if not os.path.isfile(path) and not os.path.isdir(path):
1707	return
1708
1709	if os.path.isdir(path):
1710	self.load_folder(path)
1711	return
1712
1713	basename = os.path.basename(path)
1714	_, extension = os.path.splitext(basename)
1715	if extension.lower() not in EXTENSIONS:
1716	self.load_data(path)
1717	else:
1718	self.load_state(path)
1719
1720	self._default_save_location = os.path.dirname(path)
1721
1722	def load_state(self, path, is_project=False):
1723	"""
1724	load data from command line or application
1725	"""
1726	if path and (path is not None) and os.path.isfile(path):
1727	basename = os.path.basename(path)
1728	if APPLICATION_STATE_EXTENSION is not None \
1729	and basename.endswith(APPLICATION_STATE_EXTENSION):
1730	if is_project:
1731	for ID in self.plot_panels.keys():
1732	panel = self.plot_panels[ID]
1733	panel.on_close(None)
1734	self.get_data(path)
1735	wx.PostEvent(self, StatusEvent(status="Completed loading."))
1736	else:
1737	wx.PostEvent(self, StatusEvent(status=" "))
1738
1739	def load_data(self, path):
1740	"""
1741	load data from command line
1742	"""
1743	if not os.path.isfile(path):
1744	return
1745	basename = os.path.basename(path)
1746	_, extension = os.path.splitext(basename)
1747	if extension.lower() in EXTENSIONS:
1748	log_msg = "Data Loader cannot "
1749	log_msg += "load: %s\n" % str(path)
1750	log_msg += "Try File opening ...."
1751	logger.error(log_msg)
1752	return
1753	log_msg = ''
1754	output = {}
1755	error_message = ""
1756	try:
1757	logger.info("Loading Data...:\n" + str(path) + "\n")
1758	temp = self.loader.load(path)
1759	if temp.__class__.__name__ == "list":
1760	for item in temp:
1761	data = self.create_gui_data(item, path)
1762	output[data.id] = data
1763	else:
1764	data = self.create_gui_data(temp, path)
1765	output[data.id] = data
1766
1767	self.add_data(data_list=output)
1768	except:
1769	error_message = "Error while loading"
1770	error_message += " Data from cmd:\n %s\n" % str(path)
1771	error_message += str(sys.exc_value) + "\n"
1772	logger.error(error_message)
1773
1774	def load_folder(self, path):
1775	"""
1776	Load entire folder
1777	"""
1778	if not os.path.isdir(path):
1779	return
1780	if self._data_plugin is None:
1781	return
1782	try:
1783	if path is not None:
1784	self._default_save_location = os.path.dirname(path)
1785	file_list = self._data_plugin.get_file_path(path)
1786	self._data_plugin.get_data(file_list)
1787	else:
1788	return
1789	except:
1790	error_message = "Error while loading"
1791	error_message += " Data folder from cmd:\n %s\n" % str(path)
1792	error_message += str(sys.exc_value) + "\n"
1793	logger.error(error_message)
1794
1795	def _on_open_state_application(self, event):
1796	"""
1797	"""
1798	path = None
1799	if self._default_save_location is None:
1800	self._default_save_location = os.getcwd()
1801	wx.PostEvent(self, StatusEvent(status="Loading Analysis file..."))
1802	plug_wlist = self._on_open_state_app_helper()
1803	dlg = wx.FileDialog(self,
1804	"Choose a file",
1805	self._default_save_location, "",
1806	plug_wlist)
1807	if dlg.ShowModal() == wx.ID_OK:
1808	path = dlg.GetPath()
1809	if path is not None:
1810	self._default_save_location = os.path.dirname(path)
1811	dlg.Destroy()
1812	self.load_state(path=path)
1813
1814	def _on_open_state_app_helper(self):
1815	"""
1816	Helps '_on_open_state_application()' to find the extension of
1817	the current perspective/application
1818	"""
1819	# No current perspective or no extension attr
1820	if self._current_perspective is None:
1821	return PLUGINS_WLIST
1822	try:
1823	# Find the extension of the perspective
1824	# and get that as 1st item in list
1825	ind = None
1826	app_ext = self._current_perspective._extensions
1827	plug_wlist = config.PLUGINS_WLIST
1828	for ext in set(plug_wlist):
1829	if ext.count(app_ext) > 0:
1830	ind = ext
1831	break
1832	# Found the extension
1833	if ind is not None:
1834	plug_wlist.remove(ind)
1835	plug_wlist.insert(0, ind)
1836	try:
1837	plug_wlist = '\|'.join(plug_wlist)
1838	except:
1839	plug_wlist = ''
1840
1841	except:
1842	plug_wlist = PLUGINS_WLIST
1843
1844	return plug_wlist
1845
1846	def _on_open_state_project(self, event):
1847	"""
1848	Load in a .svs project file after removing all data from SasView
1849	"""
1850	path = None
1851	if self._default_save_location is None:
1852	self._default_save_location = os.getcwd()
1853	msg = "This operation will set remove all data, plots and analyses from"
1854	msg += " SasView before loading the project. Do you wish to continue?"
1855	msg_box = wx.MessageDialog(None, msg, 'Warning', wx.OK \| wx.CANCEL)
1856	if msg_box.ShowModal() == wx.ID_OK:
1857	self._data_panel.selection_cbox.SetValue('Select all Data')
1858	self._data_panel._on_selection_type(None)
1859	for _, theory_dict in self._data_panel.list_cb_theory.iteritems():
1860	for key, value in theory_dict.iteritems():
1861	item, _, _ = value
1862	item.Check(True)
1863
1864	wx.PostEvent(self, StatusEvent(status="Loading Project file..."))
1865	dlg = wx.FileDialog(self, "Choose a file",
1866	self._default_save_location, "",
1867	APPLICATION_WLIST)
1868	if dlg.ShowModal() == wx.ID_OK:
1869	path = dlg.GetPath()
1870	if path is not None:
1871	self._default_save_location = os.path.dirname(path)
1872	dlg.Destroy()
1873	# Reset to a base state
1874	self._on_reset_state()
1875	self._data_panel.on_remove(None, False)
1876	# Load the project file
1877	self.load_state(path=path, is_project=True)
1878
1879	def _on_reset_state(self):
1880	"""
1881	Resets SasView to its freshly opened state.
1882	:return: None
1883	"""
1884	# Reset all plugins to their base state
1885	self._data_panel.set_panel_on_focus()
1886	# Remove all loaded data
1887	for plugin in self.plugins:
1888	plugin.clear_panel()
1889	# Reset plot number to 0
1890	self.graph_num = 0
1891
1892	def _on_save_application(self, event):
1893	"""
1894	save the state of the current active application
1895	"""
1896	if self.cpanel_on_focus is not None:
1897	try:
1898	wx.PostEvent(self,
1899	StatusEvent(status="Saving Analysis file..."))
1900	self.cpanel_on_focus.on_save(event)
1901	wx.PostEvent(self,
1902	StatusEvent(status="Completed saving."))
1903	except Exception:
1904	msg = "Error occurred while saving: "
1905	msg += traceback.format_exc()
1906	msg += "To save, the application panel should have a data set.."
1907	wx.PostEvent(self, StatusEvent(status=msg))
1908
1909	def _on_save_project(self, event):
1910	"""
1911	save the state of the SasView as *.svs
1912	"""
1913	if self._current_perspective is None:
1914	return
1915	wx.PostEvent(self, StatusEvent(status="Saving Project file..."))
1916	path = None
1917	extension = '*' + APPLICATION_STATE_EXTENSION
1918	dlg = wx.FileDialog(self, "Save Project file",
1919	self._default_save_location, "sasview_proj",
1920	extension,
1921	wx.SAVE)
1922	if dlg.ShowModal() == wx.ID_OK:
1923	path = dlg.GetPath()
1924	self._default_save_location = os.path.dirname(path)
1925	else:
1926	return None
1927	dlg.Destroy()
1928	try:
1929	if path is None:
1930	return
1931	# default cansas xml doc
1932	doc = None
1933	for panel in self.panels.values():
1934	temp = panel.save_project(doc)
1935	if temp is not None:
1936	doc = temp
1937
1938	# Write the XML document
1939	extens = APPLICATION_STATE_EXTENSION
1940	fName = os.path.splitext(path)[0] + extens
1941	if doc is not None:
1942	fd = open(fName, 'w')
1943	fd.write(doc.toprettyxml())
1944	fd.close()
1945	wx.PostEvent(self, StatusEvent(status="Completed Saving."))
1946	else:
1947	msg = "Error occurred while saving the project: "
1948	msg += "To save, at least one application panel "
1949	msg += "should have a data set "
1950	msg += "and model selected. "
1951	msg += "No project was saved to %s" % (str(path))
1952	logger.warning(msg)
1953	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1954	except Exception:
1955	msg = "Error occurred while saving: "
1956	msg += traceback.format_exc()
1957	msg += "To save, at least one application panel "
1958	msg += "should have a data set.."
1959	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1960
1961	def on_save_helper(self, doc, reader, panel, path):
1962	"""
1963	Save state into a file
1964	"""
1965	if reader is not None:
1966	# case of a panel with multi-pages
1967	if hasattr(panel, "opened_pages"):
1968	for _, page in panel.opened_pages.iteritems():
1969	data = page.get_data()
1970	# state must be cloned
1971	state = page.get_state().clone()
1972	if data is not None:
1973	new_doc = reader.write_toXML(data, state)
1974	if doc is not None and hasattr(doc, "firstChild"):
1975	child = new_doc.firstChild.firstChild
1976	doc.firstChild.appendChild(child)
1977	else:
1978	doc = new_doc
1979	# case of only a panel
1980	else:
1981	data = panel.get_data()
1982	state = panel.get_state()
1983	if data is not None:
1984	new_doc = reader.write_toXML(data, state)
1985	if doc is not None and hasattr(doc, "firstChild"):
1986	child = new_doc.firstChild.firstChild
1987	doc.firstChild.appendChild(child)
1988	else:
1989	doc = new_doc
1990	return doc
1991
1992	def quit_guiframe(self):
1993	"""
1994	Pop up message to make sure the user wants to quit the application
1995	"""
1996	message = "\nDo you really want to exit this application? \n\n"
1997	dial = wx.MessageDialog(self, message, 'Confirm Exit',
1998	wx.YES_NO \| wx.YES_DEFAULT \| wx.ICON_QUESTION)
1999	if dial.ShowModal() == wx.ID_YES:
2000	return True
2001	else:
2002	return False
2003
2004	def WindowClose(self, event=None):
2005	"""
2006	Quit the application from x icon
2007	"""
2008	flag = self.quit_guiframe()
2009	if flag:
2010	_pylab_helpers.Gcf.figs = {}
2011	self.Close()
2012
2013	def Close(self, event=None):
2014	"""
2015	Quit the application
2016	"""
2017	#IF SAS_OPENCL is set, settings are stored in the custom config file
2018	self._write_opencl_config_file()
2019	logger.info(" --- SasView session was closed --- \n")
2020	wx.Exit()
2021	sys.exit()
2022
2023	def _write_opencl_config_file(self):
2024	"""
2025	Writes OpenCL settings to custom config file, so they can be remmbered
2026	from session to session
2027	"""
2028	if custom_config is not None:
2029	sas_opencl = os.environ.get("SAS_OPENCL")
2030	new_config_lines = []
2031	config_file = open(custom_config.__file__)
2032	config_lines = config_file.readlines()
2033	for line in config_lines:
2034	if "SAS_OPENCL" in line:
2035	if sas_opencl:
2036	new_config_lines.append("SAS_OPENCL = \"" + sas_opencl
2037	+ "\"\n")
2038	else:
2039	new_config_lines.append("SAS_OPENCL = \"None\"\n")
2040	else:
2041	new_config_lines.append(line)
2042	config_file.close()
2043
2044	#If custom_config is None, settings will not be remmbered
2045	new_config_file = open(custom_config.__file__,"w")
2046	new_config_file.writelines(new_config_lines)
2047	new_config_file.close()
2048	else:
2049	logger.info("Failed to save OPENCL settings in custom config file")
2050
2051
2052	def _check_update(self, event=None):
2053	"""
2054	Check with the deployment server whether a new version
2055	of the application is available.
2056	A thread is started for the connecting with the server. The thread calls
2057	a call-back method when the current version number has been obtained.
2058	"""
2059	version_info = {"version": "0.0.0"}
2060	c = Connection(config.__update_URL__, config.UPDATE_TIMEOUT)
2061	response = c.connect()
2062	if response is not None:
2063	try:
2064	content = response.read().strip()
2065	logger.info("Connected to www.sasview.org. Latest version: %s", content)
2066	version_info = json.loads(content)
2067	except:
2068	logger.info("Failed to connect to www.sasview.org")
2069	self._process_version(version_info, standalone=event is None)
2070
2071
2072	def _process_version(self, version_info, standalone=True):
2073	"""
2074	Call-back method for the process of checking for updates.
2075	This methods is called by a VersionThread object once the current
2076	version number has been obtained. If the check is being done in the
2077	background, the user will not be notified unless there's an update.
2078
2079	:param version: version string
2080	:param standalone: True of the update is being checked in
2081	the background, False otherwise.
2082
2083	"""
2084	try:
2085	version = version_info["version"]
2086	if version == "0.0.0":
2087	msg = "Could not connect to the application server."
2088	msg += " Please try again later."
2089	self.SetStatusText(msg)
2090	elif cmp(version, config.__version__) > 0:
2091	msg = "Version %s is available! " % str(version)
2092	if not standalone:
2093	import webbrowser
2094	if "download_url" in version_info:
2095	webbrowser.open(version_info["download_url"])
2096	else:
2097	webbrowser.open(config.__download_page__)
2098	else:
2099	msg += "See the help menu to download it."
2100	self.SetStatusText(msg)
2101	else:
2102	if not standalone:
2103	msg = "You have the latest version"
2104	msg += " of %s" % str(config.__appname__)
2105	self.SetStatusText(msg)
2106	except:
2107	msg = "guiframe: could not get latest application"
2108	msg += " version number\n %s" % sys.exc_value
2109	logger.error(msg)
2110	if not standalone:
2111	msg = "Could not connect to the application server."
2112	msg += " Please try again later."
2113	self.SetStatusText(msg)
2114
2115	def _onAcknowledge(self, evt):
2116	"""
2117	Pop up the acknowledge dialog
2118
2119	:param evt: menu event
2120
2121	"""
2122	if config._do_acknowledge:
2123	import sas.sasgui.guiframe.acknowledgebox as AcknowledgeBox
2124	dialog = AcknowledgeBox.DialogAcknowledge(None, -1, "")
2125	dialog.ShowModal()
2126
2127	def _onAbout(self, evt):
2128	"""
2129	Pop up the about dialog
2130
2131	:param evt: menu event
2132
2133	"""
2134	if config._do_aboutbox:
2135	import sas.sasgui.guiframe.aboutbox as AboutBox
2136	dialog = AboutBox.DialogAbout(None, -1, "")
2137	dialog.ShowModal()
2138
2139	def _onTutorial(self, evt):
2140	"""
2141	Pop up the tutorial dialog
2142
2143	:param evt: menu event
2144
2145	"""
2146	# if config._do_tutorial:
2147	# path = config.TUTORIAL_PATH
2148	# if IS_WIN:
2149	# try:
2150	# from sas.sasgui.guiframe.pdfview import PDFFrame
2151	# dialog = PDFFrame(None, -1, "Tutorial", path)
2152	# # put icon
2153	# self.put_icon(dialog)
2154	# dialog.Show(True)
2155	# except:
2156	# logger.error("Error in _onTutorial: %s" % sys.exc_value)
2157	# try:
2158	# # Try an alternate method
2159	# logger.error(
2160	# "Could not open the tutorial pdf, trying xhtml2pdf")
2161	# from xhtml2pdf import pisa
2162	# pisa.startViewer(path)
2163	# except:
2164	# logger.error(
2165	# "Could not open the tutorial pdf with xhtml2pdf")
2166	# msg = "This feature requires 'PDF Viewer'\n"
2167	# wx.MessageBox(msg, 'Error')
2168	# else:
2169	# try:
2170	# command = "open '%s'" % path
2171	# os.system(command)
2172	# except:
2173	# try:
2174	# # Try an alternate method
2175	# logger.error(
2176	# "Could not open the tutorial pdf, trying xhtml2pdf")
2177	# from xhtml2pdf import pisa
2178	# pisa.startViewer(path)
2179	# except:
2180	# logger.error(
2181	# "Could not open the tutorial pdf with xhtml2pdf")
2182	# msg = "This feature requires the Preview application\n"
2183	# wx.MessageBox(msg, 'Error')
2184	from documentation_window import DocumentationWindow
2185	_TreeLocation = "user/tutorial.html"
2186	DocumentationWindow(self, -1, _TreeLocation, "",
2187	"SasView Documentation")
2188
2189	def _onSphinxDocs(self, evt):
2190	"""
2191	Bring up Sphinx Documentation at top level whenever the menu item
2192	'documentation' is clicked. Calls DocumentationWindow with the top
2193	level path of "index.html"
2194
2195	:param evt: menu event
2196	"""
2197	# Running SasView "in-place" using run.py means the docs will be in a
2198	# different place than they would otherwise.
2199	from documentation_window import DocumentationWindow
2200	_TreeLocation = "user/user.html"
2201	DocumentationWindow(self, -1, _TreeLocation, "",
2202	"SasView Documentation")
2203
2204	def set_manager(self, manager):
2205	"""
2206	Sets the application manager for this frame
2207
2208	:param manager: frame manager
2209	"""
2210	self.app_manager = manager
2211
2212	def post_init(self):
2213	"""
2214	This initialization method is called after the GUI
2215	has been created and all plug-ins loaded. It calls
2216	the post_init() method of each plug-in (if it exists)
2217	so that final initialization can be done.
2218	"""
2219	for item in self.plugins:
2220	if hasattr(item, "post_init"):
2221	item.post_init()
2222
2223	def set_perspective(self, panels):
2224	"""
2225	Sets the perspective of the GUI.
2226	Opens all the panels in the list, and closes
2227	all the others.
2228
2229	:param panels: list of panels
2230	"""
2231	for item in self.panels.keys():
2232	# Check whether this is a sticky panel
2233	if hasattr(self.panels[item], "ALWAYS_ON"):
2234	if self.panels[item].ALWAYS_ON:
2235	continue
2236	if self.panels[item] is None:
2237	continue
2238	if self.panels[item].window_name in panels:
2239	frame = self.panels[item].get_frame()
2240	if not frame.IsShown():
2241	frame.Show(True)
2242	else:
2243	# always show the data panel if enable
2244	style = self.__gui_style & GUIFRAME.MANAGER_ON
2245	if (style == GUIFRAME.MANAGER_ON) \
2246	and self.panels[item] == self._data_panel:
2247	if 'data_panel' in self.panels.keys():
2248	frame = self.panels['data_panel'].get_frame()
2249	if frame is None:
2250	continue
2251	flag = frame.IsShown()
2252	frame.Show(flag)
2253	else:
2254	frame = self.panels[item].get_frame()
2255	if frame is None:
2256	continue
2257
2258	if frame.IsShown():
2259	frame.Show(False)
2260
2261	def show_data_panel(self, event=None, action=True):
2262	"""
2263	show the data panel
2264	"""
2265	if self._data_panel_menu is None:
2266	return
2267	label = self._data_panel_menu.GetText()
2268	pane = self.panels["data_panel"]
2269	frame = pane.get_frame()
2270	if label == 'Show Data Explorer':
2271	if action:
2272	frame.Show(True)
2273	self.__gui_style = self.__gui_style \| GUIFRAME.MANAGER_ON
2274	self._data_panel_menu.SetText('Hide Data Explorer')
2275	else:
2276	if action:
2277	frame.Show(False)
2278	self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
2279	self._data_panel_menu.SetText('Show Data Explorer')
2280
2281	def add_data_helper(self, data_list):
2282	"""
2283	"""
2284	if self._data_manager is not None:
2285	self._data_manager.add_data(data_list)
2286
2287	def add_data(self, data_list):
2288	"""
2289	receive a dictionary of data from loader
2290	store them its data manager if possible
2291	send to data the current active perspective if the data panel
2292	is not active.
2293	:param data_list: dictionary of data's ID and value Data
2294	"""
2295	# Store data into manager
2296	self.add_data_helper(data_list)
2297	# set data in the data panel
2298	if self._data_panel is not None:
2299	data_state = self._data_manager.get_data_state(data_list.keys())
2300	self._data_panel.load_data_list(data_state)
2301	# if the data panel is shown wait for the user to press a button
2302	# to send data to the current perspective. if the panel is not
2303	# show automatically send the data to the current perspective
2304	style = self.__gui_style & GUIFRAME.MANAGER_ON
2305	if style == GUIFRAME.MANAGER_ON:
2306	# wait for button press from the data panel to set_data
2307	if self._data_panel is not None:
2308	self._data_panel.frame.Show(True)
2309	else:
2310	# automatically send that to the current perspective
2311	self.set_data(data_id=data_list.keys())
2312
2313	def set_data(self, data_id, theory_id=None):
2314	"""
2315	set data to current perspective
2316	"""
2317	list_data, _ = self._data_manager.get_by_id(data_id)
2318	if self._current_perspective is not None:
2319	self._current_perspective.set_data(list_data.values())
2320
2321	else:
2322	msg = "Guiframe does not have a current perspective"
2323	logger.info(msg)
2324
2325	def set_theory(self, state_id, theory_id=None):
2326	"""
2327	"""
2328	_, list_theory = self._data_manager.get_by_id(theory_id)
2329	if self._current_perspective is not None:
2330	try:
2331	self._current_perspective.set_theory(list_theory.values())
2332	except:
2333	msg = "Guiframe set_theory: \n" + str(sys.exc_value)
2334	logger.info(msg)
2335	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
2336	else:
2337	msg = "Guiframe does not have a current perspective"
2338	logger.info(msg)
2339
2340	def plot_data(self, state_id, data_id=None,
2341	theory_id=None, append=False):
2342	"""
2343	send a list of data to plot
2344	"""
2345	data_list, _ = self._data_manager.get_by_id(data_id)
2346	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
2347	total_plot_list = data_list.values()
2348	for item in temp_list_theory.values():
2349	theory_data, theory_state = item
2350	total_plot_list.append(theory_data)
2351	GROUP_ID = wx.NewId()
2352	for new_plot in total_plot_list:
2353	if append:
2354	if self.panel_on_focus is None:
2355	message = "cannot append plot. No plot panel on focus!"
2356	message += "please click on any available plot to set focus"
2357	wx.PostEvent(self, StatusEvent(status=message,
2358	info='warning'))
2359	return
2360	else:
2361	if self.enable_add_data(new_plot):
2362	new_plot.group_id = self.panel_on_focus.group_id
2363	else:
2364	message = "Only 1D Data can be append to"
2365	message += " plot panel containing 1D data.\n"
2366	message += "%s not be appended.\n" % str(new_plot.name)
2367	message += "try new plot option.\n"
2368	wx.PostEvent(self, StatusEvent(status=message,
2369	info='warning'))
2370	else:
2371	# if not append then new plot
2372	from sas.sasgui.guiframe.dataFitting import Data2D
2373	if issubclass(Data2D, new_plot.__class__):
2374	# for 2 D always plot in a separated new plot
2375	new_plot.group_id = wx.NewId()
2376	else:
2377	# plot all 1D in a new plot
2378	new_plot.group_id = GROUP_ID
2379	title = "PLOT " + str(new_plot.title)
2380	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
2381	title=title,
2382	group_id=new_plot.group_id))
2383
2384	def remove_data(self, data_id, theory_id=None):
2385	"""
2386	Delete data state if data_id is provide
2387	delete theory created with data of id data_id if theory_id is provide
2388	if delete all true: delete the all state
2389	else delete theory
2390	"""
2391	temp = data_id + theory_id
2392	for plug in self.plugins:
2393	plug.delete_data(temp)
2394	data_list, _ = self._data_manager.get_by_id(data_id)
2395	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
2396	total_plot_list = data_list.values()
2397	for item in temp_list_theory.values():
2398	theory_data, theory_state = item
2399	total_plot_list.append(theory_data)
2400	for new_plot in total_plot_list:
2401	for group_id in new_plot.list_group_id:
2402	wx.PostEvent(self, NewPlotEvent(id=new_plot.id,
2403	group_id=group_id,
2404	action='remove'))
2405	wx.CallAfter(self._remove_res_plot, new_plot.id)
2406	self._data_manager.delete_data(data_id=data_id,
2407	theory_id=theory_id)
2408
2409	def _remove_res_plot(self, id):
2410	"""
2411	Try to remove corresponding res plot
2412
2413	: param id: id of the data
2414	"""
2415	try:
2416	wx.PostEvent(self, NewPlotEvent(id=("res" + str(id)),
2417	group_id=("res" + str(id)),
2418	action='remove'))
2419	except:
2420	logger.error(sys.exc_value)
2421
2422	def save_data1d(self, data, fname):
2423	"""
2424	Save data dialog
2425	"""
2426	default_name = fname
2427	wildcard = "Text files (.txt)\|.txt\|"\
2428	"CanSAS 1D files(.xml)\|.xml"
2429	path = None
2430	dlg = wx.FileDialog(self, "Choose a file",
2431	self._default_save_location,
2432	default_name, wildcard, wx.SAVE)
2433
2434	if dlg.ShowModal() == wx.ID_OK:
2435	path = dlg.GetPath()
2436	# ext_num = 0 for .txt, ext_num = 1 for .xml
2437	# This is MAC Fix
2438	ext_num = dlg.GetFilterIndex()
2439	if ext_num == 0:
2440	ext_format = '.txt'
2441	else:
2442	ext_format = '.xml'
2443	path = os.path.splitext(path)[0] + ext_format
2444	mypath = os.path.basename(path)
2445
2446	# Instantiate a loader
2447	loader = Loader()
2448	ext_format = ".txt"
2449	if os.path.splitext(mypath)[1].lower() == ext_format:
2450	# Make sure the ext included in the file name
2451	# especially on MAC
2452	fName = os.path.splitext(path)[0] + ext_format
2453	self._onsaveTXT(data, fName)
2454	ext_format = ".xml"
2455	if os.path.splitext(mypath)[1].lower() == ext_format:
2456	# Make sure the ext included in the file name
2457	# especially on MAC
2458	fName = os.path.splitext(path)[0] + ext_format
2459	loader.save(fName, data, ext_format)
2460	try:
2461	self._default_save_location = os.path.dirname(path)
2462	except:
2463	pass
2464	dlg.Destroy()
2465
2466	def _onsaveTXT(self, data, path):
2467	"""
2468	Save file as txt
2469
2470	.. todo:: Refactor and remove this method. See 'TODO' in _onSave.
2471	"""
2472	if path is not None:
2473	out = open(path, 'w')
2474	has_errors = True
2475	if data.dy is None or data.dy == []:
2476	has_errors = False
2477	# Sanity check
2478	if has_errors:
2479	try:
2480	if len(data.y) != len(data.dy):
2481	has_errors = False
2482	except:
2483	has_errors = False
2484	if has_errors:
2485	if data.dx is not None and data.dx != []:
2486	out.write("<X> <Y> <dY> <dX>\n")
2487	else:
2488	out.write("<X> <Y> <dY>\n")
2489	else:
2490	out.write("<X> <Y>\n")
2491
2492	for i in range(len(data.x)):
2493	if has_errors:
2494	if data.dx is not None and data.dx != []:
2495	if data.dx[i] is not None:
2496	out.write("%g %g %g %g\n" % (data.x[i],
2497	data.y[i],
2498	data.dy[i],
2499	data.dx[i]))
2500	else:
2501	out.write("%g %g %g\n" % (data.x[i],
2502	data.y[i],
2503	data.dy[i]))
2504	else:
2505	out.write("%g %g %g\n" % (data.x[i],
2506	data.y[i],
2507	data.dy[i]))
2508	else:
2509	out.write("%g %g\n" % (data.x[i],
2510	data.y[i]))
2511	out.close()
2512
2513	def show_data1d(self, data, name):
2514	"""
2515	Show data dialog
2516	"""
2517	try:
2518	xmin = min(data.x)
2519	ymin = min(data.y)
2520	except:
2521	msg = "Unable to find min/max of \n data named %s" % \
2522	data.filename
2523	wx.PostEvent(self, StatusEvent(status=msg,
2524	info="error"))
2525	raise ValueError, msg
2526	# text = str(data)
2527	text = data.__str__()
2528	text += 'Data Min Max:\n'
2529	text += 'X_min = %s: X_max = %s\n' % (xmin, max(data.x))
2530	text += 'Y_min = %s: Y_max = %s\n' % (ymin, max(data.y))
2531	if data.dy is not None:
2532	text += 'dY_min = %s: dY_max = %s\n' % (min(data.dy), max(data.dy))
2533	text += '\nData Points:\n'
2534	x_st = "X"
2535	for index in range(len(data.x)):
2536	if data.dy is not None and len(data.dy) > index:
2537	dy_val = data.dy[index]
2538	else:
2539	dy_val = 0.0
2540	if data.dx is not None and len(data.dx) > index:
2541	dx_val = data.dx[index]
2542	else:
2543	dx_val = 0.0
2544	if data.dxl is not None and len(data.dxl) > index:
2545	if index == 0:
2546	x_st = "Xl"
2547	dx_val = data.dxl[index]
2548	elif data.dxw is not None and len(data.dxw) > index:
2549	if index == 0:
2550	x_st = "Xw"
2551	dx_val = data.dxw[index]
2552
2553	if index == 0:
2554	text += "<index> \t<X> \t<Y> \t<dY> \t<d%s>\n" % x_st
2555	text += "%s \t%s \t%s \t%s \t%s\n" % (index,
2556	data.x[index],
2557	data.y[index],
2558	dy_val,
2559	dx_val)
2560	from pdfview import TextFrame
2561	frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2562	# put icon
2563	self.put_icon(frame)
2564	frame.Show(True)
2565
2566	def save_data2d(self, data, fname):
2567	"""
2568	Save data2d dialog
2569	"""
2570	default_name = fname
2571	wildcard = "IGOR/DAT 2D file in Q_map (.dat)\|.DAT"
2572	dlg = wx.FileDialog(self, "Choose a file",
2573	self._default_save_location,
2574	default_name, wildcard, wx.SAVE)
2575
2576	if dlg.ShowModal() == wx.ID_OK:
2577	path = dlg.GetPath()
2578	# ext_num = 0 for .txt, ext_num = 1 for .xml
2579	# This is MAC Fix
2580	ext_num = dlg.GetFilterIndex()
2581	if ext_num == 0:
2582	ext_format = '.dat'
2583	else:
2584	ext_format = ''
2585	path = os.path.splitext(path)[0] + ext_format
2586	mypath = os.path.basename(path)
2587
2588	# Instantiate a loader
2589	loader = Loader()
2590
2591	ext_format = ".dat"
2592	if os.path.splitext(mypath)[1].lower() == ext_format:
2593	# Make sure the ext included in the file name
2594	# especially on MAC
2595	fileName = os.path.splitext(path)[0] + ext_format
2596	loader.save(fileName, data, ext_format)
2597	try:
2598	self._default_save_location = os.path.dirname(path)
2599	except:
2600	pass
2601	dlg.Destroy()
2602
2603	def show_data2d(self, data, name):
2604	"""
2605	Show data dialog
2606	"""
2607	wx.PostEvent(self, StatusEvent(status="Gathering Data2D Info.",
2608	type='start'))
2609	text = data.__str__()
2610	text += 'Data Min Max:\n'
2611	text += 'I_min = %s\n' % min(data.data)
2612	text += 'I_max = %s\n\n' % max(data.data)
2613	text += 'Data (First 2501) Points:\n'
2614	text += 'Data columns include err(I).\n'
2615	text += 'ASCII data starts here.\n'
2616	text += "<index> \t<Qx> \t<Qy> \t<I> \t<dI> \t<dQparal> \t<dQperp>\n"
2617	di_val = 0.0
2618	dx_val = 0.0
2619	dy_val = 0.0
2620	len_data = len(data.qx_data)
2621	for index in xrange(0, len_data):
2622	x_val = data.qx_data[index]
2623	y_val = data.qy_data[index]
2624	i_val = data.data[index]
2625	if data.err_data is not None:
2626	di_val = data.err_data[index]
2627	if data.dqx_data is not None:
2628	dx_val = data.dqx_data[index]
2629	if data.dqy_data is not None:
2630	dy_val = data.dqy_data[index]
2631
2632	text += "%s \t%s \t%s \t%s \t%s \t%s \t%s\n" % (index,
2633	x_val,
2634	y_val,
2635	i_val,
2636	di_val,
2637	dx_val,
2638	dy_val)
2639	# Takes too long time for typical data2d: Break here
2640	if index >= 2500:
2641	text += ".............\n"
2642	break
2643
2644	from pdfview import TextFrame
2645	frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2646	# put icon
2647	self.put_icon(frame)
2648	frame.Show(True)
2649	wx.PostEvent(self, StatusEvent(status="Data2D Info Displayed",
2650	type='stop'))
2651
2652	def set_current_perspective(self, perspective):
2653	"""
2654	set the current active perspective
2655	"""
2656	self._current_perspective = perspective
2657	name = "No current analysis selected"
2658	if self._current_perspective is not None:
2659	self._add_current_plugin_menu()
2660	for panel in self.panels.values():
2661	if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
2662	for name in self._current_perspective.get_perspective():
2663	frame = panel.get_frame()
2664	if frame is not None:
2665	if name == panel.window_name:
2666	panel.on_set_focus(event=None)
2667	frame.Show(True)
2668	else:
2669	frame.Show(False)
2670	name = self._current_perspective.sub_menu
2671	if self._data_panel is not None:
2672	self._data_panel.set_active_perspective(name)
2673	self._check_applications_menu()
2674	# Set the SasView title
2675	self._set_title_name(name)
2676
2677	def _set_title_name(self, name):
2678	"""
2679	Set the SasView title w/ the current application name
2680
2681	: param name: application name [string]
2682	"""
2683	# Set SanView Window title w/ application anme
2684	title = self.title + " - " + name + " -"
2685	self.SetTitle(title)
2686
2687	def _check_applications_menu(self):
2688	"""
2689	check the menu of the current application
2690	"""
2691	if self._applications_menu is not None:
2692	for menu in self._applications_menu.GetMenuItems():
2693	if self._current_perspective is not None:
2694	name = self._current_perspective.sub_menu
2695	if menu.IsCheckable():
2696	if menu.GetLabel() == name:
2697	menu.Check(True)
2698	else:
2699	menu.Check(False)
2700
2701	def enable_add_data(self, new_plot):
2702	"""
2703	Enable append data on a plot panel
2704	"""
2705
2706	if self.panel_on_focus \
2707	not in self._plotting_plugin.plot_panels.values():
2708	return
2709	check = "Theory1D"
2710	is_theory = len(self.panel_on_focus.plots) <= 1 and \
2711	self.panel_on_focus.plots.values()[0].__class__.__name__ == check
2712
2713	is_data2d = hasattr(new_plot, 'data')
2714
2715	is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
2716	and self.panel_on_focus.group_id is not None
2717	has_meta_data = hasattr(new_plot, 'meta_data')
2718
2719	# disable_add_data if the data is being recovered from a saved state
2720	is_state_data = False
2721	if has_meta_data:
2722	if 'invstate' in new_plot.meta_data:
2723	is_state_data = True
2724	if 'prstate' in new_plot.meta_data:
2725	is_state_data = True
2726	if 'fitstate' in new_plot.meta_data:
2727	is_state_data = True
2728
2729	return is_data1d and not is_data2d and not is_theory \
2730	and not is_state_data
2731
2732	def check_multimode(self, perspective=None):
2733	"""
2734	Check the perspective have batch mode capablitity
2735	"""
2736	if perspective is None or self._data_panel is None:
2737	return
2738	flag = perspective.get_batch_capable()
2739	flag_on = perspective.batch_on
2740	if flag:
2741	self._data_panel.rb_single_mode.SetValue(not flag_on)
2742	self._data_panel.rb_batch_mode.SetValue(flag_on)
2743	else:
2744	self._data_panel.rb_single_mode.SetValue(True)
2745	self._data_panel.rb_batch_mode.SetValue(False)
2746	self._data_panel.rb_single_mode.Enable(flag)
2747	self._data_panel.rb_batch_mode.Enable(flag)
2748
2749	def enable_edit_menu(self):
2750	"""
2751	enable menu item under edit menu depending on the panel on focus
2752	"""
2753	if self.cpanel_on_focus is not None and self._edit_menu is not None:
2754	flag = self.cpanel_on_focus.get_undo_flag()
2755	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2756	flag = self.cpanel_on_focus.get_redo_flag()
2757	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2758	flag = self.cpanel_on_focus.get_copy_flag()
2759	self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2760	flag = self.cpanel_on_focus.get_paste_flag()
2761	self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2762
2763	# Copy menu
2764	flag = self.cpanel_on_focus.get_copy_flag()
2765	self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYEX_ID, flag)
2766	self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYLAT_ID, flag)
2767
2768	flag = self.cpanel_on_focus.get_preview_flag()
2769	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2770	flag = self.cpanel_on_focus.get_reset_flag()
2771	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2772	else:
2773	flag = False
2774	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2775	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2776	self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2777	self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2778	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2779	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2780
2781	def on_undo_panel(self, event=None):
2782	"""
2783	undo previous action of the last panel on focus if possible
2784	"""
2785	if self.cpanel_on_focus is not None:
2786	self.cpanel_on_focus.on_undo(event)
2787
2788	def on_redo_panel(self, event=None):
2789	"""
2790	redo the last cancel action done on the last panel on focus
2791	"""
2792	if self.cpanel_on_focus is not None:
2793	self.cpanel_on_focus.on_redo(event)
2794
2795	def on_copy_panel(self, event=None):
2796	"""
2797	copy the last panel on focus if possible
2798	"""
2799	if self.cpanel_on_focus is not None:
2800	self.cpanel_on_focus.on_copy(event)
2801
2802	def on_paste_panel(self, event=None):
2803	"""
2804	paste clipboard to the last panel on focus
2805	"""
2806	if self.cpanel_on_focus is not None:
2807	self.cpanel_on_focus.on_paste(event)
2808
2809	def on_bookmark_panel(self, event=None):
2810	"""
2811	bookmark panel
2812	"""
2813	if self.cpanel_on_focus is not None:
2814	self.cpanel_on_focus.on_bookmark(event)
2815
2816	def append_bookmark(self, event=None):
2817	"""
2818	Bookmark available information of the panel on focus
2819	"""
2820	self._toolbar.append_bookmark(event)
2821
2822	def on_save_panel(self, event=None):
2823	"""
2824	save possible information on the current panel
2825	"""
2826	if self.cpanel_on_focus is not None:
2827	self.cpanel_on_focus.on_save(event)
2828
2829	def on_preview_panel(self, event=None):
2830	"""
2831	preview information on the panel on focus
2832	"""
2833	if self.cpanel_on_focus is not None:
2834	self.cpanel_on_focus.on_preview(event)
2835
2836	def on_print_panel(self, event=None):
2837	"""
2838	print available information on the last panel on focus
2839	"""
2840	if self.cpanel_on_focus is not None:
2841	self.cpanel_on_focus.on_print(event)
2842
2843	def on_zoom_panel(self, event=None):
2844	"""
2845	zoom on the current panel if possible
2846	"""
2847	if self.cpanel_on_focus is not None:
2848	self.cpanel_on_focus.on_zoom(event)
2849
2850	def on_zoom_in_panel(self, event=None):
2851	"""
2852	zoom in of the panel on focus
2853	"""
2854	if self.cpanel_on_focus is not None:
2855	self.cpanel_on_focus.on_zoom_in(event)
2856
2857	def on_zoom_out_panel(self, event=None):
2858	"""
2859	zoom out on the panel on focus
2860	"""
2861	if self.cpanel_on_focus is not None:
2862	self.cpanel_on_focus.on_zoom_out(event)
2863
2864	def on_drag_panel(self, event=None):
2865	"""
2866	drag apply to the panel on focus
2867	"""
2868	if self.cpanel_on_focus is not None:
2869	self.cpanel_on_focus.on_drag(event)
2870
2871	def on_reset_panel(self, event=None):
2872	"""
2873	reset the current panel
2874	"""
2875	if self.cpanel_on_focus is not None:
2876	self.cpanel_on_focus.on_reset(event)
2877
2878	def on_change_caption(self, name, old_caption, new_caption):
2879	"""
2880	Change the panel caption
2881
2882	:param name: window_name of the pane
2883	:param old_caption: current caption [string]
2884	:param new_caption: new caption [string]
2885	"""
2886	# wx.aui.AuiPaneInfo
2887	pane_info = self.get_paneinfo(old_caption)
2888	# update the data_panel.cb_plotpanel
2889	if 'data_panel' in self.panels.keys():
2890	# remove from data_panel combobox
2891	data_panel = self.panels["data_panel"]
2892	if data_panel.cb_plotpanel is not None:
2893	# Check if any panel has the same caption
2894	has_newstring = data_panel.cb_plotpanel.FindString(
2895	str(new_caption))
2896	caption = new_caption
2897	if has_newstring != wx.NOT_FOUND:
2898	captions = self._get_plotpanel_captions()
2899	# Append nummber
2900	inc = 1
2901	# FIXME: fix this terrible loop
2902	while (1):
2903	caption = new_caption + '_%s' % str(inc)
2904	if caption not in captions:
2905	break
2906	inc += 1
2907	# notify to users
2908	msg = "Found Same Title: Added '_%s'" % str(inc)
2909	wx.PostEvent(self, StatusEvent(status=msg))
2910	# update data_panel cb
2911	pos = data_panel.cb_plotpanel.FindString(str(old_caption))
2912	if pos != wx.NOT_FOUND:
2913	data_panel.cb_plotpanel.SetString(pos, caption)
2914	data_panel.cb_plotpanel.SetStringSelection(caption)
2915	# New Caption
2916	pane_info.SetTitle(caption)
2917	return caption
2918
2919	def get_paneinfo(self, name):
2920	"""
2921	Get pane Caption from window_name
2922
2923	:param name: window_name in AuiPaneInfo
2924	:returns: AuiPaneInfo of the name
2925	"""
2926	for panel in self.plot_panels.values():
2927	if panel.frame.GetTitle() == name:
2928	return panel.frame
2929	return None
2930
2931	def enable_undo(self):
2932	"""
2933	enable undo related control
2934	"""
2935	if self.cpanel_on_focus is not None:
2936	self._toolbar.enable_undo(self.cpanel_on_focus)
2937
2938	def enable_redo(self):
2939	"""
2940	enable redo
2941	"""
2942	if self.cpanel_on_focus is not None:
2943	self._toolbar.enable_redo(self.cpanel_on_focus)
2944
2945	def enable_copy(self):
2946	"""
2947	enable copy related control
2948	"""
2949	if self.cpanel_on_focus is not None:
2950	self._toolbar.enable_copy(self.cpanel_on_focus)
2951
2952	def enable_paste(self):
2953	"""
2954	enable paste
2955	"""
2956	if self.cpanel_on_focus is not None:
2957	self._toolbar.enable_paste(self.cpanel_on_focus)
2958
2959	def enable_bookmark(self):
2960	"""
2961	Bookmark
2962	"""
2963	if self.cpanel_on_focus is not None:
2964	self._toolbar.enable_bookmark(self.cpanel_on_focus)
2965
2966	def enable_save(self):
2967	"""
2968	save
2969	"""
2970	if self.cpanel_on_focus is not None:
2971	self._toolbar.enable_save(self.cpanel_on_focus)
2972
2973	def enable_preview(self):
2974	"""
2975	preview
2976	"""
2977	if self.cpanel_on_focus is not None:
2978	self._toolbar.enable_preview(self.cpanel_on_focus)
2979
2980	def enable_print(self):
2981	"""
2982	print
2983	"""
2984	if self.cpanel_on_focus is not None:
2985	self._toolbar.enable_print(self.cpanel_on_focus)
2986
2987	def enable_zoom(self):
2988	"""
2989	zoom
2990	"""
2991	if self.cpanel_on_focus is not None:
2992	self._toolbar.enable_zoom(self.panel_on_focus)
2993
2994	def enable_zoom_in(self):
2995	"""
2996	zoom in
2997	"""
2998	if self.cpanel_on_focus is not None:
2999	self._toolbar.enable_zoom_in(self.panel_on_focus)
3000
3001	def enable_zoom_out(self):
3002	"""
3003	zoom out
3004	"""
3005	if self.cpanel_on_focus is not None:
3006	self._toolbar.enable_zoom_out(self.panel_on_focus)
3007
3008	def enable_drag(self, event=None):
3009	"""
3010	drag
3011	"""
3012	# Not implemeted
3013
3014	def enable_reset(self):
3015	"""
3016	reset the current panel
3017	"""
3018	if self.cpanel_on_focus is not None:
3019	self._toolbar.enable_reset(self.panel_on_focus)
3020
3021	def get_toolbar_height(self):
3022	"""
3023	"""
3024	size_y = 0
3025	if self.GetToolBar() is not None and self.GetToolBar().IsShown():
3026	if not IS_LINUX:
3027	_, size_y = self.GetToolBar().GetSizeTuple()
3028	return size_y
3029
3030	def set_schedule_full_draw(self, panel=None, func='del'):
3031	"""
3032	Add/subtract the schedule full draw list with the panel given
3033
3034	:param panel: plot panel
3035	:param func: append or del [string]
3036	"""
3037
3038	# append this panel in the schedule list if not in yet
3039	if func == 'append':
3040	if panel not in self.schedule_full_draw_list:
3041	self.schedule_full_draw_list.append(panel)
3042	# remove this panel from schedule list
3043	elif func == 'del':
3044	if len(self.schedule_full_draw_list) > 0:
3045	if panel in self.schedule_full_draw_list:
3046	self.schedule_full_draw_list.remove(panel)
3047
3048	# reset the schdule
3049	if len(self.schedule_full_draw_list) == 0:
3050	self.schedule = False
3051	else:
3052	self.schedule = True
3053
3054	def full_draw(self):
3055	"""
3056	Draw the panels with axes in the schedule to full dwar list
3057	"""
3058
3059	count = len(self.schedule_full_draw_list)
3060	# if not self.schedule:
3061	if count < 1:
3062	self.set_schedule(False)
3063	return
3064
3065	else:
3066	ind = 0
3067	# if any of the panel is shown do full_draw
3068	for panel in self.schedule_full_draw_list:
3069	ind += 1
3070	if panel.frame.IsShown():
3071	break
3072	# otherwise, return
3073	if ind == count:
3074	return
3075	# Simple redraw only for a panel shown
3076
3077	def f_draw(panel):
3078	"""
3079	Draw A panel in the full draw list
3080	"""
3081	try:
3082	# This checking of GetCapture is to stop redrawing
3083	# while any panel is capture.
3084	frame = panel.frame
3085
3086	if not frame.GetCapture():
3087	# draw if possible
3088	panel.set_resizing(False)
3089	# panel.Show(True)
3090	panel.draw_plot()
3091	# Check if the panel is not shown
3092	flag = frame.IsShown()
3093	frame.Show(flag)
3094	except:
3095	pass
3096
3097	# Draw all panels
3098	if count == 1:
3099	f_draw(self.schedule_full_draw_list[0])
3100	else:
3101	map(f_draw, self.schedule_full_draw_list)
3102	# Reset the attr
3103	if len(self.schedule_full_draw_list) == 0:
3104	self.set_schedule(False)
3105	else:
3106	self.set_schedule(True)
3107
3108	def set_schedule(self, schedule=False):
3109	"""
3110	Set schedule
3111	"""
3112	self.schedule = schedule
3113
3114	def get_schedule(self):
3115	"""
3116	Get schedule
3117	"""
3118	return self.schedule
3119
3120	def on_set_plot_focus(self, panel):
3121	"""
3122	Set focus on a plot panel
3123	"""
3124	if panel is None:
3125	return
3126	# self.set_plot_unfocus()
3127	panel.on_set_focus(None)
3128	# set focusing panel
3129	self.panel_on_focus = panel
3130	self.set_panel_on_focus(None)
3131
3132	def set_plot_unfocus(self):
3133	"""
3134	Un focus all plot panels
3135	"""
3136	for plot in self.plot_panels.values():
3137	plot.on_kill_focus(None)
3138
3139	def get_window_size(self):
3140	"""
3141	Get window size
3142
3143	:returns: size
3144	:rtype: tuple
3145	"""
3146	width, height = self.GetSizeTuple()
3147	if not IS_WIN:
3148	# Subtract toolbar height to get real window side
3149	if self._toolbar.IsShown():
3150	height -= 45
3151	return (width, height)
3152
3153	def _onDrawIdle(self, args, *kwargs):
3154	"""
3155	ReDraw with axes
3156	"""
3157	try:
3158	# check if it is time to redraw
3159	if self.GetCapture() is None:
3160	# Draw plot, changes resizing too
3161	self.full_draw()
3162	except:
3163	pass
3164
3165	# restart idle
3166	self._redraw_idle(args, *kwargs)
3167
3168	def _redraw_idle(self, args, *kwargs):
3169	"""
3170	Restart Idle
3171	"""
3172	# restart idle
3173	self.idletimer.Restart(100 * TIME_FACTOR, args, *kwargs)
3174
3175
3176	class DefaultPanel(wx.Panel, PanelBase):
3177	"""
3178	Defines the API for a panels to work with
3179	the GUI manager
3180	"""
3181	# Internal nickname for the window, used by the AUI manager
3182	window_name = "default"
3183	# Name to appear on the window title bar
3184	window_caption = "Welcome panel"
3185	# Flag to tell the AUI manager to put this panel in the center pane
3186	CENTER_PANE = True
3187
3188	def __init__(self, parent, args, *kwds):
3189	wx.Panel.__init__(self, parent, args, *kwds)
3190	PanelBase.__init__(self, parent)
3191
3192
3193	class SasViewApp(wx.App):
3194	"""
3195	SasView application
3196	"""
3197	def OnInit(self):
3198	"""
3199	When initialised
3200	"""
3201	pos, size, self.is_max = self.window_placement((GUIFRAME_WIDTH,
3202	GUIFRAME_HEIGHT))
3203	self.frame = ViewerFrame(parent=None,
3204	title=APPLICATION_NAME,
3205	pos=pos,
3206	gui_style=DEFAULT_STYLE,
3207	size=size)
3208	self.frame.Hide()
3209	if not IS_WIN:
3210	self.frame.EnableCloseButton(False)
3211	self.s_screen = None
3212
3213	try:
3214	self.open_file()
3215	except:
3216	msg = "%s Could not load " % str(APPLICATION_NAME)
3217	msg += "input file from command line.\n"
3218	logger.error(msg)
3219	# Display a splash screen on top of the frame.
3220	try:
3221	if os.path.isfile(SPLASH_SCREEN_PATH):
3222	self.s_screen = \
3223	self.display_splash_screen(parent=self.frame,
3224	path=SPLASH_SCREEN_PATH)
3225	else:
3226	self.frame.Show()
3227	except:
3228	if self.s_screen is not None:
3229	self.s_screen.Close()
3230	msg = "Cannot display splash screen\n"
3231	msg += str(sys.exc_value)
3232	logger.error(msg)
3233	self.frame.Show()
3234
3235	self.SetTopWindow(self.frame)
3236
3237	return True
3238
3239	def maximize_win(self):
3240	"""
3241	Maximize the window after the frame shown
3242	"""
3243	if self.is_max:
3244	if self.frame.IsShown():
3245	# Max window size
3246	self.frame.Maximize(self.is_max)
3247
3248	def open_file(self):
3249	"""
3250	open a state file at the start of the application
3251	"""
3252	input_file = None
3253	if len(sys.argv) >= 2:
3254	cmd = sys.argv[0].lower()
3255	basename = os.path.basename(cmd)
3256	app_base = str(APPLICATION_NAME).lower()
3257	if os.path.isfile(cmd) or basename.lower() == app_base:
3258	app_py = app_base + '.py'
3259	app_exe = app_base + '.exe'
3260	app_app = app_base + '.app'
3261	if basename.lower() in [app_py, app_exe, app_app, app_base]:
3262	data_base = sys.argv[1]
3263	input_file = os.path.normpath(os.path.join(get_app_dir(),
3264	data_base))
3265	if input_file is None:
3266	return
3267	if self.frame is not None:
3268	self.frame.set_input_file(input_file=input_file)
3269
3270	def clean_plugin_models(self, path):
3271	"""
3272	Delete plugin models in app folder
3273
3274	:param path: path of the plugin_models folder in app
3275	"""
3276	# do it only the first time app loaded
3277	# delete unused model folder
3278	model_folder = os.path.join(get_app_dir(), path)
3279	if os.path.exists(model_folder) and os.path.isdir(model_folder):
3280	if len(os.listdir(model_folder)) > 0:
3281	try:
3282	for filename in os.listdir(model_folder):
3283	file_path = os.path.join(model_folder, filename)
3284	if os.path.isfile(file_path):
3285	os.remove(file_path)
3286	except:
3287	logger.error("gui_manager.clean_plugin_models:\n %s"
3288	% sys.exc_value)
3289
3290	def set_manager(self, manager):
3291	"""
3292	Sets a reference to the application manager
3293	of the GUI manager (Frame)
3294	"""
3295	self.frame.set_manager(manager)
3296
3297	def build_gui(self):
3298	"""
3299	Build the GUI
3300	"""
3301	# try to load file at the start
3302	self.open_file()
3303	self.frame.build_gui()
3304
3305	def set_welcome_panel(self, panel_class):
3306	"""
3307	Set the welcome panel
3308
3309	:param panel_class: class of the welcome panel to be instantiated
3310
3311	"""
3312	self.frame.welcome_panel_class = panel_class
3313
3314	def add_perspective(self, perspective):
3315	"""
3316	Manually add a perspective to the application GUI
3317	"""
3318	self.frame.add_perspective(perspective)
3319
3320	def window_placement(self, size):
3321	"""
3322	Determines the position and size of the application frame such that it
3323	fits on the user's screen without obstructing (or being obstructed by)
3324	the Windows task bar. The maximum initial size in pixels is bounded by
3325	WIDTH x HEIGHT. For most monitors, the application
3326	will be centered on the screen; for very large monitors it will be
3327	placed on the left side of the screen.
3328	"""
3329	is_maximized = False
3330	# Get size of screen without
3331	for screenCount in range(wx.Display().GetCount()):
3332	screen = wx.Display(screenCount)
3333	if screen.IsPrimary():
3334	displayRect = screen.GetClientArea()
3335	break
3336
3337	posX, posY, displayWidth, displayHeight = displayRect
3338	customWidth, customHeight = size
3339
3340	# If the custom size is default, set 90% of the screen size
3341	if customWidth <= 0 and customHeight <= 0:
3342	if customWidth == 0 and customHeight == 0:
3343	is_maximized = True
3344	customWidth = displayWidth * 0.9
3345	customHeight = displayHeight * 0.9
3346	else:
3347	# If the custom screen is bigger than the
3348	# window screen than make maximum size
3349	if customWidth > displayWidth:
3350	customWidth = displayWidth
3351	if customHeight > displayHeight:
3352	customHeight = displayHeight
3353
3354	# Note that when running Linux and using an Xming (X11) server on a PC
3355	# with a dual monitor configuration, the reported display size may be
3356	# that of both monitors combined with an incorrect display count of 1.
3357	# To avoid displaying this app across both monitors, we check for
3358	# screen 'too big'. If so, we assume a smaller width which means the
3359	# application will be placed towards the left hand side of the screen.
3360
3361	# If dual screen registered as 1 screen. Make width half.
3362	# MAC just follows the default behavior of pos
3363	if IS_WIN:
3364	if displayWidth > (displayHeight * 2):
3365	if customWidth == displayWidth:
3366	customWidth = displayWidth / 2
3367	# and set the position to be the corner of the screen.
3368	posX = 0
3369	posY = 0
3370
3371	# Make the position the middle of the screen. (Not 0,0)
3372	else:
3373	posX = (displayWidth - customWidth) / 2
3374	posY = (displayHeight - customHeight) / 2
3375	# Return the suggested position and size for the application frame.
3376	return (posX, posY), (customWidth, customHeight), is_maximized
3377
3378	def display_splash_screen(self, parent,
3379	path=SPLASH_SCREEN_PATH):
3380	"""Displays the splash screen. It will exactly cover the main frame."""
3381
3382	# Prepare the picture. On a 2GHz intel cpu, this takes about a second.
3383	image = wx.Image(path, wx.BITMAP_TYPE_PNG)
3384	image.Rescale(SPLASH_SCREEN_WIDTH,
3385	SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
3386	bm = image.ConvertToBitmap()
3387
3388	# Create and show the splash screen. It will disappear only when the
3389	# program has entered the event loop AND either the timeout has expired
3390	# or the user has left clicked on the screen. Thus any processing
3391	# performed in this routine (including sleeping) or processing in the
3392	# calling routine (including doing imports) will prevent the splash
3393	# screen from disappearing.
3394	#
3395	# Note that on Linux, the timeout appears to occur immediately in which
3396	# case the splash screen disappears upon entering the event loop.
3397	s_screen = wx.SplashScreen(bitmap=bm,
3398	splashStyle=(wx.SPLASH_TIMEOUT \|
3399	wx.SPLASH_CENTRE_ON_SCREEN),
3400	style=(wx.SIMPLE_BORDER \|
3401	wx.FRAME_NO_TASKBAR \|
3402	wx.FRAME_FLOAT_ON_PARENT),
3403	milliseconds=SS_MAX_DISPLAY_TIME,
3404	parent=parent,
3405	id=wx.ID_ANY)
3406	from sas.sasgui.guiframe.gui_statusbar import SPageStatusbar
3407	statusBar = SPageStatusbar(s_screen)
3408	s_screen.SetStatusBar(statusBar)
3409	s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
3410	s_screen.Show()
3411	return s_screen
3412
3413	def on_close_splash_screen(self, event):
3414	"""
3415	When the splash screen is closed.
3416	"""
3417	self.frame.Show(True)
3418	event.Skip()
3419	self.maximize_win()
3420
3421
3422	class MDIFrame(CHILD_FRAME):
3423	"""
3424	Frame for panels
3425	"""
3426	def __init__(self, parent, panel, title="Untitled", size=(300, 200)):
3427	"""
3428	comment
3429	:param parent: parent panel/container
3430	"""
3431	# Initialize the Frame object
3432	CHILD_FRAME.__init__(self, parent=parent, id=wx.ID_ANY,
3433	title=title, size=size)
3434	self.parent = parent
3435	self.name = "Untitled"
3436	self.batch_on = self.parent.batch_on
3437	self.panel = panel
3438	if panel is not None:
3439	self.set_panel(panel)
3440	self.Show(False)
3441
3442	def show_data_panel(self, action):
3443	"""
3444	Turns on the data panel
3445
3446	The the data panel is optional. Most of its functions can be
3447	performed from the menu bar and from the plots.
3448	"""
3449	self.parent.show_data_panel(action)
3450
3451	def set_panel(self, panel):
3452	"""
3453	"""
3454	self.panel = panel
3455	self.name = panel.window_name
3456	self.SetTitle(panel.window_caption)
3457	self.SetHelpText(panel.help_string)
3458	width, height = self.parent._get_panels_size(panel)
3459	if hasattr(panel, "CENTER_PANE") and panel.CENTER_PANE:
3460	width *= 0.6
3461	self.SetSize((width, height))
3462	self.parent.put_icon(self)
3463	self.Bind(wx.EVT_SET_FOCUS, self.set_panel_focus)
3464	self.Bind(wx.EVT_CLOSE, self.OnClose)
3465	self.Show(False)
3466
3467	def set_panel_focus(self, event):
3468	"""
3469	"""
3470	if self.parent.panel_on_focus != self.panel:
3471	self.panel.SetFocus()
3472	self.parent.panel_on_focus = self.panel
3473
3474	def OnClose(self, event):
3475	"""
3476	On Close event
3477	"""
3478	self.panel.on_close(event)
3479
3480	if __name__ == "__main__":
3481	app = SasViewApp(0)
3482	app.MainLoop()

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

SasView

source: sasview/src/sas/sasgui/guiframe/gui_manager.py @ bb008fd

Download in other formats: