data_panel.py @ 6d7b252b

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

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

SasView

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

Download in other formats: