Context Navigation

source: trunk/GSASIIgrid.py @ 1145

Last change on this file since 1145 was 1145, checked in by toby, 10 years ago
move DefaultControls? out of g2grid to avoid wx requirement; now import mmCIF reflection files
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 165.3 KB

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

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

Download in other formats: