gui_manager.py @ 72100ee

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 72100ee was 38beeab, checked in by Ricardo Ferraz Leal <ricleal@…>, 8 years ago
Logger is now a separate file
Property mode set to `100644`
File size: 129.4 KB

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

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

SasView

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

Download in other formats: