gui_manager.py @ 7ba6470

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

Last change on this file since 7ba6470 was 8ac05a5, checked in by smk78, 6 years ago
Implementing html Release Notes from Help menu.
Property mode set to `100644`
File size: 125.9 KB

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

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

SasView

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

Download in other formats: