Context Navigation

source: trunk/GSASIIgrid.py @ 1205

Last change on this file since 1205 was 1205, checked in by vondreele, 10 years ago
Add models to SASD data tree Add error bar plotting to SASD data Add I*Q^{4 option to log SASD data got rid of the if, else blocks for all key driven toggles in G2plot}
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 171.8 KB

Line
1	# -- coding: utf-8 --
2	#GSASIIgrid - data display routines
3	########### SVN repository information ###################
4	# $Date: 2014-01-23 21:15:51 +0000 (Thu, 23 Jan 2014) $
5	# $Author: vondreele $
6	# $Revision: 1205 $
7	# $URL: trunk/GSASIIgrid.py $
8	# $Id: GSASIIgrid.py 1205 2014-01-23 21:15:51Z vondreele $
9	########### SVN repository information ###################
10	'''
11	GSASIIgrid: Basic GUI routines
12	--------------------------------
13
14	'''
15	import wx
16	import wx.grid as wg
17	import wx.wizard as wz
18	import wx.aui
19	import wx.lib.scrolledpanel as wxscroll
20	import time
21	import copy
22	import cPickle
23	import sys
24	import numpy as np
25	import numpy.ma as ma
26	import os.path
27	import wx.html # could postpone this for quicker startup
28	import webbrowser # could postpone this for quicker startup
29	import GSASIIpath
30	GSASIIpath.SetVersionNumber("$Revision: 1205 $")
31	import GSASIImath as G2mth
32	import GSASIIIO as G2IO
33	import GSASIIlattice as G2lat
34	import GSASIIplot as G2plt
35	import GSASIIpwdGUI as G2pdG
36	import GSASIIimgGUI as G2imG
37	import GSASIIphsGUI as G2phG
38	import GSASIIspc as G2spc
39	import GSASIImapvars as G2mv
40	import GSASIIconstrGUI as G2cnstG
41	import GSASIIrestrGUI as G2restG
42	import GSASIIpy3 as G2py3
43	import GSASIIobj as G2obj
44
45	# trig functions in degrees
46	sind = lambda x: np.sin(x*np.pi/180.)
47	tand = lambda x: np.tan(x*np.pi/180.)
48	cosd = lambda x: np.cos(x*np.pi/180.)
49
50	# globals we will use later
51	__version__ = None # gets overridden in GSASII.py
52	path2GSAS2 = os.path.dirname(os.path.realpath(__file__)) # save location of this file
53	helpLocDict = {}
54	htmlPanel = None
55	htmlFrame = None
56	helpMode = 'browser'
57	#if sys.platform.lower().startswith('win'): helpMode = 'internal' # need a global control to set this
58
59	htmlFirstUse = True
60
61	[ wxID_FOURCALC, wxID_FOURSEARCH, wxID_FOURCLEAR, wxID_PEAKSMOVE, wxID_PEAKSCLEAR,
62	wxID_CHARGEFLIP, wxID_PEAKSUNIQUE, wxID_PEAKSDELETE, wxID_PEAKSDA,
63	wxID_PEAKSDISTVP, wxID_PEAKSVIEWPT, wxID_FINDEQVPEAKS,wxID_SHOWBONDS,wxID_MULTIMCSA,
64	wxID_SINGLEMCSA
65	] = [wx.NewId() for item in range(15)]
66
67	[ wxID_PWDRADD, wxID_HKLFADD,wxID_PWDANALYSIS,wxID_DATADELETE,
68	] = [wx.NewId() for item in range(4)]
69
70	[ wxID_ATOMSEDITADD, wxID_ATOMSEDITINSERT, wxID_ATOMSEDITDELETE, wxID_ATOMSREFINE,
71	wxID_ATOMSMODIFY, wxID_ATOMSTRANSFORM, wxID_ATOMSVIEWADD, wxID_ATOMVIEWINSERT,
72	wxID_RELOADDRAWATOMS,wxID_ATOMSDISAGL,wxID_ATOMMOVE,
73	wxID_ASSIGNATMS2RB,wxID_ATOMSPDISAGL, wxID_ISODISP,
74	] = [wx.NewId() for item in range(14)]
75
76	[ wxID_DRAWATOMSTYLE, wxID_DRAWATOMLABEL, wxID_DRAWATOMCOLOR, wxID_DRAWATOMRESETCOLOR,
77	wxID_DRAWVIEWPOINT, wxID_DRAWTRANSFORM, wxID_DRAWDELETE, wxID_DRAWFILLCELL,
78	wxID_DRAWADDEQUIV, wxID_DRAWFILLCOORD, wxID_DRAWDISAGLTOR, wxID_DRAWPLANE,
79	wxID_DRAWDISTVP,
80	] = [wx.NewId() for item in range(13)]
81
82	[ wxID_DRAWRESTRBOND, wxID_DRAWRESTRANGLE, wxID_DRAWRESTRPLANE, wxID_DRAWRESTRCHIRAL,
83	] = [wx.NewId() for item in range(4)]
84
85	[ wxID_ADDMCSAATOM,wxID_ADDMCSARB,wxID_CLEARMCSARB,wxID_MOVEMCSA,wxID_MCSACLEARRESULTS,
86	] = [wx.NewId() for item in range(5)]
87
88	[ wxID_CLEARTEXTURE,wxID_REFINETEXTURE,
89	] = [wx.NewId() for item in range(2)]
90
91	[ wxID_PAWLEYLOAD, wxID_PAWLEYESTIMATE, wxID_PAWLEYUPDATE,
92	] = [wx.NewId() for item in range(3)]
93
94	[ wxID_IMCALIBRATE,wxID_IMRECALIBRATE,wxID_IMINTEGRATE, wxID_IMCLEARCALIB,
95	wxID_IMCOPYCONTROLS, wxID_INTEGRATEALL, wxID_IMSAVECONTROLS, wxID_IMLOADCONTROLS,
96	] = [wx.NewId() for item in range(8)]
97
98	[ wxID_MASKCOPY, wxID_MASKSAVE, wxID_MASKLOAD,wxID_NEWMASKSPOT,wxID_NEWMASKARC,wxID_NEWMASKRING,
99	wxID_NEWMASKFRAME, wxID_NEWMASKPOLY,
100	] = [wx.NewId() for item in range(8)]
101
102	[ wxID_STRSTACOPY, wxID_STRSTAFIT, wxID_STRSTASAVE, wxID_STRSTALOAD,wxID_APPENDDZERO,
103	wxID_STRSTAALLFIT,wxID_UPDATEDZERO,
104	] = [wx.NewId() for item in range(7)]
105
106	[ wxID_BACKCOPY,wxID_LIMITCOPY,wxID_SAMPLECOPY, wxID_BACKFLAGCOPY, wxID_SAMPLEFLAGCOPY,
107	wxID_SAMPLESAVE, wxID_SAMPLELOAD,wxID_ADDEXCLREGION,
108	] = [wx.NewId() for item in range(8)]
109
110	[ wxID_INSTPRMRESET,wxID_CHANGEWAVETYPE,wxID_INSTCOPY, wxID_INSTFLAGCOPY, wxID_INSTLOAD,
111	wxID_INSTSAVE,
112	] = [wx.NewId() for item in range(6)]
113
114	[ wxID_UNDO,wxID_LSQPEAKFIT,wxID_LSQONECYCLE,wxID_RESETSIGGAM,wxID_CLEARPEAKS,wxID_AUTOSEARCH,
115	] = [wx.NewId() for item in range(6)]
116
117	[ wxID_INDXRELOAD, wxID_INDEXPEAKS, wxID_REFINECELL, wxID_COPYCELL, wxID_MAKENEWPHASE,
118	] = [wx.NewId() for item in range(5)]
119
120	[ wxID_CONSTRAINTADD,wxID_EQUIVADD,wxID_HOLDADD,wxID_FUNCTADD,
121	wxID_CONSPHASE, wxID_CONSHIST, wxID_CONSHAP, wxID_CONSGLOBAL,
122	] = [wx.NewId() for item in range(8)]
123
124	[ wxID_RESTRAINTADD, wxID_RESTSELPHASE,wxID_RESTDELETE, wxID_RESRCHANGEVAL,
125	wxID_RESTCHANGEESD,wxID_AARESTRAINTADD,wxID_AARESTRAINTPLOT,
126	] = [wx.NewId() for item in range(7)]
127
128	[ wxID_RIGIDBODYADD,wxID_DRAWDEFINERB,wxID_RIGIDBODYIMPORT,wxID_RESIDUETORSSEQ,
129	wxID_AUTOFINDRESRB,wxID_GLOBALRESREFINE,wxID_RBREMOVEALL,wxID_COPYRBPARMS,
130	wxID_GLOBALTHERM,
131	] = [wx.NewId() for item in range(9)]
132
133	[ wxID_SAVESEQSEL,
134	] = [wx.NewId() for item in range(1)]
135
136	[ wxID_MODELCOPY,wxID_MODELFIT
137	] = [wx.NewId() for item in range(2)]
138
139	[ wxID_SELECTPHASE,
140	] = [wx.NewId() for item in range(1)]
141
142	[ wxID_PDFCOPYCONTROLS, wxID_PDFSAVECONTROLS, wxID_PDFLOADCONTROLS,
143	wxID_PDFCOMPUTE, wxID_PDFCOMPUTEALL, wxID_PDFADDELEMENT, wxID_PDFDELELEMENT,
144	] = [wx.NewId() for item in range(7)]
145
146	VERY_LIGHT_GREY = wx.Colour(235,235,235)
147	################################################################################
148	#### GSAS-II class definitions
149	################################################################################
150
151	class ValidatedTxtCtrl(wx.TextCtrl):
152	'''Create a TextCtrl widget that uses a validator to prevent the
153	entry of inappropriate characters and changes color to highlight
154	when invalid input is supplied. As valid values are typed,
155	they are placed into the dict or list where the initial value
156	came from. The type of the initial value must be int,
157	float or str or None (see :obj:`key` and :obj:`typeHint`);
158	this type (or the one in :obj:`typeHint`) is preserved.
159
160	Float values can be entered in the TextCtrl as numbers or also
161	as algebraic expressions using operators + - / \* () and \\,
162	in addition pi, sind(), cosd(), tand(), and sqrt() can be used,
163	as well as appreviations s, sin, c, cos, t, tan and sq.
164
165	:param wx.Panel parent: name of panel or frame that will be
166	the parent to the TextCtrl. Can be None.
167
168	:param dict/list loc: the dict or list with the initial value to be
169	placed in the TextCtrl.
170
171	:param int/str key: the dict key or the list index for the value to be
172	edited by the TextCtrl. The ``loc[key]`` element must exist, but may
173	have value None. If None, the type for the element is taken from
174	:obj:`typeHint` and the value for the control is set initially
175	blank (and thus invalid.) This is a way to specify a field without a
176	default value: a user must set a valid value.
177	If the value is not None, it must have a base
178	type of int, float, str or unicode; the TextCrtl will be initialized
179	from this value.
180
181	:param list [nDig,nPlc]: number of digits & places after decimal to use
182	for display of float. Alternately, None can be specified which causes
183	numbers to be displayed with approximately 5 significant figures
184	(Default=None).
185
186	:param bool notBlank: if True (default) blank values are invalid
187	for str inputs.
188
189	:param number min: minimum allowed valid value. If None (default) the
190	lower limit is unbounded.
191
192	:param number max: maximum allowed valid value. If None (default) the
193	upper limit is unbounded
194
195	:param function OKcontrol: specifies a function or method that will be
196	called when the input is validated. The called function is supplied
197	with one argument which is False if the TextCtrl contains an invalid
198	value and True if the value is valid.
199	Note that this function should check all values
200	in the dialog when True, since other entries might be invalid.
201	The default for this is None, which indicates no function should
202	be called.
203
204	:param function OnLeave: specifies a function or method that will be
205	called when the focus for the control is lost.
206	The called function is supplied with (at present) three keyword arguments:
207
208	* invalid: (bool) True if the value for the TextCtrl is invalid
209	* value: (int/float/str) the value contained in the TextCtrl
210	* tc: (wx.TextCtrl) the TextCtrl name
211
212	The number of keyword arguments may be increased in the future, if needs arise,
213	so it is best to code these functions with a \\kwargs argument so they will
214	continue to run without errors
215
216	The default for OnLeave is None, which indicates no function should
217	be called.
218
219	:param type typeHint: the value of typeHint is overrides the initial value
220	for the dict/list element ``loc[key]``, if set to
221	int or float, which specifies the type for input to the TextCtrl.
222	Defaults as None, which is ignored.
223
224	:param bool CIFinput: for str input, indicates that only printable
225	ASCII characters may be entered into the TextCtrl. Forces output
226	to be ASCII rather than Unicode. For float and int input, allows
227	use of a single '?' or '.' character as valid input.
228
229	:param dict OnLeaveArgs: a dict with keyword args that are passed to
230	the :attr:`OnLeave` function. Defaults to ``{}``
231
232	:param (other): other optional keyword parameters for the
233	wx.TextCtrl widget such as Size or Style may be specified.
234
235	'''
236	def __init__(self,parent,loc,key,nDig=None,notBlank=True,min=None,max=None,
237	OKcontrol=None,OnLeave=None,typeHint=None,
238	CIFinput=False, OnLeaveArgs={}, **kw):
239	# save passed values needed outside __init__
240	self.result = loc
241	self.key = key
242	self.nDig = nDig
243	self.OKcontrol=OKcontrol
244	self.OnLeave = OnLeave
245	self.OnLeaveArgs = OnLeaveArgs
246	self.CIFinput = CIFinput
247	self.type = str
248	# initialization
249	self.invalid = False # indicates if the control has invalid contents
250	self.evaluated = False # set to True when the validator recognizes an expression
251	val = loc[key]
252	if isinstance(val,int) or typeHint is int:
253	self.type = int
254	wx.TextCtrl.__init__(
255	self,parent,wx.ID_ANY,
256	validator=NumberValidator(int,result=loc,key=key,
257	min=min,max=max,
258	OKcontrol=OKcontrol,
259	CIFinput=CIFinput),
260	**kw)
261	if val is not None:
262	self.SetValue(val)
263	else: # no default is invalid for a number
264	self.invalid = True
265	self._IndicateValidity()
266
267	elif isinstance(val,float) or typeHint is float:
268	self.type = float
269	wx.TextCtrl.__init__(
270	self,parent,wx.ID_ANY,
271	validator=NumberValidator(float,result=loc,key=key,
272	min=min,max=max,
273	OKcontrol=OKcontrol,
274	CIFinput=CIFinput),
275	**kw)
276	if val is not None:
277	self.SetValue(val)
278	else:
279	self.invalid = True
280	self._IndicateValidity()
281
282	elif isinstance(val,str) or isinstance(val,unicode):
283	if self.CIFinput:
284	wx.TextCtrl.__init__(
285	self,parent,wx.ID_ANY,val,
286	validator=ASCIIValidator(result=loc,key=key),
287	**kw)
288	else:
289	wx.TextCtrl.__init__(self,parent,wx.ID_ANY,val,**kw)
290	if notBlank:
291	self.Bind(wx.EVT_CHAR,self._onStringKey)
292	self.ShowStringValidity() # test if valid input
293	else:
294	self.invalid = False
295	self.Bind(wx.EVT_CHAR,self._GetStringValue)
296	elif val is None:
297	raise Exception,("ValidatedTxtCtrl error: value of "+str(key)+
298	" element is None and typeHint not defined as int or float")
299	else:
300	raise Exception,("ValidatedTxtCtrl error: Unknown element ("+str(key)+
301	") type: "+str(type(val)))
302	# When the mouse is moved away or the widget loses focus
303	# display the last saved value, if an expression
304	self.Bind(wx.EVT_LEAVE_WINDOW, self._onLeaveWindow)
305	self.Bind(wx.EVT_TEXT_ENTER, self._onLoseFocus)
306	self.Bind(wx.EVT_KILL_FOCUS, self._onLoseFocus)
307
308	def SetValue(self,val):
309	self.invalid = False
310	if self.type is int:
311	try:
312	if int(val) != val:
313	self.invalid = True
314	else:
315	val = int(val)
316	except:
317	if self.CIFinput and (val == '?' or val == '.'):
318	pass
319	else:
320	self.invalid = True
321	wx.TextCtrl.SetValue(self,str(val))
322	elif self.type is float:
323	try:
324	float(val)
325	except:
326	if self.CIFinput and (val == '?' or val == '.'):
327	pass
328	else:
329	self.invalid = True
330	if self.nDig:
331	wx.TextCtrl.SetValue(self,str(G2py3.FormatValue(val,self.nDig)))
332	else:
333	wx.TextCtrl.SetValue(self,str(G2py3.FormatSigFigs(val)))
334	else:
335	wx.TextCtrl.SetValue(self,str(val))
336	self.ShowStringValidity() # test if valid input
337	return
338
339	self._IndicateValidity()
340	if self.OKcontrol:
341	self.OKcontrol(not self.invalid)
342
343	def _onStringKey(self,event):
344	event.Skip()
345	if self.invalid: # check for validity after processing the keystroke
346	wx.CallAfter(self.ShowStringValidity,True) # was invalid
347	else:
348	wx.CallAfter(self.ShowStringValidity,False) # was valid
349
350	def _IndicateValidity(self):
351	'Set the control colors to show invalid input'
352	if self.invalid:
353	self.SetForegroundColour("red")
354	self.SetBackgroundColour("yellow")
355	self.SetFocus()
356	self.Refresh()
357	else: # valid input
358	self.SetBackgroundColour(
359	wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW))
360	self.SetForegroundColour("black")
361	self.Refresh()
362
363	def ShowStringValidity(self,previousInvalid=True):
364	'''Check if input is valid. Anytime the input is
365	invalid, call self.OKcontrol (if defined) because it is fast.
366	If valid, check for any other invalid entries only when
367	changing from invalid to valid, since that is slower.
368
369	:param bool previousInvalid: True if the TextCtrl contents were
370	invalid prior to the current change.
371
372	'''
373	val = self.GetValue().strip()
374	self.invalid = not val
375	self._IndicateValidity()
376	if self.invalid:
377	if self.OKcontrol:
378	self.OKcontrol(False)
379	elif self.OKcontrol and previousInvalid:
380	self.OKcontrol(True)
381	# always store the result
382	if self.CIFinput: # for CIF make results ASCII
383	self.result[self.key] = val.encode('ascii','replace')
384	else:
385	self.result[self.key] = val
386
387	def _GetStringValue(self,event):
388	'''Get string input and store.
389	'''
390	event.Skip() # process keystroke
391	wx.CallAfter(self._SaveStringValue)
392
393	def _SaveStringValue(self):
394	val = self.GetValue().strip()
395	# always store the result
396	if self.CIFinput: # for CIF make results ASCII
397	self.result[self.key] = val.encode('ascii','replace')
398	else:
399	self.result[self.key] = val
400
401	def _onLoseFocus(self,event):
402	if self.evaluated: self.EvaluateExpression()
403	if self.OnLeave: self.OnLeave(invalid=self.invalid,
404	value=self.result[self.key],
405	tc=self,
406	**self.OnLeaveArgs)
407
408	def _onLeaveWindow(self,event):
409	if self.evaluated: self.EvaluateExpression()
410
411	def EvaluateExpression(self):
412	'''Show the computed value when an expression is entered to the TextCtrl
413	Make sure that the number fits by truncating decimal places and switching
414	to scientific notation, as needed.
415	Called on loss of focus.
416	'''
417	if self.invalid: return # don't substitute for an invalid expression
418	if not self.evaluated: return # true when an expression is evaluated
419	if self.result is not None: # retrieve the stored result
420	self.SetValue(self.result[self.key])
421	self.evaluated = False # expression has been recast as value, reset flag
422
423	class NumberValidator(wx.PyValidator):
424	'''A validator to be used with a TextCtrl to prevent
425	entering characters other than digits, signs, and for float
426	input, a period and exponents.
427
428	The value is checked for validity after every keystroke
429	If an invalid number is entered, the box is highlighted.
430	If the number is valid, it is saved in result[key]
431
432	:param type typ: the base data type. Must be int or float.
433
434	:param bool positiveonly: If True, negative integers are not allowed
435	(default False). This prevents the + or - keys from being pressed.
436	Used with typ=int; ignored for typ=float.
437
438	:param number min: Minimum allowed value. If None (default) the
439	lower limit is unbounded
440
441	:param number max: Maximum allowed value. If None (default) the
442	upper limit is unbounded
443
444	:param dict/list result: List or dict where value should be placed when valid
445
446	:param any key: key to use for result (int for list)
447
448	:param function OKcontrol: function or class method to control
449	an OK button for a window.
450	Ignored if None (default)
451
452	:param bool CIFinput: allows use of a single '?' or '.' character
453	as valid input.
454
455	'''
456	def __init__(self, typ, positiveonly=False, min=None, max=None,
457	result=None, key=None, OKcontrol=None, CIFinput=False):
458	'Create the validator'
459	wx.PyValidator.__init__(self)
460	# save passed parameters
461	self.typ = typ
462	self.positiveonly = positiveonly
463	self.min = min
464	self.max = max
465	self.result = result
466	self.key = key
467	self.OKcontrol = OKcontrol
468	self.CIFinput = CIFinput
469	# set allowed keys by data type
470	self.Bind(wx.EVT_CHAR, self.OnChar)
471	if self.typ == int and self.positiveonly:
472	self.validchars = '0123456789'
473	elif self.typ == int:
474	self.validchars = '0123456789+-'
475	elif self.typ == float:
476	# allow for above and sind, cosd, sqrt, tand, pi, and abbreviations
477	# also addition, subtraction, division, multiplication, exponentiation
478	self.validchars = '0123456789.-+eE/cosindcqrtap()*'
479	else:
480	self.validchars = None
481	return
482	if self.CIFinput:
483	self.validchars += '?.'
484	def Clone(self):
485	'Create a copy of the validator, a strange, but required component'
486	return NumberValidator(typ=self.typ,
487	positiveonly=self.positiveonly,
488	min=self.min, max=self.max,
489	result=self.result, key=self.key,
490	OKcontrol=self.OKcontrol,
491	CIFinput=self.CIFinput)
492	def TransferToWindow(self):
493	'Needed by validator, strange, but required component'
494	return True # Prevent wxDialog from complaining.
495	def TransferFromWindow(self):
496	'Needed by validator, strange, but required component'
497	return True # Prevent wxDialog from complaining.
498	def TestValid(self,tc):
499	'''Check if the value is valid by casting the input string
500	into the current type.
501
502	Set the invalid variable in the TextCtrl object accordingly.
503
504	If the value is valid, save it in the dict/list where
505	the initial value was stored, if appropriate.
506
507	:param wx.TextCtrl tc: A reference to the TextCtrl that the validator
508	is associated with.
509	'''
510	tc.invalid = False # assume valid
511	if self.CIFinput:
512	val = tc.GetValue().strip()
513	if val == '?' or val == '.':
514	self.result[self.key] = val
515	return
516	try:
517	val = self.typ(tc.GetValue())
518	except (ValueError, SyntaxError) as e:
519	if self.typ is float: # for float values, see if an expression can be evaluated
520	val = G2py3.FormulaEval(tc.GetValue())
521	if val is None:
522	tc.invalid = True
523	return
524	else:
525	tc.evaluated = True
526	else:
527	tc.invalid = True
528	return
529	# if self.max != None and self.typ == int:
530	# if val > self.max:
531	# tc.invalid = True
532	# if self.min != None and self.typ == int:
533	# if val < self.min:
534	# tc.invalid = True # invalid
535	if self.max != None:
536	if val > self.max:
537	tc.invalid = True
538	if self.min != None:
539	if val < self.min:
540	tc.invalid = True # invalid
541	if self.key is not None and self.result is not None and not tc.invalid:
542	self.result[self.key] = val
543
544	def ShowValidity(self,tc):
545	'''Set the control colors to show invalid input
546
547	:param wx.TextCtrl tc: A reference to the TextCtrl that the validator
548	is associated with.
549
550	'''
551	if tc.invalid:
552	tc.SetForegroundColour("red")
553	tc.SetBackgroundColour("yellow")
554	tc.SetFocus()
555	tc.Refresh()
556	return False
557	else: # valid input
558	tc.SetBackgroundColour(
559	wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW))
560	tc.SetForegroundColour("black")
561	tc.Refresh()
562	return True
563
564	def CheckInput(self,previousInvalid):
565	'''called to test every change to the TextCtrl for validity and
566	to change the appearance of the TextCtrl
567
568	Anytime the input is invalid, call self.OKcontrol
569	(if defined) because it is fast.
570	If valid, check for any other invalid entries only when
571	changing from invalid to valid, since that is slower.
572
573	:param bool previousInvalid: True if the TextCtrl contents were
574	invalid prior to the current change.
575	'''
576	tc = self.GetWindow()
577	self.TestValid(tc)
578	self.ShowValidity(tc)
579	# if invalid
580	if tc.invalid and self.OKcontrol:
581	self.OKcontrol(False)
582	if not tc.invalid and self.OKcontrol and previousInvalid:
583	self.OKcontrol(True)
584
585	def OnChar(self, event):
586	'''Called each type a key is pressed
587	ignores keys that are not allowed for int and float types
588	'''
589	key = event.GetKeyCode()
590	tc = self.GetWindow()
591	if key == wx.WXK_RETURN:
592	if tc.invalid:
593	self.CheckInput(True)
594	else:
595	self.CheckInput(False)
596	return
597	if key < wx.WXK_SPACE or key == wx.WXK_DELETE or key > 255: # control characters get processed
598	event.Skip()
599	if tc.invalid:
600	wx.CallAfter(self.CheckInput,True)
601	else:
602	wx.CallAfter(self.CheckInput,False)
603	return
604	elif chr(key) in self.validchars: # valid char pressed?
605	event.Skip()
606	if tc.invalid:
607	wx.CallAfter(self.CheckInput,True)
608	else:
609	wx.CallAfter(self.CheckInput,False)
610	return
611	if not wx.Validator_IsSilent(): wx.Bell()
612	return # Returning without calling event.Skip, which eats the keystroke
613
614	################################################################################
615	class ASCIIValidator(wx.PyValidator):
616	'''A validator to be used with a TextCtrl to prevent
617	entering characters other than ASCII characters.
618
619	The value is checked for validity after every keystroke
620	If an invalid number is entered, the box is highlighted.
621	If the number is valid, it is saved in result[key]
622
623	:param dict/list result: List or dict where value should be placed when valid
624
625	:param any key: key to use for result (int for list)
626
627	'''
628	def __init__(self, result=None, key=None):
629	'Create the validator'
630	import string
631	wx.PyValidator.__init__(self)
632	# save passed parameters
633	self.result = result
634	self.key = key
635	self.validchars = string.ascii_letters + string.digits + string.punctuation + string.whitespace
636	self.Bind(wx.EVT_CHAR, self.OnChar)
637	def Clone(self):
638	'Create a copy of the validator, a strange, but required component'
639	return ASCIIValidator(result=self.result, key=self.key)
640	tc = self.GetWindow()
641	tc.invalid = False # make sure the validity flag is defined in parent
642	def TransferToWindow(self):
643	'Needed by validator, strange, but required component'
644	return True # Prevent wxDialog from complaining.
645	def TransferFromWindow(self):
646	'Needed by validator, strange, but required component'
647	return True # Prevent wxDialog from complaining.
648	def TestValid(self,tc):
649	'''Check if the value is valid by casting the input string
650	into ASCII.
651
652	Save it in the dict/list where the initial value was stored
653
654	:param wx.TextCtrl tc: A reference to the TextCtrl that the validator
655	is associated with.
656	'''
657	self.result[self.key] = tc.GetValue().encode('ascii','replace')
658
659	def OnChar(self, event):
660	'''Called each type a key is pressed
661	ignores keys that are not allowed for int and float types
662	'''
663	key = event.GetKeyCode()
664	tc = self.GetWindow()
665	if key == wx.WXK_RETURN:
666	self.TestValid(tc)
667	return
668	if key < wx.WXK_SPACE or key == wx.WXK_DELETE or key > 255: # control characters get processed
669	event.Skip()
670	self.TestValid(tc)
671	return
672	elif chr(key) in self.validchars: # valid char pressed?
673	event.Skip()
674	self.TestValid(tc)
675	return
676	if not wx.Validator_IsSilent():
677	wx.Bell()
678	return # Returning without calling event.Skip, which eats the keystroke
679	################################################################################
680	class EnumSelector(wx.ComboBox):
681	'''A customized :class:`wxpython.ComboBox` that selects items from a list
682	of choices, but sets a dict (list) entry to the corresponding
683	entry from the input list of values.
684
685	:param wx.Panel parent: the parent to the :class:`~wxpython.ComboBox` (usually a
686	frame or panel)
687	:param dict dct: a dict (or list) to contain the value set
688	for the :class:`~wxpython.ComboBox`.
689	:param item: the dict key (or list index) where ``dct[item]`` will
690	be set to the value selected in the :class:`~wxpython.ComboBox`. Also, dct[item]
691	contains the starting value shown in the widget. If the value
692	does not match an entry in :data:`values`, the first value
693	in :data:`choices` is used as the default, but ``dct[item]`` is
694	not changed.
695	:param list choices: a list of choices to be displayed to the
696	user such as
697	::
698
699	["default","option 1","option 2",]
700
701	Note that these options will correspond to the entries in
702	:data:`values` (if specified) item by item.
703	:param list values: a list of values that correspond to
704	the options in :data:`choices`, such as
705	::
706
707	[0,1,2]
708
709	The default for :data:`values` is to use the same list as
710	specified for :data:`choices`.
711	:param (other): additional keyword arguments accepted by
712	:class:`~wxpython.ComboBox` can be specified.
713	'''
714	def __init__(self,parent,dct,item,choices,values=None,**kw):
715	if values is None:
716	values = choices
717	if dct[item] in values:
718	i = values.index(dct[item])
719	else:
720	i = 0
721	startval = choices[i]
722	wx.ComboBox.__init__(self,parent,wx.ID_ANY,startval,
723	choices = choices,
724	style=wx.CB_DROPDOWN\|wx.CB_READONLY,
725	**kw)
726	self.choices = choices
727	self.values = values
728	self.dct = dct
729	self.item = item
730	self.Bind(wx.EVT_COMBOBOX, self.onSelection)
731	def onSelection(self,event):
732	# respond to a selection by setting the enum value in the CIF dictionary
733	if self.GetValue() in self.choices: # should always be true!
734	self.dct[self.item] = self.values[self.choices.index(self.GetValue())]
735	else:
736	self.dct[self.item] = self.values[0] # unknown
737
738	################################################################################
739	class G2CheckBox(wx.CheckBox):
740	'''A customized version of a CheckBox that automatically initializes
741	the control to match a supplied
742
743	:param wx.Panel parent: name of panel or frame that will be
744	the parent to the TextCtrl. Can be None.
745	:param str label: text to put on check button
746	:param dict/list loc: the dict or list with the initial value to be
747	placed in the CheckBox.
748	:param int/str key: the dict key or the list index for the value to be
749	edited by the CheckBox. The ``loc[key]`` element must exist.
750	The CheckBox will be initialized from this value.
751	If the value is anything other that True (or 1), it will be taken as
752	False.
753	'''
754	def __init__(self,parent,label,loc,key):
755	wx.CheckBox.__init__(self,parent,id=wx.ID_ANY,label=label)
756	self.loc = loc
757	self.key = key
758	self.SetValue(self.loc[self.key]==True)
759	self.Bind(wx.EVT_CHECKBOX, self._OnCheckBox)
760	def _OnCheckBox(self,event):
761	self.loc[self.key] = self.GetValue()
762	################################################################################
763	def CallScrolledMultiEditor(parent,dictlst,elemlst,prelbl=[],postlbl=[],
764	title='Edit items',header='',size=(300,250),
765	CopyButton=False):
766	'''Shell routine to call a ScrolledMultiEditor dialog. See
767	:class:`ScrolledMultiEditor` for parameter definitions.
768
769	:returns: True if the OK button is pressed; False if the window is closed
770	with the system menu or the Cancel button.
771
772	'''
773	dlg = ScrolledMultiEditor(parent,dictlst,elemlst,prelbl,postlbl,
774	title,header,size,
775	CopyButton)
776	if dlg.ShowModal() == wx.ID_OK:
777	dlg.Destroy()
778	return True
779	else:
780	dlg.Destroy()
781	return False
782
783	class ScrolledMultiEditor(wx.Dialog):
784	'''Define a window for editing a potentially large number of dict- or
785	list-contained values with validation for each item. Edited values are
786	automatically placed in their source location. If invalid entries
787	are provided, the TextCtrl is turned yellow and the OK button is disabled.
788
789	The type for each TextCtrl validation is determined by the
790	initial value of the entry (int, float or string).
791	Float values can be entered in the TextCtrl as numbers or also
792	as algebraic expressions using operators + - / \* () and \\,
793	in addition pi, sind(), cosd(), tand(), and sqrt() can be used,
794	as well as appreviations s(), sin(), c(), cos(), t(), tan() and sq().
795
796	:param wx.Frame parent: name of parent window, or may be None
797
798	:param tuple dictlst: a list of dicts or lists containing values to edit
799
800	:param tuple elemlst: a list of keys for each item in a dictlst. Must have the
801	same length as dictlst.
802
803	:param wx.Frame parent: name of parent window, or may be None
804
805	:param tuple prelbl: a list of labels placed before the TextCtrl for each
806	item (optional)
807
808	:param tuple postlbl: a list of labels placed after the TextCtrl for each
809	item (optional)
810
811	:param str title: a title to place in the frame of the dialog
812
813	:param str header: text to place at the top of the window. May contain
814	new line characters.
815
816	:param wx.Size size: a size parameter that dictates the
817	size for the scrolled region of the dialog. The default is
818	(300,250).
819
820	:param bool CopyButton: if True adds a small button that copies the
821	value for the current row to all fields below (default is False)
822
823	:param list minvals: optional list of minimum values for validation
824	of float or int values. Ignored if value is None.
825	:param list maxvals: optional list of maximum values for validation
826	of float or int values. Ignored if value is None.
827	:param list sizevals: optional list of wx.Size values for each input
828	widget. Ignored if value is None.
829	:returns: the wx.Dialog created here. Use method .ShowModal() to display it.
830
831	Example for use of ScrolledMultiEditor:
832
833	::
834
835	dlg = <pkg>.ScrolledMultiEditor(frame,dictlst,elemlst,prelbl,postlbl,
836	header=header)
837	if dlg.ShowModal() == wx.ID_OK:
838	for d,k in zip(dictlst,elemlst):
839	print d[k]
840
841	Example definitions for dictlst and elemlst:
842
843	::
844
845	dictlst = (dict1,list1,dict1,list1)
846	elemlst = ('a', 1, 2, 3)
847
848	This causes items dict1['a'], list1[1], dict1[2] and list1[3] to be edited.
849
850	Note that these items must have int, float or str values assigned to
851	them. The dialog will force these types to be retained. String values
852	that are blank are marked as invalid.
853	'''
854
855	def __init__(self,parent,dictlst,elemlst,prelbl=[],postlbl=[],
856	title='Edit items',header='',size=(300,250),
857	CopyButton=False,
858	minvals=[],maxvals=[],sizevals=[]):
859	if len(dictlst) != len(elemlst):
860	raise Exception,"ScrolledMultiEditor error: len(dictlst) != len(elemlst) "+str(len(dictlst))+" != "+str(len(elemlst))
861	wx.Dialog.__init__( # create dialog & sizer
862	self,parent,wx.ID_ANY,title,
863	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
864	mainSizer = wx.BoxSizer(wx.VERTICAL)
865	self.orig = []
866	self.dictlst = dictlst
867	self.elemlst = elemlst
868	self.ButtonIndex = {}
869	for d,i in zip(dictlst,elemlst):
870	self.orig.append(d[i])
871	# add a header if supplied
872	if header:
873	subSizer = wx.BoxSizer(wx.HORIZONTAL)
874	subSizer.Add((-1,-1),1,wx.EXPAND)
875	subSizer.Add(wx.StaticText(self,wx.ID_ANY,header))
876	subSizer.Add((-1,-1),1,wx.EXPAND)
877	mainSizer.Add(subSizer,0,wx.EXPAND,0)
878	# make OK button now, because we will need it for validation
879	self.OKbtn = wx.Button(self, wx.ID_OK)
880	self.OKbtn.SetDefault()
881	# create scrolled panel and sizer
882	panel = wxscroll.ScrolledPanel(
883	self, wx.ID_ANY,
884	size=size,
885	style = wx.TAB_TRAVERSAL\|wx.SUNKEN_BORDER)
886	cols = 3
887	if CopyButton: cols += 1
888	subSizer = wx.FlexGridSizer(rows=len(dictlst),cols=cols,hgap=2,vgap=2)
889	self.ValidatedControlsList = [] # make list of TextCtrls
890	for i,(d,k) in enumerate(zip(dictlst,elemlst)):
891	if i >= len(prelbl): # label before TextCtrl, or put in a blank
892	subSizer.Add((-1,-1))
893	else:
894	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,str(prelbl[i])))
895	kargs = {}
896	if i < len(minvals):
897	if minvals[i] is not None: kargs['min']=minvals[i]
898	if i < len(maxvals):
899	if maxvals[i] is not None: kargs['max']=maxvals[i]
900	if i < len(sizevals):
901	if sizevals[i]: kargs['size']=sizevals[i]
902	if CopyButton:
903	import wx.lib.colourselect as wscs
904	but = wscs.ColourSelect(label='v', # would like to use u'\u2193' or u'\u25BC' but not in WinXP
905	# is there a way to test?
906	parent=panel,
907	colour=(255,255,200),
908	size=wx.Size(30,23),
909	style=wx.RAISED_BORDER)
910	but.Bind(wx.EVT_BUTTON, self._OnCopyButton)
911	but.SetToolTipString('Press to copy adjacent value to all rows below')
912	self.ButtonIndex[but] = i
913	subSizer.Add(but)
914	# create the validated TextCrtl, store it and add it to the sizer
915	ctrl = ValidatedTxtCtrl(panel,d,k,OKcontrol=self.ControlOKButton,
916	**kargs)
917	self.ValidatedControlsList.append(ctrl)
918	subSizer.Add(ctrl)
919	if i >= len(postlbl): # label after TextCtrl, or put in a blank
920	subSizer.Add((-1,-1))
921	else:
922	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,str(postlbl[i])))
923	# finish up ScrolledPanel
924	panel.SetSizer(subSizer)
925	panel.SetAutoLayout(1)
926	panel.SetupScrolling()
927	mainSizer.Add(panel,1, wx.ALL\|wx.EXPAND,1)
928
929	# Sizer for OK/Close buttons. N.B. on Close changes are discarded
930	# by restoring the initial values
931	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
932	btnsizer.Add(self.OKbtn)
933	btn = wx.Button(self, wx.ID_CLOSE,"Cancel")
934	btn.Bind(wx.EVT_BUTTON,self._onClose)
935	btnsizer.Add(btn)
936	mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
937	# size out the window. Set it to be enlarged but not made smaller
938	self.SetSizer(mainSizer)
939	mainSizer.Fit(self)
940	self.SetMinSize(self.GetSize())
941
942	def _OnCopyButton(self,event):
943	'Implements the copy down functionality'
944	but = event.GetEventObject()
945	n = self.ButtonIndex.get(but)
946	if n is None: return
947	for i,(d,k,ctrl) in enumerate(zip(self.dictlst,self.elemlst,self.ValidatedControlsList)):
948	if i < n: continue
949	if i == n:
950	val = d[k]
951	continue
952	d[k] = val
953	ctrl.SetValue(val)
954
955	def _onClose(self,event):
956	'Restore original values & close the window'
957	for d,i,v in zip(self.dictlst,self.elemlst,self.orig):
958	d[i] = v
959	self.EndModal(wx.ID_CANCEL)
960
961	def ControlOKButton(self,setvalue):
962	'''Enable or Disable the OK button for the dialog. Note that this is
963	passed into the ValidatedTxtCtrl for use by validators.
964
965	:param bool setvalue: if True, all entries in the dialog are
966	checked for validity. if False then the OK button is disabled.
967
968	'''
969	if setvalue: # turn button on, do only if all controls show as valid
970	for ctrl in self.ValidatedControlsList:
971	if ctrl.invalid:
972	self.OKbtn.Disable()
973	return
974	else:
975	self.OKbtn.Enable()
976	else:
977	self.OKbtn.Disable()
978
979	################################################################################
980	class SymOpDialog(wx.Dialog):
981	'''Class to select a symmetry operator
982	'''
983	def __init__(self,parent,SGData,New=True,ForceUnit=False):
984	wx.Dialog.__init__(self,parent,-1,'Select symmetry operator',
985	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
986	panel = wx.Panel(self)
987	self.SGData = SGData
988	self.New = New
989	self.Force = ForceUnit
990	self.OpSelected = [0,0,0,[0,0,0],False,False]
991	mainSizer = wx.BoxSizer(wx.VERTICAL)
992	if ForceUnit:
993	choice = ['No','Yes']
994	self.force = wx.RadioBox(panel,-1,'Force to unit cell?',choices=choice)
995	self.force.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
996	mainSizer.Add(self.force,0,wx.ALIGN_CENTER_VERTICAL)
997	mainSizer.Add((5,5),0)
998	if SGData['SGInv']:
999	choice = ['No','Yes']
1000	self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
1001	self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
1002	mainSizer.Add(self.inv,0,wx.ALIGN_CENTER_VERTICAL)
1003	mainSizer.Add((5,5),0)
1004	if SGData['SGLatt'] != 'P':
1005	LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
1006	self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
1007	self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
1008	mainSizer.Add(self.latt,0,wx.ALIGN_CENTER_VERTICAL)
1009	mainSizer.Add((5,5),0)
1010	if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
1011	Ncol = 2
1012	else:
1013	Ncol = 3
1014	OpList = []
1015	for M,T in SGData['SGOps']:
1016	OpList.append(G2spc.MT2text(M,T))
1017	self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
1018	majorDimension=Ncol)
1019	self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
1020	mainSizer.Add(self.oprs,0,wx.ALIGN_CENTER_VERTICAL)
1021	mainSizer.Add((5,5),0)
1022	mainSizer.Add(wx.StaticText(panel,-1," Choose unit cell?"),0,wx.ALIGN_CENTER_VERTICAL)
1023	mainSizer.Add((5,5),0)
1024	cellSizer = wx.BoxSizer(wx.HORIZONTAL)
1025	cellSizer.Add((5,0),0)
1026	cellName = ['X','Y','Z']
1027	self.cell = []
1028	for i in range(3):
1029	self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
1030	self.cell[-1].SetRange(-3,3)
1031	self.cell[-1].SetValue(0)
1032	self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
1033	cellSizer.Add(self.cell[-1],0,wx.ALIGN_CENTER_VERTICAL)
1034	mainSizer.Add(cellSizer,0,)
1035	if self.New:
1036	choice = ['No','Yes']
1037	self.new = wx.RadioBox(panel,-1,'Generate new positions?',choices=choice)
1038	self.new.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
1039	mainSizer.Add(self.new,0,wx.ALIGN_CENTER_VERTICAL)
1040	mainSizer.Add((5,5),0)
1041
1042	OkBtn = wx.Button(panel,-1,"Ok")
1043	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
1044	cancelBtn = wx.Button(panel,-1,"Cancel")
1045	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
1046	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
1047	btnSizer.Add((20,20),1)
1048	btnSizer.Add(OkBtn)
1049	btnSizer.Add((20,20),1)
1050	btnSizer.Add(cancelBtn)
1051	btnSizer.Add((20,20),1)
1052
1053	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
1054	panel.SetSizer(mainSizer)
1055	panel.Fit()
1056	self.Fit()
1057
1058	def OnOpSelect(self,event):
1059	if self.SGData['SGInv']:
1060	self.OpSelected[0] = self.inv.GetSelection()
1061	if self.SGData['SGLatt'] != 'P':
1062	self.OpSelected[1] = self.latt.GetSelection()
1063	self.OpSelected[2] = self.oprs.GetSelection()
1064	for i in range(3):
1065	self.OpSelected[3][i] = float(self.cell[i].GetValue())
1066	if self.New:
1067	self.OpSelected[4] = self.new.GetSelection()
1068	if self.Force:
1069	self.OpSelected[5] = self.force.GetSelection()
1070
1071	def GetSelection(self):
1072	return self.OpSelected
1073
1074	def OnOk(self,event):
1075	parent = self.GetParent()
1076	parent.Raise()
1077	self.EndModal(wx.ID_OK)
1078
1079	def OnCancel(self,event):
1080	parent = self.GetParent()
1081	parent.Raise()
1082	self.EndModal(wx.ID_CANCEL)
1083
1084	class DisAglDialog(wx.Dialog):
1085	'''Distance/Angle Controls input dialog. After
1086	:meth:`ShowModal` returns, the results are found in
1087	dict :attr:`self.data`, which is accessed using :meth:`GetData`.
1088
1089	:param wx.Frame parent: reference to parent frame (or None)
1090	:param dict data: a dict containing the current
1091	search ranges or an empty dict, which causes default values
1092	to be used.
1093	Will be used to set element `DisAglCtls` in
1094	:ref:`Phase Tree Item <Phase_table>`
1095	:param dict default: A dict containing the default
1096	search ranges for each element.
1097	'''
1098	def __init__(self,parent,data,default):
1099	wx.Dialog.__init__(self,parent,wx.ID_ANY,
1100	'Distance Angle Controls',
1101	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
1102	self.default = default
1103	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
1104	self._default(data,self.default)
1105	self.Draw(self.data)
1106
1107	def _default(self,data,default):
1108	'''Set starting values for the search values, either from
1109	the input array or from defaults, if input is null
1110	'''
1111	if data:
1112	self.data = copy.deepcopy(data) # don't mess with originals
1113	else:
1114	self.data = {}
1115	self.data['Name'] = default['Name']
1116	self.data['Factors'] = [0.85,0.85]
1117	self.data['AtomTypes'] = default['AtomTypes']
1118	self.data['BondRadii'] = default['BondRadii'][:]
1119	self.data['AngleRadii'] = default['AngleRadii'][:]
1120
1121	def Draw(self,data):
1122	'''Creates the contents of the dialog. Normally called
1123	by :meth:`__init__`.
1124	'''
1125	self.panel.Destroy()
1126	self.panel = wx.Panel(self)
1127	mainSizer = wx.BoxSizer(wx.VERTICAL)
1128	mainSizer.Add(wx.StaticText(self.panel,-1,'Controls for phase '+data['Name']),
1129	0,wx.ALIGN_CENTER_VERTICAL\|wx.LEFT,10)
1130	mainSizer.Add((10,10),1)
1131
1132	radiiSizer = wx.FlexGridSizer(2,3,5,5)
1133	radiiSizer.Add(wx.StaticText(self.panel,-1,' Type'),0,wx.ALIGN_CENTER_VERTICAL)
1134	radiiSizer.Add(wx.StaticText(self.panel,-1,'Bond radii'),0,wx.ALIGN_CENTER_VERTICAL)
1135	radiiSizer.Add(wx.StaticText(self.panel,-1,'Angle radii'),0,wx.ALIGN_CENTER_VERTICAL)
1136	self.objList = {}
1137	for id,item in enumerate(self.data['AtomTypes']):
1138	radiiSizer.Add(wx.StaticText(self.panel,-1,' '+item),0,wx.ALIGN_CENTER_VERTICAL)
1139	bRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['BondRadii'][id]),style=wx.TE_PROCESS_ENTER)
1140	self.objList[bRadii.GetId()] = ['BondRadii',id]
1141	bRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
1142	bRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
1143	radiiSizer.Add(bRadii,0,wx.ALIGN_CENTER_VERTICAL)
1144	aRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['AngleRadii'][id]),style=wx.TE_PROCESS_ENTER)
1145	self.objList[aRadii.GetId()] = ['AngleRadii',id]
1146	aRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
1147	aRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
1148	radiiSizer.Add(aRadii,0,wx.ALIGN_CENTER_VERTICAL)
1149	mainSizer.Add(radiiSizer,0,wx.EXPAND)
1150	factorSizer = wx.FlexGridSizer(2,2,5,5)
1151	Names = ['Bond','Angle']
1152	for i,name in enumerate(Names):
1153	factorSizer.Add(wx.StaticText(self.panel,-1,name+' search factor'),0,wx.ALIGN_CENTER_VERTICAL)
1154	bondFact = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['Factors'][i]),style=wx.TE_PROCESS_ENTER)
1155	self.objList[bondFact.GetId()] = ['Factors',i]
1156	bondFact.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
1157	bondFact.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
1158	factorSizer.Add(bondFact)
1159	mainSizer.Add(factorSizer,0,wx.EXPAND)
1160
1161	OkBtn = wx.Button(self.panel,-1,"Ok")
1162	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
1163	ResetBtn = wx.Button(self.panel,-1,'Reset')
1164	ResetBtn.Bind(wx.EVT_BUTTON, self.OnReset)
1165	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
1166	btnSizer.Add((20,20),1)
1167	btnSizer.Add(OkBtn)
1168	btnSizer.Add(ResetBtn)
1169	btnSizer.Add((20,20),1)
1170	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
1171	self.panel.SetSizer(mainSizer)
1172	self.panel.Fit()
1173	self.Fit()
1174
1175	def OnRadiiVal(self,event):
1176	Obj = event.GetEventObject()
1177	item = self.objList[Obj.GetId()]
1178	try:
1179	self.data[item[0]][item[1]] = float(Obj.GetValue())
1180	except ValueError:
1181	pass
1182	Obj.SetValue("%.3f"%(self.data[item[0]][item[1]])) #reset in case of error
1183
1184	def GetData(self):
1185	'Returns the values from the dialog'
1186	return self.data
1187
1188	def OnOk(self,event):
1189	'Called when the OK button is pressed'
1190	parent = self.GetParent()
1191	parent.Raise()
1192	self.EndModal(wx.ID_OK)
1193
1194	def OnReset(self,event):
1195	'Called when the Reset button is pressed'
1196	data = {}
1197	self._default(data,self.default)
1198	self.Draw(self.data)
1199
1200	class PickTwoDialog(wx.Dialog):
1201	'''This does not seem to be in use
1202	'''
1203	def __init__(self,parent,title,prompt,names,choices):
1204	wx.Dialog.__init__(self,parent,-1,title,
1205	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
1206	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
1207	self.prompt = prompt
1208	self.choices = choices
1209	self.names = names
1210	self.Draw()
1211
1212	def Draw(self):
1213	Indx = {}
1214
1215	def OnSelection(event):
1216	Obj = event.GetEventObject()
1217	id = Indx[Obj.GetId()]
1218	self.choices[id] = Obj.GetValue().encode() #to avoid Unicode versions
1219	self.Draw()
1220
1221	self.panel.DestroyChildren()
1222	self.panel.Destroy()
1223	self.panel = wx.Panel(self)
1224	mainSizer = wx.BoxSizer(wx.VERTICAL)
1225	mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
1226	for isel,name in enumerate(self.choices):
1227	lineSizer = wx.BoxSizer(wx.HORIZONTAL)
1228	lineSizer.Add(wx.StaticText(self.panel,-1,'Reference atom '+str(isel+1)),0,wx.ALIGN_CENTER)
1229	nameList = self.names[:]
1230	if isel:
1231	if self.choices[0] in nameList:
1232	nameList.remove(self.choices[0])
1233	choice = wx.ComboBox(self.panel,-1,value=name,choices=nameList,
1234	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
1235	Indx[choice.GetId()] = isel
1236	choice.Bind(wx.EVT_COMBOBOX, OnSelection)
1237	lineSizer.Add(choice,0,wx.ALIGN_CENTER)
1238	mainSizer.Add(lineSizer)
1239	OkBtn = wx.Button(self.panel,-1,"Ok")
1240	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
1241	CancelBtn = wx.Button(self.panel,-1,'Cancel')
1242	CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
1243	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
1244	btnSizer.Add((20,20),1)
1245	btnSizer.Add(OkBtn)
1246	btnSizer.Add(CancelBtn)
1247	btnSizer.Add((20,20),1)
1248	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
1249	self.panel.SetSizer(mainSizer)
1250	self.panel.Fit()
1251	self.Fit()
1252
1253	def GetSelection(self):
1254	return self.choices
1255
1256	def OnOk(self,event):
1257	parent = self.GetParent()
1258	parent.Raise()
1259	self.EndModal(wx.ID_OK)
1260
1261	def OnCancel(self,event):
1262	parent = self.GetParent()
1263	parent.Raise()
1264	self.EndModal(wx.ID_CANCEL)
1265
1266	class SingleFloatDialog(wx.Dialog):
1267	'Dialog to obtain a single float value from user'
1268	def __init__(self,parent,title,prompt,value,limits=[0.,1.],format='%.5g'):
1269	wx.Dialog.__init__(self,parent,-1,title,
1270	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
1271	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
1272	self.limits = limits
1273	self.value = value
1274	self.prompt = prompt
1275	self.format = format
1276	self.Draw()
1277
1278	def Draw(self):
1279
1280	def OnValItem(event):
1281	try:
1282	val = float(valItem.GetValue())
1283	if val < self.limits[0] or val > self.limits[1]:
1284	raise ValueError
1285	except ValueError:
1286	val = self.value
1287	self.value = val
1288	valItem.SetValue(self.format%(self.value))
1289
1290	self.panel.Destroy()
1291	self.panel = wx.Panel(self)
1292	mainSizer = wx.BoxSizer(wx.VERTICAL)
1293	mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
1294	valItem = wx.TextCtrl(self.panel,-1,value=self.format%(self.value),style=wx.TE_PROCESS_ENTER)
1295	mainSizer.Add(valItem,0,wx.ALIGN_CENTER)
1296	valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
1297	valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
1298	OkBtn = wx.Button(self.panel,-1,"Ok")
1299	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
1300	CancelBtn = wx.Button(self.panel,-1,'Cancel')
1301	CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
1302	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
1303	btnSizer.Add((20,20),1)
1304	btnSizer.Add(OkBtn)
1305	btnSizer.Add(CancelBtn)
1306	btnSizer.Add((20,20),1)
1307	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
1308	self.panel.SetSizer(mainSizer)
1309	self.panel.Fit()
1310	self.Fit()
1311
1312	def GetValue(self):
1313	return self.value
1314
1315	def OnOk(self,event):
1316	parent = self.GetParent()
1317	parent.Raise()
1318	self.EndModal(wx.ID_OK)
1319
1320	def OnCancel(self,event):
1321	parent = self.GetParent()
1322	parent.Raise()
1323	self.EndModal(wx.ID_CANCEL)
1324
1325	################################################################################
1326	class SingleStringDialog(wx.Dialog):
1327	'''Dialog to obtain a single string value from user
1328
1329	:param wx.Frame parent: name of parent frame
1330	:param str title: title string for dialog
1331	:param str prompt: string to tell use what they are inputting
1332	:param str value: default input value, if any
1333	'''
1334	def __init__(self,parent,title,prompt,value='',size=(200,-1)):
1335	wx.Dialog.__init__(self,parent,wx.ID_ANY,title,
1336	pos=wx.DefaultPosition,
1337	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
1338	self.value = value
1339	self.prompt = prompt
1340	self.CenterOnParent()
1341	self.panel = wx.Panel(self)
1342	mainSizer = wx.BoxSizer(wx.VERTICAL)
1343	mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
1344	self.valItem = wx.TextCtrl(self.panel,-1,value=str(self.value),size=size)
1345	mainSizer.Add(self.valItem,0,wx.ALIGN_CENTER)
1346	btnsizer = wx.StdDialogButtonSizer()
1347	OKbtn = wx.Button(self.panel, wx.ID_OK)
1348	OKbtn.SetDefault()
1349	btnsizer.AddButton(OKbtn)
1350	btn = wx.Button(self.panel, wx.ID_CANCEL)
1351	btnsizer.AddButton(btn)
1352	btnsizer.Realize()
1353	mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
1354	self.panel.SetSizer(mainSizer)
1355	self.panel.Fit()
1356	self.Fit()
1357
1358	def Show(self):
1359	'''Use this method after creating the dialog to post it
1360	:returns: True if the user pressed OK; False if the User pressed Cancel
1361	'''
1362	if self.ShowModal() == wx.ID_OK:
1363	self.value = self.valItem.GetValue()
1364	return True
1365	else:
1366	return False
1367
1368	def GetValue(self):
1369	'''Use this method to get the value entered by the user
1370	:returns: string entered by user
1371	'''
1372	return self.value
1373
1374	################################################################################
1375	class G2MultiChoiceDialog(wx.Dialog):
1376	'''A dialog similar to MultiChoiceDialog except that buttons are
1377	added to set all choices and to toggle all choices.
1378
1379	:param wx.Frame ParentFrame: reference to parent frame
1380	:param str title: heading above list of choices
1381	:param str header: Title to place on window frame
1382	:param list ChoiceList: a list of choices where one will be selected
1383	:param bool toggle: If True (default) the toggle and select all buttons
1384	are displayed
1385
1386	:param kw: optional keyword parameters for the wx.Dialog may
1387	be included such as size [which defaults to `(320,310)`] and
1388	style (which defaults to `wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER\|wx.CENTRE\| wx.OK \| wx.CANCEL`);
1389	note that `wx.OK` and `wx.CANCEL` controls
1390	the presence of the eponymous buttons in the dialog.
1391	:returns: the name of the created dialog
1392	'''
1393	def __init__(self,parent, title, header, ChoiceList, toggle=True, **kw):
1394	# process keyword parameters, notably Style
1395	options = {'size':(320,310), # default Frame keywords
1396	'style':wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER\|wx.CENTRE\| wx.OK \| wx.CANCEL,
1397	}
1398	options.update(kw)
1399	if options['style'] & wx.OK:
1400	useOK = True
1401	options['style'] ^= wx.OK
1402	else:
1403	useOK = False
1404	if options['style'] & wx.CANCEL:
1405	useCANCEL = True
1406	options['style'] ^= wx.CANCEL
1407	else:
1408	useCANCEL = False
1409	# create the dialog frame
1410	wx.Dialog.__init__(self,parent,wx.ID_ANY,header,**options)
1411	# fill the dialog
1412	Sizer = wx.BoxSizer(wx.VERTICAL)
1413	Sizer.Add(wx.StaticText(self,wx.ID_ANY,title),0,wx.ALL,12)
1414	self.clb = wx.CheckListBox(self, wx.ID_ANY, (30,30), wx.DefaultSize, ChoiceList)
1415	self.numchoices = len(ChoiceList)
1416	Sizer.Add(self.clb,1,wx.LEFT\|wx.RIGHT\|wx.EXPAND,10)
1417	Sizer.Add((-1,10))
1418	# set/toggle buttons
1419	if toggle:
1420	bSizer = wx.BoxSizer(wx.VERTICAL)
1421	setBut = wx.Button(self,wx.ID_ANY,'Set All')
1422	setBut.Bind(wx.EVT_BUTTON,self._SetAll)
1423	bSizer.Add(setBut,0,wx.ALIGN_CENTER)
1424	bSizer.Add((-1,5))
1425	togBut = wx.Button(self,wx.ID_ANY,'Toggle All')
1426	togBut.Bind(wx.EVT_BUTTON,self._ToggleAll)
1427	bSizer.Add(togBut,0,wx.ALIGN_CENTER)
1428	Sizer.Add(bSizer,0,wx.LEFT,12)
1429	# OK/Cancel buttons
1430	btnsizer = wx.StdDialogButtonSizer()
1431	if useOK:
1432	OKbtn = wx.Button(self, wx.ID_OK)
1433	OKbtn.SetDefault()
1434	btnsizer.AddButton(OKbtn)
1435	if useCANCEL:
1436	btn = wx.Button(self, wx.ID_CANCEL)
1437	btnsizer.AddButton(btn)
1438	btnsizer.Realize()
1439	Sizer.Add((-1,5))
1440	Sizer.Add(btnsizer,0,wx.ALIGN_RIGHT,50)
1441	Sizer.Add((-1,20))
1442	# OK done, let's get outa here
1443	self.SetSizer(Sizer)
1444	def GetSelections(self):
1445	'Returns a list of the indices for the selected choices'
1446	return [i for i in range(self.numchoices) if self.clb.IsChecked(i)]
1447	def _SetAll(self,event):
1448	'Set all choices on'
1449	self.clb.SetChecked(range(self.numchoices))
1450	def _ToggleAll(self,event):
1451	'flip the state of all choices'
1452	for i in range(self.numchoices):
1453	self.clb.Check(i,not self.clb.IsChecked(i))
1454
1455	def ItemSelector(ChoiceList, ParentFrame=None,
1456	title='Select an item',
1457	size=None, header='Item Selector',
1458	useCancel=True,multiple=False):
1459	''' Provide a wx dialog to select a single item or multiple items from list of choices
1460
1461	:param list ChoiceList: a list of choices where one will be selected
1462	:param wx.Frame ParentFrame: Name of parent frame (default None)
1463	:param str title: heading above list of choices (default 'Select an item')
1464	:param wx.Size size: Size for dialog to be created (default None -- size as needed)
1465	:param str header: Title to place on window frame (default 'Item Selector')
1466	:param bool useCancel: If True (default) both the OK and Cancel buttons are offered
1467	:param bool multiple: If True then multiple items can be selected (default False)
1468
1469	:returns: the selection index or None or a selection list if multiple is true
1470	'''
1471	if multiple:
1472	if useCancel:
1473	dlg = G2MultiChoiceDialog(
1474	ParentFrame,title, header, ChoiceList)
1475	else:
1476	dlg = G2MultiChoiceDialog(
1477	ParentFrame,title, header, ChoiceList,
1478	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER\|wx.OK\|wx.CENTRE)
1479	else:
1480	if useCancel:
1481	dlg = wx.SingleChoiceDialog(
1482	ParentFrame,title, header, ChoiceList)
1483	else:
1484	dlg = wx.SingleChoiceDialog(
1485	ParentFrame,title, header,ChoiceList,
1486	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER\|wx.OK\|wx.CENTRE)
1487	if size: dlg.SetSize(size)
1488	if dlg.ShowModal() == wx.ID_OK:
1489	if multiple:
1490	dlg.Destroy()
1491	return dlg.GetSelections()
1492	else:
1493	dlg.Destroy()
1494	return dlg.GetSelection()
1495	else:
1496	dlg.Destroy()
1497	return None
1498	dlg.Destroy()
1499
1500	################################################################################
1501	class GridFractionEditor(wg.PyGridCellEditor):
1502	'''A grid cell editor class that allows entry of values as fractions as well
1503	as sine and cosine values [as s() and c()]
1504	'''
1505	def __init__(self,grid):
1506	wg.PyGridCellEditor.__init__(self)
1507
1508	def Create(self, parent, id, evtHandler):
1509	self._tc = wx.TextCtrl(parent, id, "")
1510	self._tc.SetInsertionPoint(0)
1511	self.SetControl(self._tc)
1512
1513	if evtHandler:
1514	self._tc.PushEventHandler(evtHandler)
1515
1516	self._tc.Bind(wx.EVT_CHAR, self.OnChar)
1517
1518	def SetSize(self, rect):
1519	self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
1520	wx.SIZE_ALLOW_MINUS_ONE)
1521
1522	def BeginEdit(self, row, col, grid):
1523	self.startValue = grid.GetTable().GetValue(row, col)
1524	self._tc.SetValue(str(self.startValue))
1525	self._tc.SetInsertionPointEnd()
1526	self._tc.SetFocus()
1527	self._tc.SetSelection(0, self._tc.GetLastPosition())
1528
1529	def EndEdit(self, row, col, grid):
1530	changed = False
1531
1532	val = self._tc.GetValue().lower()
1533
1534	if val != self.startValue:
1535	changed = True
1536	neg = False
1537	if '-' in val:
1538	neg = True
1539	if '/' in val and '.' not in val:
1540	val += '.'
1541	elif 's' in val and not 'sind(' in val:
1542	if neg:
1543	val = '-sind('+val.strip('-s')+')'
1544	else:
1545	val = 'sind('+val.strip('s')+')'
1546	elif 'c' in val and not 'cosd(' in val:
1547	if neg:
1548	val = '-cosd('+val.strip('-c')+')'
1549	else:
1550	val = 'cosd('+val.strip('c')+')'
1551	try:
1552	val = float(eval(val))
1553	except (SyntaxError,NameError):
1554	val = self.startValue
1555	grid.GetTable().SetValue(row, col, val) # update the table
1556
1557	self.startValue = ''
1558	self._tc.SetValue('')
1559	return changed
1560
1561	def Reset(self):
1562	self._tc.SetValue(self.startValue)
1563	self._tc.SetInsertionPointEnd()
1564
1565	def Clone(self):
1566	return GridFractionEditor(grid)
1567
1568	def StartingKey(self, evt):
1569	self.OnChar(evt)
1570	if evt.GetSkipped():
1571	self._tc.EmulateKeyPress(evt)
1572
1573	def OnChar(self, evt):
1574	key = evt.GetKeyCode()
1575	if key == 15:
1576	return
1577	if key > 255:
1578	evt.Skip()
1579	return
1580	char = chr(key)
1581	if char in '.+-/0123456789cosind()':
1582	self._tc.WriteText(char)
1583	else:
1584	evt.Skip()
1585
1586	################################################################################
1587	class ShowLSParms(wx.Dialog):
1588	'''Create frame to show least-squares parameters
1589	'''
1590	def __init__(self,parent,title,parmDict,varyList,fullVaryList,
1591	size=(300,430)):
1592	wx.Dialog.__init__(self,parent,wx.ID_ANY,title,size=size,
1593	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
1594	mainSizer = wx.BoxSizer(wx.VERTICAL)
1595
1596	panel = wxscroll.ScrolledPanel(
1597	self, wx.ID_ANY,
1598	#size=size,
1599	style = wx.TAB_TRAVERSAL\|wx.SUNKEN_BORDER)
1600	num = len(varyList)
1601	mainSizer.Add(wx.StaticText(self,wx.ID_ANY,'Number of refined variables: '+str(num)))
1602	if len(varyList) != len(fullVaryList):
1603	num = len(fullVaryList) - len(varyList)
1604	mainSizer.Add(wx.StaticText(self,wx.ID_ANY,' + '+str(num)+' parameters are varied via constraints'))
1605	subSizer = wx.FlexGridSizer(rows=len(parmDict)+1,cols=4,hgap=2,vgap=2)
1606	parmNames = parmDict.keys()
1607	parmNames.sort()
1608	subSizer.Add((-1,-1))
1609	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'Parameter name '))
1610	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'refine?'))
1611	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'value'),0,wx.ALIGN_RIGHT)
1612	explainRefine = False
1613	for name in parmNames:
1614	# skip entries without numerical values
1615	if isinstance(parmDict[name],basestring): continue
1616	try:
1617	value = G2py3.FormatSigFigs(parmDict[name])
1618	except TypeError:
1619	value = str(parmDict[name])+' -?' # unexpected
1620	#continue
1621	v = G2obj.getVarDescr(name)
1622	if v is None or v[-1] is None:
1623	subSizer.Add((-1,-1))
1624	else:
1625	ch = HelpButton(panel,G2obj.fmtVarDescr(name))
1626	subSizer.Add(ch,0,wx.LEFT\|wx.RIGHT\|wx.ALIGN_CENTER_VERTICAL\|wx.ALIGN_CENTER,1)
1627	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,str(name)))
1628	if name in varyList:
1629	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'R'))
1630	elif name in fullVaryList:
1631	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,'C'))
1632	explainRefine = True
1633	else:
1634	subSizer.Add((-1,-1))
1635	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,value),0,wx.ALIGN_RIGHT)
1636
1637	# finish up ScrolledPanel
1638	panel.SetSizer(subSizer)
1639	panel.SetAutoLayout(1)
1640	panel.SetupScrolling()
1641	mainSizer.Add(panel,1, wx.ALL\|wx.EXPAND,1)
1642
1643	if explainRefine:
1644	mainSizer.Add(
1645	wx.StaticText(self,wx.ID_ANY,
1646	'"R" indicates a refined variable\n'+
1647	'"C" indicates generated from a constraint'
1648	),
1649	0, wx.ALL,0)
1650	# make OK button
1651	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
1652	btn = wx.Button(self, wx.ID_CLOSE,"Close")
1653	btn.Bind(wx.EVT_BUTTON,self._onClose)
1654	btnsizer.Add(btn)
1655	mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
1656	# Allow window to be enlarged but not made smaller
1657	self.SetSizer(mainSizer)
1658	self.SetMinSize(self.GetSize())
1659
1660	def _onClose(self,event):
1661	self.EndModal(wx.ID_CANCEL)
1662
1663	################################################################################
1664	class downdate(wx.Dialog):
1665	'''Dialog to allow a user to select a version of GSAS-II to install
1666	'''
1667	def __init__(self,parent=None):
1668	style=wx.DEFAULT_DIALOG_STYLE \| wx.RESIZE_BORDER
1669	wx.Dialog.__init__(self, parent, wx.ID_ANY, 'Select Version', style=style)
1670	pnl = wx.Panel(self)
1671	sizer = wx.BoxSizer(wx.VERTICAL)
1672	insver = GSASIIpath.svnGetRev(local=True)
1673	curver = int(GSASIIpath.svnGetRev(local=False))
1674	label = wx.StaticText(
1675	pnl, wx.ID_ANY,
1676	'Select a specific GSAS-II version to install'
1677	)
1678	sizer.Add(label, 0, wx.ALIGN_CENTRE\|wx.ALL, 5)
1679	sizer1 = wx.BoxSizer(wx.HORIZONTAL)
1680	sizer1.Add(
1681	wx.StaticText(pnl, wx.ID_ANY,
1682	'Currently installed version: '+str(insver)),
1683	0, wx.ALIGN_CENTRE\|wx.ALL, 5)
1684	sizer.Add(sizer1)
1685	sizer1 = wx.BoxSizer(wx.HORIZONTAL)
1686	sizer1.Add(
1687	wx.StaticText(pnl, wx.ID_ANY,
1688	'Select GSAS-II version to install: '),
1689	0, wx.ALIGN_CENTRE\|wx.ALL, 5)
1690	self.spin = wx.SpinCtrl(pnl, wx.ID_ANY,size=(150,-1))
1691	self.spin.SetRange(1, curver)
1692	self.spin.SetValue(curver)
1693	self.Bind(wx.EVT_SPINCTRL, self._onSpin, self.spin)
1694	self.Bind(wx.EVT_KILL_FOCUS, self._onSpin, self.spin)
1695	sizer1.Add(self.spin)
1696	sizer.Add(sizer1)
1697
1698	line = wx.StaticLine(pnl,-1, size=(-1,3), style=wx.LI_HORIZONTAL)
1699	sizer.Add(line, 0, wx.EXPAND\|wx.ALIGN_CENTER\|wx.ALL, 10)
1700
1701	self.text = wx.StaticText(pnl, wx.ID_ANY, "")
1702	sizer.Add(self.text, 0, wx.ALIGN_LEFT\|wx.EXPAND\|wx.ALL, 5)
1703
1704	line = wx.StaticLine(pnl,-1, size=(-1,3), style=wx.LI_HORIZONTAL)
1705	sizer.Add(line, 0, wx.EXPAND\|wx.ALIGN_CENTER\|wx.ALL, 10)
1706	sizer.Add(
1707	wx.StaticText(
1708	pnl, wx.ID_ANY,
1709	'If "Install" is pressed, your project will be saved;\n'
1710	'GSAS-II will exit; The specified version will be loaded\n'
1711	'and GSAS-II will restart. Press "Cancel" to abort.'),
1712	0, wx.EXPAND\|wx.ALL, 10)
1713	btnsizer = wx.StdDialogButtonSizer()
1714	btn = wx.Button(pnl, wx.ID_OK, "Install")
1715	btn.SetDefault()
1716	btnsizer.AddButton(btn)
1717	btn = wx.Button(pnl, wx.ID_CANCEL)
1718	btnsizer.AddButton(btn)
1719	btnsizer.Realize()
1720	sizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
1721	pnl.SetSizer(sizer)
1722	sizer.Fit(self)
1723	self.topsizer=sizer
1724	self.CenterOnParent()
1725	self._onSpin(None)
1726
1727	def _onSpin(self,event):
1728	'Called to load info about the selected version in the dialog'
1729	ver = self.spin.GetValue()
1730	d = GSASIIpath.svnGetLog(version=ver)
1731	date = d.get('date','?').split('T')[0]
1732	s = '(Version '+str(ver)+' created '+date
1733	s += ' by '+d.get('author','?')+')'
1734	msg = d.get('msg')
1735	if msg: s += '\n\nComment: '+msg
1736	self.text.SetLabel(s)
1737	self.topsizer.Fit(self)
1738
1739	def getVersion(self):
1740	'Get the version number in the dialog'
1741	return self.spin.GetValue()
1742
1743	################################################################################
1744	class MyHelp(wx.Menu):
1745	'''
1746	A class that creates the contents of a help menu.
1747	The menu will start with two entries:
1748
1749	* 'Help on <helpType>': where helpType is a reference to an HTML page to
1750	be opened
1751	* About: opens an About dialog using OnHelpAbout. N.B. on the Mac this
1752	gets moved to the App menu to be consistent with Apple style.
1753
1754	NOTE: for this to work properly with respect to system menus, the title
1755	for the menu must be &Help, or it will not be processed properly:
1756
1757	::
1758
1759	menu.Append(menu=MyHelp(self,...),title="&Help")
1760
1761	'''
1762	def __init__(self,frame,helpType=None,helpLbl=None,morehelpitems=[],title=''):
1763	wx.Menu.__init__(self,title)
1764	self.HelpById = {}
1765	self.frame = frame
1766	self.Append(help='', id=wx.ID_ABOUT, kind=wx.ITEM_NORMAL,
1767	text='&About GSAS-II')
1768	frame.Bind(wx.EVT_MENU, self.OnHelpAbout, id=wx.ID_ABOUT)
1769	if GSASIIpath.whichsvn():
1770	helpobj = self.Append(
1771	help='', id=wx.ID_ANY, kind=wx.ITEM_NORMAL,
1772	text='&Check for updates')
1773	frame.Bind(wx.EVT_MENU, self.OnCheckUpdates, helpobj)
1774	helpobj = self.Append(
1775	help='', id=wx.ID_ANY, kind=wx.ITEM_NORMAL,
1776	text='&Regress to an old GSAS-II version')
1777	frame.Bind(wx.EVT_MENU, self.OnSelectVersion, helpobj)
1778	for lbl,indx in morehelpitems:
1779	helpobj = self.Append(text=lbl,
1780	id=wx.ID_ANY, kind=wx.ITEM_NORMAL)
1781	frame.Bind(wx.EVT_MENU, self.OnHelpById, helpobj)
1782	self.HelpById[helpobj.GetId()] = indx
1783	# add a help item only when helpType is specified
1784	if helpType is not None:
1785	self.AppendSeparator()
1786	if helpLbl is None: helpLbl = helpType
1787	helpobj = self.Append(text='Help on '+helpLbl,
1788	id=wx.ID_ANY, kind=wx.ITEM_NORMAL)
1789	frame.Bind(wx.EVT_MENU, self.OnHelpById, helpobj)
1790	self.HelpById[helpobj.GetId()] = helpType
1791
1792	def OnHelpById(self,event):
1793	'''Called when Help on... is pressed in a menu. Brings up
1794	a web page for documentation.
1795	'''
1796	helpType = self.HelpById.get(event.GetId())
1797	if helpType is None:
1798	print 'Error: help lookup failed!',event.GetEventObject()
1799	print 'id=',event.GetId()
1800	else:
1801	ShowHelp(helpType,self.frame)
1802
1803	def OnHelpAbout(self, event):
1804	"Display an 'About GSAS-II' box"
1805	global __version__
1806	info = wx.AboutDialogInfo()
1807	info.Name = 'GSAS-II'
1808	ver = GSASIIpath.svnGetRev()
1809	if ver:
1810	info.Version = 'Revision '+str(ver)+' (svn), version '+__version__
1811	else:
1812	info.Version = 'Revision '+str(GSASIIpath.GetVersionNumber())+' (.py files), version '+__version__
1813	#info.Developers = ['Robert B. Von Dreele','Brian H. Toby']
1814	info.Copyright = ('(c) ' + time.strftime('%Y') +
1815	''' Argonne National Laboratory
1816	This product includes software developed
1817	by the UChicago Argonne, LLC, as
1818	Operator of Argonne National Laboratory.''')
1819	info.Description = '''General Structure Analysis System-II (GSAS-II)
1820	Robert B. Von Dreele and Brian H. Toby
1821
1822	Please cite as:
1823	B.H. Toby & R.B. Von Dreele, J. Appl. Cryst. 46, 544-549 (2013) '''
1824
1825	info.WebSite = ("https://subversion.xray.aps.anl.gov/trac/pyGSAS","GSAS-II home page")
1826	wx.AboutBox(info)
1827
1828	def OnCheckUpdates(self,event):
1829	'''Check if the GSAS-II repository has an update for the current source files
1830	and perform that update if requested.
1831	'''
1832	if not GSASIIpath.whichsvn():
1833	dlg = wx.MessageDialog(self.frame,
1834	'No Subversion','Cannot update GSAS-II because subversion (svn) was not found.',
1835	wx.OK)
1836	dlg.ShowModal()
1837	dlg.Destroy()
1838	return
1839	wx.BeginBusyCursor()
1840	local = GSASIIpath.svnGetRev()
1841	if local is None:
1842	wx.EndBusyCursor()
1843	dlg = wx.MessageDialog(self.frame,
1844	'Unable to run subversion on the GSAS-II current directory. Is GSAS-II installed correctly?',
1845	'Subversion error',
1846	wx.OK)
1847	dlg.ShowModal()
1848	dlg.Destroy()
1849	return
1850	print 'Installed GSAS-II version: '+local
1851	repos = GSASIIpath.svnGetRev(local=False)
1852	wx.EndBusyCursor()
1853	if repos is None:
1854	dlg = wx.MessageDialog(self.frame,
1855	'Unable to access the GSAS-II server. Is this computer on the internet?',
1856	'Server unavailable',
1857	wx.OK)
1858	dlg.ShowModal()
1859	dlg.Destroy()
1860	return
1861	print 'GSAS-II version on server: '+repos
1862	if local == repos:
1863	dlg = wx.MessageDialog(self.frame,
1864	'GSAS-II is up-to-date. Version '+local+' is already loaded.',
1865	'GSAS-II Up-to-date',
1866	wx.OK)
1867	dlg.ShowModal()
1868	dlg.Destroy()
1869	return
1870	mods = GSASIIpath.svnFindLocalChanges()
1871	if mods:
1872	dlg = wx.MessageDialog(self.frame,
1873	'You have version '+local+
1874	' of GSAS-II installed, but the current version is '+repos+
1875	'. However, '+str(len(mods))+
1876	' file(s) on your local computer have been modified.'
1877	' Updating will attempt to merge your local changes with '
1878	'the latest GSAS-II version, but if '
1879	'conflicts arise, local changes will be '
1880	'discarded. It is also possible that the '
1881	'local changes my prevent GSAS-II from running. '
1882	'Press OK to start an update if this is acceptable:',
1883	'Local GSAS-II Mods',
1884	wx.OK\|wx.CANCEL)
1885	if dlg.ShowModal() != wx.ID_OK:
1886	dlg.Destroy()
1887	return
1888	else:
1889	dlg.Destroy()
1890	else:
1891	dlg = wx.MessageDialog(self.frame,
1892	'You have version '+local+
1893	' of GSAS-II installed, but the current version is '+repos+
1894	'. Press OK to start an update:',
1895	'GSAS-II Updates',
1896	wx.OK\|wx.CANCEL)
1897	if dlg.ShowModal() != wx.ID_OK:
1898	dlg.Destroy()
1899	return
1900	dlg.Destroy()
1901	print 'start updates'
1902	dlg = wx.MessageDialog(self.frame,
1903	'Your project will now be saved, GSAS-II will exit and an update '
1904	'will be performed and GSAS-II will restart. Press Cancel to '
1905	'abort the update',
1906	'Start update?',
1907	wx.OK\|wx.CANCEL)
1908	if dlg.ShowModal() != wx.ID_OK:
1909	dlg.Destroy()
1910	return
1911	dlg.Destroy()
1912	self.frame.OnFileSave(event)
1913	GSASIIpath.svnUpdateProcess(projectfile=self.frame.GSASprojectfile)
1914	return
1915
1916	def OnSelectVersion(self,event):
1917	'''Allow the user to select a specific version of GSAS-II
1918	'''
1919	if not GSASIIpath.whichsvn():
1920	dlg = wx.MessageDialog(self,'No Subversion','Cannot update GSAS-II because subversion (svn) '+
1921	'was not found.'
1922	,wx.OK)
1923	dlg.ShowModal()
1924	return
1925	local = GSASIIpath.svnGetRev()
1926	if local is None:
1927	dlg = wx.MessageDialog(self.frame,
1928	'Unable to run subversion on the GSAS-II current directory. Is GSAS-II installed correctly?',
1929	'Subversion error',
1930	wx.OK)
1931	dlg.ShowModal()
1932	return
1933	mods = GSASIIpath.svnFindLocalChanges()
1934	if mods:
1935	dlg = wx.MessageDialog(self.frame,
1936	'You have version '+local+
1937	' of GSAS-II installed'
1938	'. However, '+str(len(mods))+
1939	' file(s) on your local computer have been modified.'
1940	' Downdating will attempt to merge your local changes with '
1941	'the selected GSAS-II version. '
1942	'Downdating is not encouraged because '
1943	'if merging is not possible, your local changes will be '
1944	'discarded. It is also possible that the '
1945	'local changes my prevent GSAS-II from running. '
1946	'Press OK to continue anyway.',
1947	'Local GSAS-II Mods',
1948	wx.OK\|wx.CANCEL)
1949	if dlg.ShowModal() != wx.ID_OK:
1950	dlg.Destroy()
1951	return
1952	dlg.Destroy()
1953	dlg = downdate(parent=self.frame)
1954	if dlg.ShowModal() == wx.ID_OK:
1955	ver = dlg.getVersion()
1956	else:
1957	dlg.Destroy()
1958	return
1959	dlg.Destroy()
1960	print('start regress to '+str(ver))
1961	GSASIIpath.svnUpdateProcess(
1962	projectfile=self.frame.GSASprojectfile,
1963	version=str(ver)
1964	)
1965	self.frame.OnFileSave(event)
1966	return
1967
1968	################################################################################
1969	class AddHelp(wx.Menu):
1970	'''For the Mac: creates an entry to the help menu of type
1971	'Help on <helpType>': where helpType is a reference to an HTML page to
1972	be opened.
1973
1974	NOTE: when appending this menu (menu.Append) be sure to set the title to
1975	'&Help' so that wx handles it correctly.
1976	'''
1977	def __init__(self,frame,helpType,helpLbl=None,title=''):
1978	wx.Menu.__init__(self,title)
1979	self.frame = frame
1980	if helpLbl is None: helpLbl = helpType
1981	# add a help item only when helpType is specified
1982	helpobj = self.Append(text='Help on '+helpLbl,
1983	id=wx.ID_ANY, kind=wx.ITEM_NORMAL)
1984	frame.Bind(wx.EVT_MENU, self.OnHelpById, helpobj)
1985	self.HelpById = helpType
1986
1987	def OnHelpById(self,event):
1988	'''Called when Help on... is pressed in a menu. Brings up
1989	a web page for documentation.
1990	'''
1991	ShowHelp(self.HelpById,self.frame)
1992
1993	################################################################################
1994	class HelpButton(wx.Button):
1995	'''Create a help button that displays help information.
1996	The text is displayed in a modal message window.
1997
1998	TODO: it might be nice if it were non-modal: e.g. it stays around until
1999	the parent is deleted or the user closes it, but this did not work for
2000	me.
2001
2002	:param parent: the panel which will be the parent of the button
2003	:param str msg: the help text to be displayed
2004	'''
2005	def __init__(self,parent,msg):
2006	if sys.platform == "darwin":
2007	wx.Button.__init__(self,parent,wx.ID_HELP)
2008	else:
2009	wx.Button.__init__(self,parent,wx.ID_ANY,'?',style=wx.BU_EXACTFIT)
2010	self.Bind(wx.EVT_BUTTON,self._onPress)
2011	self.msg=msg
2012	self.parent = parent
2013	def _onClose(self,event):
2014	self.dlg.EndModal(wx.ID_CANCEL)
2015	def _onPress(self,event):
2016	'Respond to a button press by displaying the requested text'
2017	#dlg = wx.MessageDialog(self.parent,self.msg,'Help info',wx.OK)
2018	self.dlg = wx.Dialog(self.parent,wx.ID_ANY,'Help information',
2019	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
2020	#self.dlg.SetBackgroundColour(wx.WHITE)
2021	mainSizer = wx.BoxSizer(wx.VERTICAL)
2022	txt = wx.StaticText(self.dlg,wx.ID_ANY,self.msg)
2023	mainSizer.Add(txt,1,wx.ALL\|wx.EXPAND,10)
2024	txt.SetBackgroundColour(wx.WHITE)
2025
2026	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
2027	btn = wx.Button(self.dlg, wx.ID_CLOSE)
2028	btn.Bind(wx.EVT_BUTTON,self._onClose)
2029	btnsizer.Add(btn)
2030	mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
2031	self.dlg.SetSizer(mainSizer)
2032	mainSizer.Fit(self.dlg)
2033	self.dlg.ShowModal()
2034	self.dlg.Destroy()
2035	################################################################################
2036	class MyHtmlPanel(wx.Panel):
2037	'''Defines a panel to display HTML help information, as an alternative to
2038	displaying help information in a web browser.
2039	'''
2040	def __init__(self, frame, id):
2041	self.frame = frame
2042	wx.Panel.__init__(self, frame, id)
2043	sizer = wx.BoxSizer(wx.VERTICAL)
2044	back = wx.Button(self, -1, "Back")
2045	back.Bind(wx.EVT_BUTTON, self.OnBack)
2046	self.htmlwin = G2HtmlWindow(self, id, size=(750,450))
2047	sizer.Add(self.htmlwin, 1,wx.EXPAND)
2048	sizer.Add(back, 0, wx.ALIGN_LEFT, 0)
2049	self.SetSizer(sizer)
2050	sizer.Fit(frame)
2051	self.Bind(wx.EVT_SIZE,self.OnHelpSize)
2052	def OnHelpSize(self,event): #does the job but weirdly!!
2053	anchor = self.htmlwin.GetOpenedAnchor()
2054	if anchor:
2055	self.htmlwin.ScrollToAnchor(anchor)
2056	wx.CallAfter(self.htmlwin.ScrollToAnchor,anchor)
2057	event.Skip()
2058	def OnBack(self, event):
2059	self.htmlwin.HistoryBack()
2060	def LoadFile(self,file):
2061	pos = file.rfind('#')
2062	if pos != -1:
2063	helpfile = file[:pos]
2064	helpanchor = file[pos+1:]
2065	else:
2066	helpfile = file
2067	helpanchor = None
2068	self.htmlwin.LoadPage(helpfile)
2069	if helpanchor is not None:
2070	self.htmlwin.ScrollToAnchor(helpanchor)
2071	xs,ys = self.htmlwin.GetViewStart()
2072	self.htmlwin.Scroll(xs,ys-1)
2073
2074	class G2HtmlWindow(wx.html.HtmlWindow):
2075	'''Displays help information in a primitive HTML browser type window
2076	'''
2077	def __init__(self, parent, args, *kwargs):
2078	self.parent = parent
2079	wx.html.HtmlWindow.__init__(self, parent, args, *kwargs)
2080	def LoadPage(self, args, *kwargs):
2081	wx.html.HtmlWindow.LoadPage(self, args, *kwargs)
2082	self.TitlePage()
2083	def OnLinkClicked(self, args, *kwargs):
2084	wx.html.HtmlWindow.OnLinkClicked(self, args, *kwargs)
2085	xs,ys = self.GetViewStart()
2086	self.Scroll(xs,ys-1)
2087	self.TitlePage()
2088	def HistoryBack(self, args, *kwargs):
2089	wx.html.HtmlWindow.HistoryBack(self, args, *kwargs)
2090	self.TitlePage()
2091	def TitlePage(self):
2092	self.parent.frame.SetTitle(self.GetOpenedPage() + ' -- ' +
2093	self.GetOpenedPageTitle())
2094
2095	################################################################################
2096	class DataFrame(wx.Frame):
2097	'''Create the data item window and all the entries in menus used in
2098	that window. For Linux and windows, the menu entries are created for the
2099	current data item window, but in the Mac the menu is accessed from all
2100	windows. This means that a different menu is posted depending on which
2101	data item is posted. On the Mac, all the menus contain the data tree menu
2102	items, but additional menus are added specific to the data item.
2103
2104	Note that while the menus are created here,
2105	the binding for the menus is done later in various GSASII*GUI modules,
2106	where the functions to be called are defined.
2107	'''
2108	def Bind(self,args,*kwargs):
2109	'''Override the Bind() function: on the Mac the binding is to
2110	the main window, so that menus operate with any window on top.
2111	For other platforms, call the default wx.Frame Bind()
2112	'''
2113	if sys.platform == "darwin": # mac
2114	self.G2frame.Bind(args,*kwargs)
2115	else:
2116	wx.Frame.Bind(self,args,*kwargs)
2117
2118	def PrefillDataMenu(self,menu,helpType,helpLbl=None,empty=False):
2119	'''Create the "standard" part of data frame menus. Note that on Linux and
2120	Windows nothing happens here. On Mac, this menu duplicates the
2121	tree menu, but adds an extra help command for the data item and a separator.
2122	'''
2123	self.datamenu = menu
2124	self.helpType = helpType
2125	self.helpLbl = helpLbl
2126	if sys.platform == "darwin": # mac
2127	self.G2frame.FillMainMenu(menu) # add the data tree menu items
2128	if not empty:
2129	menu.Append(wx.Menu(title=''),title='\|') # add a separator
2130
2131	def PostfillDataMenu(self,empty=False):
2132	'''Create the "standard" part of data frame menus. Note that on Linux and
2133	Windows, this is the standard help Menu. On Mac, this menu duplicates the
2134	tree menu, but adds an extra help command for the data item and a separator.
2135	'''
2136	menu = self.datamenu
2137	helpType = self.helpType
2138	helpLbl = self.helpLbl
2139	if sys.platform == "darwin": # mac
2140	if not empty:
2141	menu.Append(wx.Menu(title=''),title='\|') # add another separator
2142	menu.Append(AddHelp(self.G2frame,helpType=helpType, helpLbl=helpLbl),
2143	title='&Help')
2144	else: # other
2145	menu.Append(menu=MyHelp(self,helpType=helpType, helpLbl=helpLbl),
2146	title='&Help')
2147
2148	def _init_menus(self):
2149	'define all GSAS-II data frame menus'
2150
2151	# for use where no menu or data frame help is provided
2152	self.BlankMenu = wx.MenuBar()
2153
2154	# Controls
2155	self.ControlsMenu = wx.MenuBar()
2156	self.PrefillDataMenu(self.ControlsMenu,helpType='Controls',empty=True)
2157	self.PostfillDataMenu(empty=True)
2158
2159	# Notebook
2160	self.DataNotebookMenu = wx.MenuBar()
2161	self.PrefillDataMenu(self.DataNotebookMenu,helpType='Notebook',empty=True)
2162	self.PostfillDataMenu(empty=True)
2163
2164	# Comments
2165	self.DataCommentsMenu = wx.MenuBar()
2166	self.PrefillDataMenu(self.DataCommentsMenu,helpType='Comments',empty=True)
2167	self.PostfillDataMenu(empty=True)
2168
2169	# Constraints
2170	self.ConstraintMenu = wx.MenuBar()
2171	self.PrefillDataMenu(self.ConstraintMenu,helpType='Constraints')
2172	self.ConstraintTab = wx.Menu(title='')
2173	self.ConstraintMenu.Append(menu=self.ConstraintTab, title='Select tab')
2174	for id,txt in (
2175	(wxID_CONSPHASE,'Phase'),
2176	(wxID_CONSHAP,'Histogram/Phase'),
2177	(wxID_CONSHIST,'Histogram'),
2178	(wxID_CONSGLOBAL,'Global')):
2179	self.ConstraintTab.Append(
2180	id=id, kind=wx.ITEM_NORMAL,text=txt,
2181	help='Select '+txt+' constraint editing tab')
2182	self.ConstraintEdit = wx.Menu(title='')
2183	self.ConstraintMenu.Append(menu=self.ConstraintEdit, title='Edit')
2184	self.ConstraintEdit.Append(id=wxID_HOLDADD, kind=wx.ITEM_NORMAL,text='Add hold',
2185	help='Add hold on a parameter value')
2186	self.ConstraintEdit.Append(id=wxID_EQUIVADD, kind=wx.ITEM_NORMAL,text='Add equivalence',
2187	help='Add equivalence between parameter values')
2188	self.ConstraintEdit.Append(id=wxID_CONSTRAINTADD, kind=wx.ITEM_NORMAL,text='Add constraint',
2189	help='Add constraint on parameter values')
2190	self.ConstraintEdit.Append(id=wxID_FUNCTADD, kind=wx.ITEM_NORMAL,text='Add New Var',
2191	help='Add variable composed of existing parameter')
2192
2193	# item = self.ConstraintEdit.Append(id=wx.ID_ANY,kind=wx.ITEM_NORMAL,text='Update GUI')
2194	# def UpdateGSASIIconstrGUI(event):
2195	# import GSASIIconstrGUI
2196	# reload(GSASIIconstrGUI)
2197	# import GSASIIobj
2198	# reload(GSASIIobj)
2199	# self.Bind(wx.EVT_MENU,UpdateGSASIIconstrGUI,id=item.GetId())
2200
2201	self.PostfillDataMenu()
2202
2203	# Rigid bodies
2204	self.VectorRBEdit = wx.Menu(title='')
2205	self.VectorRBEdit.Append(id=wxID_RIGIDBODYADD, kind=wx.ITEM_NORMAL,text='Add rigid body',
2206	help='Add vector rigid body')
2207	self.ResidueRBMenu = wx.Menu(title='')
2208	self.ResidueRBMenu.Append(id=wxID_RIGIDBODYIMPORT, kind=wx.ITEM_NORMAL,text='Import XYZ',
2209	help='Import rigid body XYZ from file')
2210	self.ResidueRBMenu.Append(id=wxID_RESIDUETORSSEQ, kind=wx.ITEM_NORMAL,text='Define sequence',
2211	help='Define torsion sequence')
2212	self.ResidueRBMenu.Append(id=wxID_RIGIDBODYADD, kind=wx.ITEM_NORMAL,text='Import residues',
2213	help='Import residue rigid bodies from macro file')
2214
2215	self.RigidBodyMenu = wx.MenuBar()
2216	self.PrefillDataMenu(self.RigidBodyMenu,helpType='Rigid bodies')
2217	self.RigidBodyMenu.Append(menu=self.VectorRBEdit, title='Edit')
2218	self.PostfillDataMenu()
2219
2220	# Restraints
2221	self.RestraintEdit = wx.Menu(title='')
2222	self.RestraintEdit.Append(id=wxID_RESTSELPHASE, kind=wx.ITEM_NORMAL,text='Select phase',
2223	help='Select phase')
2224	self.RestraintEdit.Append(id=wxID_RESTRAINTADD, kind=wx.ITEM_NORMAL,text='Add restraints',
2225	help='Add restraints')
2226	self.RestraintEdit.Enable(wxID_RESTRAINTADD,True) #gets disenabled if macromolecule phase
2227	self.RestraintEdit.Append(id=wxID_AARESTRAINTADD, kind=wx.ITEM_NORMAL,text='Add residue restraints',
2228	help='Add residue based restraints for macromolecules from macro file')
2229	self.RestraintEdit.Enable(wxID_AARESTRAINTADD,False) #gets enabled if macromolecule phase
2230	self.RestraintEdit.Append(id=wxID_AARESTRAINTPLOT, kind=wx.ITEM_NORMAL,text='Plot residue restraints',
2231	help='Plot selected residue based restraints for macromolecules from macro file')
2232	self.RestraintEdit.Enable(wxID_AARESTRAINTPLOT,False) #gets enabled if macromolecule phase
2233	self.RestraintEdit.Append(id=wxID_RESRCHANGEVAL, kind=wx.ITEM_NORMAL,text='Change value',
2234	help='Change observed value')
2235	self.RestraintEdit.Append(id=wxID_RESTCHANGEESD, kind=wx.ITEM_NORMAL,text='Change esd',
2236	help='Change esd in observed value')
2237	self.RestraintEdit.Append(id=wxID_RESTDELETE, kind=wx.ITEM_NORMAL,text='Delete restraints',
2238	help='Delete selected restraints')
2239
2240	self.RestraintMenu = wx.MenuBar()
2241	self.PrefillDataMenu(self.RestraintMenu,helpType='Restraints')
2242	self.RestraintMenu.Append(menu=self.RestraintEdit, title='Edit')
2243	self.PostfillDataMenu()
2244
2245	# Sequential results
2246	self.SequentialMenu = wx.MenuBar()
2247	self.PrefillDataMenu(self.SequentialMenu,helpType='Sequential',helpLbl='Sequential Refinement')
2248	self.SequentialFile = wx.Menu(title='')
2249	self.SequentialMenu.Append(menu=self.SequentialFile, title='File')
2250	self.SequentialFile.Append(id=wxID_SAVESEQSEL, kind=wx.ITEM_NORMAL,text='Save...',
2251	help='Save selected sequential refinement results')
2252	self.PostfillDataMenu()
2253
2254	# PDR
2255	self.ErrorMenu = wx.MenuBar()
2256	self.PrefillDataMenu(self.ErrorMenu,helpType='PWD Analysis',helpLbl='Powder Fit Error Analysis')
2257	self.ErrorAnal = wx.Menu(title='')
2258	self.ErrorMenu.Append(menu=self.ErrorAnal,title='Analysis')
2259	self.ErrorAnal.Append(id=wxID_PWDANALYSIS,kind=wx.ITEM_NORMAL,text='Analyze',
2260	help='Error analysis on powder pattern')
2261	self.PostfillDataMenu()
2262
2263	# PDR / Limits
2264	self.LimitMenu = wx.MenuBar()
2265	self.PrefillDataMenu(self.LimitMenu,helpType='Limits')
2266	self.LimitEdit = wx.Menu(title='')
2267	self.LimitMenu.Append(menu=self.LimitEdit, title='Edit')
2268	self.LimitEdit.Append(id=wxID_LIMITCOPY, kind=wx.ITEM_NORMAL,text='Copy',
2269	help='Copy limits to other histograms')
2270	self.LimitEdit.Append(id=wxID_ADDEXCLREGION, kind=wx.ITEM_NORMAL,text='Add exclude',
2271	help='Add excluded region - select a point on plot; drag to adjust')
2272	self.PostfillDataMenu()
2273
2274	# PDR / Background
2275	self.BackMenu = wx.MenuBar()
2276	self.PrefillDataMenu(self.BackMenu,helpType='Background')
2277	self.BackEdit = wx.Menu(title='')
2278	self.BackMenu.Append(menu=self.BackEdit, title='File')
2279	self.BackEdit.Append(id=wxID_BACKCOPY, kind=wx.ITEM_NORMAL,text='Copy',
2280	help='Copy background parameters to other histograms')
2281	self.BackEdit.Append(id=wxID_BACKFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
2282	help='Copy background refinement flags to other histograms')
2283	self.PostfillDataMenu()
2284
2285	# PDR / Instrument Parameters
2286	self.InstMenu = wx.MenuBar()
2287	self.PrefillDataMenu(self.InstMenu,helpType='Instrument Parameters')
2288	self.InstEdit = wx.Menu(title='')
2289	self.InstMenu.Append(menu=self.InstEdit, title='Operations')
2290	self.InstEdit.Append(help='Reset instrument profile parameters to default',
2291	id=wxID_INSTLOAD, kind=wx.ITEM_NORMAL,text='Load profile...')
2292	self.InstEdit.Append(help='Load instrument profile parameters from file',
2293	id=wxID_INSTSAVE, kind=wx.ITEM_NORMAL,text='Save profile...')
2294	self.InstEdit.Append(help='Save instrument profile parameters to file',
2295	id=wxID_INSTPRMRESET, kind=wx.ITEM_NORMAL,text='Reset profile')
2296	self.InstEdit.Append(help='Copy instrument profile parameters to other histograms',
2297	id=wxID_INSTCOPY, kind=wx.ITEM_NORMAL,text='Copy')
2298	self.InstEdit.Append(id=wxID_INSTFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
2299	help='Copy instrument parameter refinement flags to other histograms')
2300	# self.InstEdit.Append(help='Change radiation type (Ka12 - synch)',
2301	# id=wxID_CHANGEWAVETYPE, kind=wx.ITEM_NORMAL,text='Change radiation')
2302	self.PostfillDataMenu()
2303
2304	# PDR / Sample Parameters
2305	self.SampleMenu = wx.MenuBar()
2306	self.PrefillDataMenu(self.SampleMenu,helpType='Sample Parameters')
2307	self.SampleEdit = wx.Menu(title='')
2308	self.SampleMenu.Append(menu=self.SampleEdit, title='Command')
2309	self.SampleEdit.Append(id=wxID_SAMPLELOAD, kind=wx.ITEM_NORMAL,text='Load',
2310	help='Load sample parameters from file')
2311	self.SampleEdit.Append(id=wxID_SAMPLESAVE, kind=wx.ITEM_NORMAL,text='Save',
2312	help='Save sample parameters to file')
2313	self.SampleEdit.Append(id=wxID_SAMPLECOPY, kind=wx.ITEM_NORMAL,text='Copy',
2314	help='Copy refinable sample parameters to other histograms')
2315	self.SampleEdit.Append(id=wxID_SAMPLEFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
2316	help='Copy sample parameter refinement flags to other histograms')
2317	self.PostfillDataMenu()
2318
2319	# PDR / Peak List
2320	self.PeakMenu = wx.MenuBar()
2321	self.PrefillDataMenu(self.PeakMenu,helpType='Peak List')
2322	self.PeakEdit = wx.Menu(title='')
2323	self.PeakMenu.Append(menu=self.PeakEdit, title='Peak Fitting')
2324	self.AutoSearch = self.PeakEdit.Append(help='Automatic peak search',
2325	id=wxID_AUTOSEARCH, kind=wx.ITEM_NORMAL,text='Auto search')
2326	self.UnDo = self.PeakEdit.Append(help='Undo last least squares refinement',
2327	id=wxID_UNDO, kind=wx.ITEM_NORMAL,text='UnDo')
2328	self.PeakFit = self.PeakEdit.Append(id=wxID_LSQPEAKFIT, kind=wx.ITEM_NORMAL,text='LSQ PeakFit',
2329	help='Peak fitting via least-squares' )
2330	self.PFOneCycle = self.PeakEdit.Append(id=wxID_LSQONECYCLE, kind=wx.ITEM_NORMAL,text='LSQ one cycle',
2331	help='One cycle of Peak fitting via least-squares' )
2332	self.PeakEdit.Append(id=wxID_RESETSIGGAM, kind=wx.ITEM_NORMAL,
2333	text='Reset sig and gam',help='Reset sigma and gamma to global fit' )
2334	self.PeakEdit.Append(id=wxID_CLEARPEAKS, kind=wx.ITEM_NORMAL,text='Clear peaks',
2335	help='Clear the peak list' )
2336	self.PostfillDataMenu()
2337	self.UnDo.Enable(False)
2338	self.PeakFit.Enable(False)
2339	self.PFOneCycle.Enable(False)
2340
2341	# PDR / Index Peak List
2342	self.IndPeaksMenu = wx.MenuBar()
2343	self.PrefillDataMenu(self.IndPeaksMenu,helpType='Index Peak List')
2344	self.IndPeaksEdit = wx.Menu(title='')
2345	self.IndPeaksMenu.Append(menu=self.IndPeaksEdit,title='Operations')
2346	self.IndPeaksEdit.Append(help='Load/Reload index peaks from peak list',id=wxID_INDXRELOAD,
2347	kind=wx.ITEM_NORMAL,text='Load/Reload')
2348	self.PostfillDataMenu()
2349
2350	# PDR / Unit Cells List
2351	self.IndexMenu = wx.MenuBar()
2352	self.PrefillDataMenu(self.IndexMenu,helpType='Unit Cells List')
2353	self.IndexEdit = wx.Menu(title='')
2354	self.IndexMenu.Append(menu=self.IndexEdit, title='Cell Index/Refine')
2355	self.IndexPeaks = self.IndexEdit.Append(help='', id=wxID_INDEXPEAKS, kind=wx.ITEM_NORMAL,
2356	text='Index Cell')
2357	self.CopyCell = self.IndexEdit.Append( id=wxID_COPYCELL, kind=wx.ITEM_NORMAL,text='Copy Cell',
2358	help='Copy selected unit cell from indexing to cell refinement fields')
2359	self.RefineCell = self.IndexEdit.Append( id=wxID_REFINECELL, kind=wx.ITEM_NORMAL,
2360	text='Refine Cell',help='Refine unit cell parameters from indexed peaks')
2361	self.MakeNewPhase = self.IndexEdit.Append( id=wxID_MAKENEWPHASE, kind=wx.ITEM_NORMAL,
2362	text='Make new phase',help='Make new phase from selected unit cell')
2363	self.PostfillDataMenu()
2364	self.IndexPeaks.Enable(False)
2365	self.CopyCell.Enable(False)
2366	self.RefineCell.Enable(False)
2367	self.MakeNewPhase.Enable(False)
2368
2369	# PDR / Reflection Lists
2370	self.ReflMenu = wx.MenuBar()
2371	self.PrefillDataMenu(self.ReflMenu,helpType='Reflection List')
2372	self.ReflEdit = wx.Menu(title='')
2373	self.ReflMenu.Append(menu=self.ReflEdit, title='Reflection List')
2374	self.SelectPhase = self.ReflEdit.Append(help='Select phase for reflection list',id=wxID_SELECTPHASE,
2375	kind=wx.ITEM_NORMAL,text='Select phase')
2376	self.PostfillDataMenu()
2377
2378	# SASD/ Models
2379	self.ModelMenu = wx.MenuBar()
2380	self.PrefillDataMenu(self.ModelMenu,helpType='Models')
2381	self.ModelEdit = wx.Menu(title='')
2382	self.ModelMenu.Append(menu=self.ModelEdit, title='Models')
2383	self.ModelEdit.Append(id=wxID_MODELFIT, kind=wx.ITEM_NORMAL,text='Fit',
2384	help='Fit model parameters to data')
2385	self.ModelEdit.Append(id=wxID_MODELCOPY, kind=wx.ITEM_NORMAL,text='Copy',
2386	help='Copy model parameters to other histograms')
2387	self.PostfillDataMenu()
2388
2389	# IMG / Image Controls
2390	self.ImageMenu = wx.MenuBar()
2391	self.PrefillDataMenu(self.ImageMenu,helpType='Image Controls')
2392	self.ImageEdit = wx.Menu(title='')
2393	self.ImageMenu.Append(menu=self.ImageEdit, title='Operations')
2394	self.ImageEdit.Append(help='Calibrate detector by fitting to calibrant lines',
2395	id=wxID_IMCALIBRATE, kind=wx.ITEM_NORMAL,text='Calibrate')
2396	self.ImageEdit.Append(help='Recalibrate detector by fitting to calibrant lines',
2397	id=wxID_IMRECALIBRATE, kind=wx.ITEM_NORMAL,text='Recalibrate')
2398	self.ImageEdit.Append(help='Clear calibration data points and rings',id=wxID_IMCLEARCALIB,
2399	kind=wx.ITEM_NORMAL,text='Clear calibration')
2400	self.ImageEdit.Append(help='Integrate selected image',id=wxID_IMINTEGRATE,
2401	kind=wx.ITEM_NORMAL,text='Integrate')
2402	self.ImageEdit.Append(help='Integrate all images selected from list',id=wxID_INTEGRATEALL,
2403	kind=wx.ITEM_NORMAL,text='Integrate all')
2404	self.ImageEdit.Append(help='Copy image controls to other images',
2405	id=wxID_IMCOPYCONTROLS, kind=wx.ITEM_NORMAL,text='Copy Controls')
2406	self.ImageEdit.Append(help='Save image controls to file',
2407	id=wxID_IMSAVECONTROLS, kind=wx.ITEM_NORMAL,text='Save Controls')
2408	self.ImageEdit.Append(help='Load image controls from file',
2409	id=wxID_IMLOADCONTROLS, kind=wx.ITEM_NORMAL,text='Load Controls')
2410	self.PostfillDataMenu()
2411
2412	# IMG / Masks
2413	self.MaskMenu = wx.MenuBar()
2414	self.PrefillDataMenu(self.MaskMenu,helpType='Image Masks')
2415	self.MaskEdit = wx.Menu(title='')
2416	self.MaskMenu.Append(menu=self.MaskEdit, title='Operations')
2417	submenu = wx.Menu()
2418	self.MaskEdit.AppendMenu(
2419	wx.ID_ANY,'Create new', submenu,
2420	help=''
2421	)
2422	self.MaskEdit.Append(help='Copy mask to other images',
2423	id=wxID_MASKCOPY, kind=wx.ITEM_NORMAL,text='Copy mask')
2424	self.MaskEdit.Append(help='Save mask to file',
2425	id=wxID_MASKSAVE, kind=wx.ITEM_NORMAL,text='Save mask')
2426	self.MaskEdit.Append(help='Load mask from file',
2427	id=wxID_MASKLOAD, kind=wx.ITEM_NORMAL,text='Load mask')
2428	submenu.Append(help='Create an arc mask with mouse input',
2429	id=wxID_NEWMASKARC, kind=wx.ITEM_NORMAL,text='Arc mask')
2430	submenu.Append(help='Create a frame mask with mouse input',
2431	id=wxID_NEWMASKFRAME, kind=wx.ITEM_NORMAL,text='Frame mask')
2432	submenu.Append(help='Create a polygon mask with mouse input',
2433	id=wxID_NEWMASKPOLY, kind=wx.ITEM_NORMAL,text='Polygon mask')
2434	submenu.Append(help='Create a ring mask with mouse input',
2435	id=wxID_NEWMASKRING, kind=wx.ITEM_NORMAL,text='Ring mask')
2436	submenu.Append(help='Create a spot mask with mouse input',
2437	id=wxID_NEWMASKSPOT, kind=wx.ITEM_NORMAL,text='Spot mask')
2438	self.PostfillDataMenu()
2439
2440	# IMG / Stress/Strain
2441	self.StrStaMenu = wx.MenuBar()
2442	self.PrefillDataMenu(self.StrStaMenu,helpType='Stress/Strain')
2443	self.StrStaEdit = wx.Menu(title='')
2444	self.StrStaMenu.Append(menu=self.StrStaEdit, title='Operations')
2445	self.StrStaEdit.Append(help='Append d-zero for one ring',
2446	id=wxID_APPENDDZERO, kind=wx.ITEM_NORMAL,text='Append d-zero')
2447	self.StrStaEdit.Append(help='Fit stress/strain data',
2448	id=wxID_STRSTAFIT, kind=wx.ITEM_NORMAL,text='Fit stress/strain')
2449	self.StrStaEdit.Append(help='Update d-zero from ave d-zero',
2450	id=wxID_UPDATEDZERO, kind=wx.ITEM_NORMAL,text='Update d-zero')
2451	self.StrStaEdit.Append(help='Fit stress/strain data for all images',
2452	id=wxID_STRSTAALLFIT, kind=wx.ITEM_NORMAL,text='All image fit')
2453	self.StrStaEdit.Append(help='Copy stress/strain data to other images',
2454	id=wxID_STRSTACOPY, kind=wx.ITEM_NORMAL,text='Copy stress/strain')
2455	self.StrStaEdit.Append(help='Save stress/strain data to file',
2456	id=wxID_STRSTASAVE, kind=wx.ITEM_NORMAL,text='Save stress/strain')
2457	self.StrStaEdit.Append(help='Load stress/strain data from file',
2458	id=wxID_STRSTALOAD, kind=wx.ITEM_NORMAL,text='Load stress/strain')
2459	self.PostfillDataMenu()
2460
2461	# PDF / PDF Controls
2462	self.PDFMenu = wx.MenuBar()
2463	self.PrefillDataMenu(self.PDFMenu,helpType='PDF Controls')
2464	self.PDFEdit = wx.Menu(title='')
2465	self.PDFMenu.Append(menu=self.PDFEdit, title='PDF Controls')
2466	self.PDFEdit.Append(help='Add element to sample composition',id=wxID_PDFADDELEMENT, kind=wx.ITEM_NORMAL,
2467	text='Add element')
2468	self.PDFEdit.Append(help='Delete element from sample composition',id=wxID_PDFDELELEMENT, kind=wx.ITEM_NORMAL,
2469	text='Delete element')
2470	self.PDFEdit.Append(help='Copy PDF controls', id=wxID_PDFCOPYCONTROLS, kind=wx.ITEM_NORMAL,
2471	text='Copy controls')
2472	# self.PDFEdit.Append(help='Load PDF controls from file',id=wxID_PDFLOADCONTROLS, kind=wx.ITEM_NORMAL,
2473	# text='Load Controls')
2474	# self.PDFEdit.Append(help='Save PDF controls to file', id=wxID_PDFSAVECONTROLS, kind=wx.ITEM_NORMAL,
2475	# text='Save controls')
2476	self.PDFEdit.Append(help='Compute PDF', id=wxID_PDFCOMPUTE, kind=wx.ITEM_NORMAL,
2477	text='Compute PDF')
2478	self.PDFEdit.Append(help='Compute all PDFs', id=wxID_PDFCOMPUTEALL, kind=wx.ITEM_NORMAL,
2479	text='Compute all PDFs')
2480	self.PostfillDataMenu()
2481
2482	# Phase / General tab
2483	self.DataGeneral = wx.MenuBar()
2484	self.PrefillDataMenu(self.DataGeneral,helpType='General', helpLbl='Phase/General')
2485	self.DataGeneral.Append(menu=wx.Menu(title=''),title='Select tab')
2486	self.GeneralCalc = wx.Menu(title='')
2487	self.DataGeneral.Append(menu=self.GeneralCalc,title='Compute')
2488	self.GeneralCalc.Append(help='Compute Fourier map',id=wxID_FOURCALC, kind=wx.ITEM_NORMAL,
2489	text='Fourier map')
2490	self.GeneralCalc.Append(help='Search Fourier map',id=wxID_FOURSEARCH, kind=wx.ITEM_NORMAL,
2491	text='Search map')
2492	self.GeneralCalc.Append(help='Run charge flipping',id=wxID_CHARGEFLIP, kind=wx.ITEM_NORMAL,
2493	text='Charge flipping')
2494	self.GeneralCalc.Append(help='Clear map',id=wxID_FOURCLEAR, kind=wx.ITEM_NORMAL,
2495	text='Clear map')
2496	self.GeneralCalc.Append(help='Run Monte Carlo - Simulated Annealing',id=wxID_SINGLEMCSA, kind=wx.ITEM_NORMAL,
2497	text='MC/SA')
2498	self.GeneralCalc.Append(help='Run Monte Carlo - Simulated Annealing on multiprocessors',id=wxID_MULTIMCSA, kind=wx.ITEM_NORMAL,
2499	text='Multi MC/SA') #currently not useful
2500	self.PostfillDataMenu()
2501
2502	# Phase / Data tab
2503	self.DataMenu = wx.MenuBar()
2504	self.PrefillDataMenu(self.DataMenu,helpType='Data', helpLbl='Phase/Data')
2505	self.DataMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2506	self.DataEdit = wx.Menu(title='')
2507	self.DataMenu.Append(menu=self.DataEdit, title='Edit')
2508	self.DataEdit.Append(id=wxID_PWDRADD, kind=wx.ITEM_NORMAL,text='Add powder histograms',
2509	help='Select new powder histograms to be used for this phase')
2510	self.DataEdit.Append(id=wxID_HKLFADD, kind=wx.ITEM_NORMAL,text='Add single crystal histograms',
2511	help='Select new single crystal histograms to be used for this phase')
2512	self.DataEdit.Append(id=wxID_DATADELETE, kind=wx.ITEM_NORMAL,text='Remove histograms',
2513	help='Remove histograms from use for this phase')
2514	self.PostfillDataMenu()
2515
2516	# Phase / Atoms tab
2517	self.AtomsMenu = wx.MenuBar()
2518	self.PrefillDataMenu(self.AtomsMenu,helpType='Atoms')
2519	self.AtomsMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2520	self.AtomEdit = wx.Menu(title='')
2521	self.AtomCompute = wx.Menu(title='')
2522	self.AtomsMenu.Append(menu=self.AtomEdit, title='Edit')
2523	self.AtomsMenu.Append(menu=self.AtomCompute, title='Compute')
2524	self.AtomEdit.Append(id=wxID_ATOMSEDITADD, kind=wx.ITEM_NORMAL,text='Append atom',
2525	help='Appended as an H atom')
2526	self.AtomEdit.Append(id=wxID_ATOMSVIEWADD, kind=wx.ITEM_NORMAL,text='Append view point',
2527	help='Appended as an H atom')
2528	self.AtomEdit.Append(id=wxID_ATOMSEDITINSERT, kind=wx.ITEM_NORMAL,text='Insert atom',
2529	help='Select atom row to insert before; inserted as an H atom')
2530	self.AtomEdit.Append(id=wxID_ATOMVIEWINSERT, kind=wx.ITEM_NORMAL,text='Insert view point',
2531	help='Select atom row to insert before; inserted as an H atom')
2532	self.AtomEdit.Append(id=wxID_ATOMMOVE, kind=wx.ITEM_NORMAL,text='Move atom to view point',
2533	help='Select single atom to move')
2534	self.AtomEdit.Append(id=wxID_ATOMSEDITDELETE, kind=wx.ITEM_NORMAL,text='Delete atom',
2535	help='Select atoms to delete first')
2536	self.AtomEdit.Append(id=wxID_ATOMSREFINE, kind=wx.ITEM_NORMAL,text='Set atom refinement flags',
2537	help='Select atoms to refine first')
2538	self.AtomEdit.Append(id=wxID_ATOMSMODIFY, kind=wx.ITEM_NORMAL,text='Modify atom parameters',
2539	help='Select atoms to modify first')
2540	self.AtomEdit.Append(id=wxID_ATOMSTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform atoms',
2541	help='Select atoms to transform first')
2542	self.AtomEdit.Append(id=wxID_RELOADDRAWATOMS, kind=wx.ITEM_NORMAL,text='Reload draw atoms',
2543	help='Reload atom drawing list')
2544	submenu = wx.Menu()
2545	self.AtomEdit.AppendMenu(wx.ID_ANY, 'Reimport atoms', submenu,
2546	help='Reimport atoms from file; sequence must match')
2547	# setup a cascade menu for the formats that have been defined
2548	self.ReImportMenuId = {} # points to readers for each menu entry
2549	for reader in self.G2frame.ImportPhaseReaderlist:
2550	item = submenu.Append(
2551	wx.ID_ANY,help=reader.longFormatName,
2552	kind=wx.ITEM_NORMAL,text='reimport coordinates from '+reader.formatName+' file')
2553	self.ReImportMenuId[item.GetId()] = reader
2554	item = submenu.Append(
2555	wx.ID_ANY,
2556	help='Reimport coordinates, try to determine format from file',
2557	kind=wx.ITEM_NORMAL,
2558	text='guess format from file')
2559	self.ReImportMenuId[item.GetId()] = None # try all readers
2560
2561	self.AtomCompute.Append(id=wxID_ATOMSDISAGL, kind=wx.ITEM_NORMAL,text='Show Distances && Angles',
2562	help='Compute distances & angles for selected atoms')
2563	self.AtomCompute.Append(id=wxID_ATOMSPDISAGL, kind=wx.ITEM_NORMAL,text='Save Distances && Angles',
2564	help='Compute distances & angles for selected atoms')
2565	self.AtomCompute.ISOcalc = self.AtomCompute.Append(
2566	id=wxID_ISODISP, kind=wx.ITEM_NORMAL,
2567	text='Compute ISODISTORT mode values',
2568	help='Compute values of ISODISTORT modes from atom parameters')
2569	self.PostfillDataMenu()
2570
2571	# Phase / Draw Options tab
2572	self.DataDrawOptions = wx.MenuBar()
2573	self.PrefillDataMenu(self.DataDrawOptions,helpType='Draw Options', helpLbl='Phase/Draw Options')
2574	self.DataDrawOptions.Append(menu=wx.Menu(title=''),title='Select tab')
2575	self.PostfillDataMenu()
2576
2577	# Phase / Draw Atoms tab
2578	self.DrawAtomsMenu = wx.MenuBar()
2579	self.PrefillDataMenu(self.DrawAtomsMenu,helpType='Draw Atoms')
2580	self.DrawAtomsMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2581	self.DrawAtomEdit = wx.Menu(title='')
2582	self.DrawAtomCompute = wx.Menu(title='')
2583	self.DrawAtomRestraint = wx.Menu(title='')
2584	self.DrawAtomRigidBody = wx.Menu(title='')
2585	self.DrawAtomsMenu.Append(menu=self.DrawAtomEdit, title='Edit')
2586	self.DrawAtomsMenu.Append(menu=self.DrawAtomCompute,title='Compute')
2587	self.DrawAtomsMenu.Append(menu=self.DrawAtomRestraint, title='Restraints')
2588	self.DrawAtomsMenu.Append(menu=self.DrawAtomRigidBody, title='Rigid body')
2589	self.DrawAtomEdit.Append(id=wxID_DRAWATOMSTYLE, kind=wx.ITEM_NORMAL,text='Atom style',
2590	help='Select atoms first')
2591	self.DrawAtomEdit.Append(id=wxID_DRAWATOMLABEL, kind=wx.ITEM_NORMAL,text='Atom label',
2592	help='Select atoms first')
2593	self.DrawAtomEdit.Append(id=wxID_DRAWATOMCOLOR, kind=wx.ITEM_NORMAL,text='Atom color',
2594	help='Select atoms first')
2595	self.DrawAtomEdit.Append(id=wxID_DRAWATOMRESETCOLOR, kind=wx.ITEM_NORMAL,text='Reset atom colors',
2596	help='Resets all atom colors to defaults')
2597	self.DrawAtomEdit.Append(id=wxID_DRAWVIEWPOINT, kind=wx.ITEM_NORMAL,text='View point',
2598	help='View point is 1st atom selected')
2599	self.DrawAtomEdit.Append(id=wxID_DRAWADDEQUIV, kind=wx.ITEM_NORMAL,text='Add atoms',
2600	help='Add symmetry & cell equivalents to drawing set from selected atoms')
2601	self.DrawAtomEdit.Append(id=wxID_DRAWTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform atoms',
2602	help='Transform selected atoms by symmetry & cell translations')
2603	self.DrawAtomEdit.Append(id=wxID_DRAWFILLCOORD, kind=wx.ITEM_NORMAL,text='Fill CN-sphere',
2604	help='Fill coordination sphere for selected atoms')
2605	self.DrawAtomEdit.Append(id=wxID_DRAWFILLCELL, kind=wx.ITEM_NORMAL,text='Fill unit cell',
2606	help='Fill unit cell with selected atoms')
2607	self.DrawAtomEdit.Append(id=wxID_DRAWDELETE, kind=wx.ITEM_NORMAL,text='Delete atoms',
2608	help='Delete atoms from drawing set')
2609	self.DrawAtomCompute.Append(id=wxID_DRAWDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
2610	help='Compute distance of selected atoms from view point')
2611	self.DrawAtomCompute.Append(id=wxID_DRAWDISAGLTOR, kind=wx.ITEM_NORMAL,text='Dist. Ang. Tors.',
2612	help='Compute distance, angle or torsion for 2-4 selected atoms')
2613	self.DrawAtomCompute.Append(id=wxID_DRAWPLANE, kind=wx.ITEM_NORMAL,text='Best plane',
2614	help='Compute best plane for 4+ selected atoms')
2615	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRBOND, kind=wx.ITEM_NORMAL,text='Add bond restraint',
2616	help='Add bond restraint for selected atoms (2)')
2617	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRANGLE, kind=wx.ITEM_NORMAL,text='Add angle restraint',
2618	help='Add angle restraint for selected atoms (3: one end 1st)')
2619	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRPLANE, kind=wx.ITEM_NORMAL,text='Add plane restraint',
2620	help='Add plane restraint for selected atoms (4+)')
2621	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRCHIRAL, kind=wx.ITEM_NORMAL,text='Add chiral restraint',
2622	help='Add chiral restraint for selected atoms (4: center atom 1st)')
2623	self.DrawAtomRigidBody.Append(id=wxID_DRAWDEFINERB, kind=wx.ITEM_NORMAL,text='Define rigid body',
2624	help='Define rigid body with selected atoms')
2625	self.PostfillDataMenu()
2626
2627	# Phase / MCSA tab
2628	self.MCSAMenu = wx.MenuBar()
2629	self.PrefillDataMenu(self.MCSAMenu,helpType='MC/SA')
2630	self.MCSAMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2631	self.MCSAEdit = wx.Menu(title='')
2632	self.MCSAMenu.Append(menu=self.MCSAEdit, title='MC/SA')
2633	self.MCSAEdit.Append(id=wxID_ADDMCSAATOM, kind=wx.ITEM_NORMAL,text='Add atom',
2634	help='Add single atom to MC/SA model')
2635	self.MCSAEdit.Append(id=wxID_ADDMCSARB, kind=wx.ITEM_NORMAL,text='Add rigid body',
2636	help='Add rigid body to MC/SA model' )
2637	self.MCSAEdit.Append(id=wxID_CLEARMCSARB, kind=wx.ITEM_NORMAL,text='Clear rigid bodies',
2638	help='Clear all atoms & rigid bodies from MC/SA model' )
2639	self.MCSAEdit.Append(id=wxID_MOVEMCSA, kind=wx.ITEM_NORMAL,text='Move MC/SA solution',
2640	help='Move MC/SA solution to atom list' )
2641	self.MCSAEdit.Append(id=wxID_MCSACLEARRESULTS, kind=wx.ITEM_NORMAL,text='Clear results',
2642	help='Clear table of MC/SA results' )
2643	self.PostfillDataMenu()
2644
2645	# Phase / Texture tab
2646	self.TextureMenu = wx.MenuBar()
2647	self.PrefillDataMenu(self.TextureMenu,helpType='Texture')
2648	self.TextureMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2649	self.TextureEdit = wx.Menu(title='')
2650	self.TextureMenu.Append(menu=self.TextureEdit, title='Texture')
2651	self.TextureEdit.Append(id=wxID_REFINETEXTURE, kind=wx.ITEM_NORMAL,text='Refine texture',
2652	help='Refine the texture coefficients from sequential Pawley results')
2653	self.TextureEdit.Append(id=wxID_CLEARTEXTURE, kind=wx.ITEM_NORMAL,text='Clear texture',
2654	help='Clear the texture coefficients' )
2655	self.PostfillDataMenu()
2656
2657	# Phase / Pawley tab
2658	self.PawleyMenu = wx.MenuBar()
2659	self.PrefillDataMenu(self.PawleyMenu,helpType='Pawley')
2660	self.PawleyMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2661	self.PawleyEdit = wx.Menu(title='')
2662	self.PawleyMenu.Append(menu=self.PawleyEdit,title='Operations')
2663	self.PawleyEdit.Append(id=wxID_PAWLEYLOAD, kind=wx.ITEM_NORMAL,text='Pawley create',
2664	help='Initialize Pawley reflection list')
2665	self.PawleyEdit.Append(id=wxID_PAWLEYESTIMATE, kind=wx.ITEM_NORMAL,text='Pawley estimate',
2666	help='Estimate initial Pawley intensities')
2667	self.PawleyEdit.Append(id=wxID_PAWLEYUPDATE, kind=wx.ITEM_NORMAL,text='Pawley update',
2668	help='Update negative Pawley intensities with -0.5*Fobs and turn off refinemnt')
2669	self.PostfillDataMenu()
2670
2671	# Phase / Map peaks tab
2672	self.MapPeaksMenu = wx.MenuBar()
2673	self.PrefillDataMenu(self.MapPeaksMenu,helpType='Map peaks')
2674	self.MapPeaksMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2675	self.MapPeaksEdit = wx.Menu(title='')
2676	self.MapPeaksMenu.Append(menu=self.MapPeaksEdit, title='Map peaks')
2677	self.MapPeaksEdit.Append(id=wxID_PEAKSMOVE, kind=wx.ITEM_NORMAL,text='Move peaks',
2678	help='Move selected peaks to atom list')
2679	self.MapPeaksEdit.Append(id=wxID_PEAKSVIEWPT, kind=wx.ITEM_NORMAL,text='View point',
2680	help='View point is 1st peak selected')
2681	self.MapPeaksEdit.Append(id=wxID_PEAKSDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
2682	help='Compute distance of selected peaks from view point')
2683	self.MapPeaksEdit.Append(id=wxID_SHOWBONDS, kind=wx.ITEM_NORMAL,text='Hide bonds',
2684	help='Hide or show bonds between peak positions')
2685	self.MapPeaksEdit.Append(id=wxID_PEAKSDA, kind=wx.ITEM_NORMAL,text='Calc dist/ang',
2686	help='Calculate distance or angle for selection')
2687	self.MapPeaksEdit.Append(id=wxID_FINDEQVPEAKS, kind=wx.ITEM_NORMAL,text='Equivalent peaks',
2688	help='Find equivalent peaks')
2689	self.MapPeaksEdit.Append(id=wxID_PEAKSUNIQUE, kind=wx.ITEM_NORMAL,text='Unique peaks',
2690	help='Select unique set')
2691	self.MapPeaksEdit.Append(id=wxID_PEAKSDELETE, kind=wx.ITEM_NORMAL,text='Delete peaks',
2692	help='Delete selected peaks')
2693	self.MapPeaksEdit.Append(id=wxID_PEAKSCLEAR, kind=wx.ITEM_NORMAL,text='Clear peaks',
2694	help='Clear the map peak list')
2695	self.PostfillDataMenu()
2696
2697	# Phase / Rigid bodies tab
2698	self.RigidBodiesMenu = wx.MenuBar()
2699	self.PrefillDataMenu(self.RigidBodiesMenu,helpType='Rigid bodies')
2700	self.RigidBodiesMenu.Append(menu=wx.Menu(title=''),title='Select tab')
2701	self.RigidBodiesEdit = wx.Menu(title='')
2702	self.RigidBodiesMenu.Append(menu=self.RigidBodiesEdit, title='Edit')
2703	self.RigidBodiesEdit.Append(id=wxID_ASSIGNATMS2RB, kind=wx.ITEM_NORMAL,text='Assign atoms to rigid body',
2704	help='Select & position rigid body in structure of existing atoms')
2705	self.RigidBodiesEdit.Append(id=wxID_AUTOFINDRESRB, kind=wx.ITEM_NORMAL,text='Auto find residues',
2706	help='Auto find of residue RBs in macromolecule')
2707	self.RigidBodiesEdit.Append(id=wxID_COPYRBPARMS, kind=wx.ITEM_NORMAL,text='Copy rigid body parms',
2708	help='Copy rigid body location & TLS parameters')
2709	self.RigidBodiesEdit.Append(id=wxID_GLOBALTHERM, kind=wx.ITEM_NORMAL,text='Global thermal motion',
2710	help='Global setting of residue thermal motion models')
2711	self.RigidBodiesEdit.Append(id=wxID_GLOBALRESREFINE, kind=wx.ITEM_NORMAL,text='Global residue refine',
2712	help='Global setting of residue RB refinement flags')
2713	self.RigidBodiesEdit.Append(id=wxID_RBREMOVEALL, kind=wx.ITEM_NORMAL,text='Remove all rigid bodies',
2714	help='Remove all rigid body assignment for atoms')
2715	self.PostfillDataMenu()
2716	# end of GSAS-II menu definitions
2717
2718	def _init_ctrls(self, parent,name=None,size=None,pos=None):
2719	wx.Frame.__init__(self,parent=parent,
2720	style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX \| wx.FRAME_FLOAT_ON_PARENT ,
2721	size=size,pos=pos,title='GSAS-II data display')
2722	self._init_menus()
2723	if name:
2724	self.SetLabel(name)
2725	self.Show()
2726
2727	def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
2728	self.G2frame = frame
2729	self._init_ctrls(parent,name,size,pos)
2730	self.data = data
2731	clientSize = wx.ClientDisplayRect()
2732	Size = self.GetSize()
2733	xPos = clientSize[2]-Size[0]
2734	self.SetPosition(wx.Point(xPos,clientSize[1]+250))
2735	self.AtomGrid = []
2736	self.selectedRow = 0
2737
2738	def setSizePosLeft(self,Width):
2739	clientSize = wx.ClientDisplayRect()
2740	Width[1] = min(Width[1],clientSize[2]-300)
2741	Width[0] = max(Width[0],300)
2742	self.SetSize(Width)
2743	# self.SetPosition(wx.Point(clientSize[2]-Width[0],clientSize[1]+250))
2744
2745	def Clear(self):
2746	self.ClearBackground()
2747	self.DestroyChildren()
2748
2749	################################################################################
2750	##### GSNotebook
2751	################################################################################
2752
2753	class GSNoteBook(wx.aui.AuiNotebook):
2754	'''Notebook used in various locations; implemented with wx.aui extension
2755	'''
2756	def __init__(self, parent, name='',size = None):
2757	wx.aui.AuiNotebook.__init__(self, parent, -1,
2758	style=wx.aui.AUI_NB_TOP \|
2759	wx.aui.AUI_NB_SCROLL_BUTTONS)
2760	if size: self.SetSize(size)
2761
2762	def Clear(self):
2763	GSNoteBook.DeleteAllPages(self)
2764
2765	def FindPage(self,name):
2766	numPage = self.GetPageCount()
2767	for page in range(numPage):
2768	if self.GetPageText(page) == name:
2769	return page
2770
2771	def ChangeSelection(self,page):
2772	# in wx.Notebook ChangeSelection is like SetSelection, but it
2773	# does not invoke the event related to pressing the tab button
2774	# I don't see a way to do that in aui.
2775	oldPage = self.GetSelection()
2776	self.SetSelection(page)
2777	return oldPage
2778
2779	# def __getattribute__(self,name):
2780	# '''This method provides a way to print out a message every time
2781	# that a method in a class is called -- to see what all the calls
2782	# might be, or where they might be coming from.
2783	# Cute trick for debugging!
2784	# '''
2785	# attr = object.__getattribute__(self, name)
2786	# if hasattr(attr, '__call__'):
2787	# def newfunc(args, *kwargs):
2788	# print('GSauiNoteBook calling %s' %attr.__name__)
2789	# result = attr(args, *kwargs)
2790	# return result
2791	# return newfunc
2792	# else:
2793	# return attr
2794
2795	################################################################################
2796	##### GSGrid
2797	################################################################################
2798
2799	class GSGrid(wg.Grid):
2800	'''Basic wx.Grid implementation
2801	'''
2802	def __init__(self, parent, name=''):
2803	wg.Grid.__init__(self,parent,-1,name=name)
2804	#self.SetSize(parent.GetClientSize())
2805	# above removed to speed drawing of initial grid
2806	# does not appear to be needed
2807
2808	def Clear(self):
2809	wg.Grid.ClearGrid(self)
2810
2811	def SetCellStyle(self,r,c,color="white",readonly=True):
2812	self.SetCellBackgroundColour(r,c,color)
2813	self.SetReadOnly(r,c,isReadOnly=readonly)
2814
2815	def GetSelection(self):
2816	#this is to satisfy structure drawing stuff in G2plt when focus changes
2817	return None
2818
2819	################################################################################
2820	##### Table
2821	################################################################################
2822
2823	class Table(wg.PyGridTableBase):
2824	'''Basic data table for use with GSgrid
2825	'''
2826	def __init__(self, data=[], rowLabels=None, colLabels=None, types = None):
2827	wg.PyGridTableBase.__init__(self)
2828	self.colLabels = colLabels
2829	self.rowLabels = rowLabels
2830	self.dataTypes = types
2831	self.data = data
2832
2833	def AppendRows(self, numRows=1):
2834	self.data.append([])
2835	return True
2836
2837	def CanGetValueAs(self, row, col, typeName):
2838	if self.dataTypes:
2839	colType = self.dataTypes[col].split(':')[0]
2840	if typeName == colType:
2841	return True
2842	else:
2843	return False
2844	else:
2845	return False
2846
2847	def CanSetValueAs(self, row, col, typeName):
2848	return self.CanGetValueAs(row, col, typeName)
2849
2850	def DeleteRow(self,pos):
2851	data = self.GetData()
2852	self.SetData([])
2853	new = []
2854	for irow,row in enumerate(data):
2855	if irow <> pos:
2856	new.append(row)
2857	self.SetData(new)
2858
2859	def GetColLabelValue(self, col):
2860	if self.colLabels:
2861	return self.colLabels[col]
2862
2863	def GetData(self):
2864	data = []
2865	for row in range(self.GetNumberRows()):
2866	data.append(self.GetRowValues(row))
2867	return data
2868
2869	def GetNumberCols(self):
2870	try:
2871	return len(self.colLabels)
2872	except TypeError:
2873	return None
2874
2875	def GetNumberRows(self):
2876	return len(self.data)
2877
2878	def GetRowLabelValue(self, row):
2879	if self.rowLabels:
2880	return self.rowLabels[row]
2881
2882	def GetColValues(self, col):
2883	data = []
2884	for row in range(self.GetNumberRows()):
2885	data.append(self.GetValue(row, col))
2886	return data
2887
2888	def GetRowValues(self, row):
2889	data = []
2890	for col in range(self.GetNumberCols()):
2891	data.append(self.GetValue(row, col))
2892	return data
2893
2894	def GetTypeName(self, row, col):
2895	try:
2896	return self.dataTypes[col]
2897	except TypeError:
2898	return None
2899
2900	def GetValue(self, row, col):
2901	try:
2902	return self.data[row][col]
2903	except IndexError:
2904	return None
2905
2906	def InsertRows(self, pos, rows):
2907	for row in range(rows):
2908	self.data.insert(pos,[])
2909	pos += 1
2910
2911	def IsEmptyCell(self,row,col):
2912	try:
2913	return not self.data[row][col]
2914	except IndexError:
2915	return True
2916
2917	def OnKeyPress(self, event):
2918	dellist = self.GetSelectedRows()
2919	if event.GetKeyCode() == wx.WXK_DELETE and dellist:
2920	grid = self.GetView()
2921	for i in dellist: grid.DeleteRow(i)
2922
2923	def SetColLabelValue(self, col, label):
2924	numcols = self.GetNumberCols()
2925	if col > numcols-1:
2926	self.colLabels.append(label)
2927	else:
2928	self.colLabels[col]=label
2929
2930	def SetData(self,data):
2931	for row in range(len(data)):
2932	self.SetRowValues(row,data[row])
2933
2934	def SetRowLabelValue(self, row, label):
2935	self.rowLabels[row]=label
2936
2937	def SetRowValues(self,row,data):
2938	self.data[row] = data
2939
2940	def SetValue(self, row, col, value):
2941	def innerSetValue(row, col, value):
2942	try:
2943	self.data[row][col] = value
2944	except TypeError:
2945	return
2946	except IndexError:
2947	print row,col,value
2948	# add a new row
2949	if row > self.GetNumberRows():
2950	self.data.append([''] * self.GetNumberCols())
2951	elif col > self.GetNumberCols():
2952	for row in range(self.GetNumberRows):
2953	self.data[row].append('')
2954	print self.data
2955	self.data[row][col] = value
2956	innerSetValue(row, col, value)
2957
2958	################################################################################
2959	#### Help
2960	################################################################################
2961
2962	def ShowHelp(helpType,frame):
2963	'''Called to bring up a web page for documentation.'''
2964	global htmlFirstUse
2965	# look up a definition for help info from dict
2966	helplink = helpLocDict.get(helpType)
2967	if helplink is None:
2968	# no defined link to use, create a default based on key
2969	helplink = 'gsasII.html#'+helpType.replace(' ','_')
2970	helplink = os.path.join(path2GSAS2,'help',helplink)
2971	if helpMode == 'internal':
2972	try:
2973	htmlPanel.LoadFile(helplink)
2974	htmlFrame.Raise()
2975	except:
2976	htmlFrame = wx.Frame(frame, -1, size=(610, 510))
2977	htmlFrame.Show(True)
2978	htmlFrame.SetTitle("HTML Window") # N.B. reset later in LoadFile
2979	htmlPanel = MyHtmlPanel(htmlFrame,-1)
2980	htmlPanel.LoadFile(helplink)
2981	else:
2982	pfx = "file://"
2983	if sys.platform.lower().startswith('win'):
2984	pfx = ''
2985	if htmlFirstUse:
2986	webbrowser.open_new(pfx+helplink)
2987	htmlFirstUse = False
2988	else:
2989	webbrowser.open(pfx+helplink, new=0, autoraise=True)
2990
2991	################################################################################
2992	##### Notebook
2993	################################################################################
2994
2995	def UpdateNotebook(G2frame,data):
2996	'''Called when the data tree notebook entry is selected. Allows for
2997	editing of the text in that tree entry
2998	'''
2999	def OnNoteBook(event):
3000	data = G2frame.dataDisplay.GetValue()
3001	G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Notebook'),data)
3002
3003	if G2frame.dataDisplay:
3004	G2frame.dataDisplay.Destroy()
3005	G2frame.dataFrame.SetLabel('Notebook')
3006	G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
3007	style=wx.TE_MULTILINE\|wx.TE_PROCESS_ENTER \| wx.TE_DONTWRAP)
3008	G2frame.dataDisplay.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
3009	G2frame.dataDisplay.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
3010	for line in data:
3011	G2frame.dataDisplay.AppendText(line+"\n")
3012	G2frame.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
3013	G2frame.dataFrame.setSizePosLeft([400,250])
3014
3015	################################################################################
3016	##### Controls
3017	################################################################################
3018
3019	def UpdateControls(G2frame,data):
3020	'''Edit overall GSAS-II controls in main Controls data tree entry
3021	'''
3022	#patch
3023	if 'deriv type' not in data:
3024	data = {}
3025	data['deriv type'] = 'analytic Hessian'
3026	data['min dM/M'] = 0.0001
3027	data['shift factor'] = 1.
3028	data['max cyc'] = 3
3029	data['F**2'] = True
3030	data['minF/sig'] = 0
3031	if 'shift factor' not in data:
3032	data['shift factor'] = 1.
3033	if 'max cyc' not in data:
3034	data['max cyc'] = 3
3035	if 'F**2' not in data:
3036	data['F**2'] = True
3037	data['minF/sig'] = 0
3038	if 'Author' not in data:
3039	data['Author'] = 'no name'
3040	if 'FreePrm1' not in data:
3041	data['FreePrm1'] = 'Sample humidity (%)'
3042	if 'FreePrm2' not in data:
3043	data['FreePrm2'] = 'Sample voltage (V)'
3044	if 'FreePrm3' not in data:
3045	data['FreePrm3'] = 'Applied load (MN)'
3046	#end patch
3047
3048	def SeqSizer():
3049
3050	def OnSelectData(event):
3051	choices = ['All',]+GetPatternTreeDataNames(G2frame,['PWDR',])
3052	sel = []
3053	if 'Seq Data' in data:
3054	for item in data['Seq Data']:
3055	sel.append(choices.index(item))
3056	names = []
3057	dlg = wx.MultiChoiceDialog(G2frame,'Select data:','Sequential refinement',choices)
3058	dlg.SetSelections(sel)
3059	if dlg.ShowModal() == wx.ID_OK:
3060	sel = dlg.GetSelections()
3061	for i in sel: names.append(choices[i])
3062	if 'All' in names:
3063	names = choices[1:]
3064	data['Seq Data'] = names
3065	dlg.Destroy()
3066	reverseSel.Enable(True)
3067
3068	def OnReverse(event):
3069	data['Reverse Seq'] = reverseSel.GetValue()
3070
3071	seqSizer = wx.BoxSizer(wx.HORIZONTAL)
3072	seqSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sequential Refinement Powder Data: '),0,wx.ALIGN_CENTER_VERTICAL)
3073	selSeqData = wx.Button(G2frame.dataDisplay,-1,label=' Select data')
3074	selSeqData.Bind(wx.EVT_BUTTON,OnSelectData)
3075	seqSizer.Add(selSeqData,0,wx.ALIGN_CENTER_VERTICAL)
3076	seqSizer.Add((5,0),0)
3077	reverseSel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Reverse order?')
3078	reverseSel.Bind(wx.EVT_CHECKBOX,OnReverse)
3079	if 'Seq Data' not in data:
3080	reverseSel.Enable(False)
3081	if 'Reverse Seq' in data:
3082	reverseSel.SetValue(data['Reverse Seq'])
3083	seqSizer.Add(reverseSel,0,wx.ALIGN_CENTER_VERTICAL)
3084	return seqSizer
3085
3086	def LSSizer():
3087
3088	def OnDerivType(event):
3089	data['deriv type'] = derivSel.GetValue()
3090	derivSel.SetValue(data['deriv type'])
3091	wx.CallAfter(UpdateControls,G2frame,data)
3092
3093	def OnConvergence(event):
3094	try:
3095	value = max(1.e-9,min(1.0,float(Cnvrg.GetValue())))
3096	except ValueError:
3097	value = 0.0001
3098	data['min dM/M'] = value
3099	Cnvrg.SetValue('%.2g'%(value))
3100
3101	def OnMaxCycles(event):
3102	data['max cyc'] = int(maxCyc.GetValue())
3103	maxCyc.SetValue(str(data['max cyc']))
3104
3105	def OnFactor(event):
3106	try:
3107	value = min(max(float(Factr.GetValue()),0.00001),100.)
3108	except ValueError:
3109	value = 1.0
3110	data['shift factor'] = value
3111	Factr.SetValue('%.5f'%(value))
3112
3113	def OnFsqRef(event):
3114	data['F**2'] = fsqRef.GetValue()
3115
3116	def OnMinSig(event):
3117	try:
3118	value = min(max(float(minSig.GetValue()),0.),5.)
3119	except ValueError:
3120	value = 1.0
3121	data['minF/sig'] = value
3122	minSig.SetValue('%.2f'%(value))
3123
3124	LSSizer = wx.FlexGridSizer(cols=4,vgap=5,hgap=5)
3125	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement derivatives: '),0,wx.ALIGN_CENTER_VERTICAL)
3126	Choice=['analytic Jacobian','numeric','analytic Hessian']
3127	derivSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['deriv type'],choices=Choice,
3128	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3129	derivSel.SetValue(data['deriv type'])
3130	derivSel.Bind(wx.EVT_COMBOBOX, OnDerivType)
3131
3132	LSSizer.Add(derivSel,0,wx.ALIGN_CENTER_VERTICAL)
3133	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min delta-M/M: '),0,wx.ALIGN_CENTER_VERTICAL)
3134	Cnvrg = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2g'%(data['min dM/M']),style=wx.TE_PROCESS_ENTER)
3135	Cnvrg.Bind(wx.EVT_TEXT_ENTER,OnConvergence)
3136	Cnvrg.Bind(wx.EVT_KILL_FOCUS,OnConvergence)
3137	LSSizer.Add(Cnvrg,0,wx.ALIGN_CENTER_VERTICAL)
3138	if 'Hessian' in data['deriv type']:
3139	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max cycles: '),0,wx.ALIGN_CENTER_VERTICAL)
3140	Choice = ['0','1','2','3','5','10','15','20']
3141	maxCyc = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['max cyc']),choices=Choice,
3142	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3143	maxCyc.SetValue(str(data['max cyc']))
3144	maxCyc.Bind(wx.EVT_COMBOBOX, OnMaxCycles)
3145	LSSizer.Add(maxCyc,0,wx.ALIGN_CENTER_VERTICAL)
3146	else:
3147	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial shift factor: '),0,wx.ALIGN_CENTER_VERTICAL)
3148	Factr = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.5f'%(data['shift factor']),style=wx.TE_PROCESS_ENTER)
3149	Factr.Bind(wx.EVT_TEXT_ENTER,OnFactor)
3150	Factr.Bind(wx.EVT_KILL_FOCUS,OnFactor)
3151	LSSizer.Add(Factr,0,wx.ALIGN_CENTER_VERTICAL)
3152	if G2frame.Sngl:
3153	LSSizer.Add((1,0),)
3154	LSSizer.Add((1,0),)
3155	fsqRef = wx.CheckBox(G2frame.dataDisplay,-1,label='Refine HKLF as F^2? ')
3156	fsqRef.SetValue(data['F**2'])
3157	fsqRef.Bind(wx.EVT_CHECKBOX,OnFsqRef)
3158	LSSizer.Add(fsqRef,0,wx.ALIGN_CENTER_VERTICAL)
3159	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label='Min obs/sig (0-5): '),0,wx.ALIGN_CENTER_VERTICAL)
3160	minSig = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2f'%(data['minF/sig']),style=wx.TE_PROCESS_ENTER)
3161	minSig.Bind(wx.EVT_TEXT_ENTER,OnMinSig)
3162	minSig.Bind(wx.EVT_KILL_FOCUS,OnMinSig)
3163	LSSizer.Add(minSig,0,wx.ALIGN_CENTER_VERTICAL)
3164	return LSSizer
3165
3166	def AuthSizer():
3167
3168	def OnAuthor(event):
3169	data['Author'] = auth.GetValue()
3170
3171	Author = data['Author']
3172	authSizer = wx.BoxSizer(wx.HORIZONTAL)
3173	authSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' CIF Author (last, first):'),0,wx.ALIGN_CENTER_VERTICAL)
3174	auth = wx.TextCtrl(G2frame.dataDisplay,-1,value=Author,style=wx.TE_PROCESS_ENTER)
3175	auth.Bind(wx.EVT_TEXT_ENTER,OnAuthor)
3176	auth.Bind(wx.EVT_KILL_FOCUS,OnAuthor)
3177	authSizer.Add(auth,0,wx.ALIGN_CENTER_VERTICAL)
3178	return authSizer
3179
3180
3181	if G2frame.dataDisplay:
3182	G2frame.dataDisplay.Destroy()
3183	if not G2frame.dataFrame.GetStatusBar():
3184	Status = G2frame.dataFrame.CreateStatusBar()
3185	Status.SetStatusText('')
3186	G2frame.dataFrame.SetLabel('Controls')
3187	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
3188	SetDataMenuBar(G2frame,G2frame.dataFrame.ControlsMenu)
3189	mainSizer = wx.BoxSizer(wx.VERTICAL)
3190	mainSizer.Add((5,5),0)
3191	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement Controls:'),0,wx.ALIGN_CENTER_VERTICAL)
3192	mainSizer.Add(LSSizer())
3193	mainSizer.Add((5,5),0)
3194	mainSizer.Add(SeqSizer())
3195	mainSizer.Add((5,5),0)
3196	mainSizer.Add(AuthSizer())
3197	mainSizer.Add((5,5),0)
3198
3199	mainSizer.Layout()
3200	G2frame.dataDisplay.SetSizer(mainSizer)
3201	G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
3202	G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
3203
3204	################################################################################
3205	##### Comments
3206	################################################################################
3207
3208	def UpdateComments(G2frame,data):
3209
3210	if G2frame.dataDisplay:
3211	G2frame.dataDisplay.Destroy()
3212	G2frame.dataFrame.SetLabel('Comments')
3213	G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
3214	style=wx.TE_MULTILINE\|wx.TE_READONLY\|wx.TE_DONTWRAP)
3215	for line in data:
3216	G2frame.dataDisplay.AppendText(line+'\n')
3217	G2frame.dataFrame.setSizePosLeft([400,250])
3218
3219	################################################################################
3220	##### Sequential Results
3221	################################################################################
3222
3223	def UpdateSeqResults(G2frame,data):
3224	"""
3225	Called when the Sequential Results data tree entry is selected
3226	to show results from a sequential refinement.
3227
3228	:param wx.Frame G2frame: main GSAS-II data tree windows
3229
3230	:param dict data: a dictionary containing the following items:
3231
3232	* 'histNames' - list of histogram names in order as processed by Sequential Refinement
3233	* 'varyList' - list of variables - identical over all refinements in sequence
3234	* 'histName' - dictionaries for all data sets processed, which contains:
3235
3236	* 'variables'- result[0] from leastsq call
3237	* 'varyList' - list of variables; same as above
3238	* 'sig' - esds for variables
3239	* 'covMatrix' - covariance matrix from individual refinement
3240	* 'title' - histogram name; same as dict item name
3241	* 'newAtomDict' - new atom parameters after shifts applied
3242	* 'newCellDict' - new cell parameters after shifts to A0-A5 applied'
3243	"""
3244	if not data:
3245	print 'No sequential refinement results'
3246	return
3247	histNames = data['histNames']
3248
3249	def GetSampleParms():
3250	sampleParmDict = {'Temperature':300.,'Pressure':1.,
3251	'FreePrm1':0.,'FreePrm2':0.,'FreePrm3':0.,}
3252	sampleParm = {}
3253	for name in histNames:
3254	Id = GetPatternTreeItemId(G2frame,G2frame.root,name)
3255	sampleData = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
3256	for item in sampleParmDict:
3257	sampleParmDict[item].append(sampleData[item])
3258	for item in sampleParmDict:
3259	frstValue = sampleParmDict[item][0]
3260	if np.any(np.array(sampleParmDict[item])-frstValue):
3261	sampleParm[item] = sampleParmDict[item]
3262	return sampleParm
3263
3264	def GetRwps():
3265	Rwps = []
3266	for name in histNames:
3267	Rwps.append(data[name]['Rvals']['Rwp'])
3268	return Rwps
3269
3270	def GetSigData(parm):
3271	sigData = []
3272	for name in histNames:
3273	sigList = data[name]['sig']
3274	if colLabels[parm] in atomList:
3275	sigData.append(sigList[colLabels.index(atomList[colLabels[parm]])-1])
3276	elif colLabels[parm] in cellList:
3277	sigData.append(sigList[colLabels.index(cellList[colLabels[parm]])-1])
3278	else:
3279	sigData.append(sigList[parm-1])
3280	return sigData
3281
3282	def Select(event):
3283	cols = G2frame.dataDisplay.GetSelectedCols()
3284	rows = G2frame.dataDisplay.GetSelectedRows()
3285	if cols:
3286	plotData = []
3287	plotSig = []
3288	plotNames = []
3289	for col in cols:
3290	plotData.append(G2frame.SeqTable.GetColValues(col))
3291	if col: #not Rwp
3292	plotSig.append(GetSigData(col))
3293	else:
3294	plotSig.append(0.0)
3295	plotNames.append(G2frame.SeqTable.GetColLabelValue(col))
3296	plotData = np.array(plotData)
3297	G2plt.PlotSeq(G2frame,plotData,plotSig,plotNames,sampleParms)
3298	elif rows:
3299	name = histNames[rows[0]] #only does 1st one selected
3300	G2plt.PlotCovariance(G2frame,data[name])
3301
3302	def OnSaveSelSeq(event):
3303	cols = G2frame.dataDisplay.GetSelectedCols()
3304	if cols:
3305	numRows = G2frame.SeqTable.GetNumberRows()
3306	dataNames = []
3307	saveNames = [G2frame.SeqTable.GetRowLabelValue(r) for r in range(numRows)]
3308	saveData = []
3309	for col in cols:
3310	dataNames.append(G2frame.SeqTable.GetColLabelValue(col))
3311	if col: #not Rwp
3312	saveData.append(zip(G2frame.SeqTable.GetColValues(col),GetSigData(col)))
3313	else:
3314	saveData.append(zip(G2frame.SeqTable.GetColValues(col),0.0))
3315	lenName = len(saveNames[0])
3316	saveData = np.swapaxes(np.array(saveData),0,1)
3317	dlg = wx.FileDialog(G2frame, 'Choose text output file for your selection', '.', '',
3318	'Text output file (.txt)\|.txt',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT\|wx.CHANGE_DIR)
3319	try:
3320	if dlg.ShowModal() == wx.ID_OK:
3321	SeqTextFile = dlg.GetPath()
3322	SeqTextFile = G2IO.FileDlgFixExt(dlg,SeqTextFile)
3323	SeqFile = open(SeqTextFile,'w')
3324	line = ' %s '%('name'.center(lenName))
3325	for item in dataNames:
3326	line += ' %12s %12s '%(item.center(12),'esd'.center(12))
3327	line += '\n'
3328	SeqFile.write(line)
3329	for i,item in enumerate(saveData):
3330	line = " '%s' "%(saveNames[i])
3331	for val,esd in item:
3332	line += ' %12.6f %12.6f '%(val,esd)
3333	line += '\n'
3334	SeqFile.write(line)
3335	SeqFile.close()
3336	finally:
3337	dlg.Destroy()
3338
3339
3340	if G2frame.dataDisplay:
3341	G2frame.dataDisplay.Destroy()
3342	atomList = {}
3343	newAtomDict = data[histNames[0]]['newAtomDict']
3344	for item in newAtomDict:
3345	if item in data['varyList']:
3346	atomList[newAtomDict[item][0]] = item
3347	cellList = {}
3348	newCellDict = data[histNames[0]]['newCellDict']
3349	for item in newCellDict:
3350	if item in data['varyList']:
3351	cellList[newCellDict[item][0]] = item
3352	sampleParms = GetSampleParms()
3353	Rwps = GetRwps()
3354	SetDataMenuBar(G2frame,G2frame.dataFrame.SequentialMenu)
3355	G2frame.dataFrame.SetLabel('Sequential refinement results')
3356	G2frame.dataFrame.CreateStatusBar()
3357	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeq, id=wxID_SAVESEQSEL)
3358	colLabels = ['Rwp',]+data['varyList']+atomList.keys()+cellList.keys()
3359	Types = (len(data['varyList']+atomList.keys()+cellList.keys())+1)*[wg.GRID_VALUE_FLOAT,]
3360	seqList = [[Rwps[i],]+list(data[name]['variables']) for i,name in enumerate(histNames)]
3361	for i,item in enumerate(seqList):
3362	newAtomDict = data[histNames[i]]['newAtomDict']
3363	newCellDict = data[histNames[i]]['newCellDict']
3364	item += [newAtomDict[atomList[parm]][1] for parm in atomList.keys()]
3365	item += [newCellDict[cellList[parm]][1] for parm in cellList.keys()]
3366	G2frame.SeqTable = Table(seqList,colLabels=colLabels,rowLabels=histNames,types=Types)
3367	G2frame.dataDisplay = GSGrid(parent=G2frame.dataFrame)
3368	G2frame.dataDisplay.SetTable(G2frame.SeqTable, True)
3369	G2frame.dataDisplay.EnableEditing(False)
3370	G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, Select)
3371	G2frame.dataDisplay.SetRowLabelSize(8*len(histNames[0])) #pretty arbitrary 8
3372	G2frame.dataDisplay.SetMargins(0,0)
3373	G2frame.dataDisplay.AutoSizeColumns(True)
3374	G2frame.dataFrame.setSizePosLeft([700,350])
3375
3376	################################################################################
3377	##### Main PWDR panel
3378	################################################################################
3379
3380	def UpdatePWHKPlot(G2frame,kind,item):
3381	'''Called when the histogram main tree entry is called. Displays the
3382	histogram weight factor, refinement statistics for the histogram
3383	and the range of data for a simulation.
3384
3385	Also invokes a plot of the histogram.
3386	'''
3387	def onEditSimRange(event):
3388	'Edit simulation range'
3389	inp = [
3390	min(data[1][0]),
3391	max(data[1][0]),
3392	None
3393	]
3394	inp[2] = (inp[1] - inp[0])/(len(data[1][0])-1.)
3395	names = ('start angle', 'end angle', 'step size')
3396	dictlst = [inp] * len(inp)
3397	elemlst = range(len(inp))
3398	dlg = ScrolledMultiEditor(
3399	G2frame,[inp] * len(inp), range(len(inp)), names,
3400	header='Edit simulation range',
3401	minvals=(0.001,0.001,0.0001),
3402	maxvals=(180.,180.,.1),
3403	)
3404	dlg.CenterOnParent()
3405	val = dlg.ShowModal()
3406	dlg.Destroy()
3407	if val != wx.ID_OK: return
3408	if inp[0] > inp[1]:
3409	end,start,step = inp
3410	else:
3411	start,end,step = inp
3412	step = abs(step)
3413	N = int((end-start)/step)+1
3414	newdata = np.linspace(start,end,N,True)
3415	if len(newdata) < 2: return # too small a range - reject
3416	data[1] = [newdata,np.zeros_like(newdata),np.ones_like(newdata),
3417	np.zeros_like(newdata),np.zeros_like(newdata),np.zeros_like(newdata)]
3418	Tmin = newdata[0]
3419	Tmax = newdata[-1]
3420	G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,item,'Limits'),
3421	[(Tmin,Tmax),[Tmin,Tmax]])
3422	UpdatePWHKPlot(G2frame,kind,item) # redisplay data screen
3423
3424	def OnErrorAnalysis(event):
3425	G2plt.PlotDeltSig(G2frame,kind)
3426
3427	def OnWtFactor(event):
3428	try:
3429	val = float(wtval.GetValue())
3430	except ValueError:
3431	val = data[0]['wtFactor']
3432	data[0]['wtFactor'] = val
3433	wtval.SetValue('%.3f'%(val))
3434
3435	data = G2frame.PatternTree.GetItemPyData(item)
3436	#patches
3437	if 'wtFactor' not in data[0]:
3438	data[0] = {'wtFactor':1.0}
3439	if isinstance(data[1],list) and kind == 'HKLF':
3440	RefData = {'RefList':[],'FF':[]}
3441	for ref in data[1]:
3442	RefData['RefList'].append(ref[:11]+[ref[13],])
3443	RefData['FF'].append(ref[14])
3444	data[1] = RefData
3445	G2frame.PatternTree.SetItemPyData(item,data)
3446	#end patches
3447	if G2frame.dataDisplay:
3448	G2frame.dataDisplay.Destroy()
3449	SetDataMenuBar(G2frame,G2frame.dataFrame.ErrorMenu)
3450	G2frame.dataFrame.Bind(wx.EVT_MENU,OnErrorAnalysis, id=wxID_PWDANALYSIS)
3451	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
3452
3453	mainSizer = wx.BoxSizer(wx.VERTICAL)
3454	mainSizer.Add((5,5),)
3455	wtSizer = wx.BoxSizer(wx.HORIZONTAL)
3456	wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Weight factor: '),0,wx.ALIGN_CENTER_VERTICAL)
3457	wtval = wx.TextCtrl(G2frame.dataDisplay,-1,'%.3f'%(data[0]['wtFactor']),style=wx.TE_PROCESS_ENTER)
3458	wtval.Bind(wx.EVT_TEXT_ENTER,OnWtFactor)
3459	wtval.Bind(wx.EVT_KILL_FOCUS,OnWtFactor)
3460	wtSizer.Add(wtval,0,wx.ALIGN_CENTER_VERTICAL)
3461	mainSizer.Add(wtSizer)
3462	if data[0].get('Dummy'):
3463	simSizer = wx.BoxSizer(wx.HORIZONTAL)
3464	Tmin = min(data[1][0])
3465	Tmax = max(data[1][0])
3466	num = len(data[1][0])
3467	step = (Tmax - Tmin)/(num-1)
3468	t = u'2\u03b8' # 2theta
3469	lbl = u'Simulation range: {:.2f} to {:.2f} {:s}\nwith {:.4f} steps ({:d} points)'
3470	lbl += u'\n(Edit range resets observed intensities).'
3471	lbl = lbl.format(Tmin,Tmax,t,step,num)
3472	simSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,lbl),
3473	0,wx.ALIGN_CENTER_VERTICAL)
3474	but = wx.Button(G2frame.dataDisplay,wx.ID_ANY,"Edit range")
3475	but.Bind(wx.EVT_BUTTON,onEditSimRange)
3476	simSizer.Add(but,0,wx.ALIGN_CENTER_VERTICAL)
3477	mainSizer.Add(simSizer)
3478	if 'Nobs' in data[0]:
3479	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3480	' Data residual wR: %.3f%% on %d observations'%(data[0]['wR'],data[0]['Nobs'])))
3481	for value in data[0]:
3482	if 'Nref' in value:
3483	mainSizer.Add((5,5),)
3484	pfx = value.split('Nref')[0]
3485	name = data[0][pfx.split(':')[0]+'::Name']
3486	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For phase '+name+':'))
3487	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
3488	u' Unweighted phase residuals RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections '% \
3489	(data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])))
3490	mainSizer.Add((5,5),)
3491	mainSizer.Layout()
3492	G2frame.dataDisplay.SetSizer(mainSizer)
3493	Size = mainSizer.Fit(G2frame.dataFrame)
3494	Size[1] += 10
3495	G2frame.dataFrame.setSizePosLeft(Size)
3496	G2frame.PatternTree.SetItemPyData(item,data)
3497	if kind == 'PWDR':
3498	G2plt.PlotPatterns(G2frame,plotType=kind,newPlot=True)
3499	elif kind == 'SASD':
3500	G2plt.PlotPatterns(G2frame,plotType=kind,newPlot=True)
3501	elif kind == 'HKLF':
3502	G2plt.PlotSngl(G2frame,newPlot=True)
3503
3504	################################################################################
3505	##### HKLF controls
3506	################################################################################
3507
3508	def UpdateHKLControls(G2frame,data):
3509	'''Needs a doc string
3510	'''
3511
3512	def OnScaleSlider(event):
3513	scale = int(scaleSel.GetValue())/1000.
3514	scaleSel.SetValue(int(scale*1000.))
3515	data['Scale'] = scale*1.
3516	G2plt.PlotSngl(G2frame)
3517
3518	def OnLayerSlider(event):
3519	layer = layerSel.GetValue()
3520	data['Layer'] = layer
3521	G2plt.PlotSngl(G2frame)
3522
3523	def OnSelZone(event):
3524	data['Zone'] = zoneSel.GetValue()
3525	izone = zones.index(data['Zone'])
3526	layerSel.SetRange(maxValue=HKLmax[izone],minValue=HKLmin[izone])
3527	G2plt.PlotSngl(G2frame,newPlot=True)
3528
3529	def OnSelType(event):
3530	data['Type'] = typeSel.GetValue()
3531	G2plt.PlotSngl(G2frame)
3532
3533	def SetStatusLine():
3534	Status.SetStatusText("")
3535
3536	if G2frame.dataDisplay:
3537	G2frame.dataDisplay.Destroy()
3538	if not G2frame.dataFrame.GetStatusBar():
3539	Status = G2frame.dataFrame.CreateStatusBar()
3540	SetStatusLine()
3541	zones = ['100','010','001']
3542	HKLmax = data['HKLmax']
3543	HKLmin = data['HKLmin']
3544	typeChoices = ['Fosq','Fo','\|DFsq\|/sig','\|DFsq\|>sig','\|DFsq\|>3sig']
3545	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
3546	SetDataMenuBar(G2frame)
3547	G2frame.dataFrame.SetTitle('HKL Plot Controls')
3548	mainSizer = wx.BoxSizer(wx.VERTICAL)
3549	mainSizer.Add((5,10),0)
3550
3551	scaleSizer = wx.BoxSizer(wx.HORIZONTAL)
3552	scaleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Scale'),0,
3553	wx.ALIGN_CENTER_VERTICAL\|wx.EXPAND)
3554	scaleSel = wx.Slider(parent=G2frame.dataDisplay,maxValue=1000,minValue=1,
3555	style=wx.SL_HORIZONTAL,value=int(data['Scale']*10))
3556	scaleSizer.Add(scaleSel,1,wx.EXPAND\|wx.RIGHT\|wx.ALIGN_CENTER_VERTICAL)
3557	scaleSel.SetLineSize(10)
3558	scaleSel.SetPageSize(10)
3559	scaleSel.Bind(wx.EVT_SLIDER, OnScaleSlider)
3560	mainSizer.Add(scaleSizer,0,wx.EXPAND\|wx.RIGHT)
3561	mainSizer.Add((0,10),0)
3562
3563	zoneSizer = wx.BoxSizer(wx.HORIZONTAL)
3564	zoneSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Zone '),0,
3565	wx.ALIGN_CENTER_VERTICAL)
3566	zoneSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['Zone'],choices=['100','010','001'],
3567	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3568	zoneSel.Bind(wx.EVT_COMBOBOX, OnSelZone)
3569	zoneSizer.Add(zoneSel,0,wx.ALIGN_CENTER_VERTICAL)
3570	zoneSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Plot type '),0,
3571	wx.ALIGN_CENTER_VERTICAL)
3572	typeSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['Type'],choices=typeChoices,
3573	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3574	typeSel.Bind(wx.EVT_COMBOBOX, OnSelType)
3575	zoneSizer.Add(typeSel,0,wx.ALIGN_CENTER_VERTICAL)
3576	zoneSizer.Add((10,0),0)
3577	mainSizer.Add(zoneSizer,0,wx.EXPAND\|wx.RIGHT)
3578	mainSizer.Add((0,10),0)
3579
3580	izone = zones.index(data['Zone'])
3581	layerSizer = wx.BoxSizer(wx.HORIZONTAL)
3582	layerSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Layer'),0,
3583	wx.ALIGN_CENTER_VERTICAL\|wx.EXPAND)
3584	layerSel = wx.Slider(parent=G2frame.dataDisplay,maxValue=HKLmax[izone],minValue=HKLmin[izone],
3585	style=wx.SL_HORIZONTAL\|wx.SL_AUTOTICKS\|wx.SL_LABELS,value=0)
3586	layerSel.SetLineSize(1)
3587	layerSel.SetPageSize(1)
3588	layerSel.Bind(wx.EVT_SLIDER, OnLayerSlider)
3589	layerSizer.Add(layerSel,1,wx.EXPAND\|wx.RIGHT\|wx.ALIGN_CENTER_VERTICAL)
3590	layerSizer.Add((10,0),0)
3591	mainSizer.Add(layerSizer,1,wx.EXPAND\|wx.RIGHT)
3592
3593
3594	mainSizer.Layout()
3595	G2frame.dataDisplay.SetSizer(mainSizer)
3596	G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
3597	G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
3598
3599	################################################################################
3600	##### Pattern tree routines
3601	################################################################################
3602
3603	def GetPatternTreeDataNames(G2frame,dataTypes):
3604	'''Needs a doc string
3605	'''
3606	names = []
3607	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
3608	while item:
3609	name = G2frame.PatternTree.GetItemText(item)
3610	if name[:4] in dataTypes:
3611	names.append(name)
3612	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
3613	return names
3614
3615	def GetPatternTreeItemId(G2frame, parentId, itemText):
3616	'''Needs a doc string
3617	'''
3618	item, cookie = G2frame.PatternTree.GetFirstChild(parentId)
3619	while item:
3620	if G2frame.PatternTree.GetItemText(item) == itemText:
3621	return item
3622	item, cookie = G2frame.PatternTree.GetNextChild(parentId, cookie)
3623	return 0
3624
3625	def MovePatternTreeToGrid(G2frame,item):
3626	'''Needs a doc string
3627	'''
3628
3629	# print G2frame.PatternTree.GetItemText(item)
3630
3631	oldPage = None # will be set later if already on a Phase item
3632	if G2frame.dataFrame:
3633	SetDataMenuBar(G2frame)
3634	if G2frame.dataFrame.GetLabel() == 'Comments':
3635	try:
3636	data = [G2frame.dataDisplay.GetValue()]
3637	G2frame.dataDisplay.Clear()
3638	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Comments')
3639	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
3640	except: #clumsy but avoids dead window problem when opening another project
3641	pass
3642	elif G2frame.dataFrame.GetLabel() == 'Notebook':
3643	try:
3644	data = [G2frame.dataDisplay.GetValue()]
3645	G2frame.dataDisplay.Clear()
3646	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Notebook')
3647	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
3648	except: #clumsy but avoids dead window problem when opening another project
3649	pass
3650	elif 'Phase Data for' in G2frame.dataFrame.GetLabel():
3651	if G2frame.dataDisplay:
3652	oldPage = G2frame.dataDisplay.GetSelection()
3653	G2frame.dataFrame.Clear()
3654	G2frame.dataFrame.SetLabel('')
3655	else:
3656	#create the frame for the data item window
3657	G2frame.dataFrame = DataFrame(parent=G2frame.mainPanel,frame=G2frame)
3658	G2frame.dataFrame.PhaseUserSize = None
3659
3660	G2frame.dataFrame.Raise()
3661	G2frame.PickId = 0
3662	parentID = G2frame.root
3663	for i in G2frame.ExportPattern: i.Enable(False)
3664	defWid = [250,150]
3665	if item != G2frame.root:
3666	parentID = G2frame.PatternTree.GetItemParent(item)
3667	if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
3668	G2frame.PatternId = item
3669	G2frame.PickId = item
3670	if G2frame.PatternTree.GetItemText(item) == 'Notebook':
3671	SetDataMenuBar(G2frame,G2frame.dataFrame.DataNotebookMenu)
3672	G2frame.PatternId = 0
3673	for i in G2frame.ExportPattern: i.Enable(False)
3674	data = G2frame.PatternTree.GetItemPyData(item)
3675	UpdateNotebook(G2frame,data)
3676	elif G2frame.PatternTree.GetItemText(item) == 'Controls':
3677	G2frame.PatternId = 0
3678	for i in G2frame.ExportPattern: i.Enable(False)
3679	data = G2frame.PatternTree.GetItemPyData(item)
3680	if not data: #fill in defaults
3681	data = copy.copy(G2obj.DefaultControls) #least squares controls
3682	G2frame.PatternTree.SetItemPyData(item,data)
3683	for i in G2frame.Refine: i.Enable(True)
3684	for i in G2frame.SeqRefine: i.Enable(True)
3685	UpdateControls(G2frame,data)
3686	elif G2frame.PatternTree.GetItemText(item) == 'Sequential results':
3687	data = G2frame.PatternTree.GetItemPyData(item)
3688	UpdateSeqResults(G2frame,data)
3689	elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
3690	data = G2frame.PatternTree.GetItemPyData(item)
3691	G2frame.dataFrame.setSizePosLeft(defWid)
3692	text = ''
3693	if 'Rvals' in data:
3694	Nvars = len(data['varyList'])
3695	Rvals = data['Rvals']
3696	text = '\nFinal residuals: \nwR = %.3f%% \nchi**2 = %.1f \nGOF = %.2f'%(Rvals['Rwp'],Rvals['chisq'],Rvals['GOF'])
3697	text += '\nNobs = %d \nNvals = %d'%(Rvals['Nobs'],Nvars)
3698	if 'lamMax' in Rvals:
3699	text += '\nlog10 MaxLambda = %.1f'%(np.log10(Rvals['lamMax']))
3700	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
3701	value='See plot window for covariance display'+text,style=wx.TE_MULTILINE)
3702	G2plt.PlotCovariance(G2frame,data)
3703	elif G2frame.PatternTree.GetItemText(item) == 'Constraints':
3704	data = G2frame.PatternTree.GetItemPyData(item)
3705	G2cnstG.UpdateConstraints(G2frame,data)
3706	elif G2frame.PatternTree.GetItemText(item) == 'Rigid bodies':
3707	data = G2frame.PatternTree.GetItemPyData(item)
3708	G2cnstG.UpdateRigidBodies(G2frame,data)
3709	elif G2frame.PatternTree.GetItemText(item) == 'Restraints':
3710	data = G2frame.PatternTree.GetItemPyData(item)
3711	Phases = G2frame.GetPhaseData()
3712	phase = ''
3713	phaseName = ''
3714	if Phases:
3715	phaseName = Phases.keys()[0]
3716	G2frame.dataFrame.setSizePosLeft(defWid)
3717	G2restG.UpdateRestraints(G2frame,data,Phases,phaseName)
3718	elif 'IMG' in G2frame.PatternTree.GetItemText(item):
3719	G2frame.Image = item
3720	G2plt.PlotImage(G2frame,newPlot=True)
3721	elif 'PKS' in G2frame.PatternTree.GetItemText(item):
3722	G2plt.PlotPowderLines(G2frame)
3723	elif 'PWDR' in G2frame.PatternTree.GetItemText(item):
3724	for i in G2frame.ExportPattern: i.Enable(True)
3725	UpdatePWHKPlot(G2frame,'PWDR',item)
3726	elif 'SASD' in G2frame.PatternTree.GetItemText(item):
3727	for i in G2frame.ExportPattern: i.Enable(True)
3728	UpdatePWHKPlot(G2frame,'SASD',item)
3729	elif 'HKLF' in G2frame.PatternTree.GetItemText(item):
3730	G2frame.Sngl = item
3731	UpdatePWHKPlot(G2frame,'HKLF',item)
3732	elif 'PDF' in G2frame.PatternTree.GetItemText(item):
3733	G2frame.PatternId = item
3734	for i in G2frame.ExportPDF: i.Enable(True)
3735	G2plt.PlotISFG(G2frame,type='S(Q)')
3736	elif G2frame.PatternTree.GetItemText(item) == 'Phases':
3737	G2frame.dataFrame.setSizePosLeft(defWid)
3738	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
3739	value='Select one phase to see its parameters')
3740	elif 'I(Q)' in G2frame.PatternTree.GetItemText(item):
3741	G2frame.PickId = item
3742	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3743	G2plt.PlotISFG(G2frame,type='I(Q)',newPlot=True)
3744	elif 'S(Q)' in G2frame.PatternTree.GetItemText(item):
3745	G2frame.PickId = item
3746	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3747	G2plt.PlotISFG(G2frame,type='S(Q)',newPlot=True)
3748	elif 'F(Q)' in G2frame.PatternTree.GetItemText(item):
3749	G2frame.PickId = item
3750	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3751	G2plt.PlotISFG(G2frame,type='F(Q)',newPlot=True)
3752	elif 'G(R)' in G2frame.PatternTree.GetItemText(item):
3753	G2frame.PickId = item
3754	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3755	G2plt.PlotISFG(G2frame,type='G(R)',newPlot=True)
3756	elif G2frame.PatternTree.GetItemText(parentID) == 'Phases':
3757	G2frame.PickId = item
3758	data = G2frame.PatternTree.GetItemPyData(item)
3759	G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
3760	elif G2frame.PatternTree.GetItemText(item) == 'Comments':
3761	SetDataMenuBar(G2frame,G2frame.dataFrame.DataCommentsMenu)
3762	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3763	G2frame.PickId = item
3764	data = G2frame.PatternTree.GetItemPyData(item)
3765	UpdateComments(G2frame,data)
3766	elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
3767	G2frame.dataFrame.SetTitle('Image Controls')
3768	G2frame.PickId = item
3769	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
3770	masks = G2frame.PatternTree.GetItemPyData(
3771	GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
3772	data = G2frame.PatternTree.GetItemPyData(item)
3773	G2imG.UpdateImageControls(G2frame,data,masks)
3774	G2plt.PlotImage(G2frame)
3775	elif G2frame.PatternTree.GetItemText(item) == 'Masks':
3776	G2frame.dataFrame.SetTitle('Masks')
3777	G2frame.PickId = item
3778	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
3779	data = G2frame.PatternTree.GetItemPyData(item)
3780	G2imG.UpdateMasks(G2frame,data)
3781	G2plt.PlotImage(G2frame)
3782	elif G2frame.PatternTree.GetItemText(item) == 'Stress/Strain':
3783	G2frame.dataFrame.SetTitle('Stress/Strain')
3784	G2frame.PickId = item
3785	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
3786	data = G2frame.PatternTree.GetItemPyData(item)
3787	G2imG.UpdateStressStrain(G2frame,data)
3788	G2plt.PlotImage(G2frame)
3789	G2plt.PlotStrain(G2frame,data,newPlot=True)
3790	elif G2frame.PatternTree.GetItemText(item) == 'HKL Plot Controls':
3791	G2frame.PickId = item
3792	G2frame.Sngl = G2frame.PatternTree.GetItemParent(item)
3793	data = G2frame.PatternTree.GetItemPyData(item)
3794	UpdateHKLControls(G2frame,data)
3795	G2plt.PlotSngl(G2frame)
3796	elif G2frame.PatternTree.GetItemText(item) == 'PDF Controls':
3797	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3798	for i in G2frame.ExportPDF: i.Enable(True)
3799	G2frame.PickId = item
3800	data = G2frame.PatternTree.GetItemPyData(item)
3801	G2pdG.UpdatePDFGrid(G2frame,data)
3802	G2plt.PlotISFG(G2frame,type='I(Q)')
3803	G2plt.PlotISFG(G2frame,type='S(Q)')
3804	G2plt.PlotISFG(G2frame,type='F(Q)')
3805	G2plt.PlotISFG(G2frame,type='G(R)')
3806	elif G2frame.PatternTree.GetItemText(item) == 'Peak List':
3807	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3808	for i in G2frame.ExportPeakList: i.Enable(True)
3809	G2frame.PickId = item
3810	data = G2frame.PatternTree.GetItemPyData(item)
3811	G2pdG.UpdatePeakGrid(G2frame,data)
3812	G2plt.PlotPatterns(G2frame)
3813	elif G2frame.PatternTree.GetItemText(item) == 'Background':
3814	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3815	G2frame.PickId = item
3816	data = G2frame.PatternTree.GetItemPyData(item)
3817	G2pdG.UpdateBackground(G2frame,data)
3818	G2plt.PlotPatterns(G2frame)
3819	elif G2frame.PatternTree.GetItemText(item) == 'Limits':
3820	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3821	G2frame.PickId = item
3822	data = G2frame.PatternTree.GetItemPyData(item)
3823	G2pdG.UpdateLimitsGrid(G2frame,data)
3824	G2plt.PlotPatterns(G2frame)
3825	elif G2frame.PatternTree.GetItemText(item) == 'Instrument Parameters':
3826	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3827	G2frame.PickId = item
3828	data = G2frame.PatternTree.GetItemPyData(item)[0]
3829	G2pdG.UpdateInstrumentGrid(G2frame,data)
3830	if 'P' in data['Type'][0]: #powder data only
3831	G2plt.PlotPeakWidths(G2frame)
3832	elif G2frame.PatternTree.GetItemText(item) == 'Models':
3833	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3834	G2frame.PickId = item
3835	data = G2frame.PatternTree.GetItemPyData(item)
3836	G2pdG.UpdateModelsGrid(G2frame,data)
3837	elif G2frame.PatternTree.GetItemText(item) == 'Sample Parameters':
3838	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3839	G2frame.PickId = item
3840	data = G2frame.PatternTree.GetItemPyData(item)
3841
3842	if 'Temperature' not in data: #temp fix for old gpx files
3843	data = {'Scale':[1.0,True],'Type':'Debye-Scherrer','Absorption':[0.0,False],'DisplaceX':[0.0,False],
3844	'DisplaceY':[0.0,False],'Diffuse':[],'Temperature':300.,'Pressure':1.0,
3845	'FreePrm1':0.,'FreePrm2':0.,'FreePrm3':0.,
3846	'Gonio. radius':200.0}
3847	G2frame.PatternTree.SetItemPyData(item,data)
3848
3849	G2pdG.UpdateSampleGrid(G2frame,data)
3850	G2plt.PlotPatterns(G2frame)
3851	elif G2frame.PatternTree.GetItemText(item) == 'Index Peak List':
3852	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3853	for i in G2frame.ExportPeakList: i.Enable(True)
3854	G2frame.PickId = item
3855	data = G2frame.PatternTree.GetItemPyData(item)
3856	G2pdG.UpdateIndexPeaksGrid(G2frame,data)
3857	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
3858	G2plt.PlotPowderLines(G2frame)
3859	else:
3860	G2plt.PlotPatterns(G2frame)
3861	elif G2frame.PatternTree.GetItemText(item) == 'Unit Cells List':
3862	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3863	G2frame.PickId = item
3864	data = G2frame.PatternTree.GetItemPyData(item)
3865	if not data:
3866	data.append([0,0.0,4,25.0,0,'P1',1,1,1,90,90,90]) #zero error flag, zero value, max Nc/No, start volume
3867	data.append([0,0,0,0,0,0,0,0,0,0,0,0,0,0]) #Bravais lattice flags
3868	data.append([]) #empty cell list
3869	data.append([]) #empty dmin
3870	G2frame.PatternTree.SetItemPyData(item,data)
3871	G2pdG.UpdateUnitCellsGrid(G2frame,data)
3872	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
3873	G2plt.PlotPowderLines(G2frame)
3874	else:
3875	G2plt.PlotPatterns(G2frame)
3876	elif G2frame.PatternTree.GetItemText(item) == 'Reflection Lists': #powder reflections
3877	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3878	G2frame.PickId = item
3879	data = G2frame.PatternTree.GetItemPyData(item)
3880	G2frame.RefList = ''
3881	if len(data):
3882	G2frame.RefList = data.keys()[0]
3883	G2pdG.UpdateReflectionGrid(G2frame,data)
3884	G2plt.PlotPatterns(G2frame)
3885	elif G2frame.PatternTree.GetItemText(item) == 'Reflection List': #HKLF reflections
3886	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
3887	name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
3888	data = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
3889	G2pdG.UpdateReflectionGrid(G2frame,data,HKLF=True,Name=name)
3890
3891	def SetDataMenuBar(G2frame,menu=None):
3892	'''Set the menu for the data frame. On the Mac put this
3893	menu for the data tree window instead.
3894
3895	Note that data frame items do not have menus, for these (menu=None)
3896	display a blank menu or on the Mac display the standard menu for
3897	the data tree window.
3898	'''
3899	if sys.platform == "darwin":
3900	if menu is None:
3901	G2frame.SetMenuBar(G2frame.GSASIIMenu)
3902	else:
3903	G2frame.SetMenuBar(menu)
3904	else:
3905	if menu is None:
3906	G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
3907	else:
3908	G2frame.dataFrame.SetMenuBar(menu)
3909
3910	def HorizontalLine(sizer,parent):
3911	'''Draws a horizontal line as wide as the window.
3912	This shows up on the Mac as a very thin line, no matter what I do
3913	'''
3914	line = wx.StaticLine(parent,-1, size=(-1,3), style=wx.LI_HORIZONTAL)
3915	sizer.Add(line, 0, wx.EXPAND\|wx.ALIGN_CENTER\|wx.ALL, 10)
3916
3917	if __name__ == '__main__':
3918	# test ScrolledMultiEditor
3919	app = wx.PySimpleApp()
3920	frm = wx.Frame(None) # create a frame
3921	frm.Show(True)
3922	Data1 = {
3923	'Order':1,
3924	'omega':'string',
3925	'chi':2.0,
3926	'phi':'',
3927	}
3928	elemlst = sorted(Data1.keys())
3929	postlbl = sorted(Data1.keys())
3930	dictlst = len(elemlst)*[Data1,]
3931
3932	Data2 = list(range(100))
3933	elemlst += range(2,6)
3934	postlbl += range(2,6)
3935	dictlst += len(range(2,6))*[Data2,]
3936
3937	prelbl = range(len(elemlst))
3938	postlbl[1] = "a very long label for the 2nd item to force a horiz. scrollbar"
3939	header="""This is a longer\nmultiline and perhaps silly header"""
3940	dlg = ScrolledMultiEditor(frm,dictlst,elemlst,prelbl,postlbl,
3941	header=header,CopyButton=True)
3942	print Data1
3943	if dlg.ShowModal() == wx.ID_OK:
3944	for d,k in zip(dictlst,elemlst):
3945	print k,d[k]
3946	dlg.Destroy()
3947	if CallScrolledMultiEditor(frm,dictlst,elemlst,prelbl,postlbl,
3948	header=header):
3949	for d,k in zip(dictlst,elemlst):
3950	print k,d[k]
3951
3952	#app.MainLoop()

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

Download in other formats: