data_panel.py @ 9c3d784

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

Last change on this file since 9c3d784 was 9c3d784, checked in by andyfaff, 7 years ago
MAINT: using print function
Property mode set to `100644`
File size: 55.1 KB

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

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

SasView

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

Download in other formats: