data_processor.py @ 5fb59f0

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 5fb59f0 was 4550a5a, checked in by Jae Cho <jhjcho@…>, 12 years ago
more fix in grid/output display
Property mode set to `100644`
File size: 66.7 KB

Line
1	"""
2	Implement grid used to store data
3	"""
4	import wx
5	import numpy
6	import math
7	import time
8	import re
9	import os
10	import sys
11	import copy
12	from wx.lib.scrolledpanel import ScrolledPanel
13	import wx.grid as Grid
14	import wx.aui
15	from wx.aui import AuiNotebook as nb
16	import wx.lib.sheet as sheet
17	from sans.guiframe.panel_base import PanelBase
18	from sans.guiframe.utils import format_number
19	from sans.guiframe.events import NewPlotEvent
20	from sans.guiframe.events import StatusEvent
21	from danse.common.plottools import plottables
22	from sans.guiframe.dataFitting import Data1D
23
24	FUNC_DICT = {"sqrt": "math.sqrt",
25	"pow": "math.sqrt"}
26
27	class BatchCell:
28	"""
29	Object describing a cell in the grid.
30
31	"""
32	def __init__(self):
33	self.label = ""
34	self.value = None
35	self.col = -1
36	self.row = -1
37	self.object = []
38
39
40	def parse_string(sentence, list):
41	"""
42	Return a dictionary of column label and index or row selected
43	:param sentence: String to parse
44	:param list: list of columns label
45	"""
46	toks = []
47	p2 = re.compile(r'\d+')
48	p = re.compile(r'[\+\-\*\%\/]')
49	labels = p.split(sentence)
50	col_dict = {}
51	for elt in labels:
52	rang = None
53	temp_arr = []
54	for label in list:
55	label_pos = elt.find(label)
56	separator_pos = label_pos + len(label)
57	if label_pos != -1 and len(elt) >= separator_pos and\
58	elt[separator_pos]== "[":
59	# the label contain , meaning the range selected is not
60	# continuous
61	if elt.count(',') > 0:
62	new_temp = []
63	temp = elt.split(label)
64	for item in temp:
65	range_pos = item.find(":")
66	if range_pos != -1:
67	rang = p2.findall(item)
68	for i in xrange(int(rang[0]), int(rang[1])+1 ):
69	new_temp.append(i)
70	temp_arr += new_temp
71	else:
72	# continuous range
73	temp = elt.split(label)
74	for item in temp:
75	if item.strip() != "":
76	range_pos = item.find(":")
77	if range_pos != -1:
78	rang = p2.findall(item)
79	for i in xrange(int(rang[0]), int(rang[1])+1 ):
80	temp_arr.append(i)
81	col_dict[elt] = (label, temp_arr)
82	return col_dict
83
84
85
86	class SPanel(ScrolledPanel):
87	def __init__(self, parent, args, *kwds):
88	ScrolledPanel.__init__(self, parent , args, *kwds)
89	self.SetupScrolling()
90
91	class GridPage(sheet.CSheet):
92	"""
93	"""
94	def __init__(self, parent, panel=None):
95	"""
96	"""
97	sheet.CSheet.__init__(self, parent)
98
99	self.AdjustScrollbars()
100	#self.SetLabelBackgroundColour('#DBD4D4')
101	self.uid = wx.NewId()
102	self.parent = parent
103	self.panel = panel
104	self.col_names = []
105	self.data_inputs = {}
106	self.data_outputs = {}
107	self.data = None
108	self.details = ""
109	self.file_name = None
110	self._cols = 50
111	self._rows = 3001
112	self.last_selected_row = -1
113	self.last_selected_col = -1
114	self.col_width = 30
115	self.row_height = 20
116	self.max_row_touse = 0
117	self.axis_value = []
118	self.axis_label = ""
119	self.selected_cells = []
120	self.selected_cols = []
121	self.selected_rows = []
122	self.plottable_cells = []
123	self.plottable_flag = False
124	self.SetColMinimalAcceptableWidth(self.col_width)
125	self.SetRowMinimalAcceptableHeight(self.row_height)
126	self.SetNumberRows(self._rows)
127	self.SetNumberCols(self._cols)
128	color = self.parent.GetBackgroundColour()
129	for col in range(self._cols):
130	self.SetCellBackgroundColour(0, col, color)
131	self.AutoSize()
132	self.list_plot_panels = {}
133	self.default_col_width = 75
134	self.EnableEditing(True)
135	if self.GetNumberCols() > 0:
136	self.default_col_width = self.GetColSize(0)
137	self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_left_click)
138	self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.on_right_click)
139	self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.on_selected_cell)
140	self.Bind(wx.grid.EVT_GRID_CMD_CELL_CHANGE, self.on_edit_cell)
141	self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.onContextMenu)
142
143	def on_edit_cell(self, event):
144	"""
145	"""
146	row, col = event.GetRow(), event.GetCol()
147	if row > self.max_row_touse:
148	self.max_row_touse = row
149	if self.data == None:
150	self.data = {}
151	event.Skip()
152
153	def on_selected_cell(self, event):
154	"""
155	Handler catching cell selection
156	"""
157	flag = event.CmdDown() or event.ControlDown()
158	flag_shift = event.ShiftDown()
159	row, col = event.GetRow(), event.GetCol()
160	cell = (row, col)
161	event.Skip()
162	if not flag and not flag_shift:
163	self.selected_cols = []
164	self.selected_rows = []
165	self.selected_cells = []
166	self.axis_label = ""
167	self.axis_value = []
168	self.plottable_list = []
169	self.plottable_cells = []
170	self.plottable_flag = False
171	self.last_selected_col = col
172	self.last_selected_row = row
173	if col >= 0:
174	if flag:
175	label_row = row
176	else:
177	label_row = 0
178	self.axis_label = self.GetCellValue(label_row, col)
179	self.selected_cols.append(col)
180	if flag_shift:
181	if not self.selected_rows:
182	min_r = 1
183	else:
184	min_r = min(self.selected_rows)
185	for row_s in range(min_r, row+1):
186	cel = (row_s, col)
187	if cel not in self.selected_cells:
188	if row > 0:
189	self.selected_cells.append(cel)
190	self.selected_rows.append(row)
191	for row_s in self.selected_rows:
192	cel = (row_s, col)
193	if row_s > row:
194	try:
195	self.selected_cells.remove(cel)
196	except:
197	pass
198	try:
199	self.selected_rows.remove(row_s)
200	except:
201	pass
202	elif flag:
203	if cell not in self.selected_cells:
204	if row > 0 :
205	self.selected_cells.append(cell)
206	self.selected_rows.append(row)
207	else:
208	try:
209	self.selected_cells.remove(cell)
210	except:
211	pass
212	try:
213	self.selected_rows.remove(row)
214	except:
215	pass
216	else:
217	self.selected_cells.append(cell)
218	self.selected_rows.append(row)
219	self.axis_value = []
220	for cell_row, cell_col in self.selected_cells:
221	if cell_row > 0 and cell_row < self.max_row_touse:
222	self.axis_value.append(self.GetCellValue(cell_row, cell_col))
223
224	def on_left_click(self, event):
225	"""
226	Catch the left click on label mouse event
227	"""
228	event.Skip()
229	flag = event.CmdDown() or event.ControlDown()
230
231	col = event.GetCol()
232	row = event.GetRow()
233
234	if not (flag):
235	self.selected_cols = []
236	self.selected_rows = []
237	self.selected_cells = []
238	self.axis_label = ""
239	self.axis_value = []
240	self.plottable_list = []
241	self.plottable_cells = []
242	self.plottable_flag = False
243
244	self.last_selected_col = col
245	self.last_selected_row = row
246	if row != -1 and row not in self.selected_rows:
247	self.selected_rows.append(row)
248
249	if col != -1:
250	for row in range(1, self.GetNumberRows()+ 1):
251	cell = (row, col)
252	if row > 0 and row < self.max_row_touse:
253	if cell not in self.selected_cells:
254	self.selected_cells.append(cell)
255	else:
256	if flag:
257	self.selected_cells.remove(cell)
258	self.selected_cols.append(col)
259	self.axis_value = []
260	for cell_row, cell_col in self.selected_cells:
261	val = self.GetCellValue(cell_row, cell_col)
262	if not val:
263	self.axis_value.append(self.GetCellValue(cell_row, cell_col))
264	self.axis_label = self.GetCellValue(0, col)
265	if not self.axis_label:
266	self.axis_label = " "
267
268	def on_right_click(self, event):
269	"""
270	Catch the right click mouse
271	"""
272
273	col = event.GetCol()
274	row = event.GetRow()
275	# Ignore the index column
276	if col < 0 or row != -1:
277	return
278	self.selected_cols = []
279	self.selected_cols.append(col)
280	# Slicer plot popup menu
281	slicerpop = wx.Menu()
282	col_label_menu = wx.Menu()
283	c_name = self.GetCellValue(0, col)
284	label = "Insert column before %s " % str(c_name)
285	slicerpop.AppendSubMenu(col_label_menu ,
286	'&%s' % str(label), str(label))
287	col_name = [self.GetCellValue(0, c)
288	for c in range(self.GetNumberCols())]
289	row = 0
290	label = self.GetCellValue(row, col)
291	self.insert_col_menu(col_label_menu, label, self)
292
293
294	col_after_menu = wx.Menu()
295	label = "Insert column after %s " % str(c_name)
296	slicerpop.AppendSubMenu(col_after_menu ,
297	'&%s' % str(label), str(label))
298	col_name = [self.GetCellValue(0, c)
299	for c in range(self.GetNumberCols())]
300	self.insert_after_col_menu(col_after_menu, label, self)
301
302
303	id = wx.NewId()
304	hint = 'Remove selected column %s'
305	slicerpop.Append(id, '&Remove Column', hint)
306	wx.EVT_MENU(self, id, self.on_remove_column)
307
308	pos = wx.GetMousePosition()
309	pos = self.ScreenToClient(pos)
310	self.PopupMenu(slicerpop, pos)
311	event.Skip()
312
313	def insert_col_menu(self, menu, label, window):
314	"""
315	"""
316	if self.data is None:
317	return
318	id = wx.NewId()
319	title = "Empty"
320	hint = 'Insert empty column before %s' % str(label)
321	menu.Append(id, title, hint)
322	wx.EVT_MENU(window, id, self.on_insert_column)
323	row = 0
324	col_name = [self.GetCellValue(row, col)
325	for col in range(self.GetNumberCols())]
326	for c_name in self.data.keys():
327	if c_name not in col_name and self.data[c_name]:
328	id = wx.NewId()
329	hint = "Insert %s column before the " % str(c_name)
330	hint += " %s column" % str(label)
331	menu.Append(id, '&%s' % str(c_name), hint)
332	wx.EVT_MENU(window, id, self.on_insert_column)
333
334	def insert_after_col_menu(self, menu, label, window):
335	"""
336	"""
337	if self.data is None:
338	return
339	id = wx.NewId()
340	title = "Empty"
341	hint = 'Insert empty column after %s' % str(label)
342	menu.Append(id, title, hint)
343	wx.EVT_MENU(window, id, self.on_insert_after_column)
344	row = 0
345	col_name = [self.GetCellValue(row, col)
346	for col in range(self.GetNumberCols())]
347	for c_name in self.data.keys():
348	if c_name not in col_name and self.data[c_name]:
349	id = wx.NewId()
350	hint = "Insert %s column after the " % str(c_name)
351	hint += " %s column" % str(label)
352	menu.Append(id, '&%s' % str(c_name), hint)
353	wx.EVT_MENU(window, id, self.on_insert_after_column)
354
355	def on_remove_column(self, event=None):
356	"""
357	"""
358	if self.selected_cols is not None or len(self.selected_cols) > 0:
359	col = self.selected_cols[0]
360	self.remove_column(col=col, numCols=1)
361
362	def remove_column(self, col, numCols=1):
363	"""
364	Remove column to the current grid
365	"""
366	# add data to the grid
367	row = 0
368	col_name = self.GetCellValue(row, col)
369	self.data[col_name] = []
370	for row in range(1, self.GetNumberRows() + 1):
371	if row < self.max_row_touse:
372	value = self.GetCellValue(row, col)
373	self.data[col_name].append(value)
374	for k , value_list in self.data.iteritems():
375	if k != col_name:
376	length = len(value_list)
377	if length < self.max_row_touse:
378	diff = self.max_row_touse - length
379	for i in range(diff):
380	self.data[k].append("")
381	self.DeleteCols(pos=col, numCols=numCols, updateLabels=True)
382
383	def on_insert_column(self, event):
384	"""
385	"""
386	if self.selected_cols is not None or len(self.selected_cols) > 0:
387	col = self.selected_cols[0]
388	# add data to the grid
389	row = 0
390	id = event.GetId()
391	col_name = event.GetEventObject().GetLabelText(id)
392	self.insert_column(col=col, col_name=col_name)
393	if not issubclass(event.GetEventObject().__class__ , wx.Menu):
394	col += 1
395	self.selected_cols[0] += 1
396
397	def on_insert_after_column(self, event):
398	"""
399	Insert the given column after the highlighted column
400	"""
401	if self.selected_cols is not None or len(self.selected_cols) > 0:
402	col = self.selected_cols[0] + 1
403	# add data to the grid
404	row = 0
405	id = event.GetId()
406	col_name = event.GetEventObject().GetLabelText(id)
407	self.insert_column(col=col, col_name=col_name)
408	if not issubclass(event.GetEventObject().__class__ , wx.Menu):
409	self.selected_cols[0] += 1
410
411	def insert_column(self, col, col_name):
412	"""
413	"""
414
415	row = 0
416	self.InsertCols(pos=col, numCols=1, updateLabels=True)
417	if col_name.strip() != "Empty":
418	self.SetCellValue(row, col, str(col_name.strip()))
419	if col_name in self.data.keys():
420	value_list = self.data[col_name]
421	cell_row = 1
422	for value in value_list:
423	label = value#format_number(value, high=True)
424	self.SetCellValue(cell_row, col, str(label))
425	cell_row += 1
426	self.AutoSizeColumn(col, True)
427	width = self.GetColSize(col)
428	if width < self.default_col_width:
429	self.SetColSize(col, self.default_col_width)
430	color = self.parent.GetBackgroundColour()
431	self.SetCellBackgroundColour(0, col, color)
432	self.ForceRefresh()
433
434	def on_set_x_axis(self, event):
435	"""
436	"""
437	self.panel.set_xaxis(x=self.axis_value, label=self.axis_label)
438
439	def on_set_y_axis(self, event):
440	"""
441	"""
442	self.panel.set_yaxis(y=self.axis_value, label=self.axis_label)
443
444	def set_data(self, data_inputs, data_outputs, details, file_name):
445	"""
446	Add data to the grid
447	:param data_inputs: data to use from the context menu of the grid
448	:param data_ouputs: default columns deplayed
449	"""
450	self.file_name = file_name
451	self.details = details
452
453	if data_outputs is None:
454	data_outputs = {}
455	self.data_outputs = data_outputs
456	if data_inputs is None:
457	data_inputs = {}
458	self.data_inputs = data_inputs
459	self.data = {}
460	for item in (self.data_outputs, self.data_inputs):
461	self.data.update(item)
462
463	#if len(self.data) + len(self.data_inputs) +len(self.data_outputs) == 0:
464	# self.EnableEditing(False)
465	#else:
466	# self.EnableEditing(True)
467	if len(self.data_outputs) > 0:
468	self._cols = self.GetNumberCols()
469	self._rows = self.GetNumberRows()
470	self.col_names = self.data_outputs.keys()
471	self.col_names.sort()
472	nbr_user_cols = len(self.col_names)
473	#Add more columns to the grid if necessary
474	if nbr_user_cols > self._cols:
475	new_col_nbr = nbr_user_cols - self._cols + 1
476	self.AppendCols(new_col_nbr, True)
477	#Add more rows to the grid if necessary
478	nbr_user_row = len(self.data_outputs.values()[0])
479	if nbr_user_row > self._rows + 1:
480	new_row_nbr = nbr_user_row - self._rows + 1
481	self.AppendRows(new_row_nbr, True)
482	# add data to the grid
483	wx.CallAfter(self.set_grid_values)
484	self.ForceRefresh()
485
486	def set_grid_values(self):
487	"""
488	Set the values in grids
489	"""
490	# add data to the grid
491	row = 0
492	col = 0
493	cell_col = 0
494	for col_name in self.col_names:
495	# use the first row of the grid to add user defined labels
496	self.SetCellValue(row, col, str(col_name))
497	col += 1
498	cell_row = 1
499	value_list = self.data_outputs[col_name]
500
501	for value in value_list:
502	label = value
503	if issubclass(value.__class__, BatchCell):
504	label = value.label
505	try:
506	float(label)
507	label = str(label)#format_number(label, high=True)
508	except:
509	label = str(label)
510	self.SetCellValue(cell_row, cell_col, label)
511	self.AutoSizeColumn(cell_col, True)
512	width = self.GetColSize(cell_col)
513	if width < self.default_col_width:
514	self.SetColSize(cell_col, self.default_col_width)
515
516	cell_row += 1
517	cell_col += 1
518	if cell_row > self.max_row_touse:
519	self.max_row_touse = cell_row
520
521	def get_grid_view(self):
522	"""
523	Return value contained in the grid
524	"""
525	grid_view = {}
526	for col in xrange(self.GetNumberCols()):
527	label = self.GetCellValue(row=0, col=col)
528	label = label.strip()
529	if label != "":
530	grid_view[label] = []
531	for row in range(1, self.max_row_touse):
532	value = self.GetCellValue(row=row, col=col)
533	if value != "":
534	grid_view[label].append(value)
535	else:
536	grid_view[label].append(None)
537	return grid_view
538
539	def get_nofrows(self):
540	"""
541	Return number of total rows
542	"""
543	return self._rows
544
545	def onContextMenu(self, event):
546	"""
547	Default context menu
548	"""
549	id = wx.NewId()
550	c_menu = wx.Menu()
551	copy_menu = c_menu.Append(id, '&Copy', 'Copy the selected cells')
552	wx.EVT_MENU(self, id, self.on_copy)
553
554	id = wx.NewId()
555	paste_menu = c_menu.Append(id, '&Paste', 'Paste the selected cells')
556	wx.EVT_MENU(self, id, self.on_paste)
557
558	id = wx.NewId()
559	clear_menu = c_menu.Append(id, '&Clear', 'Clear the selected cells')
560	wx.EVT_MENU(self, id, self.on_clear)
561
562	# enable from flag
563	has_selection = False
564	selected_cel = self.selected_cells
565	if len(selected_cel) > 0:
566	_row, _col = selected_cel[0]
567	has_selection = self.IsInSelection(_row, _col)
568	if len(self.selected_cols) > 0:
569	has_selection = True
570	if len(self.selected_rows) > 0:
571	has_selection = True
572	copy_menu.Enable(has_selection)
573	clear_menu.Enable(has_selection)
574	try:
575	# mouse event pos
576	pos_evt = event.GetPosition()
577	self.PopupMenu(c_menu, pos_evt)
578	except:
579	return
580
581	def on_copy(self, event):
582	"""
583	On copy event from the contextmenu
584	"""
585	self.Copy()
586
587	def on_paste(self, event):
588	"""
589	On paste event from the contextmenu
590	"""
591	if self.data == None:
592	self.data = {}
593	if self.file_name == None:
594	self.file_name = 'copied_data'
595	self.Paste()
596
597	def on_clear(self, event):
598	"""
599	Clear the cells selected
600	"""
601	self.Clear()
602
603	class Notebook(nb, PanelBase):
604	"""
605	## Internal name for the AUI manager
606	window_name = "Fit panel"
607	## Title to appear on top of the window
608	"""
609	window_caption = "Notebook "
610
611	def __init__(self, parent, manager=None, data=None, args, *kwargs):
612	"""
613	"""
614	nb.__init__(self, parent, -1,
615	style=wx.aui.AUI_NB_WINDOWLIST_BUTTON\|
616	wx.aui.AUI_BUTTON_DOWN\|
617	wx.aui.AUI_NB_DEFAULT_STYLE\|
618	wx.CLIP_CHILDREN)
619	PanelBase.__init__(self, parent)
620	self.gpage_num = 1
621	self.enable_close_button()
622	self.parent = parent
623	self.manager = manager
624	self.data = data
625	#add empty page
626	self.add_empty_page()
627	self.pageClosedEvent = wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE
628	self.Bind(self.pageClosedEvent, self.on_close_page)
629
630	def add_empty_page(self):
631	"""
632	"""
633	grid = GridPage(self, panel=self.parent)
634	self.AddPage(grid, "", True)
635	pos = self.GetPageIndex(grid)
636	title = "Table" + str(self.gpage_num)
637	self.SetPageText(pos, title)
638	self.SetSelection(pos)
639	self.enable_close_button()
640	self.gpage_num += 1
641	return grid , pos
642
643	def enable_close_button(self):
644	"""
645	display the close button on tab for more than 1 tabs else remove the
646	close button
647	"""
648	if self.GetPageCount() <= 1:
649	style = self.GetWindowStyleFlag()
650	flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
651	if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB == flag:
652	style = style & ~wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
653	self.SetWindowStyle(style)
654	else:
655	style = self.GetWindowStyleFlag()
656	flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
657	if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB != flag:
658	style \|= wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
659	self.SetWindowStyle(style)
660
661	def on_edit_axis(self):
662	"""
663	Return the select cell of a given selected column. Check that all cells
664	are from the same column
665	"""
666	pos = self.GetSelection()
667	grid = self.GetPage(pos)
668	#grid.selected_cols = [grid.GetSelectedRows()]#
669	if len(grid.selected_cols) >= 1:
670	col = grid.selected_cols[0]
671	for c in grid.selected_cols:
672	if c != col:
673	msg = "Edit axis doesn't understand this selection.\n"
674	msg += "Please select only one column"
675	raise ValueError, msg
676	for (cell_row, cell_col) in grid.selected_cells:
677	if cell_col != col:
678	msg = "Cannot use cells from different columns for "
679	msg += "this operation.\n"
680	msg += "Please select elements of the same col.\n"
681	raise ValueError, msg
682
683	# Finally check the highlighted cell if any cells missing
684	self.get_highlighted_row(True)
685	else:
686	msg = "No item selected.\n"
687	msg += "Please select only one column or one cell"
688	raise ValueError, msg
689	return grid.selected_cells
690
691	def get_highlighted_row(self, is_number=True):
692	"""
693	Add highlight rows
694	"""
695	pos = self.GetSelection()
696	grid = self.GetPage(pos)
697	col = grid.selected_cols[0]
698	# Finally check the highlighted cell if any cells missing
699	for row in range(grid.get_nofrows()):
700	if grid.IsInSelection(row, col):
701	cel = (row, col)
702	if row < 1 and not is_number:
703	continue
704	# empty cell
705	if not grid.GetCellValue(row, col).lstrip().rstrip():
706	if cel in grid.selected_cells:
707	grid.selected_cells.remove(cel)
708	continue
709	if is_number:
710	try:
711	float(grid.GetCellValue(row, col))
712	except:
713	# non numeric cell
714	if cel in grid.selected_cells:
715	grid.selected_cells.remove(cel)
716	continue
717	if cel not in grid.selected_cells:
718	grid.selected_cells.append(cel)
719
720	def get_column_labels(self):
721	"""
722	return dictionary of columns labels of the current page
723	"""
724	pos = self.GetSelection()
725	grid = self.GetPage(pos)
726	labels = {}
727	row = 0
728	for col in range(grid.GetNumberCols()):
729	label = grid.GetColLabelValue(int(col))
730	#label = grid.GetCellValue(row, col)
731	if label.strip() != "" :
732	labels[label.strip()] = col
733	return labels
734
735	def create_axis_label(self, cell_list):
736	"""
737	Receive a list of cells and create a string presenting the selected
738	cells.
739	:param cell_list: list of tuple
740
741	"""
742	pos = self.GetSelection()
743	grid = self.GetPage(pos)
744	label = ""
745	col_name = ""
746	def create_label(col_name, row_min=None, row_max=None):
747	"""
748	"""
749	result = " "
750	if row_min is not None or row_max is not None:
751	if row_min is None:
752	result = str(row_max) + "]"
753	elif row_max is None:
754	result = str(col_name) + "[" + str(row_min) + ":"
755	else:
756	result = str(col_name) + "[" + str(row_min) + ":"
757	result += str(row_max) + "]"
758	return str(result)
759
760	if len(cell_list) > 0:
761	if len(cell_list) == 1:
762	row_min, col = cell_list[0]
763	col_name = grid.GetColLabelValue(int(col))
764
765	col_title = grid.GetCellValue(0, col)
766	label = create_label(col_name, row_min+1 , row_min+1)
767	return label, col_title
768	else:
769	temp_list = copy.deepcopy(cell_list)
770	temp_list.sort()
771	length = len(temp_list)
772	row_min, col = temp_list[0]
773	row_max, _ = temp_list[length-1]
774	col_name = grid.GetColLabelValue(int(col))
775	col_title = grid.GetCellValue(0, col)
776
777	index = 0
778	for row in xrange(row_min, row_max + 1):
779	if index > 0 and index < len(temp_list):
780	new_row, _ = temp_list[index]
781	if row != new_row:
782	temp_list.insert(index, (None, None))
783	if index -1 >= 0:
784	new_row, _ = temp_list[index-1]
785	if not new_row == None and new_row != ' ' :
786	label += create_label(col_name, None,
787	int(new_row) +1)
788	else:
789	label += "]"
790	label += ","
791	if index + 1 < len(temp_list):
792	new_row, _ = temp_list[index + 1]
793	if not new_row==None:
794	label += create_label(col_name,
795	int(new_row)+1, None)
796	if row_min != None and row_max != None:
797	if index == 0:
798	label += create_label(col_name,
799	int(row_min)+1, None)
800	elif index == len(temp_list)-1:
801	label += create_label(col_name, None,
802	int(row_max)+1)
803	index += 1
804	# clean up the list
805	label_out = ''
806	for item in label.split(','):
807	if item.split(":")[1] == "]":
808	continue
809	else:
810	label_out += item + ","
811
812	return label_out, col_title
813
814	def on_close_page(self, event):
815	"""
816	close the page
817	"""
818	if self.GetPageCount() == 1:
819	event.Veto()
820	wx.CallAfter(self.enable_close_button)
821
822	def set_data(self, data_inputs, data_outputs, details="", file_name=None):
823	if data_outputs is None or data_outputs == {}:
824	return
825	inputs, outputs = self.get_odered_results(data_inputs, data_outputs)
826	for pos in range(self.GetPageCount()):
827	grid = self.GetPage(pos)
828	if grid.data is None:
829	#Found empty page
830	grid.set_data(data_inputs=inputs,
831	data_outputs=outputs,
832	details=details,
833	file_name=file_name)
834	self.SetSelection(pos)
835	return
836
837	grid, pos = self.add_empty_page()
838	grid.set_data(data_inputs=inputs,
839	data_outputs=outputs,
840	file_name=file_name,
841	details=details)
842
843	def get_odered_results(self, inputs, outputs=None):
844	"""
845	Get ordered the results
846	"""
847	# Let's re-order the data from the keys in 'Data' name.
848	if outputs == None:
849	return
850	try:
851	# For outputs from batch
852	to_be_sort = [str(item.label) for item in outputs['Data']]
853	except:
854	# When inputs are from an external file
855	return inputs, outputs
856	inds = numpy.lexsort((to_be_sort, to_be_sort))
857	for key in outputs.keys():
858	key_list = outputs[key]
859	temp_key = [item for item in key_list]
860	for ind in inds:
861	temp_key[ind] = key_list[inds[ind]]
862	outputs[key] = temp_key
863	for key in inputs.keys():
864	key_list = inputs[key]
865	if len(key_list) == len(inds):
866	temp_key = [item for item in key_list]
867	for ind in inds:
868	temp_key[ind] = key_list[inds[ind]]
869	inputs[key] = temp_key
870	else:
871	inputs[key] = []
872	#print "Different length in %s: Removed from Listing."% key
873
874	return inputs, outputs
875
876	def add_column(self):
877	"""
878	Append a new column to the grid
879	"""
880	pos = self.GetSelection()
881	grid = self.GetPage(pos)
882	grid.AppendCols(1, True)
883
884	def on_remove_column(self):
885	"""
886	Remove the selected column from the grid
887	"""
888	pos = self.GetSelection()
889	grid = self.GetPage(pos)
890	grid.on_remove_column(event=None)
891
892	class GridPanel(SPanel):
893	def __init__(self, parent, data_inputs=None,
894	data_outputs=None, args, *kwds):
895	SPanel.__init__(self, parent , args, *kwds)
896
897	self.vbox = wx.BoxSizer(wx.VERTICAL)
898
899	self.plotting_sizer = wx.FlexGridSizer(3, 7, 10, 5)
900	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
901	self.grid_sizer = wx.BoxSizer(wx.HORIZONTAL)
902	self.vbox.AddMany([(self.grid_sizer, 1, wx.EXPAND, 0),
903	(wx.StaticLine(self, -1), 0, wx.EXPAND, 0),
904	(self.plotting_sizer),
905	(self.button_sizer, 0, wx.BOTTOM, 10)])
906	self.parent = parent
907	self._data_inputs = data_inputs
908	self._data_outputs = data_outputs
909	self.x = []
910	self.y = []
911	self.dy = []
912	self.x_axis_label = None
913	self.y_axis_label = None
914	self.dy_axis_label = None
915	self.x_axis_title = None
916	self.y_axis_title = None
917	self.x_axis_unit = None
918	self.y_axis_unit = None
919	self.view_button = None
920	self.plot_button = None
921	self.notebook = None
922	self.plot_num = 1
923
924	self.layout_grid()
925	self.layout_plotting_area()
926	self.SetSizer(self.vbox)
927
928	def set_xaxis(self, label="", x=None):
929	"""
930	"""
931	if x is None:
932	x = []
933	self.x = x
934	self.x_axis_label.SetValue("%s[:]" % str(label))
935	self.x_axis_title.SetValue(str(label))
936
937	def set_yaxis(self, label="", y=None):
938	"""
939	"""
940	if y is None:
941	y = []
942	self.y = y
943	self.y_axis_label.SetValue("%s[:]" % str(label))
944	self.y_axis_title.SetValue(str(label))
945
946	def set_dyaxis(self, label="", dy=None):
947	"""
948	"""
949	if dy is None:
950	dy = []
951	self.dy = dy
952	self.dy_axis_label.SetValue("%s[:]" % str(label))
953
954	def get_plot_axis(self, col, list):
955	"""
956
957	"""
958	axis = []
959	pos = self.notebook.GetSelection()
960	grid = self.notebook.GetPage(pos)
961	for row in list:
962	label = grid.GetCellValue(0, col)
963	value = grid.GetCellValue(row - 1, col).strip()
964	if value != "":
965	if label.lower().strip() == "data":
966	axis.append(float(row - 1))
967	else:
968	try:
969	axis.append(float(value))
970	except:
971	msg = "Invalid data in row %s column %s" % (str(row),
972	str(col))
973	wx.PostEvent(self.parent.parent,
974	StatusEvent(status=msg, info="error"))
975	return None
976	else:
977	axis.append(None)
978	return axis
979
980	def on_view(self, event):
981	"""
982	Get object represented buy the given cell and plot them.
983	"""
984	pos = self.notebook.GetSelection()
985	grid = self.notebook.GetPage(pos)
986	title = self.notebook.GetPageText(pos)
987	self.notebook.get_highlighted_row(False)
988	if len(grid.selected_cells) == 0:
989	msg = "Highlight a Data or Chi2 column first..."
990	wx.PostEvent(self.parent.parent,
991	StatusEvent(status=msg, info="error"))
992	return
993	elif len(grid.selected_cells) > 20:
994	msg = "Too many data (> 20) to plot..."
995	msg += "\n Please select no more than 20 data."
996	dial = wx.MessageDialog(self, msg, 'Plotting', wx.OK)
997	wx.PostEvent(self.parent.parent,
998	StatusEvent(status=msg, info="error"))
999	return
1000
1001	for cell in grid.selected_cells:
1002	row, col = cell
1003	label_row = 0
1004	label = grid.GetCellValue(label_row, col)
1005	if label in grid.data:
1006	values = grid.data[label]
1007	if row > len(values) or row < 1:
1008	msg = "Invalid cell was chosen."
1009	wx.PostEvent(self.parent.parent, StatusEvent(status=msg,
1010	info="error"))
1011	continue
1012	else:
1013	value = values[row -1]
1014	if issubclass(value.__class__, BatchCell):
1015	if value.object is None or len(value.object) == 0:
1016	msg = "Row %s , " % str(row)
1017	msg += "Column %s is NOT " % str(label)
1018	msg += "the results of fits to view..."
1019	#raise ValueError, msg
1020	wx.PostEvent(self.parent.parent, StatusEvent(status=msg,
1021	info="error"))
1022	return
1023	for new_plot in value.object:
1024	if new_plot is None or \
1025	not issubclass(new_plot.__class__,
1026	plottables.Plottable):
1027	msg = "Row %s , " % str(row)
1028	msg += "Column %s is NOT " % str(label)
1029	msg += "the results of fits to view..."
1030	#raise ValueError, msg
1031	wx.PostEvent(self.parent.parent,
1032	StatusEvent(status=msg, info="error"))
1033	return
1034	#continue
1035	#new_plot.name = title + ': ' + new_plot.title
1036	if issubclass(new_plot.__class__, Data1D):
1037	if label in grid.list_plot_panels.keys():
1038	group_id = grid.list_plot_panels[label]
1039	else:
1040	group_id = str(new_plot.group_id) + str(grid.uid)
1041	grid.list_plot_panels[label] = group_id
1042	if group_id not in new_plot.list_group_id:
1043	new_plot.group_id = group_id
1044	new_plot.list_group_id.append(group_id)
1045	else:
1046	if label.lower() in ["data", "chi2"]:
1047	if len(grid.selected_cells) != 1:
1048	msg = "2D View: Please select one data set"
1049	msg += " at a time for View Fit Results."
1050	wx.PostEvent(self.parent.parent,
1051	StatusEvent(status=msg,
1052	info="error"))
1053	#time.sleep(0.5)
1054	return
1055
1056	wx.PostEvent(self.parent.parent,
1057	NewPlotEvent(plot=new_plot,
1058	group_id=str(new_plot.group_id),
1059	title=title))
1060	msg = "Plotting the View Fit Results completed!"
1061	wx.PostEvent( self.parent.parent,
1062	StatusEvent(status=msg))
1063	else:
1064
1065	msg = "Row %s , " % str(row)
1066	msg += "Column %s is NOT " % str(label)
1067	msg += "the results of fits to view..."
1068	#raise ValueError, msg
1069	wx.PostEvent(self.parent.parent,
1070	StatusEvent(status=msg, info="error"))
1071	#time.sleep(0.5)
1072	return
1073	#continue
1074
1075	def on_plot(self, event):
1076	"""
1077	Evaluate the contains of textcrtl and plot result
1078	"""
1079	pos = self.notebook.GetSelection()
1080	grid = self.notebook.GetPage(pos)
1081	column_names = {}
1082	if grid is not None:
1083	column_names = self.notebook.get_column_labels()
1084	#evaluate x
1085	sentence = self.x_axis_label.GetValue()
1086	try:
1087	if sentence.strip() == "":
1088	msg = "Select column values for x axis"
1089	raise ValueError, msg
1090	except:
1091	msg = "X axis value error."
1092	wx.PostEvent(self.parent.parent,
1093	StatusEvent(status=msg, info="error"))
1094	return
1095	dict = parse_string(sentence, column_names.keys())
1096
1097	try:
1098	sentence = self.get_sentence(dict, sentence, column_names)
1099	x = eval(sentence)
1100	except:
1101	msg = "Need a proper x-range."
1102	wx.PostEvent(self.parent.parent,
1103	StatusEvent(status=msg, info="error"))
1104	return
1105	#evaluate y
1106	sentence = self.y_axis_label.GetValue()
1107	try:
1108	if sentence.strip() == "":
1109	msg = "select value for y axis"
1110	raise ValueError, msg
1111	except:
1112	msg = "Y axis value error."
1113	wx.PostEvent(self.parent.parent,
1114	StatusEvent(status=msg, info="error"))
1115	return
1116	dict = parse_string(sentence, column_names.keys())
1117	try:
1118	sentence = self.get_sentence(dict, sentence, column_names)
1119	y = eval(sentence)
1120	except:
1121	msg = "Need a proper y-range."
1122	wx.PostEvent(self.parent.parent,
1123	StatusEvent(status=msg, info="error"))
1124	return
1125	#evaluate y
1126	sentence = self.dy_axis_label.GetValue()
1127	dy = None
1128	if sentence.strip() != "":
1129	dict = parse_string(sentence, column_names.keys())
1130	sentence = self.get_sentence(dict, sentence, column_names)
1131	try:
1132	dy = eval(sentence)
1133	except:
1134	msg = "Need a proper dy-range."
1135	wx.PostEvent(self.parent.parent,
1136	StatusEvent(status=msg, info="error"))
1137	return
1138	if len(x) != len(y) or (len(x) == 0 or len(y) == 0):
1139	msg = "Need same length for X and Y axis and both greater than 0"
1140	msg += " to plot.\n"
1141	msg += "Got X length = %s, Y length = %s" % (str(len(x)),
1142	str(len(y)))
1143	wx.PostEvent(self.parent.parent,
1144	StatusEvent(status=msg, info="error"))
1145	return
1146	if dy != None and (len(y) != len(dy)):
1147	msg = "Need same length for Y and dY axis and both greater than 0"
1148	msg += " to plot.\n"
1149	msg += "Got Y length = %s, dY length = %s" % (str(len(y)),
1150	str(len(dy)))
1151	wx.PostEvent(self.parent.parent,
1152	StatusEvent(status=msg, info="error"))
1153	return
1154	if dy == None:
1155	dy = numpy.zeros(len(y))
1156	#plotting
1157	new_plot = Data1D(x=x, y=y, dy=dy)
1158	new_plot.id = wx.NewId()
1159	new_plot.is_data = False
1160	new_plot.group_id = wx.NewId()
1161	y_title = self.y_axis_title.GetValue()
1162	x_title = self.x_axis_title.GetValue()
1163	title = "%s_vs_%s" % (y_title,
1164	x_title)
1165	new_plot.xaxis(x_title,
1166	self.x_axis_unit.GetValue())
1167	new_plot.yaxis(y_title,
1168	self.y_axis_unit.GetValue())
1169	try:
1170	title = y_title.strip()
1171
1172	title += "_" + self.notebook.GetPageText(pos)
1173	title += "_" + str(self.plot_num)
1174	self.plot_num += 1
1175	new_plot.name = title
1176	new_plot.xtransform = "x"
1177	new_plot.ytransform = "y"
1178	#new_plot.is_data = False
1179	wx.PostEvent(self.parent.parent,
1180	NewPlotEvent(plot=new_plot,
1181	group_id=str(new_plot.group_id), title =title))
1182	msg = "Plotting completed!"
1183	wx.PostEvent( self.parent.parent,
1184	StatusEvent(status=msg))
1185	self.parent.parent.update_theory(data_id=new_plot.id,
1186	theory=new_plot)
1187	except:
1188	wx.PostEvent(self.parent.parent,
1189	StatusEvent(status=msg, info="error"))
1190
1191	def get_sentence(self, dict, sentence, column_names):
1192	"""
1193	Get sentence from dict
1194	"""
1195	for tok, (col_name, list) in dict.iteritems():
1196	col = column_names[col_name]
1197	axis = self.get_plot_axis(col, list)
1198	if axis == None:
1199	return None
1200	sentence = sentence.replace(tok,
1201	"numpy.array(%s)" % str(axis))
1202	for key, value in FUNC_DICT.iteritems():
1203	sentence = sentence.replace(key.lower(), value)
1204	return sentence
1205
1206	def layout_grid(self):
1207	"""
1208	Draw the area related to the grid
1209	"""
1210	self.notebook = Notebook(parent=self)
1211	self.notebook.set_data(self._data_inputs, self._data_outputs)
1212	self.grid_sizer.Add(self.notebook, 1, wx.EXPAND, 0)
1213
1214	def layout_plotting_area(self):
1215	"""
1216	Draw area containing options to plot
1217	"""
1218	view_description = wx.StaticBox(self, -1, 'Plot Fits/Residuals')
1219	note = "To plot the fits (or residuals), click the 'View Fits' button"
1220	note += "\n after highlighting the Data names (or Chi2 values)."
1221	note_text = wx.StaticText(self, -1, note)
1222	boxsizer1 = wx.StaticBoxSizer(view_description, wx.HORIZONTAL)
1223	self.x_axis_title = wx.TextCtrl(self, -1)
1224	self.y_axis_title = wx.TextCtrl(self, -1)
1225	self.x_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
1226	self.y_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
1227	self.dy_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
1228	self.x_axis_add = wx.Button(self, -1, "Add")
1229	self.x_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
1230	id=self.x_axis_add.GetId())
1231	self.y_axis_add = wx.Button(self, -1, "Add")
1232	self.y_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
1233	id=self.y_axis_add.GetId())
1234	self.dy_axis_add = wx.Button(self, -1, "Add")
1235	self.dy_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
1236	id=self.dy_axis_add.GetId())
1237	self.x_axis_unit = wx.TextCtrl(self, -1)
1238	self.y_axis_unit = wx.TextCtrl(self, -1)
1239	self.view_button = wx.Button(self, -1, "View Fits")
1240	view_tip = "Highlight the data set or the Chi2 column first."
1241	self.view_button.SetToolTipString(view_tip)
1242	wx.EVT_BUTTON(self, self.view_button.GetId(), self.on_view)
1243	self.plot_button = wx.Button(self, -1, "Plot")
1244	plot_tip = "Highlight a column for each axis and \n"
1245	plot_tip += "click the Add buttons first."
1246
1247	self.plot_button.SetToolTipString(plot_tip)
1248	boxsizer1.AddMany([(note_text, 0, wx.LEFT, 10),
1249	(self.view_button, 0, wx.LEFT\|wx.RIGHT, 10)])
1250	self.button_sizer.AddMany([(boxsizer1, 0,
1251	wx.LEFT\|wx.RIGHT\|wx.BOTTOM, 10),
1252	(self.plot_button, 0,
1253	wx.LEFT\|wx.TOP\|wx.BOTTOM\|wx.EXPAND, 12)])
1254
1255	wx.EVT_BUTTON(self, self.plot_button.GetId(), self.on_plot)
1256	self.plotting_sizer.AddMany([
1257	(wx.StaticText(self, -1,
1258	"X-axis Label\nSelection Range"), 1,
1259	wx.TOP\|wx.BOTTOM\|wx.LEFT, 10),
1260	(self.x_axis_label, 1, wx.TOP\|wx.BOTTOM, 10),
1261	(self.x_axis_add, 1, wx.TOP\|wx.BOTTOM\|wx.RIGHT, 10),
1262	(wx.StaticText(self, -1, "X-axis Label"), 1,
1263	wx.TOP\|wx.BOTTOM\|wx.LEFT, 10),
1264	(self.x_axis_title, 1, wx.TOP\|wx.BOTTOM, 10),
1265	(wx.StaticText(self, -1 , "X-axis Unit"), 1,
1266	wx.TOP\|wx.BOTTOM, 10),
1267	(self.x_axis_unit, 1, wx.TOP\|wx.BOTTOM, 10),
1268	(wx.StaticText(self, -1,
1269	"Y-axis Label\nSelection Range"), 1,
1270	wx.BOTTOM\|wx.LEFT, 10),
1271	(self.y_axis_label, wx.BOTTOM, 10),
1272	(self.y_axis_add, 1, wx.BOTTOM\|wx.RIGHT, 10),
1273	(wx.StaticText(self, -1, "Y-axis Label"), 1,
1274	wx.BOTTOM\|wx.LEFT, 10),
1275	(self.y_axis_title, wx.BOTTOM, 10),
1276	(wx.StaticText(self, -1 , "Y-axis Unit"), 1, wx.BOTTOM, 10),
1277	(self.y_axis_unit, 1, wx.BOTTOM, 10),
1278	(wx.StaticText(self, -1,
1279	"dY-Bar (Optional)\nSelection Range"),
1280	1, wx.BOTTOM\|wx.LEFT, 10),
1281	(self.dy_axis_label, wx.BOTTOM, 10),
1282	(self.dy_axis_add, 1, wx.BOTTOM\|wx.RIGHT, 10),
1283	(-1, -1),
1284	(-1, -1),
1285	(-1, -1),
1286	(-1, -1),
1287	(-1, -1),
1288	(-1, -1),
1289	(-1, 1)])
1290
1291	def on_edit_axis(self, event):
1292	"""
1293	Get the selected column on the visible grid and set values for axis
1294	"""
1295	try:
1296	cell_list = self.notebook.on_edit_axis()
1297	label, title = self.create_axis_label(cell_list)
1298	except:
1299	msg = str(sys.exc_value)
1300	wx.PostEvent(self.parent.parent,
1301	StatusEvent(status=msg, info="error"))
1302	return
1303	tcrtl = event.GetEventObject()
1304	if tcrtl == self.x_axis_add:
1305	self.edit_axis_helper(self.x_axis_label, self.x_axis_title,
1306	label, title)
1307	elif tcrtl == self.y_axis_add:
1308	self.edit_axis_helper(self.y_axis_label, self.y_axis_title,
1309	label, title)
1310	elif tcrtl == self.dy_axis_add:
1311	self.edit_axis_helper(self.dy_axis_label, None,
1312	label, None)
1313
1314	def create_axis_label(self, cell_list):
1315	"""
1316	Receive a list of cells and create a string presenting the selected
1317	cells.
1318	:param cell_list: list of tuple
1319
1320	"""
1321	if self.notebook is not None:
1322	return self.notebook.create_axis_label(cell_list)
1323
1324	def edit_axis_helper(self, tcrtl_label, tcrtl_title, label, title):
1325	"""
1326	get controls to modify
1327	"""
1328	if label != None:
1329	tcrtl_label.SetValue(str(label))
1330	if title != None:
1331	tcrtl_title.SetValue(str(title))
1332
1333	def add_column(self):
1334	"""
1335	"""
1336	if self.notebook is not None:
1337	self.notebook.add_column()
1338
1339	def on_remove_column(self):
1340	"""
1341	"""
1342	if self.notebook is not None:
1343	self.notebook.on_remove_column()
1344
1345
1346	class GridFrame(wx.Frame):
1347	def __init__(self, parent=None, data_inputs=None, data_outputs=None, id=-1,
1348	title="Grid Window", size=(800, 500)):
1349	wx.Frame.__init__(self, parent=parent, id=id, title=title, size=size)
1350	self.parent = parent
1351	self.panel = GridPanel(self, data_inputs, data_outputs)
1352	menubar = wx.MenuBar()
1353	self.SetMenuBar(menubar)
1354
1355	self.curr_col = None
1356	self.curr_grid = None
1357	self.curr_col_name = ""
1358	self.file = wx.Menu()
1359	menubar.Append(self.file, "&File")
1360
1361	hint = "Open file containing batch results"
1362	open_menu = self.file.Append(wx.NewId(), 'Open ', hint)
1363	wx.EVT_MENU(self, open_menu.GetId(), self.on_open)
1364
1365	hint = "Open the the current grid into excel"
1366	self.open_excel_menu = self.file.Append(wx.NewId(), 'Open with Excel', hint)
1367	wx.EVT_MENU(self, self.open_excel_menu.GetId(), self.open_with_excel)
1368	self.file.AppendSeparator()
1369	self.save_menu = self.file.Append(wx.NewId(), 'Save As', 'Save into File')
1370	wx.EVT_MENU(self, self.save_menu.GetId(), self.on_save_page)
1371
1372	self.edit = wx.Menu()
1373
1374	add_table_menu = self.edit.Append(-1, 'New Table',
1375	'Add a New Table')
1376	self.edit.AppendSeparator()
1377	wx.EVT_MENU(self, add_table_menu.GetId(), self.add_table)
1378
1379	self.copy_menu = self.edit.Append(-1, 'Copy',
1380	'Copy the selected cells')
1381	wx.EVT_MENU(self, self.copy_menu.GetId(), self.on_copy)
1382	self.paste_menu = self.edit.Append(-1, 'Paste',
1383	'Paste the selected Cells')
1384	wx.EVT_MENU(self, self.paste_menu.GetId(), self.on_paste)
1385	self.clear_menu = self.edit.Append(-1, 'Clear',
1386	'Clear the selected Cells')
1387	wx.EVT_MENU(self, self.clear_menu.GetId(), self.on_clear)
1388
1389	self.edit.AppendSeparator()
1390	hint = "Insert column before the selected column"
1391	self.insert_before_menu = wx.Menu()
1392	self.insertb_sub_menu = self.edit.AppendSubMenu(self.insert_before_menu,
1393	'Insert Before', hint)
1394	hint = "Insert column after the selected column"
1395	self.insert_after_menu = wx.Menu()
1396	self.inserta_sub_menu = self.edit.AppendSubMenu(self.insert_after_menu,
1397	'Insert After', hint)
1398	hint = "Remove the selected column"
1399	self.remove_menu = self.edit.Append(-1, 'Remove Column', hint)
1400	wx.EVT_MENU(self, self.remove_menu.GetId(), self.on_remove_column)
1401
1402	self.Bind(wx.EVT_MENU_OPEN, self.on_menu_open)
1403	menubar.Append(self.edit, "&Edit")
1404	self.Bind(wx.EVT_CLOSE, self.on_close)
1405
1406	def on_copy(self, event):
1407	"""
1408	On Copy
1409	"""
1410	if event != None:
1411	event.Skip()
1412	pos = self.panel.notebook.GetSelection()
1413	grid = self.panel.notebook.GetPage(pos)
1414	grid.Copy()
1415
1416	def on_paste(self, event):
1417	"""
1418	On Paste
1419	"""
1420	if event != None:
1421	event.Skip()
1422	pos = self.panel.notebook.GetSelection()
1423	grid = self.panel.notebook.GetPage(pos)
1424	grid.on_paste(None)
1425
1426	def on_clear(self, event):
1427	"""
1428	On Clear
1429	"""
1430	pos = self.panel.notebook.GetSelection()
1431	grid = self.panel.notebook.GetPage(pos)
1432	grid.Clear()
1433
1434	def GetLabelText(self, id):
1435	"""
1436	Get Label Text
1437	"""
1438	for item in self.insert_before_menu.GetMenuItems():
1439	m_id = item.GetId()
1440	if m_id == id:
1441	return item.GetLabel()
1442
1443	def on_remove_column(self, event):
1444	"""
1445	On remove column
1446	"""
1447	pos = self.panel.notebook.GetSelection()
1448	grid = self.panel.notebook.GetPage(pos)
1449	grid.on_remove_column(event=None)
1450
1451	def on_menu_open(self, event):
1452	"""
1453	On menu open
1454	"""
1455	if self.file == event.GetMenu():
1456	pos = self.panel.notebook.GetSelection()
1457	grid = self.panel.notebook.GetPage(pos)
1458	has_data = (grid.data != None and grid.data != {})
1459	self.open_excel_menu.Enable(has_data)
1460	self.save_menu.Enable(has_data)
1461
1462	if self.edit == event.GetMenu():
1463	#get the selected column
1464	pos = self.panel.notebook.GetSelection()
1465	grid = self.panel.notebook.GetPage(pos)
1466	col_list = grid.GetSelectedCols()
1467	has_selection = False
1468	selected_cel = grid.selected_cells
1469	if len(selected_cel) > 0:
1470	_row, _col = selected_cel[0]
1471	has_selection = grid.IsInSelection(_row, _col)
1472	if len(grid.selected_cols) > 0:
1473	has_selection = True
1474	if len(grid.selected_rows) > 0:
1475	has_selection = True
1476	self.copy_menu.Enable(has_selection)
1477	self.clear_menu.Enable(has_selection)
1478
1479	if len(col_list) > 0:
1480	self.remove_menu.Enable(True)
1481	else:
1482	self.remove_menu.Enable(False)
1483	if len(col_list) == 0 or len(col_list) > 1:
1484	self.insertb_sub_menu.Enable(False)
1485	self.inserta_sub_menu.Enable(False)
1486	label = "Insert Column Before"
1487	self.insertb_sub_menu.SetText(label)
1488	label = "Insert Column After"
1489	self.inserta_sub_menu.SetText(label)
1490	else:
1491	self.insertb_sub_menu.Enable(True)
1492	self.inserta_sub_menu.Enable(True)
1493
1494	col = col_list[0]
1495	col_name = grid.GetCellValue(row=0, col=col)
1496	label = "Insert Column Before " + str(col_name)
1497	self.insertb_sub_menu.SetText(label)
1498	for item in self.insert_before_menu.GetMenuItems():
1499	self.insert_before_menu.DeleteItem(item)
1500	grid.insert_col_menu(menu=self.insert_before_menu,
1501	label=col_name, window=self)
1502	label = "Insert Column After " + str(col_name)
1503	self.inserta_sub_menu.SetText(label)
1504	for item in self.insert_after_menu.GetMenuItems():
1505	self.insert_after_menu.DeleteItem(item)
1506	grid.insert_after_col_menu(menu=self.insert_after_menu,
1507	label=col_name, window=self)
1508	event.Skip()
1509
1510
1511
1512	def on_save_page(self, event):
1513	"""
1514	"""
1515	if self.parent is not None:
1516	pos = self.panel.notebook.GetSelection()
1517	grid = self.panel.notebook.GetPage(pos)
1518	if grid.file_name is None or grid.file_name.strip() == "" or \
1519	grid.data is None or len(grid.data) == 0:
1520	name = self.panel.notebook.GetPageText(pos)
1521	msg = " %s has not data to save" % str(name)
1522	wx.PostEvent(self.parent,
1523	StatusEvent(status=msg, info="error"))
1524
1525	return
1526	reader, ext = os.path.splitext(grid.file_name)
1527	path = None
1528	if self.parent is not None:
1529	location = os.path.dirname(grid.file_name)
1530	dlg = wx.FileDialog(self, "Save Project file",
1531	location, grid.file_name, ext, wx.SAVE)
1532	path = None
1533	if dlg.ShowModal() == wx.ID_OK:
1534	path = dlg.GetPath()
1535	dlg.Destroy()
1536	if path != None:
1537	if self.parent is not None:
1538	data = grid.get_grid_view()
1539	self.parent.write_batch_tofile(data=data,
1540	file_name=path,
1541	details=grid.details)
1542
1543	def on_open(self, event):
1544	"""
1545	Open file containg batch result
1546	"""
1547	if self.parent is not None:
1548	self.parent.on_read_batch_tofile(self)
1549
1550	def open_with_excel(self, event):
1551	"""
1552	open excel and display batch result in Excel
1553	"""
1554	if self.parent is not None:
1555	pos = self.panel.notebook.GetSelection()
1556	grid = self.panel.notebook.GetPage(pos)
1557	data = grid.get_grid_view()
1558	if grid.file_name is None or grid.file_name.strip() == "" or \
1559	grid.data is None or len(grid.data) == 0:
1560	name = self.panel.notebook.GetPageText(pos)
1561	msg = " %s has not data to open on excel" % str(name)
1562	wx.PostEvent(self.parent,
1563	StatusEvent(status=msg, info="error"))
1564
1565	return
1566	self.parent.open_with_externalapp(data=data,
1567	file_name=grid.file_name,
1568	details=grid.details)
1569
1570	def on_close(self, event):
1571	"""
1572	"""
1573	self.Hide()
1574
1575	def on_append_column(self, event):
1576	"""
1577	Append a new column to the grid
1578	"""
1579	self.panel.add_column()
1580
1581	def set_data(self, data_inputs, data_outputs, details="", file_name=None):
1582	"""
1583	Set data
1584	"""
1585	self.panel.notebook.set_data(data_inputs=data_inputs,
1586	file_name=file_name,
1587	details=details,
1588	data_outputs=data_outputs)
1589
1590	def add_table(self, event):
1591	"""
1592	Add a new table
1593	"""
1594	# DO not event.Skip(): it will make 2 pages
1595	self.panel.notebook.add_empty_page()
1596
1597	class BatchOutputFrame(wx.Frame):
1598	"""
1599	Allow to select where the result of batch will be displayed or stored
1600	"""
1601	def __init__(self, parent, data_inputs, data_outputs, file_name="",
1602	details="", args, *kwds):
1603	"""
1604	:param parent: Window instantiating this dialog
1605	:param result: result to display in a grid or export to an external
1606	application.
1607	"""
1608	#kwds['style'] = wx.CAPTION\|wx.SYSTEM_MENU
1609	wx.Frame.__init__(self, parent, args, *kwds)
1610	self.parent = parent
1611	self.panel = wx.Panel(self)
1612	self.file_name = file_name
1613	self.details = details
1614	self.data_inputs = data_inputs
1615	self.data_outputs = data_outputs
1616	self.data = {}
1617	for item in (self.data_outputs, self.data_inputs):
1618	self.data.update(item)
1619	self.flag = 1
1620	self.SetSize((300, 200))
1621	self.local_app_selected = None
1622	self.external_app_selected = None
1623	self.save_to_file = None
1624	self._do_layout()
1625
1626	def _do_layout(self):
1627	"""
1628	Draw the content of the current dialog window
1629	"""
1630	vbox = wx.BoxSizer(wx.VERTICAL)
1631	box_description = wx.StaticBox(self.panel, -1, str("Batch Outputs"))
1632	hint_sizer = wx.StaticBoxSizer(box_description, wx.VERTICAL)
1633	selection_sizer = wx.GridBagSizer(5, 5)
1634	button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1635	text = "Open with %s" % self.parent.application_name
1636	self.local_app_selected = wx.RadioButton(self.panel, -1, text,
1637	style=wx.RB_GROUP)
1638	self.Bind(wx.EVT_RADIOBUTTON, self.onselect,
1639	id=self.local_app_selected.GetId())
1640	text = "Open with Excel"
1641	self.external_app_selected = wx.RadioButton(self.panel, -1, text)
1642	self.Bind(wx.EVT_RADIOBUTTON, self.onselect,
1643	id=self.external_app_selected.GetId())
1644	text = "Save to File"
1645	self.save_to_file = wx.CheckBox(self.panel, -1, text)
1646	self.Bind(wx.EVT_CHECKBOX, self.onselect,
1647	id=self.save_to_file.GetId())
1648	self.local_app_selected.SetValue(True)
1649	self.external_app_selected.SetValue(False)
1650	self.save_to_file.SetValue(False)
1651	button_close = wx.Button(self.panel, -1, "Close")
1652	button_close.Bind(wx.EVT_BUTTON, id=button_close.GetId(),
1653	handler=self.on_close)
1654	button_apply = wx.Button(self.panel, -1, "Apply")
1655	button_apply.Bind(wx.EVT_BUTTON, id=button_apply.GetId(),
1656	handler=self.on_apply)
1657	button_apply.SetFocus()
1658	hint = ""
1659	hint_sizer.Add(wx.StaticText(self.panel, -1, hint))
1660	hint_sizer.Add(selection_sizer)
1661	#draw area containing radio buttons
1662	ix = 0
1663	iy = 0
1664	selection_sizer.Add(self.local_app_selected, (iy, ix),
1665	(1, 1), wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1666	iy += 1
1667	selection_sizer.Add(self.external_app_selected, (iy, ix),
1668	(1, 1), wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1669	iy += 1
1670	selection_sizer.Add(self.save_to_file, (iy, ix),
1671	(1, 1), wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1672	#contruction the sizer contaning button
1673	button_sizer.Add((20, 20), 1, wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
1674
1675	button_sizer.Add(button_close, 0,
1676	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1677	button_sizer.Add(button_apply, 0,
1678	wx.LEFT\|wx.RIGHT\|wx.ADJUST_MINSIZE, 10)
1679	vbox.Add(hint_sizer, 0, wx.EXPAND\|wx.ALL, 10)
1680	vbox.Add(wx.StaticLine(self.panel, -1), 0, wx.EXPAND, 0)
1681	vbox.Add(button_sizer, 0, wx.TOP\|wx.BOTTOM, 10)
1682	self.SetSizer(vbox)
1683
1684	def on_apply(self, event):
1685	"""
1686	Get the user selection and display output to the selected application
1687	"""
1688	if self.flag == 1:
1689	self.parent.open_with_localapp(data_inputs=self.data_inputs,
1690	data_outputs=self.data_outputs)
1691	elif self.flag == 2:
1692	self.parent.open_with_externalapp(data=self.data,
1693	file_name=self.file_name,
1694	details=self.details)
1695	def on_close(self, event):
1696	"""
1697	close the Window
1698	"""
1699	self.Close()
1700
1701	def onselect(self, event=None):
1702	"""
1703	Receive event and display data into third party application
1704	or save data to file.
1705
1706	"""
1707	if self.save_to_file.GetValue():
1708	reader, ext = os.path.splitext(self.file_name)
1709	path = None
1710	location = os.getcwd()
1711	if self.parent is not None:
1712	location = os.path.dirname(self.file_name)
1713	dlg = wx.FileDialog(self, "Save Project file",
1714	location, self.file_name, ext, wx.SAVE)
1715	path = None
1716	if dlg.ShowModal() == wx.ID_OK:
1717	path = dlg.GetPath()
1718	dlg.Destroy()
1719	if path != None:
1720	if self.parent is not None and self.data is not None:
1721	self.parent.write_batch_tofile(data=self.data,
1722	file_name=path,
1723	details=self.details)
1724	if self.local_app_selected.GetValue():
1725	self.flag = 1
1726	else:
1727	self.flag = 2
1728	return self.flag
1729
1730
1731
1732	if __name__ == "__main__":
1733	app = wx.App()
1734
1735	try:
1736	data = {}
1737	j = 0
1738	for i in range(4):
1739	j += 1
1740	data["index"+str(i)] = [i/j, i*j, i, i+j]
1741
1742	data_input = copy.deepcopy(data)
1743	data_input["index5"] = [10, 20, 40, 50]
1744	frame = GridFrame(data_outputs=data, data_inputs=data_input)
1745	frame.Show(True)
1746	except:
1747	print sys.exc_value
1748
1749	app.MainLoop()

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

SasView

source: sasview/sansguiframe/src/sans/guiframe/data_processor.py @ 5fb59f0

Download in other formats: