data_panel.py @ f4771596

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

Last change on this file since f4771596 was a1b8fee, checked in by andyfaff, 8 years ago
MAINT: from future import print_function
Property mode set to `100644`
File size: 55.1 KB

Rev	Line
[959eb01]	1	################################################################################
	2	# This software was developed by the University of Tennessee as part of the
	3	# Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
	4	# project funded by the US National Science Foundation.
	5	#
	6	# See the license text in license.txt
	7	#
	8	# copyright 2010, University of Tennessee
	9	################################################################################
	10	"""
	11	This module provides Graphic interface for the data_manager module.
	12	"""
[a1b8fee]	13	from __future__ import print_function
	14
[959eb01]	15	import wx
	16	from wx.build import build_options
	17
	18	import sys
	19	from wx.lib.scrolledpanel import ScrolledPanel
	20	import wx.lib.agw.customtreectrl as CT
	21	from sas.sasgui.guiframe.dataFitting import Data1D
	22	from sas.sasgui.guiframe.dataFitting import Data2D
	23	from sas.sasgui.guiframe.panel_base import PanelBase
	24	from sas.sasgui.guiframe.events import StatusEvent
	25	from sas.sasgui.guiframe.events import EVT_DELETE_PLOTPANEL
	26	from sas.sasgui.guiframe.events import NewLoadDataEvent
	27	from sas.sasgui.guiframe.events import NewPlotEvent
	28	from sas.sasgui.guiframe.gui_style import GUIFRAME
	29	from sas.sasgui.guiframe.events import NewBatchEvent
	30	from sas.sascalc.dataloader.loader import Loader
	31	# from sas.sasgui.guiframe.local_perspectives.plotting.masking \
	32	# import FloatPanel as QucikPlotDialog
	33	from sas.sasgui.guiframe.local_perspectives.plotting.SimplePlot \
	34	import PlotFrame as QucikPlotDialog
	35	import sas.sasgui.guiframe.config as config
	36
	37	# Check version
	38	toks = str(wx.__version__).split('.')
	39	if int(toks[1]) < 9:
	40	if int(toks[2]) < 12:
	41	wx_version = 811
	42	else:
	43	wx_version = 812
	44	else:
	45	wx_version = 900
	46
	47	extension_list = []
	48	if config.APPLICATION_STATE_EXTENSION is not None:
	49	extension_list.append(config.APPLICATION_STATE_EXTENSION)
	50	EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS + extension_list
	51	PLUGINS_WLIST = config.PLUGINS_WLIST
	52	APPLICATION_WLIST = config.APPLICATION_WLIST
	53
	54	# Control panel width
	55	if sys.platform.count("win32") > 0:
	56	PANEL_WIDTH = 235
	57	PANEL_HEIGHT = 700
	58	CBOX_WIDTH = 140
	59	BUTTON_WIDTH = 80
	60	FONT_VARIANT = 0
	61	IS_MAC = False
	62	else:
	63	PANEL_WIDTH = 255
	64	PANEL_HEIGHT = 750
	65	CBOX_WIDTH = 155
	66	BUTTON_WIDTH = 100
	67	FONT_VARIANT = 1
	68	IS_MAC = True
	69
	70	STYLE_FLAG = (wx.RAISED_BORDER \| CT.TR_HAS_BUTTONS \|
	71	wx.WANTS_CHARS \| CT.TR_HAS_VARIABLE_ROW_HEIGHT)
	72
	73
	74	class DataTreeCtrl(CT.CustomTreeCtrl):
	75	"""
	76	Check list control to be used for Data Panel
	77	"""
	78	def __init__(self, parent, root, args, *kwds):
	79	# agwstyle is introduced in wx.2.8.11 but is not working for mac
	80	if IS_MAC and wx_version < 812:
	81	try:
	82	kwds['style'] = STYLE_FLAG
	83	CT.CustomTreeCtrl.__init__(self, parent, args, *kwds)
	84	except:
	85	del kwds['style']
	86	CT.CustomTreeCtrl.__init__(self, parent, args, *kwds)
	87	else:
	88	# agwstyle is introduced in wx.2.8.11
	89	# argument working only for windows
	90	try:
	91	kwds['agwStyle'] = STYLE_FLAG
	92	CT.CustomTreeCtrl.__init__(self, parent, args, *kwds)
	93	except:
	94	try:
	95	del kwds['agwStyle']
	96	kwds['style'] = STYLE_FLAG
	97	CT.CustomTreeCtrl.__init__(self, parent, args, *kwds)
	98	except:
	99	del kwds['style']
	100	CT.CustomTreeCtrl.__init__(self, parent, args, *kwds)
	101	self.root = self.AddRoot(root)
	102
	103	def OnCompareItems(self, item1, item2):
	104	"""
	105	Overrides OnCompareItems in wx.TreeCtrl.
	106	Used by the SortChildren method.
	107	"""
	108	# Get the item data
	109	data_1 = self.GetItemText(item1)
	110	data_2 = self.GetItemText(item2)
	111	# Compare the item data
	112	if data_1 < data_2:
	113	return -1
	114	elif data_1 > data_2:
	115	return 1
	116	else:
	117	return 0
	118
	119
	120	class DataPanel(ScrolledPanel, PanelBase):
	121	"""
	122	This panel displays data available in the application and widgets to
	123	interact with data.
	124	"""
	125	# Internal name for the AUI manager
	126	window_name = "Data Panel"
	127	# Title to appear on top of the window
	128	window_caption = "Data Explorer"
	129	# type of window
	130	window_type = "Data Panel"
	131	# Flag to tell the GUI manager that this panel is not
	132	# tied to any perspective
	133	# ALWAYS_ON = True
	134
	135	def __init__(self, parent,
	136	list=None,
	137	size=(PANEL_WIDTH, PANEL_HEIGHT),
	138	id=-1,
	139	list_of_perspective=None, manager=None, args, *kwds):
	140	# kwds['size'] = size
	141	# kwds['style'] = STYLE_FLAG
	142	ScrolledPanel.__init__(self, parent=parent, id=id, args, *kwds)
	143	PanelBase.__init__(self, parent)
	144	self.SetupScrolling()
	145	# Set window's font size
	146	self.SetWindowVariant(variant=FONT_VARIANT)
	147	self.loader = Loader()
	148	# Default location
	149	self._default_save_location = None
	150	self.all_data1d = True
	151	self.parent = parent.parent
	152	self._manager = manager
	153	self.frame = parent
	154	if list is None:
	155	list = []
	156	self.list_of_data = list
	157	if list_of_perspective is None:
	158	list_of_perspective = []
	159	self.list_of_perspective = list_of_perspective
	160	self.list_rb_perspectives = []
	161	self.list_cb_data = {}
	162	self.list_cb_theory = {}
	163	self.tree_ctrl = None
	164	self.tree_ctrl_theory = None
	165	self.perspective_cbox = None
	166	# Create context menu for page
	167	self.data_menu = None
	168	self.popUpMenu = None
	169	self.plot3d_id = None
	170	self.editmask_id = None
	171	# Default attr
	172	self.vbox = None
	173	self.sizer1 = None
	174	self.sizer2 = None
	175	self.sizer3 = None
	176	self.sizer4 = None
	177	self.sizer5 = None
	178	self.selection_cbox = None
	179	self.bt_add = None
	180	self.bt_remove = None
	181	self.bt_import = None
	182	self.bt_append_plot = None
	183	self.bt_plot = None
	184	self.bt_freeze = None
	185	self.cb_plotpanel = None
	186	self.rb_single_mode = None
	187	self.rb_batch_mode = None
	188
	189	self.owner = None
	190	self.do_layout()
	191	self.fill_cbox_analysis(self.list_of_perspective)
	192	self.Bind(wx.EVT_SHOW, self.on_close_page)
	193	if self.parent is not None:
	194	self.parent.Bind(EVT_DELETE_PLOTPANEL, self._on_delete_plot_panel)
	195
	196	def do_layout(self):
	197	"""
	198	Create the panel layout
	199	"""
	200	self.define_panel_structure()
	201	self.layout_selection()
	202	self.layout_data_list()
	203	self.layout_batch()
	204	self.layout_button()
	205
	206	def disable_app_combo(self, enable):
	207	"""
	208	Disable app combo box
	209	"""
	210	self.perspective_cbox.Enable(enable)
	211
	212	def define_panel_structure(self):
	213	"""
	214	Define the skeleton of the panel
	215	"""
	216	w, h = self.parent.GetSize()
	217	self.vbox = wx.BoxSizer(wx.VERTICAL)
	218	self.sizer1 = wx.BoxSizer(wx.VERTICAL)
	219	self.sizer1.SetMinSize(wx.Size(w/13, h*2/5))
	220
	221	self.sizer2 = wx.BoxSizer(wx.VERTICAL)
	222	self.sizer3 = wx.FlexGridSizer(9, 2, 4, 1)
	223	self.sizer4 = wx.BoxSizer(wx.VERTICAL)
	224	self.sizer5 = wx.BoxSizer(wx.VERTICAL)
	225
	226	self.vbox.Add(self.sizer5, 0, wx.EXPAND \| wx.ALL, 1)
	227	self.vbox.Add(self.sizer1, 1, wx.EXPAND \| wx.ALL, 0)
	228	self.vbox.Add(self.sizer2, 0, wx.EXPAND \| wx.ALL, 1)
	229	self.vbox.Add(self.sizer3, 0, wx.EXPAND \| wx.ALL, 10)
	230	# self.vbox.Add(self.sizer4, 0, wx.EXPAND\|wx.ALL,5)
	231
	232	self.SetSizer(self.vbox)
	233
	234	def layout_selection(self):
	235	"""
	236	Create selection option combo box
	237	"""
	238	select_txt = wx.StaticText(self, -1, 'Selection Options')
	239	select_txt.SetForegroundColour('blue')
	240	self.selection_cbox = wx.ComboBox(self, -1, style=wx.CB_READONLY)
	241	list_of_options = ['Select all Data',
	242	'Unselect all Data',
	243	'Select all Data 1D',
	244	'Unselect all Data 1D',
	245	'Select all Data 2D',
	246	'Unselect all Data 2D']
	247	for option in list_of_options:
	248	self.selection_cbox.Append(str(option))
	249	self.selection_cbox.SetValue('Select all Data')
	250	wx.EVT_COMBOBOX(self.selection_cbox, -1, self._on_selection_type)
	251	self.sizer5.AddMany([(select_txt, 0, wx.ALL, 5),
	252	(self.selection_cbox, 0, wx.ALL, 5)])
	253	self.enable_selection()
	254
	255	def _on_selection_type(self, event):
	256	"""
	257	Select data according to patterns
	258	:param event: UI event
	259	"""
	260	def check_item_and_children(control, check_value=True):
	261	self.tree_ctrl.CheckItem(data_ctrl, check_value)
	262	if data_ctrl.HasChildren():
	263	if check_value and not control.IsExpanded():
	264	# Only select children if control is expanded
	265	# Always deselect children, regardless (see ticket #259)
	266	return
	267	for child_ctrl in data_ctrl.GetChildren():
	268	self.tree_ctrl.CheckItem(child_ctrl, check_value)
	269
	270	option = self.selection_cbox.GetValue()
	271
	272	pos = self.selection_cbox.GetSelection()
	273	if pos == wx.NOT_FOUND:
	274	return
	275	option = self.selection_cbox.GetString(pos)
	276	for item in self.list_cb_data.values():
	277	data_ctrl, _, _, _, _, _, _, _ = item
	278	_, data_class, _ = self.tree_ctrl.GetItemPyData(data_ctrl)
	279	if option == 'Select all Data':
	280	check_item_and_children(data_ctrl, check_value=True)
	281	elif option == 'Unselect all Data':
	282	check_item_and_children(data_ctrl, check_value=False)
	283	elif option == 'Select all Data 1D':
	284	if data_class == 'Data1D':
	285	check_item_and_children(data_ctrl, check_value=True)
	286	elif option == 'Unselect all Data 1D':
	287	if data_class == 'Data1D':
	288	check_item_and_children(data_ctrl, check_value=False)
	289	elif option == 'Select all Data 2D':
	290	if data_class == 'Data2D':
	291	check_item_and_children(data_ctrl, check_value=True)
	292	elif option == 'Unselect all Data 2D':
	293	if data_class == 'Data2D':
	294	check_item_and_children(data_ctrl, check_value=False)
	295	self.enable_append()
	296	self.enable_freeze()
	297	self.enable_plot()
	298	self.enable_import()
	299	self.enable_remove()
	300
	301	def layout_button(self):
	302	"""
	303	Layout widgets related to buttons
	304	"""
	305	# Load Data Button
	306	self.bt_add = wx.Button(self, wx.NewId(), "Load Data",
	307	size=(BUTTON_WIDTH, -1))
	308	self.bt_add.SetToolTipString("Load data files")
	309	wx.EVT_BUTTON(self, self.bt_add.GetId(), self._load_data)
	310
	311	# Delete Data Button
	312	self.bt_remove = wx.Button(self, wx.NewId(), "Delete Data",
	313	size=(BUTTON_WIDTH, -1))
	314	self.bt_remove.SetToolTipString("Delete data from the application")
	315	wx.EVT_BUTTON(self, self.bt_remove.GetId(), self.on_remove)
	316
	317	# Send data to perspective button
	318	self.bt_import = wx.Button(self, wx.NewId(), "Send To",
	319	size=(BUTTON_WIDTH, -1))
	320	self.bt_import.SetToolTipString("Send Data set to active perspective")
	321	wx.EVT_BUTTON(self, self.bt_import.GetId(), self.on_import)
	322
	323	# Choose perspective to be send data to combo box
	324	self.perspective_cbox = wx.ComboBox(self, -1,
	325	style=wx.CB_READONLY)
	326	if not IS_MAC:
	327	self.perspective_cbox.SetMinSize((BUTTON_WIDTH*1.6, -1))
	328	wx.EVT_COMBOBOX(self.perspective_cbox, -1,
	329	self._on_perspective_selection)
	330
	331	# Append data to current Graph Button
	332	self.bt_append_plot = wx.Button(self, wx.NewId(), "Append Plot To",
	333	size=(BUTTON_WIDTH, -1))
	334	self.bt_append_plot.SetToolTipString(
	335	"Plot the selected data in the active panel")
	336	wx.EVT_BUTTON(self, self.bt_append_plot.GetId(), self.on_append_plot)
	337
	338	# Create a new graph and send data to that new graph button
	339	self.bt_plot = wx.Button(self, wx.NewId(), "New Plot",
	340	size=(BUTTON_WIDTH, -1))
	341	self.bt_plot.SetToolTipString("To trigger plotting")
	342	wx.EVT_BUTTON(self, self.bt_plot.GetId(), self.on_plot)
	343
	344	# Freeze current theory button - becomes a data set and stays on graph
	345	self.bt_freeze = wx.Button(self, wx.NewId(), "Freeze Theory",
	346	size=(BUTTON_WIDTH, -1))
	347	freeze_tip = "To trigger freeze a theory: making a copy\n"
	348	freeze_tip += "of the theory checked to Data box,\n"
	349	freeze_tip += " so that it can act like a real data set."
	350	self.bt_freeze.SetToolTipString(freeze_tip)
	351	wx.EVT_BUTTON(self, self.bt_freeze.GetId(), self.on_freeze)
	352
	353	# select plot to send to combo box (blank if no data)
	354	if sys.platform == 'darwin':
	355	self.cb_plotpanel = wx.ComboBox(self, -1,
	356	style=wx.CB_READONLY)
	357	else:
	358	self.cb_plotpanel = wx.ComboBox(self, -1,
	359	style=wx.CB_READONLY \| wx.CB_SORT)
	360	wx.EVT_COMBOBOX(self.cb_plotpanel, -1, self._on_plot_selection)
	361	self.cb_plotpanel.Disable()
	362
	363	# Help button
	364	self.bt_help = wx.Button(self, wx.NewId(), "HELP",
	365	size=(BUTTON_WIDTH, -1))
	366	self.bt_help.SetToolTipString("Help for the Data Explorer.")
	367	wx.EVT_BUTTON(self, self.bt_help.GetId(), self.on_help)
	368
	369	self.sizer3.AddMany([(self.bt_add),
	370	((10, 10)),
	371	(self.bt_remove),
	372	((10, 10)),
	373	(self.bt_freeze),
	374	((10, 10)),
	375	(self.bt_plot),
	376	((10, 10)),
	377	(self.bt_append_plot),
	378	(self.cb_plotpanel,
	379	wx.EXPAND \| wx.ADJUST_MINSIZE, 5),
	380	((5, 5)),
	381	((5, 5)),
	382	(self.bt_import, 0, wx.EXPAND \| wx.RIGHT, 5),
	383	(self.perspective_cbox,
	384	wx.EXPAND \| wx.ADJUST_MINSIZE, 5),
	385	((10, 10)),
	386	(self.sizer4),
	387	((10, 10)),
	388	(self.bt_help, 0, wx.RIGHT, 5)])
	389
	390	self.sizer3.AddGrowableCol(1, 1)
	391	self.show_data_button()
	392	self.enable_remove()
	393	self.enable_import()
	394	self.enable_plot()
	395	self.enable_append()
	396	self.enable_freeze()
	397	self.enable_remove_plot()
	398
	399	def layout_batch(self):
	400	"""
	401	Set up batch mode options
	402	"""
	403	self.rb_single_mode = wx.RadioButton(self, -1, 'Single Mode',
	404	style=wx.RB_GROUP)
	405	self.rb_batch_mode = wx.RadioButton(self, -1, 'Batch Mode')
	406	self.Bind(wx.EVT_RADIOBUTTON, self.on_single_mode,
	407	id=self.rb_single_mode.GetId())
	408	self.Bind(wx.EVT_RADIOBUTTON, self.on_batch_mode,
	409	id=self.rb_batch_mode.GetId())
	410
	411	self.rb_single_mode.SetValue(not self.parent.batch_on)
	412	self.rb_batch_mode.SetValue(self.parent.batch_on)
	413	self.sizer4.AddMany([(self.rb_single_mode, 0, wx.ALL, 4),
	414	(self.rb_batch_mode, 0, wx.ALL, 4)])
	415
	416	def on_single_mode(self, event):
	417	"""
	418	Change to single mode
	419	:param event: UI event
	420	"""
	421	if self.parent is not None:
	422	wx.PostEvent(self.parent, NewBatchEvent(enable=False))
	423
	424	def on_batch_mode(self, event):
	425	"""
	426	Change to batch mode
	427	:param event: UI event
	428	"""
	429	if self.parent is not None:
	430	wx.PostEvent(self.parent,
	431	NewBatchEvent(enable=True))
	432
	433	def _get_data_selection(self, event):
	434	"""
	435	Get data selection from the right click
	436	:param event: UI event
	437	"""
	438	data = None
	439	# selection = event.GetSelection()
	440	id, _, _ = self.FindFocus().GetSelection().GetData()
	441	data_list, theory_list = \
	442	self.parent.get_data_manager().get_by_id(id_list=[id])
	443	if data_list:
	444	data = data_list.values()[0]
	445	if data is None:
	446	data = theory_list.values()[0][0]
	447	return data
	448
	449	def on_edit_data(self, event):
	450	"""
	451	Pop Up Data Editor
	452	"""
	453	data = self._get_data_selection(event)
	454	from sas.sasgui.guiframe.local_perspectives.plotting.masking \
	455	import MaskPanel as MaskDialog
	456
	457	panel = MaskDialog(parent=self.parent, base=self,
	458	data=data, id=wx.NewId())
	459	panel.ShowModal()
	460
	461	def on_plot_3d(self, event):
	462	"""
	463	Frozen image of 3D
	464	"""
	465	data = self._get_data_selection(event)
	466	from sas.sasgui.guiframe.local_perspectives.plotting.masking \
	467	import FloatPanel as Float3dDialog
	468
	469	panel = Float3dDialog(base=self, data=data,
	470	dimension=3, id=wx.NewId())
	471	panel.ShowModal()
	472
	473	def on_quick_plot(self, event):
	474	"""
	475	Frozen plot
	476	"""
	477	data = self._get_data_selection(event)
	478	if data.__class__.__name__ == "Data2D":
	479	dimension = 2
	480	else:
	481	dimension = 1
	482	# panel = QucikPlotDialog(base=self, data=data,
	483	# dimension=dimension, id=wx.NewId())
	484	frame = QucikPlotDialog(self, -1, "Plot " + data.name, 'log_{10}')
	485	self.parent.put_icon(frame)
	486	frame.add_plot(data)
	487	# frame.SetTitle(title)
	488	frame.Show(True)
	489	frame.SetFocus()
	490	# panel.ShowModal()
	491
	492	def on_data_info(self, event):
	493	"""
	494	Data Info panel
	495	"""
	496	data = self._get_data_selection(event)
	497	if data.__class__.__name__ == "Data2D":
	498	self.parent.show_data2d(data, data.name)
	499	else:
	500	self.parent.show_data1d(data, data.name)
	501
	502	def on_save_as(self, event):
	503	"""
	504	Save data as a file
	505	"""
	506	data = self._get_data_selection(event)
	507	# path = None
	508	default_name = data.name
	509	if default_name.count('.') > 0:
	510	default_name = default_name.split('.')[0]
	511	default_name += "_out"
	512	if self.parent is not None:
	513	if issubclass(data.__class__, Data1D):
	514	self.parent.save_data1d(data, default_name)
	515	elif issubclass(data.__class__, Data2D):
	516	self.parent.save_data2d(data, default_name)
	517	else:
[9c3d784]	518	print("unable to save this type of data")
[959eb01]	519
	520	def layout_data_list(self):
	521	"""
	522	Add a listcrtl in the panel
	523	"""
	524	# Add splitter
	525	w, h = self.parent.GetSize()
	526	splitter = wx.SplitterWindow(self)
	527	splitter.SetMinimumPaneSize(50)
	528	splitter.SetSashGravity(1.0)
	529
	530	file_sizer = wx.BoxSizer(wx.VERTICAL)
	531	file_sizer.SetMinSize(wx.Size(w/13, h*2/5))
	532	theory_sizer = wx.BoxSizer(wx.VERTICAL)
	533	theory_sizer.SetMinSize(wx.Size(w/13, h*2/5))
	534
	535	self.tree_ctrl = DataTreeCtrl(parent=splitter,
	536	style=wx.SUNKEN_BORDER,
	537	root="Available Data")
	538
	539	self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_CHECKING, self.on_check_item)
	540	self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_MENU, self.on_right_click_data)
	541	# Create context menu for page
	542	self.data_menu = wx.Menu()
	543	id = wx.NewId()
	544	name = "Data Info"
	545	msg = "Show Data Info"
	546	self.data_menu.Append(id, name, msg)
	547	wx.EVT_MENU(self, id, self.on_data_info)
	548
	549	id = wx.NewId()
	550	name = "Save As"
	551	msg = "Save Theory/Data as a file"
	552	self.data_menu.Append(id, name, msg)
	553	wx.EVT_MENU(self, id, self.on_save_as)
	554
	555	quickplot_id = wx.NewId()
	556	name = "Quick Plot"
	557	msg = "Plot the current Data"
	558	self.data_menu.Append(quickplot_id, name, msg)
	559	wx.EVT_MENU(self, quickplot_id, self.on_quick_plot)
	560
	561	self.plot3d_id = wx.NewId()
	562	name = "Quick 3DPlot (Slow)"
	563	msg = "Plot3D the current 2D Data"
	564	self.data_menu.Append(self.plot3d_id, name, msg)
	565	wx.EVT_MENU(self, self.plot3d_id, self.on_plot_3d)
	566
	567	self.editmask_id = wx.NewId()
	568	name = "Edit Mask"
	569	msg = "Edit Mask for the current 2D Data"
	570	self.data_menu.Append(self.editmask_id, name, msg)
	571	wx.EVT_MENU(self, self.editmask_id, self.on_edit_data)
	572
	573	self.tree_ctrl_theory = DataTreeCtrl(parent=splitter,
	574	style=wx.SUNKEN_BORDER,
	575	root="Available Theory")
	576	self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_CHECKING,
	577	self.on_check_item)
	578	self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_MENU,
	579	self.on_right_click_theory)
	580	splitter.SplitHorizontally(self.tree_ctrl, self.tree_ctrl_theory)
	581	self.sizer1.Add(splitter, 1, wx.EXPAND \| wx.ALL, 10)
	582
	583	def on_right_click_theory(self, event):
	584	"""
	585	On click theory data
	586	"""
	587	try:
	588	id, data_class_name, _ = \
	589	self.tree_ctrl_theory.GetSelection().GetData()
	590	_, _ = self.parent.get_data_manager().get_by_id(id_list=[id])
	591	except:
	592	return
	593	if self.data_menu is not None:
	594	menu_enable = (data_class_name == "Data2D")
	595	self.data_menu.Enable(self.editmask_id, False)
	596	self.data_menu.Enable(self.plot3d_id, menu_enable)
	597	self.PopupMenu(self.data_menu)
	598
	599	def on_right_click_data(self, event):
	600	"""
	601	Allow Editing Data
	602	"""
	603	# selection = event.GetSelection()
	604	is_data = True
	605	try:
	606	id, data_class_name, _ = self.tree_ctrl.GetSelection().GetData()
	607	data_list, _ = \
	608	self.parent.get_data_manager().get_by_id(id_list=[id])
	609	if not data_list:
	610	is_data = False
	611	except:
	612	return
	613	if self.data_menu is not None:
	614	menu_enable = (data_class_name == "Data2D")
	615	maskmenu_enable = (menu_enable and is_data)
	616	self.data_menu.Enable(self.editmask_id, maskmenu_enable)
	617	self.data_menu.Enable(self.plot3d_id, menu_enable)
	618	self.PopupMenu(self.data_menu)
	619
	620	def onContextMenu(self, event):
	621	"""
	622	Retrieve the state selected state
	623	"""
	624	# Skipping the save state functionality for release 0.9.0
	625	# return
	626	pos = event.GetPosition()
	627	pos = self.ScreenToClient(pos)
	628	self.PopupMenu(self.popUpMenu, pos)
	629
	630	def on_check_item(self, event):
	631	"""
	632	On check item
	633	"""
	634	item = event.GetItem()
	635	item.Check(not item.IsChecked())
	636	self.enable_append()
	637	self.enable_freeze()
	638	self.enable_plot()
	639	self.enable_import()
	640	self.enable_remove()
	641	event.Skip()
	642
	643	def fill_cbox_analysis(self, plugin):
	644	"""
	645	fill the combobox with analysis name
	646	"""
	647	self.list_of_perspective = plugin
	648	if self.parent is None or \
	649	not hasattr(self.parent, "get_current_perspective") or \
	650	len(self.list_of_perspective) == 0:
	651	return
	652	if self.parent is not None and self.perspective_cbox is not None:
	653	for plug in self.list_of_perspective:
	654	if plug.get_perspective():
	655	self.perspective_cbox.Append(plug.sub_menu, plug)
	656
	657	curr_pers = self.parent.get_current_perspective()
	658	if curr_pers:
	659	self.perspective_cbox.SetStringSelection(curr_pers.sub_menu)
	660	self.enable_import()
	661
	662	def load_data_list(self, list):
	663	"""
	664	add need data with its theory under the tree
	665	"""
	666	if list:
	667	for state_id, dstate in list.iteritems():
	668	data = dstate.get_data()
	669	theory_list = dstate.get_theory()
	670	if data is not None:
	671	data_name = str(data.name)
	672	data_title = str(data.title)
	673	data_run = str(data.run)
	674	data_class = data.__class__.__name__
	675	path = dstate.get_path()
	676	process_list = data.process
	677	data_id = data.id
	678	s_path = str(path)
	679	if state_id not in self.list_cb_data:
	680	# new state
	681	data_c = self.tree_ctrl.InsertItem(self.tree_ctrl.root,
	682	0, data_name,
	683	ct_type=1,
	684	data=(data_id, data_class, state_id))
	685	data_c.Check(True)
	686	d_i_c = self.tree_ctrl.AppendItem(data_c, 'Info')
	687	d_t_c = self.tree_ctrl.AppendItem(d_i_c,
	688	'Title: %s' %
	689	data_title)
	690	r_n_c = self.tree_ctrl.AppendItem(d_i_c,
	691	'Run: %s' % data_run)
	692	i_c_c = self.tree_ctrl.AppendItem(d_i_c,
	693	'Type: %s' %
	694	data_class)
	695	p_c_c = self.tree_ctrl.AppendItem(d_i_c,
	696	"Path: '%s'" % s_path)
	697	d_p_c = self.tree_ctrl.AppendItem(d_i_c, 'Process')
	698
	699	for process in process_list:
	700	process_str = str(process).replace('\n', ' ')
	701	if len(process_str) > 20:
	702	process_str = process_str[:20] + ' [...]'
	703	self.tree_ctrl.AppendItem(d_p_c, process_str)
	704	theory_child = self.tree_ctrl.AppendItem(data_c,
	705	"THEORIES")
	706	self.list_cb_data[state_id] = [data_c,
	707	d_i_c,
	708	d_t_c,
	709	r_n_c,
	710	i_c_c,
	711	p_c_c,
	712	d_p_c,
	713	theory_child]
	714	else:
	715	data_ctrl_list = self.list_cb_data[state_id]
	716	# This state is already display replace it contains
	717	data_c, d_i_c, d_t_c, r_n_c, i_c_c, p_c_c, d_p_c, _ \
	718	= data_ctrl_list
	719	self.tree_ctrl.SetItemText(data_c, data_name)
	720	temp = (data_id, data_class, state_id)
	721	self.tree_ctrl.SetItemPyData(data_c, temp)
	722	self.tree_ctrl.SetItemText(i_c_c,
	723	'Type: %s' % data_class)
	724	self.tree_ctrl.SetItemText(p_c_c,
	725	'Path: %s' % s_path)
	726	self.tree_ctrl.DeleteChildren(d_p_c)
	727	for process in process_list:
	728	if not process.is_empty():
	729	_ = self.tree_ctrl.AppendItem(d_p_c,
	730	process.single_line_desc())
	731	wx.CallAfter(self.append_theory, state_id, theory_list)
	732	# Sort by data name
	733	if self.tree_ctrl.root:
	734	self.tree_ctrl.SortChildren(self.tree_ctrl.root)
	735	# Expand root if # of data sets > 0
	736	if self.tree_ctrl.GetCount() > 0:
	737	self.tree_ctrl.root.Expand()
	738	self.enable_remove()
	739	self.enable_import()
	740	self.enable_plot()
	741	self.enable_freeze()
	742	self.enable_selection()
	743
	744	def _uncheck_all(self):
	745	"""
	746	Uncheck all check boxes
	747	"""
	748	for item in self.list_cb_data.values():
	749	data_ctrl, _, _, _, _, _, _, _ = item
	750	self.tree_ctrl.CheckItem(data_ctrl, False)
	751	self.enable_append()
	752	self.enable_freeze()
	753	self.enable_plot()
	754	self.enable_import()
	755	self.enable_remove()
	756
	757	def append_theory(self, state_id, theory_list):
	758	"""
	759	append theory object under data from a state of id = state_id
	760	replace that theory if already displayed
	761	"""
	762	if not theory_list:
	763	return
	764	if state_id not in self.list_cb_data.keys():
	765	root = self.tree_ctrl_theory.root
	766	tree = self.tree_ctrl_theory
	767	else:
	768	item = self.list_cb_data[state_id]
	769	data_c, _, _, _, _, _, _, _ = item
	770	root = data_c
	771	tree = self.tree_ctrl
	772	if root is not None:
	773	wx.CallAfter(self.append_theory_helper, tree=tree, root=root,
	774	state_id=state_id,
	775	theory_list=theory_list)
	776	if self.tree_ctrl_theory.GetCount() > 0:
	777	self.tree_ctrl_theory.root.Expand()
	778
	779	def append_theory_helper(self, tree, root, state_id, theory_list):
	780	"""
	781	Append theory helper
	782	"""
	783	if state_id in self.list_cb_theory.keys():
	784	# update current list of theory for this data
	785	theory_list_ctrl = self.list_cb_theory[state_id]
	786
	787	for theory_id, item in theory_list.iteritems():
	788	theory_data, _ = item
	789	if theory_data is None:
	790	name = "Unknown"
	791	theory_class = "Unknown"
	792	theory_id = "Unknown"
	793	temp = (None, None, None)
	794	else:
	795	name = theory_data.name
	796	theory_class = theory_data.__class__.__name__
	797	theory_id = theory_data.id
	798	# if theory_state is not None:
	799	# name = theory_state.model.name
	800	temp = (theory_id, theory_class, state_id)
	801	if theory_id not in theory_list_ctrl:
	802	# add new theory
	803	t_child = tree.AppendItem(root,
	804	name, ct_type=1, data=temp)
	805	t_i_c = tree.AppendItem(t_child, 'Info')
	806	i_c_c = tree.AppendItem(t_i_c,
	807	'Type: %s' % theory_class)
	808	t_p_c = tree.AppendItem(t_i_c, 'Process')
	809
	810	for process in theory_data.process:
	811	tree.AppendItem(t_p_c, process.__str__())
	812	theory_list_ctrl[theory_id] = [t_child,
	813	i_c_c,
	814	t_p_c]
	815	else:
	816	# replace theory
	817	t_child, i_c_c, t_p_c = theory_list_ctrl[theory_id]
	818	tree.SetItemText(t_child, name)
	819	tree.SetItemPyData(t_child, temp)
	820	tree.SetItemText(i_c_c, 'Type: %s' % theory_class)
	821	tree.DeleteChildren(t_p_c)
	822	for process in theory_data.process:
	823	tree.AppendItem(t_p_c, process.__str__())
	824
	825	else:
	826	# data didn't have a theory associated it before
	827	theory_list_ctrl = {}
	828	for theory_id, item in theory_list.iteritems():
	829	theory_data, _ = item
	830	if theory_data is not None:
	831	name = theory_data.name
	832	theory_class = theory_data.__class__.__name__
	833	theory_id = theory_data.id
	834	# if theory_state is not None:
	835	# name = theory_state.model.name
	836	temp = (theory_id, theory_class, state_id)
	837	t_child = tree.AppendItem(root,
	838	name, ct_type=1,
	839	data=(theory_data.id, theory_class, state_id))
	840	t_i_c = tree.AppendItem(t_child, 'Info')
	841	i_c_c = tree.AppendItem(t_i_c,
	842	'Type: %s' % theory_class)
	843	t_p_c = tree.AppendItem(t_i_c, 'Process')
	844
	845	for process in theory_data.process:
	846	tree.AppendItem(t_p_c, process.__str__())
	847
	848	theory_list_ctrl[theory_id] = [t_child, i_c_c, t_p_c]
	849	# self.list_cb_theory[data_id] = theory_list_ctrl
	850	self.list_cb_theory[state_id] = theory_list_ctrl
	851
	852	def set_data_helper(self):
	853	"""
	854	Set data helper
	855	"""
	856	data_to_plot = []
	857	state_to_plot = []
	858	theory_to_plot = []
	859	for value in self.list_cb_data.values():
	860	item, _, _, _, _, _, _, _ = value
	861	if item.IsChecked():
	862	data_id, _, state_id = self.tree_ctrl.GetItemPyData(item)
	863	data_to_plot.append(data_id)
	864	if state_id not in state_to_plot:
	865	state_to_plot.append(state_id)
	866
	867	for theory_dict in self.list_cb_theory.values():
	868	for _, value in theory_dict.iteritems():
	869	item, _, _ = value
	870	if item.IsChecked():
	871	theory_id, _, state_id = self.tree_ctrl.GetItemPyData(item)
	872	theory_to_plot.append(theory_id)
	873	if state_id not in state_to_plot:
	874	state_to_plot.append(state_id)
	875	return data_to_plot, theory_to_plot, state_to_plot
	876
	877	def remove_by_id(self, id):
	878	"""
	879	Remove_dat by id
	880	"""
	881	for item in self.list_cb_data.values():
	882	data_c, _, _, _, _, _, _, _ = item
	883	data_id, _, state_id = self.tree_ctrl.GetItemPyData(data_c)
	884	if id == data_id:
	885	self.tree_ctrl.Delete(data_c)
	886	del self.list_cb_data[state_id]
	887	del self.list_cb_theory[data_id]
	888
	889	def load_error(self, error=None):
	890	"""
	891	Pop up an error message.
	892
	893	:param error: details error message to be displayed
	894	"""
	895	if error is not None or str(error).strip() != "":
	896	dial = wx.MessageDialog(self.parent, str(error),
	897	'Error Loading File',
	898	wx.OK \| wx.ICON_EXCLAMATION)
	899	dial.ShowModal()
	900
	901	def _load_data(self, event):
	902	"""
	903	send an event to the parent to trigger load from plugin module
	904	"""
	905	if self.parent is not None:
	906	wx.PostEvent(self.parent, NewLoadDataEvent())
	907
	908	def on_remove(self, event, prompt=True):
	909	"""
	910	Get a list of item checked and remove them from the treectrl
	911	Ask the parent to remove reference to this item
	912	"""
	913	if prompt:
	914	msg = "This operation will delete the data sets checked "
	915	msg += "and all the dependents."
	916	msg_box = wx.MessageDialog(None, msg, 'Warning', wx.OK\|wx.CANCEL)
	917	if msg_box.ShowModal() != wx.ID_OK:
	918	return
	919
	920	data_to_remove, theory_to_remove, _ = self.set_data_helper()
	921	data_key = []
	922	theory_key = []
	923	# remove data from treectrl
	924	for d_key, item in self.list_cb_data.iteritems():
	925	data_c, _, _, _, _, _, _, _ = item
	926	if data_c.IsChecked():
	927	self.tree_ctrl.Delete(data_c)
	928	data_key.append(d_key)
	929	if d_key in self.list_cb_theory.keys():
	930	theory_list_ctrl = self.list_cb_theory[d_key]
	931	theory_to_remove += theory_list_ctrl.keys()
	932	# Remove theory from treectrl
	933	for _, theory_dict in self.list_cb_theory.iteritems():
	934	for key, value in theory_dict.iteritems():
	935	item, _, _ = value
	936	if item.IsChecked():
	937	try:
	938	self.tree_ctrl.Delete(item)
	939	except:
	940	pass
	941	theory_key.append(key)
	942
	943	# Remove data and related theory references
	944	for key in data_key:
	945	del self.list_cb_data[key]
	946	if key in theory_key:
	947	del self.list_cb_theory[key]
	948	# remove theory references independently of data
	949	for key in theory_key:
	950	for _, theory_dict in self.list_cb_theory.iteritems():
	951	if key in theory_dict:
	952	for key, value in theory_dict.iteritems():
	953	item, _, _ = value
	954	if item.IsChecked():
	955	try:
	956	self.tree_ctrl_theory.Delete(item)
	957	except:
	958	pass
	959	del theory_dict[key]
	960
	961	self.parent.remove_data(data_id=data_to_remove,
	962	theory_id=theory_to_remove)
	963	self.enable_remove()
	964	self.enable_freeze()
	965	self.enable_remove_plot()
	966
	967	def on_import(self, event=None):
	968	"""
	969	Get all select data and set them to the current active perspetive
	970	"""
	971	if event is not None:
	972	event.Skip()
	973	data_id, theory_id, state_id = self.set_data_helper()
	974	temp = data_id + state_id
	975	self.parent.set_data(data_id=temp, theory_id=theory_id)
	976
	977	def on_append_plot(self, event=None):
	978	"""
	979	append plot to plot panel on focus
	980	"""
	981	self._on_plot_selection()
	982	data_id, theory_id, state_id = self.set_data_helper()
	983	self.parent.plot_data(data_id=data_id,
	984	state_id=state_id,
	985	theory_id=theory_id,
	986	append=True)
	987
	988	def on_plot(self, event=None):
	989	"""
	990	Send a list of data names to plot
	991	"""
	992	data_id, theory_id, state_id = self.set_data_helper()
	993	self.parent.plot_data(data_id=data_id,
	994	state_id=state_id,
	995	theory_id=theory_id,
	996	append=False)
	997	self.enable_remove_plot()
	998
	999	def on_close_page(self, event=None):
	1000	"""
	1001	On close
	1002	"""
	1003	if event is not None:
	1004	event.Skip()
	1005	# send parent to update menu with no show nor hide action
	1006	self.parent.show_data_panel(action=False)
	1007
	1008	def on_freeze(self, event):
	1009	"""
	1010	On freeze to make a theory to a data set
	1011	"""
	1012	_, theory_id, state_id = self.set_data_helper()
	1013	if len(theory_id) > 0:
	1014	self.parent.freeze(data_id=state_id, theory_id=theory_id)
	1015	msg = "Freeze Theory:"
	1016	msg += " The theory(s) copied to the Data box as a data set."
	1017	else:
	1018	msg = "Freeze Theory: Requires at least one theory checked."
	1019	wx.PostEvent(self.parent, StatusEvent(status=msg))
	1020
	1021	def set_active_perspective(self, name):
	1022	"""
	1023	set the active perspective
	1024	"""
	1025	self.perspective_cbox.SetStringSelection(name)
	1026	self.enable_import()
	1027
	1028	def _on_delete_plot_panel(self, event):
	1029	"""
	1030	get an event with attribute name and caption to delete existing name
	1031	from the combobox of the current panel
	1032	"""
	1033	# name = event.name
	1034	caption = event.caption
	1035	if self.cb_plotpanel is not None:
	1036	pos = self.cb_plotpanel.FindString(str(caption))
	1037	if pos != wx.NOT_FOUND:
	1038	self.cb_plotpanel.Delete(pos)
	1039	self.enable_append()
	1040
	1041	def set_panel_on_focus(self, name=None):
	1042	"""
	1043	set the plot panel on focus
	1044	"""
	1045	if self.cb_plotpanel and self.cb_plotpanel.IsBeingDeleted():
	1046	return
	1047	for _, value in self.parent.plot_panels.iteritems():
	1048	name_plot_panel = str(value.window_caption)
	1049	if name_plot_panel not in self.cb_plotpanel.GetItems():
	1050	self.cb_plotpanel.Append(name_plot_panel, value)
	1051	if name is not None and name == name_plot_panel:
	1052	self.cb_plotpanel.SetStringSelection(name_plot_panel)
	1053	break
	1054	self.enable_append()
	1055	self.enable_remove_plot()
	1056
	1057	def set_plot_unfocus(self):
	1058	"""
	1059	Unfocus plot
	1060	"""
	1061	return
	1062
	1063	def _on_perspective_selection(self, event=None):
	1064	"""
	1065	select the current perspective for guiframe
	1066	"""
	1067	selection = self.perspective_cbox.GetSelection()
	1068	if self.perspective_cbox.GetValue() != 'None':
	1069	perspective = self.perspective_cbox.GetClientData(selection)
	1070	perspective.on_perspective(event=None)
	1071	self.parent.check_multimode(perspective=perspective)
	1072
	1073	def _on_plot_selection(self, event=None):
	1074	"""
	1075	On source combobox selection
	1076	"""
	1077	if event is not None:
	1078	combo = event.GetEventObject()
	1079	event.Skip()
	1080	else:
	1081	combo = self.cb_plotpanel
	1082	selection = combo.GetSelection()
	1083
	1084	if combo.GetValue() != 'None':
	1085	panel = combo.GetClientData(selection)
	1086	self.parent.on_set_plot_focus(panel)
	1087
	1088	def on_close_plot(self, event):
	1089	"""
	1090	clseo the panel on focus
	1091	"""
	1092	self.enable_append()
	1093	selection = self.cb_plotpanel.GetSelection()
	1094	if self.cb_plotpanel.GetValue() != 'None':
	1095	panel = self.cb_plotpanel.GetClientData(selection)
	1096	if self.parent is not None and panel is not None:
	1097	wx.PostEvent(self.parent,
	1098	NewPlotEvent(group_id=panel.group_id,
	1099	action="delete"))
	1100	self.enable_remove_plot()
	1101
	1102	def set_frame(self, frame):
	1103	"""
	1104	"""
	1105	self.frame = frame
	1106
	1107	def get_frame(self):
	1108	"""
	1109	"""
	1110	return self.frame
	1111
	1112	def on_help(self, event):
	1113	"""
	1114	Bring up the data manager Documentation whenever
	1115	the HELP button is clicked.
	1116
	1117	Calls DocumentationWindow with the path of the location within the
	1118	documentation tree (after /doc/ ....". Note that when using old
	1119	versions of Wx (before 2.9) and thus not the release version of
	1120	installers, the help comes up at the top level of the file as
	1121	webbrowser does not pass anything past the # to the browser when it is
	1122	running "file:///...."
	1123
	1124	:param event: Triggers on clicking the help button
	1125	"""
	1126
	1127	#import documentation window here to avoid circular imports
	1128	#if put at top of file with rest of imports.
	1129	from documentation_window import DocumentationWindow
	1130
	1131	_TreeLocation = "user/sasgui/guiframe/data_explorer_help.html"
	1132	_doc_viewer = DocumentationWindow(self, -1, _TreeLocation, "",
	1133	"Data Explorer Help")
	1134
	1135	def on_close(self, event):
	1136	"""
	1137	On close event
	1138	"""
	1139	self.parent.show_data_panel(event)
	1140
	1141	def set_schedule_full_draw(self, panel=None, func='del'):
	1142	"""
	1143	Send full draw to guimanager
	1144	"""
	1145	self.parent.set_schedule_full_draw(panel, func)
	1146
	1147	def enable_remove_plot(self):
	1148	"""
	1149	enable remove plot button if there is a plot panel on focus
	1150	"""
	1151	pass
	1152	#if self.cb_plotpanel.GetCount() == 0:
	1153	# self.bt_close_plot.Disable()
	1154	#else:
	1155	# self.bt_close_plot.Enable()
	1156
	1157	def enable_remove(self):
	1158	"""
	1159	enable or disable remove button
	1160	"""
	1161	n_t = self.tree_ctrl.GetCount()
	1162	n_t_t = self.tree_ctrl_theory.GetCount()
	1163	if n_t + n_t_t <= 0:
	1164	self.bt_remove.Disable()
	1165	else:
	1166	self.bt_remove.Enable()
	1167
	1168	def enable_import(self):
	1169	"""
	1170	enable or disable send button
	1171	"""
	1172	n_t = 0
	1173	if self.tree_ctrl is not None:
	1174	n_t = self.tree_ctrl.GetCount()
	1175	if n_t > 0 and len(self.list_of_perspective) > 0:
	1176	self.bt_import.Enable()
	1177	else:
	1178	self.bt_import.Disable()
	1179	if len(self.list_of_perspective) <= 0 or \
	1180	self.perspective_cbox.GetValue() in ["None",
	1181	"No Active Application"]:
	1182	self.perspective_cbox.Disable()
	1183	else:
	1184	self.perspective_cbox.Enable()
	1185
	1186	def enable_plot(self):
	1187	"""
	1188	enable or disable plot button
	1189	"""
	1190	n_t = 0
	1191	n_t_t = 0
	1192	if self.tree_ctrl is not None:
	1193	n_t = self.tree_ctrl.GetCount()
	1194	if self.tree_ctrl_theory is not None:
	1195	n_t_t = self.tree_ctrl_theory.GetCount()
	1196	if n_t + n_t_t <= 0:
	1197	self.bt_plot.Disable()
	1198	else:
	1199	self.bt_plot.Enable()
	1200	self.enable_append()
	1201
	1202	def enable_append(self):
	1203	"""
	1204	enable or disable append button
	1205	"""
	1206	n_t = 0
	1207	n_t_t = 0
	1208	if self.tree_ctrl is not None:
	1209	n_t = self.tree_ctrl.GetCount()
	1210	if self.tree_ctrl_theory is not None:
	1211	n_t_t = self.tree_ctrl_theory.GetCount()
	1212	if n_t + n_t_t <= 0:
	1213	self.bt_append_plot.Disable()
	1214	self.cb_plotpanel.Disable()
	1215	elif self.cb_plotpanel.GetCount() <= 0:
	1216	self.cb_plotpanel.Disable()
	1217	self.bt_append_plot.Disable()
	1218	else:
	1219	self.bt_append_plot.Enable()
	1220	self.cb_plotpanel.Enable()
	1221
	1222	def check_theory_to_freeze(self):
	1223	"""
	1224	Check_theory_to_freeze
	1225	"""
	1226	def enable_freeze(self):
	1227	"""
	1228	enable or disable the freeze button
	1229	"""
	1230	n_t_t = 0
	1231	n_l = 0
	1232	if self.tree_ctrl_theory is not None:
	1233	n_t_t = self.tree_ctrl_theory.GetCount()
	1234	n_l = len(self.list_cb_theory)
	1235	if (n_t_t + n_l > 0):
	1236	self.bt_freeze.Enable()
	1237	else:
	1238	self.bt_freeze.Disable()
	1239
	1240	def enable_selection(self):
	1241	"""
	1242	enable or disable combobo box selection
	1243	"""
	1244	n_t = 0
	1245	n_t_t = 0
	1246	if self.tree_ctrl is not None:
	1247	n_t = self.tree_ctrl.GetCount()
	1248	if self.tree_ctrl_theory is not None:
	1249	n_t_t = self.tree_ctrl_theory.GetCount()
	1250	if n_t + n_t_t > 0 and self.selection_cbox is not None:
	1251	self.selection_cbox.Enable()
	1252	else:
	1253	self.selection_cbox.Disable()
	1254
	1255	def show_data_button(self):
	1256	"""
	1257	show load data and remove data button if
	1258	dataloader on else hide them
	1259	"""
	1260	try:
	1261	gui_style = self.parent.get_style()
	1262	style = gui_style & GUIFRAME.DATALOADER_ON
	1263	if style == GUIFRAME.DATALOADER_ON:
	1264	#self.bt_remove.Show(True)
	1265	self.bt_add.Show(True)
	1266	else:
	1267	#self.bt_remove.Hide()
	1268	self.bt_add.Hide()
	1269	except:
	1270	#self.bt_remove.Hide()
	1271	self.bt_add.Hide()
	1272
	1273
	1274	WIDTH = 400
	1275	HEIGHT = 300
	1276
	1277
	1278	class DataDialog(wx.Dialog):
	1279	"""
	1280	Allow file selection at loading time
	1281	"""
	1282	def __init__(self, data_list, parent=None, text='', args, *kwds):
	1283	wx.Dialog.__init__(self, parent, args, *kwds)
	1284	self.SetTitle("Data Selection")
	1285	self.SetSize((WIDTH, HEIGHT))
	1286	self.list_of_ctrl = []
	1287	if not data_list:
	1288	return
	1289	self._sizer_main = wx.BoxSizer(wx.VERTICAL)
	1290	self._sizer_txt = wx.BoxSizer(wx.VERTICAL)
	1291	self._sizer_button = wx.BoxSizer(wx.HORIZONTAL)
	1292	self.sizer = wx.GridBagSizer(5, 5)
	1293	self._panel = ScrolledPanel(self, style=wx.RAISED_BORDER,
	1294	size=(WIDTH-20, HEIGHT-50))
	1295	self._panel.SetupScrolling()
	1296	self.__do_layout(data_list, text=text)
	1297
	1298	def __do_layout(self, data_list, text=''):
	1299	"""
	1300	layout the dialog
	1301	"""
	1302	if not data_list or len(data_list) <= 1:
	1303	return
	1304	# add text
	1305
	1306	text = "Deleting these file reset some panels.\n"
	1307	text += "Do you want to proceed?\n"
	1308	text_ctrl = wx.StaticText(self, -1, str(text))
	1309	self._sizer_txt.Add(text_ctrl)
	1310	iy = 0
	1311	ix = 0
	1312	# data_count = 0
	1313	for (data_name, in_use, sub_menu) in range(len(data_list)):
	1314	if in_use:
	1315	ctrl_name = wx.StaticBox(self, -1, str(data_name))
	1316	ctrl_in_use = wx.StaticBox(self, -1, " is used by ")
	1317	plug_name = str(sub_menu) + "\n"
	1318	# ctrl_sub_menu = wx.StaticBox(self, -1, plug_name)
	1319	self.sizer.Add(ctrl_name, (iy, ix),
	1320	(1, 1), wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
	1321	ix += 1
	1322	self._sizer_button.Add(ctrl_in_use, 1,
	1323	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
	1324	ix += 1
	1325	self._sizer_button.Add(plug_name, 1,
	1326	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
	1327	iy += 1
	1328	self._panel.SetSizer(self.sizer)
	1329	# add sizer
	1330	self._sizer_button.Add((20, 20), 1, wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
	1331	button_cancel = wx.Button(self, wx.ID_CANCEL, "Cancel")
	1332	self._sizer_button.Add(button_cancel, 0,
	1333	wx.LEFT\|wx.RIGHT\|wx.ADJUST_MINSIZE, 10)
	1334	button_OK = wx.Button(self, wx.ID_OK, "Ok")
	1335	button_OK.SetFocus()
	1336	self._sizer_button.Add(button_OK, 0,
	1337	wx.LEFT\|wx.RIGHT\|wx.ADJUST_MINSIZE, 10)
	1338	static_line = wx.StaticLine(self, -1)
	1339
	1340	self._sizer_txt.Add(self._panel, 1, wx.EXPAND\|wx.LEFT\|wx.RIGHT, 5)
	1341	self._sizer_main.Add(self._sizer_txt, 1, wx.EXPAND\|wx.ALL, 10)
	1342	#self._sizer_main.Add(self._data_text_ctrl, 0,
	1343	# wx.EXPAND\|wx.LEFT\|wx.RIGHT, 10)
	1344	self._sizer_main.Add(static_line, 0, wx.EXPAND, 0)
	1345	self._sizer_main.Add(self._sizer_button, 0, wx.EXPAND\|wx.ALL, 10)
	1346	self.SetSizer(self._sizer_main)
	1347	self.Layout()
	1348
	1349	def get_data(self):
	1350	"""
	1351	return the selected data
	1352	"""
	1353	temp = []
	1354	for item in self.list_of_ctrl:
	1355	cb, data = item
	1356	if cb.GetValue():
	1357	temp.append(data)
	1358	return temp
	1359
	1360	class DataFrame(wx.Frame):
	1361	"""
	1362	Data Frame
	1363	"""
	1364	## Internal name for the AUI manager
	1365	window_name = "Data Panel"
	1366	## Title to appear on top of the window
	1367	window_caption = "Data Panel"
	1368	## Flag to tell the GUI manager that this panel is not
	1369	# tied to any perspective
	1370	ALWAYS_ON = True
	1371
	1372	def __init__(self, parent=None, owner=None, manager=None, size=(300, 800),
	1373	list_of_perspective=[], list=[], args, *kwds):
	1374	kwds['size'] = size
	1375	kwds['id'] = -1
	1376	kwds['title'] = "Loaded Data"
	1377	wx.Frame.__init__(self, parent=parent, args, *kwds)
	1378	self.parent = parent
	1379	self.owner = owner
	1380	self._manager = manager
	1381	self.panel = DataPanel(parent=self,
	1382	manager=manager,
	1383	list_of_perspective=list_of_perspective)
	1384
	1385	def load_data_list(self, list=[]):
	1386	"""
	1387	Fill the list inside its panel
	1388	"""
	1389	self.panel.load_data_list(list=list)
	1390
	1391
	1392	from sas.sasgui.guiframe.dataFitting import Theory1D
	1393	from sas.sasgui.guiframe.data_state import DataState
	1394
	1395
	1396	class State():
	1397	"""
	1398	DataPanel State
	1399	"""
	1400	def __init__(self):
	1401	self.msg = ""
	1402	def __str__(self):
	1403	self.msg = "model mane : model1\n"
	1404	self.msg += "params : \n"
	1405	self.msg += "name value\n"
	1406	return self.msg
	1407
	1408
	1409	def set_data_state(data=None, path=None, theory=None, state=None):
	1410	"""
	1411	Set data state
	1412	"""
	1413	dstate = DataState(data=data)
	1414	dstate.set_path(path=path)
	1415	dstate.set_theory(theory, state)
	1416
	1417	return dstate
	1418
	1419	if __name__ == "__main__":
	1420
	1421	app = wx.App()
	1422	try:
	1423	# list_of_perspective = [('perspective2', False), ('perspective1', True)]
	1424	data_list1 = {}
	1425	# state 1
	1426	data1 = Data2D()
	1427	data1.name = "data2"
	1428	data1.id = 1
	1429	data1.append_empty_process()
	1430	process1 = data1.process[len(data1.process)-1]
	1431	process1.data = "07/01/2010"
	1432	theory1 = Data2D()
	1433	theory1.id = 34
	1434	theory1.name = "theory1"
	1435	path1 = "path1"
	1436	state1 = State()
	1437	data_list1['1'] = set_data_state(data1, path1, theory1, state1)
	1438	# state 2
	1439	data1 = Data2D()
	1440	data1.name = "data2"
	1441	data1.id = 76
	1442	theory1 = Data2D()
	1443	theory1.id = 78
	1444	theory1.name = "CoreShell 07/24/25"
	1445	path1 = "path2"
	1446	# state3
	1447	state1 = State()
	1448	data_list1['2'] = set_data_state(data1, path1, theory1, state1)
	1449	data1 = Data1D()
	1450	data1.id = 3
	1451	data1.name = "data2"
	1452	theory1 = Theory1D()
	1453	theory1.name = "CoreShell"
	1454	theory1.id = 4
	1455	theory1.append_empty_process()
	1456	process1 = theory1.process[len(theory1.process)-1]
	1457	process1.description = "this is my description"
	1458	path1 = "path3"
	1459	data1.append_empty_process()
	1460	process1 = data1.process[len(data1.process)-1]
	1461	process1.data = "07/22/2010"
	1462	data_list1['4'] = set_data_state(data1, path1, theory1, state1)
	1463	# state 4
	1464	temp_data_list = {}
	1465	data1.name = "data5 erasing data2"
	1466	temp_data_list['4'] = set_data_state(data1, path1, theory1, state1)
	1467	# state 5
	1468	data1 = Data2D()
	1469	data1.name = "data3"
	1470	data1.id = 5
	1471	data1.append_empty_process()
	1472	process1 = data1.process[len(data1.process)-1]
	1473	process1.data = "07/01/2010"
	1474	theory1 = Theory1D()
	1475	theory1.name = "Cylinder"
	1476	path1 = "path2"
	1477	state1 = State()
	1478	dstate1 = set_data_state(data1, path1, theory1, state1)
	1479	theory1 = Theory1D()
	1480	theory1.id = 6
	1481	theory1.name = "CoreShell"
	1482	dstate1.set_theory(theory1)
	1483	theory1 = Theory1D()
	1484	theory1.id = 6
	1485	theory1.name = "CoreShell replacing coreshell in data3"
	1486	dstate1.set_theory(theory1)
	1487	data_list1['3'] = dstate1
	1488	#state 6
	1489	data_list1['6'] = set_data_state(None, path1, theory1, state1)
	1490	data_list1['6'] = set_data_state(theory=theory1, state=None)
	1491	theory1 = Theory1D()
	1492	theory1.id = 7
	1493	data_list1['6'] = set_data_state(theory=theory1, state=None)
	1494	data_list1['7'] = set_data_state(theory=theory1, state=None)
	1495	window = DataFrame(list=data_list1)
	1496	window.load_data_list(list=data_list1)
	1497	window.Show(True)
	1498	window.load_data_list(list=temp_data_list)
	1499	except:
	1500	# raise
[9c3d784]	1501	print("error", sys.exc_value)
[959eb01]	1502
	1503	app.MainLoop()

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

SasView

source: sasview/src/sas/sasgui/guiframe/data_panel.py @ f4771596

Download in other formats: