basepage.py @ 2e95da4

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 2e95da4 was 2e95da4, checked in by Jae Cho <jhjcho@…>, 13 years ago
fixed 2d model default deta: redefine qmax based on real data setting
Property mode set to `100644`
File size: 115.7 KB

Line
1
2	import sys
3	import os
4	import wx
5	import numpy
6	import time
7	import copy
8	import math
9	import string
10	from wx.lib.scrolledpanel import ScrolledPanel
11	from sans.guiframe.panel_base import PanelBase
12	from sans.guiframe.utils import format_number,check_float
13	from sans.guiframe.events import PanelOnFocusEvent
14	from sans.guiframe.events import StatusEvent
15	from sans.guiframe.events import AppendBookmarkEvent
16	from sans.guiframe.dataFitting import Data2D
17	from sans.guiframe.dataFitting import Data1D
18	from sans.guiframe.dataFitting import check_data_validity
19	from sans.dataloader.data_info import Detector
20	from sans.dataloader.data_info import Source
21	import pagestate
22	from pagestate import PageState
23
24	(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
25	(PreviousStateEvent, EVT_PREVIOUS_STATE) = wx.lib.newevent.NewEvent()
26	(NextStateEvent, EVT_NEXT_STATE) = wx.lib.newevent.NewEvent()
27
28	_BOX_WIDTH = 76
29	_QMIN_DEFAULT = 0.0005
30	_QMAX_DEFAULT = 0.5
31	_NPTS_DEFAULT = 50
32	#Control panel width
33	if sys.platform.count("win32")> 0:
34	PANEL_WIDTH = 450
35	FONT_VARIANT = 0
36	ON_MAC = False
37	else:
38	PANEL_WIDTH = 500
39	FONT_VARIANT = 1
40	ON_MAC = True
41
42
43
44	class BasicPage(ScrolledPanel, PanelBase):
45	"""
46	This class provide general structure of fitpanel page
47	"""
48	## Internal name for the AUI manager
49	window_name = "Fit Page"
50	## Title to appear on top of the window
51	window_caption = "Fit Page "
52
53	def __init__(self, parent,color='blue', **kwargs):
54	"""
55	"""
56	ScrolledPanel.__init__(self, parent, **kwargs)
57	PanelBase.__init__(self, parent)
58	self.SetupScrolling()
59	#Set window's font size
60	self.SetWindowVariant(variant=FONT_VARIANT)
61
62	self.SetBackgroundColour(color)
63	## parent of the page
64	self.parent = parent
65	## manager is the fitting plugin
66	## owner of the page (fitting plugin)
67	self.event_owner = None
68	## current model
69	self.model = None
70	self.index_model = None
71	## data
72	self.data = None
73	#list of available data
74	self.data_list = []
75	self.mask = None
76	self.uid = wx.NewId()
77	#Q range for data set
78	self.qmin_data_set = None
79	self.qmax_data_set = None
80	self.npts_data_set = 0
81	## Q range
82	self.qmin = None
83	self.qmax = None
84	self.qmax_x = _QMAX_DEFAULT
85	self.qmin_x = _QMIN_DEFAULT
86	self.npts_x = _NPTS_DEFAULT
87	## total number of point: float
88	self.npts = None
89	## default fitengine type
90	self.engine_type = 'scipy'
91	## smear default
92	self.current_smearer = None
93	## 2D smear accuracy default
94	self.smear2d_accuracy = 'Low'
95	## slit smear:
96	self.dxl = None
97	self.dxw = None
98	## pinhole smear
99	self.dx_min = None
100	self.dx_max = None
101
102	self.disp_cb_dict = {}
103
104	self.state = PageState(parent=parent)
105	## dictionary containing list of models
106	self.model_list_box = {}
107
108	## Data member to store the dispersion object created
109	self._disp_obj_dict = {}
110	## selected parameters to apply dispersion
111	self.disp_cb_dict ={}
112	## smearer object
113	self.enable2D = False
114	self.is_mac = ON_MAC
115
116	##list of model parameters. each item must have same length
117	## each item related to a given parameters
118	##[cb state, name, value, "+/-", error of fit, min, max , units]
119	self.parameters = []
120	# non-fittable parameter whose value is astring
121	self.str_parameters = []
122	## list of parameters to fit , must be like self.parameters
123	self.param_toFit = []
124	## list of looking like parameters but with non fittable parameters info
125	self.fixed_param = []
126	## list of looking like parameters but with fittable parameters info
127	self.fittable_param = []
128	##list of dispersion parameters
129	self.disp_list = []
130	self.disp_name = ""
131
132	## list of orientation parameters
133	self.orientation_params = []
134	self.orientation_params_disp = []
135	if self.model != None:
136	self.disp_list = self.model.getDispParamList()
137	self.temp_multi_functional = False
138	##enable model 2D draw
139	self.enable2D = False
140	## check that the fit range is correct to plot the model again
141	self.fitrange = True
142	## Create memento to save the current state
143	self.state = PageState(parent=self.parent,
144	model=self.model, data=self.data)
145	## flag to determine if state has change
146	self.state_change = False
147	## save customized array
148	self.values = []
149	self.weights = []
150	## retrieve saved state
151	self.number_saved_state = 0
152	## dictionary of saved state
153	self.saved_states = {}
154	## Create context menu for page
155	self.popUpMenu = wx.Menu()
156
157	id = wx.NewId()
158	self._keep = wx.MenuItem(self.popUpMenu,id,"Add bookmark",
159	" Keep the panel status to recall it later")
160	self.popUpMenu.AppendItem(self._keep)
161	self._keep.Enable(False)
162	self._set_bookmark_flag(False)
163	self._set_save_flag(False)
164	wx.EVT_MENU(self, id, self.on_bookmark)
165	self.popUpMenu.AppendSeparator()
166
167	## Default locations
168	self._default_save_location = os.getcwd()
169	## save initial state on context menu
170	#self.onSave(event=None)
171	self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu)
172
173	# bind key event
174	self.Bind(wx.EVT_LEFT_DOWN, self.on_left_down)
175
176	## create the basic structure of the panel with empty sizer
177	self.define_page_structure()
178	## drawing Initial dispersion parameters sizer
179	self.set_dispers_sizer()
180
181	## layout
182	self.set_layout()
183
184	def set_index_model(self, index):
185	"""
186	Index related to this page
187	"""
188	self.index_model = index
189
190	def create_default_data(self):
191	"""
192	Given the user selection, creates a 1D or 2D data
193	Only when the page is on theory mode.
194	"""
195	if not hasattr(self, "model_view"):
196	return
197	toggle_mode_on = self.model_view.IsEnabled()
198	if toggle_mode_on:
199	if self.enable2D and not check_data_validity(self.data):
200	self._create_default_2d_data()
201	else:
202	self._create_default_1d_data()
203
204	def _create_default_1d_data(self):
205	"""
206	Create default data for fitting perspective
207	Only when the page is on theory mode.
208	:warning: This data is never plotted.
209
210	"""
211	x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x,
212	num=self.npts_x, endpoint=True)
213	self.data = Data1D(x=x)
214	self.data.xaxis('\\rm{Q}',"A^{-1}")
215	self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
216	self.data.is_data = False
217	self.data.id = str(self.uid) + " data"
218	self.data.group_id = str(self.uid) + " Model1D"
219
220	def _create_default_2d_data(self):
221	"""
222	Create 2D data by default
223	Only when the page is on theory mode.
224	:warning: This data is never plotted.
225	"""
226	self.data = Data2D()
227	qmax = self.qmax_x / math.sqrt(2)
228	self.data.xaxis('\\rm{Q_{x}}', 'A^{-1}')
229	self.data.yaxis('\\rm{Q_{y}}', 'A^{-1}')
230	self.data.is_data = False
231	self.data.id = str(self.uid) + " data"
232	self.data.group_id = str(self.uid) + " Model2D"
233	## Default values
234	self.data.detector.append(Detector())
235	index = len(self.data.detector) - 1
236	self.data.detector[index].distance = 8000 # mm
237	self.data.source.wavelength= 6 # A
238	self.data.detector[index].pixel_size.x = 5 # mm
239	self.data.detector[index].pixel_size.y = 5 # mm
240	self.data.detector[index].beam_center.x = qmax
241	self.data.detector[index].beam_center.y = qmax
242	## create x_bins and y_bins of the model 2D
243	pixel_width_x = self.data.detector[index].pixel_size.x
244	pixel_width_y = self.data.detector[index].pixel_size.y
245	center_x = self.data.detector[index].beam_center.x/pixel_width_x
246	center_y = self.data.detector[index].beam_center.y/pixel_width_y
247	# theory default: assume the beam
248	#center is located at the center of sqr detector
249	xmax = qmax
250	xmin = -qmax
251	ymax = qmax
252	ymin = -qmax
253	qstep = self.npts_x
254
255	x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
256	y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
257	## use data info instead
258	new_x = numpy.tile(x, (len(y), 1))
259	new_y = numpy.tile(y, (len(x), 1))
260	new_y = new_y.swapaxes(0,1)
261	# all data reuire now in 1d array
262	qx_data = new_x.flatten()
263	qy_data = new_y.flatten()
264	q_data = numpy.sqrt(qx_dataqx_data + qy_dataqy_data)
265	# set all True (standing for unmasked) as default
266	mask = numpy.ones(len(qx_data), dtype=bool)
267	# calculate the range of qx and qy: this way,
268	# it is a little more independent
269	x_size = xmax - xmin
270	y_size = ymax - ymin
271	# store x and y bin centers in q space
272	x_bins = x
273	y_bins = y
274	# bin size: x- & y-directions
275	xstep = x_size/len(x_bins-1)
276	ystep = y_size/len(y_bins-1)
277
278	self.data.source = Source()
279	self.data.data = numpy.ones(len(mask))
280	self.data.err_data = numpy.ones(len(mask))
281	self.data.qx_data = qx_data
282	self.data.qy_data = qy_data
283	self.data.q_data = q_data
284	self.data.mask = mask
285	self.data.x_bins = x_bins
286	self.data.y_bins = y_bins
287	# max and min taking account of the bin sizes
288	self.data.xmin = xmin
289	self.data.xmax = xmax
290	self.data.ymin = ymin
291	self.data.ymax = ymax
292
293	def on_set_focus(self, event):
294	"""
295	"""
296	if self._manager is not None:
297	wx.PostEvent(self._manager.parent, PanelOnFocusEvent(panel=self))
298
299	class ModelTextCtrl(wx.TextCtrl):
300	"""
301	Text control for model and fit parameters.
302	Binds the appropriate events for user interactions.
303	Default callback methods can be overwritten on initialization
304
305	:param kill_focus_callback: callback method for EVT_KILL_FOCUS event
306	:param set_focus_callback: callback method for EVT_SET_FOCUS event
307	:param mouse_up_callback: callback method for EVT_LEFT_UP event
308	:param text_enter_callback: callback method for EVT_TEXT_ENTER event
309
310	"""
311	## Set to True when the mouse is clicked while the whole string is selected
312	full_selection = False
313	## Call back for EVT_SET_FOCUS events
314	_on_set_focus_callback = None
315
316	def __init__(self, parent, id=-1,
317	value=wx.EmptyString,
318	pos=wx.DefaultPosition,
319	size=wx.DefaultSize,
320	style=0,
321	validator=wx.DefaultValidator,
322	name=wx.TextCtrlNameStr,
323	kill_focus_callback=None,
324	set_focus_callback=None,
325	mouse_up_callback=None,
326	text_enter_callback = None):
327
328	wx.TextCtrl.__init__(self, parent, id, value, pos,
329	size, style, validator, name)
330
331	# Bind appropriate events
332	self._on_set_focus_callback = parent.onSetFocus \
333	if set_focus_callback is None else set_focus_callback
334	self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
335	self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus \
336	if kill_focus_callback is None else kill_focus_callback)
337	self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter \
338	if text_enter_callback is None else text_enter_callback)
339	if not ON_MAC :
340	self.Bind(wx.EVT_LEFT_UP, self._highlight_text \
341	if mouse_up_callback is None else mouse_up_callback)
342
343	def _on_set_focus(self, event):
344	"""
345	Catch when the text control is set in focus to highlight the whole
346	text if necessary
347
348	:param event: mouse event
349
350	"""
351	event.Skip()
352	self.full_selection = True
353	return self._on_set_focus_callback(event)
354
355
356
357	def _highlight_text(self, event):
358	"""
359	Highlight text of a TextCtrl only of no text has be selected
360
361	:param event: mouse event
362
363	"""
364	# Make sure the mouse event is available to other listeners
365	event.Skip()
366	control = event.GetEventObject()
367	if self.full_selection:
368	self.full_selection = False
369	# Check that we have a TextCtrl
370	if issubclass(control.__class__, wx.TextCtrl):
371	# Check whether text has been selected,
372	# if not, select the whole string
373	(start, end) = control.GetSelection()
374	if start==end:
375	control.SetSelection(-1,-1)
376
377	def _silent_kill_focus(self,event):
378	"""
379	Save the state of the page
380	"""
381
382	event.Skip()
383	pass
384
385	def set_page_info(self, page_info):
386	"""
387	set some page important information at once
388	"""
389	##window_name
390	self.window_name = page_info.window_name
391	##window_caption
392	self.window_caption = page_info.window_caption
393	## manager is the fitting plugin
394	self._manager= page_info.manager
395	## owner of the page (fitting plugin)
396	self.event_owner= page_info.event_owner
397	## current model
398	self.model = page_info.model
399	## data
400	self.data = page_info.data
401	## dictionary containing list of models
402	self.model_list_box = page_info.model_list_box
403	## Data member to store the dispersion object created
404	self.populate_box(dict=self.model_list_box)
405
406	def onContextMenu(self, event):
407	"""
408	Retrieve the state selected state
409	"""
410	# Skipping the save state functionality for release 0.9.0
411	#return
412
413	pos = event.GetPosition()
414	pos = self.ScreenToClient(pos)
415
416	self.PopupMenu(self.popUpMenu, pos)
417
418
419	def onUndo(self, event):
420	"""
421	Cancel the previous action
422	"""
423	event = PreviousStateEvent(page = self)
424	wx.PostEvent(self.parent, event)
425
426	def onRedo(self, event):
427	"""
428	Restore the previous action cancelled
429	"""
430	event = NextStateEvent(page= self)
431	wx.PostEvent(self.parent, event)
432
433	def define_page_structure(self):
434	"""
435	Create empty sizer for a panel
436	"""
437	self.vbox = wx.BoxSizer(wx.VERTICAL)
438	self.sizer0 = wx.BoxSizer(wx.VERTICAL)
439	self.sizer1 = wx.BoxSizer(wx.VERTICAL)
440	self.sizer2 = wx.BoxSizer(wx.VERTICAL)
441	self.sizer3 = wx.BoxSizer(wx.VERTICAL)
442	self.sizer4 = wx.BoxSizer(wx.VERTICAL)
443	self.sizer5 = wx.BoxSizer(wx.VERTICAL)
444	self.sizer6 = wx.BoxSizer(wx.VERTICAL)
445
446	self.sizer0.SetMinSize((PANEL_WIDTH,-1))
447	self.sizer1.SetMinSize((PANEL_WIDTH,-1))
448	self.sizer2.SetMinSize((PANEL_WIDTH,-1))
449	self.sizer3.SetMinSize((PANEL_WIDTH,-1))
450	self.sizer4.SetMinSize((PANEL_WIDTH,-1))
451	self.sizer5.SetMinSize((PANEL_WIDTH,-1))
452	self.sizer6.SetMinSize((PANEL_WIDTH,-1))
453
454	self.vbox.Add(self.sizer0)
455	self.vbox.Add(self.sizer1)
456	self.vbox.Add(self.sizer2)
457	self.vbox.Add(self.sizer3)
458	self.vbox.Add(self.sizer4)
459	self.vbox.Add(self.sizer5)
460	self.vbox.Add(self.sizer6)
461
462	def set_layout(self):
463	"""
464	layout
465	"""
466	self.vbox.Layout()
467	self.vbox.Fit(self)
468	self.SetSizer(self.vbox)
469	self.Centre()
470
471	def set_owner(self,owner):
472	"""
473	set owner of fitpage
474
475	:param owner: the class responsible of plotting
476
477	"""
478	self.event_owner = owner
479	self.state.event_owner = owner
480
481	def get_state(self):
482	"""
483	"""
484	return self.state
485
486	def get_data(self):
487	"""
488	return the current data
489	"""
490	return self.data
491
492	def get_data_list(self):
493	"""
494	return the current data
495	"""
496	return self.data_list
497
498	def set_manager(self, manager):
499	"""
500	set panel manager
501
502	:param manager: instance of plugin fitting
503
504	"""
505	self._manager = manager
506	self.state.manager = manager
507
508	def populate_box(self, dict):
509	"""
510	Store list of model
511
512	:param dict: dictionary containing list of models
513
514	"""
515	self.model_list_box = dict
516	self.state.model_list_box = self.model_list_box
517	self.initialize_combox()
518
519	def initialize_combox(self):
520	"""
521	put default value in the combobox
522	"""
523	## fill combox box
524	if self.model_list_box is None:
525	return
526	if len(self.model_list_box) > 0:
527	self._populate_box(self.formfactorbox,
528	self.model_list_box["Shapes"])
529
530	if len(self.model_list_box) > 0:
531	self._populate_box(self.structurebox,
532	self.model_list_box["Structure Factors"])
533	self.structurebox.Insert("None", 0, None)
534	self.structurebox.SetSelection(0)
535	self.structurebox.Hide()
536	self.text2.Hide()
537	self.structurebox.Disable()
538	self.text2.Disable()
539
540	if self.model.__class__ in self.model_list_box["P(Q)*S(Q)"]:
541	self.structurebox.Show()
542	self.text2.Show()
543	self.structurebox.Enable()
544	self.text2.Enable()
545
546	def set_dispers_sizer(self):
547	"""
548	fill sizer containing dispersity info
549	"""
550	self.sizer4.Clear(True)
551	name="Polydispersity and Orientational Distribution"
552	box_description= wx.StaticBox(self, -1,name)
553	boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
554	#----------------------------------------------------
555	self.disable_disp = wx.RadioButton(self, -1, 'Off', (10, 10),
556	style=wx.RB_GROUP)
557	self.enable_disp = wx.RadioButton(self, -1, 'On', (10, 30))
558	# best size for MAC and PC
559	if ON_MAC:
560	size_q = (30, 20)
561	else:
562	size_q = (20, 15)
563	self.disp_help_bt = wx.Button(self,wx.NewId(),'?',
564	style = wx.BU_EXACTFIT,
565	size=size_q)
566	self.disp_help_bt.Bind(wx.EVT_BUTTON,
567	self.on_pd_help_clicked,id= self.disp_help_bt.GetId())
568	self.disp_help_bt.SetToolTipString("Helps for Polydispersion.")
569
570	self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
571	id=self.disable_disp.GetId())
572	self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
573	id=self.enable_disp.GetId())
574	#MAC needs SetValue
575	self.disable_disp.SetValue(True)
576	sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL)
577	sizer_dispersion.Add((20,20))
578	name=""#Polydispersity and \nOrientational Distribution "
579	sizer_dispersion.Add(wx.StaticText(self,-1,name))
580	sizer_dispersion.Add(self.enable_disp )
581	sizer_dispersion.Add((20,20))
582	sizer_dispersion.Add(self.disable_disp )
583	sizer_dispersion.Add((25,20))
584	sizer_dispersion.Add(self.disp_help_bt)
585
586	## fill a sizer for dispersion
587	boxsizer1.Add( sizer_dispersion,0,
588	wx.TOP\|wx.BOTTOM\|wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE,border=5)
589	#boxsizer1.Add( (10,10) )
590	#boxsizer1.Add( sizer_select_dispers )
591	self.sizer4_4 = wx.GridBagSizer(6,5)
592
593	boxsizer1.Add( self.sizer4_4 )
594	#-----------------------------------------------------
595	self.sizer4.Add(boxsizer1,0, wx.EXPAND \| wx.ALL, 10)
596	self.sizer4_4.Layout()
597	self.sizer4.Layout()
598	self.Layout()
599
600	self.Refresh()
601	## saving the state of enable dispersity button
602	self.state.enable_disp= self.enable_disp.GetValue()
603	self.state.disable_disp= self.disable_disp.GetValue()
604	self.SetupScrolling()
605
606
607	def onResetModel(self, event):
608	"""
609	Reset model state
610	"""
611	menu = event.GetEventObject()
612	## post help message for the selected model
613	msg = menu.GetHelpString(event.GetId())
614	msg +=" reloaded"
615	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
616
617	name = menu.GetLabel(event.GetId())
618	self._on_select_model_helper()
619
620	if name in self.saved_states.keys():
621	previous_state = self.saved_states[name]
622	## reset state of checkbox,textcrtl and regular parameters value
623	self.Show(False)
624	self.reset_page(previous_state)
625	self.Show(True)
626
627	def on_preview(self, event):
628	"""
629	Report the current fit results
630	"""
631	# Get plot image from plotpanel
632	images, canvases = self.get_images()
633	# get the report dialog
634	self.state.report(images, canvases)
635
636
637	def on_save(self, event):
638	"""
639	Save the current state into file
640	"""
641	self.save_current_state()
642	new_state = self.state.clone()
643	# Ask the user the location of the file to write to.
644	path = None
645	dlg = wx.FileDialog(self, "Choose a file", self._default_save_location,
646	"", "*.fitv", wx.SAVE)
647	if dlg.ShowModal() == wx.ID_OK:
648	path = dlg.GetPath()
649	self._default_save_location = os.path.dirname(path)
650	else:
651	return None
652	# MAC always needs the extension for saving
653	extens = ".fitv"
654	# Make sure the ext included in the file name
655	fName = os.path.splitext(path)[0] + extens
656	#the manager write the state into file
657	self._manager.save_fit_state(filepath=fName, fitstate=new_state)
658	return new_state
659
660	def on_copy(self, event):
661	"""
662	Copy Parameter values to the clipboad
663	"""
664	if event != None:
665	event.Skip()
666	# It seems MAC needs wxCallAfter
667	wx.CallAfter(self.get_copy)
668
669	# messages depending on the flag
670	self._copy_info(None)
671
672	def on_paste(self, event):
673	"""
674	Paste Parameter values to the panel if possible
675	"""
676	if event != None:
677	event.Skip()
678	# It seems MAC needs wxCallAfter for the setvalues
679	# for multiple textctrl items, otherwise it tends to crash once a while.
680	wx.CallAfter(self.get_paste)
681	# messages depending on the flag
682	#self._copy_info(True)
683
684	def _copy_info(self, flag):
685	"""
686	Send event dpemding on flag
687
688	: Param flag: flag that distinguish event
689	"""
690	# messages depending on the flag
691	if flag == None:
692	msg = " Parameter values are copied to the clipboard..."
693	infor = 'warning'
694	elif flag:
695	msg = " Parameter values are pasted from the clipboad..."
696	infor = "warning"
697	else:
698	msg = "Error was occured "
699	msg += ": No valid parameter values to paste from the clipboard..."
700	infor = "error"
701	# inform msg to wx
702	wx.PostEvent( self.parent.parent,
703	StatusEvent(status= msg, info=infor))
704
705	def _get_time_stamp(self):
706	"""
707	return time and date stings
708	"""
709	# date and time
710	year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime()
711	current_time= str(hour)+":"+str(minute)+":"+str(second)
712	current_date= str( month)+"/"+str(day)+"/"+str(year)
713	return current_time, current_date
714
715	def on_bookmark(self, event):
716	"""
717	save history of the data and model
718	"""
719	if self.model==None:
720	msg="Can not bookmark; Please select Data and Model first..."
721	wx.MessageBox(msg, 'Info')
722	return
723	self.save_current_state()
724	new_state = self.state.clone()
725	##Add model state on context menu
726	self.number_saved_state += 1
727	current_time, current_date = self._get_time_stamp()
728	#name= self.model.name+"[%g]"%self.number_saved_state
729	name = "Fitting: %g]" % self.number_saved_state
730	name += self.model.__class__.__name__
731	name += "bookmarked at %s on %s" % (current_time, current_date)
732	self.saved_states[name]= new_state
733
734	## Add item in the context menu
735	msg = "Model saved at %s on %s"%(current_time, current_date)
736	## post help message for the selected model
737	msg +=" Saved! right click on this page to retrieve this model"
738	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
739
740	id = wx.NewId()
741	self.popUpMenu.Append(id,name,str(msg))
742	wx.EVT_MENU(self, id, self.onResetModel)
743	wx.PostEvent(self.parent.parent,
744	AppendBookmarkEvent(title=name,
745	hint=str(msg), handler=self._back_to_bookmark))
746	def _back_to_bookmark(self, event):
747	"""
748	Back to bookmark
749	"""
750	self._manager.on_perspective(event)
751	self.onResetModel(event)
752	def old_on_bookmark(self, event):
753	"""
754	save history of the data and model
755	"""
756	if self.model==None:
757	msg="Can not bookmark; Please select Data and Model first..."
758	wx.MessageBox(msg, 'Info')
759	return
760	if hasattr(self,"enable_disp"):
761	self.state.enable_disp = copy.deepcopy(self.enable_disp.GetValue())
762	if hasattr(self, "disp_box"):
763	self.state.disp_box = copy.deepcopy(self.disp_box.GetSelection())
764
765	self.state.model.name= self.model.name
766
767	#Remember fit engine_type for fit panel
768	if self.engine_type == None:
769	self.engine_type = "scipy"
770	if self._manager !=None:
771	self._manager._on_change_engine(engine=self.engine_type)
772
773	self.state.engine_type = self.engine_type
774
775	new_state = self.state.clone()
776	new_state.model.name = self.state.model.name
777
778	new_state.enable2D = copy.deepcopy(self.enable2D)
779	##Add model state on context menu
780	self.number_saved_state += 1
781	#name= self.model.name+"[%g]"%self.number_saved_state
782	name= self.model.__class__.__name__+"[%g]"%self.number_saved_state
783	self.saved_states[name]= new_state
784
785	## Add item in the context menu
786
787	year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime()
788	my_time= str(hour)+" : "+str(minute)+" : "+str(second)+" "
789	date= str( month)+"\|"+str(day)+"\|"+str(year)
790	msg= "Model saved at %s on %s"%(my_time, date)
791	## post help message for the selected model
792	msg +=" Saved! right click on this page to retrieve this model"
793	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
794
795	id = wx.NewId()
796	self.popUpMenu.Append(id,name,str(msg))
797	wx.EVT_MENU(self, id, self.onResetModel)
798
799	def onSetFocus(self, evt):
800	"""
801	highlight the current textcrtl and hide the error text control shown
802	after fitting
803	"""
804	return
805
806	def read_file(self, path):
807	"""
808	Read two columns file
809
810	:param path: the path to the file to read
811
812	"""
813	try:
814	if path==None:
815	wx.PostEvent(self.parent.parent, StatusEvent(status=\
816	" Selected Distribution was not loaded: %s"%path))
817	return None, None
818	input_f = open(path, 'r')
819	buff = input_f.read()
820	lines = buff.split('\n')
821
822	angles = []
823	weights=[]
824	for line in lines:
825	toks = line.split()
826	try:
827	angle = float(toks[0])
828	weight = float(toks[1])
829	except:
830	# Skip non-data lines
831	pass
832	angles.append(angle)
833	weights.append(weight)
834	return numpy.array(angles), numpy.array(weights)
835	except:
836	raise
837
838	def createMemento(self):
839	"""
840	return the current state of the page
841	"""
842	return self.state.clone()
843
844
845	def save_current_state(self):
846	"""
847	Store current state
848	"""
849	self.state.engine_type = copy.deepcopy(self.engine_type)
850	## save model option
851	if self.model!= None:
852	self.disp_list= self.model.getDispParamList()
853	self.state.disp_list= copy.deepcopy(self.disp_list)
854	self.state.model = self.model.clone()
855	#save radiobutton state for model selection
856	self.state.shape_rbutton = self.shape_rbutton.GetValue()
857	self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
858	self.state.struct_rbutton = self.struct_rbutton.GetValue()
859	self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
860	#model combobox
861	self.state.structurebox = self.structurebox.GetSelection()
862	self.state.formfactorbox = self.formfactorbox.GetSelection()
863
864	self.state.enable2D = copy.deepcopy(self.enable2D)
865	self.state.values= copy.deepcopy(self.values)
866	self.state.weights = copy.deepcopy( self.weights)
867	## save data
868	self.state.data= copy.deepcopy(self.data)
869	self.state.qmax_x = self.qmax_x
870	self.state.qmin_x = self.qmin_x
871
872	if hasattr(self,"enable_disp"):
873	self.state.enable_disp= self.enable_disp.GetValue()
874	self.state.disable_disp = self.disable_disp.GetValue()
875
876	self.state.smearer = copy.deepcopy(self.current_smearer)
877	if hasattr(self,"enable_smearer"):
878	self.state.enable_smearer = \
879	copy.deepcopy(self.enable_smearer.GetValue())
880	self.state.disable_smearer = \
881	copy.deepcopy(self.disable_smearer.GetValue())
882
883	self.state.pinhole_smearer = \
884	copy.deepcopy(self.pinhole_smearer.GetValue())
885	self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
886
887	if len(self._disp_obj_dict)>0:
888	for k , v in self._disp_obj_dict.iteritems():
889	self.state._disp_obj_dict[k]= v
890
891
892	self.state.values = copy.deepcopy(self.values)
893	self.state.weights = copy.deepcopy(self.weights)
894	## save plotting range
895	self._save_plotting_range()
896
897	self.state.orientation_params = []
898	self.state.orientation_params_disp = []
899	self.state.parameters = []
900	self.state.fittable_param = []
901	self.state.fixed_param = []
902	self.state.str_parameters = []
903
904
905	## save checkbutton state and txtcrtl values
906	self._copy_parameters_state(self.str_parameters,
907	self.state.str_parameters)
908	self._copy_parameters_state(self.orientation_params,
909	self.state.orientation_params)
910	self._copy_parameters_state(self.orientation_params_disp,
911	self.state.orientation_params_disp)
912
913	self._copy_parameters_state(self.parameters, self.state.parameters)
914	self._copy_parameters_state(self.fittable_param,
915	self.state.fittable_param)
916	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
917	#save chisqr
918	self.state.tcChi = self.tcChi.GetValue()
919
920	def save_current_state_fit(self):
921	"""
922	Store current state for fit_page
923	"""
924	## save model option
925	if self.model!= None:
926	self.disp_list= self.model.getDispParamList()
927	self.state.disp_list= copy.deepcopy(self.disp_list)
928	self.state.model = self.model.clone()
929	if hasattr(self, "engine_type"):
930	self.state.engine_type = copy.deepcopy(self.engine_type)
931
932	self.state.enable2D = copy.deepcopy(self.enable2D)
933	self.state.values= copy.deepcopy(self.values)
934	self.state.weights = copy.deepcopy( self.weights)
935	## save data
936	self.state.data= copy.deepcopy(self.data)
937
938	if hasattr(self,"enable_disp"):
939	self.state.enable_disp= self.enable_disp.GetValue()
940	self.state.disable_disp = self.disable_disp.GetValue()
941
942	self.state.smearer = copy.deepcopy(self.current_smearer)
943	if hasattr(self,"enable_smearer"):
944	self.state.enable_smearer = \
945	copy.deepcopy(self.enable_smearer.GetValue())
946	self.state.disable_smearer = \
947	copy.deepcopy(self.disable_smearer.GetValue())
948
949	self.state.pinhole_smearer = \
950	copy.deepcopy(self.pinhole_smearer.GetValue())
951	self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
952
953	if hasattr(self,"disp_box"):
954	self.state.disp_box = self.disp_box.GetCurrentSelection()
955
956	if len(self.disp_cb_dict) > 0:
957	for k, v in self.disp_cb_dict.iteritems():
958
959	if v == None :
960	self.state.disp_cb_dict[k] = v
961	else:
962	try:
963	self.state.disp_cb_dict[k] = v.GetValue()
964	except:
965	self.state.disp_cb_dict[k] = None
966
967	if len(self._disp_obj_dict) > 0:
968	for k , v in self._disp_obj_dict.iteritems():
969
970	self.state._disp_obj_dict[k] = v
971
972
973	self.state.values = copy.deepcopy(self.values)
974	self.state.weights = copy.deepcopy(self.weights)
975
976	## save plotting range
977	self._save_plotting_range()
978
979	## save checkbutton state and txtcrtl values
980	self._copy_parameters_state(self.orientation_params,
981	self.state.orientation_params)
982	self._copy_parameters_state(self.orientation_params_disp,
983	self.state.orientation_params_disp)
984	self._copy_parameters_state(self.parameters, self.state.parameters)
985	self._copy_parameters_state(self.fittable_param,
986	self.state.fittable_param)
987	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
988
989
990	def check_invalid_panel(self):
991	"""
992	check if the user can already perform some action with this panel
993	"""
994	flag = False
995	if self.data is None:
996	self.disable_smearer.SetValue(True)
997	self.disable_disp.SetValue(True)
998	msg = "Please load Data and select Model to start..."
999	wx.MessageBox(msg, 'Info')
1000	return True
1001
1002	def set_model_state(self, state):
1003	"""
1004	reset page given a model state
1005	"""
1006	self.disp_cb_dict = state.disp_cb_dict
1007	self.disp_list = state.disp_list
1008
1009	## set the state of the radio box
1010	self.shape_rbutton.SetValue(state.shape_rbutton )
1011	self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton)
1012	self.struct_rbutton.SetValue(state.struct_rbutton)
1013	self.plugin_rbutton.SetValue(state.plugin_rbutton)
1014
1015	## fill model combobox
1016	self._show_combox_helper()
1017	#select the current model
1018	self.formfactorbox.Select(int(state.formfactorcombobox))
1019	self.structurebox.SetSelection(state.structurecombobox )
1020	if state.multi_factor != None:
1021	self.multifactorbox.SetSelection(state.multi_factor)
1022
1023	## reset state of checkbox,textcrtl and regular parameters value
1024	self._reset_parameters_state(self.orientation_params_disp,
1025	state.orientation_params_disp)
1026	self._reset_parameters_state(self.orientation_params,
1027	state.orientation_params)
1028	self._reset_parameters_state(self.str_parameters,
1029	state.str_parameters)
1030	self._reset_parameters_state(self.parameters,state.parameters)
1031	## display dispersion info layer
1032	self.enable_disp.SetValue(state.enable_disp)
1033	self.disable_disp.SetValue(state.disable_disp)
1034
1035	if hasattr(self, "disp_box"):
1036
1037	self.disp_box.SetSelection(state.disp_box)
1038	n= self.disp_box.GetCurrentSelection()
1039	dispersity= self.disp_box.GetClientData(n)
1040	name = dispersity.__name__
1041
1042	self._set_dipers_Param(event=None)
1043
1044	if name == "ArrayDispersion":
1045
1046	for item in self.disp_cb_dict.keys():
1047
1048	if hasattr(self.disp_cb_dict[item], "SetValue") :
1049	self.disp_cb_dict[item].SetValue(\
1050	state.disp_cb_dict[item])
1051	# Create the dispersion objects
1052	from sans.models.dispersion_models import ArrayDispersion
1053	disp_model = ArrayDispersion()
1054	if hasattr(state,"values")and\
1055	self.disp_cb_dict[item].GetValue() == True:
1056	if len(state.values)>0:
1057	self.values=state.values
1058	self.weights=state.weights
1059	disp_model.set_weights(self.values,
1060	state.weights)
1061	else:
1062	self._reset_dispersity()
1063
1064	self._disp_obj_dict[item] = disp_model
1065	# Set the new model as the dispersion object
1066	#for the selected parameter
1067	self.model.set_dispersion(item, disp_model)
1068
1069	self.model._persistency_dict[item] = \
1070	[state.values, state.weights]
1071
1072	else:
1073	keys = self.model.getParamList()
1074	for item in keys:
1075	if item in self.disp_list and \
1076	not self.model.details.has_key(item):
1077	self.model.details[item] = ["", None, None]
1078	for k,v in self.state.disp_cb_dict.iteritems():
1079	self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1080	self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1081	## smearing info restore
1082	if hasattr(self, "enable_smearer"):
1083	## set smearing value whether or not the data
1084	#contain the smearing info
1085	self.enable_smearer.SetValue(state.enable_smearer)
1086	self.disable_smearer.SetValue(state.disable_smearer)
1087	self.onSmear(event=None)
1088	self.pinhole_smearer.SetValue(state.pinhole_smearer)
1089	self.slit_smearer.SetValue(state.slit_smearer)
1090	## we have two more options for smearing
1091	if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None)
1092	elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None)
1093
1094	## reset state of checkbox,textcrtl and dispersity parameters value
1095	self._reset_parameters_state(self.fittable_param,state.fittable_param)
1096	self._reset_parameters_state(self.fixed_param,state.fixed_param)
1097
1098	## draw the model with previous parameters value
1099	self._onparamEnter_helper()
1100	self.select_param(event=None)
1101	#Save state_fit
1102	self.save_current_state_fit()
1103	self._lay_out()
1104	self.Refresh()
1105
1106	def reset_page_helper(self, state):
1107	"""
1108	Use page_state and change the state of existing page
1109
1110	:precondition: the page is already drawn or created
1111
1112	:postcondition: the state of the underlying data change as well as the
1113	state of the graphic interface
1114	"""
1115	if state == None:
1116	#self._undo.Enable(False)
1117	return
1118	# set data, etc. from the state
1119	# reset page between theory and fitting from bookmarking
1120	#if state.data == None:
1121	# data = None
1122	#else:
1123	data = state.data
1124
1125	#if data != None:
1126
1127	if data == None:
1128	data_min = state.qmin
1129	data_max = state.qmax
1130	self.qmin_x = data_min
1131	self.qmax_x = data_max
1132	#self.minimum_q.SetValue(str(data_min))
1133	#self.maximum_q.SetValue(str(data_max))
1134	self.qmin.SetValue(str(data_min))
1135	self.qmax.SetValue(str(data_max))
1136
1137	self.state.data = data
1138	self.state.qmin = self.qmin_x
1139	self.state.qmax = self.qmax_x
1140	else:
1141	self.set_data(data)
1142
1143	self.enable2D= state.enable2D
1144	self.engine_type = state.engine_type
1145
1146	self.disp_cb_dict = state.disp_cb_dict
1147	self.disp_list = state.disp_list
1148
1149	## set the state of the radio box
1150	self.shape_rbutton.SetValue(state.shape_rbutton )
1151	self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton)
1152	self.struct_rbutton.SetValue(state.struct_rbutton)
1153	self.plugin_rbutton.SetValue(state.plugin_rbutton)
1154
1155	## fill model combobox
1156	self._show_combox_helper()
1157	#select the current model
1158	self.formfactorbox.Select(int(state.formfactorcombobox))
1159	self.structurebox.SetSelection(state.structurecombobox )
1160	if state.multi_factor != None:
1161	self.multifactorbox.SetSelection(state.multi_factor)
1162
1163	#reset the fitting engine type
1164	self.engine_type = state.engine_type
1165	#draw the pnael according to the new model parameter
1166	self._on_select_model(event=None)
1167	# take care of 2D button
1168	if data == None and self.model_view.IsEnabled():
1169	if self.enable2D:
1170	self.model_view.SetLabel("2D Mode")
1171	else:
1172	self.model_view.SetLabel("1D Mode")
1173	# else:
1174
1175	if self._manager !=None:
1176	self._manager._on_change_engine(engine=self.engine_type)
1177	## set the select all check box to the a given state
1178	self.cb1.SetValue(state.cb1)
1179
1180	## reset state of checkbox,textcrtl and regular parameters value
1181	self._reset_parameters_state(self.orientation_params_disp,
1182	state.orientation_params_disp)
1183	self._reset_parameters_state(self.orientation_params,
1184	state.orientation_params)
1185	self._reset_parameters_state(self.str_parameters,
1186	state.str_parameters)
1187	self._reset_parameters_state(self.parameters,state.parameters)
1188	## display dispersion info layer
1189	self.enable_disp.SetValue(state.enable_disp)
1190	self.disable_disp.SetValue(state.disable_disp)
1191	# If the polydispersion is ON
1192	if state.enable_disp:
1193	# reset dispersion according the state
1194	self._set_dipers_Param(event=None)
1195	self._reset_page_disp_helper(state)
1196	##plotting range restore
1197	self._reset_plotting_range(state)
1198	## smearing info restore
1199	if hasattr(self, "enable_smearer"):
1200	## set smearing value whether or not the data
1201	#contain the smearing info
1202	self.enable_smearer.SetValue(state.enable_smearer)
1203	self.disable_smearer.SetValue(state.disable_smearer)
1204	self.onSmear(event=None)
1205	self.pinhole_smearer.SetValue(state.pinhole_smearer)
1206	self.slit_smearer.SetValue(state.slit_smearer)
1207	## we have two more options for smearing
1208	if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None)
1209	elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None)
1210
1211	## reset state of checkbox,textcrtl and dispersity parameters value
1212	self._reset_parameters_state(self.fittable_param,state.fittable_param)
1213	self._reset_parameters_state(self.fixed_param,state.fixed_param)
1214
1215	## draw the model with previous parameters value
1216	self._onparamEnter_helper()
1217	#reset the value of chisqr when not consistent with the value computed
1218	self.tcChi.SetValue(str(self.state.tcChi))
1219	## reset context menu items
1220	self._reset_context_menu()
1221
1222	## set the value of the current state to the state given as parameter
1223	self.state = state.clone()
1224
1225	def _reset_page_disp_helper(self, state):
1226	"""
1227	Help to rest page for dispersions
1228	"""
1229	keys = self.model.getParamList()
1230	for item in keys:
1231	if item in self.disp_list and \
1232	not self.model.details.has_key(item):
1233	self.model.details[item] = ["", None, None]
1234	#for k,v in self.state.disp_cb_dict.iteritems():
1235	self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1236	self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1237	self.values = copy.deepcopy(state.values)
1238	self.weights = copy.deepcopy(state.weights)
1239
1240	for key, disp in state._disp_obj_dict.iteritems():
1241	# From saved file, disp_model can not be sent in model obj.
1242	# it will be sent as a string here, then converted to model object.
1243	if disp.__class__.__name__ == 'str':
1244	com_str = "from sans.models.dispersion_models "
1245	com_str += "import %s as disp_func"
1246	exec com_str % disp
1247	disp_model = disp_func()
1248	else:
1249	disp_model = disp
1250
1251	self._disp_obj_dict[key] = disp_model
1252	param_name = key.split('.')[0]
1253	# Try to set dispersion only when available
1254	# for eg., pass the orient. angles for 1D Cal
1255	try:
1256	self.model.set_dispersion(param_name, disp_model)
1257	self.model._persistency_dict[key] = \
1258	[state.values, state.weights]
1259	except:
1260	pass
1261	selection = self._find_polyfunc_selection(disp_model)
1262	for list in self.fittable_param:
1263	if list[1] == key and list[7] != None:
1264	list[7].SetSelection(selection)
1265	# For the array disp_model, set the values and weights
1266	if selection == 1:
1267	disp_model.set_weights(self.values[key],
1268	self.weights[key])
1269	try:
1270	# Diables all fittable params for array
1271	list[0].SetValue(False)
1272	list[0].Disable()
1273	list[2].Disable()
1274	list[5].Disable()
1275	list[6].Disable()
1276	except:
1277	pass
1278	# For array, disable all fixed params
1279	if selection == 1:
1280	for item in self.fixed_param:
1281	if item[1].split(".")[0] == key.split(".")[0]:
1282	# try it and pass it for the orientation for 1D
1283	try:
1284	item[2].Disable()
1285	except:
1286	pass
1287
1288	# Make sure the check box updated when all checked
1289	if self.cb1.GetValue():
1290	self.select_all_param(None)
1291
1292	def _selectDlg(self):
1293	"""
1294	open a dialog file to selected the customized dispersity
1295	"""
1296	import os
1297	dlg = wx.FileDialog(self, "Choose a weight file",
1298	self._default_save_location , "",
1299	".", wx.OPEN)
1300	path = None
1301	if dlg.ShowModal() == wx.ID_OK:
1302	path = dlg.GetPath()
1303	dlg.Destroy()
1304	return path
1305
1306	def _reset_context_menu(self):
1307	"""
1308	reset the context menu
1309	"""
1310	for name, state in self.state.saved_states.iteritems():
1311	self.number_saved_state += 1
1312	## Add item in the context menu
1313	id = wx.NewId()
1314	msg = 'Save model and state %g' % self.number_saved_state
1315	self.popUpMenu.Append(id, name, msg)
1316	wx.EVT_MENU(self, id, self.onResetModel)
1317
1318	def _reset_plotting_range(self, state):
1319	"""
1320	Reset the plotting range to a given state
1321	"""
1322	# if self.check_invalid_panel():
1323	# return
1324	self.qmin.SetValue(str(state.qmin))
1325	self.qmax.SetValue(str(state.qmax))
1326
1327	def _save_typeOfmodel(self):
1328	"""
1329	save radiobutton containing the type model that can be selected
1330	"""
1331	self.state.shape_rbutton = self.shape_rbutton.GetValue()
1332	self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
1333	self.state.struct_rbutton = self.struct_rbutton.GetValue()
1334	self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
1335	self.state.structurebox= self.structurebox.GetCurrentSelection()
1336	self.state.formfactorbox = self.formfactorbox.GetCurrentSelection()
1337
1338	#self._undo.Enable(True)
1339	## post state to fit panel
1340	event = PageInfoEvent(page = self)
1341	wx.PostEvent(self.parent, event)
1342
1343	def _save_plotting_range(self ):
1344	"""
1345	save the state of plotting range
1346	"""
1347	self.state.qmin = self.qmin_x
1348	self.state.qmax = self.qmax_x
1349	self.state.npts = self.npts_x
1350
1351	def _onparamEnter_helper(self):
1352	"""
1353	check if values entered by the user are changed and valid to replot
1354	model
1355	"""
1356	# Flag to register when a parameter has changed.
1357	is_modified = False
1358	self.fitrange = True
1359	is_2Ddata = False
1360	#self._undo.Enable(True)
1361	# check if 2d data
1362	if self.data.__class__.__name__ == "Data2D":
1363	is_2Ddata = True
1364	if self.model !=None:
1365	try:
1366	is_modified = self._check_value_enter(self.fittable_param,
1367	is_modified)
1368	is_modified = self._check_value_enter(self.fixed_param,
1369	is_modified)
1370	is_modified = self._check_value_enter(self.parameters,
1371	is_modified)
1372	except:
1373	pass
1374	#if is_modified:
1375
1376	# Here we should check whether the boundaries have been modified.
1377	# If qmin and qmax have been modified, update qmin and qmax and
1378	# set the is_modified flag to True
1379	if self._validate_qrange(self.qmin, self.qmax):
1380	tempmin = float(self.qmin.GetValue())
1381	if tempmin != self.qmin_x:
1382	self.qmin_x = tempmin
1383	is_modified = True
1384	tempmax = float(self.qmax.GetValue())
1385	if tempmax != self.qmax_x:
1386	self.qmax_x = tempmax
1387	is_modified = True
1388
1389	if is_2Ddata:
1390	# set mask
1391	is_modified = self._validate_Npts()
1392
1393	else:
1394	self.fitrange = False
1395
1396	## if any value is modify draw model with new value
1397	if not self.fitrange:
1398	#self.btFit.Disable()
1399	if is_2Ddata: self.btEditMask.Disable()
1400	else:
1401	#self.btFit.Enable(True)
1402	if is_2Ddata: self.btEditMask.Enable(True)
1403	if is_modified and self.fitrange:
1404	#if self.data == None:
1405	# Theory case: need to get npts value to draw
1406	self.npts_x = float(self.Npts_total.GetValue())
1407	self.create_default_data()
1408	self.state_change= True
1409	self._draw_model()
1410	self.Refresh()
1411	return is_modified
1412
1413	def _update_paramv_on_fit(self):
1414	"""
1415	make sure that update param values just before the fitting
1416	"""
1417	#flag for qmin qmax check values
1418	flag = True
1419	self.fitrange = True
1420	is_modified = False
1421
1422	#wx.PostEvent(self._manager.parent, StatusEvent(status=" \
1423	#updating ... ",type="update"))
1424
1425	##So make sure that update param values on_Fit.
1426	#self._undo.Enable(True)
1427	if self.model !=None:
1428	##Check the values
1429	self._check_value_enter( self.fittable_param ,is_modified)
1430	self._check_value_enter( self.fixed_param ,is_modified)
1431	self._check_value_enter( self.parameters ,is_modified)
1432
1433	# If qmin and qmax have been modified, update qmin and qmax and
1434	# Here we should check whether the boundaries have been modified.
1435	# If qmin and qmax have been modified, update qmin and qmax and
1436	# set the is_modified flag to True
1437	self.fitrange = self._validate_qrange(self.qmin, self.qmax)
1438	if self.fitrange:
1439	tempmin = float(self.qmin.GetValue())
1440	if tempmin != self.qmin_x:
1441	self.qmin_x = tempmin
1442	tempmax = float(self.qmax.GetValue())
1443	if tempmax != self.qmax_x:
1444	self.qmax_x = tempmax
1445	if tempmax == tempmin:
1446	flag = False
1447	temp_smearer = None
1448	if not self.disable_smearer.GetValue():
1449	temp_smearer= self.current_smearer
1450	if self.slit_smearer.GetValue():
1451	flag = self.update_slit_smear()
1452	elif self.pinhole_smearer.GetValue():
1453	flag = self.update_pinhole_smear()
1454	else:
1455	self._manager.set_smearer(smearer=temp_smearer,
1456	uid=self.uid,
1457	fid=self.data.id,
1458	qmin=float(self.qmin_x),
1459	qmax=float(self.qmax_x),
1460	enable_smearer=not self.disable_smearer.GetValue(),
1461	draw=False)
1462	elif not self._is_2D():
1463	self._manager.set_smearer(smearer=temp_smearer,
1464	qmin=float(self.qmin_x),
1465	uid=self.uid,
1466	fid=self.data.id,
1467	qmax= float(self.qmax_x),
1468	enable_smearer=not self.disable_smearer.GetValue(),
1469	draw=False)
1470	if self.data != None:
1471	index_data = ((self.qmin_x <= self.data.x)&\
1472	(self.data.x <= self.qmax_x))
1473	val = str(len(self.data.x[index_data==True]))
1474	self.Npts_fit.SetValue(val)
1475	else:
1476	# No data in the panel
1477	try:
1478	self.npts_x = float(self.Npts_total.GetValue())
1479	except:
1480	flag = False
1481	return flag
1482	flag = True
1483	if self._is_2D():
1484	# only 2D case set mask
1485	flag = self._validate_Npts()
1486	if not flag:
1487	return flag
1488	else: flag = False
1489	else:
1490	flag = False
1491
1492	#For invalid q range, disable the mask editor and fit button, vs.
1493	if not self.fitrange:
1494	#self.btFit.Disable()
1495	if self._is_2D():
1496	self.btEditMask.Disable()
1497	else:
1498	#self.btFit.Enable(True)
1499	if self._is_2D() and self.data != None:
1500	self.btEditMask.Enable(True)
1501
1502	if not flag:
1503	msg = "Cannot Plot or Fit :Must select a "
1504	msg += " model or Fitting range is not valid!!! "
1505	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
1506
1507	self.save_current_state()
1508
1509	return flag
1510
1511	def _is_modified(self, is_modified):
1512	"""
1513	return to self._is_modified
1514	"""
1515	return is_modified
1516
1517	def _reset_parameters_state(self, listtorestore, statelist):
1518	"""
1519	Reset the parameters at the given state
1520	"""
1521	if len(statelist) == 0 or len(listtorestore) == 0:
1522	return
1523	if len(statelist) != len(listtorestore):
1524	return
1525
1526	for j in range(len(listtorestore)):
1527	item_page = listtorestore[j]
1528	item_page_info = statelist[j]
1529	##change the state of the check box for simple parameters
1530	if item_page[0]!=None:
1531	item_page[0].SetValue(item_page_info[0])
1532	if item_page[2]!=None:
1533	item_page[2].SetValue(item_page_info[2])
1534	if item_page[2].__class__.__name__ == "ComboBox":
1535	if self.model.fun_list.has_key(item_page_info[2]):
1536	fun_val = self.model.fun_list[item_page_info[2]]
1537	self.model.setParam(item_page_info[1],fun_val)
1538	if item_page[3]!=None:
1539	## show or hide text +/-
1540	if item_page_info[2]:
1541	item_page[3].Show(True)
1542	else:
1543	item_page[3].Hide()
1544	if item_page[4]!=None:
1545	## show of hide the text crtl for fitting error
1546	if item_page_info[4][0]:
1547	item_page[4].Show(True)
1548	item_page[4].SetValue(item_page_info[4][1])
1549	else:
1550	item_page[3].Hide()
1551	if item_page[5]!=None:
1552	## show of hide the text crtl for fitting error
1553	item_page[5].Show(item_page_info[5][0])
1554	item_page[5].SetValue(item_page_info[5][1])
1555
1556	if item_page[6]!=None:
1557	## show of hide the text crtl for fitting error
1558	item_page[6].Show(item_page_info[6][0])
1559	item_page[6].SetValue(item_page_info[6][1])
1560
1561
1562	def _reset_strparam_state(self, listtorestore, statelist):
1563	"""
1564	Reset the string parameters at the given state
1565	"""
1566	if len(statelist) == 0:
1567	return
1568
1569	listtorestore = copy.deepcopy(statelist)
1570
1571	for j in range(len(listtorestore)):
1572	item_page = listtorestore[j]
1573	item_page_info = statelist[j]
1574	##change the state of the check box for simple parameters
1575
1576	if item_page[0] != None:
1577	item_page[0].SetValue(format_number(item_page_info[0], True))
1578
1579	if item_page[2] != None:
1580	param_name = item_page_info[1]
1581	value = item_page_info[2]
1582	selection = value
1583	if self.model.fun_list.has_key(value):
1584	selection = self.model.fun_list[value]
1585	item_page[2].SetValue(selection)
1586	self.model.setParam(param_name, selection)
1587
1588	def _copy_parameters_state(self, listtocopy, statelist):
1589	"""
1590	copy the state of button
1591
1592	:param listtocopy: the list of check button to copy
1593	:param statelist: list of state object to store the current state
1594
1595	"""
1596	if len(listtocopy)==0:
1597	return
1598
1599	for item in listtocopy:
1600
1601	checkbox_state = None
1602	if item[0]!= None:
1603	checkbox_state= item[0].GetValue()
1604	parameter_name = item[1]
1605	parameter_value = None
1606	if item[2]!=None:
1607	parameter_value = item[2].GetValue()
1608	static_text = None
1609	if item[3]!=None:
1610	static_text = item[3].IsShown()
1611	error_value = None
1612	error_state = None
1613	if item[4]!= None:
1614	error_value = item[4].GetValue()
1615	error_state = item[4].IsShown()
1616
1617	min_value = None
1618	min_state = None
1619	if item[5]!= None:
1620	min_value = item[5].GetValue()
1621	min_state = item[5].IsShown()
1622
1623	max_value = None
1624	max_state = None
1625	if item[6]!= None:
1626	max_value = item[6].GetValue()
1627	max_state = item[6].IsShown()
1628	unit=None
1629	if item[7]!=None:
1630	unit = item[7].GetLabel()
1631
1632	statelist.append([checkbox_state, parameter_name, parameter_value,
1633	static_text ,[error_state, error_value],
1634	[min_state, min_value],
1635	[max_state, max_value], unit])
1636
1637	def _set_model_sizer_selection(self, model):
1638	"""
1639	Display the sizer according to the type of the current model
1640	"""
1641	if model == None:
1642	return
1643	if hasattr(model ,"s_model"):
1644
1645	class_name = model.s_model.__class__
1646	name = model.s_model.name
1647	flag = (name != "NoStructure")
1648	if flag and \
1649	(class_name in self.model_list_box["Structure Factors"]):
1650	self.structurebox.Show()
1651	self.text2.Show()
1652	self.structurebox.Enable()
1653	self.text2.Enable()
1654	items = self.structurebox.GetItems()
1655	self.sizer1.Layout()
1656
1657	for i in range(len(items)):
1658	if items[i]== str(name):
1659	self.structurebox.SetSelection(i)
1660	break
1661
1662	if hasattr(model ,"p_model"):
1663	class_name = model.p_model.__class__
1664	name = model.p_model.name
1665	self.formfactorbox.Clear()
1666
1667	for k, list in self.model_list_box.iteritems():
1668	if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]:
1669	self.shape_rbutton.SetValue(True)
1670	## fill the form factor list with new model
1671	self._populate_box(self.formfactorbox,self.model_list_box["Shapes"])
1672	items = self.formfactorbox.GetItems()
1673	## set comboxbox to the selected item
1674	for i in range(len(items)):
1675	if items[i]== str(name):
1676	self.formfactorbox.SetSelection(i)
1677	break
1678	return
1679	elif k == "Shape-Independent":
1680	self.shape_indep_rbutton.SetValue(True)
1681	elif k == "Structure Factors":
1682	self.struct_rbutton.SetValue(True)
1683	elif k == "Multi-Functions":
1684	continue
1685	else:
1686	self.plugin_rbutton.SetValue(True)
1687
1688	if class_name in list:
1689	## fill the form factor list with new model
1690	self._populate_box(self.formfactorbox, list)
1691	items = self.formfactorbox.GetItems()
1692	## set comboxbox to the selected item
1693	for i in range(len(items)):
1694	if items[i]== str(name):
1695	self.formfactorbox.SetSelection(i)
1696	break
1697	break
1698	else:
1699
1700	## Select the model from the menu
1701	class_name = model.__class__
1702	name = model.name
1703	self.formfactorbox.Clear()
1704	items = self.formfactorbox.GetItems()
1705
1706	for k, list in self.model_list_box.iteritems():
1707	if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]:
1708	if class_name in self.model_list_box["P(Q)*S(Q)"]:
1709	self.structurebox.Show()
1710	self.text2.Show()
1711	self.structurebox.Enable()
1712	self.structurebox.SetSelection(0)
1713	self.text2.Enable()
1714	else:
1715	self.structurebox.Hide()
1716	self.text2.Hide()
1717	self.structurebox.Disable()
1718	self.structurebox.SetSelection(0)
1719	self.text2.Disable()
1720
1721	self.shape_rbutton.SetValue(True)
1722	## fill the form factor list with new model
1723	self._populate_box(self.formfactorbox,self.model_list_box["Shapes"])
1724	items = self.formfactorbox.GetItems()
1725	## set comboxbox to the selected item
1726	for i in range(len(items)):
1727	if items[i]== str(name):
1728	self.formfactorbox.SetSelection(i)
1729	break
1730	return
1731	elif k == "Shape-Independent":
1732	self.shape_indep_rbutton.SetValue(True)
1733	elif k == "Structure Factors":
1734	self.struct_rbutton.SetValue(True)
1735	elif k == "Multi-Functions":
1736	continue
1737	else:
1738	self.plugin_rbutton.SetValue(True)
1739	if class_name in list:
1740	self.structurebox.SetSelection(0)
1741	self.structurebox.Disable()
1742	self.text2.Disable()
1743	## fill the form factor list with new model
1744	self._populate_box(self.formfactorbox, list)
1745	items = self.formfactorbox.GetItems()
1746	## set comboxbox to the selected item
1747	for i in range(len(items)):
1748	if items[i]== str(name):
1749	self.formfactorbox.SetSelection(i)
1750	break
1751	break
1752
1753	def _draw_model(self, update_chisqr=True):
1754	"""
1755	Method to draw or refresh a plotted model.
1756	The method will use the data member from the model page
1757	to build a call to the fitting perspective manager.
1758
1759	:param chisqr: update chisqr value [bool]
1760	"""
1761	#if self.check_invalid_panel():
1762	# return
1763	if self.model !=None:
1764	temp_smear=None
1765	if hasattr(self, "enable_smearer"):
1766	if not self.disable_smearer.GetValue():
1767	temp_smear= self.current_smearer
1768	toggle_mode_on = self.model_view.IsEnabled()
1769	self._manager.draw_model(self.model,
1770	data=self.data,
1771	smearer= temp_smear,
1772	qmin=float(self.qmin_x),
1773	qmax=float(self.qmax_x),
1774	page_id=self.uid,
1775	toggle_mode_on=toggle_mode_on,
1776	state = self.state,
1777	enable2D=self.enable2D,
1778	update_chisqr=update_chisqr)
1779
1780
1781	def _on_show_sld(self, event=None):
1782	"""
1783	Plot SLD profile
1784	"""
1785	# get profile data
1786	x,y=self.model.getProfile()
1787
1788	from danse.common.plottools import Data1D
1789	#from sans.perspectives.theory.profile_dialog import SLDPanel
1790	from sans.guiframe.local_perspectives.plotting.profile_dialog \
1791	import SLDPanel
1792	sld_data = Data1D(x,y)
1793	sld_data.name = 'SLD'
1794	sld_data.axes = self.sld_axes
1795	self.panel = SLDPanel(self, data=sld_data, axes =self.sld_axes,id =-1)
1796	self.panel.ShowModal()
1797
1798	def _set_multfactor_combobox(self, multiplicity=10):
1799	"""
1800	Set comboBox for muitfactor of CoreMultiShellModel
1801	:param multiplicit: no. of multi-functionality
1802	"""
1803	# build content of the combobox
1804	for idx in range(0,multiplicity):
1805	self.multifactorbox.Append(str(idx),int(idx))
1806	#self.multifactorbox.SetSelection(1)
1807	self._hide_multfactor_combobox()
1808
1809	def _show_multfactor_combobox(self):
1810	"""
1811	Show the comboBox of muitfactor of CoreMultiShellModel
1812	"""
1813	if not self.mutifactor_text.IsShown():
1814	self.mutifactor_text.Show(True)
1815	self.mutifactor_text1.Show(True)
1816	if not self.multifactorbox.IsShown():
1817	self.multifactorbox.Show(True)
1818
1819	def _hide_multfactor_combobox(self):
1820	"""
1821	Hide the comboBox of muitfactor of CoreMultiShellModel
1822	"""
1823	if self.mutifactor_text.IsShown():
1824	self.mutifactor_text.Hide()
1825	self.mutifactor_text1.Hide()
1826	if self.multifactorbox.IsShown():
1827	self.multifactorbox.Hide()
1828
1829
1830	def _show_combox_helper(self):
1831	"""
1832	Fill panel's combo box according to the type of model selected
1833	"""
1834	if self.shape_rbutton.GetValue():
1835	##fill the combobox with form factor list
1836	self.structurebox.SetSelection(0)
1837	self.structurebox.Disable()
1838	self.formfactorbox.Clear()
1839	self._populate_box( self.formfactorbox,self.model_list_box["Shapes"])
1840	if self.shape_indep_rbutton.GetValue():
1841	##fill the combobox with shape independent factor list
1842	self.structurebox.SetSelection(0)
1843	self.structurebox.Disable()
1844	self.formfactorbox.Clear()
1845	self._populate_box( self.formfactorbox,
1846	self.model_list_box["Shape-Independent"])
1847	if self.struct_rbutton.GetValue():
1848	##fill the combobox with structure factor list
1849	self.structurebox.SetSelection(0)
1850	self.structurebox.Disable()
1851	self.formfactorbox.Clear()
1852	self._populate_box( self.formfactorbox,
1853	self.model_list_box["Structure Factors"])
1854	if self.plugin_rbutton.GetValue():
1855	##fill the combobox with form factor list
1856	self.structurebox.Disable()
1857	self.formfactorbox.Clear()
1858	self._populate_box( self.formfactorbox,
1859	self.model_list_box["Customized Models"])
1860
1861	def _show_combox(self, event=None):
1862	"""
1863	Show combox box associate with type of model selected
1864	"""
1865	#if self.check_invalid_panel():
1866	# self.shape_rbutton.SetValue(True)
1867	# return
1868
1869	self._show_combox_helper()
1870	self._on_select_model(event=None)
1871	self._save_typeOfmodel()
1872	self.sizer4_4.Layout()
1873	self.sizer4.Layout()
1874	self.Layout()
1875	self.Refresh()
1876
1877	def _populate_box(self, combobox, list):
1878	"""
1879	fill combox box with dict item
1880
1881	:param list: contains item to fill the combox
1882	item must model class
1883	"""
1884	for models in list:
1885	model= models()
1886	name = model.__class__.__name__
1887	if models.__name__!="NoStructure":
1888	if hasattr(model, "name"):
1889	name = model.name
1890	combobox.Append(name,models)
1891	return 0
1892
1893	def _onQrangeEnter(self, event):
1894	"""
1895	Check validity of value enter in the Q range field
1896
1897	"""
1898	tcrtl = event.GetEventObject()
1899	#Clear msg if previously shown.
1900	msg = ""
1901	wx.PostEvent(self.parent, StatusEvent(status=msg))
1902	# Flag to register when a parameter has changed.
1903	is_modified = False
1904	if tcrtl.GetValue().lstrip().rstrip() != "":
1905	try:
1906	value = float(tcrtl.GetValue())
1907	tcrtl.SetBackgroundColour(wx.WHITE)
1908	# If qmin and qmax have been modified, update qmin and qmax
1909	if self._validate_qrange(self.qmin, self.qmax):
1910	tempmin = float(self.qmin.GetValue())
1911	if tempmin != self.qmin_x:
1912	self.qmin_x = tempmin
1913	tempmax = float(self.qmax.GetValue())
1914	if tempmax != self.qmax_x:
1915	self.qmax_x = tempmax
1916	else:
1917	tcrtl.SetBackgroundColour("pink")
1918	msg = "Model Error:wrong value entered : %s" % sys.exc_value
1919	wx.PostEvent(self.parent, StatusEvent(status=msg))
1920	return
1921	except:
1922	tcrtl.SetBackgroundColour("pink")
1923	msg = "Model Error:wrong value entered : %s" % sys.exc_value
1924	wx.PostEvent(self.parent, StatusEvent(status=msg))
1925	return
1926	#Check if # of points for theory model are valid(>0).
1927	if self.npts != None:
1928	if check_float(self.npts):
1929	temp_npts = float(self.npts.GetValue())
1930	if temp_npts != self.num_points:
1931	self.num_points = temp_npts
1932	is_modified = True
1933	else:
1934	msg = "Cannot Plot :No npts in that Qrange!!! "
1935	wx.PostEvent(self.parent, StatusEvent(status=msg))
1936	else:
1937	tcrtl.SetBackgroundColour("pink")
1938	msg = "Model Error:wrong value entered!!!"
1939	wx.PostEvent(self.parent, StatusEvent(status=msg))
1940	#self._undo.Enable(True)
1941	self.save_current_state()
1942	event = PageInfoEvent(page=self)
1943	wx.PostEvent(self.parent, event)
1944	self.state_change = False
1945	#Draw the model for a different range
1946	self.create_default_data()
1947	self._draw_model()
1948
1949	def _theory_qrange_enter(self, event):
1950	"""
1951	Check validity of value enter in the Q range field
1952	"""
1953
1954	tcrtl= event.GetEventObject()
1955	#Clear msg if previously shown.
1956	msg= ""
1957	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1958	# Flag to register when a parameter has changed.
1959	is_modified = False
1960	if tcrtl.GetValue().lstrip().rstrip()!="":
1961	try:
1962	value = float(tcrtl.GetValue())
1963	tcrtl.SetBackgroundColour(wx.WHITE)
1964
1965	# If qmin and qmax have been modified, update qmin and qmax
1966	if self._validate_qrange(self.theory_qmin, self.theory_qmax):
1967	tempmin = float(self.theory_qmin.GetValue())
1968	if tempmin != self.theory_qmin_x:
1969	self.theory_qmin_x = tempmin
1970	tempmax = float(self.theory_qmax.GetValue())
1971	if tempmax != self.qmax_x:
1972	self.theory_qmax_x = tempmax
1973	else:
1974	tcrtl.SetBackgroundColour("pink")
1975	msg= "Model Error:wrong value entered : %s"% sys.exc_value
1976	wx.PostEvent(self._manager.parent, StatusEvent(status = msg ))
1977	return
1978	except:
1979	tcrtl.SetBackgroundColour("pink")
1980	msg= "Model Error:wrong value entered : %s"% sys.exc_value
1981	wx.PostEvent(self._manager.parent, StatusEvent(status = msg ))
1982	return
1983	#Check if # of points for theory model are valid(>0).
1984	if self.Npts_total.IsEditable() :
1985	if check_float(self.Npts_total):
1986	temp_npts = float(self.Npts_total.GetValue())
1987	if temp_npts != self.num_points:
1988	self.num_points = temp_npts
1989	is_modified = True
1990	else:
1991	msg= "Cannot Plot :No npts in that Qrange!!! "
1992	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1993	else:
1994	tcrtl.SetBackgroundColour("pink")
1995	msg = "Model Error:wrong value entered!!!"
1996	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
1997	#self._undo.Enable(True)
1998	self.save_current_state()
1999	event = PageInfoEvent(page = self)
2000	wx.PostEvent(self.parent, event)
2001	self.state_change= False
2002	#Draw the model for a different range
2003	self.create_default_data()
2004	self._draw_model()
2005
2006	def _on_select_model_helper(self):
2007	"""
2008	call back for model selection
2009	"""
2010	## reset dictionary containing reference to dispersion
2011	self._disp_obj_dict = {}
2012	self.disp_cb_dict ={}
2013	self.temp_multi_functional = False
2014	f_id = self.formfactorbox.GetCurrentSelection()
2015	#For MAC
2016	form_factor = None
2017	if f_id >= 0:
2018	form_factor = self.formfactorbox.GetClientData(f_id)
2019
2020	if not form_factor in self.model_list_box["multiplication"]:
2021	self.structurebox.Hide()
2022	self.text2.Hide()
2023	self.structurebox.Disable()
2024	self.structurebox.SetSelection(0)
2025	self.text2.Disable()
2026	else:
2027	self.structurebox.Show()
2028	self.text2.Show()
2029	self.structurebox.Enable()
2030	self.text2.Enable()
2031
2032	if form_factor != None:
2033	# set multifactor for Mutifunctional models
2034	if form_factor().__class__ in self.model_list_box["Multi-Functions"]:
2035	m_id = self.multifactorbox.GetCurrentSelection()
2036	multiplicity = form_factor().multiplicity_info[0]
2037	self.multifactorbox.Clear()
2038	#self.mutifactor_text.SetLabel(form_factor().details[])
2039	self._set_multfactor_combobox(multiplicity)
2040	self._show_multfactor_combobox()
2041	#ToDo: this info should be called directly from the model
2042	text = form_factor().multiplicity_info[1]#'No. of Shells: '
2043
2044	#self.mutifactor_text.Clear()
2045	self.mutifactor_text.SetLabel(text)
2046	if m_id > multiplicity -1:
2047	# default value
2048	m_id = 1
2049
2050	self.multi_factor = self.multifactorbox.GetClientData(m_id)
2051	if self.multi_factor == None: self.multi_factor =0
2052	form_factor = form_factor(int(self.multi_factor))
2053	self.multifactorbox.SetSelection(m_id)
2054	# Check len of the text1 and max_multiplicity
2055	text = ''
2056	if form_factor.multiplicity_info[0] == len(form_factor.multiplicity_info[2]):
2057	text = form_factor.multiplicity_info[2][self.multi_factor]
2058	self.mutifactor_text1.SetLabel(text)
2059	# Check if model has get sld profile.
2060	if len(form_factor.multiplicity_info[3]) > 0:
2061	self.sld_axes = form_factor.multiplicity_info[3]
2062	self.show_sld_button.Show(True)
2063	else:
2064	self.sld_axes = ""
2065
2066	else:
2067	self._hide_multfactor_combobox()
2068	self.show_sld_button.Hide()
2069	form_factor = form_factor()
2070	self.multi_factor = None
2071	else:
2072	self._hide_multfactor_combobox()
2073	self.show_sld_button.Hide()
2074	self.multi_factor = None
2075
2076	s_id = self.structurebox.GetCurrentSelection()
2077	struct_factor = self.structurebox.GetClientData( s_id )
2078
2079	if struct_factor !=None:
2080	from sans.models.MultiplicationModel import MultiplicationModel
2081	self.model= MultiplicationModel(form_factor,struct_factor())
2082	# multifunctional form factor
2083	if len(form_factor.non_fittable) > 0:
2084	self.temp_multi_functional = True
2085	else:
2086	if form_factor != None:
2087	self.model= form_factor
2088	else:
2089	self.model = None
2090	return self.model
2091
2092
2093	## post state to fit panel
2094	self.state.parameters =[]
2095	self.state.model =self.model
2096	self.state.qmin = self.qmin_x
2097	self.state.multi_factor = self.multi_factor
2098	self.disp_list =self.model.getDispParamList()
2099	self.state.disp_list = self.disp_list
2100	self.on_set_focus(None)
2101	self.Layout()
2102
2103	def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
2104	"""
2105	Verify that the Q range controls have valid values
2106	and that Qmin < Qmax.
2107
2108	:param qmin_ctrl: text control for Qmin
2109	:param qmax_ctrl: text control for Qmax
2110
2111	:return: True is the Q range is value, False otherwise
2112
2113	"""
2114	qmin_validity = check_float(qmin_ctrl)
2115	qmax_validity = check_float(qmax_ctrl)
2116	if not (qmin_validity and qmax_validity):
2117	return False
2118	else:
2119	qmin = float(qmin_ctrl.GetValue())
2120	qmax = float(qmax_ctrl.GetValue())
2121	if qmin < qmax:
2122	#Make sure to set both colours white.
2123	qmin_ctrl.SetBackgroundColour(wx.WHITE)
2124	qmin_ctrl.Refresh()
2125	qmax_ctrl.SetBackgroundColour(wx.WHITE)
2126	qmax_ctrl.Refresh()
2127	else:
2128	qmin_ctrl.SetBackgroundColour("pink")
2129	qmin_ctrl.Refresh()
2130	qmax_ctrl.SetBackgroundColour("pink")
2131	qmax_ctrl.Refresh()
2132	msg= "Invalid Q range: Q min must be smaller than Q max"
2133	wx.PostEvent(self.parent.parent, StatusEvent(status = msg))
2134	return False
2135	return True
2136
2137	def _validate_Npts(self):
2138	"""
2139	Validate the number of points for fitting is more than 10 points.
2140	If valid, setvalues Npts_fit otherwise post msg.
2141	"""
2142	#default flag
2143	flag = True
2144	# Theory
2145	if self.data == None and self.enable2D:
2146	return flag
2147
2148	# q value from qx and qy
2149	radius= numpy.sqrt( self.data.qx_data * self.data.qx_data +
2150	self.data.qy_data * self.data.qy_data )
2151	#get unmasked index
2152	index_data = (float(self.qmin.GetValue()) <= radius) & \
2153	(radius <= float(self.qmax.GetValue()))
2154	index_data = (index_data) & (self.data.mask)
2155	index_data = (index_data) & (numpy.isfinite(self.data.data))
2156
2157	if len(index_data[index_data]) < 10:
2158	# change the color pink.
2159	self.qmin.SetBackgroundColour("pink")
2160	self.qmin.Refresh()
2161	self.qmax.SetBackgroundColour("pink")
2162	self.qmax.Refresh()
2163	msg= "Cannot Plot :No or too little npts in that data range!!! "
2164	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2165	self.fitrange = False
2166	flag = False
2167	else:
2168	self.Npts_fit.SetValue(str(len(self.data.mask[index_data==True])))
2169	self.fitrange = True
2170
2171	return flag
2172
2173	def _check_value_enter(self, list, modified):
2174	"""
2175	:param list: model parameter and panel info
2176	:Note: each item of the list should be as follow:
2177	item=[check button state, parameter's name,
2178	paramater's value, string="+/-",
2179	parameter's error of fit,
2180	parameter's minimum value,
2181	parrameter's maximum value ,
2182	parameter's units]
2183	"""
2184	is_modified = modified
2185	if len(list)==0:
2186	return is_modified
2187	for item in list:
2188	#skip angle parameters for 1D
2189	if not self.enable2D:#self.data.__class__.__name__ !="Data2D":
2190	if item in self.orientation_params:
2191	continue
2192	#try:
2193	name = str(item[1])
2194
2195	if string.find(name,".npts") ==-1 and \
2196	string.find(name,".nsigmas")==-1:
2197	## check model parameters range
2198	param_min= None
2199	param_max= None
2200
2201	## check minimun value
2202	if item[5]!= None and item[5]!= "":
2203	if item[5].GetValue().lstrip().rstrip()!="":
2204	try:
2205
2206	param_min = float(item[5].GetValue())
2207	if not self._validate_qrange(item[5],item[2]):
2208	if numpy.isfinite(param_min):
2209	item[2].SetValue(format_number(param_min))
2210
2211	item[5].SetBackgroundColour(wx.WHITE)
2212	item[2].SetBackgroundColour(wx.WHITE)
2213
2214	except:
2215	msg = "Wrong Fit parameter range entered "
2216	wx.PostEvent(self.parent.parent,
2217	StatusEvent(status = msg))
2218	raise ValueError, msg
2219	is_modified = True
2220	## check maximum value
2221	if item[6]!= None and item[6]!= "":
2222	if item[6].GetValue().lstrip().rstrip()!="":
2223	try:
2224	param_max = float(item[6].GetValue())
2225	if not self._validate_qrange(item[2],item[6]):
2226	if numpy.isfinite(param_max):
2227	item[2].SetValue(format_number(param_max))
2228
2229	item[6].SetBackgroundColour(wx.WHITE)
2230	item[2].SetBackgroundColour(wx.WHITE)
2231	except:
2232	msg = "Wrong Fit parameter range entered "
2233	wx.PostEvent(self.parent.parent,
2234	StatusEvent(status = msg))
2235	raise ValueError, msg
2236	is_modified = True
2237
2238
2239	if param_min != None and param_max !=None:
2240	if not self._validate_qrange(item[5], item[6]):
2241	msg= "Wrong Fit range entered for parameter "
2242	msg+= "name %s of model %s "%(name, self.model.name)
2243	wx.PostEvent(self.parent.parent,
2244	StatusEvent(status = msg))
2245
2246	if name in self.model.details.keys():
2247	self.model.details[name][1:3] = param_min, param_max
2248	is_modified = True
2249
2250	else:
2251	self.model.details [name] = ["", param_min, param_max]
2252	is_modified = True
2253	try:
2254	# Check if the textctr is enabled
2255	if item[2].IsEnabled():
2256	value= float(item[2].GetValue())
2257	item[2].SetBackgroundColour("white")
2258	# If the value of the parameter has changed,
2259	# +update the model and set the is_modified flag
2260	if value != self.model.getParam(name) and \
2261	numpy.isfinite(value):
2262	self.model.setParam(name, value)
2263
2264	except:
2265	item[2].SetBackgroundColour("pink")
2266	msg = "Wrong Fit parameter value entered "
2267	wx.PostEvent(self.parent.parent, StatusEvent(status = msg))
2268
2269	return is_modified
2270
2271
2272	def _set_dipers_Param(self, event):
2273	"""
2274	respond to self.enable_disp and self.disable_disp radio box.
2275	The dispersity object is reset inside the model into Gaussian.
2276	When the user select yes , this method display a combo box for more selection
2277	when the user selects No,the combo box disappears.
2278	Redraw the model with the default dispersity (Gaussian)
2279	"""
2280	#if self.check_invalid_panel():
2281	# return
2282	## On selction if no model exists.
2283	if self.model ==None:
2284	self.disable_disp.SetValue(True)
2285	msg="Please select a Model first..."
2286	wx.MessageBox(msg, 'Info')
2287	wx.PostEvent(self._manager.parent, StatusEvent(status=\
2288	"Polydispersion: %s"%msg))
2289	return
2290
2291	self._reset_dispersity()
2292
2293	if self.model ==None:
2294	self.model_disp.Hide()
2295	self.sizer4_4.Clear(True)
2296	return
2297
2298	if self.enable_disp.GetValue():
2299	## layout for model containing no dispersity parameters
2300
2301	self.disp_list= self.model.getDispParamList()
2302
2303	if len(self.disp_list)==0 and len(self.disp_cb_dict)==0:
2304	self._layout_sizer_noDipers()
2305	else:
2306	## set gaussian sizer
2307	self._on_select_Disp(event=None)
2308	else:
2309	self.sizer4_4.Clear(True)
2310
2311	## post state to fit panel
2312	self.save_current_state()
2313	if event !=None:
2314	#self._undo.Enable(True)
2315	event = PageInfoEvent(page = self)
2316	wx.PostEvent(self.parent, event)
2317	#draw the model with the current dispersity
2318	self._draw_model()
2319	self.sizer4_4.Layout()
2320	self.sizer5.Layout()
2321	self.Layout()
2322	self.Refresh()
2323
2324
2325	def _layout_sizer_noDipers(self):
2326	"""
2327	Draw a sizer with no dispersity info
2328	"""
2329	ix=0
2330	iy=1
2331	self.fittable_param=[]
2332	self.fixed_param=[]
2333	self.orientation_params_disp=[]
2334
2335	self.sizer4_4.Clear(True)
2336	text = "No polydispersity available for this model"
2337	text = "No polydispersity available for this model"
2338	model_disp = wx.StaticText(self, -1, text)
2339	self.sizer4_4.Add(model_disp,( iy, ix),(1,1),
2340	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 10)
2341	self.sizer4_4.Layout()
2342	self.sizer4.Layout()
2343
2344	def _reset_dispersity(self):
2345	"""
2346	put gaussian dispersity into current model
2347	"""
2348	if len(self.param_toFit)>0:
2349	for item in self.fittable_param:
2350	if item in self.param_toFit:
2351	self.param_toFit.remove(item)
2352
2353	for item in self.orientation_params_disp:
2354	if item in self.param_toFit:
2355	self.param_toFit.remove(item)
2356
2357	self.fittable_param=[]
2358	self.fixed_param=[]
2359	self.orientation_params_disp=[]
2360	self.values={}
2361	self.weights={}
2362
2363	from sans.models.dispersion_models import GaussianDispersion, ArrayDispersion
2364	if len(self.disp_cb_dict)==0:
2365	self.save_current_state()
2366	self.sizer4_4.Clear(True)
2367	self.Layout()
2368
2369	return
2370	if (len(self.disp_cb_dict)>0) :
2371	for p in self.disp_cb_dict:
2372	# The parameter was un-selected. Go back to Gaussian model (with 0 pts)
2373	disp_model = GaussianDispersion()
2374
2375	self._disp_obj_dict[p] = disp_model
2376	# Set the new model as the dispersion object for the selected parameter
2377	try:
2378	self.model.set_dispersion(p, disp_model)
2379	except:
2380
2381	pass
2382
2383	## save state into
2384	self.save_current_state()
2385	self.Layout()
2386	self.Refresh()
2387
2388	def _on_select_Disp(self,event):
2389	"""
2390	allow selecting different dispersion
2391	self.disp_list should change type later .now only gaussian
2392	"""
2393	self._set_sizer_dispersion()
2394
2395	## Redraw the model
2396	self._draw_model()
2397	#self._undo.Enable(True)
2398	event = PageInfoEvent(page = self)
2399	wx.PostEvent(self.parent, event)
2400
2401	self.sizer4_4.Layout()
2402	self.sizer4.Layout()
2403	self.SetupScrolling()
2404
2405	def _on_disp_func(self, event=None):
2406	"""
2407	Select a distribution function for the polydispersion
2408
2409	:Param event: ComboBox event
2410	"""
2411	# get ready for new event
2412	if event != None:
2413	event.Skip()
2414	# Get event object
2415	disp_box = event.GetEventObject()
2416
2417	# Try to select a Distr. function
2418	try:
2419	disp_box.SetBackgroundColour("white")
2420	selection = disp_box.GetCurrentSelection()
2421	param_name = disp_box.Name.split('.')[0]
2422	disp_name = disp_box.GetValue()
2423	dispersity= disp_box.GetClientData(selection)
2424
2425	#disp_model = GaussianDispersion()
2426	disp_model = dispersity()
2427	# Get param names to reset the values of the param
2428	name1 = param_name + ".width"
2429	name2 = param_name + ".npts"
2430	name3 = param_name + ".nsigmas"
2431	# Check Disp. function whether or not it is 'array'
2432	if disp_name.lower() == "array":
2433	value2= ""
2434	value3= ""
2435	value1 = self._set_array_disp(name=name1, disp=disp_model)
2436	else:
2437	self._del_array_values(name1)
2438	#self._reset_array_disp(param_name)
2439	self._disp_obj_dict[name1] = disp_model
2440	self.model.set_dispersion(param_name, disp_model)
2441	self.state._disp_obj_dict[name1]= disp_model
2442
2443	value1= str(format_number(self.model.getParam(name1), True))
2444	value2= str(format_number(self.model.getParam(name2)))
2445	value3= str(format_number(self.model.getParam(name3)))
2446	# Reset fittable polydispersin parameter value
2447	for item in self.fittable_param:
2448	if item[1] == name1:
2449	item[2].SetValue(value1)
2450	item[5].SetValue("")
2451	item[6].SetValue("")
2452	# Disable for array
2453	if disp_name.lower() == "array":
2454	item[0].SetValue(False)
2455	item[0].Disable()
2456	item[2].Disable()
2457	item[5].Disable()
2458	item[6].Disable()
2459	else:
2460	item[0].Enable()
2461	item[2].Enable()
2462	item[5].Enable()
2463	item[6].Enable()
2464	break
2465	# Reset fixed polydispersion params
2466	for item in self.fixed_param:
2467	if item[1] == name2:
2468	item[2].SetValue(value2)
2469	# Disable Npts for array
2470	if disp_name.lower() == "array":
2471	item[2].Disable()
2472	else:
2473	item[2].Enable()
2474	if item[1] == name3:
2475	item[2].SetValue(value3)
2476	# Disable Nsigs for array
2477	if disp_name.lower() == "array":
2478	item[2].Disable()
2479	else:
2480	item[2].Enable()
2481
2482	# Make sure the check box updated when all checked
2483	if self.cb1.GetValue():
2484	self.select_all_param(None)
2485
2486	# update params
2487	self._update_paramv_on_fit()
2488	# draw
2489	self._draw_model()
2490	self.Refresh()
2491	except:
2492	# Error msg
2493	msg = "Error occurred:"
2494	msg += " Could not select the distribution function..."
2495	msg += " Please select another distribution function."
2496	disp_box.SetBackgroundColour("pink")
2497	# Focus on Fit button so that users can see the pinky box
2498	self.btFit.SetFocus()
2499	wx.PostEvent(self.parent.parent,
2500	StatusEvent(status=msg, info="error"))
2501
2502
2503	def _set_array_disp(self, name=None, disp=None):
2504	"""
2505	Set array dispersion
2506
2507	:param name: name of the parameter for the dispersion to be set
2508	:param disp: the polydisperion object
2509	"""
2510	# The user wants this parameter to be averaged.
2511	# Pop up the file selection dialog.
2512	path = self._selectDlg()
2513	# Array data
2514	values = []
2515	weights = []
2516	# If nothing was selected, just return
2517	if path is None:
2518	self.disp_cb_dict[name].SetValue(False)
2519	#self.noDisper_rbox.SetValue(True)
2520	return
2521	self._default_save_location = os.path.dirname(path)
2522
2523	basename = os.path.basename(path)
2524	values,weights = self.read_file(path)
2525
2526	# If any of the two arrays is empty, notify the user that we won't
2527	# proceed
2528	if len(self.param_toFit)>0:
2529	if name in self.param_toFit:
2530	self.param_toFit.remove(name)
2531
2532	# Tell the user that we are about to apply the distribution
2533	msg = "Applying loaded %s distribution: %s" % (name, path)
2534	wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
2535
2536	disp.set_weights(values, weights)
2537	self._disp_obj_dict[name] = disp
2538	self.model.set_dispersion(name.split('.')[0], disp)
2539	self.state._disp_obj_dict[name]= disp
2540	self.values[name] = values
2541	self.weights[name] = weights
2542	# Store the object to make it persist outside the
2543	# scope of this method
2544	#TODO: refactor model to clean this up?
2545	self.state.values = {}
2546	self.state.weights = {}
2547	self.state.values = copy.deepcopy(self.values)
2548	self.state.weights = copy.deepcopy(self.weights)
2549
2550	# Set the new model as the dispersion object for the
2551	#selected parameter
2552	#self.model.set_dispersion(p, disp_model)
2553	# Store a reference to the weights in the model object
2554	#so that
2555	# it's not lost when we use the model within another thread.
2556	#TODO: total hack - fix this
2557	self.state.model= self.model.clone()
2558	self.model._persistency_dict[name.split('.')[0]] = \
2559	[values, weights]
2560	self.state.model._persistency_dict[name.split('.')[0]] = \
2561	[values,weights]
2562	return basename
2563
2564	def _del_array_values(self, name=None):
2565	"""
2566	Reset array dispersion
2567
2568	:param name: name of the parameter for the dispersion to be set
2569	"""
2570	# Try to delete values and weight of the names array dic if exists
2571	try:
2572	del self.values[name]
2573	del self.weights[name]
2574	# delete all other dic
2575	del self.state.values[name]
2576	del self.state.weights[name]
2577	del self.model._persistency_dict[name.split('.')[0]]
2578	del self.state.model._persistency_dict[name.split('.')[0]]
2579	except:
2580	pass
2581
2582	def _lay_out(self):
2583	"""
2584	returns self.Layout
2585
2586	:Note: Mac seems to like this better when self.
2587	Layout is called after fitting.
2588	"""
2589	self._sleep4sec()
2590	self.Layout()
2591	return
2592
2593	def _sleep4sec(self):
2594	"""
2595	sleep for 1 sec only applied on Mac
2596	Note: This 1sec helps for Mac not to crash on self.:ayout after self._draw_model
2597	"""
2598	if ON_MAC == True:
2599	time.sleep(1)
2600
2601	def _find_polyfunc_selection(self, disp_func = None):
2602	"""
2603	FInd Comboox selection from disp_func
2604
2605	:param disp_function: dispersion distr. function
2606	"""
2607	# List of the poly_model name in the combobox
2608	list = ["RectangleDispersion", "ArrayDispersion",
2609	"LogNormalDispersion", "GaussianDispersion",
2610	"SchulzDispersion"]
2611
2612	# Find the selection
2613	try:
2614	selection = list.index(disp_func.__class__.__name__)
2615	return selection
2616	except:
2617	return 3
2618
2619	def on_reset_clicked(self,event):
2620	"""
2621	On 'Reset' button for Q range clicked
2622	"""
2623	flag = True
2624	#if self.check_invalid_panel():
2625	# return
2626	##For 3 different cases: Data2D, Data1D, and theory
2627	if self.model == None:
2628	msg="Please select a model first..."
2629	wx.MessageBox(msg, 'Info')
2630	flag = False
2631	return
2632
2633	elif self.data.__class__.__name__ == "Data2D":
2634	data_min= 0
2635	x= max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
2636	y= max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
2637	self.qmin_x = data_min
2638	self.qmax_x = math.sqrt(xx + yy)
2639	# check smearing
2640	if not self.disable_smearer.GetValue():
2641	temp_smearer= self.current_smearer
2642	## set smearing value whether or not the data contain the smearing info
2643	if self.pinhole_smearer.GetValue():
2644	flag = self.update_pinhole_smear()
2645	else:
2646	flag = True
2647
2648	elif self.data == None:
2649	self.qmin_x = _QMIN_DEFAULT
2650	self.qmax_x = _QMAX_DEFAULT
2651	self.num_points = _NPTS_DEFAULT
2652	self.state.npts = self.num_points
2653
2654	elif self.data.__class__.__name__ != "Data2D":
2655	self.qmin_x = min(self.data.x)
2656	self.qmax_x = max(self.data.x)
2657	# check smearing
2658	if not self.disable_smearer.GetValue():
2659	temp_smearer= self.current_smearer
2660	## set smearing value whether or not the data contain the smearing info
2661	if self.slit_smearer.GetValue():
2662	flag = self.update_slit_smear()
2663	elif self.pinhole_smearer.GetValue():
2664	flag = self.update_pinhole_smear()
2665	else:
2666	flag = True
2667	else:
2668	flag = False
2669
2670	if flag == False:
2671	msg= "Cannot Plot :Must enter a number!!! "
2672	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2673	else:
2674	# set relative text ctrs.
2675	self.qmin.SetValue(str(self.qmin_x))
2676	self.qmax.SetValue(str(self.qmax_x))
2677	self.set_npts2fit()
2678	# At this point, some button and variables satatus (disabled?) should be checked
2679	# such as color that should be reset to white in case that it was pink.
2680	self._onparamEnter_helper()
2681
2682	self.save_current_state()
2683	self.state.qmin = self.qmin_x
2684	self.state.qmax = self.qmax_x
2685
2686	#reset the q range values
2687	self._reset_plotting_range(self.state)
2688	#self.compute_chisqr(smearer=self.current_smearer)
2689	#Re draw plot
2690	self._draw_model()
2691
2692	def get_images(self):
2693	"""
2694	Get the images of the plots corresponding this panel for report
2695
2696	: return graphs: list of figures
2697	: TODO: Move to guiframe
2698	"""
2699	# set list of graphs
2700	graphs = []
2701	canvases = []
2702	# call gui_manager
2703	gui_manager = self.parent.parent
2704	# loops through the panels [dic]
2705	for item1, item2 in gui_manager.panels.iteritems():
2706	data_title = self.data.group_id
2707	data_name = str(self.data.name).split(" [")[0]
2708	# try to get all plots belonging to this control panel
2709	try:
2710	title = ''
2711	# check titles (main plot)
2712	if hasattr(item2,"data2D"):
2713	title = item2.data2D.title
2714	# and data_names (model plot[2D], and residuals)
2715	if item2.group_id == data_title or \
2716	title.count(data_name) or \
2717	item2.window_name.count(data_name) or \
2718	item2.window_caption.count(data_name):
2719	#panel = gui_manager._mgr.GetPane(item2.window_name)
2720	# append to the list
2721	graphs.append(item2.figure)
2722	canvases.append(item2.canvas)
2723	except:
2724	# Not for control panels
2725	pass
2726	# return the list of graphs
2727	return graphs, canvases
2728
2729	def on_model_help_clicked(self,event):
2730	"""
2731	on 'More details' button
2732	"""
2733	from help_panel import HelpWindow
2734	from sans.models import get_data_path
2735
2736	# Get models help model_function path
2737	path = get_data_path(media='media')
2738	model_path = os.path.join(path,"model_functions.html")
2739	if self.model == None:
2740	name = 'FuncHelp'
2741	else:
2742	name = self.formfactorbox.GetValue()
2743	#name = self.model.__class__.__name__
2744	frame = HelpWindow(None, -1, pageToOpen=model_path)
2745	frame.Show(True)
2746	if frame.rhelp.HasAnchor(name):
2747	frame.rhelp.ScrollToAnchor(name)
2748	else:
2749	msg= "Model does not contains an available description "
2750	msg +="Please try searching in the Help window"
2751	wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
2752
2753	def on_pd_help_clicked(self, event):
2754	"""
2755	Button event for PD help
2756	"""
2757	from help_panel import HelpWindow
2758	import sans.models as models
2759
2760	# Get models help model_function path
2761	path = models.get_data_path(media='media')
2762	pd_path = os.path.join(path,"pd_help.html")
2763
2764	frame = HelpWindow(None, -1, pageToOpen=pd_path)
2765	frame.Show(True)
2766
2767	def on_left_down(self, event):
2768	"""
2769	Get key stroke event
2770	"""
2771	# Figuring out key combo: Cmd for copy, Alt for paste
2772	if event.CmdDown() and event.ShiftDown():
2773	flag = self.get_paste()
2774	elif event.CmdDown():
2775	flag = self.get_copy()
2776	else:
2777	event.Skip()
2778	return
2779	# make event free
2780	event.Skip()
2781
2782
2783	def get_copy(self):
2784	"""
2785	Get the string copies of the param names and values in the tap
2786	"""
2787	content = 'sansview_parameter_values:'
2788	# Do it if params exist
2789	if self.parameters !=[]:
2790
2791	# go through the parameters
2792	string = self._get_copy_helper(self.parameters,
2793	self.orientation_params)
2794	content += string
2795
2796	# go through the fittables
2797	string = self._get_copy_helper(self.fittable_param,
2798	self.orientation_params_disp)
2799	content += string
2800
2801	# go through the fixed params
2802	string = self._get_copy_helper(self.fixed_param,
2803	self.orientation_params_disp)
2804	content += string
2805
2806	# go through the str params
2807	string = self._get_copy_helper(self.str_parameters,
2808	self.orientation_params)
2809	content += string
2810
2811	if wx.TheClipboard.Open():
2812	wx.TheClipboard.SetData(wx.TextDataObject(str(content)))
2813	data = wx.TextDataObject()
2814	success = wx.TheClipboard.GetData(data)
2815	text = data.GetText()
2816	wx.TheClipboard.Close()
2817
2818	return None
2819
2820	def _get_copy_helper(self, param, orient_param):
2821	"""
2822	Helping get value and name of the params
2823
2824	: param param: parameters
2825	: param orient_param = oritational params
2826	: return content: strings [list] [name,value:....]
2827	"""
2828	content = ''
2829	# go through the str params
2830	for item in param:
2831	# 2D
2832	if self.data.__class__.__name__== "Data2D":
2833	name = item[1]
2834	value = item[2].GetValue()
2835	# 1D
2836	else:
2837	## for 1D all parameters except orientation
2838	if not item[1] in orient_param:
2839	name = item[1]
2840	value = item[2].GetValue()
2841	# add to the content
2842	content += name + ',' + value + ':'
2843
2844	return content
2845
2846	def get_paste(self):
2847	"""
2848	Get the string copies of the param names and values in the tap
2849	"""
2850	context = {}
2851	text = ""
2852
2853	# Get text from the clip board
2854	if wx.TheClipboard.Open():
2855	if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
2856	data = wx.TextDataObject()
2857	# get wx dataobject
2858	success = wx.TheClipboard.GetData(data)
2859	# get text
2860	text = data.GetText()
2861	# close clipboard
2862	wx.TheClipboard.Close()
2863
2864	# put the text into dictionary
2865	lines = text.split(':')
2866	if lines[0] != 'sansview_parameter_values':
2867	self._copy_info(False)
2868	return False
2869	for line in lines[1:-1]:
2870	if len(line) != 0:
2871	item =line.split(',')
2872	name = item[0]
2873	value = item[1]
2874	# Transfer the text to content[dictionary]
2875	context[name] = value
2876
2877	# Do it if params exist
2878	if self.parameters != []:
2879	# go through the parameters
2880	self._get_paste_helper(self.parameters,
2881	self.orientation_params, context)
2882
2883	# go through the fittables
2884	self._get_paste_helper(self.fittable_param,
2885	self.orientation_params_disp, context)
2886
2887	# go through the fixed params
2888	self._get_paste_helper(self.fixed_param,
2889	self.orientation_params_disp, context)
2890
2891	# go through the str params
2892	self._get_paste_helper(self.str_parameters,
2893	self.orientation_params, context)
2894	self._copy_info(True)
2895	return True
2896
2897	def _get_paste_helper(self, param, orient_param, content):
2898	"""
2899	Helping set values of the params
2900
2901	: param param: parameters
2902	: param orient_param: oritational params
2903	: param content: dictionary [ name, value: name1.value1,...]
2904	"""
2905	# go through the str params
2906	for item in param:
2907	# 2D
2908	if self.data.__class__.__name__== "Data2D":
2909	name = item[1]
2910	if name in content.keys():
2911	item[2].SetValue(content[name])
2912	# 1D
2913	else:
2914	## for 1D all parameters except orientation
2915	if not item[1] in orient_param:
2916	name = item[1]
2917	if name in content.keys():
2918	# Avoid changing combox content which needs special care
2919	value = content[name]
2920	item[2].SetValue(value)
2921	if item[2].__class__.__name__ == "ComboBox":
2922	if self.model.fun_list.has_key(value):
2923	fun_val = self.model.fun_list[value]
2924	self.model.setParam(name,fun_val)
2925	# save state
2926	#self._copy_parameters_state(self.str_parameters,
2927	# self.state.str_parameters)
2928

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

SasView

source: sasview/fittingview/src/sans/perspectives/fitting/basepage.py @ 2e95da4

Download in other formats: