data_processor.py @ c812d11

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 c812d11 was dc2da3d, checked in by butler, 9 years ago
Link new documentation to data_processor.py (batch fit page). This completes linking of help to guiframe elements
Property mode set to `100644`
File size: 77.8 KB

Line
1	"""
2	Implement grid used to store results of a batch fit.
3
4	This is in Guiframe rather than fitting which is probably where it should be.
5	Actually could be a generic framework implemented in fit gui module. At this
6	point however there this grid behaves independently of the fitting panel and
7	only knows about information sent to it but not about the fits or fit panel and
8	thus cannot feed back to the fitting panel. This could change in the future.
9
10	The organization of the classes goes as:
11
12	#Path to this is: /sasview/src/sas/sasgui/guiframe/data_processor.py
13	#Path to image is: /sasview/src/sas/sasgui/guiframe/media/BatchGridClassLayout.png
14	.. image:: ./guiframe/media/BatchGridClassLayout.png
15	:align: center
16
17	"""
18	import wx
19	import numpy
20	import math
21	import re
22	import os
23	import sys
24	import copy
25	from wx.lib.scrolledpanel import ScrolledPanel
26	import wx.aui
27	from wx.aui import AuiNotebook as nb
28	import wx.lib.sheet as sheet
29	from sas.sasgui.guiframe.panel_base import PanelBase
30	from sas.sasgui.guiframe.events import NewPlotEvent
31	from sas.sasgui.guiframe.events import StatusEvent
32	from sas.sasgui.plottools import plottables
33	from sas.sasgui.guiframe.dataFitting import Data1D
34
35
36	FUNC_DICT = {"sqrt": "math.sqrt",
37	"pow": "math.sqrt"}
38
39	class BatchCell(object):
40	"""
41	Object describing a cell in the grid.
42	"""
43	def __init__(self):
44	"""
45	Initialize attributes of class (label, value, col, row, object)
46	"""
47	self.label = ""
48	self.value = None
49	self.col = -1
50	self.row = -1
51	self.object = []
52
53
54	def parse_string(sentence, list):
55	"""
56	Return a dictionary of column label and index or row selected
57
58	:param sentence: String to parse
59	:param list: list of columns label
60	:returns: col_dict
61	"""
62
63	p2 = re.compile(r'\d+')
64	p = re.compile(r'[\+\-\*\%\/]')
65	labels = p.split(sentence)
66	col_dict = {}
67	for elt in labels:
68	rang = None
69	temp_arr = []
70	for label in list:
71	label_pos = elt.find(label)
72	separator_pos = label_pos + len(label)
73	if label_pos != -1 and len(elt) >= separator_pos and\
74	elt[separator_pos] == "[":
75	# the label contain , meaning the range selected is not
76	# continuous
77	if elt.count(',') > 0:
78	new_temp = []
79	temp = elt.split(label)
80	for item in temp:
81	range_pos = item.find(":")
82	if range_pos != -1:
83	rang = p2.findall(item)
84	for i in xrange(int(rang[0]), int(rang[1]) + 1):
85	new_temp.append(i)
86	temp_arr += new_temp
87	else:
88	# continuous range
89	temp = elt.split(label)
90	for item in temp:
91	if item.strip() != "":
92	range_pos = item.find(":")
93	if range_pos != -1:
94	rang = p2.findall(item)
95	for i in xrange(int(rang[0]), int(rang[1]) + 1):
96	temp_arr.append(i)
97	col_dict[elt] = (label, temp_arr)
98	return col_dict
99
100
101	class SPanel(ScrolledPanel):
102	"""
103	ensure proper scrolling of GridPanel
104
105	Adds a SetupScrolling call to the normal ScrolledPanel init.
106	GridPanel then subclasses this class
107
108	"""
109	def __init__(self, parent, args, *kwds):
110	"""
111	initialize ScrolledPanel then force a call to SetupScrolling
112
113	"""
114	ScrolledPanel.__init__(self, parent, args, *kwds)
115	self.SetupScrolling()
116
117
118	class GridCellEditor(sheet.CCellEditor):
119	"""
120	Custom cell editor
121
122	This subclasses the sheet.CCellEditor (itself a subclass of
123	grid.GridCellEditor) in order to override two of its methods:
124	PaintBackrgound and EndEdit.
125
126	This is necessary as the sheet module is broken in wx 3.0.2 and
127	improperly subclasses grid.GridCellEditor
128	"""
129	def __init__(self, grid):
130	"""
131	Override of CCellEditor init. Runs the grid.GridCellEditor init code
132	"""
133	super(GridCellEditor, self).__init__(grid)
134
135	def PaintBackground(self, dc, rect, attr):
136	"""
137	Overrides wx.sheet.CCellEditor.PaintBackground which incorrectly calls
138	the base class method.
139
140	In wx3.0 all paint objects must explicitly
141	have a wxPaintDC (Device Context) object. Thus the paint event which
142	generates a call to this method provides such a DC object and the
143	base class in grid expects to receive that object. sheet was apparently
144	not updated to reflect this and hence fails. This could thus
145	become obsolete in a future bug fix of wxPython.
146
147	Apart from adding a dc variable in the list of arguments in the def
148	and in the call to the base class the rest of this method is copied
149	as is from sheet.CCellEditor.PaintBackground
150
151	From original GridCellEditor docs:
152
153	Draws the part of the cell not occupied by the edit control. The
154	base class version just fills it with background colour from the
155	attribute.
156
157	NOTE: There is no need to override this if you don't need
158	to do something out of the ordinary.
159
160	:param dc: the wxDC object for the paint
161	"""
162	# Call base class method.
163	DC = dc
164	super(sheet.CCellEditor,self).PaintBackground(DC, rect, attr)
165
166	def EndEdit(self, row, col, grid, previous):
167	"""
168	Commit editing the current cell. Returns True if the value has changed.
169
170	:param previous: previous value in the cell
171	"""
172	changed = False # Assume value not changed
173	val = self._tc.GetValue() # Get value in edit control
174	if val != self._startValue: # Compare
175	changed = True # If different then changed is True
176	grid.GetTable().SetValue(row, col, val) # Update the table
177	self._startValue = '' # Clear the class' start value
178	self._tc.SetValue('') # Clear contents of the edit control
179	return changed
180
181
182	class GridPage(sheet.CSheet):
183	"""
184	Class that receives the results of a batch fit.
185
186	GridPage displays the received results in a wx.grid using sheet. This is
187	then used by GridPanel and GridFrame to present the full GUI.
188	"""
189	def __init__(self, parent, panel=None):
190	"""
191	Initialize
192
193	Initialize all the attributes of GridPage, and the events. include
194	the init stuff from sheet.CSheet as well.
195	"""
196	#sheet.CSheet.__init__(self, parent)
197
198	# The following is the __init__ from CSheet. ##########################
199	# We re-write it here because the class is broken in wx 3.0,
200	# such that the cell editor is not able to receive the right
201	# number of parameters when it is called. The only way to
202	# pick a different cell editor is apparently to re-write the __init__.
203	wx.grid.Grid.__init__(self, parent, -1)
204
205	# Init variables
206	self._lastCol = -1 # Init last cell column clicked
207	self._lastRow = -1 # Init last cell row clicked
208	self._selected = None # Init range currently selected
209	# Map string datatype to default renderer/editor
210	self.RegisterDataType(wx.grid.GRID_VALUE_STRING,
211	wx.grid.GridCellStringRenderer(),
212	GridCellEditor(self))
213
214	self.CreateGrid(4, 3) # By default start with a 4 x 3 grid
215	self.SetColLabelSize(18) # Default sizes and alignment
216	self.SetRowLabelSize(50)
217	self.SetRowLabelAlignment(wx.ALIGN_RIGHT, wx.ALIGN_BOTTOM)
218	self.SetColSize(0, 75) # Default column sizes
219	self.SetColSize(1, 75)
220	self.SetColSize(2, 75)
221
222	# Sink events
223	self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self.OnRangeSelect)
224	self.Bind(wx.grid.EVT_GRID_ROW_SIZE, self.OnRowSize)
225	self.Bind(wx.grid.EVT_GRID_COL_SIZE, self.OnColSize)
226	self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.OnGridSelectCell)
227	# NOTE: the following bind to standard sheet methods that are
228	# overriden in this subclassn - actually we have currently
229	# disabled the on_context_menu that would override the OnRightClick
230	self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.OnCellChange)
231	self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.OnLeftClick)
232	self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.OnRightClick)
233	#self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.OnLeftDoubleClick)
234	# This ends the __init__ section for CSheet. ##########################
235
236
237
238	# The following events must be bound even if CSheet is working
239	# properly and does not need the above re-implementation of the
240	# CSheet init method. Basically these override any intrinsic binding
241	self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.on_right_click)
242	self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_left_click)
243
244	self.AdjustScrollbars()
245	#self.SetLabelBackgroundColour('#DBD4D4')
246	self.uid = wx.NewId()
247	self.parent = parent
248	self.panel = panel
249	self.col_names = []
250	self.data_inputs = {}
251	self.data_outputs = {}
252	self.data = None
253	self.details = ""
254	self.file_name = None
255	self._cols = 50
256	self._rows = 3001
257	self.last_selected_row = -1
258	self.last_selected_col = -1
259	self.col_width = 30
260	self.row_height = 20
261	self.max_row_touse = 0
262	self.axis_value = []
263	self.axis_label = ""
264	self.selected_cells = []
265	self.selected_cols = []
266	self.selected_rows = []
267	self.plottable_cells = []
268	self.plottable_flag = False
269	self.SetColMinimalAcceptableWidth(self.col_width)
270	self.SetRowMinimalAcceptableHeight(self.row_height)
271	self.SetNumberRows(self._rows)
272	self.SetNumberCols(self._cols)
273	color = self.parent.GetBackgroundColour()
274	for col in range(self._cols):
275	self.SetCellBackgroundColour(0, col, color)
276	self.AutoSize()
277	self.list_plot_panels = {}
278	self.default_col_width = 75
279	self.EnableEditing(True)
280	if self.GetNumberCols() > 0:
281	self.default_col_width = self.GetColSize(0)
282	# We have moved these to the top of the init section with the
283	# rest of the grid event bindings from the sheet init when
284	# appropriate
285	#self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_left_click)
286	#self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.on_right_click)
287	#self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.on_selected_cell)
288	#self.Bind(wx.grid.EVT_GRID_CMD_CELL_CHANGE, self.on_edit_cell)
289	#self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.onContextMenu)
290
291	def OnLeftClick(self, event):
292	"""
293	Overrides sheet.CSheet.OnLefClick.
294
295	Processes when a cell is selected by left clicking on that cell. First
296	process the base Sheet method then the current class specific method
297	"""
298	sheet.CSheet.OnLeftClick(self, event)
299	self.on_selected_cell(event)
300
301
302	def OnCellChange(self, event):
303	"""
304	Overrides sheet.CSheet.OnCellChange.
305
306	Processes when a cell has been edited by a cell editor. Checks for the
307	edited row being outside the max row to use attribute and if so updates
308	the last row. Then calls the base handler using skip.
309	"""
310	row, _ = event.GetRow(), event.GetCol()
311	if row > self.max_row_touse:
312	self.max_row_touse = row
313	if self.data == None:
314	self.data = {}
315	event.Skip()
316
317	def on_selected_cell(self, event):
318	"""
319	Handler catching cell selection.
320
321	Called after calling base 'on left click' method.
322	"""
323
324	flag = event.CmdDown() or event.ControlDown()
325	flag_shift = event.ShiftDown()
326	row, col = event.GetRow(), event.GetCol()
327	cell = (row, col)
328	if not flag and not flag_shift:
329	self.selected_cols = []
330	self.selected_rows = []
331	self.selected_cells = []
332	self.axis_label = ""
333	self.axis_value = []
334	self.plottable_list = []
335	self.plottable_cells = []
336	self.plottable_flag = False
337	self.last_selected_col = col
338	self.last_selected_row = row
339	if col >= 0:
340	if flag:
341	label_row = row
342	else:
343	label_row = 0
344	self.axis_label = self.GetCellValue(label_row, col)
345	self.selected_cols.append(col)
346	if flag_shift:
347	if not self.selected_rows:
348	min_r = 1
349	else:
350	min_r = min(self.selected_rows)
351	for row_s in range(min_r, row + 1):
352	cel = (row_s, col)
353	if cel not in self.selected_cells:
354	if row > 0:
355	self.selected_cells.append(cel)
356	self.selected_rows.append(row)
357	for row_s in self.selected_rows:
358	cel = (row_s, col)
359	if row_s > row:
360	try:
361	self.selected_cells.remove(cel)
362	except:
363	pass
364	try:
365	self.selected_rows.remove(row_s)
366	except:
367	pass
368	elif flag:
369	if cell not in self.selected_cells:
370	if row > 0:
371	self.selected_cells.append(cell)
372	self.selected_rows.append(row)
373	else:
374	try:
375	self.selected_cells.remove(cell)
376	except:
377	pass
378	try:
379	self.selected_rows.remove(row)
380	except:
381	pass
382	else:
383	self.selected_cells.append(cell)
384	self.selected_rows.append(row)
385	self.axis_value = []
386	for cell_row, cell_col in self.selected_cells:
387	if cell_row > 0 and cell_row < self.max_row_touse:
388	self.axis_value.append(self.GetCellValue(cell_row, cell_col))
389	event.Skip()
390
391	def on_left_click(self, event):
392	"""
393	Is triggered when the left mouse button is clicked while the mouse
394	is hovering over the column 'label.'
395
396	This processes the information on the selected column: the column name
397	(in row 0 of column) and the range of cells with a valid value to be
398	used by the GridPanel set_axis methods.
399	"""
400
401	flag = event.CmdDown() or event.ControlDown()
402
403	col = event.GetCol()
404	row = event.GetRow()
405
406	if not flag:
407	self.selected_cols = []
408	self.selected_rows = []
409	self.selected_cells = []
410	self.axis_label = ""
411	self.axis_value = []
412	self.plottable_list = []
413	self.plottable_cells = []
414	self.plottable_flag = False
415
416	self.last_selected_col = col
417	self.last_selected_row = row
418	if row != -1 and row not in self.selected_rows:
419	self.selected_rows.append(row)
420
421	if col != -1:
422	for row in range(1, self.GetNumberRows() + 1):
423	cell = (row, col)
424	if row > 0 and row < self.max_row_touse:
425	if cell not in self.selected_cells:
426	self.selected_cells.append(cell)
427	else:
428	if flag:
429	self.selected_cells.remove(cell)
430	self.selected_cols.append(col)
431	self.axis_value = []
432	for cell_row, cell_col in self.selected_cells:
433	val = self.GetCellValue(cell_row, cell_col)
434	if not val:
435	self.axis_value.append(self.GetCellValue(cell_row, cell_col))
436	self.axis_label = self.GetCellValue(0, col)
437	if not self.axis_label:
438	self.axis_label = " "
439	event.Skip()
440
441	def on_right_click(self, event):
442	"""
443	Is triggered when the right mouse button is clicked while the mouse
444	is hovering over the column 'label.'
445
446	This brings up a context menu that allows the deletion of the column,
447	or the insertion of a new column either to the right or left of the
448	current column. If inserting a new column can insert a blank column or
449	choose a number of hidden columns. By default all the error parameters
450	are in hidden columns so as to save space on the grid. Also any other
451	intrinsic variables stored with the data such as Temperature, pressure,
452	time etc can be used to populate this menu.
453	"""
454
455	col = event.GetCol()
456	row = event.GetRow()
457	# Ignore the index column
458	if col < 0 or row != -1:
459	return
460	self.selected_cols = []
461	self.selected_cols.append(col)
462	# Slicer plot popup menu
463	slicerpop = wx.Menu()
464	col_label_menu = wx.Menu()
465	c_name = self.GetCellValue(0, col)
466	label = "Insert column before %s " % str(c_name)
467	slicerpop.AppendSubMenu(col_label_menu, '&%s' % str(label), str(label))
468	row = 0
469	label = self.GetCellValue(row, col)
470	self.insert_col_menu(col_label_menu, label, self)
471
472	col_after_menu = wx.Menu()
473	label = "Insert column after %s " % str(c_name)
474	slicerpop.AppendSubMenu(col_after_menu, '&%s' % str(label), str(label))
475	self.insert_after_col_menu(col_after_menu, label, self)
476
477	wx_id = wx.NewId()
478	hint = 'Remove selected column %s'
479	slicerpop.Append(wx_id, '&Remove Column', hint)
480	wx.EVT_MENU(self, wx_id, self.on_remove_column)
481
482	pos = wx.GetMousePosition()
483	pos = self.ScreenToClient(pos)
484	self.PopupMenu(slicerpop, pos)
485	event.Skip()
486
487	def insert_col_menu(self, menu, label, window):
488	"""
489	method called to populate the 'insert column before current column'
490	submenu.
491	"""
492
493	if self.data is None:
494	return
495	id = wx.NewId()
496	title = "Empty"
497	hint = 'Insert empty column before %s' % str(label)
498	menu.Append(id, title, hint)
499	wx.EVT_MENU(window, id, self.on_insert_column)
500	row = 0
501	col_name = [self.GetCellValue(row, col) for col in range(self.GetNumberCols())]
502	for c_name in self.data.keys():
503	if c_name not in col_name and self.data[c_name]:
504	wx_id = wx.NewId()
505	hint = "Insert %s column before the " % str(c_name)
506	hint += " %s column" % str(label)
507	menu.Append(wx_id, '&%s' % str(c_name), hint)
508	wx.EVT_MENU(window, wx_id, self.on_insert_column)
509
510	def insert_after_col_menu(self, menu, label, window):
511	"""
512	Method called to populate the 'insert column after current column'
513	submenu
514	"""
515
516	if self.data is None:
517	return
518	wx_id = wx.NewId()
519	title = "Empty"
520	hint = 'Insert empty column after %s' % str(label)
521	menu.Append(wx_id, title, hint)
522	wx.EVT_MENU(window, wx_id, self.on_insert_after_column)
523	row = 0
524	col_name = [self.GetCellValue(row, col)
525	for col in range(self.GetNumberCols())]
526	for c_name in self.data.keys():
527	if c_name not in col_name and self.data[c_name]:
528	wx_id = wx.NewId()
529	hint = "Insert %s column after the " % str(c_name)
530	hint += " %s column" % str(label)
531	menu.Append(wx_id, '&%s' % str(c_name), hint)
532	wx.EVT_MENU(window, wx_id, self.on_insert_after_column)
533
534	def on_remove_column(self, event=None):
535	"""
536	Called when user chooses remove from the column right click menu
537	Checks the columnn exists then calls the remove_column method
538	"""
539
540	if self.selected_cols is not None or len(self.selected_cols) > 0:
541	col = self.selected_cols[0]
542	self.remove_column(col=col, numCols=1)
543
544	def remove_column(self, col, numCols=1):
545	"""
546	Remove the col column from the current grid
547	"""
548
549	# add data to the grid
550	row = 0
551	col_name = self.GetCellValue(row, col)
552	self.data[col_name] = []
553	for row in range(1, self.GetNumberRows() + 1):
554	if row < self.max_row_touse:
555	value = self.GetCellValue(row, col)
556	self.data[col_name].append(value)
557	for k, value_list in self.data.iteritems():
558	if k != col_name:
559	length = len(value_list)
560	if length < self.max_row_touse:
561	diff = self.max_row_touse - length
562	for i in range(diff):
563	self.data[k].append("")
564	self.DeleteCols(pos=col, numCols=numCols, updateLabels=True)
565
566	def on_insert_column(self, event):
567	"""
568	Called when user chooses insert 'column before' submenu
569	of the column context menu obtained when right clicking on a given
570	column header.
571
572	Sets up to insert column into the current grid before the current
573	highlighted column location and sets up what to populate that column
574	with. Then calls insert_column method to actually do the insertion.
575	"""
576
577	if self.selected_cols is not None or len(self.selected_cols) > 0:
578	col = self.selected_cols[0]
579	# add data to the grid
580	wx_id = event.GetId()
581	col_name = event.GetEventObject().GetLabelText(wx_id)
582	self.insert_column(col=col, col_name=col_name)
583	if not issubclass(event.GetEventObject().__class__, wx.Menu):
584	col += 1
585	self.selected_cols[0] += 1
586
587	def on_insert_after_column(self, event):
588	"""
589	Called when user chooses insert 'column after' submenu
590	of the column context menu obtained when right clicking on a given
591	column header.
592
593	Sets up to insert column into the current grid after the current
594	highlighted column location and sets up what to populate that column
595	with. Then calls insert_column method to actually do the insertion.
596	"""
597
598	if self.selected_cols is not None or len(self.selected_cols) > 0:
599	col = self.selected_cols[0] + 1
600	# add data to the grid
601	wx_id = event.GetId()
602	col_name = event.GetEventObject().GetLabelText(wx_id)
603	self.insert_column(col=col, col_name=col_name)
604	if not issubclass(event.GetEventObject().__class__, wx.Menu):
605	self.selected_cols[0] += 1
606
607	def insert_column(self, col, col_name):
608	"""
609	Insert column at position col with data[col_name] into the current
610	grid.
611	"""
612
613	row = 0
614	self.InsertCols(pos=col, numCols=1, updateLabels=True)
615	if col_name.strip() != "Empty":
616	self.SetCellValue(row, col, str(col_name.strip()))
617	if col_name in self.data.keys():
618	value_list = self.data[col_name]
619	cell_row = 1
620	for value in value_list:
621	label = value#format_number(value, high=True)
622	self.SetCellValue(cell_row, col, str(label))
623	cell_row += 1
624	self.AutoSizeColumn(col, True)
625	width = self.GetColSize(col)
626	if width < self.default_col_width:
627	self.SetColSize(col, self.default_col_width)
628	color = self.parent.GetBackgroundColour()
629	self.SetCellBackgroundColour(0, col, color)
630	self.ForceRefresh()
631
632	def on_set_x_axis(self, event):
633	"""
634	Just calls the panel version of the method
635	"""
636
637	self.panel.set_xaxis(x=self.axis_value, label=self.axis_label)
638
639	def on_set_y_axis(self, event):
640	"""
641	Just calls the panel version of the method
642	"""
643
644	self.panel.set_yaxis(y=self.axis_value, label=self.axis_label)
645
646	def set_data(self, data_inputs, data_outputs, details, file_name):
647	"""
648	Add data to the grid
649
650	:param data_inputs: data to use from the context menu of the grid
651	:param data_ouputs: default columns displayed
652	"""
653
654	self.file_name = file_name
655	self.details = details
656
657	if data_outputs is None:
658	data_outputs = {}
659	self.data_outputs = data_outputs
660	if data_inputs is None:
661	data_inputs = {}
662	self.data_inputs = data_inputs
663	self.data = {}
664	for item in (self.data_outputs, self.data_inputs):
665	self.data.update(item)
666
667	if len(self.data_outputs) > 0:
668	self._cols = self.GetNumberCols()
669	self._rows = self.GetNumberRows()
670	self.col_names = self.data_outputs.keys()
671	self.col_names.sort()
672	nbr_user_cols = len(self.col_names)
673	#Add more columns to the grid if necessary
674	if nbr_user_cols > self._cols:
675	new_col_nbr = nbr_user_cols - self._cols + 1
676	self.AppendCols(new_col_nbr, True)
677	#Add more rows to the grid if necessary
678	nbr_user_row = len(self.data_outputs.values()[0])
679	if nbr_user_row > self._rows + 1:
680	new_row_nbr = nbr_user_row - self._rows + 1
681	self.AppendRows(new_row_nbr, True)
682	# add data to the grid
683	wx.CallAfter(self.set_grid_values)
684	self.ForceRefresh()
685
686	def set_grid_values(self):
687	"""
688	Set the values in grids
689	"""
690
691	# add data to the grid
692	row = 0
693	col = 0
694	cell_col = 0
695	for col_name in self.col_names:
696	# use the first row of the grid to add user defined labels
697	self.SetCellValue(row, col, str(col_name))
698	col += 1
699	cell_row = 1
700	value_list = self.data_outputs[col_name]
701
702	for value in value_list:
703	label = value
704	if issubclass(value.__class__, BatchCell):
705	label = value.label
706	try:
707	float(label)
708	label = str(label)#format_number(label, high=True)
709	except:
710	label = str(label)
711	self.SetCellValue(cell_row, cell_col, label)
712	self.AutoSizeColumn(cell_col, True)
713	width = self.GetColSize(cell_col)
714	if width < self.default_col_width:
715	self.SetColSize(cell_col, self.default_col_width)
716
717	cell_row += 1
718	cell_col += 1
719	if cell_row > self.max_row_touse:
720	self.max_row_touse = cell_row
721
722	def get_grid_view(self):
723	"""
724	Return value contained in the grid
725	"""
726
727	grid_view = {}
728	for col in xrange(self.GetNumberCols()):
729	label = self.GetCellValue(row=0, col=col)
730	label = label.strip()
731	if label != "":
732	grid_view[label] = []
733	for row in range(1, self.max_row_touse):
734	value = self.GetCellValue(row=row, col=col)
735	if value != "":
736	grid_view[label].append(value)
737	else:
738	grid_view[label].append(None)
739	return grid_view
740
741	def get_nofrows(self):
742	"""
743	Return number of total rows
744	"""
745	return self._rows
746
747	def onContextMenu(self, event):
748	"""
749	Method to handle cell right click context menu.
750
751	THIS METHOD IS NOT CURRENTLY USED. It is designed to provide a
752	cell pop up context by right clicking on a cell and gives the
753	option to cut, paste, and clear. This will probably be removed in
754	future versions and is being superceded by more traditional cut and
755	paste options.
756	"""
757
758	wx_id = wx.NewId()
759	c_menu = wx.Menu()
760	copy_menu = c_menu.Append(wx_id, '&Copy', 'Copy the selected cells')
761	wx.EVT_MENU(self, wx_id, self.on_copy)
762
763	wx_id = wx.NewId()
764	c_menu.Append(wx_id, '&Paste', 'Paste the selected cells')
765	wx.EVT_MENU(self, wx_id, self.on_paste)
766
767	wx_id = wx.NewId()
768	clear_menu = c_menu.Append(wx_id, '&Clear', 'Clear the selected cells')
769	wx.EVT_MENU(self, wx_id, self.on_clear)
770
771	# enable from flag
772	has_selection = False
773	selected_cel = self.selected_cells
774	if len(selected_cel) > 0:
775	_row, _col = selected_cel[0]
776	has_selection = self.IsInSelection(_row, _col)
777	if len(self.selected_cols) > 0:
778	has_selection = True
779	if len(self.selected_rows) > 0:
780	has_selection = True
781	copy_menu.Enable(has_selection)
782	clear_menu.Enable(has_selection)
783	try:
784	# mouse event pos
785	pos_evt = event.GetPosition()
786	self.PopupMenu(c_menu, pos_evt)
787	except:
788	return
789
790	def on_copy(self, event):
791	"""
792	Called when copy is chosen from cell right click context menu
793
794	THIS METHOD IS NOT CURRENTLY USED. it is part of right click cell
795	context menu which is being removed. This will probably be removed in
796	future versions and is being superceded by more traditional cut and
797	paste options
798	"""
799
800	self.Copy()
801
802	def on_paste(self, event):
803	"""
804	Called when paste is chosen from cell right click context menu
805
806	THIS METHOD IS NOT CURRENTLY USED. it is part of right click cell
807	context menu which is being removed. This will probably be removed in
808	future versions and is being superceded by more traditional cut and
809	paste options
810	"""
811
812	if self.data == None:
813	self.data = {}
814	if self.file_name == None:
815	self.file_name = 'copied_data'
816	self.Paste()
817
818	def on_clear(self, event):
819	"""
820	Called when clear cell is chosen from cell right click context menu
821
822	THIS METHOD IS NOT CURRENTLY USED. it is part of right click cell
823	context menu which is being removed. This will probably be removed in
824	future versions and is being superceded by more traditional cut and
825	paste options
826	"""
827
828	self.Clear()
829
830	class Notebook(nb, PanelBase):
831	"""
832	## Internal name for the AUI manager
833	window_name = "Fit panel"
834	## Title to appear on top of the window
835	"""
836
837	window_caption = "Notebook "
838
839	def __init__(self, parent, manager=None, data=None, args, *kwargs):
840	"""
841	"""
842	nb.__init__(self, parent, -1,
843	style=wx.aui.AUI_NB_WINDOWLIST_BUTTON \|
844	wx.aui.AUI_BUTTON_DOWN \|
845	wx.aui.AUI_NB_DEFAULT_STYLE \|
846	wx.CLIP_CHILDREN)
847	PanelBase.__init__(self, parent)
848	self.gpage_num = 1
849	self.enable_close_button()
850	self.parent = parent
851	self.manager = manager
852	self.data = data
853	#add empty page
854	self.add_empty_page()
855	self.pageClosedEvent = wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE
856	self.Bind(self.pageClosedEvent, self.on_close_page)
857
858	def add_empty_page(self):
859	"""
860	"""
861	grid = GridPage(self, panel=self.parent)
862	self.AddPage(grid, "", True)
863	pos = self.GetPageIndex(grid)
864	title = "Table" + str(self.gpage_num)
865	self.SetPageText(pos, title)
866	self.SetSelection(pos)
867	self.enable_close_button()
868	self.gpage_num += 1
869	return grid, pos
870
871	def enable_close_button(self):
872	"""
873	display the close button on the tab if more than 1 tab exits.
874	Otherwise remove the close button
875	"""
876
877	if self.GetPageCount() <= 1:
878	style = self.GetWindowStyleFlag()
879	flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
880	if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB == flag:
881	style = style & ~wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
882	self.SetWindowStyle(style)
883	else:
884	style = self.GetWindowStyleFlag()
885	flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
886	if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB != flag:
887	style \|= wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
888	self.SetWindowStyle(style)
889
890	def on_edit_axis(self):
891	"""
892	Return the select cell range from a given selected column. Checks that
893	all cells are from the same column
894	"""
895
896	pos = self.GetSelection()
897	grid = self.GetPage(pos)
898	#grid.selected_cols = [grid.GetSelectedRows()]#
899	if len(grid.selected_cols) >= 1:
900	col = grid.selected_cols[0]
901	for c in grid.selected_cols:
902	if c != col:
903	msg = "Edit axis doesn't understand this selection.\n"
904	msg += "Please select only one column"
905	raise ValueError, msg
906	for (_, cell_col) in grid.selected_cells:
907	if cell_col != col:
908	msg = "Cannot use cells from different columns for "
909	msg += "this operation.\n"
910	msg += "Please select elements of the same col.\n"
911	raise ValueError, msg
912
913	# Finally check the highlighted cell if any cells missing
914	self.get_highlighted_row(True)
915	else:
916	msg = "No item selected.\n"
917	msg += "Please select only one column or one cell"
918	raise ValueError, msg
919	return grid.selected_cells
920
921	def get_highlighted_row(self, is_number=True):
922	"""
923	Add highlight rows
924	"""
925
926	pos = self.GetSelection()
927	grid = self.GetPage(pos)
928	col = grid.selected_cols[0]
929	# Finally check the highlighted cell if any cells missing
930	for row in range(grid.get_nofrows()):
931	if grid.IsInSelection(row, col):
932	cel = (row, col)
933	if row < 1 and not is_number:
934	continue
935	# empty cell
936	if not grid.GetCellValue(row, col).lstrip().rstrip():
937	if cel in grid.selected_cells:
938	grid.selected_cells.remove(cel)
939	continue
940	if is_number:
941	try:
942	float(grid.GetCellValue(row, col))
943	except:
944	# non numeric cell
945	if cel in grid.selected_cells:
946	grid.selected_cells.remove(cel)
947	continue
948	if cel not in grid.selected_cells:
949	grid.selected_cells.append(cel)
950
951	def get_column_labels(self):
952	"""
953	return dictionary of columns labels on the current page
954	"""
955
956	pos = self.GetSelection()
957	grid = self.GetPage(pos)
958	labels = {}
959	for col in range(grid.GetNumberCols()):
960	label = grid.GetColLabelValue(int(col))
961	if label.strip() != "":
962	labels[label.strip()] = col
963	return labels
964
965	def create_axis_label(self, cell_list):
966	"""
967	Receive a list of cells and create a string presenting the selected
968	cells that can be used as data for one axis of a plot.
969
970	:param cell_list: list of tuple
971	"""
972	pos = self.GetSelection()
973	grid = self.GetPage(pos)
974	label = ""
975	col_name = ""
976	def create_label(col_name, row_min=None, row_max=None):
977	"""
978	"""
979	result = " "
980	if row_min is not None or row_max is not None:
981	if row_min is None:
982	result = str(row_max) + "]"
983	elif row_max is None:
984	result = str(col_name) + "[" + str(row_min) + ":"
985	else:
986	result = str(col_name) + "[" + str(row_min) + ":"
987	result += str(row_max) + "]"
988	return str(result)
989
990	if len(cell_list) > 0:
991	if len(cell_list) == 1:
992	row_min, col = cell_list[0]
993	col_name = grid.GetColLabelValue(int(col))
994
995	col_title = grid.GetCellValue(0, col)
996	label = create_label(col_name, row_min + 1, row_min + 1)
997	return label, col_title
998	else:
999	temp_list = copy.deepcopy(cell_list)
1000	temp_list.sort()
1001	length = len(temp_list)
1002	row_min, col = temp_list[0]
1003	row_max, _ = temp_list[length - 1]
1004	col_name = grid.GetColLabelValue(int(col))
1005	col_title = grid.GetCellValue(0, col)
1006
1007	index = 0
1008	for row in xrange(row_min, row_max + 1):
1009	if index > 0 and index < len(temp_list):
1010	new_row, _ = temp_list[index]
1011	if row != new_row:
1012	temp_list.insert(index, (None, None))
1013	if index - 1 >= 0:
1014	new_row, _ = temp_list[index - 1]
1015	if not new_row == None and new_row != ' ':
1016	label += create_label(col_name, None,
1017	int(new_row) + 1)
1018	else:
1019	label += "]"
1020	label += ","
1021	if index + 1 < len(temp_list):
1022	new_row, _ = temp_list[index + 1]
1023	if not new_row == None:
1024	label += create_label(col_name,
1025	int(new_row) + 1, None)
1026	if row_min != None and row_max != None:
1027	if index == 0:
1028	label += create_label(col_name,
1029	int(row_min) + 1, None)
1030	elif index == len(temp_list) - 1:
1031	label += create_label(col_name, None,
1032	int(row_max) + 1)
1033	index += 1
1034	# clean up the list
1035	label_out = ''
1036	for item in label.split(','):
1037	if item.split(":")[1] == "]":
1038	continue
1039	else:
1040	label_out += item + ","
1041
1042	return label_out, col_title
1043
1044	def on_close_page(self, event):
1045	"""
1046	close the page
1047	"""
1048
1049	if self.GetPageCount() == 1:
1050	event.Veto()
1051	wx.CallAfter(self.enable_close_button)
1052
1053	def set_data(self, data_inputs, data_outputs, details="", file_name=None):
1054	"""
1055	"""
1056	if data_outputs is None or data_outputs == {}:
1057	return
1058	inputs, outputs = self.get_odered_results(data_inputs, data_outputs)
1059	for pos in range(self.GetPageCount()):
1060	grid = self.GetPage(pos)
1061	if grid.data is None:
1062	#Found empty page
1063	grid.set_data(data_inputs=inputs,
1064	data_outputs=outputs,
1065	details=details,
1066	file_name=file_name)
1067	self.SetSelection(pos)
1068	return
1069
1070	grid, pos = self.add_empty_page()
1071	grid.set_data(data_inputs=inputs,
1072	data_outputs=outputs,
1073	file_name=file_name,
1074	details=details)
1075
1076	def get_odered_results(self, inputs, outputs=None):
1077	"""
1078	Order a list of 'inputs.' Used to sort rows and columns to present
1079	in batch results grid.
1080	"""
1081
1082	# Let's re-order the data from the keys in 'Data' name.
1083	if outputs == None:
1084	return
1085	try:
1086	# For outputs from batch
1087	to_be_sort = [str(item.label) for item in outputs['Data']]
1088	except:
1089	# When inputs are from an external file
1090	return inputs, outputs
1091	inds = numpy.lexsort((to_be_sort, to_be_sort))
1092	for key in outputs.keys():
1093	key_list = outputs[key]
1094	temp_key = [item for item in key_list]
1095	for ind in inds:
1096	temp_key[ind] = key_list[inds[ind]]
1097	outputs[key] = temp_key
1098	for key in inputs.keys():
1099	key_list = inputs[key]
1100	if len(key_list) == len(inds):
1101	temp_key = [item for item in key_list]
1102	for ind in inds:
1103	temp_key[ind] = key_list[inds[ind]]
1104	inputs[key] = temp_key
1105	else:
1106	inputs[key] = []
1107
1108	return inputs, outputs
1109
1110	def add_column(self):
1111	"""
1112	Append a new column to the grid
1113	"""
1114
1115	# I Believe this is no longer used now that we have removed the
1116	# edit menu from the menubar - PDB July 12, 2015
1117	pos = self.GetSelection()
1118	grid = self.GetPage(pos)
1119	grid.AppendCols(1, True)
1120
1121	def on_remove_column(self):
1122	"""
1123	Remove the selected column from the grid
1124	"""
1125	# I Believe this is no longer used now that we have removed the
1126	# edit menu from the menubar - PDB July 12, 2015
1127	pos = self.GetSelection()
1128	grid = self.GetPage(pos)
1129	grid.on_remove_column(event=None)
1130
1131	class GridPanel(SPanel):
1132	"""
1133	A ScrolledPanel class that contains the grid sheet as well as a number of
1134	widgets to create interesting plots and buttons for help etc.
1135	"""
1136
1137	def __init__(self, parent, data_inputs=None,
1138	data_outputs=None, args, *kwds):
1139	"""
1140	Initialize the GridPanel
1141	"""
1142
1143	SPanel.__init__(self, parent, args, *kwds)
1144
1145	self.vbox = wx.BoxSizer(wx.VERTICAL)
1146
1147	self.plotting_sizer = wx.FlexGridSizer(3, 7, 10, 5)
1148	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1149	self.grid_sizer = wx.BoxSizer(wx.HORIZONTAL)
1150	self.vbox.AddMany([(self.grid_sizer, 1, wx.EXPAND, 0),
1151	(wx.StaticLine(self, -1), 0, wx.EXPAND, 0),
1152	(self.plotting_sizer),
1153	(self.button_sizer, 0, wx.BOTTOM, 10)])
1154	self.parent = parent
1155	self._data_inputs = data_inputs
1156	self._data_outputs = data_outputs
1157	self.x = []
1158	self.y = []
1159	self.dy = []
1160	self.x_axis_label = None
1161	self.y_axis_label = None
1162	self.dy_axis_label = None
1163	self.x_axis_title = None
1164	self.y_axis_title = None
1165	self.x_axis_unit = None
1166	self.y_axis_unit = None
1167	self.view_button = None
1168	self.plot_button = None
1169	self.notebook = None
1170	self.plot_num = 1
1171
1172	self.layout_grid()
1173	self.layout_plotting_area()
1174	self.SetSizer(self.vbox)
1175
1176	def set_xaxis(self, label="", x=None):
1177	"""
1178	"""
1179	if x is None:
1180	x = []
1181	self.x = x
1182	self.x_axis_label.SetValue("%s[:]" % str(label))
1183	self.x_axis_title.SetValue(str(label))
1184
1185	def set_yaxis(self, label="", y=None):
1186	"""
1187	"""
1188	if y is None:
1189	y = []
1190	self.y = y
1191	self.y_axis_label.SetValue("%s[:]" % str(label))
1192	self.y_axis_title.SetValue(str(label))
1193
1194	def set_dyaxis(self, label="", dy=None):
1195	"""
1196	"""
1197	if dy is None:
1198	dy = []
1199	self.dy = dy
1200	self.dy_axis_label.SetValue("%s[:]" % str(label))
1201
1202	def get_plot_axis(self, col, list):
1203	"""
1204	"""
1205	axis = []
1206	pos = self.notebook.GetSelection()
1207	grid = self.notebook.GetPage(pos)
1208	for row in list:
1209	label = grid.GetCellValue(0, col)
1210	value = grid.GetCellValue(row - 1, col).strip()
1211	if value != "":
1212	if label.lower().strip() == "data":
1213	axis.append(float(row - 1))
1214	else:
1215	try:
1216	axis.append(float(value))
1217	except:
1218	msg = "Invalid data in row %s column %s" % (str(row), str(col))
1219	wx.PostEvent(self.parent.parent,
1220	StatusEvent(status=msg, info="error"))
1221	return None
1222	else:
1223	axis.append(None)
1224	return axis
1225
1226	def on_view(self, event):
1227	"""
1228	Get object represented by the given cells and plot them. Basically
1229	plot the colum in y vs the column in x.
1230	"""
1231
1232	pos = self.notebook.GetSelection()
1233	grid = self.notebook.GetPage(pos)
1234	title = self.notebook.GetPageText(pos)
1235	self.notebook.get_highlighted_row(False)
1236	if len(grid.selected_cells) == 0:
1237	msg = "Highlight a Data or Chi2 column first..."
1238	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1239	return
1240	elif len(grid.selected_cells) > 20:
1241	msg = "Too many data (> 20) to plot..."
1242	msg += "\n Please select no more than 20 data."
1243	wx.MessageDialog(self, msg, 'Plotting', wx.OK)
1244	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1245	return
1246
1247	for cell in grid.selected_cells:
1248	row, col = cell
1249	label_row = 0
1250	label = grid.GetCellValue(label_row, col)
1251	if label in grid.data:
1252	values = grid.data[label]
1253	if row > len(values) or row < 1:
1254	msg = "Invalid cell was chosen."
1255	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1256	continue
1257	else:
1258	value = values[row - 1]
1259	if issubclass(value.__class__, BatchCell):
1260	if value.object is None or len(value.object) == 0:
1261	msg = "Row %s , " % str(row)
1262	msg += "Column %s is NOT " % str(label)
1263	msg += "the results of fits to view..."
1264	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1265	return
1266	for new_plot in value.object:
1267	if new_plot is None or \
1268	not issubclass(new_plot.__class__,
1269	plottables.Plottable):
1270	msg = "Row %s , " % str(row)
1271	msg += "Column %s is NOT " % str(label)
1272	msg += "the results of fits to view..."
1273	wx.PostEvent(self.parent.parent,
1274	StatusEvent(status=msg, info="error"))
1275	return
1276	if issubclass(new_plot.__class__, Data1D):
1277	if label in grid.list_plot_panels.keys():
1278	group_id = grid.list_plot_panels[label]
1279	else:
1280	group_id = str(new_plot.group_id) + str(grid.uid)
1281	grid.list_plot_panels[label] = group_id
1282	if group_id not in new_plot.list_group_id:
1283	new_plot.group_id = group_id
1284	new_plot.list_group_id.append(group_id)
1285	else:
1286	if label.lower() in ["data", "chi2"]:
1287	if len(grid.selected_cells) != 1:
1288	msg = "2D View: Please select one data set"
1289	msg += " at a time for View Fit Results."
1290	wx.PostEvent(self.parent.parent,
1291	StatusEvent(status=msg, info="error"))
1292	return
1293
1294	wx.PostEvent(self.parent.parent,
1295	NewPlotEvent(plot=new_plot,
1296	group_id=str(new_plot.group_id),
1297	title=title))
1298	msg = "Plotting the View Fit Results completed!"
1299	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
1300	else:
1301	msg = "Row %s , " % str(row)
1302	msg += "Column %s is NOT " % str(label)
1303	msg += "the results of fits to view..."
1304	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1305	return
1306
1307	def on_plot(self, event):
1308	"""
1309	Evaluate the contains of textcrtl and plot result
1310	"""
1311
1312	pos = self.notebook.GetSelection()
1313	grid = self.notebook.GetPage(pos)
1314	column_names = {}
1315	if grid is not None:
1316	column_names = self.notebook.get_column_labels()
1317	#evaluate x
1318	sentence = self.x_axis_label.GetValue()
1319	try:
1320	if sentence.strip() == "":
1321	msg = "Select column values for x axis"
1322	raise ValueError, msg
1323	except:
1324	msg = "X axis value error."
1325	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1326	return
1327	dict = parse_string(sentence, column_names.keys())
1328
1329	try:
1330	sentence = self.get_sentence(dict, sentence, column_names)
1331	x = eval(sentence)
1332	except:
1333	msg = "Need a proper x-range."
1334	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1335	return
1336	#evaluate y
1337	sentence = self.y_axis_label.GetValue()
1338	try:
1339	if sentence.strip() == "":
1340	msg = "select value for y axis"
1341	raise ValueError, msg
1342	except:
1343	msg = "Y axis value error."
1344	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1345	return
1346	dict = parse_string(sentence, column_names.keys())
1347	try:
1348	sentence = self.get_sentence(dict, sentence, column_names)
1349	y = eval(sentence)
1350	except:
1351	msg = "Need a proper y-range."
1352	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1353	return
1354	#evaluate y
1355	sentence = self.dy_axis_label.GetValue()
1356	dy = None
1357	if sentence.strip() != "":
1358	dict = parse_string(sentence, column_names.keys())
1359	sentence = self.get_sentence(dict, sentence, column_names)
1360	try:
1361	dy = eval(sentence)
1362	except:
1363	msg = "Need a proper dy-range."
1364	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1365	return
1366	if len(x) != len(y) or (len(x) == 0 or len(y) == 0):
1367	msg = "Need same length for X and Y axis and both greater than 0"
1368	msg += " to plot.\n"
1369	msg += "Got X length = %s, Y length = %s" % (str(len(x)), str(len(y)))
1370	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1371	return
1372	if dy != None and (len(y) != len(dy)):
1373	msg = "Need same length for Y and dY axis and both greater than 0"
1374	msg += " to plot.\n"
1375	msg += "Got Y length = %s, dY length = %s" % (str(len(y)), str(len(dy)))
1376	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1377	return
1378	if dy == None:
1379	dy = numpy.zeros(len(y))
1380	#plotting
1381	new_plot = Data1D(x=x, y=y, dy=dy)
1382	new_plot.id = wx.NewId()
1383	new_plot.is_data = False
1384	new_plot.group_id = wx.NewId()
1385	y_title = self.y_axis_title.GetValue()
1386	x_title = self.x_axis_title.GetValue()
1387	title = "%s_vs_%s" % (y_title, x_title)
1388	new_plot.xaxis(x_title, self.x_axis_unit.GetValue())
1389	new_plot.yaxis(y_title, self.y_axis_unit.GetValue())
1390	try:
1391	title = y_title.strip()
1392	title += "_" + self.notebook.GetPageText(pos)
1393	title += "_" + str(self.plot_num)
1394	self.plot_num += 1
1395	new_plot.name = title
1396	new_plot.xtransform = "x"
1397	new_plot.ytransform = "y"
1398	wx.PostEvent(self.parent.parent,
1399	NewPlotEvent(plot=new_plot,
1400	group_id=str(new_plot.group_id), title=title))
1401	msg = "Plotting completed!"
1402	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
1403	self.parent.parent.update_theory(data_id=new_plot.id, theory=new_plot)
1404	except:
1405	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1406
1407	def on_help(self, event):
1408	"""
1409	Bring up the Batch Grid Panel Usage Documentation whenever
1410	the HELP button is clicked.
1411
1412	Calls DocumentationWindow with the path of the location within the
1413	documentation tree (after /doc/ ....". Note that when using old
1414	versions of Wx (before 2.9) and thus not the release version of
1415	installers, the help comes up at the top level of the file as
1416	webbrowser does not pass anything past the # to the browser when it is
1417	running "file:///...."
1418
1419	:param evt: Triggers on clicking the help button
1420	"""
1421
1422	#import documentation window here to avoid circular imports
1423	#if put at top of file with rest of imports.
1424	from documentation_window import DocumentationWindow
1425
1426	_TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html"
1427	_PageAnchor = "#batch-fit-mode"
1428	_doc_viewer = DocumentationWindow(self, -1, _TreeLocation, _PageAnchor,
1429	"Batch Mode Help")
1430
1431	def get_sentence(self, dict, sentence, column_names):
1432	"""
1433	Get sentence from dict
1434	"""
1435
1436	for tok, (col_name, list) in dict.iteritems():
1437	col = column_names[col_name]
1438	axis = self.get_plot_axis(col, list)
1439	if axis == None:
1440	return None
1441	sentence = sentence.replace(tok, "numpy.array(%s)" % str(axis))
1442	for key, value in FUNC_DICT.iteritems():
1443	sentence = sentence.replace(key.lower(), value)
1444	return sentence
1445
1446	def layout_grid(self):
1447	"""
1448	Draw the area related to the grid by adding it as the first element
1449	in the panel's grid_sizer
1450	"""
1451
1452	self.notebook = Notebook(parent=self)
1453	self.notebook.set_data(self._data_inputs, self._data_outputs)
1454	self.grid_sizer.Add(self.notebook, 1, wx.EXPAND, 0)
1455
1456	def layout_plotting_area(self):
1457	"""
1458	Add the area containing all the plot options, buttons etc to a plotting
1459	area sizer to later be added to the top level grid_sizer
1460	"""
1461
1462	view_description = wx.StaticBox(self, -1, 'Plot Fits/Residuals')
1463	note = "To plot the fits (or residuals), click the 'View Fits' button"
1464	note += "\n after highlighting the Data names (or Chi2 values)."
1465	note_text = wx.StaticText(self, -1, note)
1466	boxsizer1 = wx.StaticBoxSizer(view_description, wx.HORIZONTAL)
1467	self.x_axis_title = wx.TextCtrl(self, -1)
1468	self.y_axis_title = wx.TextCtrl(self, -1)
1469	self.x_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
1470	self.y_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
1471	self.dy_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
1472	self.x_axis_add = wx.Button(self, -1, "Add")
1473	self.x_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
1474	id=self.x_axis_add.GetId())
1475	self.y_axis_add = wx.Button(self, -1, "Add")
1476	self.y_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
1477	id=self.y_axis_add.GetId())
1478	self.dy_axis_add = wx.Button(self, -1, "Add")
1479	self.dy_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis,
1480	id=self.dy_axis_add.GetId())
1481	self.x_axis_unit = wx.TextCtrl(self, -1)
1482	self.y_axis_unit = wx.TextCtrl(self, -1)
1483	self.view_button = wx.Button(self, -1, "View Fits")
1484	view_tip = "Highlight the data set or the Chi2 column first."
1485	self.view_button.SetToolTipString(view_tip)
1486	wx.EVT_BUTTON(self, self.view_button.GetId(), self.on_view)
1487	self.plot_button = wx.Button(self, -1, "Plot")
1488	plot_tip = "Highlight a column for each axis and \n"
1489	plot_tip += "click the Add buttons first."
1490
1491	self.plot_button.SetToolTipString(plot_tip)
1492
1493	self.help_button = wx.Button(self, -1, "HELP")
1494	self.help_button.SetToolTipString("Get Help for Batch Mode")
1495	self.help_button.Bind(wx.EVT_BUTTON, self.on_help)
1496
1497	boxsizer1.AddMany([(note_text, 0, wx.LEFT, 10),
1498	(self.view_button, 0, wx.LEFT \| wx.RIGHT, 10)])
1499	self.button_sizer.AddMany([(boxsizer1, 0,
1500	wx.LEFT \| wx.RIGHT \| wx.BOTTOM, 10),
1501	(self.plot_button, 0,
1502	wx.LEFT \| wx.TOP \| wx.BOTTOM, 12),
1503	(self.help_button,0,
1504	wx.LEFT \| wx.TOP \| wx.BOTTOM, 12)])
1505
1506	wx.EVT_BUTTON(self, self.plot_button.GetId(), self.on_plot)
1507	self.plotting_sizer.AddMany(\
1508	[(wx.StaticText(self, -1, "X-axis Label\nSelection Range"), 1,
1509	wx.TOP \| wx.BOTTOM \| wx.LEFT, 10),
1510	(self.x_axis_label, 1, wx.TOP \| wx.BOTTOM, 10),
1511	(self.x_axis_add, 1, wx.TOP \| wx.BOTTOM \| wx.RIGHT, 10),
1512	(wx.StaticText(self, -1, "X-axis Label"), 1, wx.TOP \| wx.BOTTOM \| wx.LEFT, 10),
1513	(self.x_axis_title, 1, wx.TOP \| wx.BOTTOM, 10),
1514	(wx.StaticText(self, -1, "X-axis Unit"), 1, wx.TOP \| wx.BOTTOM, 10),
1515	(self.x_axis_unit, 1, wx.TOP \| wx.BOTTOM, 10),
1516	(wx.StaticText(self, -1, "Y-axis Label\nSelection Range"), 1,
1517	wx.BOTTOM \| wx.LEFT, 10),
1518	(self.y_axis_label, wx.BOTTOM, 10),
1519	(self.y_axis_add, 1, wx.BOTTOM \| wx.RIGHT, 10),
1520	(wx.StaticText(self, -1, "Y-axis Label"), 1,
1521	wx.BOTTOM \| wx.LEFT, 10),
1522	(self.y_axis_title, wx.BOTTOM, 10),
1523	(wx.StaticText(self, -1, "Y-axis Unit"), 1, wx.BOTTOM, 10),
1524	(self.y_axis_unit, 1, wx.BOTTOM, 10),
1525	(wx.StaticText(self, -1, "dY-Bar (Optional)\nSelection Range"),
1526	1, wx.BOTTOM \| wx.LEFT, 10),
1527	(self.dy_axis_label, wx.BOTTOM, 10),
1528	(self.dy_axis_add, 1, wx.BOTTOM \| wx.RIGHT, 10),
1529	(-1, -1),
1530	(-1, -1),
1531	(-1, -1),
1532	(-1, 1)])
1533
1534	def on_edit_axis(self, event):
1535	"""
1536	Get the selected column on the visible grid and set values for axis
1537	"""
1538
1539	try:
1540	cell_list = self.notebook.on_edit_axis()
1541	label, title = self.create_axis_label(cell_list)
1542	except:
1543	msg = str(sys.exc_value)
1544	wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error"))
1545	return
1546	tcrtl = event.GetEventObject()
1547	if tcrtl == self.x_axis_add:
1548	self.edit_axis_helper(self.x_axis_label, self.x_axis_title, label, title)
1549	elif tcrtl == self.y_axis_add:
1550	self.edit_axis_helper(self.y_axis_label, self.y_axis_title, label, title)
1551	elif tcrtl == self.dy_axis_add:
1552	self.edit_axis_helper(self.dy_axis_label, None, label, None)
1553
1554	def create_axis_label(self, cell_list):
1555	"""
1556	Receive a list of cells and create a string presenting the selected
1557	cells.
1558
1559	:param cell_list: list of tuple
1560	"""
1561
1562	if self.notebook is not None:
1563	return self.notebook.create_axis_label(cell_list)
1564
1565	def edit_axis_helper(self, tcrtl_label, tcrtl_title, label, title):
1566	"""
1567	get controls to modify
1568	"""
1569
1570	if label != None:
1571	tcrtl_label.SetValue(str(label))
1572	if title != None:
1573	tcrtl_title.SetValue(str(title))
1574
1575	def add_column(self):
1576	"""
1577	"""
1578	# I Believe this is no longer used now that we have removed the
1579	# edit menu from the menubar - PDB July 12, 2015
1580	if self.notebook is not None:
1581	self.notebook.add_column()
1582
1583	def on_remove_column(self):
1584	"""
1585	"""
1586	# I Believe this is no longer used now that we have removed the
1587	# edit menu from the menubar - PDB July 12, 2015
1588	if self.notebook is not None:
1589	self.notebook.on_remove_column()
1590
1591
1592	class GridFrame(wx.Frame):
1593	"""
1594	The main wx.Frame for the batch results grid
1595	"""
1596
1597	def __init__(self, parent=None, data_inputs=None, data_outputs=None, id=-1,
1598	title="Batch Fitting Results Panel", size=(800, 500)):
1599	"""
1600	Initialize the Frame
1601	"""
1602
1603	wx.Frame.__init__(self, parent=parent, id=id, title=title, size=size)
1604	self.parent = parent
1605	self.panel = GridPanel(self, data_inputs, data_outputs)
1606	menubar = wx.MenuBar()
1607	self.SetMenuBar(menubar)
1608
1609	self.curr_col = None
1610	self.curr_grid = None
1611	self.curr_col_name = ""
1612	self.file = wx.Menu()
1613	menubar.Append(self.file, "&File")
1614
1615	hint = "Open file containing batch results"
1616	open_menu = self.file.Append(wx.NewId(), 'Open ', hint)
1617	wx.EVT_MENU(self, open_menu.GetId(), self.on_open)
1618
1619	hint = "Open the the current grid into excel"
1620	self.open_excel_menu = self.file.Append(wx.NewId(), 'Open with Excel', hint)
1621	wx.EVT_MENU(self, self.open_excel_menu.GetId(), self.open_with_excel)
1622	self.file.AppendSeparator()
1623	self.save_menu = self.file.Append(wx.NewId(), 'Save As', 'Save into File')
1624	wx.EVT_MENU(self, self.save_menu.GetId(), self.on_save_page)
1625
1626	# We need to grab a WxMenu handle here, otherwise the next one to grab
1627	# the handle will be treated as the Edit Menu handle when checking in
1628	# on_menu_open event handler and thus raise an exception when it hits an
1629	# unitialized object. Alternative is to comment out that whole section
1630	# in on_menu_open, but that would make it more difficult to undo the
1631	# hidding of the menu. PDB July 12, 2015.
1632	#
1633	# To enable the Edit menubar comment out next line and uncomment the
1634	# following line.
1635	self.edit = wx.Menu()
1636	#self.add_edit_menu()
1637
1638	self.Bind(wx.EVT_MENU_OPEN, self.on_menu_open)
1639	self.Bind(wx.EVT_CLOSE, self.on_close)
1640
1641	def add_edit_menu(self, menubar):
1642	"""
1643	populates the edit menu on the menubar. Not activated as of SasView
1644	3.1.0
1645	"""
1646	self.edit = wx.Menu()
1647
1648	add_table_menu = self.edit.Append(-1, 'New Table',
1649	'Add a New Table')
1650	self.edit.AppendSeparator()
1651	wx.EVT_MENU(self, add_table_menu.GetId(), self.add_table)
1652
1653	self.copy_menu = self.edit.Append(-1, 'Copy',
1654	'Copy the selected cells')
1655	wx.EVT_MENU(self, self.copy_menu.GetId(), self.on_copy)
1656	self.paste_menu = self.edit.Append(-1, 'Paste',
1657	'Paste the selected Cells')
1658	wx.EVT_MENU(self, self.paste_menu.GetId(), self.on_paste)
1659	self.clear_menu = self.edit.Append(-1, 'Clear',
1660	'Clear the selected Cells')
1661	wx.EVT_MENU(self, self.clear_menu.GetId(), self.on_clear)
1662
1663	self.edit.AppendSeparator()
1664	hint = "Insert column before the selected column"
1665	self.insert_before_menu = wx.Menu()
1666	self.insertb_sub_menu = self.edit.AppendSubMenu(self.insert_before_menu,
1667	'Insert Before', hint)
1668	hint = "Insert column after the selected column"
1669	self.insert_after_menu = wx.Menu()
1670	self.inserta_sub_menu = self.edit.AppendSubMenu(self.insert_after_menu,
1671	'Insert After', hint)
1672	hint = "Remove the selected column"
1673	self.remove_menu = self.edit.Append(-1, 'Remove Column', hint)
1674	wx.EVT_MENU(self, self.remove_menu.GetId(), self.on_remove_column)
1675	menubar.Append(self.edit, "&Edit")
1676
1677	def on_copy(self, event):
1678	"""
1679	On Copy from the Edit menu item on the menubar
1680	"""
1681	# I Believe this is no longer used now that we have removed the
1682	# edit menu from the menubar - PDB July 12, 2015
1683	if event != None:
1684	event.Skip()
1685	pos = self.panel.notebook.GetSelection()
1686	grid = self.panel.notebook.GetPage(pos)
1687	grid.Copy()
1688
1689	def on_paste(self, event):
1690	"""
1691	On Paste from the Edit menu item on the menubar
1692	"""
1693	# I Believe this is no longer used now that we have removed the
1694	# edit menu from the menubar - PDB July 12, 2015
1695	if event != None:
1696	event.Skip()
1697	pos = self.panel.notebook.GetSelection()
1698	grid = self.panel.notebook.GetPage(pos)
1699	grid.on_paste(None)
1700
1701	def on_clear(self, event):
1702	"""
1703	On Clear from the Edit menu item on the menubar
1704	"""
1705	# I Believe this is no longer used now that we have removed the
1706	# edit menu from the menubar - PDB July 12, 2015
1707	pos = self.panel.notebook.GetSelection()
1708	grid = self.panel.notebook.GetPage(pos)
1709	grid.Clear()
1710
1711	def GetLabelText(self, id):
1712	"""
1713	Get Label Text
1714	"""
1715	for item in self.insert_before_menu.GetMenuItems():
1716	m_id = item.GetId()
1717	if m_id == id:
1718	return item.GetLabel()
1719
1720	def on_remove_column(self, event):
1721	"""
1722	On remove column from the Edit menu Item on the menubar
1723	"""
1724	# I Believe this is no longer used now that we have removed the
1725	# edit menu from the menubar - PDB July 12, 2015
1726	pos = self.panel.notebook.GetSelection()
1727	grid = self.panel.notebook.GetPage(pos)
1728	grid.on_remove_column(event=None)
1729
1730	def on_menu_open(self, event):
1731	"""
1732	On menu open
1733	"""
1734	if self.file == event.GetMenu():
1735	pos = self.panel.notebook.GetSelection()
1736	grid = self.panel.notebook.GetPage(pos)
1737	has_data = (grid.data != None and grid.data != {})
1738	self.open_excel_menu.Enable(has_data)
1739	self.save_menu.Enable(has_data)
1740
1741	if self.edit == event.GetMenu():
1742	#get the selected column
1743	pos = self.panel.notebook.GetSelection()
1744	grid = self.panel.notebook.GetPage(pos)
1745	col_list = grid.GetSelectedCols()
1746	has_selection = False
1747	selected_cel = grid.selected_cells
1748	if len(selected_cel) > 0:
1749	_row, _col = selected_cel[0]
1750	has_selection = grid.IsInSelection(_row, _col)
1751	if len(grid.selected_cols) > 0:
1752	has_selection = True
1753	if len(grid.selected_rows) > 0:
1754	has_selection = True
1755	self.copy_menu.Enable(has_selection)
1756	self.clear_menu.Enable(has_selection)
1757
1758	if len(col_list) > 0:
1759	self.remove_menu.Enable(True)
1760	else:
1761	self.remove_menu.Enable(False)
1762	if len(col_list) == 0 or len(col_list) > 1:
1763	self.insertb_sub_menu.Enable(False)
1764	self.inserta_sub_menu.Enable(False)
1765	label = "Insert Column Before"
1766	self.insertb_sub_menu.SetText(label)
1767	label = "Insert Column After"
1768	self.inserta_sub_menu.SetText(label)
1769	else:
1770	self.insertb_sub_menu.Enable(True)
1771	self.inserta_sub_menu.Enable(True)
1772
1773	col = col_list[0]
1774	col_name = grid.GetCellValue(row=0, col=col)
1775	label = "Insert Column Before " + str(col_name)
1776	self.insertb_sub_menu.SetText(label)
1777	for item in self.insert_before_menu.GetMenuItems():
1778	self.insert_before_menu.DeleteItem(item)
1779	grid.insert_col_menu(menu=self.insert_before_menu,
1780	label=col_name, window=self)
1781	label = "Insert Column After " + str(col_name)
1782	self.inserta_sub_menu.SetText(label)
1783	for item in self.insert_after_menu.GetMenuItems():
1784	self.insert_after_menu.DeleteItem(item)
1785	grid.insert_after_col_menu(menu=self.insert_after_menu,
1786	label=col_name, window=self)
1787	event.Skip()
1788
1789
1790
1791	def on_save_page(self, event):
1792	"""
1793	Saves data in grid to a csv file.
1794
1795	At this time only the columns displayed get saved. Thus any error
1796	bars not inserted before saving will not be saved in the file
1797	"""
1798
1799	if self.parent is not None:
1800	pos = self.panel.notebook.GetSelection()
1801	grid = self.panel.notebook.GetPage(pos)
1802	if grid.file_name is None or grid.file_name.strip() == "" or \
1803	grid.data is None or len(grid.data) == 0:
1804	name = self.panel.notebook.GetPageText(pos)
1805	msg = " %s has not data to save" % str(name)
1806	wx.PostEvent(self.parent,
1807	StatusEvent(status=msg, info="error"))
1808
1809	return
1810	reader, ext = os.path.splitext(grid.file_name)
1811	path = None
1812	if self.parent is not None:
1813	location = os.path.dirname(grid.file_name)
1814	dlg = wx.FileDialog(self, "Save Project file",
1815	location, grid.file_name, ext, wx.SAVE)
1816	path = None
1817	if dlg.ShowModal() == wx.ID_OK:
1818	path = dlg.GetPath()
1819	dlg.Destroy()
1820	if path != None:
1821	if self.parent is not None:
1822	data = grid.get_grid_view()
1823	self.parent.write_batch_tofile(data=data,
1824	file_name=path,
1825	details=grid.details)
1826
1827	def on_open(self, event):
1828	"""
1829	Open file containing batch result
1830	"""
1831
1832	if self.parent is not None:
1833	self.parent.on_read_batch_tofile(self)
1834
1835	def open_with_excel(self, event):
1836	"""
1837	open excel and display batch result in Excel
1838	"""
1839
1840	if self.parent is not None:
1841	pos = self.panel.notebook.GetSelection()
1842	grid = self.panel.notebook.GetPage(pos)
1843	data = grid.get_grid_view()
1844	if grid.file_name is None or grid.file_name.strip() == "" or \
1845	grid.data is None or len(grid.data) == 0:
1846	name = self.panel.notebook.GetPageText(pos)
1847	msg = " %s has not data to open on excel" % str(name)
1848	wx.PostEvent(self.parent,
1849	StatusEvent(status=msg, info="error"))
1850
1851	return
1852	self.parent.open_with_externalapp(data=data,
1853	file_name=grid.file_name,
1854	details=grid.details)
1855
1856	def on_close(self, event):
1857	"""
1858	"""
1859	self.Hide()
1860
1861	def on_append_column(self, event):
1862	"""
1863	Append a new column to the grid
1864	"""
1865	self.panel.add_column()
1866
1867	def set_data(self, data_inputs, data_outputs, details="", file_name=None):
1868	"""
1869	Set data
1870	"""
1871	self.panel.notebook.set_data(data_inputs=data_inputs,
1872	file_name=file_name,
1873	details=details,
1874	data_outputs=data_outputs)
1875
1876	def add_table(self, event):
1877	"""
1878	Add a new table
1879	"""
1880	# DO not event.Skip(): it will make 2 pages
1881	self.panel.notebook.add_empty_page()
1882
1883	class BatchOutputFrame(wx.Frame):
1884	"""
1885	Allow to select where the result of batch will be displayed or stored
1886	"""
1887	def __init__(self, parent, data_inputs, data_outputs, file_name="",
1888	details="", args, *kwds):
1889	"""
1890	Initialize dialog
1891
1892	:param parent: Window instantiating this dialog
1893	:param result: result to display in a grid or export to an external\
1894	application.
1895	"""
1896
1897	#kwds['style'] = wx.CAPTION\|wx.SYSTEM_MENU
1898	wx.Frame.__init__(self, parent, args, *kwds)
1899	self.parent = parent
1900	self.panel = wx.Panel(self)
1901	self.file_name = file_name
1902	self.details = details
1903	self.data_inputs = data_inputs
1904	self.data_outputs = data_outputs
1905	self.data = {}
1906	for item in (self.data_outputs, self.data_inputs):
1907	self.data.update(item)
1908	self.flag = 1
1909	self.SetSize((300, 200))
1910	self.local_app_selected = None
1911	self.external_app_selected = None
1912	self.save_to_file = None
1913	self._do_layout()
1914
1915	def _do_layout(self):
1916	"""
1917	Draw the content of the current dialog window
1918	"""
1919
1920	vbox = wx.BoxSizer(wx.VERTICAL)
1921	box_description = wx.StaticBox(self.panel, -1, str("Batch Outputs"))
1922	hint_sizer = wx.StaticBoxSizer(box_description, wx.VERTICAL)
1923	selection_sizer = wx.GridBagSizer(5, 5)
1924	button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1925	text = "Open with %s" % self.parent.application_name
1926	self.local_app_selected = wx.RadioButton(self.panel, -1, text, style=wx.RB_GROUP)
1927	self.Bind(wx.EVT_RADIOBUTTON, self.onselect,
1928	id=self.local_app_selected.GetId())
1929	text = "Open with Excel"
1930	self.external_app_selected = wx.RadioButton(self.panel, -1, text)
1931	self.Bind(wx.EVT_RADIOBUTTON, self.onselect, id=self.external_app_selected.GetId())
1932	text = "Save to File"
1933	self.save_to_file = wx.CheckBox(self.panel, -1, text)
1934	self.Bind(wx.EVT_CHECKBOX, self.onselect, id=self.save_to_file.GetId())
1935	self.local_app_selected.SetValue(True)
1936	self.external_app_selected.SetValue(False)
1937	self.save_to_file.SetValue(False)
1938	button_close = wx.Button(self.panel, -1, "Close")
1939	button_close.Bind(wx.EVT_BUTTON, id=button_close.GetId(), handler=self.on_close)
1940	button_apply = wx.Button(self.panel, -1, "Apply")
1941	button_apply.Bind(wx.EVT_BUTTON, id=button_apply.GetId(), handler=self.on_apply)
1942	button_apply.SetFocus()
1943	hint = ""
1944	hint_sizer.Add(wx.StaticText(self.panel, -1, hint))
1945	hint_sizer.Add(selection_sizer)
1946	#draw area containing radio buttons
1947	ix = 0
1948	iy = 0
1949	selection_sizer.Add(self.local_app_selected, (iy, ix),
1950	(1, 1), wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
1951	iy += 1
1952	selection_sizer.Add(self.external_app_selected, (iy, ix),
1953	(1, 1), wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
1954	iy += 1
1955	selection_sizer.Add(self.save_to_file, (iy, ix),
1956	(1, 1), wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
1957	#contruction the sizer contaning button
1958	button_sizer.Add((20, 20), 1, wx.EXPAND \| wx.ADJUST_MINSIZE, 0)
1959
1960	button_sizer.Add(button_close, 0,
1961	wx.LEFT \| wx.EXPAND \| wx.ADJUST_MINSIZE, 15)
1962	button_sizer.Add(button_apply, 0,
1963	wx.LEFT \| wx.RIGHT \| wx.ADJUST_MINSIZE, 10)
1964	vbox.Add(hint_sizer, 0, wx.EXPAND \| wx.ALL, 10)
1965	vbox.Add(wx.StaticLine(self.panel, -1), 0, wx.EXPAND, 0)
1966	vbox.Add(button_sizer, 0, wx.TOP \| wx.BOTTOM, 10)
1967	self.SetSizer(vbox)
1968
1969	def on_apply(self, event):
1970	"""
1971	Get the user selection and display output to the selected application
1972	"""
1973
1974	if self.flag == 1:
1975	self.parent.open_with_localapp(data_inputs=self.data_inputs,
1976	data_outputs=self.data_outputs)
1977	elif self.flag == 2:
1978	self.parent.open_with_externalapp(data=self.data,
1979	file_name=self.file_name,
1980	details=self.details)
1981	def on_close(self, event):
1982	"""
1983	close the Window
1984	"""
1985
1986	self.Close()
1987
1988	def onselect(self, event=None):
1989	"""
1990	Receive event and display data into third party application
1991	or save data to file.
1992	"""
1993	if self.save_to_file.GetValue():
1994	_, ext = os.path.splitext(self.file_name)
1995	path = None
1996	location = os.getcwd()
1997	if self.parent is not None:
1998	location = os.path.dirname(self.file_name)
1999	dlg = wx.FileDialog(self, "Save Project file",
2000	location, self.file_name, ext, wx.SAVE)
2001	path = None
2002	if dlg.ShowModal() == wx.ID_OK:
2003	path = dlg.GetPath()
2004	dlg.Destroy()
2005	if path != None:
2006	if self.parent is not None and self.data is not None:
2007	self.parent.write_batch_tofile(data=self.data,
2008	file_name=path,
2009	details=self.details)
2010	if self.local_app_selected.GetValue():
2011	self.flag = 1
2012	else:
2013	self.flag = 2
2014	return self.flag
2015
2016
2017
2018	if __name__ == "__main__":
2019	app = wx.App()
2020
2021	try:
2022	data = {}
2023	j = 0
2024	for i in range(4):
2025	j += 1
2026	data["index" + str(i)] = [i / j, i * j, i, i + j]
2027
2028	data_input = copy.deepcopy(data)
2029	data_input["index5"] = [10, 20, 40, 50]
2030	frame = GridFrame(data_outputs=data, data_inputs=data_input)
2031	frame.Show(True)
2032	except:
2033	print sys.exc_value
2034
2035	app.MainLoop()

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

SasView

source: sasview/src/sas/sasgui/guiframe/data_processor.py @ c812d11

Download in other formats: