gui_manager.py @ f0b9bce

ticket-1094-headless

Last change on this file since f0b9bce was dcd6efd, checked in by GitHub <noreply@…>, 6 years ago

Merge pull request #180 from SasView?/ticket-1111

Multiple data loader and writer updates - NXcanSAS compliance, data conversion, saving as NXcanSAS, plus more

Fixes #976
Fixes #1129
Fixes #1111
Fixes #1221

Property mode set to 100644

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

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

SasView

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

Download in other formats: