gui_manager.py @ 009abcc

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

Last change on this file since 009abcc was 5f08251, checked in by smk78, 6 years ago
Removed old commented text
Property mode set to `100644`
File size: 125.2 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	# Pluralised both occurences of 'Tutorial' in the line below
1284	# S King, Sep 2018
1285	self._help_menu.Append(wx_id, '&Tutorials', 'Software tutorials')
1286	wx.EVT_MENU(self, wx_id, self._onTutorial)
1287
1288	if config._do_acknowledge:
1289	wx_id = wx.NewId()
1290	self._help_menu.Append(wx_id, '&Acknowledge',
1291	'Acknowledging SasView')
1292	wx.EVT_MENU(self, wx_id, self._onAcknowledge)
1293
1294	if config._do_aboutbox:
1295	logger.info("Doing help menu")
1296	wx_id = wx.NewId()
1297	self._help_menu.Append(wx_id, '&About', 'Software information')
1298	wx.EVT_MENU(self, wx_id, self._onAbout)
1299
1300	if config.marketplace_url:
1301	wx_id = wx.NewId()
1302	self._help_menu.Append(wx_id, '&Model marketplace', '')
1303	wx.EVT_MENU(self, wx_id, self._on_marketplace_click)
1304
1305	# Checking for updates
1306	wx_id = wx.NewId()
1307	self._help_menu.Append(wx_id, '&Check for update',
1308	'Check for the latest version of %s' %
1309	config.__appname__)
1310	wx.EVT_MENU(self, wx_id, self._check_update)
1311	self._menubar.Append(self._help_menu, '&Help')
1312
1313	def _add_menu_view(self):
1314	"""
1315	add menu items under view menu
1316	"""
1317	if not VIEW_MENU:
1318	return
1319	self._view_menu = wx.Menu()
1320
1321	wx_id = wx.NewId()
1322	hint = "Display the Grid Window for batch results etc."
1323	self._view_menu.Append(wx_id, '&Show Grid Window', hint)
1324	wx.EVT_MENU(self, wx_id, self.show_batch_frame)
1325
1326	self._view_menu.AppendSeparator()
1327	style = self.__gui_style & GUIFRAME.MANAGER_ON
1328	wx_id = wx.NewId()
1329	self._data_panel_menu = self._view_menu.Append(wx_id,
1330	'&Show Data Explorer',
1331	'')
1332	wx.EVT_MENU(self, wx_id, self.show_data_panel)
1333	if style == GUIFRAME.MANAGER_ON:
1334	self._data_panel_menu.SetText('Hide Data Explorer')
1335	else:
1336	self._data_panel_menu.SetText('Show Data Explorer')
1337
1338	self._view_menu.AppendSeparator()
1339	wx_id = wx.NewId()
1340	style1 = self.__gui_style & GUIFRAME.TOOLBAR_ON
1341	if style1 == GUIFRAME.TOOLBAR_ON:
1342	self._toolbar_menu = self._view_menu.Append(wx_id, '&Hide Toolbar',
1343	'')
1344	else:
1345	self._toolbar_menu = self._view_menu.Append(wx_id, '&Show Toolbar',
1346	'')
1347	wx.EVT_MENU(self, wx_id, self._on_toggle_toolbar)
1348
1349	if custom_config is not None:
1350	self._view_menu.AppendSeparator()
1351	wx_id = wx.NewId()
1352	hint_ss = "Select the current/default configuration "
1353	hint_ss += "as a startup setting"
1354	preference_menu = self._view_menu.Append(wx_id, 'Startup Setting',
1355	hint_ss)
1356	wx.EVT_MENU(self, wx_id, self._on_preference_menu)
1357
1358	wx_id = wx.NewId()
1359	self._view_menu.AppendSeparator()
1360	self._view_menu.Append(wx_id, 'Category Manager',
1361	'Edit model categories')
1362	wx.EVT_MENU(self, wx_id, self._on_category_manager)
1363
1364	self._menubar.Append(self._view_menu, '&View')
1365
1366	def show_batch_frame(self, event=None):
1367	"""
1368	show the grid of result
1369	"""
1370	# Show(False) before Show(True) in order to bring it to the front
1371	self.batch_frame.Show(False)
1372	self.batch_frame.Show(True)
1373
1374	def on_category_panel(self, event):
1375	"""
1376	On cat panel
1377	"""
1378	self._on_category_manager(event)
1379
1380	def _on_category_manager(self, event):
1381	"""
1382	Category manager frame
1383	"""
1384	frame = CategoryManager(self, -1, 'Model Category Manager')
1385	icon = self.GetIcon()
1386	frame.SetIcon(icon)
1387
1388	def _on_preference_menu(self, event):
1389	"""
1390	Build a panel to allow to edit Mask
1391	"""
1392	from sas.sasgui.guiframe.startup_configuration \
1393	import StartupConfiguration as ConfDialog
1394
1395	dialog = ConfDialog(parent=self, gui=self.__gui_style)
1396	result = dialog.ShowModal()
1397	if result == wx.ID_OK:
1398	dialog.write_custom_config()
1399	# post event for info
1400	wx.PostEvent(self, StatusEvent(status="Wrote custom configuration",
1401	info='info'))
1402	dialog.Destroy()
1403
1404	def _add_menu_application(self):
1405	"""
1406	# Attach a menu item for each defined perspective or application.
1407	# Only add the perspective menu if there are more than one perspectives
1408	add menu application
1409	"""
1410	if self._num_perspectives > 1:
1411	plug_data_count = False
1412	plug_no_data_count = False
1413	self._applications_menu = wx.Menu()
1414	pos = 0
1415	separator = self._applications_menu.AppendSeparator()
1416	for plug in self.plugins:
1417	if len(plug.get_perspective()) > 0:
1418	id = wx.NewId()
1419	if plug.use_data():
1420	self._applications_menu.InsertCheckItem(pos, id,
1421	plug.sub_menu,
1422	"Switch to analysis: %s" % plug.sub_menu)
1423	plug_data_count = True
1424	pos += 1
1425	else:
1426	plug_no_data_count = True
1427	self._applications_menu.AppendCheckItem(id,
1428	plug.sub_menu,
1429	"Switch to analysis: %s" % plug.sub_menu)
1430	wx.EVT_MENU(self, id, plug.on_perspective)
1431
1432	if not plug_data_count or not plug_no_data_count:
1433	self._applications_menu.RemoveItem(separator)
1434	# Windows introduces a "Window" menu item during the layout process
1435	# somehow. We want it to be next to the last item with Help as
1436	# last. However Analysis gets stuck after Window in normal ordering
1437	# so force it to be next after the Tools menu item. Should we add
1438	# another menu item will need to check if this is still where we
1439	# want Analysis. This is NOT an issue on the Mac which does not
1440	# have the extra Window menu item.
1441	# March 2016 Code Camp -- PDB
1442	Tools_pos = self._menubar.FindMenu("Tools")
1443	self._menubar.Insert(Tools_pos+1, self._applications_menu,
1444	'&Analysis')
1445	self._check_applications_menu()
1446
1447	def _populate_file_menu(self):
1448	"""
1449	Insert menu item under file menu
1450	"""
1451	for plugin in self.plugins:
1452	if len(plugin.populate_file_menu()) > 0:
1453	for item in plugin.populate_file_menu():
1454	m_name, m_hint, m_handler = item
1455	wx_id = wx.NewId()
1456	self._file_menu.Append(wx_id, m_name, m_hint)
1457	wx.EVT_MENU(self, wx_id, m_handler)
1458	self._file_menu.AppendSeparator()
1459
1460	style1 = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
1461	if OPEN_SAVE_MENU:
1462	wx_id = wx.NewId()
1463	hint_load_file = "read all analysis states saved previously"
1464	self._save_appl_menu = self._file_menu.Append(wx_id,
1465	'&Open Project',
1466	hint_load_file)
1467	wx.EVT_MENU(self, wx_id, self._on_open_state_project)
1468
1469	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1470	# some menu of plugin to be seen under file menu
1471	hint_load_file = "Read a status files and load"
1472	hint_load_file += " them into the analysis"
1473	wx_id = wx.NewId()
1474	self._save_appl_menu = self._file_menu.Append(wx_id,
1475	'&Open Analysis',
1476	hint_load_file)
1477	wx.EVT_MENU(self, wx_id, self._on_open_state_application)
1478	if OPEN_SAVE_MENU:
1479	self._file_menu.AppendSeparator()
1480	wx_id = wx.NewId()
1481	self._file_menu.Append(wx_id, '&Save Project',
1482	'Save the state of the whole analysis')
1483	wx.EVT_MENU(self, wx_id, self._on_save_project)
1484	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1485	wx_id = wx.NewId()
1486	txt = '&Save Analysis'
1487	txt2 = 'Save state of the current active analysis panel'
1488	self._save_appl_menu = self._file_menu.Append(wx_id, txt, txt2)
1489	wx.EVT_MENU(self, wx_id, self._on_save_application)
1490	if not sys.platform == 'darwin':
1491	self._file_menu.AppendSeparator()
1492	wx_id = wx.NewId()
1493	self._file_menu.Append(wx_id, '&Quit', 'Exit')
1494	wx.EVT_MENU(self, wx_id, self.Close)
1495
1496	def _add_menu_file(self):
1497	"""
1498	add menu file
1499	"""
1500	# File menu
1501	self._file_menu = wx.Menu()
1502	# Add sub menus
1503	self._menubar.Append(self._file_menu, '&File')
1504
1505	def _add_menu_edit(self):
1506	"""
1507	add menu edit
1508	"""
1509	if not EDIT_MENU:
1510	return
1511	# Edit Menu
1512	self._edit_menu = wx.Menu()
1513	self._edit_menu.Append(GUIFRAME_ID.UNDO_ID, '&Undo',
1514	'Undo the previous action')
1515	wx.EVT_MENU(self, GUIFRAME_ID.UNDO_ID, self.on_undo_panel)
1516	self._edit_menu.Append(GUIFRAME_ID.REDO_ID, '&Redo',
1517	'Redo the previous action')
1518	wx.EVT_MENU(self, GUIFRAME_ID.REDO_ID, self.on_redo_panel)
1519	self._edit_menu.AppendSeparator()
1520	self._edit_menu.Append(GUIFRAME_ID.COPY_ID, '&Copy Params',
1521	'Copy parameter values')
1522	wx.EVT_MENU(self, GUIFRAME_ID.COPY_ID, self.on_copy_panel)
1523	self._edit_menu.Append(GUIFRAME_ID.PASTE_ID, '&Paste Params',
1524	'Paste parameter values')
1525	wx.EVT_MENU(self, GUIFRAME_ID.PASTE_ID, self.on_paste_panel)
1526
1527	self._edit_menu.AppendSeparator()
1528
1529	self._edit_menu_copyas = wx.Menu()
1530	# Sub menu for Copy As...
1531	self._edit_menu_copyas.Append(GUIFRAME_ID.COPYEX_ID,
1532	'Copy current tab to Excel',
1533	'Copy parameter values in tabular format')
1534	wx.EVT_MENU(self, GUIFRAME_ID.COPYEX_ID, self.on_copy_panel)
1535
1536	self._edit_menu_copyas.Append(GUIFRAME_ID.COPYLAT_ID,
1537	'Copy current tab to LaTeX',
1538	'Copy parameter values in tabular format')
1539	wx.EVT_MENU(self, GUIFRAME_ID.COPYLAT_ID, self.on_copy_panel)
1540
1541	self._edit_menu.AppendMenu(GUIFRAME_ID.COPYAS_ID, 'Copy Params as...',
1542	self._edit_menu_copyas,
1543	'Copy parameter values in various formats')
1544
1545	self._edit_menu.AppendSeparator()
1546
1547	self._edit_menu.Append(GUIFRAME_ID.PREVIEW_ID, '&Report Results',
1548	'Preview current panel')
1549	wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel)
1550
1551	self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset Page',
1552	'Reset current panel')
1553	wx.EVT_MENU(self, GUIFRAME_ID.RESET_ID, self.on_reset_panel)
1554
1555	self._menubar.Append(self._edit_menu, '&Edit')
1556	self.enable_edit_menu()
1557
1558	def get_style(self):
1559	"""
1560	Return the gui style
1561	"""
1562	return self.__gui_style
1563
1564	def _add_menu_data(self):
1565	"""
1566	Add menu item item data to menu bar
1567	"""
1568	if self._data_plugin is not None:
1569	menu_list = self._data_plugin.populate_menu(self)
1570	if menu_list:
1571	for (menu, name) in menu_list:
1572	self._menubar.Append(menu, name)
1573
1574	def _on_toggle_toolbar(self, event=None):
1575	"""
1576	hide or show toolbar
1577	"""
1578	if self._toolbar is None:
1579	return
1580	if self._toolbar.IsShown():
1581	if self._toolbar_menu is not None:
1582	self._toolbar_menu.SetItemLabel('Show Toolbar')
1583	self._toolbar.Hide()
1584	else:
1585	if self._toolbar_menu is not None:
1586	self._toolbar_menu.SetItemLabel('Hide Toolbar')
1587	self._toolbar.Show()
1588	self._toolbar.Realize()
1589
1590	def _on_status_event(self, evt):
1591	"""
1592	Display status message
1593	"""
1594	# This CallAfter fixes many crashes on MAC.
1595	wx.CallAfter(self.sb.set_status, evt)
1596
1597	def on_view(self, evt):
1598	"""
1599	A panel was selected to be shown. If it's not already
1600	shown, display it.
1601
1602	:param evt: menu event
1603
1604	"""
1605	panel_id = str(evt.GetId())
1606	self.on_set_plot_focus(self.panels[panel_id])
1607	wx.CallLater(5 * TIME_FACTOR, self.set_schedule(True))
1608	self.set_plot_unfocus()
1609
1610	def show_welcome_panel(self, event):
1611	"""
1612	Display the welcome panel
1613	"""
1614	if self.defaultPanel is None:
1615	return
1616	frame = self.panels['default'].get_frame()
1617	if frame is None:
1618	return
1619	# Show default panel
1620	if not frame.IsShown():
1621	frame.Show(True)
1622
1623	def on_close_welcome_panel(self):
1624	"""
1625	Close the welcome panel
1626	"""
1627	if self.defaultPanel is None:
1628	return
1629	default_panel = self.panels["default"].frame
1630	if default_panel.IsShown():
1631	default_panel.Show(False)
1632
1633	def delete_panel(self, uid):
1634	"""
1635	delete panel given uid
1636	"""
1637	ID = str(uid)
1638	config.printEVT("delete_panel: %s" % ID)
1639	if ID in self.panels.keys():
1640	self.panel_on_focus = None
1641	panel = self.panels[ID]
1642
1643	if hasattr(panel, "connect"):
1644	panel.connect.disconnect()
1645	self._plotting_plugin.delete_panel(panel.group_id)
1646
1647	if panel in self.schedule_full_draw_list:
1648	self.schedule_full_draw_list.remove(panel)
1649
1650	# delete uid number not str(uid)
1651	if ID in self.plot_panels.keys():
1652	del self.plot_panels[ID]
1653	if ID in self.panels.keys():
1654	del self.panels[ID]
1655	else:
1656	logger.error("delete_panel: No such plot id as %s" % ID)
1657
1658	def create_gui_data(self, data, path=None):
1659	"""
1660	"""
1661	return self._data_manager.create_gui_data(data, path)
1662
1663	def get_data(self, path):
1664	"""
1665	"""
1666	log_msg = ''
1667	basename = os.path.basename(path)
1668	_, extension = os.path.splitext(basename)
1669	if extension.lower() not in EXTENSIONS:
1670	log_msg = "File Loader cannot "
1671	log_msg += "load: %s\n" % str(basename)
1672	log_msg += "Try Data opening...."
1673	logger.error(log_msg)
1674	return
1675
1676	# reading a state file
1677	for plug in self.plugins:
1678	reader, ext = plug.get_extensions()
1679	if reader is not None:
1680	# read the state of the single plugin
1681	if extension == ext:
1682	reader.read(path)
1683	return
1684	elif extension == APPLICATION_STATE_EXTENSION:
1685	try:
1686	reader.read(path)
1687	except:
1688	msg = "DataLoader Error: Encounted Non-ASCII character"
1689	msg += "\n(%s)" % sys.exc_value
1690	wx.PostEvent(self, StatusEvent(status=msg,
1691	info="error",
1692	type="stop"))
1693	return
1694
1695	style = self.__gui_style & GUIFRAME.MANAGER_ON
1696	if style == GUIFRAME.MANAGER_ON:
1697	if self._data_panel is not None:
1698	self._data_panel.frame.Show(True)
1699
1700	def load_from_cmd(self, path):
1701	"""
1702	load data from cmd or application
1703	"""
1704	if path is None:
1705	return
1706	else:
1707	path = os.path.abspath(path)
1708	if not os.path.isfile(path) and not os.path.isdir(path):
1709	return
1710
1711	if os.path.isdir(path):
1712	self.load_folder(path)
1713	return
1714
1715	basename = os.path.basename(path)
1716	_, extension = os.path.splitext(basename)
1717	if extension.lower() not in EXTENSIONS:
1718	self.load_data(path)
1719	else:
1720	self.load_state(path)
1721
1722	self._default_save_location = os.path.dirname(path)
1723
1724	def load_state(self, path, is_project=False):
1725	"""
1726	load data from command line or application
1727	"""
1728	if path and (path is not None) and os.path.isfile(path):
1729	basename = os.path.basename(path)
1730	if APPLICATION_STATE_EXTENSION is not None \
1731	and basename.endswith(APPLICATION_STATE_EXTENSION):
1732	if is_project:
1733	for ID in self.plot_panels.keys():
1734	panel = self.plot_panels[ID]
1735	panel.on_close(None)
1736	self.get_data(path)
1737	wx.PostEvent(self, StatusEvent(status="Completed loading."))
1738	else:
1739	wx.PostEvent(self, StatusEvent(status=" "))
1740
1741	def load_data(self, path):
1742	"""
1743	load data from command line
1744	"""
1745	if not os.path.isfile(path):
1746	return
1747	basename = os.path.basename(path)
1748	_, extension = os.path.splitext(basename)
1749	if extension.lower() in EXTENSIONS:
1750	log_msg = "Data Loader cannot "
1751	log_msg += "load: %s\n" % str(path)
1752	log_msg += "Try File opening ...."
1753	logger.error(log_msg)
1754	return
1755	log_msg = ''
1756	output = {}
1757	error_message = ""
1758	try:
1759	logger.info("Loading Data...:\n" + str(path) + "\n")
1760	temp = self.loader.load(path)
1761	if temp.__class__.__name__ == "list":
1762	for item in temp:
1763	data = self.create_gui_data(item, path)
1764	output[data.id] = data
1765	else:
1766	data = self.create_gui_data(temp, path)
1767	output[data.id] = data
1768
1769	self.add_data(data_list=output)
1770	except:
1771	error_message = "Error while loading"
1772	error_message += " Data from cmd:\n %s\n" % str(path)
1773	error_message += str(sys.exc_value) + "\n"
1774	logger.error(error_message)
1775
1776	def load_folder(self, path):
1777	"""
1778	Load entire folder
1779	"""
1780	if not os.path.isdir(path):
1781	return
1782	if self._data_plugin is None:
1783	return
1784	try:
1785	if path is not None:
1786	self._default_save_location = os.path.dirname(path)
1787	file_list = self._data_plugin.get_file_path(path)
1788	self._data_plugin.get_data(file_list)
1789	else:
1790	return
1791	except:
1792	error_message = "Error while loading"
1793	error_message += " Data folder from cmd:\n %s\n" % str(path)
1794	error_message += str(sys.exc_value) + "\n"
1795	logger.error(error_message)
1796
1797	def _on_open_state_application(self, event):
1798	"""
1799	"""
1800	path = None
1801	if self._default_save_location is None:
1802	self._default_save_location = os.getcwd()
1803	wx.PostEvent(self, StatusEvent(status="Loading Analysis file..."))
1804	plug_wlist = self._on_open_state_app_helper()
1805	dlg = wx.FileDialog(self,
1806	"Choose a file",
1807	self._default_save_location, "",
1808	plug_wlist)
1809	if dlg.ShowModal() == wx.ID_OK:
1810	path = dlg.GetPath()
1811	if path is not None:
1812	self._default_save_location = os.path.dirname(path)
1813	dlg.Destroy()
1814	self.load_state(path=path)
1815
1816	def _on_open_state_app_helper(self):
1817	"""
1818	Helps '_on_open_state_application()' to find the extension of
1819	the current perspective/application
1820	"""
1821	# No current perspective or no extension attr
1822	if self._current_perspective is None:
1823	return PLUGINS_WLIST
1824	try:
1825	# Find the extension of the perspective
1826	# and get that as 1st item in list
1827	ind = None
1828	app_ext = self._current_perspective._extensions
1829	plug_wlist = config.PLUGINS_WLIST
1830	for ext in set(plug_wlist):
1831	if ext.count(app_ext) > 0:
1832	ind = ext
1833	break
1834	# Found the extension
1835	if ind is not None:
1836	plug_wlist.remove(ind)
1837	plug_wlist.insert(0, ind)
1838	try:
1839	plug_wlist = '\|'.join(plug_wlist)
1840	except:
1841	plug_wlist = ''
1842
1843	except:
1844	plug_wlist = PLUGINS_WLIST
1845
1846	return plug_wlist
1847
1848	def _on_open_state_project(self, event):
1849	"""
1850	Load in a .svs project file after removing all data from SasView
1851	"""
1852	path = None
1853	if self._default_save_location is None:
1854	self._default_save_location = os.getcwd()
1855	msg = "This operation will set remove all data, plots and analyses from"
1856	msg += " SasView before loading the project. Do you wish to continue?"
1857	msg_box = wx.MessageDialog(None, msg, 'Warning', wx.OK \| wx.CANCEL)
1858	if msg_box.ShowModal() == wx.ID_OK:
1859	self._data_panel.selection_cbox.SetValue('Select all Data')
1860	self._data_panel._on_selection_type(None)
1861	for _, theory_dict in self._data_panel.list_cb_theory.iteritems():
1862	for key, value in theory_dict.iteritems():
1863	item, _, _ = value
1864	item.Check(True)
1865
1866	wx.PostEvent(self, StatusEvent(status="Loading Project file..."))
1867	dlg = wx.FileDialog(self, "Choose a file",
1868	self._default_save_location, "",
1869	APPLICATION_WLIST)
1870	if dlg.ShowModal() == wx.ID_OK:
1871	path = dlg.GetPath()
1872	if path is not None:
1873	self._default_save_location = os.path.dirname(path)
1874	dlg.Destroy()
1875	# Reset to a base state
1876	self._on_reset_state()
1877	self._data_panel.on_remove(None, False)
1878	# Load the project file
1879	self.load_state(path=path, is_project=True)
1880
1881	def _on_reset_state(self):
1882	"""
1883	Resets SasView to its freshly opened state.
1884	:return: None
1885	"""
1886	# Reset all plugins to their base state
1887	self._data_panel.set_panel_on_focus()
1888	# Remove all loaded data
1889	for plugin in self.plugins:
1890	plugin.clear_panel()
1891	# Reset plot number to 0
1892	self.graph_num = 0
1893
1894	def _on_save_application(self, event):
1895	"""
1896	save the state of the current active application
1897	"""
1898	if self.cpanel_on_focus is not None:
1899	try:
1900	wx.PostEvent(self,
1901	StatusEvent(status="Saving Analysis file..."))
1902	self.cpanel_on_focus.on_save(event)
1903	wx.PostEvent(self,
1904	StatusEvent(status="Completed saving."))
1905	except Exception:
1906	msg = "Error occurred while saving: "
1907	msg += traceback.format_exc()
1908	msg += "To save, the application panel should have a data set.."
1909	wx.PostEvent(self, StatusEvent(status=msg))
1910
1911	def _on_save_project(self, event):
1912	"""
1913	save the state of the SasView as *.svs
1914	"""
1915	if self._current_perspective is None:
1916	return
1917	wx.PostEvent(self, StatusEvent(status="Saving Project file..."))
1918	path = None
1919	extension = '*' + APPLICATION_STATE_EXTENSION
1920	dlg = wx.FileDialog(self, "Save Project file",
1921	self._default_save_location, "sasview_proj",
1922	extension,
1923	wx.SAVE)
1924	if dlg.ShowModal() == wx.ID_OK:
1925	path = dlg.GetPath()
1926	self._default_save_location = os.path.dirname(path)
1927	else:
1928	return None
1929	dlg.Destroy()
1930	try:
1931	if path is None:
1932	return
1933	# default cansas xml doc
1934	doc = None
1935	for panel in self.panels.values():
1936	temp = panel.save_project(doc)
1937	if temp is not None:
1938	doc = temp
1939
1940	# Write the XML document
1941	extens = APPLICATION_STATE_EXTENSION
1942	fName = os.path.splitext(path)[0] + extens
1943	if doc is not None:
1944	fd = open(fName, 'w')
1945	fd.write(doc.toprettyxml())
1946	fd.close()
1947	wx.PostEvent(self, StatusEvent(status="Completed Saving."))
1948	else:
1949	msg = "Error occurred while saving the project: "
1950	msg += "To save, at least one application panel "
1951	msg += "should have a data set "
1952	msg += "and model selected. "
1953	msg += "No project was saved to %s" % (str(path))
1954	logger.warning(msg)
1955	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1956	except Exception:
1957	msg = "Error occurred while saving: "
1958	msg += traceback.format_exc()
1959	msg += "To save, at least one application panel "
1960	msg += "should have a data set.."
1961	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1962
1963	def on_save_helper(self, doc, reader, panel, path):
1964	"""
1965	Save state into a file
1966	"""
1967	if reader is not None:
1968	# case of a panel with multi-pages
1969	if hasattr(panel, "opened_pages"):
1970	for _, page in panel.opened_pages.iteritems():
1971	data = page.get_data()
1972	# state must be cloned
1973	state = page.get_state().clone()
1974	if data is not None:
1975	new_doc = reader.write_toXML(data, state)
1976	if doc is not None and hasattr(doc, "firstChild"):
1977	child = new_doc.firstChild.firstChild
1978	doc.firstChild.appendChild(child)
1979	else:
1980	doc = new_doc
1981	# case of only a panel
1982	else:
1983	data = panel.get_data()
1984	state = panel.get_state()
1985	if data is not None:
1986	new_doc = reader.write_toXML(data, state)
1987	if doc is not None and hasattr(doc, "firstChild"):
1988	child = new_doc.firstChild.firstChild
1989	doc.firstChild.appendChild(child)
1990	else:
1991	doc = new_doc
1992	return doc
1993
1994	def quit_guiframe(self):
1995	"""
1996	Pop up message to make sure the user wants to quit the application
1997	"""
1998	message = "\nDo you really want to exit this application? \n\n"
1999	dial = wx.MessageDialog(self, message, 'Confirm Exit',
2000	wx.YES_NO \| wx.YES_DEFAULT \| wx.ICON_QUESTION)
2001	if dial.ShowModal() == wx.ID_YES:
2002	return True
2003	else:
2004	return False
2005
2006	def WindowClose(self, event=None):
2007	"""
2008	Quit the application from x icon
2009	"""
2010	flag = self.quit_guiframe()
2011	if flag:
2012	_pylab_helpers.Gcf.figs = {}
2013	self.Close()
2014
2015	def Close(self, event=None):
2016	"""
2017	Quit the application
2018	"""
2019	#IF SAS_OPENCL is set, settings are stored in the custom config file
2020	self._write_opencl_config_file()
2021	logger.info(" --- SasView session was closed --- \n")
2022	wx.Exit()
2023	sys.exit()
2024
2025	def _write_opencl_config_file(self):
2026	"""
2027	Writes OpenCL settings to custom config file, so they can be remmbered
2028	from session to session
2029	"""
2030	if custom_config is not None:
2031	sas_opencl = os.environ.get("SAS_OPENCL")
2032	new_config_lines = []
2033	config_file = open(custom_config.__file__)
2034	config_lines = config_file.readlines()
2035	for line in config_lines:
2036	if "SAS_OPENCL" in line:
2037	if sas_opencl:
2038	new_config_lines.append("SAS_OPENCL = \"" + sas_opencl
2039	+ "\"\n")
2040	else:
2041	new_config_lines.append("SAS_OPENCL = \"None\"\n")
2042	else:
2043	new_config_lines.append(line)
2044	config_file.close()
2045
2046	#If custom_config is None, settings will not be remmbered
2047	new_config_file = open(custom_config.__file__,"w")
2048	new_config_file.writelines(new_config_lines)
2049	new_config_file.close()
2050	else:
2051	logger.info("Failed to save OPENCL settings in custom config file")
2052
2053
2054	def _check_update(self, event=None):
2055	"""
2056	Check with the deployment server whether a new version
2057	of the application is available.
2058	A thread is started for the connecting with the server. The thread calls
2059	a call-back method when the current version number has been obtained.
2060	"""
2061	version_info = {"version": "0.0.0"}
2062	c = Connection(config.__update_URL__, config.UPDATE_TIMEOUT)
2063	response = c.connect()
2064	if response is not None:
2065	try:
2066	content = response.read().strip()
2067	logger.info("Connected to www.sasview.org. Latest version: %s", content)
2068	version_info = json.loads(content)
2069	except:
2070	logger.info("Failed to connect to www.sasview.org")
2071	self._process_version(version_info, standalone=event is None)
2072
2073
2074	def _process_version(self, version_info, standalone=True):
2075	"""
2076	Call-back method for the process of checking for updates.
2077	This methods is called by a VersionThread object once the current
2078	version number has been obtained. If the check is being done in the
2079	background, the user will not be notified unless there's an update.
2080
2081	:param version: version string
2082	:param standalone: True of the update is being checked in
2083	the background, False otherwise.
2084
2085	"""
2086	try:
2087	version = version_info["version"]
2088	if version == "0.0.0":
2089	msg = "Could not connect to the application server."
2090	msg += " Please try again later."
2091	self.SetStatusText(msg)
2092	elif cmp(version, config.__version__) > 0:
2093	msg = "Version %s is available! " % str(version)
2094	if not standalone:
2095	import webbrowser
2096	if "download_url" in version_info:
2097	webbrowser.open(version_info["download_url"])
2098	else:
2099	webbrowser.open(config.__download_page__)
2100	else:
2101	msg += "See the help menu to download it."
2102	self.SetStatusText(msg)
2103	else:
2104	if not standalone:
2105	msg = "You have the latest version"
2106	msg += " of %s" % str(config.__appname__)
2107	self.SetStatusText(msg)
2108	except:
2109	msg = "guiframe: could not get latest application"
2110	msg += " version number\n %s" % sys.exc_value
2111	logger.error(msg)
2112	if not standalone:
2113	msg = "Could not connect to the application server."
2114	msg += " Please try again later."
2115	self.SetStatusText(msg)
2116
2117	def _onAcknowledge(self, evt):
2118	"""
2119	Pop up the acknowledge dialog
2120
2121	:param evt: menu event
2122
2123	"""
2124	if config._do_acknowledge:
2125	import sas.sasgui.guiframe.acknowledgebox as AcknowledgeBox
2126	dialog = AcknowledgeBox.DialogAcknowledge(None, -1, "")
2127	dialog.ShowModal()
2128
2129	def _onAbout(self, evt):
2130	"""
2131	Pop up the about dialog
2132
2133	:param evt: menu event
2134
2135	"""
2136	if config._do_aboutbox:
2137	import sas.sasgui.guiframe.aboutbox as AboutBox
2138	dialog = AboutBox.DialogAbout(None, -1, "")
2139	dialog.ShowModal()
2140
2141	def _onTutorial(self, evt):
2142	"""
2143	Pop up the tutorial dialog
2144
2145	:param evt: menu event
2146
2147	"""
2148	# Action changed from that in 2.x/3.x/4.0.x/4.1.x
2149	# Help >> Tutorial used to bring up a pdf of the
2150	# original 2.x tutorial.
2151	# Code below, implemented from 4.2.0, redirects
2152	# action to the Tutorials page of the help
2153	# documentation to give access to all available
2154	# tutorials
2155	# S King, Sep 2018
2156
2157	from documentation_window import DocumentationWindow
2158	_TreeLocation = "user/tutorial.html"
2159	DocumentationWindow(self, -1, _TreeLocation, "",
2160	"SasView Documentation")
2161
2162	def _onSphinxDocs(self, evt):
2163	"""
2164	Bring up Sphinx Documentation at top level whenever the menu item
2165	'documentation' is clicked. Calls DocumentationWindow with the top
2166	level path of "index.html"
2167
2168	:param evt: menu event
2169	"""
2170	# Running SasView "in-place" using run.py means the docs will be in a
2171	# different place than they would otherwise.
2172	from documentation_window import DocumentationWindow
2173	_TreeLocation = "user/user.html"
2174	DocumentationWindow(self, -1, _TreeLocation, "",
2175	"SasView Documentation")
2176
2177	def set_manager(self, manager):
2178	"""
2179	Sets the application manager for this frame
2180
2181	:param manager: frame manager
2182	"""
2183	self.app_manager = manager
2184
2185	def post_init(self):
2186	"""
2187	This initialization method is called after the GUI
2188	has been created and all plug-ins loaded. It calls
2189	the post_init() method of each plug-in (if it exists)
2190	so that final initialization can be done.
2191	"""
2192	for item in self.plugins:
2193	if hasattr(item, "post_init"):
2194	item.post_init()
2195
2196	def set_perspective(self, panels):
2197	"""
2198	Sets the perspective of the GUI.
2199	Opens all the panels in the list, and closes
2200	all the others.
2201
2202	:param panels: list of panels
2203	"""
2204	for item in self.panels.keys():
2205	# Check whether this is a sticky panel
2206	if hasattr(self.panels[item], "ALWAYS_ON"):
2207	if self.panels[item].ALWAYS_ON:
2208	continue
2209	if self.panels[item] is None:
2210	continue
2211	if self.panels[item].window_name in panels:
2212	frame = self.panels[item].get_frame()
2213	if not frame.IsShown():
2214	frame.Show(True)
2215	else:
2216	# always show the data panel if enable
2217	style = self.__gui_style & GUIFRAME.MANAGER_ON
2218	if (style == GUIFRAME.MANAGER_ON) \
2219	and self.panels[item] == self._data_panel:
2220	if 'data_panel' in self.panels.keys():
2221	frame = self.panels['data_panel'].get_frame()
2222	if frame is None:
2223	continue
2224	flag = frame.IsShown()
2225	frame.Show(flag)
2226	else:
2227	frame = self.panels[item].get_frame()
2228	if frame is None:
2229	continue
2230
2231	if frame.IsShown():
2232	frame.Show(False)
2233
2234	def show_data_panel(self, event=None, action=True):
2235	"""
2236	show the data panel
2237	"""
2238	if self._data_panel_menu is None:
2239	return
2240	label = self._data_panel_menu.GetText()
2241	pane = self.panels["data_panel"]
2242	frame = pane.get_frame()
2243	if label == 'Show Data Explorer':
2244	if action:
2245	frame.Show(True)
2246	self.__gui_style = self.__gui_style \| GUIFRAME.MANAGER_ON
2247	self._data_panel_menu.SetText('Hide Data Explorer')
2248	else:
2249	if action:
2250	frame.Show(False)
2251	self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
2252	self._data_panel_menu.SetText('Show Data Explorer')
2253
2254	def add_data_helper(self, data_list):
2255	"""
2256	"""
2257	if self._data_manager is not None:
2258	self._data_manager.add_data(data_list)
2259
2260	def add_data(self, data_list):
2261	"""
2262	receive a dictionary of data from loader
2263	store them its data manager if possible
2264	send to data the current active perspective if the data panel
2265	is not active.
2266	:param data_list: dictionary of data's ID and value Data
2267	"""
2268	# Store data into manager
2269	self.add_data_helper(data_list)
2270	# set data in the data panel
2271	if self._data_panel is not None:
2272	data_state = self._data_manager.get_data_state(data_list.keys())
2273	self._data_panel.load_data_list(data_state)
2274	# if the data panel is shown wait for the user to press a button
2275	# to send data to the current perspective. if the panel is not
2276	# show automatically send the data to the current perspective
2277	style = self.__gui_style & GUIFRAME.MANAGER_ON
2278	if style == GUIFRAME.MANAGER_ON:
2279	# wait for button press from the data panel to set_data
2280	if self._data_panel is not None:
2281	self._data_panel.frame.Show(True)
2282	else:
2283	# automatically send that to the current perspective
2284	self.set_data(data_id=data_list.keys())
2285
2286	def set_data(self, data_id, theory_id=None):
2287	"""
2288	set data to current perspective
2289	"""
2290	list_data, _ = self._data_manager.get_by_id(data_id)
2291	if self._current_perspective is not None:
2292	self._current_perspective.set_data(list_data.values())
2293
2294	else:
2295	msg = "Guiframe does not have a current perspective"
2296	logger.info(msg)
2297
2298	def set_theory(self, state_id, theory_id=None):
2299	"""
2300	"""
2301	_, list_theory = self._data_manager.get_by_id(theory_id)
2302	if self._current_perspective is not None:
2303	try:
2304	self._current_perspective.set_theory(list_theory.values())
2305	except:
2306	msg = "Guiframe set_theory: \n" + str(sys.exc_value)
2307	logger.info(msg)
2308	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
2309	else:
2310	msg = "Guiframe does not have a current perspective"
2311	logger.info(msg)
2312
2313	def plot_data(self, state_id, data_id=None,
2314	theory_id=None, append=False):
2315	"""
2316	send a list of data to plot
2317	"""
2318	data_list, _ = self._data_manager.get_by_id(data_id)
2319	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
2320	total_plot_list = data_list.values()
2321	for item in temp_list_theory.values():
2322	theory_data, theory_state = item
2323	total_plot_list.append(theory_data)
2324	GROUP_ID = wx.NewId()
2325	for new_plot in total_plot_list:
2326	if append:
2327	if self.panel_on_focus is None:
2328	message = "cannot append plot. No plot panel on focus!"
2329	message += "please click on any available plot to set focus"
2330	wx.PostEvent(self, StatusEvent(status=message,
2331	info='warning'))
2332	return
2333	else:
2334	if self.enable_add_data(new_plot):
2335	new_plot.group_id = self.panel_on_focus.group_id
2336	else:
2337	message = "Only 1D Data can be append to"
2338	message += " plot panel containing 1D data.\n"
2339	message += "%s not be appended.\n" % str(new_plot.name)
2340	message += "try new plot option.\n"
2341	wx.PostEvent(self, StatusEvent(status=message,
2342	info='warning'))
2343	else:
2344	# if not append then new plot
2345	from sas.sasgui.guiframe.dataFitting import Data2D
2346	if issubclass(Data2D, new_plot.__class__):
2347	# for 2 D always plot in a separated new plot
2348	new_plot.group_id = wx.NewId()
2349	else:
2350	# plot all 1D in a new plot
2351	new_plot.group_id = GROUP_ID
2352	title = "PLOT " + str(new_plot.title)
2353	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
2354	title=title,
2355	group_id=new_plot.group_id))
2356
2357	def remove_data(self, data_id, theory_id=None):
2358	"""
2359	Delete data state if data_id is provide
2360	delete theory created with data of id data_id if theory_id is provide
2361	if delete all true: delete the all state
2362	else delete theory
2363	"""
2364	temp = data_id + theory_id
2365	for plug in self.plugins:
2366	plug.delete_data(temp)
2367	data_list, _ = self._data_manager.get_by_id(data_id)
2368	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
2369	total_plot_list = data_list.values()
2370	for item in temp_list_theory.values():
2371	theory_data, theory_state = item
2372	total_plot_list.append(theory_data)
2373	for new_plot in total_plot_list:
2374	for group_id in new_plot.list_group_id:
2375	wx.PostEvent(self, NewPlotEvent(id=new_plot.id,
2376	group_id=group_id,
2377	action='remove'))
2378	wx.CallAfter(self._remove_res_plot, new_plot.id)
2379	self._data_manager.delete_data(data_id=data_id,
2380	theory_id=theory_id)
2381
2382	def _remove_res_plot(self, id):
2383	"""
2384	Try to remove corresponding res plot
2385
2386	: param id: id of the data
2387	"""
2388	try:
2389	wx.PostEvent(self, NewPlotEvent(id=("res" + str(id)),
2390	group_id=("res" + str(id)),
2391	action='remove'))
2392	except:
2393	logger.error(sys.exc_value)
2394
2395	def save_data1d(self, data, fname):
2396	"""
2397	Save data dialog
2398	"""
2399	default_name = fname
2400	wildcard = "Text files (.txt)\|.txt\|"\
2401	"CanSAS 1D files(.xml)\|.xml"
2402	path = None
2403	dlg = wx.FileDialog(self, "Choose a file",
2404	self._default_save_location,
2405	default_name, wildcard, wx.SAVE)
2406
2407	if dlg.ShowModal() == wx.ID_OK:
2408	path = dlg.GetPath()
2409	# ext_num = 0 for .txt, ext_num = 1 for .xml
2410	# This is MAC Fix
2411	ext_num = dlg.GetFilterIndex()
2412	if ext_num == 0:
2413	ext_format = '.txt'
2414	else:
2415	ext_format = '.xml'
2416	path = os.path.splitext(path)[0] + ext_format
2417	mypath = os.path.basename(path)
2418
2419	# Instantiate a loader
2420	loader = Loader()
2421	ext_format = ".txt"
2422	if os.path.splitext(mypath)[1].lower() == ext_format:
2423	# Make sure the ext included in the file name
2424	# especially on MAC
2425	fName = os.path.splitext(path)[0] + ext_format
2426	self._onsaveTXT(data, fName)
2427	ext_format = ".xml"
2428	if os.path.splitext(mypath)[1].lower() == ext_format:
2429	# Make sure the ext included in the file name
2430	# especially on MAC
2431	fName = os.path.splitext(path)[0] + ext_format
2432	loader.save(fName, data, ext_format)
2433	try:
2434	self._default_save_location = os.path.dirname(path)
2435	except:
2436	pass
2437	dlg.Destroy()
2438
2439	def _onsaveTXT(self, data, path):
2440	"""
2441	Save file as txt
2442
2443	.. todo:: Refactor and remove this method. See 'TODO' in _onSave.
2444	"""
2445	if path is not None:
2446	out = open(path, 'w')
2447	has_errors = True
2448	if data.dy is None or data.dy == []:
2449	has_errors = False
2450	# Sanity check
2451	if has_errors:
2452	try:
2453	if len(data.y) != len(data.dy):
2454	has_errors = False
2455	except:
2456	has_errors = False
2457	if has_errors:
2458	if data.dx is not None and data.dx != []:
2459	out.write("<X> <Y> <dY> <dX>\n")
2460	else:
2461	out.write("<X> <Y> <dY>\n")
2462	else:
2463	out.write("<X> <Y>\n")
2464
2465	for i in range(len(data.x)):
2466	if has_errors:
2467	if data.dx is not None and data.dx != []:
2468	if data.dx[i] is not None:
2469	out.write("%g %g %g %g\n" % (data.x[i],
2470	data.y[i],
2471	data.dy[i],
2472	data.dx[i]))
2473	else:
2474	out.write("%g %g %g\n" % (data.x[i],
2475	data.y[i],
2476	data.dy[i]))
2477	else:
2478	out.write("%g %g %g\n" % (data.x[i],
2479	data.y[i],
2480	data.dy[i]))
2481	else:
2482	out.write("%g %g\n" % (data.x[i],
2483	data.y[i]))
2484	out.close()
2485
2486	def show_data1d(self, data, name):
2487	"""
2488	Show data dialog
2489	"""
2490	try:
2491	xmin = min(data.x)
2492	ymin = min(data.y)
2493	except:
2494	msg = "Unable to find min/max of \n data named %s" % \
2495	data.filename
2496	wx.PostEvent(self, StatusEvent(status=msg,
2497	info="error"))
2498	raise ValueError, msg
2499	# text = str(data)
2500	text = data.__str__()
2501	text += 'Data Min Max:\n'
2502	text += 'X_min = %s: X_max = %s\n' % (xmin, max(data.x))
2503	text += 'Y_min = %s: Y_max = %s\n' % (ymin, max(data.y))
2504	if data.dy is not None:
2505	text += 'dY_min = %s: dY_max = %s\n' % (min(data.dy), max(data.dy))
2506	text += '\nData Points:\n'
2507	x_st = "X"
2508	for index in range(len(data.x)):
2509	if data.dy is not None and len(data.dy) > index:
2510	dy_val = data.dy[index]
2511	else:
2512	dy_val = 0.0
2513	if data.dx is not None and len(data.dx) > index:
2514	dx_val = data.dx[index]
2515	else:
2516	dx_val = 0.0
2517	if data.dxl is not None and len(data.dxl) > index:
2518	if index == 0:
2519	x_st = "Xl"
2520	dx_val = data.dxl[index]
2521	elif data.dxw is not None and len(data.dxw) > index:
2522	if index == 0:
2523	x_st = "Xw"
2524	dx_val = data.dxw[index]
2525
2526	if index == 0:
2527	text += "<index> \t<X> \t<Y> \t<dY> \t<d%s>\n" % x_st
2528	text += "%s \t%s \t%s \t%s \t%s\n" % (index,
2529	data.x[index],
2530	data.y[index],
2531	dy_val,
2532	dx_val)
2533	from pdfview import TextFrame
2534	frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2535	# put icon
2536	self.put_icon(frame)
2537	frame.Show(True)
2538
2539	def save_data2d(self, data, fname):
2540	"""
2541	Save data2d dialog
2542	"""
2543	default_name = fname
2544	wildcard = "IGOR/DAT 2D file in Q_map (.dat)\|.DAT"
2545	dlg = wx.FileDialog(self, "Choose a file",
2546	self._default_save_location,
2547	default_name, wildcard, wx.SAVE)
2548
2549	if dlg.ShowModal() == wx.ID_OK:
2550	path = dlg.GetPath()
2551	# ext_num = 0 for .txt, ext_num = 1 for .xml
2552	# This is MAC Fix
2553	ext_num = dlg.GetFilterIndex()
2554	if ext_num == 0:
2555	ext_format = '.dat'
2556	else:
2557	ext_format = ''
2558	path = os.path.splitext(path)[0] + ext_format
2559	mypath = os.path.basename(path)
2560
2561	# Instantiate a loader
2562	loader = Loader()
2563
2564	ext_format = ".dat"
2565	if os.path.splitext(mypath)[1].lower() == ext_format:
2566	# Make sure the ext included in the file name
2567	# especially on MAC
2568	fileName = os.path.splitext(path)[0] + ext_format
2569	loader.save(fileName, data, ext_format)
2570	try:
2571	self._default_save_location = os.path.dirname(path)
2572	except:
2573	pass
2574	dlg.Destroy()
2575
2576	def show_data2d(self, data, name):
2577	"""
2578	Show data dialog
2579	"""
2580	wx.PostEvent(self, StatusEvent(status="Gathering Data2D Info.",
2581	type='start'))
2582	text = data.__str__()
2583	text += 'Data Min Max:\n'
2584	text += 'I_min = %s\n' % min(data.data)
2585	text += 'I_max = %s\n\n' % max(data.data)
2586	text += 'Data (First 2501) Points:\n'
2587	text += 'Data columns include err(I).\n'
2588	text += 'ASCII data starts here.\n'
2589	text += "<index> \t<Qx> \t<Qy> \t<I> \t<dI> \t<dQparal> \t<dQperp>\n"
2590	di_val = 0.0
2591	dx_val = 0.0
2592	dy_val = 0.0
2593	len_data = len(data.qx_data)
2594	for index in xrange(0, len_data):
2595	x_val = data.qx_data[index]
2596	y_val = data.qy_data[index]
2597	i_val = data.data[index]
2598	if data.err_data is not None:
2599	di_val = data.err_data[index]
2600	if data.dqx_data is not None:
2601	dx_val = data.dqx_data[index]
2602	if data.dqy_data is not None:
2603	dy_val = data.dqy_data[index]
2604
2605	text += "%s \t%s \t%s \t%s \t%s \t%s \t%s\n" % (index,
2606	x_val,
2607	y_val,
2608	i_val,
2609	di_val,
2610	dx_val,
2611	dy_val)
2612	# Takes too long time for typical data2d: Break here
2613	if index >= 2500:
2614	text += ".............\n"
2615	break
2616
2617	from pdfview import TextFrame
2618	frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2619	# put icon
2620	self.put_icon(frame)
2621	frame.Show(True)
2622	wx.PostEvent(self, StatusEvent(status="Data2D Info Displayed",
2623	type='stop'))
2624
2625	def set_current_perspective(self, perspective):
2626	"""
2627	set the current active perspective
2628	"""
2629	self._current_perspective = perspective
2630	name = "No current analysis selected"
2631	if self._current_perspective is not None:
2632	self._add_current_plugin_menu()
2633	for panel in self.panels.values():
2634	if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
2635	for name in self._current_perspective.get_perspective():
2636	frame = panel.get_frame()
2637	if frame is not None:
2638	if name == panel.window_name:
2639	panel.on_set_focus(event=None)
2640	frame.Show(True)
2641	else:
2642	frame.Show(False)
2643	name = self._current_perspective.sub_menu
2644	if self._data_panel is not None:
2645	self._data_panel.set_active_perspective(name)
2646	self._check_applications_menu()
2647	# Set the SasView title
2648	self._set_title_name(name)
2649
2650	def _set_title_name(self, name):
2651	"""
2652	Set the SasView title w/ the current application name
2653
2654	: param name: application name [string]
2655	"""
2656	# Set SanView Window title w/ application anme
2657	title = self.title + " - " + name + " -"
2658	self.SetTitle(title)
2659
2660	def _check_applications_menu(self):
2661	"""
2662	check the menu of the current application
2663	"""
2664	if self._applications_menu is not None:
2665	for menu in self._applications_menu.GetMenuItems():
2666	if self._current_perspective is not None:
2667	name = self._current_perspective.sub_menu
2668	if menu.IsCheckable():
2669	if menu.GetLabel() == name:
2670	menu.Check(True)
2671	else:
2672	menu.Check(False)
2673
2674	def enable_add_data(self, new_plot):
2675	"""
2676	Enable append data on a plot panel
2677	"""
2678
2679	if self.panel_on_focus \
2680	not in self._plotting_plugin.plot_panels.values():
2681	return
2682	check = "Theory1D"
2683	is_theory = len(self.panel_on_focus.plots) <= 1 and \
2684	self.panel_on_focus.plots.values()[0].__class__.__name__ == check
2685
2686	is_data2d = hasattr(new_plot, 'data')
2687
2688	is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
2689	and self.panel_on_focus.group_id is not None
2690	has_meta_data = hasattr(new_plot, 'meta_data')
2691
2692	# disable_add_data if the data is being recovered from a saved state
2693	is_state_data = False
2694	if has_meta_data:
2695	if 'invstate' in new_plot.meta_data:
2696	is_state_data = True
2697	if 'prstate' in new_plot.meta_data:
2698	is_state_data = True
2699	if 'fitstate' in new_plot.meta_data:
2700	is_state_data = True
2701
2702	return is_data1d and not is_data2d and not is_theory \
2703	and not is_state_data
2704
2705	def check_multimode(self, perspective=None):
2706	"""
2707	Check the perspective have batch mode capablitity
2708	"""
2709	if perspective is None or self._data_panel is None:
2710	return
2711	flag = perspective.get_batch_capable()
2712	flag_on = perspective.batch_on
2713	if flag:
2714	self._data_panel.rb_single_mode.SetValue(not flag_on)
2715	self._data_panel.rb_batch_mode.SetValue(flag_on)
2716	else:
2717	self._data_panel.rb_single_mode.SetValue(True)
2718	self._data_panel.rb_batch_mode.SetValue(False)
2719	self._data_panel.rb_single_mode.Enable(flag)
2720	self._data_panel.rb_batch_mode.Enable(flag)
2721
2722	def enable_edit_menu(self):
2723	"""
2724	enable menu item under edit menu depending on the panel on focus
2725	"""
2726	if self.cpanel_on_focus is not None and self._edit_menu is not None:
2727	flag = self.cpanel_on_focus.get_undo_flag()
2728	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2729	flag = self.cpanel_on_focus.get_redo_flag()
2730	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2731	flag = self.cpanel_on_focus.get_copy_flag()
2732	self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2733	flag = self.cpanel_on_focus.get_paste_flag()
2734	self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2735
2736	# Copy menu
2737	flag = self.cpanel_on_focus.get_copy_flag()
2738	self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYEX_ID, flag)
2739	self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYLAT_ID, flag)
2740
2741	flag = self.cpanel_on_focus.get_preview_flag()
2742	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2743	flag = self.cpanel_on_focus.get_reset_flag()
2744	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2745	else:
2746	flag = False
2747	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2748	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2749	self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2750	self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2751	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2752	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2753
2754	def on_undo_panel(self, event=None):
2755	"""
2756	undo previous action of the last panel on focus if possible
2757	"""
2758	if self.cpanel_on_focus is not None:
2759	self.cpanel_on_focus.on_undo(event)
2760
2761	def on_redo_panel(self, event=None):
2762	"""
2763	redo the last cancel action done on the last panel on focus
2764	"""
2765	if self.cpanel_on_focus is not None:
2766	self.cpanel_on_focus.on_redo(event)
2767
2768	def on_copy_panel(self, event=None):
2769	"""
2770	copy the last panel on focus if possible
2771	"""
2772	if self.cpanel_on_focus is not None:
2773	self.cpanel_on_focus.on_copy(event)
2774
2775	def on_paste_panel(self, event=None):
2776	"""
2777	paste clipboard to the last panel on focus
2778	"""
2779	if self.cpanel_on_focus is not None:
2780	self.cpanel_on_focus.on_paste(event)
2781
2782	def on_bookmark_panel(self, event=None):
2783	"""
2784	bookmark panel
2785	"""
2786	if self.cpanel_on_focus is not None:
2787	self.cpanel_on_focus.on_bookmark(event)
2788
2789	def append_bookmark(self, event=None):
2790	"""
2791	Bookmark available information of the panel on focus
2792	"""
2793	self._toolbar.append_bookmark(event)
2794
2795	def on_save_panel(self, event=None):
2796	"""
2797	save possible information on the current panel
2798	"""
2799	if self.cpanel_on_focus is not None:
2800	self.cpanel_on_focus.on_save(event)
2801
2802	def on_preview_panel(self, event=None):
2803	"""
2804	preview information on the panel on focus
2805	"""
2806	if self.cpanel_on_focus is not None:
2807	self.cpanel_on_focus.on_preview(event)
2808
2809	def on_print_panel(self, event=None):
2810	"""
2811	print available information on the last panel on focus
2812	"""
2813	if self.cpanel_on_focus is not None:
2814	self.cpanel_on_focus.on_print(event)
2815
2816	def on_zoom_panel(self, event=None):
2817	"""
2818	zoom on the current panel if possible
2819	"""
2820	if self.cpanel_on_focus is not None:
2821	self.cpanel_on_focus.on_zoom(event)
2822
2823	def on_zoom_in_panel(self, event=None):
2824	"""
2825	zoom in of the panel on focus
2826	"""
2827	if self.cpanel_on_focus is not None:
2828	self.cpanel_on_focus.on_zoom_in(event)
2829
2830	def on_zoom_out_panel(self, event=None):
2831	"""
2832	zoom out on the panel on focus
2833	"""
2834	if self.cpanel_on_focus is not None:
2835	self.cpanel_on_focus.on_zoom_out(event)
2836
2837	def on_drag_panel(self, event=None):
2838	"""
2839	drag apply to the panel on focus
2840	"""
2841	if self.cpanel_on_focus is not None:
2842	self.cpanel_on_focus.on_drag(event)
2843
2844	def on_reset_panel(self, event=None):
2845	"""
2846	reset the current panel
2847	"""
2848	if self.cpanel_on_focus is not None:
2849	self.cpanel_on_focus.on_reset(event)
2850
2851	def on_change_caption(self, name, old_caption, new_caption):
2852	"""
2853	Change the panel caption
2854
2855	:param name: window_name of the pane
2856	:param old_caption: current caption [string]
2857	:param new_caption: new caption [string]
2858	"""
2859	# wx.aui.AuiPaneInfo
2860	pane_info = self.get_paneinfo(old_caption)
2861	# update the data_panel.cb_plotpanel
2862	if 'data_panel' in self.panels.keys():
2863	# remove from data_panel combobox
2864	data_panel = self.panels["data_panel"]
2865	if data_panel.cb_plotpanel is not None:
2866	# Check if any panel has the same caption
2867	has_newstring = data_panel.cb_plotpanel.FindString(
2868	str(new_caption))
2869	caption = new_caption
2870	if has_newstring != wx.NOT_FOUND:
2871	captions = self._get_plotpanel_captions()
2872	# Append nummber
2873	inc = 1
2874	# FIXME: fix this terrible loop
2875	while (1):
2876	caption = new_caption + '_%s' % str(inc)
2877	if caption not in captions:
2878	break
2879	inc += 1
2880	# notify to users
2881	msg = "Found Same Title: Added '_%s'" % str(inc)
2882	wx.PostEvent(self, StatusEvent(status=msg))
2883	# update data_panel cb
2884	pos = data_panel.cb_plotpanel.FindString(str(old_caption))
2885	if pos != wx.NOT_FOUND:
2886	data_panel.cb_plotpanel.SetString(pos, caption)
2887	data_panel.cb_plotpanel.SetStringSelection(caption)
2888	# New Caption
2889	pane_info.SetTitle(caption)
2890	return caption
2891
2892	def get_paneinfo(self, name):
2893	"""
2894	Get pane Caption from window_name
2895
2896	:param name: window_name in AuiPaneInfo
2897	:returns: AuiPaneInfo of the name
2898	"""
2899	for panel in self.plot_panels.values():
2900	if panel.frame.GetTitle() == name:
2901	return panel.frame
2902	return None
2903
2904	def enable_undo(self):
2905	"""
2906	enable undo related control
2907	"""
2908	if self.cpanel_on_focus is not None:
2909	self._toolbar.enable_undo(self.cpanel_on_focus)
2910
2911	def enable_redo(self):
2912	"""
2913	enable redo
2914	"""
2915	if self.cpanel_on_focus is not None:
2916	self._toolbar.enable_redo(self.cpanel_on_focus)
2917
2918	def enable_copy(self):
2919	"""
2920	enable copy related control
2921	"""
2922	if self.cpanel_on_focus is not None:
2923	self._toolbar.enable_copy(self.cpanel_on_focus)
2924
2925	def enable_paste(self):
2926	"""
2927	enable paste
2928	"""
2929	if self.cpanel_on_focus is not None:
2930	self._toolbar.enable_paste(self.cpanel_on_focus)
2931
2932	def enable_bookmark(self):
2933	"""
2934	Bookmark
2935	"""
2936	if self.cpanel_on_focus is not None:
2937	self._toolbar.enable_bookmark(self.cpanel_on_focus)
2938
2939	def enable_save(self):
2940	"""
2941	save
2942	"""
2943	if self.cpanel_on_focus is not None:
2944	self._toolbar.enable_save(self.cpanel_on_focus)
2945
2946	def enable_preview(self):
2947	"""
2948	preview
2949	"""
2950	if self.cpanel_on_focus is not None:
2951	self._toolbar.enable_preview(self.cpanel_on_focus)
2952
2953	def enable_print(self):
2954	"""
2955	print
2956	"""
2957	if self.cpanel_on_focus is not None:
2958	self._toolbar.enable_print(self.cpanel_on_focus)
2959
2960	def enable_zoom(self):
2961	"""
2962	zoom
2963	"""
2964	if self.cpanel_on_focus is not None:
2965	self._toolbar.enable_zoom(self.panel_on_focus)
2966
2967	def enable_zoom_in(self):
2968	"""
2969	zoom in
2970	"""
2971	if self.cpanel_on_focus is not None:
2972	self._toolbar.enable_zoom_in(self.panel_on_focus)
2973
2974	def enable_zoom_out(self):
2975	"""
2976	zoom out
2977	"""
2978	if self.cpanel_on_focus is not None:
2979	self._toolbar.enable_zoom_out(self.panel_on_focus)
2980
2981	def enable_drag(self, event=None):
2982	"""
2983	drag
2984	"""
2985	# Not implemeted
2986
2987	def enable_reset(self):
2988	"""
2989	reset the current panel
2990	"""
2991	if self.cpanel_on_focus is not None:
2992	self._toolbar.enable_reset(self.panel_on_focus)
2993
2994	def get_toolbar_height(self):
2995	"""
2996	"""
2997	size_y = 0
2998	if self.GetToolBar() is not None and self.GetToolBar().IsShown():
2999	if not IS_LINUX:
3000	_, size_y = self.GetToolBar().GetSizeTuple()
3001	return size_y
3002
3003	def set_schedule_full_draw(self, panel=None, func='del'):
3004	"""
3005	Add/subtract the schedule full draw list with the panel given
3006
3007	:param panel: plot panel
3008	:param func: append or del [string]
3009	"""
3010
3011	# append this panel in the schedule list if not in yet
3012	if func == 'append':
3013	if panel not in self.schedule_full_draw_list:
3014	self.schedule_full_draw_list.append(panel)
3015	# remove this panel from schedule list
3016	elif func == 'del':
3017	if len(self.schedule_full_draw_list) > 0:
3018	if panel in self.schedule_full_draw_list:
3019	self.schedule_full_draw_list.remove(panel)
3020
3021	# reset the schdule
3022	if len(self.schedule_full_draw_list) == 0:
3023	self.schedule = False
3024	else:
3025	self.schedule = True
3026
3027	def full_draw(self):
3028	"""
3029	Draw the panels with axes in the schedule to full dwar list
3030	"""
3031
3032	count = len(self.schedule_full_draw_list)
3033	# if not self.schedule:
3034	if count < 1:
3035	self.set_schedule(False)
3036	return
3037
3038	else:
3039	ind = 0
3040	# if any of the panel is shown do full_draw
3041	for panel in self.schedule_full_draw_list:
3042	ind += 1
3043	if panel.frame.IsShown():
3044	break
3045	# otherwise, return
3046	if ind == count:
3047	return
3048	# Simple redraw only for a panel shown
3049
3050	def f_draw(panel):
3051	"""
3052	Draw A panel in the full draw list
3053	"""
3054	try:
3055	# This checking of GetCapture is to stop redrawing
3056	# while any panel is capture.
3057	frame = panel.frame
3058
3059	if not frame.GetCapture():
3060	# draw if possible
3061	panel.set_resizing(False)
3062	# panel.Show(True)
3063	panel.draw_plot()
3064	# Check if the panel is not shown
3065	flag = frame.IsShown()
3066	frame.Show(flag)
3067	except:
3068	pass
3069
3070	# Draw all panels
3071	if count == 1:
3072	f_draw(self.schedule_full_draw_list[0])
3073	else:
3074	map(f_draw, self.schedule_full_draw_list)
3075	# Reset the attr
3076	if len(self.schedule_full_draw_list) == 0:
3077	self.set_schedule(False)
3078	else:
3079	self.set_schedule(True)
3080
3081	def set_schedule(self, schedule=False):
3082	"""
3083	Set schedule
3084	"""
3085	self.schedule = schedule
3086
3087	def get_schedule(self):
3088	"""
3089	Get schedule
3090	"""
3091	return self.schedule
3092
3093	def on_set_plot_focus(self, panel):
3094	"""
3095	Set focus on a plot panel
3096	"""
3097	if panel is None:
3098	return
3099	# self.set_plot_unfocus()
3100	panel.on_set_focus(None)
3101	# set focusing panel
3102	self.panel_on_focus = panel
3103	self.set_panel_on_focus(None)
3104
3105	def set_plot_unfocus(self):
3106	"""
3107	Un focus all plot panels
3108	"""
3109	for plot in self.plot_panels.values():
3110	plot.on_kill_focus(None)
3111
3112	def get_window_size(self):
3113	"""
3114	Get window size
3115
3116	:returns: size
3117	:rtype: tuple
3118	"""
3119	width, height = self.GetSizeTuple()
3120	if not IS_WIN:
3121	# Subtract toolbar height to get real window side
3122	if self._toolbar.IsShown():
3123	height -= 45
3124	return (width, height)
3125
3126	def _onDrawIdle(self, args, *kwargs):
3127	"""
3128	ReDraw with axes
3129	"""
3130	try:
3131	# check if it is time to redraw
3132	if self.GetCapture() is None:
3133	# Draw plot, changes resizing too
3134	self.full_draw()
3135	except:
3136	pass
3137
3138	# restart idle
3139	self._redraw_idle(args, *kwargs)
3140
3141	def _redraw_idle(self, args, *kwargs):
3142	"""
3143	Restart Idle
3144	"""
3145	# restart idle
3146	self.idletimer.Restart(100 * TIME_FACTOR, args, *kwargs)
3147
3148
3149	class DefaultPanel(wx.Panel, PanelBase):
3150	"""
3151	Defines the API for a panels to work with
3152	the GUI manager
3153	"""
3154	# Internal nickname for the window, used by the AUI manager
3155	window_name = "default"
3156	# Name to appear on the window title bar
3157	window_caption = "Welcome panel"
3158	# Flag to tell the AUI manager to put this panel in the center pane
3159	CENTER_PANE = True
3160
3161	def __init__(self, parent, args, *kwds):
3162	wx.Panel.__init__(self, parent, args, *kwds)
3163	PanelBase.__init__(self, parent)
3164
3165
3166	class SasViewApp(wx.App):
3167	"""
3168	SasView application
3169	"""
3170	def OnInit(self):
3171	"""
3172	When initialised
3173	"""
3174	pos, size, self.is_max = self.window_placement((GUIFRAME_WIDTH,
3175	GUIFRAME_HEIGHT))
3176	self.frame = ViewerFrame(parent=None,
3177	title=APPLICATION_NAME,
3178	pos=pos,
3179	gui_style=DEFAULT_STYLE,
3180	size=size)
3181	self.frame.Hide()
3182	if not IS_WIN:
3183	self.frame.EnableCloseButton(False)
3184	self.s_screen = None
3185
3186	try:
3187	self.open_file()
3188	except:
3189	msg = "%s Could not load " % str(APPLICATION_NAME)
3190	msg += "input file from command line.\n"
3191	logger.error(msg)
3192	# Display a splash screen on top of the frame.
3193	try:
3194	if os.path.isfile(SPLASH_SCREEN_PATH):
3195	self.s_screen = \
3196	self.display_splash_screen(parent=self.frame,
3197	path=SPLASH_SCREEN_PATH)
3198	else:
3199	self.frame.Show()
3200	except:
3201	if self.s_screen is not None:
3202	self.s_screen.Close()
3203	msg = "Cannot display splash screen\n"
3204	msg += str(sys.exc_value)
3205	logger.error(msg)
3206	self.frame.Show()
3207
3208	self.SetTopWindow(self.frame)
3209
3210	return True
3211
3212	def maximize_win(self):
3213	"""
3214	Maximize the window after the frame shown
3215	"""
3216	if self.is_max:
3217	if self.frame.IsShown():
3218	# Max window size
3219	self.frame.Maximize(self.is_max)
3220
3221	def open_file(self):
3222	"""
3223	open a state file at the start of the application
3224	"""
3225	input_file = None
3226	if len(sys.argv) >= 2:
3227	cmd = sys.argv[0].lower()
3228	basename = os.path.basename(cmd)
3229	app_base = str(APPLICATION_NAME).lower()
3230	if os.path.isfile(cmd) or basename.lower() == app_base:
3231	app_py = app_base + '.py'
3232	app_exe = app_base + '.exe'
3233	app_app = app_base + '.app'
3234	if basename.lower() in [app_py, app_exe, app_app, app_base]:
3235	data_base = sys.argv[1]
3236	input_file = os.path.normpath(os.path.join(get_app_dir(),
3237	data_base))
3238	if input_file is None:
3239	return
3240	if self.frame is not None:
3241	self.frame.set_input_file(input_file=input_file)
3242
3243	def clean_plugin_models(self, path):
3244	"""
3245	Delete plugin models in app folder
3246
3247	:param path: path of the plugin_models folder in app
3248	"""
3249	# do it only the first time app loaded
3250	# delete unused model folder
3251	model_folder = os.path.join(get_app_dir(), path)
3252	if os.path.exists(model_folder) and os.path.isdir(model_folder):
3253	if len(os.listdir(model_folder)) > 0:
3254	try:
3255	for filename in os.listdir(model_folder):
3256	file_path = os.path.join(model_folder, filename)
3257	if os.path.isfile(file_path):
3258	os.remove(file_path)
3259	except:
3260	logger.error("gui_manager.clean_plugin_models:\n %s"
3261	% sys.exc_value)
3262
3263	def set_manager(self, manager):
3264	"""
3265	Sets a reference to the application manager
3266	of the GUI manager (Frame)
3267	"""
3268	self.frame.set_manager(manager)
3269
3270	def build_gui(self):
3271	"""
3272	Build the GUI
3273	"""
3274	# try to load file at the start
3275	self.open_file()
3276	self.frame.build_gui()
3277
3278	def set_welcome_panel(self, panel_class):
3279	"""
3280	Set the welcome panel
3281
3282	:param panel_class: class of the welcome panel to be instantiated
3283
3284	"""
3285	self.frame.welcome_panel_class = panel_class
3286
3287	def add_perspective(self, perspective):
3288	"""
3289	Manually add a perspective to the application GUI
3290	"""
3291	self.frame.add_perspective(perspective)
3292
3293	def window_placement(self, size):
3294	"""
3295	Determines the position and size of the application frame such that it
3296	fits on the user's screen without obstructing (or being obstructed by)
3297	the Windows task bar. The maximum initial size in pixels is bounded by
3298	WIDTH x HEIGHT. For most monitors, the application
3299	will be centered on the screen; for very large monitors it will be
3300	placed on the left side of the screen.
3301	"""
3302	is_maximized = False
3303	# Get size of screen without
3304	for screenCount in range(wx.Display().GetCount()):
3305	screen = wx.Display(screenCount)
3306	if screen.IsPrimary():
3307	displayRect = screen.GetClientArea()
3308	break
3309
3310	posX, posY, displayWidth, displayHeight = displayRect
3311	customWidth, customHeight = size
3312
3313	# If the custom size is default, set 90% of the screen size
3314	if customWidth <= 0 and customHeight <= 0:
3315	if customWidth == 0 and customHeight == 0:
3316	is_maximized = True
3317	customWidth = displayWidth * 0.9
3318	customHeight = displayHeight * 0.9
3319	else:
3320	# If the custom screen is bigger than the
3321	# window screen than make maximum size
3322	if customWidth > displayWidth:
3323	customWidth = displayWidth
3324	if customHeight > displayHeight:
3325	customHeight = displayHeight
3326
3327	# Note that when running Linux and using an Xming (X11) server on a PC
3328	# with a dual monitor configuration, the reported display size may be
3329	# that of both monitors combined with an incorrect display count of 1.
3330	# To avoid displaying this app across both monitors, we check for
3331	# screen 'too big'. If so, we assume a smaller width which means the
3332	# application will be placed towards the left hand side of the screen.
3333
3334	# If dual screen registered as 1 screen. Make width half.
3335	# MAC just follows the default behavior of pos
3336	if IS_WIN:
3337	if displayWidth > (displayHeight * 2):
3338	if customWidth == displayWidth:
3339	customWidth = displayWidth / 2
3340	# and set the position to be the corner of the screen.
3341	posX = 0
3342	posY = 0
3343
3344	# Make the position the middle of the screen. (Not 0,0)
3345	else:
3346	posX = (displayWidth - customWidth) / 2
3347	posY = (displayHeight - customHeight) / 2
3348	# Return the suggested position and size for the application frame.
3349	return (posX, posY), (customWidth, customHeight), is_maximized
3350
3351	def display_splash_screen(self, parent,
3352	path=SPLASH_SCREEN_PATH):
3353	"""Displays the splash screen. It will exactly cover the main frame."""
3354
3355	# Prepare the picture. On a 2GHz intel cpu, this takes about a second.
3356	image = wx.Image(path, wx.BITMAP_TYPE_PNG)
3357	image.Rescale(SPLASH_SCREEN_WIDTH,
3358	SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
3359	bm = image.ConvertToBitmap()
3360
3361	# Create and show the splash screen. It will disappear only when the
3362	# program has entered the event loop AND either the timeout has expired
3363	# or the user has left clicked on the screen. Thus any processing
3364	# performed in this routine (including sleeping) or processing in the
3365	# calling routine (including doing imports) will prevent the splash
3366	# screen from disappearing.
3367	#
3368	# Note that on Linux, the timeout appears to occur immediately in which
3369	# case the splash screen disappears upon entering the event loop.
3370	s_screen = wx.SplashScreen(bitmap=bm,
3371	splashStyle=(wx.SPLASH_TIMEOUT \|
3372	wx.SPLASH_CENTRE_ON_SCREEN),
3373	style=(wx.SIMPLE_BORDER \|
3374	wx.FRAME_NO_TASKBAR \|
3375	wx.FRAME_FLOAT_ON_PARENT),
3376	milliseconds=SS_MAX_DISPLAY_TIME,
3377	parent=parent,
3378	id=wx.ID_ANY)
3379	from sas.sasgui.guiframe.gui_statusbar import SPageStatusbar
3380	statusBar = SPageStatusbar(s_screen)
3381	s_screen.SetStatusBar(statusBar)
3382	s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
3383	s_screen.Show()
3384	return s_screen
3385
3386	def on_close_splash_screen(self, event):
3387	"""
3388	When the splash screen is closed.
3389	"""
3390	self.frame.Show(True)
3391	event.Skip()
3392	self.maximize_win()
3393
3394
3395	class MDIFrame(CHILD_FRAME):
3396	"""
3397	Frame for panels
3398	"""
3399	def __init__(self, parent, panel, title="Untitled", size=(300, 200)):
3400	"""
3401	comment
3402	:param parent: parent panel/container
3403	"""
3404	# Initialize the Frame object
3405	CHILD_FRAME.__init__(self, parent=parent, id=wx.ID_ANY,
3406	title=title, size=size)
3407	self.parent = parent
3408	self.name = "Untitled"
3409	self.batch_on = self.parent.batch_on
3410	self.panel = panel
3411	if panel is not None:
3412	self.set_panel(panel)
3413	self.Show(False)
3414
3415	def show_data_panel(self, action):
3416	"""
3417	Turns on the data panel
3418
3419	The the data panel is optional. Most of its functions can be
3420	performed from the menu bar and from the plots.
3421	"""
3422	self.parent.show_data_panel(action)
3423
3424	def set_panel(self, panel):
3425	"""
3426	"""
3427	self.panel = panel
3428	self.name = panel.window_name
3429	self.SetTitle(panel.window_caption)
3430	self.SetHelpText(panel.help_string)
3431	width, height = self.parent._get_panels_size(panel)
3432	if hasattr(panel, "CENTER_PANE") and panel.CENTER_PANE:
3433	width *= 0.6
3434	self.SetSize((width, height))
3435	self.parent.put_icon(self)
3436	self.Bind(wx.EVT_SET_FOCUS, self.set_panel_focus)
3437	self.Bind(wx.EVT_CLOSE, self.OnClose)
3438	self.Show(False)
3439
3440	def set_panel_focus(self, event):
3441	"""
3442	"""
3443	if self.parent.panel_on_focus != self.panel:
3444	self.panel.SetFocus()
3445	self.parent.panel_on_focus = self.panel
3446
3447	def OnClose(self, event):
3448	"""
3449	On Close event
3450	"""
3451	self.panel.on_close(event)
3452
3453	if __name__ == "__main__":
3454	app = SasViewApp(0)
3455	app.MainLoop()

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

SasView

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

Download in other formats: