data_processor.py @ b4293d2

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 b4293d2 was 98fdccd, checked in by Jae Cho <jhjcho@…>, 13 years ago
ordered grids by data_name
Property mode set to `100644`
File size: 53.3 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 = 51
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._cols)
127	self.SetNumberCols(self._rows)
128	self.AutoSize()
129	self.list_plot_panels = {}
130	self.default_col_width = 75
131	self.EnableEditing(False)
132	if self.GetNumberCols() > 0:
133	self.default_col_width = self.GetColSize(0)
134	self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_left_click)
135	self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.on_right_click)
136	self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.on_selected_cell)
137	self.Bind(wx.grid.EVT_GRID_CMD_CELL_CHANGE, self.on_edit_cell)
138
139
140	def on_edit_cell(self, event):
141	"""
142	"""
143	row, col = event.GetRow(), event.GetCol()
144	if row > self.max_row_touse:
145	self.max_row_touse = row
146	event.Skip()
147
148	def on_selected_cell(self, event):
149	"""
150	Handler catching cell selection
151	"""
152	flag = event.CmdDown() or event.ControlDown()
153	row, col = event.GetRow(), event.GetCol()
154	cell = (row, col)
155	event.Skip()
156	if not flag:
157	self.selected_cols = []
158	self.selected_rows = []
159	self.selected_cells = []
160	self.axis_label = ""
161	self.axis_value = []
162	self.plottable_list = []
163	self.plottable_cells = []
164	self.plottable_flag = False
165	self.last_selected_col = col
166	self.last_selected_row = row
167	if col >= 0:
168	label_row = 0
169	self.axis_label = self.GetCellValue(label_row, col)
170	self.selected_cols.append(col)
171	if cell not in self.selected_cells:
172	if row > 0:
173	self.selected_cells.append(cell)
174	self.selected_rows.append(row)
175	else:
176	if flag:
177	self.selected_cells.remove(cell)
178	self.axis_value = []
179	for cell_row, cell_col in self.selected_cells:
180	if cell_row > 0 and cell_row < self.max_row_touse:
181	self.axis_value.append(self.GetCellValue(cell_row, cell_col))
182
183
184	def on_left_click(self, event):
185	"""
186	Catch the left click on label mouse event
187	"""
188	event.Skip()
189	flag = event.CmdDown() or event.ControlDown()
190	col = event.GetCol()
191	row = event.GetRow()
192	if not flag:
193	self.selected_cols = []
194	self.selected_rows = []
195	self.selected_cells = []
196	self.axis_label = ""
197	self.axis_value = []
198	self.plottable_list = []
199	self.plottable_cells = []
200	self.plottable_flag = False
201
202	self.last_selected_col = col
203	self.last_selected_row = row
204	if row != -1 and row not in self.selected_rows:
205	self.selected_rows.append(row)
206
207	if col != -1:
208	for row in range(1, self.GetNumberRows()+ 1):
209	cell = (row, col)
210	if row > 0 and row < self.max_row_touse:
211	if cell not in self.selected_cells:
212	self.selected_cells.append(cell)
213	else:
214	if flag:
215	self.selected_cells.remove(cell)
216	self.selected_cols.append(col)
217	self.axis_value = []
218	for cell_row, cell_col in self.selected_cells:
219	self.axis_value.append(self.GetCellValue(cell_row, cell_col))
220	self.axis_label = self.GetCellValue(0, col)
221
222	def on_right_click(self, event):
223	"""
224	Catch the right click mouse
225	"""
226
227	col = event.GetCol()
228	self.selected_cols = []
229	self.selected_cols.append(col)
230	# Slicer plot popup menu
231	slicerpop = wx.Menu()
232	col_label_menu = wx.Menu()
233	c_name = self.GetCellValue(0, col)
234	label = "Insert column before %s " % str(c_name)
235	slicerpop.AppendSubMenu(col_label_menu ,
236	'&%s' % str(label), str(label))
237	col_name = [self.GetCellValue(0, c)
238	for c in range(self.GetNumberCols())]
239	row = 0
240	label = self.GetCellValue(row, col)
241	self.insert_col_menu(col_label_menu, label, self)
242
243
244	col_after_menu = wx.Menu()
245	label = "Insert column after %s " % str(c_name)
246	slicerpop.AppendSubMenu(col_after_menu ,
247	'&%s' % str(label), str(label))
248	col_name = [self.GetCellValue(0, c)
249	for c in range(self.GetNumberCols())]
250	self.insert_after_col_menu(col_after_menu, label, self)
251
252
253	id = wx.NewId()
254	hint = 'Remove selected column %s'
255	slicerpop.Append(id, '&Remove Column', hint)
256	wx.EVT_MENU(self, id, self.on_remove_column)
257
258	pos = wx.GetMousePosition()
259	pos = self.ScreenToClient(pos)
260	self.PopupMenu(slicerpop, pos)
261	event.Skip()
262
263	def insert_col_menu(self, menu, label, window):
264	"""
265	"""
266	if self.data is None:
267	return
268	id = wx.NewId()
269	title = "Empty"
270	hint = 'Insert empty column before %s' % str(label)
271	menu.Append(id, title, hint)
272	wx.EVT_MENU(window, id, self.on_insert_column)
273	row = 0
274	col_name = [self.GetCellValue(row, col)
275	for col in range(self.GetNumberCols())]
276	for c_name in self.data.keys():
277	if c_name not in col_name:
278	id = wx.NewId()
279	hint = "Insert %s column before the " % str(c_name)
280	hint += " %s column" % str(label)
281	menu.Append(id, '&%s' % str(c_name), hint)
282	wx.EVT_MENU(window, id, self.on_insert_column)
283
284	def insert_after_col_menu(self, menu, label, window):
285	"""
286	"""
287	if self.data is None:
288	return
289	id = wx.NewId()
290	title = "Empty"
291	hint = 'Insert empty column after %s' % str(label)
292	menu.Append(id, title, hint)
293	wx.EVT_MENU(window, id, self.on_insert_after_column)
294	row = 0
295	col_name = [self.GetCellValue(row, col)
296	for col in range(self.GetNumberCols())]
297	for c_name in self.data.keys():
298	if c_name not in col_name:
299	id = wx.NewId()
300	hint = "Insert %s column after the " % str(c_name)
301	hint += " %s column" % str(label)
302	menu.Append(id, '&%s' % str(c_name), hint)
303	wx.EVT_MENU(window, id, self.on_insert_after_column)
304
305	def on_remove_column(self, event=None):
306	"""
307	"""
308	if self.selected_cols is not None or len(self.selected_cols) > 0:
309	col = self.selected_cols[0]
310	self.remove_column(col=col, numCols=1)
311
312	def remove_column(self, col, numCols=1):
313	"""
314	Remove column to the current grid
315	"""
316	# add data to the grid
317	row = 0
318	col_name = self.GetCellValue(row, col)
319	self.data[col_name] = []
320	for row in range(1, self.GetNumberRows() + 1):
321	if row < self.max_row_touse:
322	value = self.GetCellValue(row, col)
323	self.data[col_name].append(value)
324	for k , value_list in self.data.iteritems():
325	if k != col_name:
326	length = len(value_list)
327	if length < self.max_row_touse:
328	diff = self.max_row_touse - length
329	for i in range(diff):
330	self.data[k].append("")
331	self.DeleteCols(pos=col, numCols=numCols, updateLabels=True)
332
333	def on_insert_column(self, event):
334	"""
335	"""
336	if self.selected_cols is not None or len(self.selected_cols) > 0:
337	col = self.selected_cols[0]
338	# add data to the grid
339	row = 0
340	id = event.GetId()
341	col_name = event.GetEventObject().GetLabelText(id)
342	self.insert_column(col=col, col_name=col_name)
343	if not issubclass(event.GetEventObject().__class__ , wx.Menu):
344	col += 1
345	self.selected_cols[0] += 1
346
347	def on_insert_after_column(self, event):
348	"""
349	Insert the given column after the highlighted column
350	"""
351	if self.selected_cols is not None or len(self.selected_cols) > 0:
352	col = self.selected_cols[0] + 1
353	# add data to the grid
354	row = 0
355	id = event.GetId()
356	col_name = event.GetEventObject().GetLabelText(id)
357	self.insert_column(col=col, col_name=col_name)
358	if not issubclass(event.GetEventObject().__class__ , wx.Menu):
359	self.selected_cols[0] += 1
360
361	def insert_column(self, col, col_name):
362	"""
363	"""
364
365	row = 0
366	self.InsertCols(pos=col, numCols=1, updateLabels=True)
367	if col_name.strip() != "Empty":
368	self.SetCellValue(row, col, str(col_name.strip()))
369	if col_name in self.data.keys():
370	value_list = self.data[col_name]
371	cell_row = 1
372	for value in value_list:
373	label = value#format_number(value, high=True)
374	self.SetCellValue(cell_row, col, str(label))
375	cell_row += 1
376	self.AutoSizeColumn(col, True)
377	width = self.GetColSize(col)
378	if width < self.default_col_width:
379	self.SetColSize(col, self.default_col_width)
380	self.ForceRefresh()
381
382	def on_set_x_axis(self, event):
383	"""
384	"""
385	self.panel.set_xaxis(x=self.axis_value, label=self.axis_label)
386
387	def on_set_y_axis(self, event):
388	"""
389	"""
390	self.panel.set_yaxis(y=self.axis_value, label=self.axis_label)
391
392	def set_data(self, data_inputs, data_outputs, details, file_name):
393	"""
394	Add data to the grid
395	:param data_inputs: data to use from the context menu of the grid
396	:param data_ouputs: default columns deplayed
397	"""
398	self.file_name = file_name
399	self.details = details
400
401	if data_outputs is None:
402	data_outputs = {}
403	self.data_outputs = data_outputs
404	if data_inputs is None:
405	data_inputs = {}
406	self.data_inputs = data_inputs
407	self.data = {}
408	for item in (self.data_outputs, self.data_inputs):
409	self.data.update(item)
410
411	if len(self.data) + len(self.data_inputs) +len(self.data_outputs) == 0:
412	self.EnableEditing(False)
413	else:
414	self.EnableEditing(True)
415	if len(self.data_outputs) > 0:
416	self._cols = self.GetNumberCols()
417	self._rows = self.GetNumberRows()
418	self.col_names = self.data_outputs.keys()
419	self.col_names.sort()
420	nbr_user_cols = len(self.col_names)
421	#Add more columns to the grid if necessary
422	if nbr_user_cols > self._cols:
423	new_col_nbr = nbr_user_cols - self._cols
424	self.AppendCols(new_col_nbr, True)
425	#Add more rows to the grid if necessary
426	nbr_user_row = len(self.data_outputs.values())
427	if nbr_user_row > self._rows + 1:
428	new_row_nbr = nbr_user_row - self._rows
429	self.AppendRows(new_row_nbr, True)
430	# add data to the grid
431	row = 0
432	col = 0
433	cell_col = 0
434	for col_name in self.col_names:
435	# use the first row of the grid to add user defined labels
436	self.SetCellValue(row, col, str(col_name))
437	col += 1
438	cell_row = 1
439	value_list = self.data_outputs[col_name]
440
441	for value in value_list:
442	label = value
443	if issubclass(value.__class__, BatchCell):
444	label = value.label
445	try:
446	float(label)
447	label = str(label)#format_number(label, high=True)
448	except:
449	label = str(label)
450	self.SetCellValue(cell_row, cell_col, label)
451	self.AutoSizeColumn(cell_col, True)
452	width = self.GetColSize(cell_col)
453	if width < self.default_col_width:
454	self.SetColSize(cell_col, self.default_col_width)
455
456	cell_row += 1
457	cell_col += 1
458	if cell_row > self.max_row_touse:
459	self.max_row_touse = cell_row
460	self.ForceRefresh()
461
462	def get_grid_view(self):
463	"""
464	Return value contained in the grid
465	"""
466	grid_view = {}
467	for col in xrange(self.GetNumberCols()):
468	label = self.GetCellValue(row=0, col=col)
469	label = label.strip()
470	if label != "":
471	grid_view[label] = []
472	for row in range(1, self.max_row_touse):
473	value = self.GetCellValue(row=row, col=col)
474	if value != "":
475	grid_view[label].append(value)
476	else:
477	grid_view[label].append(None)
478	return grid_view
479
480	class Notebook(nb, PanelBase):
481	"""
482	## Internal name for the AUI manager
483	window_name = "Fit panel"
484	## Title to appear on top of the window
485	"""
486	window_caption = "Notebook "
487
488	def __init__(self, parent, manager=None, data=None, args, *kwargs):
489	"""
490	"""
491	nb.__init__(self, parent, -1,
492	style=wx.aui.AUI_NB_WINDOWLIST_BUTTON\|
493	wx.aui.AUI_BUTTON_DOWN\|
494	wx.aui.AUI_NB_DEFAULT_STYLE\|
495	wx.CLIP_CHILDREN)
496	PanelBase.__init__(self, parent)
497	self.enable_close_button()
498	self.parent = parent
499	self.manager = manager
500	self.data = data
501	#add empty page
502	self.add_empty_page()
503
504	self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.on_close_page)
505
506	def add_empty_page(self):
507	"""
508	"""
509	grid = GridPage(self, panel=self.parent)
510	self.AddPage(grid, "", True)
511	pos = self.GetPageIndex(grid)
512	title = "Batch" + str(self.GetPageCount())
513	self.SetPageText(pos, title)
514	self.SetSelection(pos)
515	return grid , pos
516
517	def enable_close_button(self):
518	"""
519	display the close button on tab for more than 1 tabs else remove the
520	close button
521	"""
522	if self.GetPageCount() <= 1:
523	style = self.GetWindowStyleFlag()
524	flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
525	if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB == flag:
526	style = style & ~wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
527	self.SetWindowStyle(style)
528	else:
529	style = self.GetWindowStyleFlag()
530	flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
531	if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB != flag:
532	style \|= wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
533	self.SetWindowStyle(style)
534
535	def on_edit_axis(self):
536	"""
537	Return the select cell of a given selected column. Check that all cells
538	are from the same column
539	"""
540	pos = self.GetSelection()
541	grid = self.GetPage(pos)
542	if len(grid.selected_cols) >= 1:
543	col = grid.selected_cols[0]
544	for c in grid.selected_cols:
545	if c != col:
546	msg = "Edit axis doesn't understand this selection.\n"
547	msg += "Please select only one column"
548	raise ValueError, msg
549	for (cell_row, cell_col) in grid.selected_cells:
550	if cell_col != col:
551	msg = "Cannot use cells from different columns for "
552	msg += "this operation.\n"
553	msg += "Please select elements of the same col.\n"
554	raise ValueError, msg
555	else:
556	msg = "No item selected.\n"
557	msg += "Please select only one column or one cell"
558	raise ValueError, msg
559
560	return grid.selected_cells
561
562
563	def get_column_labels(self):
564	"""
565	return dictionary of columns labels of the current page
566	"""
567	pos = self.GetSelection()
568	grid = self.GetPage(pos)
569	labels = {}
570	row = 0
571	for col in range(grid.GetNumberCols()):
572	label = grid.GetCellValue(row, col)
573	if label.strip() != "" :
574	labels[label.strip()] = col
575	return labels
576
577	def create_axis_label(self, cell_list):
578	"""
579	Receive a list of cells and create a string presenting the selected
580	cells.
581	:param cell_list: list of tuple
582
583	"""
584	pos = self.GetSelection()
585	grid = self.GetPage(pos)
586	label = ""
587	col_name = ""
588	def create_label(col_name, row_min=None, row_max=None):
589	"""
590	"""
591	result = ""
592	if row_min is not None or row_max is not None:
593	if row_min is None:
594	result = str(row_max) + "]"
595	elif row_max is None:
596	result = str(col_name) + "[" + str(row_min) + ":"
597	else:
598	result = str(col_name) + "[" + str(row_min) + ":"
599	result += str(row_max) + "]"
600	return str(result)
601
602	if len(cell_list) > 0:
603	if len(cell_list) == 1:
604	row_min, col = cell_list[0]
605	col_name = grid.GetCellValue(0, col)
606	label = create_label(col_name, row_min+1 , row_min+1)
607	return label, col_name
608	else:
609	temp_list = copy.deepcopy(cell_list)
610	temp_list.sort()
611	length = len(temp_list)
612	row_min, col = temp_list[0]
613	row_max, _ = temp_list[length-1]
614	col_name = grid.GetCellValue(0, col)
615	index = 0
616	for row in xrange(row_min, row_max +1):
617	if index > 0 and index < len(temp_list):
618	new_row, _ = temp_list[index]
619	if row != new_row:
620	temp_list.insert(index, (None, None))
621	if index -1 >= 0:
622	new_row, _ = temp_list[index-1]
623	label += create_label(col_name, None, new_row +1)
624	label += ","
625	if index + 1 < len(temp_list):
626	new_row, _ = temp_list[index + 1]
627	label += create_label(col_name, new_row+1, None)
628	if index == 0:
629	label += create_label(col_name, row_min+1, None)
630	elif index == len(temp_list)-1:
631	label += create_label(col_name, None, row_max+1)
632	index += 1
633	return label, col_name
634
635	def on_close_page(self, event):
636	"""
637	close the page
638	"""
639	if self.GetPageCount() == 1:
640	event.Veto()
641	self.enable_close_button()
642
643	def set_data(self, data_inputs, data_outputs, details="", file_name=None):
644	if data_outputs is None or data_outputs == {}:
645	return
646	inputs, outputs = self.get_odered_results(data_inputs, data_outputs)
647	for pos in range(self.GetPageCount()):
648	grid = self.GetPage(pos)
649	if grid.data is None:
650	#Found empty page
651	grid.set_data(data_inputs=inputs,
652	data_outputs=outputs,
653	details=details,
654	file_name=file_name)
655	self.SetSelection(pos)
656	return
657
658	grid, pos = self.add_empty_page()
659	grid.set_data(data_inputs=inputs,
660	data_outputs=outputs,
661	file_name=file_name,
662	details=details)
663
664	def get_odered_results(self, inputs, outputs=None):
665	"""
666	Get ordered the results
667	"""
668	# Let's re-order the data from the keys in 'Data' name.
669	if outputs == None:
670	return
671	to_be_sort = [str(item.label) for item in outputs['Data']]
672	inds = numpy.lexsort((to_be_sort, to_be_sort))
673	for key in outputs.keys():
674	key_list = outputs[key]
675	temp_key = [item for item in key_list]
676	for ind in inds:
677	temp_key[ind] = key_list[inds[ind]]
678	outputs[key] = temp_key
679	for key in inputs.keys():
680	key_list = inputs[key]
681	if len(key_list) > 0:
682	temp_key = [item for item in key_list]
683	for ind in inds:
684	temp_key[ind] = key_list[inds[ind]]
685	inputs[key] = temp_key
686	return inputs, outputs
687
688	def add_column(self):
689	"""
690	Append a new column to the grid
691	"""
692	pos = self.GetSelection()
693	grid = self.GetPage(pos)
694	grid.AppendCols(1, True)
695
696	class GridPanel(SPanel):
697	def __init__(self, parent, data_inputs=None,
698	data_outputs=None, args, *kwds):
699	SPanel.__init__(self, parent , args, *kwds)
700
701	self.vbox = wx.BoxSizer(wx.VERTICAL)
702
703	self.plotting_sizer = wx.FlexGridSizer(3, 7, 10, 5)
704	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
705	self.grid_sizer = wx.BoxSizer(wx.HORIZONTAL)
706	self.vbox.AddMany([(self.grid_sizer, 1, wx.EXPAND, 0),
707	(wx.StaticLine(self, -1), 0, wx.EXPAND, 0),
708	(self.plotting_sizer),
709	(self.button_sizer)])
710	self.parent = parent
711	self._data_inputs = data_inputs
712	self._data_outputs = data_outputs
713	self.x = []
714	self.y = []
715	self.x_axis_label = None
716	self.y_axis_label = None
717	self.x_axis_title = None
718	self.y_axis_title = None
719	self.x_axis_unit = None
720	self.y_axis_unit = None
721	self.view_button = None
722	self.plot_button = None
723	self.notebook = None
724
725	self.layout_grid()
726	self.layout_plotting_area()
727	self.SetSizer(self.vbox)
728
729	def set_xaxis(self, label="", x=None):
730	"""
731	"""
732	if x is None:
733	x = []
734	self.x = x
735	self.x_axis_label.SetValue("%s[:]" % str(label))
736	self.x_axis_title.SetValue(str(label))
737
738	def set_yaxis(self, label="", y=None):
739	"""
740	"""
741	if y is None:
742	y = []
743	self.y = y
744	self.y_axis_label.SetValue("%s[:]" % str(label))
745	self.y_axis_title.SetValue(str(label))
746
747	def get_plot_axis(self, col, list):
748	"""
749
750	"""
751	axis = []
752	pos = self.notebook.GetSelection()
753	grid = self.notebook.GetPage(pos)
754	for row in list:
755	label = grid.GetCellValue(0, col)
756	value = grid.GetCellValue(row - 1, col).strip()
757	if value != "":
758	if label.lower().strip() == "data":
759	axis.append(float(row - 1))
760	else:
761	try:
762	axis.append(float(value))
763	except:
764	msg = "Invalid data in row %s column %s" % (str(row),
765	str(col))
766	wx.PostEvent(self.parent.parent,
767	StatusEvent(status=msg, info="error"))
768	else:
769	axis.append(None)
770	return axis
771
772	def on_save_column(self, parent):
773	"""
774	"""
775	pos = self.notebook.GetSelection()
776	grid = self.notebook.GetPage(pos)
777	if parent is not None and self.data is not None:
778	parent.write_batch_tofile(data=grid.data,
779	file_name=path,
780	details=self.details)
781
782	def on_view(self, event):
783	"""
784	Get object represented buy the given cell and plot them.
785	"""
786	pos = self.notebook.GetSelection()
787	grid = self.notebook.GetPage(pos)
788	title = self.notebook.GetPageText(pos)
789	if len(grid.selected_cells) == 0:
790	msg = "Highlight a Data or Chi2 column first..."
791	wx.PostEvent(self.parent.parent,
792	StatusEvent(status=msg, info="error"))
793	return
794	for cell in grid.selected_cells:
795	row, col = cell
796	label_row = 0
797	label = grid.GetCellValue(label_row, col)
798	if label in grid.data:
799	values = grid.data[label]
800	if row > len(values) or row < 1:
801	msg = "Invalid cell was chosen."
802	wx.PostEvent(self.parent.parent, StatusEvent(status=msg,
803	info="error"))
804	time.sleep(0.5)
805	continue
806	else:
807	value = values[row -1]
808	if issubclass(value.__class__, BatchCell):
809	if value.object is None or len(value.object) == 0:
810	msg = "Row %s , " % str(row)
811	msg += "Column %s is NOT " % str(label)
812	msg += "the results of fits to view..."
813	#raise ValueError, msg
814	wx.PostEvent(self.parent.parent, StatusEvent(status=msg,
815	info="error"))
816	return
817	for new_plot in value.object:
818	if new_plot is None or \
819	not issubclass(new_plot.__class__,
820	plottables.Plottable):
821	msg = "Row %s , " % str(row)
822	msg += "Column %s is NOT " % str(label)
823	msg += "the results of fits to view..."
824	#raise ValueError, msg
825	wx.PostEvent(self.parent.parent,
826	StatusEvent(status=msg, info="error"))
827	time.sleep(0.5)
828	continue
829	#new_plot.name = title + ': ' + new_plot.title
830	if issubclass(new_plot.__class__, Data1D):
831	if label in grid.list_plot_panels.keys():
832	group_id = grid.list_plot_panels[label]
833	else:
834	group_id = str(new_plot.group_id) + str(grid.uid)
835	grid.list_plot_panels[label] = group_id
836	if group_id not in new_plot.list_group_id:
837	new_plot.group_id = group_id
838	new_plot.list_group_id.append(group_id)
839	else:
840	if label.lower() in ["data", "chi2"]:
841	if len(grid.selected_cells) != 1:
842	msg = "2D View: Please select one data set"
843	msg += " at a time for View Results."
844	wx.PostEvent(self.parent.parent,
845	StatusEvent(status=msg,
846	info="error"))
847	time.sleep(0.5)
848	continue
849	"""
850	wx.PostEvent(self.parent.parent,
851	NewPlotEvent(action="clear",
852	group_id=str(group_id),
853	title=title))
854	"""
855	wx.PostEvent(self.parent.parent,
856	NewPlotEvent(plot=new_plot,
857	group_id=str(new_plot.group_id),
858	title=title))
859	msg = "Plotting the View Results completed!"
860	wx.PostEvent( self.parent.parent,
861	StatusEvent(status=msg))
862	else:
863
864	msg = "Row %s , " % str(row)
865	msg += "Column %s is NOT " % str(label)
866	msg += "the results of fits to view..."
867	#raise ValueError, msg
868	wx.PostEvent(self.parent.parent,
869	StatusEvent(status=msg, info="error"))
870	time.sleep(0.5)
871	continue
872
873
874
875
876	def on_plot(self, event):
877	"""
878	Evaluate the contains of textcrtl and plot result
879	"""
880	pos = self.notebook.GetSelection()
881	grid = self.notebook.GetPage(pos)
882	column_names = {}
883	if grid is not None:
884	column_names = self.notebook.get_column_labels()
885	#evaluate x
886	sentence = self.x_axis_label.GetValue()
887	try:
888	if sentence.strip() == "":
889	msg = "Select column values for x axis"
890	raise ValueError, msg
891	except:
892	wx.PostEvent(self.parent.parent,
893	StatusEvent(status=msg, info="error"))
894	return
895
896	dict = parse_string(sentence, column_names.keys())
897	for tok, (col_name, list) in dict.iteritems():
898	col = column_names[col_name]
899	xaxis = self.get_plot_axis(col, list)
900	sentence = sentence.replace(tok,
901	"numpy.array(%s)" % str(xaxis))
902	for key, value in FUNC_DICT.iteritems():
903	sentence = sentence.replace(key.lower(), value)
904	x = eval(sentence)
905	#evaluate y
906	sentence = self.y_axis_label.GetValue()
907	if sentence.strip() == "":
908	msg = "select value for y axis"
909	raise ValueError, msg
910	dict = parse_string(sentence, column_names.keys())
911	for tok, (col_name, list) in dict.iteritems():
912	col = column_names[col_name]
913	yaxis = self.get_plot_axis(col, list)
914	sentence = sentence.replace(tok,
915	"numpy.array(%s)" % str(yaxis))
916	for key, value in FUNC_DICT.iteritems():
917	sentence = sentence.replace(key, value)
918	y = eval(sentence)
919	if len(x) != len(y) and (len(x) == 0 or len(y) == 0):
920	msg = "Need same length for X and Y axis and both greater than 0"
921	msg += " to plot.\n"
922	msg += "Got X length = %s, Y length = %s" % (str(len(x)),
923	str(len(y)))
924	wx.PostEvent(self.parent.parent,
925	StatusEvent(status=msg, info="error"))
926	return
927
928	#plotting
929	new_plot = Data1D(x=x, y=y)
930	new_plot.id = wx.NewId()
931	new_plot.group_id = wx.NewId()
932	title = "%s vs %s" % (self.y_axis_title.GetValue(),
933	self.x_axis_title.GetValue())
934	new_plot.xaxis(self.x_axis_title.GetValue(),
935	self.x_axis_unit.GetValue())
936	new_plot.yaxis(self.y_axis_title.GetValue(),
937	self.y_axis_unit.GetValue())
938	try:
939	title = self.notebook.GetPageText(pos)
940	new_plot.name = title
941	new_plot.xtransform = "x"
942	new_plot.ytransform = "y"
943	wx.PostEvent(self.parent.parent,
944	NewPlotEvent(plot=new_plot,
945	group_id=str(new_plot.group_id), title =title))
946	msg = "Plotting completed!"
947	wx.PostEvent( self.parent.parent,
948	StatusEvent(status=msg))
949	except:
950	wx.PostEvent(self.parent.parent,
951	StatusEvent(status=msg, info="error"))
952
953	def layout_grid(self):
954	"""
955	Draw the area related to the grid
956	"""
957	self.notebook = Notebook(parent=self)
958	self.notebook.set_data(self._data_inputs, self._data_outputs)
959	self.grid_sizer.Add(self.notebook, 1, wx.EXPAND, 0)
960
961	def layout_plotting_area(self):
962	"""
963	Draw area containing options to plot
964	"""
965
966	self.x_axis_title = wx.TextCtrl(self, -1)
967	self.y_axis_title = wx.TextCtrl(self, -1)
968	self.x_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
969	self.y_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
970	self.x_axis_add = wx.Button(self, -1, "Add")
971	self.x_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
972	id=self.x_axis_add.GetId())
973	self.y_axis_add = wx.Button(self, -1, "Add")
974	self.y_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
975	id=self.y_axis_add.GetId())
976	self.x_axis_unit = wx.TextCtrl(self, -1)
977	self.y_axis_unit = wx.TextCtrl(self, -1)
978	self.view_button = wx.Button(self, -1, "View Results")
979	view_tip = "Highlight the data set or the Chi2 column first."
980	self.view_button.SetToolTipString(view_tip)
981	wx.EVT_BUTTON(self, self.view_button.GetId(), self.on_view)
982	self.plot_button = wx.Button(self, -1, "Plot")
983	plot_tip = "Highlight a column for each axis and \n"
984	plot_tip += "click the Add buttons first."
985	self.plot_button.SetToolTipString(plot_tip)
986	self.button_sizer.AddMany( [ (500, 30),
987	(self.view_button, 0, wx.RIGHT\|wx.BOTTOM, 10),
988	(self.plot_button, 0, wx.RIGHT\|wx.BOTTOM, 10)])
989
990	wx.EVT_BUTTON(self, self.plot_button.GetId(), self.on_plot)
991	self.plotting_sizer.AddMany([
992	(wx.StaticText(self, -1,
993	"X-axis Label\nSelection Range"), 1,
994	wx.TOP\|wx.BOTTOM\|wx.LEFT, 10),
995	(self.x_axis_label, 1, wx.TOP\|wx.BOTTOM, 10),
996	(self.x_axis_add, 1, wx.TOP\|wx.BOTTOM\|wx.RIGHT, 10),
997	(wx.StaticText(self, -1, "X-axis Label"), 1,
998	wx.TOP\|wx.BOTTOM\|wx.LEFT, 10),
999	(self.x_axis_title, 1, wx.TOP\|wx.BOTTOM, 10),
1000	(wx.StaticText(self, -1 , "X-axis Unit"), 1,
1001	wx.TOP\|wx.BOTTOM, 10),
1002	(self.x_axis_unit, 1, wx.TOP\|wx.BOTTOM, 10),
1003	(wx.StaticText(self, -1,
1004	"Y-axis Label\nSelection Range"), 1,
1005	wx.BOTTOM\|wx.LEFT, 10),
1006	(self.y_axis_label, wx.BOTTOM, 10),
1007	(self.y_axis_add, 1, wx.BOTTOM\|wx.RIGHT, 10),
1008	(wx.StaticText(self, -1, "Y-axis Label"), 1,
1009	wx.BOTTOM\|wx.LEFT, 10),
1010	(self.y_axis_title, wx.BOTTOM, 10),
1011	(wx.StaticText(self, -1 , "Y-axis Unit"), 1, wx.BOTTOM, 10),
1012	(self.y_axis_unit, 1, wx.BOTTOM, 10),
1013	(-1, -1),
1014	(-1, -1),
1015	(-1, -1),
1016	(-1, -1),
1017	(-1, -1),
1018	(-1, -1),
1019	(-1, 1)])
1020
1021	def on_edit_axis(self, event):
1022	"""
1023	Get the selected column on the visible grid and set values for axis
1024	"""
1025	try:
1026	cell_list = self.notebook.on_edit_axis()
1027	except:
1028	msg = str(sys.exc_value)
1029	wx.PostEvent(self.parent.parent,
1030	StatusEvent(status=msg, info="error"))
1031	return
1032	label, title = self.create_axis_label(cell_list)
1033	tcrtl = event.GetEventObject()
1034	if tcrtl == self.x_axis_add:
1035	self.edit_axis_helper(self.x_axis_label, self.x_axis_title,
1036	label, title)
1037	elif tcrtl == self.y_axis_add:
1038	self.edit_axis_helper(self.y_axis_label, self.y_axis_title,
1039	label, title)
1040
1041	def create_axis_label(self, cell_list):
1042	"""
1043	Receive a list of cells and create a string presenting the selected
1044	cells.
1045	:param cell_list: list of tuple
1046
1047	"""
1048	if self.notebook is not None:
1049	return self.notebook.create_axis_label(cell_list)
1050
1051	def edit_axis_helper(self, tcrtl_label, tcrtl_title, label, title):
1052	"""
1053	get controls to modify
1054	"""
1055	tcrtl_label.SetValue(str(label))
1056	tcrtl_title.SetValue(str(title))
1057
1058	def add_column(self):
1059	"""
1060	"""
1061	if self.notebook is not None:
1062	self.notebook.add_column()
1063
1064	def on_remove_column(self):
1065	"""
1066	"""
1067	if self.notebook is not None:
1068	self.notebook.on_remove_column()
1069
1070
1071	class GridFrame(wx.Frame):
1072	def __init__(self, parent=None, data_inputs=None, data_outputs=None, id=-1,
1073	title="Batch Window", size=(800, 500)):
1074	wx.Frame.__init__(self, parent=parent, id=id, title=title, size=size)
1075	self.parent = parent
1076	self.panel = GridPanel(self, data_inputs, data_outputs)
1077	menubar = wx.MenuBar()
1078	self.SetMenuBar(menubar)
1079
1080	self.curr_col = None
1081	self.curr_grid = None
1082	self.curr_col_name = ""
1083	file = wx.Menu()
1084	menubar.Append(file, "&File")
1085
1086	hint = "Open file containing batch results"
1087	open_menu = file.Append(wx.NewId(), 'Open ', hint)
1088	wx.EVT_MENU(self, open_menu.GetId(), self.on_open)
1089
1090	hint = "Open the the current grid into excel"
1091	open_excel_menu = file.Append(wx.NewId(), 'Open with Excel', hint)
1092	wx.EVT_MENU(self, open_excel_menu.GetId(), self.open_with_excel)
1093	file.AppendSeparator()
1094	save_menu = file.Append(wx.NewId(), 'Save As', 'Save into File')
1095	wx.EVT_MENU(self, save_menu.GetId(), self.on_save_page)
1096
1097	self.edit = wx.Menu()
1098	hint = "Insert column before the selected column"
1099	self.insert_before_menu = wx.Menu()
1100	self.insert_sub_menu = self.edit.AppendSubMenu(self.insert_before_menu,
1101	'Insert Before', hint)
1102
1103	hint = "Remove the selected column"
1104	self.remove_menu = self.edit.Append(-1, 'Remove Column', hint)
1105	wx.EVT_MENU(self, self.remove_menu.GetId(), self.on_remove_column)
1106
1107	self.Bind(wx.EVT_MENU_OPEN, self.on_menu_open)
1108	menubar.Append(self.edit, "&Edit")
1109	self.Bind(wx.EVT_CLOSE, self.on_close)
1110	def GetLabelText(self, id):
1111	"""
1112	"""
1113	for item in self.insert_before_menu.GetMenuItems():
1114	m_id = item.GetId()
1115	if m_id == id:
1116	return item.GetLabel()
1117
1118	def on_remove_column(self, event):
1119	"""
1120	"""
1121	pos = self.panel.notebook.GetSelection()
1122	grid = self.panel.notebook.GetPage(pos)
1123	grid.on_remove_column(event=None)
1124
1125	def on_menu_open(self, event):
1126	"""
1127
1128	"""
1129	if self.edit == event.GetMenu():
1130	#get the selected column
1131	pos = self.panel.notebook.GetSelection()
1132	grid = self.panel.notebook.GetPage(pos)
1133	col_list = grid.GetSelectedCols()
1134	if len(col_list) > 0:
1135	self.remove_menu.Enable(True)
1136	else:
1137	self.remove_menu.Enable(False)
1138	if len(col_list)== 0 or len(col_list) > 1:
1139	self.insert_sub_menu.Enable(False)
1140
1141	label = "Insert Column Before"
1142	self.insert_sub_menu.SetText(label)
1143	else:
1144	self.insert_sub_menu.Enable(True)
1145
1146	col = col_list[0]
1147	#GetColLabelValue(self, col)
1148	col_name = grid.GetCellValue(row=0, col=col)
1149	label = "Insert Column Before " + str(col_name)
1150	self.insert_sub_menu.SetText(label)
1151	for item in self.insert_before_menu.GetMenuItems():
1152	self.insert_before_menu.DeleteItem(item)
1153	grid.insert_col_menu(menu=self.insert_before_menu,
1154	label=col_name, window=self)
1155	event.Skip()
1156
1157
1158
1159	def on_save_page(self, event):
1160	"""
1161	"""
1162	if self.parent is not None:
1163	pos = self.panel.notebook.GetSelection()
1164	grid = self.panel.notebook.GetPage(pos)
1165	if grid.file_name is None or grid.file_name.strip() == "" or \
1166	grid.data is None or len(grid.data) == 0:
1167	name = self.panel.notebook.GetPageText(pos)
1168	msg = " %s has not data to save" % str(name)
1169	wx.PostEvent(self.parent,
1170	StatusEvent(status=msg, info="error"))
1171
1172	return
1173	reader, ext = os.path.splitext(grid.file_name)
1174	path = None
1175	if self.parent is not None:
1176	location = os.path.dirname(grid.file_name)
1177	dlg = wx.FileDialog(self, "Save Project file",
1178	location, grid.file_name, ext, wx.SAVE)
1179	path = None
1180	if dlg.ShowModal() == wx.ID_OK:
1181	path = dlg.GetPath()
1182	dlg.Destroy()
1183	if path != None:
1184	if self.parent is not None:
1185	data = grid.get_grid_view()
1186	self.parent.write_batch_tofile(data=data,
1187	file_name=path,
1188	details=grid.details)
1189
1190	def on_open(self, event):
1191	"""
1192	Open file containg batch result
1193	"""
1194	if self.parent is not None:
1195	self.parent.on_read_batch_tofile(event)
1196
1197	def open_with_excel(self, event):
1198	"""
1199	open excel and display batch result in Excel
1200	"""
1201	if self.parent is not None:
1202	pos = self.panel.notebook.GetSelection()
1203	grid = self.panel.notebook.GetPage(pos)
1204	data = grid.get_grid_view()
1205	if grid.file_name is None or grid.file_name.strip() == "" or \
1206	grid.data is None or len(grid.data) == 0:
1207	name = self.panel.notebook.GetPageText(pos)
1208	msg = " %s has not data to open on excel" % str(name)
1209	wx.PostEvent(self.parent,
1210	StatusEvent(status=msg, info="error"))
1211
1212	return
1213	self.parent.open_with_externalapp(data=data,
1214	file_name=grid.file_name,
1215	details=grid.details)
1216
1217	def on_close(self, event):
1218	"""
1219	"""
1220	self.Hide()
1221
1222
1223	def on_append_column(self, event):
1224	"""
1225	Append a new column to the grid
1226	"""
1227	self.panel.add_column()
1228
1229	def set_data(self, data_inputs, data_outputs, details="", file_name=None):
1230	"""
1231	"""
1232
1233	self.panel.notebook.set_data(data_inputs=data_inputs,
1234	file_name=file_name,
1235	details=details,
1236	data_outputs=data_outputs)
1237
1238
1239	class BatchOutputFrame(wx.Frame):
1240	"""
1241	Allow to select where the result of batch will be displayed or stored
1242	"""
1243	def __init__(self, parent, data_inputs, data_outputs, file_name="",
1244	details="", args, *kwds):
1245	"""
1246	:param parent: Window instantiating this dialog
1247	:param result: result to display in a grid or export to an external
1248	application.
1249	"""
1250	#kwds['style'] = wx.CAPTION\|wx.SYSTEM_MENU
1251	wx.Frame.__init__(self, parent, args, *kwds)
1252	self.parent = parent
1253	self.panel = wx.Panel(self)
1254	self.file_name = file_name
1255	self.details = details
1256	self.data_inputs = data_inputs
1257	self.data_outputs = data_outputs
1258	self.data = {}
1259	for item in (self.data_outputs, self.data_inputs):
1260	self.data.update(item)
1261	self.flag = 1
1262	self.SetSize((300, 200))
1263	self.local_app_selected = None
1264	self.external_app_selected = None
1265	self.save_to_file = None
1266	self._do_layout()
1267
1268	def _do_layout(self):
1269	"""
1270	Draw the content of the current dialog window
1271	"""
1272	vbox = wx.BoxSizer(wx.VERTICAL)
1273	box_description = wx.StaticBox(self.panel, -1, str("Batch Outputs"))
1274	hint_sizer = wx.StaticBoxSizer(box_description, wx.VERTICAL)
1275	selection_sizer = wx.GridBagSizer(5, 5)
1276	button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1277	text = "Open with %s" % self.parent.application_name
1278	self.local_app_selected = wx.RadioButton(self.panel, -1, text,
1279	style=wx.RB_GROUP)
1280	self.Bind(wx.EVT_RADIOBUTTON, self.onselect,
1281	id=self.local_app_selected.GetId())
1282	text = "Open with Excel"
1283	self.external_app_selected = wx.RadioButton(self.panel, -1, text)
1284	self.Bind(wx.EVT_RADIOBUTTON, self.onselect,
1285	id=self.external_app_selected.GetId())
1286	text = "Save to File"
1287	self.save_to_file = wx.CheckBox(self.panel, -1, text)
1288	self.Bind(wx.EVT_CHECKBOX, self.onselect,
1289	id=self.save_to_file.GetId())
1290	self.local_app_selected.SetValue(True)
1291	self.external_app_selected.SetValue(False)
1292	self.save_to_file.SetValue(False)
1293	button_close = wx.Button(self.panel, -1, "Close")
1294	button_close.Bind(wx.EVT_BUTTON, id=button_close.GetId(),
1295	handler=self.on_close)
1296	button_apply = wx.Button(self.panel, -1, "Apply")
1297	button_apply.Bind(wx.EVT_BUTTON, id=button_apply.GetId(),
1298	handler=self.on_apply)
1299	button_apply.SetFocus()
1300	hint = ""
1301	hint_sizer.Add(wx.StaticText(self.panel, -1, hint))
1302	hint_sizer.Add(selection_sizer)
1303	#draw area containing radio buttons
1304	ix = 0
1305	iy = 0
1306	selection_sizer.Add(self.local_app_selected, (iy, ix),
1307	(1, 1), wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1308	iy += 1
1309	selection_sizer.Add(self.external_app_selected, (iy, ix),
1310	(1, 1), wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1311	iy += 1
1312	selection_sizer.Add(self.save_to_file, (iy, ix),
1313	(1, 1), wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1314	#contruction the sizer contaning button
1315	button_sizer.Add((20, 20), 1, wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
1316
1317	button_sizer.Add(button_close, 0,
1318	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
1319	button_sizer.Add(button_apply, 0,
1320	wx.LEFT\|wx.RIGHT\|wx.ADJUST_MINSIZE, 10)
1321	vbox.Add(hint_sizer, 0, wx.EXPAND\|wx.ALL, 10)
1322	vbox.Add(wx.StaticLine(self.panel, -1), 0, wx.EXPAND, 0)
1323	vbox.Add(button_sizer, 0 , wx.TOP\|wx.BOTTOM, 10)
1324	self.SetSizer(vbox)
1325
1326	def on_apply(self, event):
1327	"""
1328	Get the user selection and display output to the selected application
1329	"""
1330	if self.flag == 1:
1331	self.parent.open_with_localapp(data_inputs=self.data_inputs,
1332	data_outputs=self.data_outputs)
1333	elif self.flag == 2:
1334	self.parent.open_with_externalapp(data=self.data,
1335	file_name=self.file_name,
1336	details=self.details)
1337	def on_close(self, event):
1338	"""
1339	close the Window
1340	"""
1341	self.Close()
1342
1343	def onselect(self, event=None):
1344	"""
1345	Receive event and display data into third party application
1346	or save data to file.
1347
1348	"""
1349	if self.save_to_file.GetValue():
1350	reader, ext = os.path.splitext(self.file_name)
1351	path = None
1352	location = os.getcwd()
1353	if self.parent is not None:
1354	location = os.path.dirname(self.file_name)
1355	dlg = wx.FileDialog(self, "Save Project file",
1356	location, self.file_name, ext, wx.SAVE)
1357	path = None
1358	if dlg.ShowModal() == wx.ID_OK:
1359	path = dlg.GetPath()
1360	dlg.Destroy()
1361	if path != None:
1362	if self.parent is not None and self.data is not None:
1363	self.parent.write_batch_tofile(data=self.data,
1364	file_name=path,
1365	details=self.details)
1366	if self.local_app_selected.GetValue():
1367	self.flag = 1
1368	else:
1369	self.flag = 2
1370	return self.flag
1371
1372
1373
1374	if __name__ == "__main__":
1375	app = wx.App()
1376
1377	try:
1378	data = {}
1379	j = 0
1380	for i in range(4):
1381	j += 1
1382	data["index"+str(i)] = [i/j, i*j, i, i+j]
1383
1384	data_input = copy.deepcopy(data)
1385	data_input["index5"] = [10,20,40, 50]
1386	frame = GridFrame(data_outputs=data, data_inputs=data_input)
1387	frame.Show(True)
1388	except:
1389	print sys.exc_value
1390
1391	app.MainLoop()

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

SasView

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

Download in other formats: