gui_manager.py @ 4efefc6

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 4efefc6 was 022af4d, checked in by Jae Cho <jhjcho@…>, 13 years ago
adde default location on open project
Property mode set to `100644`
File size: 99.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
[c91ef7e]	123	if sys.platform.count("darwin")==0:
	124	IS_WIN = True
	125	else:
	126	IS_WIN = False
	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().
[c91ef7e]	628	CloseButton(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().
	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().
	775	Name(windowname).Caption(caption).
	776	MinimizeButton().
	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)
	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)
	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	"""
[db10f97]	1238	self.sb.set_status(event=evt)
[dd66fbd]	1239
[56d5562]	1240	def on_view(self, evt):
[41d466f]	1241	"""
[d955bf19]	1242	A panel was selected to be shown. If it's not already
	1243	shown, display it.
	1244
	1245	:param evt: menu event
	1246
[41d466f]	1247	"""
[dee097b]	1248	panel_id = str(evt.GetId())
	1249	self.on_set_plot_focus(self.panels[panel_id])
	1250	self.show_panel(evt.GetId(), 'on')
[6d727ae]	1251	wx.CallLater(5, self.set_schedule(True))
[dee097b]	1252	self.set_plot_unfocus()
[c1469ebe]	1253
[b28278e]	1254	def on_close_welcome_panel(self):
[c1469ebe]	1255	"""
[d955bf19]	1256	Close the welcome panel
[c1469ebe]	1257	"""
[629e8b9]	1258	if self.defaultPanel is None:
	1259	return
[1b1bbf9]	1260	default_panel = self._mgr.GetPane(self.panels["default"].window_name)
	1261	if default_panel.IsShown():
	1262	default_panel.Hide()
[4d1dce4]	1263	# Recover current perspective
	1264	perspective = self._current_perspective
	1265	perspective.on_perspective(event=None)
[1b1bbf9]	1266	self._mgr.Update()
	1267	# Show toolbar
[5342eb8]	1268	style = self.__gui_style & GUIFRAME.TOOLBAR_ON
	1269	if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
[3554fd39]	1270	self._on_toggle_toolbar()
[1b1bbf9]	1271
[c1469ebe]	1272	def show_welcome_panel(self, event):
	1273	"""
[d955bf19]	1274	Display the welcome panel
[c1469ebe]	1275	"""
[629e8b9]	1276	if self.defaultPanel is None:
	1277	return
[4bee68d]	1278	for id, panel in self.panels.iteritems():
[c5e84fb]	1279	if id == 'default':
	1280	# Show default panel
	1281	if not self._mgr.GetPane(self.panels["default"].window_name).IsShown():
	1282	self._mgr.GetPane(self.panels["default"].window_name).Show(True)
	1283	elif id == "data_panel":
	1284	flag = self._mgr.GetPane(self.panels["data_panel"].window_name).IsShown()
	1285	self._mgr.GetPane(self.panels["data_panel"].window_name).Show(flag)
[4bee68d]	1286	elif panel not in self.plot_panels.values() :
[c5e84fb]	1287	self._mgr.GetPane(self.panels[id].window_name).IsShown()
[c1469ebe]	1288	self._mgr.GetPane(self.panels[id].window_name).Hide()
[9d8f193]	1289	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
	1290	#if (style == GUIFRAME.TOOLBAR_ON) & (self._toolbar.IsShown()):
	1291	# # self._toolbar.Show(True)
	1292	# self._on_toggle_toolbar()
[1b1bbf9]	1293
[c1469ebe]	1294	self._mgr.Update()
[c5e84fb]	1295
[6d727ae]	1296	def show_panel(self, uid, show=None):
[41d466f]	1297	"""
[d955bf19]	1298	Shows the panel with the given id
	1299
	1300	:param uid: unique ID number of the panel to show
	1301
[41d466f]	1302	"""
	1303	ID = str(uid)
	1304	config.printEVT("show_panel: %s" % ID)
	1305	if ID in self.panels.keys():
[6d727ae]	1306	if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():
	1307	if show == 'on':
	1308	self._mgr.GetPane(self.panels[ID].window_name).Show()
[52f3c98]	1309	elif self.panels[ID].window_caption.split(" ")[0] == \
	1310	"Residuals":
[6d727ae]	1311	self._mgr.GetPane(self.panels[ID].window_name).Hide()
	1312	else:
	1313	self._mgr.GetPane(self.panels[ID].window_name).Show()
[383189f9]	1314	# Hide default panel
	1315	self._mgr.GetPane(self.panels["default"].window_name).Hide()
[6d727ae]	1316	self._mgr.Update()
	1317	self._redraw_idle()
	1318
[ae83ad3]	1319	def hide_panel(self, uid):
	1320	"""
[f2d9e76]	1321	hide panel except default panel
[ae83ad3]	1322	"""
	1323	ID = str(uid)
[0a2fdca]	1324	caption = self.panels[ID].window_caption
[ae83ad3]	1325	config.printEVT("hide_panel: %s" % ID)
	1326	if ID in self.panels.keys():
	1327	if self._mgr.GetPane(self.panels[ID].window_name).IsShown():
	1328	self._mgr.GetPane(self.panels[ID].window_name).Hide()
[0a2fdca]	1329	if self._data_panel is not None and \
	1330	ID in self.plot_panels.keys():
	1331	self._data_panel.cb_plotpanel.Append(str(caption), p)
[f2d9e76]	1332	# Do not Hide default panel here...
	1333	#self._mgr.GetPane(self.panels["default"].window_name).Hide()
[ae83ad3]	1334	self._mgr.Update()
[0a2fdca]	1335
[c9937c0]	1336	def delete_panel(self, uid):
	1337	"""
	1338	delete panel given uid
	1339	"""
	1340	ID = str(uid)
	1341	config.printEVT("delete_panel: %s" % ID)
[0a2fdca]	1342	caption = self.panels[ID].window_caption
[c9937c0]	1343	if ID in self.panels.keys():
[f7d0b74]	1344	self.panel_on_focus = None
[df22224]	1345	panel = self.panels[ID]
	1346	self._plotting_plugin.delete_panel(panel.group_id)
	1347	self._mgr.DetachPane(panel)
[f7d0b74]	1348	panel.Hide()
	1349	panel.clear()
	1350	panel.Close()
	1351	self._mgr.Update()
[d64dfd2]	1352	#delete uid number not str(uid)
	1353	if uid in self.plot_panels.keys():
	1354	del self.plot_panels[uid]
[f7d0b74]	1355	return
[c9937c0]	1356
[75fbd17]	1357	def clear_panel(self):
[b3644f3]	1358	"""
	1359	"""
[75fbd17]	1360	for item in self.panels:
	1361	try:
	1362	self.panels[item].clear_panel()
	1363	except:
	1364	pass
	1365
	1366	def create_gui_data(self, data, path=None):
	1367	"""
[0348245]	1368	"""
	1369	return self._data_manager.create_gui_data(data, path)
	1370
[03314e7]	1371	def get_data(self, path):
[75fbd17]	1372	"""
	1373	"""
	1374	message = ""
	1375	log_msg = ''
	1376	output = []
	1377	error_message = ""
	1378	basename = os.path.basename(path)
	1379	root, extension = os.path.splitext(basename)
	1380	if extension.lower() not in EXTENSIONS:
	1381	log_msg = "File Loader cannot "
	1382	log_msg += "load: %s\n" % str(basename)
	1383	log_msg += "Try Data opening...."
	1384	logging.info(log_msg)
	1385	self.load_complete(output=output, error_message=error_message,
	1386	message=log_msg, path=path)
[700f9b4]	1387	return
[75fbd17]	1388
	1389	#reading a state file
	1390	for plug in self.plugins:
[03314e7]	1391	reader, ext = plug.get_extensions()
	1392	if reader is not None:
	1393	#read the state of the single plugin
	1394	if extension == ext:
	1395	reader.read(path)
	1396	return
[957723f]	1397	elif extension == APPLICATION_STATE_EXTENSION:
[03314e7]	1398	reader.read(path)
	1399
[75fbd17]	1400	style = self.__gui_style & GUIFRAME.MANAGER_ON
	1401	if style == GUIFRAME.MANAGER_ON:
	1402	if self._data_panel is not None:
[f7d0b74]	1403	#data_state = self._data_manager.get_selected_data()
	1404	#self._data_panel.load_data_list(data_state)
[75fbd17]	1405	self._mgr.GetPane(self._data_panel.window_name).Show(True)
[976604d]	1406
	1407	def load_from_cmd(self, path):
	1408	"""
[c3f697e]	1409	load data from cmd or application
[976604d]	1410	"""
[c3f697e]	1411	if path is None:
[976604d]	1412	return
	1413	else:
	1414	path = os.path.abspath(path)
	1415	if not os.path.isfile(path):
	1416	return
	1417	basename = os.path.basename(path)
	1418	root, extension = os.path.splitext(basename)
	1419	if extension.lower() not in EXTENSIONS:
	1420	self.load_data(path)
	1421	else:
	1422	self.load_state(path)
[022af4d]	1423
	1424	self._default_save_location = os.path.dirname(path)
	1425
[957723f]	1426	def load_state(self, path):
	1427	"""
[c3f697e]	1428	load data from command line or application
[957723f]	1429	"""
[976604d]	1430	if path and (path is not None) and os.path.isfile(path):
[957723f]	1431	basename = os.path.basename(path)
	1432	if APPLICATION_STATE_EXTENSION is not None \
	1433	and basename.endswith(APPLICATION_STATE_EXTENSION):
[9c35257]	1434	#Hide current plot_panels i
	1435	for ID in self.plot_panels.keys():
	1436	panel = self._mgr.GetPane(self.plot_panels[ID].window_name)
	1437	if panel.IsShown():
	1438	panel.Hide()
[1793cef]	1439	self.get_data(path)
[957723f]	1440	if self.defaultPanel is not None and \
	1441	self._mgr.GetPane(self.panels["default"].window_name).IsShown():
	1442	self.on_close_welcome_panel()
	1443
	1444	def load_data(self, path):
	1445	"""
[c3f697e]	1446	load data from command line
[957723f]	1447	"""
	1448	if not os.path.isfile(path):
	1449	return
	1450	basename = os.path.basename(path)
	1451	root, extension = os.path.splitext(basename)
	1452	if extension.lower() in EXTENSIONS:
	1453	log_msg = "Data Loader cannot "
	1454	log_msg += "load: %s\n" % str(path)
	1455	log_msg += "Try File opening ...."
	1456	print log_msg
	1457	return
[c3f697e]	1458	message = ""
	1459	log_msg = ''
	1460	output = {}
	1461	error_message = ""
[957723f]	1462	try:
[c3f697e]	1463	print "Loading Data...:\n" + str(path) + "\n"
[957723f]	1464	temp = self.loader.load(path)
	1465	if temp.__class__.__name__ == "list":
	1466	for item in temp:
[c3f697e]	1467	data = self.create_gui_data(item, path)
[957723f]	1468	output[data.id] = data
	1469	else:
[c3f697e]	1470	data = self.create_gui_data(temp, path)
[957723f]	1471	output[data.id] = data
	1472
	1473	self.add_data(data_list=output)
	1474	except:
[c3f697e]	1475	error_message = "Error while loading"
	1476	error_message += " Data from cmd:\n %s\n" % str(path)
[957723f]	1477	error_message += str(sys.exc_value) + "\n"
	1478	print error_message
	1479
[4c01978]	1480
	1481	def _on_open_state_application(self, event):
	1482	"""
	1483	"""
	1484	path = None
	1485	if self._default_save_location == None:
	1486	self._default_save_location = os.getcwd()
[d38d0042]	1487
	1488	plug_wlist = self._on_open_state_app_helper()
[4c01978]	1489	dlg = wx.FileDialog(self,
	1490	"Choose a file",
	1491	self._default_save_location, "",
[32d26da]	1492	plug_wlist)
[4c01978]	1493	if dlg.ShowModal() == wx.ID_OK:
	1494	path = dlg.GetPath()
	1495	if path is not None:
	1496	self._default_save_location = os.path.dirname(path)
	1497	dlg.Destroy()
	1498	self.load_state(path=path)
[d38d0042]	1499
	1500	def _on_open_state_app_helper(self):
	1501	"""
	1502	Helps '_on_open_state_application()' to find the extension of
	1503	the current perspective/application
	1504	"""
	1505	# No current perspective or no extension attr
	1506	if self._current_perspective is None:
	1507	return PLUGINS_WLIST
	1508	try:
	1509	# Find the extension of the perspective and get that as 1st item in list
	1510	ind = None
	1511	app_ext = self._current_perspective._extensions
	1512	plug_wlist = config.PLUGINS_WLIST
	1513	for ext in set(plug_wlist):
	1514	if ext.count(app_ext) > 0:
	1515	ind = ext
	1516	break
	1517	# Found the extension
	1518	if ind != None:
	1519	plug_wlist.remove(ind)
	1520	plug_wlist.insert(0, ind)
	1521	try:
	1522	plug_wlist ='\|'.join(plug_wlist)
	1523	except:
	1524	plug_wlist = ''
[32d26da]	1525
[d38d0042]	1526	except:
	1527	plug_wlist = PLUGINS_WLIST
[957723f]	1528
[32d26da]	1529	return plug_wlist
	1530
[4c01978]	1531	def _on_open_state_project(self, event):
[75fbd17]	1532	"""
	1533	"""
	1534	path = None
	1535	if self._default_save_location == None:
	1536	self._default_save_location = os.getcwd()
[d38d0042]	1537
[75fbd17]	1538	dlg = wx.FileDialog(self,
	1539	"Choose a file",
	1540	self._default_save_location, "",
[4c01978]	1541	APPLICATION_WLIST)
[75fbd17]	1542	if dlg.ShowModal() == wx.ID_OK:
	1543	path = dlg.GetPath()
	1544	if path is not None:
	1545	self._default_save_location = os.path.dirname(path)
	1546	dlg.Destroy()
[1793cef]	1547
	1548	#try:
	1549	# os.popen(path)
	1550	# #self.Close()
	1551	#except:
[957723f]	1552	self.load_state(path=path)
[1793cef]	1553
[52725d6]	1554	def _on_save_application(self, event):
[b35d3d1]	1555	"""
[52725d6]	1556	save the state of the current active application
[b35d3d1]	1557	"""
[0a2fdca]	1558	if self.cpanel_on_focus is not None:
	1559	self.cpanel_on_focus.on_save(event)
[52725d6]	1560
	1561	def _on_save_project(self, event):
	1562	"""
[23cdeab]	1563	save the state of the SansView as *.svs
[52725d6]	1564	"""
	1565	## Default file location for save
	1566	self._default_save_location = os.getcwd()
	1567	if self._current_perspective is None:
	1568	return
	1569	reader, ext = self._current_perspective.get_extensions()
	1570	path = None
[2e3f9e3]	1571	extension = '*' + APPLICATION_STATE_EXTENSION
[75fbd17]	1572	dlg = wx.FileDialog(self, "Save Project file",
[957723f]	1573	self._default_save_location, "",
[2e3f9e3]	1574	extension,
[957723f]	1575	wx.SAVE)
[52725d6]	1576	if dlg.ShowModal() == wx.ID_OK:
	1577	path = dlg.GetPath()
	1578	self._default_save_location = os.path.dirname(path)
	1579	else:
	1580	return None
	1581	dlg.Destroy()
	1582	if path is None:
	1583	return
	1584	# default cansas xml doc
	1585	doc = None
	1586	for panel in self.panels.values():
[6f28e70]	1587	temp = panel.save_project(doc)
	1588	if temp is not None:
	1589	doc = temp
	1590
[2e3f9e3]	1591	# Write the XML document
[23cdeab]	1592	extens = APPLICATION_STATE_EXTENSION
	1593	fName = os.path.splitext(path)[0] + extens
[2e3f9e3]	1594	if doc != None:
[23cdeab]	1595	fd = open(fName, 'w')
[2e3f9e3]	1596	fd.write(doc.toprettyxml())
	1597	fd.close()
	1598	else:
	1599	msg = "%s cannot read %s\n" % (str(APPLICATION_NAME), str(path))
[6f28e70]	1600	logging.error(msg)
[2e3f9e3]	1601
[52725d6]	1602	def on_save_helper(self, doc, reader, panel, path):
	1603	"""
	1604	Save state into a file
	1605	"""
	1606	try:
	1607	if reader is not None:
[2e3f9e3]	1608	# case of a panel with multi-pages
	1609	if hasattr(panel, "opened_pages"):
	1610	for uid, page in panel.opened_pages.iteritems():
	1611	data = page.get_data()
	1612	# state must be cloned
	1613	state = page.get_state().clone()
	1614	if data is not None:
	1615	new_doc = reader.write_toXML(data, state)
	1616	if doc != None and hasattr(doc, "firstChild"):
	1617	child = new_doc.firstChild.firstChild
	1618	doc.firstChild.appendChild(child)
	1619	else:
	1620	doc = new_doc
	1621	# case of only a panel
	1622	else:
	1623	data = panel.get_data()
	1624	state = panel.get_state()
	1625	if data is not None:
	1626	new_doc = reader.write_toXML(data, state)
	1627	if doc != None and hasattr(doc, "firstChild"):
	1628	child = new_doc.firstChild.firstChild
	1629	doc.firstChild.appendChild(child)
	1630	else:
	1631	doc = new_doc
[52725d6]	1632	except:
	1633	raise
	1634	#pass
[2e3f9e3]	1635
[52725d6]	1636	return doc
[b35d3d1]	1637
[b5ca223]	1638	def quit_guiframe(self):
	1639	"""
	1640	Pop up message to make sure the user wants to quit the application
	1641	"""
	1642	message = "Do you really want to quit \n"
	1643	message += "this application?"
	1644	dial = wx.MessageDialog(self, message, 'Question',
	1645	wx.YES_NO\|wx.YES_DEFAULT\|wx.ICON_QUESTION)
	1646	if dial.ShowModal() == wx.ID_YES:
	1647	return True
	1648	else:
	1649	return False
	1650
[41d466f]	1651	def Close(self, event=None):
	1652	"""
[d955bf19]	1653	Quit the application
[41d466f]	1654	"""
[52725d6]	1655	#flag = self.quit_guiframe()
	1656	if True:
[ba535a6]	1657	wx.Exit()
	1658	sys.exit()
[41d466f]	1659
	1660	def _check_update(self, event=None):
	1661	"""
[d955bf19]	1662	Check with the deployment server whether a new version
	1663	of the application is available.
	1664	A thread is started for the connecting with the server. The thread calls
	1665	a call-back method when the current version number has been obtained.
[52070a1]	1666	"""
[d68c655]	1667	if hasattr(config, "__update_URL__"):
	1668	import version
[32c0841]	1669	checker = version.VersionThread(config.__update_URL__,
	1670	self._process_version,
	1671	baggage=event==None)
[d68c655]	1672	checker.start()
[52070a1]	1673
	1674	def _process_version(self, version, standalone=True):
	1675	"""
[d955bf19]	1676	Call-back method for the process of checking for updates.
	1677	This methods is called by a VersionThread object once the current
	1678	version number has been obtained. If the check is being done in the
	1679	background, the user will not be notified unless there's an update.
	1680
	1681	:param version: version string
	1682	:param standalone: True of the update is being checked in
	1683	the background, False otherwise.
	1684
[52070a1]	1685	"""
	1686	try:
[32c0841]	1687	if cmp(version, config.__version__) > 0:
	1688	msg = "Version %s is available! See the Help "
	1689	msg += "menu to download it." % version
	1690	self.SetStatusText(msg)
[52070a1]	1691	if not standalone:
	1692	import webbrowser
	1693	webbrowser.open(config.__download_page__)
	1694	else:
	1695	if not standalone:
[32c0841]	1696	msg = "You have the latest version"
	1697	msg += " of %s" % config.__appname__
	1698	self.SetStatusText(msg)
[41d466f]	1699	except:
[32c0841]	1700	msg = "guiframe: could not get latest application"
	1701	msg += " version number\n %s" % sys.exc_value
	1702	logging.error(msg)
[52070a1]	1703	if not standalone:
[32c0841]	1704	msg = "Could not connect to the application server."
	1705	msg += " Please try again later."
	1706	self.SetStatusText(msg)
[52070a1]	1707
[41d466f]	1708	def _onAbout(self, evt):
	1709	"""
[d955bf19]	1710	Pop up the about dialog
	1711
	1712	:param evt: menu event
	1713
[41d466f]	1714	"""
	1715	if config._do_aboutbox:
	1716	import aboutbox
	1717	dialog = aboutbox.DialogAbout(None, -1, "")
[6ab0ad1]	1718	dialog.ShowModal()
[4e9583c]	1719
[41d466f]	1720	def set_manager(self, manager):
	1721	"""
[d955bf19]	1722	Sets the application manager for this frame
	1723
	1724	:param manager: frame manager
[41d466f]	1725	"""
	1726	self.app_manager = manager
	1727
	1728	def post_init(self):
	1729	"""
[d955bf19]	1730	This initialization method is called after the GUI
	1731	has been created and all plug-ins loaded. It calls
	1732	the post_init() method of each plug-in (if it exists)
	1733	so that final initialization can be done.
[41d466f]	1734	"""
	1735	for item in self.plugins:
	1736	if hasattr(item, "post_init"):
	1737	item.post_init()
	1738
[b28278e]	1739	def set_default_perspective(self):
	1740	"""
[d955bf19]	1741	Choose among the plugin the first plug-in that has
	1742	"set_default_perspective" method and its return value is True will be
	1743	as a default perspective when the welcome page is closed
[b28278e]	1744	"""
	1745	for item in self.plugins:
	1746	if hasattr(item, "set_default_perspective"):
	1747	if item.set_default_perspective():
[749eb8a]	1748	item.on_perspective(event=None)
[b28278e]	1749	return
[f444b20]	1750
[41d466f]	1751	def set_perspective(self, panels):
	1752	"""
[d955bf19]	1753	Sets the perspective of the GUI.
	1754	Opens all the panels in the list, and closes
	1755	all the others.
	1756
	1757	:param panels: list of panels
[41d466f]	1758	"""
[adf44c2]	1759	#style = self.__gui_style & GUIFRAME.TOOLBAR_ON
	1760	#if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
	1761	# self._on_toggle_toolbar()
[41d466f]	1762	for item in self.panels:
	1763	# Check whether this is a sticky panel
	1764	if hasattr(self.panels[item], "ALWAYS_ON"):
	1765	if self.panels[item].ALWAYS_ON:
	1766	continue
[1b1bbf9]	1767
[41d466f]	1768	if self.panels[item].window_name in panels:
	1769	if not self._mgr.GetPane(self.panels[item].window_name).IsShown():
	1770	self._mgr.GetPane(self.panels[item].window_name).Show()
	1771	else:
[3feed3e]	1772	# always show the data panel if enable
	1773	style = self.__gui_style & GUIFRAME.MANAGER_ON
	1774	if (style == GUIFRAME.MANAGER_ON) and self.panels[item] == self._data_panel:
	1775	if 'data_panel' in self.panels.keys():
	1776	flag = self._mgr.GetPane(self.panels['data_panel'].window_name).IsShown()
	1777	self._mgr.GetPane(self.panels['data_panel'].window_name).Show(flag)
	1778	else:
	1779	if self._mgr.GetPane(self.panels[item].window_name).IsShown():
	1780	self._mgr.GetPane(self.panels[item].window_name).Hide()
[1b1bbf9]	1781
[41d466f]	1782	self._mgr.Update()
[4e9583c]	1783
[1b1bbf9]	1784	def show_data_panel(self, event=None, action=True):
[52b8b74]	1785	"""
[3feed3e]	1786	show the data panel
[52b8b74]	1787	"""
[1b1bbf9]	1788	if self._data_panel_menu == None:
	1789	return
[e75b5fa]	1790	label = self._data_panel_menu.GetText()
[03da8ed]	1791	if label == 'Show Data Explorer':
[75fbd17]	1792	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
	1793	#if not pane.IsShown():
[1b1bbf9]	1794	if action:
	1795	pane.Show(True)
	1796	self._mgr.Update()
[e75b5fa]	1797	self.__gui_style = self.__gui_style \| GUIFRAME.MANAGER_ON
	1798
[03da8ed]	1799	self._data_panel_menu.SetText('Hide Data Explorer')
[e75b5fa]	1800	else:
	1801	pane = self._mgr.GetPane(self.panels["data_panel"].window_name)
	1802	#if not pane.IsShown():
[1b1bbf9]	1803	if action:
	1804	pane.Show(False)
	1805	self._mgr.Update()
[e75b5fa]	1806	self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
[03da8ed]	1807	self._data_panel_menu.SetText('Show Data Explorer')
[c70eb7c]	1808
	1809	def add_data_helper(self, data_list):
	1810	"""
	1811	"""
[e88ebfd]	1812	if self._data_manager is not None:
	1813	self._data_manager.add_data(data_list)
[c70eb7c]	1814
[75fbd17]	1815	def add_data(self, data_list):
[f444b20]	1816	"""
[e88ebfd]	1817	receive a dictionary of data from loader
	1818	store them its data manager if possible
	1819	send to data the current active perspective if the data panel
	1820	is not active.
	1821	:param data_list: dictionary of data's ID and value Data
[f444b20]	1822	"""
[e88ebfd]	1823	#Store data into manager
	1824	self.add_data_helper(data_list)
	1825	# set data in the data panel
	1826	if self._data_panel is not None:
	1827	data_state = self._data_manager.get_data_state(data_list.keys())
	1828	self._data_panel.load_data_list(data_state)
	1829	#if the data panel is shown wait for the user to press a button
	1830	#to send data to the current perspective. if the panel is not
	1831	#show automatically send the data to the current perspective
[3feed3e]	1832	style = self.__gui_style & GUIFRAME.MANAGER_ON
	1833	if style == GUIFRAME.MANAGER_ON:
[9c169f4]	1834	#wait for button press from the data panel to set_data
[3feed3e]	1835	if self._data_panel is not None:
	1836	self._mgr.GetPane(self._data_panel.window_name).Show(True)
[9c169f4]	1837	self._mgr.Update()
[3feed3e]	1838	else:
	1839	#automatically send that to the current perspective
[e88ebfd]	1840	self.set_data(data_id=data_list.keys())
[1b1bbf9]	1841	self.on_close_welcome_panel()
[c70eb7c]	1842
[0a2fdca]	1843	def set_data(self, data_id, theory_id=None):
[c5e84fb]	1844	"""
[e88ebfd]	1845	set data to current perspective
[c5e84fb]	1846	"""
[e88ebfd]	1847	list_data, _ = self._data_manager.get_by_id(data_id)
	1848	if self._current_perspective is not None:
[f2d9e76]	1849	if self.cleanup_plots:
	1850	for uid, panel in self.plot_panels.iteritems():
	1851	#panel = self.plot_panels[uid]
	1852	window = self._mgr.GetPane(panel.window_name)
	1853	# To hide all docked plot panels when set the data
	1854	if not window.IsFloating():
	1855	self.hide_panel(uid)
[df22224]	1856	self._current_perspective.set_data(list_data.values())
[1b1bbf9]	1857	self.on_close_welcome_panel()
[584c4c4]	1858	else:
[e88ebfd]	1859	msg = "Guiframe does not have a current perspective"
	1860	logging.info(msg)
	1861
	1862	def set_theory(self, state_id, theory_id=None):
[c5e84fb]	1863	"""
	1864	"""
[df22224]	1865	_, list_theory = self._data_manager.get_by_id(theory_id)
[c5e84fb]	1866	if self._current_perspective is not None:
	1867	try:
[df22224]	1868	self._current_perspective.set_theory(list_theory.values())
[c5e84fb]	1869	except:
[e88ebfd]	1870	msg = "Guiframe set_theory: \n" + str(sys.exc_value)
	1871	logging.info(msg)
[c5e84fb]	1872	wx.PostEvent(self, StatusEvent(status=msg, info="error"))
	1873	else:
	1874	msg = "Guiframe does not have a current perspective"
	1875	logging.info(msg)
[3feed3e]	1876
[e88ebfd]	1877	def plot_data(self, state_id, data_id=None,
	1878	theory_id=None, append=False):
[f444b20]	1879	"""
	1880	send a list of data to plot
	1881	"""
[d7f727d]	1882	total_plot_list = []
[e88ebfd]	1883	data_list, _ = self._data_manager.get_by_id(data_id)
[df22224]	1884	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
[d7f727d]	1885	total_plot_list = data_list.values()
[df22224]	1886	for item in temp_list_theory.values():
[e88ebfd]	1887	theory_data, theory_state = item
[d7f727d]	1888	total_plot_list.append(theory_data)
[e88ebfd]	1889	GROUP_ID = wx.NewId()
[d7f727d]	1890	for new_plot in total_plot_list:
[213892bc]	1891	if append:
[ee2b492]	1892	if self.panel_on_focus is None:
[213892bc]	1893	message = "cannot append plot. No plot panel on focus!"
	1894	message += "please click on any available plot to set focus"
	1895	wx.PostEvent(self, StatusEvent(status=message,
	1896	info='warning'))
	1897	return
	1898	else:
[e88ebfd]	1899	if self.enable_add_data(new_plot):
	1900	new_plot.group_id = self.panel_on_focus.group_id
	1901	else:
[8cb8c89]	1902	message = "Only 1D Data can be append to"
	1903	message += " plot panel containing 1D data.\n"
	1904	message += "%s not be appended.\n" %str(new_plot.name)
	1905	message += "try new plot option.\n"
[e88ebfd]	1906	wx.PostEvent(self, StatusEvent(status=message,
	1907	info='warning'))
[4c0572f]	1908	else:
[f2d9e76]	1909	if self.cleanup_plots:
	1910	for id, panel in self.plot_panels.iteritems():
	1911	window = self._mgr.GetPane(panel.window_name)
	1912	# To hide all docked plot panels when set the data
	1913	if not window.IsFloating():
	1914	self.hide_panel(id)
[4c0572f]	1915	#if not append then new plot
[7c7fe67]	1916	from sans.guiframe.dataFitting import Data2D
[8cb8c89]	1917	if issubclass(Data2D, new_plot.__class__):
[7c7fe67]	1918	#for 2 D always plot in a separated new plot
	1919	new_plot.group_id = wx.NewId()
	1920	else:
	1921	# plot all 1D in a new plot
	1922	new_plot.group_id = GROUP_ID
[e88ebfd]	1923	title = "PLOT " + str(new_plot.title)
[f444b20]	1924	wx.PostEvent(self, NewPlotEvent(plot=new_plot,
[f5348253]	1925	title=title,
	1926	group_id = new_plot.group_id))
[f444b20]	1927
[665c083]	1928	def remove_data(self, data_id, theory_id=None):
[213892bc]	1929	"""
	1930	Delete data state if data_id is provide
	1931	delete theory created with data of id data_id if theory_id is provide
	1932	if delete all true: delete the all state
	1933	else delete theory
	1934	"""
[e26d0db]	1935	temp = data_id + theory_id
[60fff67]	1936	"""
	1937	value = [plug.is_in_use(temp) for plug in self.plugins]
	1938	if len(value) > 0:
	1939	print "value"
	1940	return
	1941	from data_panel import DataDialog
	1942	dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
	1943	if dlg.ShowModal() == wx.ID_OK:
	1944	selected_data_list = dlg.get_data()
	1945	dlg.Destroy()
	1946	"""
[6db811e]	1947	for plug in self.plugins:
[e26d0db]	1948	plug.delete_data(temp)
[3658717e]	1949	total_plot_list = []
	1950	data_list, _ = self._data_manager.get_by_id(data_id)
	1951	_, temp_list_theory = self._data_manager.get_by_id(theory_id)
	1952	total_plot_list = data_list.values()
	1953	for item in temp_list_theory.values():
	1954	theory_data, theory_state = item
	1955	total_plot_list.append(theory_data)
	1956	for new_plot in total_plot_list:
	1957	id = new_plot.id
	1958	for group_id in new_plot.list_group_id:
	1959	wx.PostEvent(self, NewPlotEvent(id=id,
	1960	group_id=group_id,
	1961	action='remove'))
	1962	self._data_manager.delete_data(data_id=data_id,
	1963	theory_id=theory_id)
[6db811e]	1964
[213892bc]	1965
[f444b20]	1966	def set_current_perspective(self, perspective):
	1967	"""
	1968	set the current active perspective
	1969	"""
	1970	self._current_perspective = perspective
[f7e9af2]	1971	name = "No current analysis selected"
[cbf22e5]	1972	if self._current_perspective is not None:
	1973	self._add_current_plugin_menu()
[a45037aa]	1974	for panel in self.panels.values():
	1975	if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
	1976	for name in self._current_perspective.get_perspective():
	1977	if name == panel.window_name:
	1978	panel.on_set_focus(event=None)
[fadf925]	1979	break
[f036c692]	1980	name = self._current_perspective.sub_menu
[cbf22e5]	1981	if self._data_panel is not None:
	1982	self._data_panel.set_active_perspective(name)
[95f9cc4]	1983	self._check_applications_menu()
[1b1bbf9]	1984	#Set the SansView title
	1985	self._set_title_name(name)
[52f3c98]	1986
[1b1bbf9]	1987
	1988	def _set_title_name(self, name):
	1989	"""
	1990	Set the SansView title w/ the current application name
	1991
	1992	: param name: application name [string]
	1993	"""
	1994	# Set SanView Window title w/ application anme
	1995	title = self.title + " - " + name + " -"
	1996	self.SetTitle(title)
	1997
[95f9cc4]	1998	def _check_applications_menu(self):
	1999	"""
	2000	check the menu of the current application
	2001	"""
	2002	if self._applications_menu is not None:
	2003	for menu in self._applications_menu.GetMenuItems():
	2004	if self._current_perspective is not None:
	2005	name = self._current_perspective.sub_menu
	2006	if menu.IsCheckable():
	2007	if menu.GetLabel() == name:
	2008	menu.Check(True)
	2009	else:
	2010	menu.Check(False)
[c5e84fb]	2011
[213892bc]	2012	def set_plotpanel_floating(self, event=None):
[7a67e075]	2013	"""
	2014	make the plot panel floatable
	2015	"""
[d785914]	2016
[0663dfb1]	2017	self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
[3feed3e]	2018	self.__gui_style \|= GUIFRAME.FLOATING_PANEL
[d785914]	2019	plot_panel = []
[f2d9e76]	2020	id = event.GetId()
	2021	menu = self._window_menu.FindItemById(id)
[d785914]	2022	if self._plotting_plugin is not None:
[ae83ad3]	2023	plot_panel = self._plotting_plugin.plot_panels.values()
[d785914]	2024	for p in plot_panel:
	2025	self._popup_floating_panel(p)
[f2d9e76]	2026	menu.Check(True)
	2027
[213892bc]	2028	def set_plotpanel_fixed(self, event=None):
[7a67e075]	2029	"""
	2030	make the plot panel fixed
	2031	"""
[0663dfb1]	2032	self.__gui_style &= (~GUIFRAME.FLOATING_PANEL)
[3feed3e]	2033	self.__gui_style \|= GUIFRAME.FIXED_PANEL
	2034	plot_panel = []
[f2d9e76]	2035	id = event.GetId()
	2036	menu = self._window_menu.FindItemById(id)
[3feed3e]	2037	if self._plotting_plugin is not None:
[ae83ad3]	2038	plot_panel = self._plotting_plugin.plot_panels.values()
[d785914]	2039	for p in plot_panel:
	2040	self._popup_fixed_panel(p)
[f2d9e76]	2041	menu.Check(True)
	2042
	2043	def on_cleanup_dock(self, event=None):
	2044	"""
	2045	Set Cleanup Dock option
	2046	"""
	2047	if event == None:
	2048	return
	2049	id = event.GetId()
	2050	menu = self._window_menu.FindItemById(id)
	2051	Flag = self.cleanup_plots
	2052	if not Flag:
	2053	menu.Check(True)
	2054	self.cleanup_plots = True
	2055	msg = "Cleanup-Dock option set to 'ON'."
	2056	else:
	2057	menu.Check(False)
	2058	self.cleanup_plots = False
	2059	msg = "Cleanup-Dock option set to 'OFF'."
	2060
	2061	wx.PostEvent(self, StatusEvent(status= msg))
	2062
[3feed3e]	2063	def _popup_fixed_panel(self, p):
	2064	"""
	2065	"""
	2066	style = self.__gui_style & GUIFRAME.FIXED_PANEL
	2067	if style == GUIFRAME.FIXED_PANEL:
[52f3c98]	2068	self._mgr.GetPane(p.window_name).Dock()
[3feed3e]	2069	self._mgr.GetPane(p.window_name).Floatable()
	2070	self._mgr.GetPane(p.window_name).Right()
	2071	self._mgr.GetPane(p.window_name).TopDockable(False)
	2072	self._mgr.GetPane(p.window_name).BottomDockable(False)
	2073	self._mgr.GetPane(p.window_name).LeftDockable(False)
	2074	self._mgr.GetPane(p.window_name).RightDockable(True)
	2075	self._mgr.Update()
	2076
	2077	def _popup_floating_panel(self, p):
	2078	"""
	2079	"""
	2080	style = self.__gui_style & GUIFRAME.FLOATING_PANEL
	2081	if style == GUIFRAME.FLOATING_PANEL:
	2082	self._mgr.GetPane(p.window_name).Floatable(True)
	2083	self._mgr.GetPane(p.window_name).Float()
	2084	self._mgr.GetPane(p.window_name).Dockable(False)
	2085	self._mgr.Update()
[213892bc]	2086
	2087	def enable_add_data(self, new_plot):
	2088	"""
	2089	Enable append data on a plot panel
	2090	"""
[0a2fdca]	2091
[ee2b492]	2092	if self.panel_on_focus not in self._plotting_plugin.plot_panels.values():
	2093	return
[213892bc]	2094	is_theory = len(self.panel_on_focus.plots) <= 1 and \
	2095	self.panel_on_focus.plots.values()[0].__class__.__name__ == "Theory1D"
	2096
	2097	is_data2d = hasattr(new_plot, 'data')
[0a2fdca]	2098
[213892bc]	2099	is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
	2100	and self.panel_on_focus.group_id is not None
	2101	has_meta_data = hasattr(new_plot, 'meta_data')
	2102
	2103	#disable_add_data if the data is being recovered from a saved state file.
	2104	is_state_data = False
	2105	if has_meta_data:
	2106	if 'invstate' in new_plot.meta_data: is_state_data = True
	2107	if 'prstate' in new_plot.meta_data: is_state_data = True
	2108	if 'fitstate' in new_plot.meta_data: is_state_data = True
	2109
	2110	return is_data1d and not is_data2d and not is_theory and not is_state_data
[d828481]	2111
[f036c692]	2112	def enable_edit_menu(self):
	2113	"""
	2114	enable menu item under edit menu depending on the panel on focus
	2115	"""
[0a2fdca]	2116	if self.cpanel_on_focus is not None and self._edit_menu is not None:
	2117	flag = self.cpanel_on_focus.get_undo_flag()
[f036c692]	2118	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
[0a2fdca]	2119	flag = self.cpanel_on_focus.get_redo_flag()
[f036c692]	2120	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
[0a2fdca]	2121	flag = self.cpanel_on_focus.get_print_flag()
[f036c692]	2122	self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
[0a2fdca]	2123	flag = self.cpanel_on_focus.get_preview_flag()
[f036c692]	2124	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
[0a2fdca]	2125	flag = self.cpanel_on_focus.get_reset_flag()
[f036c692]	2126	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
	2127	else:
	2128	flag = False
	2129	self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
	2130	self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
	2131	self._edit_menu.Enable(GUIFRAME_ID.PRINT_ID, flag)
	2132	self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
	2133	self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
	2134
[d828481]	2135	def on_undo_panel(self, event=None):
	2136	"""
	2137	undo previous action of the last panel on focus if possible
	2138	"""
[0a2fdca]	2139	if self.cpanel_on_focus is not None:
	2140	self.cpanel_on_focus.on_undo(event)
[f036c692]	2141
[d828481]	2142	def on_redo_panel(self, event=None):
	2143	"""
	2144	redo the last cancel action done on the last panel on focus
	2145	"""
[0a2fdca]	2146	if self.cpanel_on_focus is not None:
	2147	self.cpanel_on_focus.on_redo(event)
[f036c692]	2148
[d828481]	2149	def on_bookmark_panel(self, event=None):
	2150	"""
[4e4d3bb]	2151	bookmark panel
[d828481]	2152	"""
[0a2fdca]	2153	if self.cpanel_on_focus is not None:
	2154	self.cpanel_on_focus.on_bookmark(event)
[f036c692]	2155
[4e4d3bb]	2156	def append_bookmark(self, event=None):
	2157	"""
	2158	Bookmark available information of the panel on focus
	2159	"""
	2160	self._toolbar.append_bookmark(event)
	2161
[d828481]	2162	def on_save_panel(self, event=None):
	2163	"""
	2164	save possible information on the current panel
	2165	"""
[0a2fdca]	2166	if self.cpanel_on_focus is not None:
	2167	self.cpanel_on_focus.on_save(event)
[f036c692]	2168
[d828481]	2169	def on_preview_panel(self, event=None):
	2170	"""
	2171	preview information on the panel on focus
	2172	"""
[0a2fdca]	2173	if self.cpanel_on_focus is not None:
	2174	self.cpanel_on_focus.on_preview(event)
[f036c692]	2175
[d828481]	2176	def on_print_panel(self, event=None):
	2177	"""
	2178	print available information on the last panel on focus
	2179	"""
[0a2fdca]	2180	if self.cpanel_on_focus is not None:
	2181	self.cpanel_on_focus.on_print(event)
[f036c692]	2182
[d828481]	2183	def on_zoom_panel(self, event=None):
	2184	"""
	2185	zoom on the current panel if possible
	2186	"""
[0a2fdca]	2187	if self.cpanel_on_focus is not None:
	2188	self.cpanel_on_focus.on_zoom(event)
[f036c692]	2189
[d828481]	2190	def on_zoom_in_panel(self, event=None):
	2191	"""
	2192	zoom in of the panel on focus
	2193	"""
[0a2fdca]	2194	if self.cpanel_on_focus is not None:
	2195	self.cpanel_on_focus.on_zoom_in(event)
[f036c692]	2196
[d828481]	2197	def on_zoom_out_panel(self, event=None):
	2198	"""
	2199	zoom out on the panel on focus
	2200	"""
[0a2fdca]	2201	if self.cpanel_on_focus is not None:
	2202	self.cpanel_on_focus.on_zoom_out(event)
[f036c692]	2203
[d828481]	2204	def on_drag_panel(self, event=None):
	2205	"""
	2206	drag apply to the panel on focus
	2207	"""
[0a2fdca]	2208	if self.cpanel_on_focus is not None:
	2209	self.cpanel_on_focus.on_drag(event)
[f036c692]	2210
[d828481]	2211	def on_reset_panel(self, event=None):
	2212	"""
	2213	reset the current panel
	2214	"""
[0a2fdca]	2215	if self.cpanel_on_focus is not None:
	2216	self.cpanel_on_focus.on_reset(event)
[03314e7]	2217
	2218	def enable_undo(self):
	2219	"""
	2220	enable undo related control
	2221	"""
[0a2fdca]	2222	if self.cpanel_on_focus is not None:
	2223	self._toolbar.enable_undo(self.cpanel_on_focus)
[03314e7]	2224
	2225	def enable_redo(self):
	2226	"""
	2227	enable redo
	2228	"""
[0a2fdca]	2229	if self.cpanel_on_focus is not None:
	2230	self._toolbar.enable_redo(self.cpanel_on_focus)
[03314e7]	2231
	2232	def enable_bookmark(self):
	2233	"""
	2234	Bookmark
	2235	"""
[0a2fdca]	2236	if self.cpanel_on_focus is not None:
	2237	self._toolbar.enable_bookmark(self.cpanel_on_focus)
[03314e7]	2238
	2239	def enable_save(self):
	2240	"""
	2241	save
	2242	"""
[0a2fdca]	2243	if self.cpanel_on_focus is not None:
	2244	self._toolbar.enable_save(self.cpanel_on_focus)
[03314e7]	2245
	2246	def enable_preview(self):
	2247	"""
	2248	preview
	2249	"""
[0a2fdca]	2250	if self.cpanel_on_focus is not None:
	2251	self._toolbar.enable_preview(self.cpanel_on_focus)
[03314e7]	2252
	2253	def enable_print(self):
	2254	"""
	2255	print
	2256	"""
[0a2fdca]	2257	if self.cpanel_on_focus is not None:
	2258	self._toolbar.enable_print(self.cpanel_on_focus)
[03314e7]	2259
	2260	def enable_zoom(self):
	2261	"""
	2262	zoom
	2263	"""
[0a2fdca]	2264	if self.cpanel_on_focus is not None:
[03314e7]	2265	self._toolbar.enable_zoom(self.panel_on_focus)
	2266
	2267	def enable_zoom_in(self):
	2268	"""
	2269	zoom in
	2270	"""
[0a2fdca]	2271	if self.cpanel_on_focus is not None:
[03314e7]	2272	self._toolbar.enable_zoom_in(self.panel_on_focus)
	2273
	2274	def enable_zoom_out(self):
	2275	"""
	2276	zoom out
	2277	"""
[0a2fdca]	2278	if self.cpanel_on_focus is not None:
[03314e7]	2279	self._toolbar.enable_zoom_out(self.panel_on_focus)
	2280
	2281	def enable_drag(self, event=None):
	2282	"""
	2283	drag
	2284	"""
[0a2fdca]	2285	if self.cpanel_on_focus is not None:
[03314e7]	2286	self._toolbar.enable_drag(self.panel_on_focus)
	2287
	2288	def enable_reset(self):
	2289	"""
	2290	reset the current panel
	2291	"""
[0a2fdca]	2292	if self.cpanel_on_focus is not None:
[03314e7]	2293	self._toolbar.enable_reset(self.panel_on_focus)
[6d727ae]	2294
	2295	def set_schedule_full_draw(self, panel=None, func='del'):
	2296	"""
	2297	Add/subtract the schedule full draw list with the panel given
	2298
	2299	:param panel: plot panel
	2300	:param func: append or del [string]
	2301	"""
	2302
	2303	# append this panel in the schedule list if not in yet
	2304	if func == 'append':
	2305	if not panel in self.schedule_full_draw_list:
	2306	self.schedule_full_draw_list.append(panel)
	2307	# remove this panel from schedule list
	2308	elif func == 'del':
	2309	if len(self.schedule_full_draw_list) > 0:
	2310	if panel in self.schedule_full_draw_list:
	2311	self.schedule_full_draw_list.remove(panel)
	2312
	2313	# reset the schdule
	2314	if len(self.schedule_full_draw_list) == 0:
	2315	self.schedule = False
	2316	else:
	2317	self.schedule = True
	2318
	2319	def full_draw(self):
	2320	"""
	2321	Draw the panels with axes in the schedule to full dwar list
	2322	"""
	2323	count = len(self.schedule_full_draw_list)
	2324	#if not self.schedule:
	2325	if count < 1:
	2326	self.set_schedule(False)
	2327	return
	2328	else:
	2329	ind = 0
	2330	# if any of the panel is shown do full_draw
	2331	for panel in self.schedule_full_draw_list:
	2332	ind += 1
	2333	if self._mgr.GetPane(panel.window_name).IsShown():
	2334	break
	2335	# otherwise, return
	2336	if ind == count:
	2337	return
	2338
	2339	#Simple redraw only for a panel shown
	2340	def f_draw(panel):
	2341	"""
	2342	Draw A panel in the full dwar list
	2343	"""
[dee097b]	2344	try:
	2345	# This checking of GetCapture is to stop redrawing
	2346	# while any panel is capture.
	2347	if self.GetCapture() == None:
	2348	# draw if possible
	2349	panel.set_resizing(False)
	2350	panel.draw_plot()
	2351	# Check if the panel is not shown
	2352	if not self._mgr.GetPane(panel.window_name).IsShown():
	2353	self._mgr.GetPane(panel.window_name).Hide()
	2354	except:
	2355	pass
[6d727ae]	2356	#print self.callback,self.schedule,self.schedule_full_draw_list
	2357
	2358	# Draw all panels
	2359	map(f_draw, self.schedule_full_draw_list)
	2360
	2361	# Reset the attr
	2362	if len(self.schedule_full_draw_list) == 0:
	2363	self.set_schedule(False)
	2364	else:
	2365	self.set_schedule(True)
[de99e3e4]	2366	# do not update mgr
	2367	#self._mgr.Update()
[6d727ae]	2368
	2369	def set_schedule(self, schedule=False):
	2370	"""
	2371	Set schedule
	2372	"""
	2373	self.schedule = schedule
	2374
	2375	def get_schedule(self):
	2376	"""
	2377	Get schedule
	2378	"""
	2379	return self.schedule
	2380
[0a2fdca]	2381	def on_set_plot_focus(self, panel):
	2382	"""
	2383	Set focus on a plot panel
	2384	"""
[dee097b]	2385	self.set_plot_unfocus()
[0a2fdca]	2386	panel.on_set_focus(None)
	2387	# set focusing panel
	2388	self.panel_on_focus = panel
	2389	self.set_panel_on_focus(None)
[5e8e615]	2390
[dee097b]	2391	def set_plot_unfocus(self):
	2392	"""
	2393	Un focus all plot panels
	2394	"""
	2395	for plot in self.plot_panels.values():
	2396	plot.on_kill_focus(None)
	2397
[6d727ae]	2398	def _onDrawIdle(self, args, *kwargs):
	2399	"""
	2400	ReDraw with axes
	2401	"""
	2402	# check if it is time to redraw
	2403	if self.GetCapture() == None:
	2404	# Draw plot, changes resizing too
	2405	self.full_draw()
	2406
	2407	# restart idle
	2408	self._redraw_idle(args, *kwargs)
	2409
	2410
	2411	def _redraw_idle(self, args, *kwargs):
	2412	"""
	2413	Restart Idle
	2414	"""
	2415	# restart idle
	2416	self.idletimer.Restart(55, args, *kwargs)
	2417
[3feed3e]	2418
[d828481]	2419	class DefaultPanel(wx.Panel, PanelBase):
[41d466f]	2420	"""
[d955bf19]	2421	Defines the API for a panels to work with
	2422	the GUI manager
[41d466f]	2423	"""
	2424	## Internal nickname for the window, used by the AUI manager
	2425	window_name = "default"
	2426	## Name to appear on the window title bar
	2427	window_caption = "Welcome panel"
	2428	## Flag to tell the AUI manager to put this panel in the center pane
	2429	CENTER_PANE = True
[1b3a5a9]	2430	def __init__(self, parent, args, *kwds):
	2431	wx.Panel.__init__(self, parent, args, *kwds)
	2432	PanelBase.__init__(self, parent)
[d828481]	2433
[41d466f]	2434
[4753fc2]	2435
[41d466f]	2436	# Toy application to test this Frame
	2437	class ViewApp(wx.App):
[d955bf19]	2438	"""
	2439	"""
[41d466f]	2440	def OnInit(self):
[d955bf19]	2441	"""
	2442	"""
[957723f]	2443	pos, size = self.window_placement((GUIFRAME_WIDTH, GUIFRAME_HEIGHT))
[3385795]	2444	self.frame = ViewerFrame(parent=None,
[957723f]	2445	title=APPLICATION_NAME,
[3385795]	2446	pos=pos,
[957723f]	2447	gui_style = DEFAULT_STYLE,
[3385795]	2448	size=size)
[7a955a9]	2449	self.frame.Hide()
[957723f]	2450	self.s_screen = None
[db6ce6c]	2451	try:
[08e1912]	2452	# make sure the current dir is App dir when it starts
[87f4dcc]	2453	temp_path = os.path.dirname(os.path.sys.path[0])
[08e1912]	2454	os.chdir(temp_path)
[db6ce6c]	2455	except:
	2456	pass
[957723f]	2457	# Display a splash screen on top of the frame.
[3385795]	2458	if len(sys.argv) > 1 and '--time' in sys.argv[1:]:
	2459	log_time("Starting to display the splash screen")
[957723f]	2460	try:
	2461	if os.path.isfile(SPLASH_SCREEN_PATH):
	2462	self.s_screen = self.display_splash_screen(parent=self.frame,
	2463	path=SPLASH_SCREEN_PATH)
	2464	else:
	2465	self.frame.Show()
	2466	except:
[7a955a9]	2467	if self.s_screen is not None:
	2468	self.s_screen.Close()
	2469	msg = "Cannot display splash screen\n"
	2470	msg += str (sys.exc_value)
	2471	logging.error(msg)
	2472	self.frame.Show()
[cc835cd8]	2473
[41d466f]	2474	if hasattr(self.frame, 'special'):
	2475	self.frame.special.SetCurrent()
	2476	self.SetTopWindow(self.frame)
[c3f697e]	2477	try:
	2478	self.open_file()
	2479	except:
	2480	msg = "%s Could not load " % str(APPLICATION_NAME)
	2481	msg += "input file from command line.\n"
	2482	logging.error(msg)
[41d466f]	2483	return True
[b46b1b9]	2484
[957723f]	2485	def open_file(self):
	2486	"""
	2487	open a state file at the start of the application
	2488	"""
[c3f697e]	2489	input_file = None
	2490	if len(sys.argv) >= 2:
	2491	cmd = sys.argv[0].lower()
	2492	if os.path.isfile(cmd):
	2493	basename = os.path.basename(cmd)
[64e44c1]	2494	app_py = str(APPLICATION_NAME).lower() + '.py'
	2495	app_exe = str(APPLICATION_NAME).lower() + '.exe'
	2496	if basename.lower() in [app_py, app_exe]:
[c3f697e]	2497	input_file = sys.argv[1]
	2498	if input_file is None:
	2499	return
[976604d]	2500	if self.frame is not None:
[29ef718]	2501	self.frame.set_input_file(input_file=input_file)
[1b1bbf9]	2502
	2503
[41d466f]	2504	def set_manager(self, manager):
	2505	"""
[d955bf19]	2506	Sets a reference to the application manager
	2507	of the GUI manager (Frame)
[41d466f]	2508	"""
	2509	self.frame.set_manager(manager)
	2510
[278cc25]	2511	def build_gui(self):
	2512	"""
[d955bf19]	2513	Build the GUI
[278cc25]	2514	"""
[976604d]	2515	#try to load file at the start
	2516	try:
	2517	self.open_file()
	2518	except:
	2519	raise
[29ef718]	2520	self.frame.build_gui()
[7a955a9]	2521	#if self.s_screen is not None and self.s_screen.IsShown():
	2522	# self.s_screen.Close()
[278cc25]	2523
[f9e803e]	2524	def set_welcome_panel(self, panel_class):
	2525	"""
[d955bf19]	2526	Set the welcome panel
	2527
	2528	:param panel_class: class of the welcome panel to be instantiated
	2529
[f9e803e]	2530	"""
	2531	self.frame.set_welcome_panel(panel_class)
	2532
[278cc25]	2533	def add_perspective(self, perspective):
	2534	"""
[d955bf19]	2535	Manually add a perspective to the application GUI
[278cc25]	2536	"""
	2537	self.frame.add_perspective(perspective)
[3385795]	2538
	2539	def window_placement(self, size):
	2540	"""
	2541	Determines the position and size of the application frame such that it
	2542	fits on the user's screen without obstructing (or being obstructed by)
	2543	the Windows task bar. The maximum initial size in pixels is bounded by
	2544	WIDTH x HEIGHT. For most monitors, the application
	2545	will be centered on the screen; for very large monitors it will be
	2546	placed on the left side of the screen.
	2547	"""
	2548	window_width, window_height = size
	2549	screen_size = wx.GetDisplaySize()
	2550	window_height = window_height if screen_size[1]>window_height else screen_size[1]-50
	2551	window_width = window_width if screen_size[0]> window_width else screen_size[0]-50
	2552	xpos = ypos = 0
	2553
	2554	# Note that when running Linux and using an Xming (X11) server on a PC
	2555	# with a dual monitor configuration, the reported display size may be
	2556	# that of both monitors combined with an incorrect display count of 1.
	2557	# To avoid displaying this app across both monitors, we check for
	2558	# screen 'too big'. If so, we assume a smaller width which means the
	2559	# application will be placed towards the left hand side of the screen.
	2560
	2561	_, _, x, y = wx.Display().GetClientArea() # size excludes task bar
	2562	if len(sys.argv) > 1 and '--platform' in sys.argv[1:]:
	2563	w, h = wx.DisplaySize() # size includes task bar area
	2564	if x > 1920: x = 1280 # display on left side, not centered on screen
	2565	if x > window_width: xpos = (x - window_width)/2
	2566	if y > window_height: ypos = (y - window_height)/2
	2567
	2568	# Return the suggested position and size for the application frame.
	2569	return (xpos, ypos), (min(x, window_width), min(y, window_height))
	2570
[783940c]	2571	def display_splash_screen(self, parent,
[957723f]	2572	path=SPLASH_SCREEN_PATH):
[3385795]	2573	"""Displays the splash screen. It will exactly cover the main frame."""
[957723f]	2574
[3385795]	2575	# Prepare the picture. On a 2GHz intel cpu, this takes about a second.
	2576	x, y = parent.GetSizeTuple()
	2577	image = wx.Image(path, wx.BITMAP_TYPE_PNG)
[957723f]	2578	image.Rescale(SPLASH_SCREEN_WIDTH,
	2579	SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
[3385795]	2580	bm = image.ConvertToBitmap()
	2581
	2582	# Create and show the splash screen. It will disappear only when the
	2583	# program has entered the event loop AND either the timeout has expired
	2584	# or the user has left clicked on the screen. Thus any processing
	2585	# performed in this routine (including sleeping) or processing in the
	2586	# calling routine (including doing imports) will prevent the splash
	2587	# screen from disappearing.
	2588	#
	2589	# Note that on Linux, the timeout appears to occur immediately in which
	2590	# case the splash screen disappears upon entering the event loop.
[783940c]	2591	s_screen = wx.SplashScreen(bitmap=bm,
	2592	splashStyle=(wx.SPLASH_TIMEOUT\|
	2593	wx.SPLASH_CENTRE_ON_SCREEN),
	2594	style=(wx.SIMPLE_BORDER\|
	2595	wx.FRAME_NO_TASKBAR\|
	2596	wx.STAY_ON_TOP),
	2597
[957723f]	2598	milliseconds=SS_MAX_DISPLAY_TIME,
[3385795]	2599	parent=parent,
	2600	id=wx.ID_ANY)
[7a955a9]	2601	from gui_statusbar import SPageStatusbar
	2602	statusBar = SPageStatusbar(s_screen)
	2603	s_screen.SetStatusBar(statusBar)
[783940c]	2604	s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
	2605	s_screen.Show()
	2606	return s_screen
	2607
	2608
	2609	def on_close_splash_screen(self, event):
	2610	"""
	2611	"""
	2612	self.frame.Show(True)
	2613	event.Skip()
[b46b1b9]	2614
[41d466f]	2615	if __name__ == "__main__":
	2616	app = ViewApp(0)
[32c0841]	2617	app.MainLoop()
	2618
	2619

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

SasView

source: sasview/guiframe/gui_manager.py @ 4efefc6

Download in other formats: