gui_manager.py @ f199764

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.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since f199764 was 889e9f8, checked in by Jae Cho <jhjcho@…>, 13 years ago
try wx2.9 for mac
Property mode set to `100644`
File size: 100.8 KB

Rev	Line
[41d466f]	1
[d955bf19]	2	################################################################################
	3	#This software was developed by the University of Tennessee as part of the
	4	#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
	5	#project funded by the US National Science Foundation.
	6	#
	7	#See the license text in license.txt
	8	#
	9	#copyright 2008, University of Tennessee
	10	################################################################################
[7681bac]	11
[d68c655]	12
[41d466f]	13	import wx
	14	import wx.aui
[32c0841]	15	import os
	16	import sys
[b0eee0f0]	17	import xml
[08e1912]	18
[adf44c2]	19
	20	# Try to find a local config
	21	import imp
	22	path = os.getcwd()
	23	if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
	24	(os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
	25	fObj, path_config, descr = imp.find_module('local_config', [path])
	26	try:
	27	config = imp.load_module('local_config', fObj, path_config, descr)
	28	except:
	29	# Didn't find local config, load the default
	30	import config
	31	finally:
	32	if fObj:
	33	fObj.close()
	34	else:
	35	# Try simply importing local_config
	36	import local_config as config
[f843099]	37	#path = os.path.sys.path[0]
[adf44c2]	38	PATH_APP = path
[f843099]	39
[adf44c2]	40	#import compileall
	41	import py_compile
	42	c_name = os.path.join(path, 'custom_config.py')
	43	if(os.path.isfile("%s/%s.py" % (path, 'custom_config'))):
	44	py_compile.compile(file=c_name)
	45	#compileall.compile_dir(dir=path, force=True, quiet=0)
	46	cfObj, path_cconfig, descr = imp.find_module('custom_config', [path])
[41d466f]	47	try:
[62b276c]	48	custom_config = imp.load_module('custom_config', cfObj, path, descr)
[41d466f]	49	except:
[adf44c2]	50	custom_config = None
	51	finally:
[f843099]	52	if custom_config != None:
[adf44c2]	53	cfObj.close()
	54
[4e9583c]	55
	56	import warnings
	57	warnings.simplefilter("ignore")
[3c44c66]	58
[4e9583c]	59	import logging
[32c0841]	60
[f444b20]	61	from sans.guiframe.events import EVT_STATUS
[4e4d3bb]	62	from sans.guiframe.events import EVT_APPEND_BOOKMARK
[a45037aa]	63	from sans.guiframe.events import EVT_PANEL_ON_FOCUS
[a03d419]	64	from sans.guiframe.events import EVT_NEW_LOAD_DATA
[f444b20]	65	from sans.guiframe.events import StatusEvent
	66	from sans.guiframe.events import NewPlotEvent
[f036c692]	67	from sans.guiframe.gui_style import GUIFRAME
	68	from sans.guiframe.gui_style import GUIFRAME_ID
[a03d419]	69	#from sans.guiframe.events import NewLoadedDataEvent
[3feed3e]	70	from sans.guiframe.data_panel import DataPanel
[d828481]	71	from sans.guiframe.panel_base import PanelBase
[f036c692]	72	from sans.guiframe.gui_toolbar import GUIToolBar
[75fbd17]	73	from DataLoader.loader import Loader
	74
[b5ca223]	75
[957723f]	76	#read some constants from config
	77	APPLICATION_STATE_EXTENSION = config.APPLICATION_STATE_EXTENSION
	78	APPLICATION_NAME = config.__appname__
	79	SPLASH_SCREEN_PATH = config.SPLASH_SCREEN_PATH
[adf44c2]	80
[957723f]	81	SPLASH_SCREEN_WIDTH = config.SPLASH_SCREEN_WIDTH
	82	SPLASH_SCREEN_HEIGHT = config.SPLASH_SCREEN_HEIGHT
	83	SS_MAX_DISPLAY_TIME = config.SS_MAX_DISPLAY_TIME
[adf44c2]	84
	85	try:
	86	DATALOADER_SHOW = custom_config.DATALOADER_SHOW
	87	TOOLBAR_SHOW = custom_config.TOOLBAR_SHOW
	88	FIXED_PANEL = custom_config.FIXED_PANEL
	89	WELCOME_PANEL_SHOW = custom_config.WELCOME_PANEL_SHOW
	90	PLOPANEL_WIDTH = custom_config.PLOPANEL_WIDTH
	91	DATAPANEL_WIDTH = custom_config.DATAPANEL_WIDTH
	92	GUIFRAME_WIDTH = custom_config.GUIFRAME_WIDTH
	93	GUIFRAME_HEIGHT = custom_config.GUIFRAME_HEIGHT
	94	DEFAULT_PERSPECTIVE = custom_config.DEFAULT_PERSPECTIVE
[f2d9e76]	95	CLEANUP_PLOT = custom_config.CLEANUP_PLOT
[adf44c2]	96	except:
	97	DATALOADER_SHOW = True
	98	TOOLBAR_SHOW = True
	99	FIXED_PANEL = True
	100	WELCOME_PANEL_SHOW = False
	101	PLOPANEL_WIDTH = config.PLOPANEL_WIDTH
	102	DATAPANEL_WIDTH = config.DATAPANEL_WIDTH
	103	GUIFRAME_WIDTH = config.GUIFRAME_WIDTH
	104	GUIFRAME_HEIGHT = config.GUIFRAME_HEIGHT
	105	DEFAULT_PERSPECTIVE = None
[f2d9e76]	106	CLEANUP_PLOT = False
[adf44c2]	107
	108	DEFAULT_STYLE = config.DEFAULT_STYLE
	109
	110
[957723f]	111	PLOPANEL_HEIGTH = config.PLOPANEL_HEIGTH
[adf44c2]	112	DATAPANEL_HEIGHT = config.DATAPANEL_HEIGHT
[957723f]	113	PLUGIN_STATE_EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS
	114	extension_list = []
	115	if APPLICATION_STATE_EXTENSION is not None:
	116	extension_list.append(APPLICATION_STATE_EXTENSION)
	117	EXTENSIONS = PLUGIN_STATE_EXTENSIONS + extension_list
	118	try:
[4c01978]	119	PLUGINS_WLIST = '\|'.join(config.PLUGINS_WLIST)
[957723f]	120	except:
[4c01978]	121	PLUGINS_WLIST = ''
	122	APPLICATION_WLIST = config.APPLICATION_WLIST
[4520830]	123	if sys.platform.count("darwin")==0:
	124	IS_WIN = True
	125	else:
	126	IS_WIN = False
[c91ef7e]	127
[41d466f]	128	class ViewerFrame(wx.Frame):
	129	"""
[d955bf19]	130	Main application frame
[41d466f]	131	"""
[f444b20]	132
[3385795]	133	def __init__(self, parent, title,
[4753fc2]	134	size=(GUIFRAME_WIDTH, GUIFRAME_HEIGHT),
[adf44c2]	135	gui_style=DEFAULT_STYLE,
[3385795]	136	pos=wx.DefaultPosition):
[41d466f]	137	"""
[d955bf19]	138	Initialize the Frame object
[41d466f]	139	"""
[b7c7a1c]	140
[3385795]	141	wx.Frame.__init__(self, parent=parent, title=title, pos=pos,size=size)
[1b1bbf9]	142	# title
	143	self.title = title
[d0802c3]	144	# Preferred window size
[3385795]	145	self._window_width, self._window_height = size
[52b8b74]	146	self.__gui_style = gui_style
[fc2b91a]	147	# Logging info
	148	logging.basicConfig(level=logging.DEBUG,
	149	format='%(asctime)s %(levelname)s %(message)s',
	150	filename='sans_app.log',
	151	filemode='w')
[c44e7cc]	152	path = os.path.dirname(__file__)
[32c0841]	153	temp_path = os.path.join(path,'images')
[c44e7cc]	154	ico_file = os.path.join(temp_path,'ball.ico')
[278cc25]	155	if os.path.isfile(ico_file):
	156	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
[cbb2e40]	157	else:
[32c0841]	158	temp_path = os.path.join(os.getcwd(),'images')
[c44e7cc]	159	ico_file = os.path.join(temp_path,'ball.ico')
[cbb2e40]	160	if os.path.isfile(ico_file):
	161	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
[7c7fe67]	162	else:
	163	ico_file = os.path.join(os.path.dirname(os.path.sys.path[0]),
	164	'images', 'ball.ico')
	165	if os.path.isfile(ico_file):
	166	self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
[adf44c2]	167	self.path = PATH_APP
[41d466f]	168	## Application manager
[29ef718]	169	self._input_file = None
[41d466f]	170	self.app_manager = None
[32c0841]	171	self._mgr = None
[f444b20]	172	#add current perpsective
	173	self._current_perspective = None
[52b8b74]	174	self._plotting_plugin = None
	175	self._data_plugin = None
	176	#Menu bar and item
	177	self._menubar = None
	178	self._file_menu = None
	179	self._data_menu = None
[34e3ab3]	180	self._view_menu = None
[52b8b74]	181	self._window_menu = None
[e75b5fa]	182	self._data_panel_menu = None
[c5e84fb]	183	self._help_menu = None
	184	self._tool_menu = None
[95f9cc4]	185	self._applications_menu_pos = -1
[4c0572f]	186	self._applications_menu_name = None
[95f9cc4]	187	self._applications_menu = None
[d828481]	188	self._edit_menu = None
[a45037aa]	189	self._toolbar_menu = None
[73b3ae2]	190	self._save_appl_menu = None
[f036c692]	191	#tool bar
	192	self._toolbar = None
[f2d9e76]	193	# number of plugins
	194	self._num_perspectives = 0
	195	# plot duck cleanup option
	196	self.cleanup_plots = CLEANUP_PLOT
[1b1bbf9]	197	# (un)-focus color
	198	#self.color = '#b3b3b3'
[41d466f]	199	## Find plug-ins
	200	# Modify this so that we can specify the directory to look into
[32c0841]	201	self.plugins = []
[b7c7a1c]	202	#add local plugin
[52b8b74]	203	self.plugins += self._get_local_plugins()
[a88ac04]	204	self.plugins += self._find_plugins()
[41d466f]	205	## List of panels
	206	self.panels = {}
[0a2fdca]	207	# List of plot panels
	208	self.plot_panels = {}
[41d466f]	209
[2310d69]	210	# Default locations
	211	self._default_save_location = os.getcwd()
[f444b20]	212
[f9e803e]	213	# Welcome panel
	214	self.defaultPanel = None
[b91c736]	215	#panel on focus
	216	self.panel_on_focus = None
[0a2fdca]	217	#control_panel on focus
	218	self.cpanel_on_focus = None
[75fbd17]	219	self.loader = Loader()
[6d727ae]	220	#data manager
[213892bc]	221	from data_manager import DataManager
	222	self._data_manager = DataManager()
	223	self._data_panel = DataPanel(parent=self)
	224	if self.panel_on_focus is not None:
[6db811e]	225	self._data_panel.set_panel_on_focus(self.panel_on_focus.window_caption)
[6d727ae]	226	# list of plot panels in schedule to full redraw
	227	self.schedule = False
	228	#self.callback = True
	229	self._idle_count = 0
	230	self.schedule_full_draw_list = []
	231	self.idletimer = wx.CallLater(1, self._onDrawIdle)
	232
[a0d56d5]	233	# Check for update
[af20f6b]	234	#self._check_update(None)
[278cc25]	235	# Register the close event so it calls our own method
[52725d6]	236	wx.EVT_CLOSE(self, self.Close)
[278cc25]	237	# Register to status events
	238	self.Bind(EVT_STATUS, self._on_status_event)
[b91c736]	239	#Register add extra data on the same panel event on load
[a45037aa]	240	self.Bind(EVT_PANEL_ON_FOCUS, self.set_panel_on_focus)
[4e4d3bb]	241	self.Bind(EVT_APPEND_BOOKMARK, self.append_bookmark)
[a03d419]	242	self.Bind(EVT_NEW_LOAD_DATA, self.on_load_data)
[1b1bbf9]	243
[adf44c2]	244	self.setup_custom_conf()
	245
	246	def setup_custom_conf(self):
	247	"""
	248	Set up custom configuration if exists
	249	"""
	250	if custom_config == None:
	251	return
[1b1bbf9]	252
[adf44c2]	253	if not FIXED_PANEL:
	254	self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
	255	self.__gui_style \|= GUIFRAME.FLOATING_PANEL
	256
	257	if not DATALOADER_SHOW:
	258	self.__gui_style &= (~GUIFRAME.MANAGER_ON)
	259
	260	if not TOOLBAR_SHOW:
	261	self.__gui_style &= (~GUIFRAME.TOOLBAR_ON)
	262
	263	if WELCOME_PANEL_SHOW:
	264	self.__gui_style \|= GUIFRAME.WELCOME_PANEL_ON
	265
	266	def set_custom_default_perspective(self):
	267	"""
	268	Set default starting perspective
	269	"""
	270	if custom_config == None:
	271	return
	272	for plugin in self.plugins:
	273	try:
	274	if plugin.sub_menu == DEFAULT_PERSPECTIVE:
	275
	276	plugin.on_perspective(event=None)
	277	#self._check_applications_menu()
	278	break
	279	except:
	280	pass
	281	return
	282
[a03d419]	283	def on_load_data(self, event):
	284	"""
	285	received an event to trigger load from data plugin
	286	"""
	287	if self._data_plugin is not None:
	288	self._data_plugin.load_data(event)
	289
[600eca2]	290	def get_current_perspective(self):
	291	"""
	292	return the current perspective
	293	"""
	294	return self._current_perspective
	295
[29ef718]	296	def set_input_file(self, input_file):
	297	"""
	298	:param input_file: file to read
	299	"""
	300	self._input_file = input_file
	301
[4c0572f]	302	def get_data_manager(self):
	303	"""
	304	"""
	305	return self._data_manager
	306
[03314e7]	307	def get_toolbar(self):
	308	"""
	309	"""
	310	return self._toolbar
	311
[b91c736]	312	def set_panel_on_focus(self, event):
	313	"""
[d955bf19]	314	Store reference to the last panel on focus
[f036c692]	315	update the toolbar if available
	316	update edit menu if available
[b91c736]	317	"""
[0a2fdca]	318	if event != None:
	319	self.panel_on_focus = event.panel
[a45037aa]	320	panel_name = 'No panel on focus'
[f7e9af2]	321	application_name = 'No Selected Analysis'
[f69b5830]	322	if self.panel_on_focus is not None:
[83a75c5]	323	if self.panel_on_focus not in self.plot_panels.values():
	324	for ID in self.panels.keys():
	325	if self.panel_on_focus != self.panels[ID]:
	326	self.panels[ID].on_kill_focus(None)
[f69b5830]	327
[168a845]	328	if self._data_panel is not None and \
	329	self.panel_on_focus is not None:
[f69b5830]	330	panel_name = self.panel_on_focus.window_caption
[48665ed]	331	ID = self.panel_on_focus.uid
	332	self._data_panel.set_panel_on_focus(ID)
[0a2fdca]	333	#update combo
	334	if self.panel_on_focus in self.plot_panels.values():
[e6cee09]	335	combo = self._data_panel.cb_plotpanel
	336	combo_title = str(self.panel_on_focus.window_caption)
	337	combo.SetStringSelection(combo_title)
	338	combo.SetToolTip( wx.ToolTip(combo_title ))
[0a2fdca]	339	elif self.panel_on_focus != self._data_panel:
[fadf925]	340	cpanel = self.panel_on_focus
	341	if self.cpanel_on_focus != cpanel:
	342	self.cpanel_on_focus = self.panel_on_focus
[f69b5830]	343	#update toolbar
	344	self._update_toolbar_helper()
	345	#update edit menu
	346	self.enable_edit_menu()
[1b1bbf9]	347
[fadf925]	348	def reset_bookmark_menu(self, panel):
	349	"""
	350	Reset Bookmark menu list
	351
	352	: param panel: a control panel or tap where the bookmark is
	353	"""
	354	cpanel = panel
	355	if self._toolbar != None and cpanel._bookmark_flag:
	356	for item in self._toolbar.get_bookmark_items():
	357	self._toolbar.remove_bookmark_item(item)
	358	self._toolbar.add_bookmark_default()
	359	pos = 0
	360	for bitem in cpanel.popUpMenu.GetMenuItems():
	361	pos += 1
	362	if pos < 3:
	363	continue
	364	id = bitem.GetId()
	365	label = bitem.GetLabel()
	366	self._toolbar.append_bookmark_item(id, label)
	367	wx.EVT_MENU(self, id, cpanel._back_to_bookmark)
	368	self._toolbar.Realize()
	369
[0a2fdca]	370
[278cc25]	371	def build_gui(self):
[d955bf19]	372	"""
	373	"""
[4d1dce4]	374	# set tool bar
	375	self._setup_tool_bar()
[41d466f]	376	# Set up the layout
	377	self._setup_layout()
[66141a0]	378
[41d466f]	379	# Set up the menu
	380	self._setup_menus()
[4d1dce4]	381
[29ef718]	382	try:
	383	self.load_from_cmd(self._input_file)
	384	except:
[64e44c1]	385	msg = "%s Cannot load file %s\n" %(str(APPLICATION_NAME),
	386	str(self._input_file))
	387	msg += str(sys.exc_value) + '\n'
	388	print msg
[600eca2]	389	if self._data_panel is not None:
	390	self._data_panel.fill_cbox_analysis(self.plugins)
[29ef718]	391	self.post_init()
[adf44c2]	392	# Set Custom default
	393	self.set_custom_default_perspective()
[66141a0]	394	# Set up extra custom tool menu
	395	self._setup_extra_custom()
[f2d9e76]	396	#self.Show(True)
	397	#self._check_update(None)
	398
	399	def _setup_extra_custom(self):
	400	"""
	401	Set up toolbar and welcome view if needed
	402	"""
[adf44c2]	403	style = self.__gui_style & GUIFRAME.TOOLBAR_ON
	404	if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
	405	self._on_toggle_toolbar()
	406
	407	# Set Custom deafult start page
	408	welcome_style = self.__gui_style & GUIFRAME.WELCOME_PANEL_ON
	409	if welcome_style == GUIFRAME.WELCOME_PANEL_ON:
	410	self.show_welcome_panel(None)
[f2d9e76]	411
[41d466f]	412	def _setup_layout(self):
	413	"""
[d955bf19]	414	Set up the layout
[41d466f]	415	"""
	416	# Status bar
[010c251]	417	from gui_statusbar import StatusBar
[db10f97]	418	self.sb = StatusBar(self, wx.ID_ANY)
[dd66fbd]	419	self.SetStatusBar(self.sb)
[41d466f]	420	# Add panel
[f69b5830]	421	default_flag = wx.aui.AUI_MGR_DEFAULT#\| wx.aui.AUI_MGR_ALLOW_ACTIVE_PANE
[52b8b74]	422	self._mgr = wx.aui.AuiManager(self, flags=default_flag)
[1b1bbf9]	423	self._mgr.SetDockSizeConstraint(0.5, 0.5)
	424	# border color
	425	#self.b_color = wx.aui.AUI_DOCKART_BORDER_COLOUR
	426	#self._mgr.GetArtProvider().SetColor(self.b_color, self.color)
	427	#self._mgr.SetArtProvider(wx.aui.AuiDockArt(wx.AuiDefaultDockArt))
	428	#print "set", self._dockart.GetColour(13)
[41d466f]	429	# Load panels
	430	self._load_panels()
[c5e84fb]	431	self.set_default_perspective()
[41d466f]	432	self._mgr.Update()
[db10f97]	433
	434	def SetStatusText(self, args, *kwds):
[d955bf19]	435	"""
	436	"""
[db10f97]	437	number = self.sb.get_msg_position()
	438	wx.Frame.SetStatusText(number=number, args, *kwds)
	439
	440	def PopStatusText(self, args, *kwds):
[d955bf19]	441	"""
	442	"""
[db10f97]	443	field = self.sb.get_msg_position()
	444	wx.Frame.PopStatusText(field=field)
	445
	446	def PushStatusText(self, args, *kwds):
[d955bf19]	447	"""
	448	"""
[db10f97]	449	field = self.sb.get_msg_position()
[32c0841]	450	wx.Frame.PushStatusText(self, field=field, string=string)
[278cc25]	451
	452	def add_perspective(self, plugin):
	453	"""
[d955bf19]	454	Add a perspective if it doesn't already
	455	exist.
[278cc25]	456	"""
[f2d9e76]	457	self._num_perspectives += 1
[278cc25]	458	is_loaded = False
	459	for item in self.plugins:
[32c0841]	460	if plugin.__class__ == item.__class__:
[56681bd]	461	msg = "Plugin %s already loaded" % plugin.sub_menu
[f444b20]	462	logging.info(msg)
[adf44c2]	463	is_loaded = True
[278cc25]	464	if not is_loaded:
[600eca2]	465
[adf44c2]	466	self.plugins.append(plugin)
	467
[41d466f]	468
[52b8b74]	469	def _get_local_plugins(self):
	470	"""
	471	get plugins local to guiframe and others
	472	"""
	473	plugins = []
	474	#import guiframe local plugins
[7a67e075]	475	#check if the style contain guiframe.dataloader
	476	style1 = self.__gui_style & GUIFRAME.DATALOADER_ON
[3feed3e]	477	style2 = self.__gui_style & GUIFRAME.PLOTTING_ON
[7a67e075]	478	if style1 == GUIFRAME.DATALOADER_ON:
[52b8b74]	479	try:
	480	from sans.guiframe.local_perspectives.data_loader import data_loader
[3feed3e]	481	self._data_plugin = data_loader.Plugin()
[52b8b74]	482	plugins.append(self._data_plugin)
	483	except:
[3feed3e]	484	msg = "ViewerFrame._get_local_plugins:"
[52b8b74]	485	msg += "cannot import dataloader plugin.\n %s" % sys.exc_value
	486	logging.error(msg)
[3feed3e]	487	if style2 == GUIFRAME.PLOTTING_ON:
[52b8b74]	488	try:
	489	from sans.guiframe.local_perspectives.plotting import plotting
	490	self._plotting_plugin = plotting.Plugin()
	491	plugins.append(self._plotting_plugin)
	492	except:
[3feed3e]	493	msg = "ViewerFrame._get_local_plugins:"
[52b8b74]	494	msg += "cannot import plotting plugin.\n %s" % sys.exc_value
	495	logging.error(msg)
[3feed3e]	496
[52b8b74]	497	return plugins
	498
[41d466f]	499	def _find_plugins(self, dir="perspectives"):
	500	"""
[d955bf19]	501	Find available perspective plug-ins
	502
	503	:param dir: directory in which to look for plug-ins
	504
	505	:return: list of plug-ins
	506
[41d466f]	507	"""
	508	import imp
	509	plugins = []
	510	# Go through files in panels directory
	511	try:
	512	list = os.listdir(dir)
[a88ac04]	513	## the default panel is the panel is the last plugin added
	514	for item in list:
[41d466f]	515	toks = os.path.splitext(os.path.basename(item))
[c3f697e]	516	name = ''
[41d466f]	517	if not toks[0] == '__init__':
[32c0841]	518	if toks[1] == '.py' or toks[1] == '':
[41d466f]	519	name = toks[0]
[56681bd]	520	#check the validity of the module name parsed
	521	#before trying to import it
	522	if name is None or name.strip() == '':
	523	continue
[41d466f]	524	path = [os.path.abspath(dir)]
[c3f697e]	525	file = ''
[41d466f]	526	try:
[32c0841]	527	if toks[1] == '':
[41d466f]	528	mod_path = '.'.join([dir, name])
[32c0841]	529	module = __import__(mod_path, globals(),
	530	locals(), [name])
[41d466f]	531	else:
	532	(file, path, info) = imp.find_module(name, path)
[32c0841]	533	module = imp.load_module( name, file, item, info)
[41d466f]	534	if hasattr(module, "PLUGIN_ID"):
[f444b20]	535	try:
	536	plug = module.Plugin()
	537	if plug.set_default_perspective():
	538	self._current_perspective = plug
	539	plugins.append(plug)
[adf44c2]	540
[32c0841]	541	msg = "Found plug-in: %s" % module.PLUGIN_ID
	542	logging.info(msg)
[41d466f]	543	except:
[32c0841]	544	msg = "Error accessing PluginPanel"
	545	msg += " in %s\n %s" % (name, sys.exc_value)
	546	config.printEVT(msg)
[41d466f]	547	except:
[32c0841]	548	msg = "ViewerFrame._find_plugins: %s" % sys.exc_value
[56681bd]	549	#print msg
[32c0841]	550	logging.error(msg)
[41d466f]	551	finally:
[32c0841]	552	if not file == None:
[41d466f]	553	file.close()
	554	except:
[32c0841]	555	# Should raise and catch at a higher level and
	556	# display error on status bar
[f2d9e76]	557	pass
	558
[41d466f]	559	return plugins
	560
[f9e803e]	561	def set_welcome_panel(self, panel_class):
	562	"""
[d955bf19]	563	Sets the default panel as the given welcome panel
	564
	565	:param panel_class: class of the welcome panel to be instantiated
	566
[f9e803e]	567	"""
[d955bf19]	568	self.defaultPanel = panel_class(self, -1, style=wx.RAISED_BORDER)
[b28278e]	569
[3feed3e]	570	def _get_panels_size(self, p):
	571	"""
	572	find the proper size of the current panel
	573	get the proper panel width and height
	574	"""
	575	panel_height_min = self._window_height
	576	panel_width_min = self._window_width
	577	style = self.__gui_style & (GUIFRAME.MANAGER_ON)
	578	if self._data_panel is not None and (p == self._data_panel):
[ea4dfe0]	579	panel_width_min = DATAPANEL_WIDTH
[1b1bbf9]	580	panel_height_min = self._window_height * 0.8
[3feed3e]	581	return panel_width_min, panel_height_min
	582	if hasattr(p, "CENTER_PANE") and p.CENTER_PANE:
	583	style = self.__gui_style & (GUIFRAME.PLOTTING_ON\|GUIFRAME.MANAGER_ON)
	584	if style == (GUIFRAME.PLOTTING_ON\|GUIFRAME.MANAGER_ON):
[ea4dfe0]	585	panel_width_min = self._window_width -\
	586	(DATAPANEL_WIDTH +config.PLOPANEL_WIDTH)
[3feed3e]	587	return panel_width_min, panel_height_min
	588	return panel_width_min, panel_height_min
	589
[41d466f]	590	def _load_panels(self):
	591	"""
[d955bf19]	592	Load all panels in the panels directory
[41d466f]	593	"""
	594
	595	# Look for plug-in panels
[c1469ebe]	596	panels = []
[41d466f]	597	for item in self.plugins:
	598	if hasattr(item, "get_panels"):
	599	ps = item.get_panels(self)
	600	panels.extend(ps)
[3feed3e]	601
[41d466f]	602	# Show a default panel with some help information
	603	# It also sets the size of the application windows
[c9454bb]	604	#TODO: Use this for slpash screen
[f9e803e]	605	if self.defaultPanel is None:
[32c0841]	606	self.defaultPanel = DefaultPanel(self, -1, style=wx.RAISED_BORDER)
[3feed3e]	607	# add a blank default panel always present
[41d466f]	608	self.panels["default"] = self.defaultPanel
	609	self._mgr.AddPane(self.defaultPanel, wx.aui.AuiPaneInfo().
	610	Name("default").
[1b1bbf9]	611	CenterPane().
	612	#CloseButton(False).
	613	#MinimizeButton(False).
[32c0841]	614	# This is where we set the size of
	615	# the application window
	616	BestSize(wx.Size(self._window_width,
	617	self._window_height)).
[41d466f]	618	Show())
[1b1bbf9]	619
[3feed3e]	620	#add data panel
	621	self.panels["data_panel"] = self._data_panel
	622	w, h = self._get_panels_size(self._data_panel)
	623	self._mgr.AddPane(self._data_panel, wx.aui.AuiPaneInfo().
	624	Name(self._data_panel.window_name).
[1b1bbf9]	625	Caption(self._data_panel.window_caption).
[3feed3e]	626	Left().
	627	MinimizeButton().
[889e9f8]	628	CloseButton(True).#(IS_WIN).
[18ec684]	629	TopDockable(False).
	630	BottomDockable(False).
	631	LeftDockable(True).
	632	RightDockable(False).
	633	BestSize(wx.Size(w, h)).
[d828481]	634	Hide())
[1b1bbf9]	635
[3feed3e]	636	style = self.__gui_style & GUIFRAME.MANAGER_ON
[1b1bbf9]	637	data_pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
[3feed3e]	638	if style != GUIFRAME.MANAGER_ON:
[64e44c1]	639	self._mgr.GetPane(self.panels["data_panel"].window_name).Hide()
[d828481]	640	else:
[64e44c1]	641	self._mgr.GetPane(self.panels["data_panel"].window_name).Show()
	642
[41d466f]	643	# Add the panels to the AUI manager
	644	for panel_class in panels:
	645	p = panel_class
	646	id = wx.NewId()
[1b1bbf9]	647	#w, h = self._get_panels_size(p)
[41d466f]	648	# Check whether we need to put this panel
	649	# in the center pane
[6f59a98]	650	if hasattr(p, "CENTER_PANE") and p.CENTER_PANE:
[1b1bbf9]	651	w, h = self._get_panels_size(p)
[41d466f]	652	if p.CENTER_PANE:
	653	self.panels[str(id)] = p
	654	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
[1b1bbf9]	655	Name(p.window_name).
[ea4dfe0]	656	CenterPane().
[1b1bbf9]	657	Center().
	658	CloseButton(False).
	659	Hide())
[41d466f]	660	else:
	661	self.panels[str(id)] = p
	662	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
	663	Name(p.window_name).Caption(p.window_caption).
	664	Right().
	665	Dock().
	666	TopDockable().
	667	BottomDockable().
	668	LeftDockable().
	669	RightDockable().
	670	MinimizeButton().
[3feed3e]	671	Hide())
[b28278e]	672
[c70eb7c]	673	def update_data(self, prev_data, new_data):
	674	"""
	675	"""
	676	prev_id, data_state = self._data_manager.update_data(prev_data=prev_data,
	677	new_data=new_data)
[e88ebfd]	678
[c70eb7c]	679	self._data_panel.remove_by_id(prev_id)
	680	self._data_panel.load_data_list(data_state)
[e88ebfd]	681
	682	def update_theory(self, data_id, theory, state=None):
	683	"""
	684	"""
	685	data_state = self._data_manager.update_theory(data_id=data_id,
	686	theory=theory,
	687	state=state)
	688	self._data_panel.load_data_list(data_state)
[c70eb7c]	689
[e6a93df]	690	def onfreeze(self, theory_id):
	691	"""
	692	"""
	693	data_state_list = self._data_manager.freeze(theory_id)
	694	self._data_panel.load_data_list(list=data_state_list)
	695	for data_state in data_state_list.values():
	696	new_plot = data_state.get_data()
[df22224]	697
[e6a93df]	698	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
	699	title=new_plot.title))
	700
[c70eb7c]	701	def freeze(self, data_id, theory_id):
	702	"""
	703	"""
	704	data_state_list = self._data_manager.freeze_theory(data_id=data_id,
	705	theory_id=theory_id)
	706	self._data_panel.load_data_list(list=data_state_list)
[ee2b492]	707	for data_state in data_state_list.values():
	708	new_plot = data_state.get_data()
	709	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
[c70eb7c]	710	title=new_plot.title))
	711
	712	def delete_data(self, data):
	713	"""
	714	"""
	715	self._current_perspective.delete_data(data)
	716
	717
[a07e72f]	718	def get_context_menu(self, plotpanel=None):
[41d466f]	719	"""
[d955bf19]	720	Get the context menu items made available
	721	by the different plug-ins.
	722	This function is used by the plotting module
[41d466f]	723	"""
[a07e72f]	724	if plotpanel is None:
	725	return
[41d466f]	726	menu_list = []
	727	for item in self.plugins:
[a07e72f]	728	menu_list.extend(item.get_context_menu(plotpanel=plotpanel))
[41d466f]	729	return menu_list
	730
	731	def popup_panel(self, p):
	732	"""
[d955bf19]	733	Add a panel object to the AUI manager
	734
	735	:param p: panel object to add to the AUI manager
[41d466f]	736
[d955bf19]	737	:return: ID of the event associated with the new panel [int]
	738
	739	"""
[41d466f]	740	ID = wx.NewId()
	741	self.panels[str(ID)] = p
	742	count = 0
	743	for item in self.panels:
[383189f9]	744	if self.panels[item].window_name.startswith(p.window_name):
[41d466f]	745	count += 1
	746	windowname = p.window_name
	747	caption = p.window_caption
[32c0841]	748	if count > 0:
[41d466f]	749	windowname += str(count+1)
	750	caption += (' '+str(count))
	751	p.window_name = windowname
	752	p.window_caption = caption
	753
[7a67e075]	754	style1 = self.__gui_style & GUIFRAME.FIXED_PANEL
	755	style2 = self.__gui_style & GUIFRAME.FLOATING_PANEL
	756	if style1 == GUIFRAME.FIXED_PANEL:
	757	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
[1b1bbf9]	758	Name(windowname).
	759	Caption(caption).
	760	Position(10).
	761	Floatable().
	762	Right().
	763	Dock().
[7a67e075]	764	MinimizeButton().
[4754192]	765	Resizable(True).
[c5e84fb]	766	# Use a large best size to make sure the AUI
	767	# manager takes all the available space
[1b1bbf9]	768	BestSize(wx.Size(PLOPANEL_WIDTH,
	769	PLOPANEL_HEIGTH)))
[adf44c2]	770
[3feed3e]	771	self._popup_fixed_panel(p)
[213892bc]	772
[0663dfb1]	773	elif style2 == GUIFRAME.FLOATING_PANEL:
[7a67e075]	774	self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
[60063f3]	775	Name(windowname).Caption(caption).
[7a67e075]	776	MinimizeButton().
[4754192]	777	Resizable(True).
[c5e84fb]	778	# Use a large best size to make sure the AUI
	779	# manager takes all the available space
[1b1bbf9]	780	BestSize(wx.Size(PLOPANEL_WIDTH,
	781	PLOPANEL_HEIGTH)))
[adf44c2]	782
[3feed3e]	783	self._popup_floating_panel(p)
[c5a769e]	784
[41d466f]	785	# Register for showing/hiding the panel
[56d5562]	786	wx.EVT_MENU(self, ID, self.on_view)
[c5a769e]	787	if p not in self.plot_panels.values() and p.group_id != None:
[0a2fdca]	788	self.plot_panels[ID] = p
[3f920de]	789	if len(self.plot_panels) == 1:
	790	self.panel_on_focus = p
	791	self.set_panel_on_focus(None)
[0a2fdca]	792	if self._data_panel is not None and \
	793	self._plotting_plugin is not None:
	794	ind = self._data_panel.cb_plotpanel.FindString('None')
	795	if ind != wx.NOT_FOUND:
	796	self._data_panel.cb_plotpanel.Delete(ind)
[670d77a]	797	if caption not in self._data_panel.cb_plotpanel.GetItems():
	798	self._data_panel.cb_plotpanel.Append(str(caption), p)
[41d466f]	799	return ID
	800
	801	def _setup_menus(self):
	802	"""
[d955bf19]	803	Set up the application menus
[41d466f]	804	"""
	805	# Menu
[b7c7a1c]	806	self._menubar = wx.MenuBar()
[52b8b74]	807	self._add_menu_file()
[f932c02]	808	self._add_menu_edit()
[34e3ab3]	809	self._add_menu_view()
	810	#self._add_menu_data()
[52b8b74]	811	self._add_menu_application()
[c5e84fb]	812	self._add_menu_tool()
[7bc88bf]	813	self._add_current_plugin_menu()
[52b8b74]	814	self._add_menu_window()
[c5e84fb]	815	self._add_help_menu()
	816	self.SetMenuBar(self._menubar)
	817
[f036c692]	818	def _setup_tool_bar(self):
	819	"""
	820	add toolbar to the frame
	821	"""
	822	#set toolbar
	823	self._toolbar = GUIToolBar(self, -1)
	824	self.SetToolBar(self._toolbar)
[a45037aa]	825	self._update_toolbar_helper()
[3554fd39]	826	self._on_toggle_toolbar(event=None)
[a45037aa]	827
	828	def _update_toolbar_helper(self):
	829	"""
	830	"""
[f7e9af2]	831	application_name = 'No Selected Analysis'
[a45037aa]	832	panel_name = 'No Panel on Focus'
[3450e7f]	833	if self._toolbar is None:
	834	return
[fadf925]	835	if self.cpanel_on_focus is not None:
	836	self.reset_bookmark_menu(self.cpanel_on_focus)
[0a2fdca]	837	self._toolbar.update_toolbar(self.cpanel_on_focus)
[f036c692]	838	if self._current_perspective is not None:
[a45037aa]	839	application_name = self._current_perspective.sub_menu
[0a2fdca]	840	if self.cpanel_on_focus is not None:
	841	panel_name = self.cpanel_on_focus.window_caption
[fadf925]	842
[a45037aa]	843	self._toolbar.update_button(application_name=application_name,
	844	panel_name=panel_name)
[fadf925]	845
[a45037aa]	846	self._toolbar.Realize()
	847
[c5e84fb]	848	def _add_menu_tool(self):
	849	"""
	850	Tools menu
	851	Go through plug-ins and find tools to populate the tools menu
	852	"""
[5342eb8]	853	style = self.__gui_style & GUIFRAME.CALCULATOR_ON
	854	if style == GUIFRAME.CALCULATOR_ON:
[c5e84fb]	855	self._tool_menu = None
	856	for item in self.plugins:
	857	if hasattr(item, "get_tools"):
	858	for tool in item.get_tools():
	859	# Only create a menu if we have at least one tool
	860	if self._tool_menu is None:
	861	self._tool_menu = wx.Menu()
	862	id = wx.NewId()
	863	self._tool_menu.Append(id, tool[0], tool[1])
	864	wx.EVT_MENU(self, id, tool[2])
	865	if self._tool_menu is not None:
[f932c02]	866	self._menubar.Append(self._tool_menu, '&Tool')
[c5e84fb]	867
	868	def _add_current_plugin_menu(self):
	869	"""
	870	add current plugin menu
[cbf22e5]	871	Look for plug-in menus
	872	Add available plug-in sub-menus.
[c5e84fb]	873	"""
[7bc88bf]	874	if (self._menubar is None) or (self._current_perspective is None):
[cbf22e5]	875	return
[7bc88bf]	876	#replace or add a new menu for the current plugin
[4c0572f]	877
	878	pos = self._menubar.FindMenu(str(self._applications_menu_name))
[7bc88bf]	879	if pos != -1:
	880	menu_list = self._current_perspective.populate_menu(self)
	881	if menu_list:
[4c0572f]	882	for (menu, name) in menu_list:
	883	hidden_menu = self._menubar.Replace(pos, menu, name)
	884	self._applications_menu_name = name
	885	#self._applications_menu_pos = pos
[7bc88bf]	886	else:
	887	hidden_menu = self._menubar.Remove(pos)
[4c0572f]	888	self._applications_menu_name = None
[7bc88bf]	889	#get the position of the menu when it first added
[4c0572f]	890	self._applications_menu_pos = pos
	891
[7bc88bf]	892	else:
	893	menu_list = self._current_perspective.populate_menu(self)
	894	if menu_list:
[4c0572f]	895	for (menu,name) in menu_list:
[95f9cc4]	896	if self._applications_menu_pos == -1:
[7bc88bf]	897	self._menubar.Append(menu, name)
	898	else:
[95f9cc4]	899	self._menubar.Insert(self._applications_menu_pos, menu, name)
[4c0572f]	900	self._applications_menu_name = name
[7bc88bf]	901
[c5e84fb]	902	def _add_help_menu(self):
	903	"""
	904	add help menu
	905	"""
[41d466f]	906	# Help menu
[c5e84fb]	907	self._help_menu = wx.Menu()
[d828481]	908	style = self.__gui_style & GUIFRAME.WELCOME_PANEL_ON
[adf44c2]	909	if style == GUIFRAME.WELCOME_PANEL_ON or custom_config != None:
[d828481]	910	# add the welcome panel menu item
	911	if self.defaultPanel is not None:
	912	id = wx.NewId()
	913	self._help_menu.Append(id, '&Welcome', '')
	914	self._help_menu.AppendSeparator()
	915	wx.EVT_MENU(self, id, self.show_welcome_panel)
[fa452e4]	916	# Look for help item in plug-ins
	917	for item in self.plugins:
	918	if hasattr(item, "help"):
	919	id = wx.NewId()
[f7e9af2]	920	self._help_menu.Append(id,'&%s Help' % item.sub_menu, '')
[fa452e4]	921	wx.EVT_MENU(self, id, item.help)
[41d466f]	922	if config._do_aboutbox:
[9d8f193]	923	self._help_menu.AppendSeparator()
[41d466f]	924	id = wx.NewId()
[c5e84fb]	925	self._help_menu.Append(id,'&About', 'Software information')
[41d466f]	926	wx.EVT_MENU(self, id, self._onAbout)
[c5e84fb]	927
[af20f6b]	928	# Checking for updates needs major refactoring to work with py2exe
	929	# We need to make sure it doesn't hang the application if the server
	930	# is not up. We also need to make sure there's a proper executable to
	931	# run if we spawn a new background process.
	932	#id = wx.NewId()
[c5e84fb]	933	#self._help_menu.Append(id,'&Check for update',
[32c0841]	934	#'Check for the latest version of %s' % config.__appname__)
[af20f6b]	935	#wx.EVT_MENU(self, id, self._check_update)
[c5e84fb]	936	self._menubar.Append(self._help_menu, '&Help')
	937
[34e3ab3]	938	def _add_menu_view(self):
	939	"""
	940	add menu items under view menu
	941	"""
	942	self._view_menu = wx.Menu()
	943	style = self.__gui_style & GUIFRAME.MANAGER_ON
	944	id = wx.NewId()
	945	self._data_panel_menu = self._view_menu.Append(id,
[03da8ed]	946	'&Show Data Explorer', '')
[34e3ab3]	947	wx.EVT_MENU(self, id, self.show_data_panel)
	948	if style == GUIFRAME.MANAGER_ON:
[03da8ed]	949	self._data_panel_menu.SetText('Hide Data Explorer')
[34e3ab3]	950	else:
[03da8ed]	951	self._data_panel_menu.SetText('Show Data Explorer')
[34e3ab3]	952	self._view_menu.AppendSeparator()
[570cb96]	953	id = wx.NewId()
[5342eb8]	954	style1 = self.__gui_style & GUIFRAME.TOOLBAR_ON
	955	if style1 == GUIFRAME.TOOLBAR_ON:
[570cb96]	956	self._toolbar_menu = self._view_menu.Append(id,'&Hide Toolbar', '')
[3554fd39]	957	else:
	958	self._toolbar_menu = self._view_menu.Append(id,'&Show Toolbar', '')
	959	wx.EVT_MENU(self, id, self._on_toggle_toolbar)
[34e3ab3]	960
[adf44c2]	961	if custom_config != None:
	962	self._view_menu.AppendSeparator()
	963	id = wx.NewId()
	964	preference_menu = self._view_menu.Append(id,'Startup Setting', '')
	965	wx.EVT_MENU(self, id, self._on_preference_menu)
	966
	967	self._menubar.Append(self._view_menu, '&View')
	968
	969	def _on_preference_menu(self, event):
	970	"""
	971	Build a panel to allow to edit Mask
	972	"""
	973
	974	from sans.guiframe.startup_configuration \
	975	import StartupConfiguration as ConfDialog
	976
	977	self.panel = ConfDialog(parent=self, gui=self.__gui_style)
	978	#self.panel.Bind(wx.EVT_CLOSE, self._draw_masked_model)
	979	self.panel.ShowModal()
	980	#wx.PostEvent(self.parent, event)
	981
	982	def _draw_masked_model(self,event):
	983	"""
	984	Draw model image w/mask
	985	"""
	986	event.Skip()
	987
	988	is_valid_qrange = self._update_paramv_on_fit()
	989
	990	if is_valid_qrange:
	991	# try re draw the model plot if it exists
	992	self._draw_model()
	993	self.panel.Destroy() # frame
	994	self.set_npts2fit()
	995	elif self.model == None:
	996	self.panel.Destroy()
	997	self.set_npts2fit()
	998	msg= "No model is found on updating MASK in the model plot... "
	999	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
	1000	else:
	1001	msg = ' Please consider your Q range, too.'
	1002	self.panel.ShowMessage(msg)
	1003
[52b8b74]	1004	def _add_menu_window(self):
	1005	"""
	1006	add a menu window to the menu bar
	1007	Window menu
	1008	Attach a menu item for each panel in our
	1009	panel list that also appears in a plug-in.
	1010
	1011	Only add the panel menu if there is only one perspective and
	1012	it has more than two panels.
	1013	Note: the first plug-in is always the plotting plug-in.
	1014	The first application
	1015	#plug-in is always the second one in the list.
	1016	"""
	1017	self._window_menu = wx.Menu()
	1018	if self._plotting_plugin is not None:
[bf4402c3]	1019	for (menu, name) in self._plotting_plugin.populate_menu(self):
[52b8b74]	1020	self._window_menu.AppendSubMenu(menu, name)
[52f3c98]	1021	self._menubar.Append(self._window_menu, '&Graph')
	1022
[4753fc2]	1023	style = self.__gui_style & GUIFRAME.PLOTTING_ON
	1024	if style == GUIFRAME.PLOTTING_ON:
	1025	self._window_menu.AppendSeparator()
	1026	id = wx.NewId()
	1027	preferences_menu = wx.Menu()
[f932c02]	1028	hint = "All plot panels will floating"
[f2d9e76]	1029	preferences_menu.AppendRadioItem(id, '&Float All', hint)
[4753fc2]	1030	wx.EVT_MENU(self, id, self.set_plotpanel_floating)
[f2d9e76]	1031	style = self.__gui_style & GUIFRAME.FLOATING_PANEL
	1032	f_menu = preferences_menu.FindItemById(id)
	1033	if style == GUIFRAME.FLOATING_PANEL:
	1034	f_checked = True
	1035	else:
	1036	f_checked = False
	1037	f_menu.Check(f_checked)
	1038
[4753fc2]	1039	id = wx.NewId()
[f932c02]	1040	hint = "All plot panels will displayed within the frame"
[f2d9e76]	1041	preferences_menu.AppendRadioItem(id, '&Dock All', hint)
	1042	wx.EVT_MENU(self, id, self.set_plotpanel_fixed)
	1043	if not f_checked:
	1044	d_menu = preferences_menu.FindItemById(id)
	1045	d_menu.Check(True)
	1046	preferences_menu.AppendSeparator()
	1047	id = wx.NewId()
	1048	hint = "Clean up the dock area for plots on new-plot"
	1049	preferences_menu.AppendCheckItem(id, '&CleanUp Dock on NewPlot', hint)
	1050	wx.EVT_MENU(self, id, self.on_cleanup_dock)
	1051	flag = self.cleanup_plots
	1052	if self.cleanup_plots:
	1053	c_menu = preferences_menu.FindItemById(id)
	1054	c_menu.Check(True)
[4753fc2]	1055	self._window_menu.AppendSubMenu(preferences_menu,'&Preferences')
[d828481]	1056	if self._window_menu.GetMenuItemCount() == 0:
[52f3c98]	1057	pos = self._menubar.FindMenu('Graph')
[d828481]	1058	self._menubar.Remove(pos)
[7a67e075]	1059	#wx.EVT_MENU(self, id, self.show_preferences_panel)
[52b8b74]	1060	"""
	1061	if len(self.plugins) == 2:
	1062	plug = self.plugins[1]
	1063	pers = plug.get_perspective()
	1064
	1065	if len(pers) > 1:
	1066	self._window_menu = wx.Menu()
	1067	for item in self.panels:
	1068	if item == 'default':
	1069	continue
	1070	panel = self.panels[item]
	1071	if panel.window_name in pers:
	1072	self._window_menu.Append(int(item),
	1073	panel.window_caption,
	1074	"Show %s window" % panel.window_caption)
[56d5562]	1075	wx.EVT_MENU(self, int(item), self.on_view)
[52b8b74]	1076	self._menubar.Append(self._window_menu, '&Window')
	1077	"""
[f2d9e76]	1078
[52b8b74]	1079
	1080	def _add_menu_application(self):
	1081	"""
	1082
	1083	# Attach a menu item for each defined perspective or application.
	1084	# Only add the perspective menu if there are more than one perspectives
	1085	add menu application
	1086	"""
[f2d9e76]	1087	#style = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
	1088	#if style == GUIFRAME.MULTIPLE_APPLICATIONS:
	1089	if self._num_perspectives > 1:
[95f9cc4]	1090	plug_data_count = False
	1091	plug_no_data_count = False
	1092	self._applications_menu = wx.Menu()
[788ff23]	1093	pos = 0
[95f9cc4]	1094	separator = self._applications_menu.AppendSeparator()
[52b8b74]	1095	for plug in self.plugins:
	1096	if len(plug.get_perspective()) > 0:
	1097	id = wx.NewId()
[95f9cc4]	1098	if plug.use_data():
[788ff23]	1099
	1100	self._applications_menu.InsertCheckItem(pos, id, plug.sub_menu,
[f7e9af2]	1101	"Switch to analysis: %s" % plug.sub_menu)
[95f9cc4]	1102	plug_data_count = True
[788ff23]	1103	pos += 1
[95f9cc4]	1104	else:
	1105	plug_no_data_count = True
	1106	self._applications_menu.AppendCheckItem(id, plug.sub_menu,
[f7e9af2]	1107	"Switch to analysis: %s" % plug.sub_menu)
[52b8b74]	1108	wx.EVT_MENU(self, id, plug.on_perspective)
[788ff23]	1109	#self._applications_menu.
	1110	if (not plug_data_count or not plug_no_data_count):
[95f9cc4]	1111	self._applications_menu.RemoveItem(separator)
[f7e9af2]	1112	self._menubar.Append(self._applications_menu, '&Analysis')
[95f9cc4]	1113	self._check_applications_menu()
[52b8b74]	1114
[34e3ab3]	1115	def _populate_file_menu(self):
	1116	"""
	1117	Insert menu item under file menu
	1118	"""
	1119	for plugin in self.plugins:
	1120	if len(plugin.populate_file_menu()) > 0:
	1121	for item in plugin.populate_file_menu():
	1122	m_name, m_hint, m_handler = item
	1123	id = wx.NewId()
	1124	self._file_menu.Append(id, m_name, m_hint)
	1125	wx.EVT_MENU(self, id, m_handler)
	1126	self._file_menu.AppendSeparator()
	1127
[52b8b74]	1128	def _add_menu_file(self):
	1129	"""
	1130	add menu file
	1131	"""
[d828481]	1132
[52b8b74]	1133	# File menu
[52725d6]	1134	self._file_menu = wx.Menu()
[34e3ab3]	1135	#append item from plugin under menu file if necessary
	1136	self._populate_file_menu()
[d828481]	1137	style = self.__gui_style & GUIFRAME.DATALOADER_ON
[4c01978]	1138	style1 = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
[a03d419]	1139
	1140	id = wx.NewId()
[f2d9e76]	1141	hint_load_file = "read all analysis states saved previously"
[a03d419]	1142	self._save_appl_menu = self._file_menu.Append(id,
	1143	'&Open Project', hint_load_file)
	1144	wx.EVT_MENU(self, id, self._on_open_state_project)
	1145
	1146	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
	1147	# some menu of plugin to be seen under file menu
	1148	hint_load_file = "Read a status files and load"
	1149	hint_load_file += " them into the analysis"
[f7e9af2]	1150	id = wx.NewId()
	1151	self._save_appl_menu = self._file_menu.Append(id,
[a03d419]	1152	'&Open Analysis', hint_load_file)
	1153	wx.EVT_MENU(self, id, self._on_open_state_application)
[4c01978]	1154
[a03d419]	1155	self._file_menu.AppendSeparator()
	1156	id = wx.NewId()
	1157	self._file_menu.Append(id, '&Save Project',
	1158	'Save the state of the whole analysis')
	1159	wx.EVT_MENU(self, id, self._on_save_project)
	1160	if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
	1161	#self._file_menu.AppendSeparator()
[d828481]	1162	id = wx.NewId()
[a03d419]	1163	self._save_appl_menu = self._file_menu.Append(id,
	1164	'&Save Analysis',
	1165	'Save state of the current active analysis panel')
	1166	wx.EVT_MENU(self, id, self._on_save_application)
	1167
	1168	self._file_menu.AppendSeparator()
[52725d6]	1169
	1170	id = wx.NewId()
	1171	self._file_menu.Append(id, '&Quit', 'Exit')
[52b8b74]	1172	wx.EVT_MENU(self, id, self.Close)
	1173	# Add sub menus
[52725d6]	1174	self._menubar.Append(self._file_menu, '&File')
[52b8b74]	1175
[d828481]	1176	def _add_menu_edit(self):
	1177	"""
	1178	add menu edit
	1179	"""
	1180	# Edit Menu
	1181	self._edit_menu = wx.Menu()
[f036c692]	1182	self._edit_menu.Append(GUIFRAME_ID.UNDO_ID, '&Undo',
	1183	'Undo the previous action')
	1184	wx.EVT_MENU(self, GUIFRAME_ID.UNDO_ID, self.on_undo_panel)
	1185	self._edit_menu.Append(GUIFRAME_ID.REDO_ID, '&Redo',
	1186	'Redo the previous action')
	1187	wx.EVT_MENU(self, GUIFRAME_ID.REDO_ID, self.on_redo_panel)
[d828481]	1188	self._edit_menu.AppendSeparator()
[783940c]	1189	self._edit_menu.Append(GUIFRAME_ID.PREVIEW_ID, '&Report',
[f036c692]	1190	'Preview current panel')
	1191	wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel)
[3ce9937]	1192	#self._edit_menu.Append(GUIFRAME_ID.PRINT_ID, '&Print',
	1193	# 'Print current panel')
	1194	#wx.EVT_MENU(self, GUIFRAME_ID.PRINT_ID, self.on_print_panel)
[f036c692]	1195	self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset',
	1196	'Reset current panel')
	1197	wx.EVT_MENU(self, GUIFRAME_ID.RESET_ID, self.on_reset_panel)
[34e3ab3]	1198
[f036c692]	1199	self._menubar.Append(self._edit_menu, '&Edit')
	1200	self.enable_edit_menu()
[d828481]	1201
[75fbd17]	1202	def get_style(self):
[52b8b74]	1203	"""
	1204	"""
[75fbd17]	1205	return self.__gui_style
	1206
	1207	def _add_menu_data(self):
[52b8b74]	1208	"""
[75fbd17]	1209	Add menu item item data to menu bar
[52b8b74]	1210	"""
[75fbd17]	1211	if self._data_plugin is not None:
	1212	menu_list = self._data_plugin.populate_menu(self)
	1213	if menu_list:
	1214	for (menu, name) in menu_list:
	1215	self._menubar.Append(menu, name)
[34e3ab3]	1216
[f932c02]	1217
[3554fd39]	1218	def _on_toggle_toolbar(self, event=None):
[a45037aa]	1219	"""
	1220	hide or show toolbar
	1221	"""
	1222	if self._toolbar is None:
	1223	return
	1224	if self._toolbar.IsShown():
	1225	if self._toolbar_menu is not None:
	1226	self._toolbar_menu.SetItemLabel('Show Toolbar')
	1227	self._toolbar.Hide()
	1228	else:
	1229	if self._toolbar_menu is not None:
	1230	self._toolbar_menu.SetItemLabel('Hide Toolbar')
	1231	self._toolbar.Show()
	1232	self._toolbar.Realize()
	1233
[41d466f]	1234	def _on_status_event(self, evt):
	1235	"""
[d955bf19]	1236	Display status message
[41d466f]	1237	"""
[35aa210]	1238	# This CallAfter fixes many crashes on MAC.
[2608933]	1239	wx.CallAfter(self.sb.set_status, evt)
[dd66fbd]	1240
[56d5562]	1241	def on_view(self, evt):
[41d466f]	1242	"""
[d955bf19]	1243	A panel was selected to be shown. If it's not already
	1244	shown, display it.
	1245
	1246	:param evt: menu event
	1247
[41d466f]	1248	"""
[dee097b]	1249	panel_id = str(evt.GetId())
	1250	self.on_set_plot_focus(self.panels[panel_id])
	1251	self.show_panel(evt.GetId(), 'on')
[6d727ae]	1252	wx.CallLater(5, self.set_schedule(True))
[dee097b]	1253	self.set_plot_unfocus()
[c1469ebe]	1254
[b28278e]	1255	def on_close_welcome_panel(self):
[c1469ebe]	1256	"""
[d955bf19]	1257	Close the welcome panel
[c1469ebe]	1258	"""
[629e8b9]	1259	if self.defaultPanel is None:
	1260	return
[1b1bbf9]	1261	default_panel = self._mgr.GetPane(self.panels["default"].window_name)
	1262	if default_panel.IsShown():
	1263	default_panel.Hide()
[4d1dce4]	1264	# Recover current perspective
	1265	perspective = self._current_perspective
	1266	perspective.on_perspective(event=None)
[1b1bbf9]	1267	self._mgr.Update()
	1268	# Show toolbar
[0fb74ef]	1269	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
	1270	#if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
	1271	# self._on_toggle_toolbar()
[1b1bbf9]	1272
[c1469ebe]	1273	def show_welcome_panel(self, event):
	1274	"""
[d955bf19]	1275	Display the welcome panel
[c1469ebe]	1276	"""
[629e8b9]	1277	if self.defaultPanel is None:
	1278	return
[4bee68d]	1279	for id, panel in self.panels.iteritems():
[c5e84fb]	1280	if id == 'default':
	1281	# Show default panel
	1282	if not self._mgr.GetPane(self.panels["default"].window_name).IsShown():
	1283	self._mgr.GetPane(self.panels["default"].window_name).Show(True)
	1284	elif id == "data_panel":
	1285	flag = self._mgr.GetPane(self.panels["data_panel"].window_name).IsShown()
	1286	self._mgr.GetPane(self.panels["data_panel"].window_name).Show(flag)
[4bee68d]	1287	elif panel not in self.plot_panels.values() :
[c5e84fb]	1288	self._mgr.GetPane(self.panels[id].window_name).IsShown()
[c1469ebe]	1289	self._mgr.GetPane(self.panels[id].window_name).Hide()
[9d8f193]	1290	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
	1291	#if (style == GUIFRAME.TOOLBAR_ON) & (self._toolbar.IsShown()):
	1292	# # self._toolbar.Show(True)
	1293	# self._on_toggle_toolbar()
[1b1bbf9]	1294
[c1469ebe]	1295	self._mgr.Update()
[c5e84fb]	1296
[6d727ae]	1297	def show_panel(self, uid, show=None):
[41d466f]	1298	"""
[d955bf19]	1299	Shows the panel with the given id
	1300
	1301	:param uid: unique ID number of the panel to show
	1302
[41d466f]	1303	"""
	1304	ID = str(uid)
	1305	config.printEVT("show_panel: %s" % ID)
	1306	if ID in self.panels.keys():
[6d727ae]	1307	if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():
	1308	if show == 'on':
	1309	self._mgr.GetPane(self.panels[ID].window_name).Show()
[52f3c98]	1310	elif self.panels[ID].window_caption.split(" ")[0] == \
	1311	"Residuals":
[6d727ae]	1312	self._mgr.GetPane(self.panels[ID].window_name).Hide()
	1313	else:
	1314	self._mgr.GetPane(self.panels[ID].window_name).Show()
[383189f9]	1315	# Hide default panel
	1316	self._mgr.GetPane(self.panels["default"].window_name).Hide()
[6d727ae]	1317	self._mgr.Update()
	1318	self._redraw_idle()
	1319
[ae83ad3]	1320	def hide_panel(self, uid):
	1321	"""
[f2d9e76]	1322	hide panel except default panel
[ae83ad3]	1323	"""
	1324	ID = str(uid)
[0a2fdca]	1325	caption = self.panels[ID].window_caption
[ae83ad3]	1326	config.printEVT("hide_panel: %s" % ID)
	1327	if ID in self.panels.keys():
	1328	if self._mgr.GetPane(self.panels[ID].window_name).IsShown():
	1329	self._mgr.GetPane(self.panels[ID].window_name).Hide()
[0a2fdca]	1330	if self._data_panel is not None and \
	1331	ID in self.plot_panels.keys():
	1332	self._data_panel.cb_plotpanel.Append(str(caption), p)
[f2d9e76]	1333	# Do not Hide default panel here...
	1334	#self._mgr.GetPane(self.panels["default"].window_name).Hide()
[ae83ad3]	1335	self._mgr.Update()
[0a2fdca]	1336
[c9937c0]	1337	def delete_panel(self, uid):
	1338	"""
	1339	delete panel given uid
	1340	"""
	1341	ID = str(uid)
	1342	config.printEVT("delete_panel: %s" % ID)
[0a2fdca]	1343	caption = self.panels[ID].window_caption
[c9937c0]	1344	if ID in self.panels.keys():
[f7d0b74]	1345	self.panel_on_focus = None
[df22224]	1346	panel = self.panels[ID]
	1347	self._plotting_plugin.delete_panel(panel.group_id)
	1348	self._mgr.DetachPane(panel)
[f7d0b74]	1349	panel.Hide()
	1350	panel.clear()
	1351	panel.Close()
	1352	self._mgr.Update()
[d64dfd2]	1353	#delete uid number not str(uid)
	1354	if uid in self.plot_panels.keys():
	1355	del self.plot_panels[uid]
[f7d0b74]	1356	return
[c9937c0]	1357
[75fbd17]	1358	def clear_panel(self):
[b3644f3]	1359	"""
	1360	"""
[75fbd17]	1361	for item in self.panels:
	1362	try:
	1363	self.panels[item].clear_panel()
	1364	except:
	1365	pass
	1366
	1367	def create_gui_data(self, data, path=None):
	1368	"""
[0348245]	1369	"""
	1370	return self._data_manager.create_gui_data(data, path)
	1371
[03314e7]	1372	def get_data(self, path):
[75fbd17]	1373	"""
	1374	"""
	1375	message = ""
	1376	log_msg = ''
	1377	output = []
	1378	error_message = ""
	1379	basename = os.path.basename(path)
	1380	root, extension = os.path.splitext(basename)
	1381	if extension.lower() not in EXTENSIONS:
	1382	log_msg = "File Loader cannot "
	1383	log_msg += "load: %s\n" % str(basename)
	1384	log_msg += "Try Data opening...."
	1385	logging.info(log_msg)
	1386	self.load_complete(output=output, error_message=error_message,
	1387	message=log_msg, path=path)
[700f9b4]	1388	return
[75fbd17]	1389
	1390	#reading a state file
	1391	for plug in self.plugins:
[03314e7]	1392	reader, ext = plug.get_extensions()
	1393	if reader is not None:
	1394	#read the state of the single plugin
	1395	if extension == ext:
	1396	reader.read(path)
	1397	return
[957723f]	1398	elif extension == APPLICATION_STATE_EXTENSION:
[03314e7]	1399	reader.read(path)
	1400
[75fbd17]	1401	style = self.__gui_style & GUIFRAME.MANAGER_ON
	1402	if style == GUIFRAME.MANAGER_ON:
	1403	if self._data_panel is not None:
[f7d0b74]	1404	#data_state = self._data_manager.get_selected_data()
	1405	#self._data_panel.load_data_list(data_state)
[75fbd17]	1406	self._mgr.GetPane(self._data_panel.window_name).Show(True)
[976604d]	1407
	1408	def load_from_cmd(self, path):
	1409	"""
[c3f697e]	1410	load data from cmd or application
[976604d]	1411	"""
[c3f697e]	1412	if path is None:
[976604d]	1413	return
	1414	else:
	1415	path = os.path.abspath(path)
[5c3d2d3]	1416	if not os.path.isfile(path) and not os.path.isdir(path):
[976604d]	1417	return
[5c3d2d3]	1418
	1419	if os.path.isdir(path):
	1420	self.load_folder(path)
	1421	return
	1422
[976604d]	1423	basename = os.path.basename(path)
	1424	root, extension = os.path.splitext(basename)
	1425	if extension.lower() not in EXTENSIONS:
	1426	self.load_data(path)
	1427	else:
	1428	self.load_state(path)
[022af4d]	1429
	1430	self._default_save_location = os.path.dirname(path)
	1431
[957723f]	1432	def load_state(self, path):
	1433	"""
[c3f697e]	1434	load data from command line or application
[957723f]	1435	"""
[976604d]	1436	if path and (path is not None) and os.path.isfile(path):
[957723f]	1437	basename = os.path.basename(path)
	1438	if APPLICATION_STATE_EXTENSION is not None \
	1439	and basename.endswith(APPLICATION_STATE_EXTENSION):
[9c35257]	1440	#Hide current plot_panels i
	1441	for ID in self.plot_panels.keys():
	1442	panel = self._mgr.GetPane(self.plot_panels[ID].window_name)
	1443	if panel.IsShown():
	1444	panel.Hide()
[1793cef]	1445	self.get_data(path)
[957723f]	1446	if self.defaultPanel is not None and \
	1447	self._mgr.GetPane(self.panels["default"].window_name).IsShown():
	1448	self.on_close_welcome_panel()
	1449
	1450	def load_data(self, path):
	1451	"""
[c3f697e]	1452	load data from command line
[957723f]	1453	"""
	1454	if not os.path.isfile(path):
	1455	return
	1456	basename = os.path.basename(path)
	1457	root, extension = os.path.splitext(basename)
	1458	if extension.lower() in EXTENSIONS:
	1459	log_msg = "Data Loader cannot "
	1460	log_msg += "load: %s\n" % str(path)
	1461	log_msg += "Try File opening ...."
	1462	print log_msg
	1463	return
[c3f697e]	1464	message = ""
	1465	log_msg = ''
	1466	output = {}
	1467	error_message = ""
[957723f]	1468	try:
[c3f697e]	1469	print "Loading Data...:\n" + str(path) + "\n"
[957723f]	1470	temp = self.loader.load(path)
	1471	if temp.__class__.__name__ == "list":
	1472	for item in temp:
[c3f697e]	1473	data = self.create_gui_data(item, path)
[957723f]	1474	output[data.id] = data
	1475	else:
[c3f697e]	1476	data = self.create_gui_data(temp, path)
[957723f]	1477	output[data.id] = data
	1478
	1479	self.add_data(data_list=output)
	1480	except:
[c3f697e]	1481	error_message = "Error while loading"
	1482	error_message += " Data from cmd:\n %s\n" % str(path)
[957723f]	1483	error_message += str(sys.exc_value) + "\n"
	1484	print error_message
	1485
[5c3d2d3]	1486	def load_folder(self, path):
	1487	"""
	1488	Load entire folder
	1489	"""
	1490	if not os.path.isdir(path):
	1491	return
	1492	if self._data_plugin is None:
	1493	return
	1494	try:
	1495	if path is not None:
	1496	self._default_save_location = os.path.dirname(path)
	1497	file_list = self._data_plugin.get_file_path(path)
	1498	self._data_plugin.get_data(file_list)
	1499	else:
	1500	return
	1501	except:
	1502	error_message = "Error while loading"
	1503	error_message += " Data folder from cmd:\n %s\n" % str(path)
	1504	error_message += str(sys.exc_value) + "\n"
	1505	print error_message
	1506
[4c01978]	1507	def _on_open_state_application(self, event):
	1508	"""
	1509	"""
	1510	path = None
	1511	if self._default_save_location == None:
	1512	self._default_save_location = os.getcwd()
[d38d0042]	1513
	1514	plug_wlist = self._on_open_state_app_helper()
[4c01978]	1515	dlg = wx.FileDialog(self,
	1516	"Choose a file",
	1517	self._default_save_location, "",
[32d26da]	1518	plug_wlist)
[4c01978]	1519	if dlg.ShowModal() == wx.ID_OK:
	1520	path = dlg.GetPath()
	1521	if path is not None:
	1522	self._default_save_location = os.path.dirname(path)
	1523	dlg.Destroy()
	1524	self.load_state(path=path)
[d38d0042]	1525
	1526	def _on_open_state_app_helper(self):
	1527	"""
	1528	Helps '_on_open_state_application()' to find the extension of
	1529	the current perspective/application
	1530	"""
	1531	# No current perspective or no extension attr
	1532	if self._current_perspective is None:
	1533	return PLUGINS_WLIST
	1534	try:
	1535	# Find the extension of the perspective and get that as 1st item in list
	1536	ind = None
	1537	app_ext = self._current_perspective._extensions
	1538	plug_wlist = config.PLUGINS_WLIST
	1539	for ext in set(plug_wlist):
	1540	if ext.count(app_ext) > 0:
	1541	ind = ext
	1542	break
	1543	# Found the extension
	1544	if ind != None:
	1545	plug_wlist.remove(ind)
	1546	plug_wlist.insert(0, ind)
	1547	try:
	1548	plug_wlist ='\|'.join(plug_wlist)
	1549	except:
	1550	plug_wlist = ''
[32d26da]	1551
[d38d0042]	1552	except:
	1553	plug_wlist = PLUGINS_WLIST
[957723f]	1554
[32d26da]	1555	return plug_wlist
	1556
[4c01978]	1557	def _on_open_state_project(self, event):
[75fbd17]	1558	"""
	1559	"""
	1560	path = None
	1561	if self._default_save_location == None:
	1562	self._default_save_location = os.getcwd()
[d38d0042]	1563
[75fbd17]	1564	dlg = wx.FileDialog(self,
	1565	"Choose a file",
	1566	self._default_save_location, "",
[4c01978]	1567	APPLICATION_WLIST)
[75fbd17]	1568	if dlg.ShowModal() == wx.ID_OK:
	1569	path = dlg.GetPath()
	1570	if path is not None:
	1571	self._default_save_location = os.path.dirname(path)
	1572	dlg.Destroy()
[1793cef]	1573
	1574	#try:
	1575	# os.popen(path)
	1576	# #self.Close()
	1577	#except:
[957723f]	1578	self.load_state(path=path)
[1793cef]	1579
[52725d6]	1580	def _on_save_application(self, event):
[b35d3d1]	1581	"""
[52725d6]	1582	save the state of the current active application
[b35d3d1]	1583	"""
[0a2fdca]	1584	if self.cpanel_on_focus is not None:
	1585	self.cpanel_on_focus.on_save(event)
[52725d6]	1586
	1587	def _on_save_project(self, event):
	1588	"""
[23cdeab]	1589	save the state of the SansView as *.svs
[52725d6]	1590	"""
	1591	## Default file location for save
	1592	self._default_save_location = os.getcwd()
	1593	if self._current_perspective is None:
	1594	return
	1595	reader, ext = self._current_perspective.get_extensions()
	1596	path = None
[2e3f9e3]	1597	extension = '*' + APPLICATION_STATE_EXTENSION
[75fbd17]	1598	dlg = wx.FileDialog(self, "Save Project file",
[957723f]	1599	self._default_save_location, "",
[2e3f9e3]	1600	extension,
[957723f]	1601	wx.SAVE)
[52725d6]	1602	if dlg.ShowModal() == wx.ID_OK:
	1603	path = dlg.GetPath()
	1604	self._default_save_location = os.path.dirname(path)
	1605	else:
	1606	return None
	1607	dlg.Destroy()
	1608	if path is None:
	1609	return
	1610	# default cansas xml doc
	1611	doc = None
	1612	for panel in self.panels.values():
[6f28e70]	1613	temp = panel.save_project(doc)
	1614	if temp is not None:
	1615	doc = temp
	1616
[2e3f9e3]	1617	# Write the XML document
[23cdeab]	1618	extens = APPLICATION_STATE_EXTENSION
	1619	fName = os.path.splitext(path)[0] + extens
[2e3f9e3]	1620	if doc != None:
[23cdeab]	1621	fd = open(fName, 'w')
[2e3f9e3]	1622	fd.write(doc.toprettyxml())
	1623	fd.close()
	1624	else:
	1625	msg = "%s cannot read %s\n" % (str(APPLICATION_NAME), str(path))
[6f28e70]	1626	logging.error(msg)
[2e3f9e3]	1627
[52725d6]	1628	def on_save_helper(self, doc, reader, panel, path):
	1629	"""
	1630	Save state into a file
	1631	"""
	1632	try:
	1633	if reader is not None:
[2e3f9e3]	1634	# case of a panel with multi-pages
	1635	if hasattr(panel, "opened_pages"):
	1636	for uid, page in panel.opened_pages.iteritems():
	1637	data = page.get_data()
	1638	# state must be cloned
	1639	state = page.get_state().clone()
	1640	if data is not None:
	1641	new_doc = reader.write_toXML(data, state)
	1642	if doc != None and hasattr(doc, "firstChild"):
	1643	child = new_doc.firstChild.firstChild
	1644	doc.firstChild.appendChild(child)
	1645	else:
	1646	doc = new_doc
	1647	# case of only a panel
	1648	else:
	1649	data = panel.get_data()
	1650	state = panel.get_state()
	1651	if data is not None:
	1652	new_doc = reader.write_toXML(data, state)
	1653	if doc != None and hasattr(doc, "firstChild"):
	1654	child = new_doc.firstChild.firstChild
	1655	doc.firstChild.appendChild(child)
	1656	else:
	1657	doc = new_doc
[52725d6]	1658	except:
	1659	raise
	1660	#pass
[2e3f9e3]	1661
[52725d6]	1662	return doc
[b35d3d1]	1663
[b5ca223]	1664	def quit_guiframe(self):
	1665	"""
	1666	Pop up message to make sure the user wants to quit the application
	1667	"""
	1668	message = "Do you really want to quit \n"
	1669	message += "this application?"
	1670	dial = wx.MessageDialog(self, message, 'Question',
	1671	wx.YES_NO\|wx.YES_DEFAULT\|wx.ICON_QUESTION)
	1672	if dial.ShowModal() == wx.ID_YES:
	1673	return True
	1674	else:
	1675	return False
	1676
[41d466f]	1677	def Close(self, event=None):
	1678	"""
[d955bf19]	1679	Quit the application
[41d466f]	1680	"""
[52725d6]	1681	#flag = self.quit_guiframe()
	1682	if True:
[ba535a6]	1683	wx.Exit()
	1684	sys.exit()
[41d466f]	1685
	1686	def _check_update(self, event=None):
	1687	"""
[d955bf19]	1688	Check with the deployment server whether a new version
	1689	of the application is available.
	1690	A thread is started for the connecting with the server. The thread calls
	1691	a call-back method when the current version number has been obtained.
[52070a1]	1692	"""
[d68c655]	1693	if hasattr(config, "__update_URL__"):
	1694	import version
[32c0841]	1695	checker = version.VersionThread(config.__update_URL__,
	1696	self._process_version,
	1697	baggage=event==None)
[d68c655]	1698	checker.start()
[52070a1]	1699
	1700	def _process_version(self, version, standalone=True):
	1701	"""
[d955bf19]	1702	Call-back method for the process of checking for updates.
	1703	This methods is called by a VersionThread object once the current
	1704	version number has been obtained. If the check is being done in the
	1705	background, the user will not be notified unless there's an update.
	1706
	1707	:param version: version string
	1708	:param standalone: True of the update is being checked in
	1709	the background, False otherwise.
	1710
[52070a1]	1711	"""
	1712	try:
[32c0841]	1713	if cmp(version, config.__version__) > 0:
	1714	msg = "Version %s is available! See the Help "
	1715	msg += "menu to download it." % version
	1716	self.SetStatusText(msg)
[52070a1]	1717	if not standalone:
	1718	import webbrowser
	1719	webbrowser.open(config.__download_page__)
	1720	else:
	1721	if not standalone:
[32c0841]	1722	msg = "You have the latest version"
	1723	msg += " of %s" % config.__appname__
	1724	self.SetStatusText(msg)
[41d466f]	1725	except:
[32c0841]	1726	msg = "guiframe: could not get latest application"
	1727	msg += " version number\n %s" % sys.exc_value
	1728	logging.error(msg)
[52070a1]	1729	if not standalone:
[32c0841]	1730	msg = "Could not connect to the application server."
	1731	msg += " Please try again later."
	1732	self.SetStatusText(msg)
[52070a1]	1733
[41d466f]	1734	def _onAbout(self, evt):
	1735	"""
[d955bf19]	1736	Pop up the about dialog
	1737
	1738	:param evt: menu event
	1739
[41d466f]	1740	"""
	1741	if config._do_aboutbox:
	1742	import aboutbox
	1743	dialog = aboutbox.DialogAbout(None, -1, "")
[6ab0ad1]	1744	dialog.ShowModal()
[4e9583c]	1745
[41d466f]	1746	def set_manager(self, manager):
	1747	"""
[d955bf19]	1748	Sets the application manager for this frame
	1749
	1750	:param manager: frame manager
[41d466f]	1751	"""
	1752	self.app_manager = manager
	1753
	1754	def post_init(self):
	1755	"""
[d955bf19]	1756	This initialization method is called after the GUI
	1757	has been created and all plug-ins loaded. It calls
	1758	the post_init() method of each plug-in (if it exists)
	1759	so that final initialization can be done.
[41d466f]	1760	"""
	1761	for item in self.plugins:
	1762	if hasattr(item, "post_init"):
	1763	item.post_init()
	1764
[b28278e]	1765	def set_default_perspective(self):
	1766	"""
[d955bf19]	1767	Choose among the plugin the first plug-in that has
	1768	"set_default_perspective" method and its return value is True will be
	1769	as a default perspective when the welcome page is closed
[b28278e]	1770	"""
	1771	for item in self.plugins:
	1772	if hasattr(item, "set_default_perspective"):
	1773	if item.set_default_perspective():
[749eb8a]	1774	item.on_perspective(event=None)
[b28278e]	1775	return
[f444b20]	1776
[41d466f]	1777	def set_perspective(self, panels):
	1778	"""
[d955bf19]	1779	Sets the perspective of the GUI.
	1780	Opens all the panels in the list, and closes
	1781	all the others.
	1782
	1783	:param panels: list of panels
[41d466f]	1784	"""
[adf44c2]	1785	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
	1786	#if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
	1787	# self._on_toggle_toolbar()
[41d466f]	1788	for item in self.panels:
	1789	# Check whether this is a sticky panel
	1790	if hasattr(self.panels[item], "ALWAYS_ON"):
	1791	if self.panels[item].ALWAYS_ON:
	1792	continue
[1b1bbf9]	1793
[41d466f]	1794	if self.panels[item].window_name in panels:
	1795	if not self._mgr.GetPane(self.panels[item].window_name).IsShown():
	1796	self._mgr.GetPane(self.panels[item].window_name).Show()
	1797	else:
[3feed3e]	1798	# always show the data panel if enable
	1799	style = self.__gui_style & GUIFRAME.MANAGER_ON
	1800	if (style == GUIFRAME.MANAGER_ON) and self.panels[item] == self._data_panel:
	1801	if 'data_panel' in self.panels.keys():
	1802	flag = self._mgr.GetPane(self.panels['data_panel'].window_name).IsShown()
	1803	self._mgr.GetPane(self.panels['data_panel'].window_name).Show(flag)
	1804	else:
	1805	if self._mgr.GetPane(self.panels[item].window_name).IsShown():
	1806	self._mgr.GetPane(self.panels[item].window_name).Hide()
[1b1bbf9]	1807
[41d466f]	1808	self._mgr.Update()
[4e9583c]	1809
[1b1bbf9]	1810	def show_data_panel(self, event=None, action=True):
[52b8b74]	1811	"""
[3feed3e]	1812	show the data panel
[52b8b74]	1813	"""
[1b1bbf9]	1814	if self._data_panel_menu == None:
	1815	return
[e75b5fa]	1816	label = self._data_panel_menu.GetText()
[03da8ed]	1817	if label == 'Show Data Explorer':
[75fbd17]	1818	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
	1819	#if not pane.IsShown():
[1b1bbf9]	1820	if action:
	1821	pane.Show(True)
	1822	self._mgr.Update()
[e75b5fa]	1823	self.__gui_style = self.__gui_style \| GUIFRAME.MANAGER_ON
	1824
[03da8ed]	1825	self._data_panel_menu.SetText('Hide Data Explorer')
[e75b5fa]	1826	else:
	1827	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
	1828	#if not pane.IsShown():
[1b1bbf9]	1829	if action:
	1830	pane.Show(False)
	1831	self._mgr.Update()
[e75b5fa]	1832	self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
[03da8ed]	1833	self._data_panel_menu.SetText('Show Data Explorer')
[c70eb7c]	1834
	1835	def add_data_helper(self, data_list):
	1836	"""
	1837	"""
[e88ebfd]	1838	if self._data_manager is not None:
	1839	self._data_manager.add_data(data_list)
[c70eb7c]	1840
[75fbd17]	1841	def add_data(self, data_list):
[f444b20]	1842	"""
[e88ebfd]	1843	receive a dictionary of data from loader
	1844	store them its data manager if possible
	1845	send to data the current active perspective if the data panel
	1846	is not active.
	1847	:param data_list: dictionary of data's ID and value Data
[f444b20]	1848	"""
[e88ebfd]	1849	#Store data into manager
	1850	self.add_data_helper(data_list)
	1851	# set data in the data panel
	1852	if self._data_panel is not None:
	1853	data_state = self._data_manager.get_data_state(data_list.keys())
	1854	self._data_panel.load_data_list(data_state)
	1855	#if the data panel is shown wait for the user to press a button
	1856	#to send data to the current perspective. if the panel is not
	1857	#show automatically send the data to the current perspective
[3feed3e]	1858	style = self.__gui_style & GUIFRAME.MANAGER_ON
	1859	if style == GUIFRAME.MANAGER_ON:
[9c169f4]	1860	#wait for button press from the data panel to set_data
[3feed3e]	1861	if self._data_panel is not None:
	1862	self._mgr.GetPane(self._data_panel.window_name).Show(True)
[9c169f4]	1863	self._mgr.Update()
[3feed3e]	1864	else:
	1865	#automatically send that to the current perspective
[e88ebfd]	1866	self.set_data(data_id=data_list.keys())
[1b1bbf9]	1867	self.on_close_welcome_panel()
[c70eb7c]	1868
[0a2fdca]	1869	def set_data(self, data_id, theory_id=None):
[c5e84fb]	1870	"""
[e88ebfd]	1871	set data to current perspective
[c5e84fb]	1872	"""
[e88ebfd]	1873	list_data, _ = self._data_manager.get_by_id(data_id)
	1874	if self._current_perspective is not None:
[f2d9e76]	1875	if self.cleanup_plots:
	1876	for uid, panel in self.plot_panels.iteritems():
	1877	#panel = self.plot_panels[uid]
	1878	window = self._mgr.GetPane(panel.window_name)
	1879	# To hide all docked plot panels when set the data
	1880	if not window.IsFloating():
	1881	self.hide_panel(uid)
[df22224]	1882	self._current_perspective.set_data(list_data.values())
[1b1bbf9]	1883	self.on_close_welcome_panel()
[584c4c4]	1884	else:
[e88ebfd]	1885	msg = "Guiframe does not have a current perspective"
	1886	logging.info(msg)
	1887
	1888	def set_theory(self, state_id, theory_id=None):
[c5e84fb]	1889	"""
	1890	"""
[df22224]	1891	_, list_theory = self._data_manager.get_by_id(theory_id)
[c5e84fb]	1892	if self._current_perspective is not None:
	1893	try:
[df22224]	1894	self._current_perspective.set_theory(list_theory.values())
[c5e84fb]	1895	except:
[e88ebfd]	1896	msg = "Guiframe set_theory: \n" + str(sys.exc_value)
	1897	logging.info(msg)
[c5e84fb]	1898	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
	1899	else:
	1900	msg = "Guiframe does not have a current perspective"
	1901	logging.info(msg)
[3feed3e]	1902
[e88ebfd]	1903	def plot_data(self, state_id, data_id=None,
	1904	theory_id=None, append=False):
[f444b20]	1905	"""
	1906	send a list of data to plot
	1907	"""
[d7f727d]	1908	total_plot_list = []
[e88ebfd]	1909	data_list, _ = self._data_manager.get_by_id(data_id)
[df22224]	1910	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
[d7f727d]	1911	total_plot_list = data_list.values()
[df22224]	1912	for item in temp_list_theory.values():
[e88ebfd]	1913	theory_data, theory_state = item
[d7f727d]	1914	total_plot_list.append(theory_data)
[e88ebfd]	1915	GROUP_ID = wx.NewId()
[d7f727d]	1916	for new_plot in total_plot_list:
[213892bc]	1917	if append:
[ee2b492]	1918	if self.panel_on_focus is None:
[213892bc]	1919	message = "cannot append plot. No plot panel on focus!"
	1920	message += "please click on any available plot to set focus"
	1921	wx.PostEvent(self, StatusEvent(status=message,
	1922	info='warning'))
	1923	return
	1924	else:
[e88ebfd]	1925	if self.enable_add_data(new_plot):
	1926	new_plot.group_id = self.panel_on_focus.group_id
	1927	else:
[8cb8c89]	1928	message = "Only 1D Data can be append to"
	1929	message += " plot panel containing 1D data.\n"
	1930	message += "%s not be appended.\n" %str(new_plot.name)
	1931	message += "try new plot option.\n"
[e88ebfd]	1932	wx.PostEvent(self, StatusEvent(status=message,
	1933	info='warning'))
[4c0572f]	1934	else:
[f2d9e76]	1935	if self.cleanup_plots:
	1936	for id, panel in self.plot_panels.iteritems():
	1937	window = self._mgr.GetPane(panel.window_name)
	1938	# To hide all docked plot panels when set the data
	1939	if not window.IsFloating():
	1940	self.hide_panel(id)
[4c0572f]	1941	#if not append then new plot
[7c7fe67]	1942	from sans.guiframe.dataFitting import Data2D
[8cb8c89]	1943	if issubclass(Data2D, new_plot.__class__):
[7c7fe67]	1944	#for 2 D always plot in a separated new plot
	1945	new_plot.group_id = wx.NewId()
	1946	else:
	1947	# plot all 1D in a new plot
	1948	new_plot.group_id = GROUP_ID
[e88ebfd]	1949	title = "PLOT " + str(new_plot.title)
[f444b20]	1950	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
[f5348253]	1951	title=title,
	1952	group_id = new_plot.group_id))
[f444b20]	1953
[665c083]	1954	def remove_data(self, data_id, theory_id=None):
[213892bc]	1955	"""
	1956	Delete data state if data_id is provide
	1957	delete theory created with data of id data_id if theory_id is provide
	1958	if delete all true: delete the all state
	1959	else delete theory
	1960	"""
[e26d0db]	1961	temp = data_id + theory_id
[60fff67]	1962	"""
	1963	value = [plug.is_in_use(temp) for plug in self.plugins]
	1964	if len(value) > 0:
	1965	print "value"
	1966	return
	1967	from data_panel import DataDialog
	1968	dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
	1969	if dlg.ShowModal() == wx.ID_OK:
	1970	selected_data_list = dlg.get_data()
	1971	dlg.Destroy()
	1972	"""
[6db811e]	1973	for plug in self.plugins:
[e26d0db]	1974	plug.delete_data(temp)
[3658717e]	1975	total_plot_list = []
	1976	data_list, _ = self._data_manager.get_by_id(data_id)
	1977	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
	1978	total_plot_list = data_list.values()
	1979	for item in temp_list_theory.values():
	1980	theory_data, theory_state = item
	1981	total_plot_list.append(theory_data)
	1982	for new_plot in total_plot_list:
	1983	id = new_plot.id
	1984	for group_id in new_plot.list_group_id:
	1985	wx.PostEvent(self, NewPlotEvent(id=id,
	1986	group_id=group_id,
	1987	action='remove'))
	1988	self._data_manager.delete_data(data_id=data_id,
	1989	theory_id=theory_id)
[6db811e]	1990
[213892bc]	1991
[f444b20]	1992	def set_current_perspective(self, perspective):
	1993	"""
	1994	set the current active perspective
	1995	"""
	1996	self._current_perspective = perspective
[f7e9af2]	1997	name = "No current analysis selected"
[cbf22e5]	1998	if self._current_perspective is not None:
	1999	self._add_current_plugin_menu()
[a45037aa]	2000	for panel in self.panels.values():
	2001	if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
	2002	for name in self._current_perspective.get_perspective():
	2003	if name == panel.window_name:
	2004	panel.on_set_focus(event=None)
[fadf925]	2005	break
[f036c692]	2006	name = self._current_perspective.sub_menu
[cbf22e5]	2007	if self._data_panel is not None:
	2008	self._data_panel.set_active_perspective(name)
[95f9cc4]	2009	self._check_applications_menu()
[1b1bbf9]	2010	#Set the SansView title
	2011	self._set_title_name(name)
[52f3c98]	2012
[1b1bbf9]	2013
	2014	def _set_title_name(self, name):
	2015	"""
	2016	Set the SansView title w/ the current application name
	2017
	2018	: param name: application name [string]
	2019	"""
	2020	# Set SanView Window title w/ application anme
	2021	title = self.title + " - " + name + " -"
	2022	self.SetTitle(title)
	2023
[95f9cc4]	2024	def _check_applications_menu(self):
	2025	"""
	2026	check the menu of the current application
	2027	"""
	2028	if self._applications_menu is not None:
	2029	for menu in self._applications_menu.GetMenuItems():
	2030	if self._current_perspective is not None:
	2031	name = self._current_perspective.sub_menu
	2032	if menu.IsCheckable():
	2033	if menu.GetLabel() == name:
	2034	menu.Check(True)
	2035	else:
	2036	menu.Check(False)
[c5e84fb]	2037
[213892bc]	2038	def set_plotpanel_floating(self, event=None):
[7a67e075]	2039	"""
	2040	make the plot panel floatable
	2041	"""
[d785914]	2042
[0663dfb1]	2043	self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
[3feed3e]	2044	self.__gui_style \|= GUIFRAME.FLOATING_PANEL
[d785914]	2045	plot_panel = []
[f2d9e76]	2046	id = event.GetId()
	2047	menu = self._window_menu.FindItemById(id)
[d785914]	2048	if self._plotting_plugin is not None:
[ae83ad3]	2049	plot_panel = self._plotting_plugin.plot_panels.values()
[d785914]	2050	for p in plot_panel:
	2051	self._popup_floating_panel(p)
[f2d9e76]	2052	menu.Check(True)
	2053
[213892bc]	2054	def set_plotpanel_fixed(self, event=None):
[7a67e075]	2055	"""
	2056	make the plot panel fixed
	2057	"""
[0663dfb1]	2058	self.__gui_style &= (~GUIFRAME.FLOATING_PANEL)
[3feed3e]	2059	self.__gui_style \|= GUIFRAME.FIXED_PANEL
	2060	plot_panel = []
[f2d9e76]	2061	id = event.GetId()
	2062	menu = self._window_menu.FindItemById(id)
[3feed3e]	2063	if self._plotting_plugin is not None:
[ae83ad3]	2064	plot_panel = self._plotting_plugin.plot_panels.values()
[d785914]	2065	for p in plot_panel:
	2066	self._popup_fixed_panel(p)
[f2d9e76]	2067	menu.Check(True)
	2068
	2069	def on_cleanup_dock(self, event=None):
	2070	"""
	2071	Set Cleanup Dock option
	2072	"""
	2073	if event == None:
	2074	return
	2075	id = event.GetId()
	2076	menu = self._window_menu.FindItemById(id)
	2077	Flag = self.cleanup_plots
	2078	if not Flag:
	2079	menu.Check(True)
	2080	self.cleanup_plots = True
	2081	msg = "Cleanup-Dock option set to 'ON'."
	2082	else:
	2083	menu.Check(False)
	2084	self.cleanup_plots = False
	2085	msg = "Cleanup-Dock option set to 'OFF'."
	2086
	2087	wx.PostEvent(self, StatusEvent(status= msg))
	2088
[3feed3e]	2089	def _popup_fixed_panel(self, p):
	2090	"""
	2091	"""
	2092	style = self.__gui_style & GUIFRAME.FIXED_PANEL
	2093	if style == GUIFRAME.FIXED_PANEL:
[52f3c98]	2094	self._mgr.GetPane(p.window_name).Dock()
[3feed3e]	2095	self._mgr.GetPane(p.window_name).Floatable()
	2096	self._mgr.GetPane(p.window_name).Right()
	2097	self._mgr.GetPane(p.window_name).TopDockable(False)
	2098	self._mgr.GetPane(p.window_name).BottomDockable(False)
	2099	self._mgr.GetPane(p.window_name).LeftDockable(False)
	2100	self._mgr.GetPane(p.window_name).RightDockable(True)
	2101	self._mgr.Update()
	2102
	2103	def _popup_floating_panel(self, p):
	2104	"""
	2105	"""
	2106	style = self.__gui_style & GUIFRAME.FLOATING_PANEL
	2107	if style == GUIFRAME.FLOATING_PANEL:
	2108	self._mgr.GetPane(p.window_name).Floatable(True)
	2109	self._mgr.GetPane(p.window_name).Float()
	2110	self._mgr.GetPane(p.window_name).Dockable(False)
	2111	self._mgr.Update()
[213892bc]	2112
	2113	def enable_add_data(self, new_plot):
	2114	"""
	2115	Enable append data on a plot panel
	2116	"""
[0a2fdca]	2117
[ee2b492]	2118	if self.panel_on_focus not in self._plotting_plugin.plot_panels.values():
	2119	return
[213892bc]	2120	is_theory = len(self.panel_on_focus.plots) <= 1 and \
	2121	self.panel_on_focus.plots.values()[0].__class__.__name__ == "Theory1D"
	2122
	2123	is_data2d = hasattr(new_plot, 'data')
[0a2fdca]	2124
[213892bc]	2125	is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
	2126	and self.panel_on_focus.group_id is not None
	2127	has_meta_data = hasattr(new_plot, 'meta_data')
	2128
	2129	#disable_add_data if the data is being recovered from a saved state file.
	2130	is_state_data = False
	2131	if has_meta_data:
	2132	if 'invstate' in new_plot.meta_data: is_state_data = True
	2133	if 'prstate' in new_plot.meta_data: is_state_data = True
	2134	if 'fitstate' in new_plot.meta_data: is_state_data = True
	2135
	2136	return is_data1d and not is_data2d and not is_theory and not is_state_data
[d828481]	2137
[f036c692]	2138	def enable_edit_menu(self):
	2139	"""
	2140	enable menu item under edit menu depending on the panel on focus
	2141	"""
[0a2fdca]	2142	if self.cpanel_on_focus is not None and self._edit_menu is not None:
	2143	flag = self.cpanel_on_focus.get_undo_flag()
[f036c692]	2144	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
[0a2fdca]	2145	flag = self.cpanel_on_focus.get_redo_flag()
[f036c692]	2146	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
[3ce9937]	2147	#flag = self.cpanel_on_focus.get_print_flag()
	2148	#self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
[0a2fdca]	2149	flag = self.cpanel_on_focus.get_preview_flag()
[f036c692]	2150	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
[0a2fdca]	2151	flag = self.cpanel_on_focus.get_reset_flag()
[f036c692]	2152	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
	2153	else:
	2154	flag = False
	2155	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
	2156	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
[3ce9937]	2157	#self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
[f036c692]	2158	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
	2159	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
	2160
[d828481]	2161	def on_undo_panel(self, event=None):
	2162	"""
	2163	undo previous action of the last panel on focus if possible
	2164	"""
[0a2fdca]	2165	if self.cpanel_on_focus is not None:
	2166	self.cpanel_on_focus.on_undo(event)
[f036c692]	2167
[d828481]	2168	def on_redo_panel(self, event=None):
	2169	"""
	2170	redo the last cancel action done on the last panel on focus
	2171	"""
[0a2fdca]	2172	if self.cpanel_on_focus is not None:
	2173	self.cpanel_on_focus.on_redo(event)
[f036c692]	2174
[d828481]	2175	def on_bookmark_panel(self, event=None):
	2176	"""
[4e4d3bb]	2177	bookmark panel
[d828481]	2178	"""
[0a2fdca]	2179	if self.cpanel_on_focus is not None:
	2180	self.cpanel_on_focus.on_bookmark(event)
[f036c692]	2181
[4e4d3bb]	2182	def append_bookmark(self, event=None):
	2183	"""
	2184	Bookmark available information of the panel on focus
	2185	"""
	2186	self._toolbar.append_bookmark(event)
	2187
[d828481]	2188	def on_save_panel(self, event=None):
	2189	"""
	2190	save possible information on the current panel
	2191	"""
[0a2fdca]	2192	if self.cpanel_on_focus is not None:
	2193	self.cpanel_on_focus.on_save(event)
[f036c692]	2194
[d828481]	2195	def on_preview_panel(self, event=None):
	2196	"""
	2197	preview information on the panel on focus
	2198	"""
[0a2fdca]	2199	if self.cpanel_on_focus is not None:
	2200	self.cpanel_on_focus.on_preview(event)
[f036c692]	2201
[d828481]	2202	def on_print_panel(self, event=None):
	2203	"""
	2204	print available information on the last panel on focus
	2205	"""
[0a2fdca]	2206	if self.cpanel_on_focus is not None:
	2207	self.cpanel_on_focus.on_print(event)
[f036c692]	2208
[d828481]	2209	def on_zoom_panel(self, event=None):
	2210	"""
	2211	zoom on the current panel if possible
	2212	"""
[0a2fdca]	2213	if self.cpanel_on_focus is not None:
	2214	self.cpanel_on_focus.on_zoom(event)
[f036c692]	2215
[d828481]	2216	def on_zoom_in_panel(self, event=None):
	2217	"""
	2218	zoom in of the panel on focus
	2219	"""
[0a2fdca]	2220	if self.cpanel_on_focus is not None:
	2221	self.cpanel_on_focus.on_zoom_in(event)
[f036c692]	2222
[d828481]	2223	def on_zoom_out_panel(self, event=None):
	2224	"""
	2225	zoom out on the panel on focus
	2226	"""
[0a2fdca]	2227	if self.cpanel_on_focus is not None:
	2228	self.cpanel_on_focus.on_zoom_out(event)
[f036c692]	2229
[d828481]	2230	def on_drag_panel(self, event=None):
	2231	"""
	2232	drag apply to the panel on focus
	2233	"""
[0a2fdca]	2234	if self.cpanel_on_focus is not None:
	2235	self.cpanel_on_focus.on_drag(event)
[f036c692]	2236
[d828481]	2237	def on_reset_panel(self, event=None):
	2238	"""
	2239	reset the current panel
	2240	"""
[0a2fdca]	2241	if self.cpanel_on_focus is not None:
	2242	self.cpanel_on_focus.on_reset(event)
[03314e7]	2243
	2244	def enable_undo(self):
	2245	"""
	2246	enable undo related control
	2247	"""
[0a2fdca]	2248	if self.cpanel_on_focus is not None:
	2249	self._toolbar.enable_undo(self.cpanel_on_focus)
[03314e7]	2250
	2251	def enable_redo(self):
	2252	"""
	2253	enable redo
	2254	"""
[0a2fdca]	2255	if self.cpanel_on_focus is not None:
	2256	self._toolbar.enable_redo(self.cpanel_on_focus)
[03314e7]	2257
	2258	def enable_bookmark(self):
	2259	"""
	2260	Bookmark
	2261	"""
[0a2fdca]	2262	if self.cpanel_on_focus is not None:
	2263	self._toolbar.enable_bookmark(self.cpanel_on_focus)
[03314e7]	2264
	2265	def enable_save(self):
	2266	"""
	2267	save
	2268	"""
[0a2fdca]	2269	if self.cpanel_on_focus is not None:
	2270	self._toolbar.enable_save(self.cpanel_on_focus)
[03314e7]	2271
	2272	def enable_preview(self):
	2273	"""
	2274	preview
	2275	"""
[0a2fdca]	2276	if self.cpanel_on_focus is not None:
	2277	self._toolbar.enable_preview(self.cpanel_on_focus)
[03314e7]	2278
	2279	def enable_print(self):
	2280	"""
	2281	print
	2282	"""
[0a2fdca]	2283	if self.cpanel_on_focus is not None:
	2284	self._toolbar.enable_print(self.cpanel_on_focus)
[03314e7]	2285
	2286	def enable_zoom(self):
	2287	"""
	2288	zoom
	2289	"""
[0a2fdca]	2290	if self.cpanel_on_focus is not None:
[03314e7]	2291	self._toolbar.enable_zoom(self.panel_on_focus)
	2292
	2293	def enable_zoom_in(self):
	2294	"""
	2295	zoom in
	2296	"""
[0a2fdca]	2297	if self.cpanel_on_focus is not None:
[03314e7]	2298	self._toolbar.enable_zoom_in(self.panel_on_focus)
	2299
	2300	def enable_zoom_out(self):
	2301	"""
	2302	zoom out
	2303	"""
[0a2fdca]	2304	if self.cpanel_on_focus is not None:
[03314e7]	2305	self._toolbar.enable_zoom_out(self.panel_on_focus)
	2306
	2307	def enable_drag(self, event=None):
	2308	"""
	2309	drag
	2310	"""
[0a2fdca]	2311	if self.cpanel_on_focus is not None:
[03314e7]	2312	self._toolbar.enable_drag(self.panel_on_focus)
	2313
	2314	def enable_reset(self):
	2315	"""
	2316	reset the current panel
	2317	"""
[0a2fdca]	2318	if self.cpanel_on_focus is not None:
[03314e7]	2319	self._toolbar.enable_reset(self.panel_on_focus)
[6d727ae]	2320
	2321	def set_schedule_full_draw(self, panel=None, func='del'):
	2322	"""
	2323	Add/subtract the schedule full draw list with the panel given
	2324
	2325	:param panel: plot panel
	2326	:param func: append or del [string]
	2327	"""
	2328
	2329	# append this panel in the schedule list if not in yet
	2330	if func == 'append':
	2331	if not panel in self.schedule_full_draw_list:
	2332	self.schedule_full_draw_list.append(panel)
	2333	# remove this panel from schedule list
	2334	elif func == 'del':
	2335	if len(self.schedule_full_draw_list) > 0:
	2336	if panel in self.schedule_full_draw_list:
	2337	self.schedule_full_draw_list.remove(panel)
	2338
	2339	# reset the schdule
	2340	if len(self.schedule_full_draw_list) == 0:
	2341	self.schedule = False
	2342	else:
	2343	self.schedule = True
	2344
	2345	def full_draw(self):
	2346	"""
	2347	Draw the panels with axes in the schedule to full dwar list
	2348	"""
	2349	count = len(self.schedule_full_draw_list)
	2350	#if not self.schedule:
	2351	if count < 1:
	2352	self.set_schedule(False)
	2353	return
	2354	else:
	2355	ind = 0
	2356	# if any of the panel is shown do full_draw
	2357	for panel in self.schedule_full_draw_list:
	2358	ind += 1
	2359	if self._mgr.GetPane(panel.window_name).IsShown():
	2360	break
	2361	# otherwise, return
	2362	if ind == count:
	2363	return
	2364
	2365	#Simple redraw only for a panel shown
	2366	def f_draw(panel):
	2367	"""
	2368	Draw A panel in the full dwar list
	2369	"""
[dee097b]	2370	try:
	2371	# This checking of GetCapture is to stop redrawing
	2372	# while any panel is capture.
	2373	if self.GetCapture() == None:
	2374	# draw if possible
	2375	panel.set_resizing(False)
	2376	panel.draw_plot()
	2377	# Check if the panel is not shown
	2378	if not self._mgr.GetPane(panel.window_name).IsShown():
	2379	self._mgr.GetPane(panel.window_name).Hide()
	2380	except:
	2381	pass
[6d727ae]	2382	#print self.callback,self.schedule,self.schedule_full_draw_list
	2383
	2384	# Draw all panels
	2385	map(f_draw, self.schedule_full_draw_list)
	2386
	2387	# Reset the attr
	2388	if len(self.schedule_full_draw_list) == 0:
	2389	self.set_schedule(False)
	2390	else:
	2391	self.set_schedule(True)
[de99e3e4]	2392	# do not update mgr
	2393	#self._mgr.Update()
[6d727ae]	2394
	2395	def set_schedule(self, schedule=False):
	2396	"""
	2397	Set schedule
	2398	"""
	2399	self.schedule = schedule
	2400
	2401	def get_schedule(self):
	2402	"""
	2403	Get schedule
	2404	"""
	2405	return self.schedule
	2406
[0a2fdca]	2407	def on_set_plot_focus(self, panel):
	2408	"""
	2409	Set focus on a plot panel
	2410	"""
[dee097b]	2411	self.set_plot_unfocus()
[0a2fdca]	2412	panel.on_set_focus(None)
	2413	# set focusing panel
	2414	self.panel_on_focus = panel
	2415	self.set_panel_on_focus(None)
[5e8e615]	2416
[dee097b]	2417	def set_plot_unfocus(self):
	2418	"""
	2419	Un focus all plot panels
	2420	"""
	2421	for plot in self.plot_panels.values():
	2422	plot.on_kill_focus(None)
	2423
[6d727ae]	2424	def _onDrawIdle(self, args, *kwargs):
	2425	"""
	2426	ReDraw with axes
	2427	"""
	2428	# check if it is time to redraw
	2429	if self.GetCapture() == None:
	2430	# Draw plot, changes resizing too
	2431	self.full_draw()
	2432
	2433	# restart idle
	2434	self._redraw_idle(args, *kwargs)
	2435
	2436
	2437	def _redraw_idle(self, args, *kwargs):
	2438	"""
	2439	Restart Idle
	2440	"""
	2441	# restart idle
	2442	self.idletimer.Restart(55, args, *kwargs)
	2443
[3feed3e]	2444
[d828481]	2445	class DefaultPanel(wx.Panel, PanelBase):
[41d466f]	2446	"""
[d955bf19]	2447	Defines the API for a panels to work with
	2448	the GUI manager
[41d466f]	2449	"""
	2450	## Internal nickname for the window, used by the AUI manager
	2451	window_name = "default"
	2452	## Name to appear on the window title bar
	2453	window_caption = "Welcome panel"
	2454	## Flag to tell the AUI manager to put this panel in the center pane
	2455	CENTER_PANE = True
[1b3a5a9]	2456	def __init__(self, parent, args, *kwds):
	2457	wx.Panel.__init__(self, parent, args, *kwds)
	2458	PanelBase.__init__(self, parent)
[d828481]	2459
[41d466f]	2460
[4753fc2]	2461
[41d466f]	2462	# Toy application to test this Frame
	2463	class ViewApp(wx.App):
[d955bf19]	2464	"""
	2465	"""
[41d466f]	2466	def OnInit(self):
[d955bf19]	2467	"""
	2468	"""
[957723f]	2469	pos, size = self.window_placement((GUIFRAME_WIDTH, GUIFRAME_HEIGHT))
[3385795]	2470	self.frame = ViewerFrame(parent=None,
[957723f]	2471	title=APPLICATION_NAME,
[3385795]	2472	pos=pos,
[957723f]	2473	gui_style = DEFAULT_STYLE,
[3385795]	2474	size=size)
[7a955a9]	2475	self.frame.Hide()
[957723f]	2476	self.s_screen = None
[db6ce6c]	2477	try:
[08e1912]	2478	# make sure the current dir is App dir when it starts
[87f4dcc]	2479	temp_path = os.path.dirname(os.path.sys.path[0])
[08e1912]	2480	os.chdir(temp_path)
[db6ce6c]	2481	except:
	2482	pass
[957723f]	2483	# Display a splash screen on top of the frame.
[3385795]	2484	if len(sys.argv) > 1 and '--time' in sys.argv[1:]:
	2485	log_time("Starting to display the splash screen")
[957723f]	2486	try:
	2487	if os.path.isfile(SPLASH_SCREEN_PATH):
	2488	self.s_screen = self.display_splash_screen(parent=self.frame,
	2489	path=SPLASH_SCREEN_PATH)
	2490	else:
	2491	self.frame.Show()
	2492	except:
[7a955a9]	2493	if self.s_screen is not None:
	2494	self.s_screen.Close()
	2495	msg = "Cannot display splash screen\n"
	2496	msg += str (sys.exc_value)
	2497	logging.error(msg)
	2498	self.frame.Show()
[cc835cd8]	2499
[41d466f]	2500	if hasattr(self.frame, 'special'):
	2501	self.frame.special.SetCurrent()
	2502	self.SetTopWindow(self.frame)
[c3f697e]	2503	try:
	2504	self.open_file()
	2505	except:
	2506	msg = "%s Could not load " % str(APPLICATION_NAME)
	2507	msg += "input file from command line.\n"
	2508	logging.error(msg)
[41d466f]	2509	return True
[b46b1b9]	2510
[957723f]	2511	def open_file(self):
	2512	"""
	2513	open a state file at the start of the application
	2514	"""
[c3f697e]	2515	input_file = None
	2516	if len(sys.argv) >= 2:
	2517	cmd = sys.argv[0].lower()
	2518	if os.path.isfile(cmd):
	2519	basename = os.path.basename(cmd)
[64e44c1]	2520	app_py = str(APPLICATION_NAME).lower() + '.py'
	2521	app_exe = str(APPLICATION_NAME).lower() + '.exe'
[b136098]	2522	app_app = str(APPLICATION_NAME).lower() + '.app'
	2523	if basename.lower() in [app_py, app_exe, app_app]:
[c3f697e]	2524	input_file = sys.argv[1]
	2525	if input_file is None:
	2526	return
[976604d]	2527	if self.frame is not None:
[29ef718]	2528	self.frame.set_input_file(input_file=input_file)
[1b1bbf9]	2529
	2530
[41d466f]	2531	def set_manager(self, manager):
	2532	"""
[d955bf19]	2533	Sets a reference to the application manager
	2534	of the GUI manager (Frame)
[41d466f]	2535	"""
	2536	self.frame.set_manager(manager)
	2537
[278cc25]	2538	def build_gui(self):
	2539	"""
[d955bf19]	2540	Build the GUI
[278cc25]	2541	"""
[976604d]	2542	#try to load file at the start
	2543	try:
	2544	self.open_file()
	2545	except:
	2546	raise
[29ef718]	2547	self.frame.build_gui()
[7a955a9]	2548	#if self.s_screen is not None and self.s_screen.IsShown():
	2549	# self.s_screen.Close()
[278cc25]	2550
[f9e803e]	2551	def set_welcome_panel(self, panel_class):
	2552	"""
[d955bf19]	2553	Set the welcome panel
	2554
	2555	:param panel_class: class of the welcome panel to be instantiated
	2556
[f9e803e]	2557	"""
	2558	self.frame.set_welcome_panel(panel_class)
	2559
[278cc25]	2560	def add_perspective(self, perspective):
	2561	"""
[d955bf19]	2562	Manually add a perspective to the application GUI
[278cc25]	2563	"""
	2564	self.frame.add_perspective(perspective)
[3385795]	2565
	2566	def window_placement(self, size):
	2567	"""
	2568	Determines the position and size of the application frame such that it
	2569	fits on the user's screen without obstructing (or being obstructed by)
	2570	the Windows task bar. The maximum initial size in pixels is bounded by
	2571	WIDTH x HEIGHT. For most monitors, the application
	2572	will be centered on the screen; for very large monitors it will be
	2573	placed on the left side of the screen.
	2574	"""
	2575	window_width, window_height = size
	2576	screen_size = wx.GetDisplaySize()
[2edc8eb]	2577	window_height = window_height if screen_size[1]>window_height else screen_size[1]-10
	2578	window_width = window_width if screen_size[0]> window_width else screen_size[0]-10
[3385795]	2579	xpos = ypos = 0
	2580
	2581	# Note that when running Linux and using an Xming (X11) server on a PC
	2582	# with a dual monitor configuration, the reported display size may be
	2583	# that of both monitors combined with an incorrect display count of 1.
	2584	# To avoid displaying this app across both monitors, we check for
	2585	# screen 'too big'. If so, we assume a smaller width which means the
	2586	# application will be placed towards the left hand side of the screen.
	2587
	2588	_, _, x, y = wx.Display().GetClientArea() # size excludes task bar
	2589	if len(sys.argv) > 1 and '--platform' in sys.argv[1:]:
	2590	w, h = wx.DisplaySize() # size includes task bar area
[491525f]	2591	# display on left side, not centered on screen
	2592	if x > 1920 and x > (2*y): x = x / 2
[3385795]	2593	if x > window_width: xpos = (x - window_width)/2
	2594	if y > window_height: ypos = (y - window_height)/2
	2595
	2596	# Return the suggested position and size for the application frame.
	2597	return (xpos, ypos), (min(x, window_width), min(y, window_height))
	2598
[783940c]	2599	def display_splash_screen(self, parent,
[957723f]	2600	path=SPLASH_SCREEN_PATH):
[3385795]	2601	"""Displays the splash screen. It will exactly cover the main frame."""
[957723f]	2602
[3385795]	2603	# Prepare the picture. On a 2GHz intel cpu, this takes about a second.
	2604	x, y = parent.GetSizeTuple()
	2605	image = wx.Image(path, wx.BITMAP_TYPE_PNG)
[957723f]	2606	image.Rescale(SPLASH_SCREEN_WIDTH,
	2607	SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
[3385795]	2608	bm = image.ConvertToBitmap()
	2609
	2610	# Create and show the splash screen. It will disappear only when the
	2611	# program has entered the event loop AND either the timeout has expired
	2612	# or the user has left clicked on the screen. Thus any processing
	2613	# performed in this routine (including sleeping) or processing in the
	2614	# calling routine (including doing imports) will prevent the splash
	2615	# screen from disappearing.
	2616	#
	2617	# Note that on Linux, the timeout appears to occur immediately in which
	2618	# case the splash screen disappears upon entering the event loop.
[783940c]	2619	s_screen = wx.SplashScreen(bitmap=bm,
	2620	splashStyle=(wx.SPLASH_TIMEOUT\|
	2621	wx.SPLASH_CENTRE_ON_SCREEN),
	2622	style=(wx.SIMPLE_BORDER\|
	2623	wx.FRAME_NO_TASKBAR\|
	2624	wx.STAY_ON_TOP),
	2625
[957723f]	2626	milliseconds=SS_MAX_DISPLAY_TIME,
[3385795]	2627	parent=parent,
	2628	id=wx.ID_ANY)
[7a955a9]	2629	from gui_statusbar import SPageStatusbar
	2630	statusBar = SPageStatusbar(s_screen)
	2631	s_screen.SetStatusBar(statusBar)
[783940c]	2632	s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
	2633	s_screen.Show()
	2634	return s_screen
	2635
	2636
	2637	def on_close_splash_screen(self, event):
	2638	"""
	2639	"""
	2640	self.frame.Show(True)
	2641	event.Skip()
[b46b1b9]	2642
[41d466f]	2643	if __name__ == "__main__":
	2644	app = ViewApp(0)
[32c0841]	2645	app.MainLoop()
	2646
	2647

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

SasView

source: sasview/guiframe/gui_manager.py @ f199764

Download in other formats: