gui_manager.py @ 104613f

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

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

SasView

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

Download in other formats: