Context Navigation

source: trunk/GSASIIgrid.py @ 933

Last change on this file since 933 was 933, checked in by toby, 10 years ago
Add megawidgets needed for CIF development
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 128.5 KB

Line
1	# -- coding: utf-8 --
2	#GSASIIgrid - data display routines
3	########### SVN repository information ###################
4	# $Date: 2013-05-26 18:35:30 +0000 (Sun, 26 May 2013) $
5	# $Author: toby $
6	# $Revision: 933 $
7	# $URL: trunk/GSASIIgrid.py $
8	# $Id: GSASIIgrid.py 933 2013-05-26 18:35:30Z 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 cPickle
22	import sys
23	import numpy as np
24	import numpy.ma as ma
25	import os.path
26	import wx.html # could postpone this for quicker startup
27	import webbrowser # could postpone this for quicker startup
28	import GSASIIpath
29	GSASIIpath.SetVersionNumber("$Revision: 933 $")
30	import GSASIImath as G2mth
31	import GSASIIIO as G2IO
32	import GSASIIlattice as G2lat
33	import GSASIIplot as G2plt
34	import GSASIIpwdGUI as G2pdG
35	import GSASIIimgGUI as G2imG
36	import GSASIIphsGUI as G2phG
37	import GSASIIspc as G2spc
38	import GSASIImapvars as G2mv
39	import GSASIIconstrGUI as G2cnstG
40	import GSASIIrestrGUI as G2restG
41	import GSASIIpy3 as G2py3
42
43	# trig functions in degrees
44	sind = lambda x: np.sin(x*np.pi/180.)
45	tand = lambda x: np.tan(x*np.pi/180.)
46	cosd = lambda x: np.cos(x*np.pi/180.)
47
48	# globals we will use later
49	__version__ = None # gets overridden in GSASII.py
50	path2GSAS2 = os.path.dirname(os.path.realpath(__file__)) # save location of this file
51	helpLocDict = {}
52	htmlPanel = None
53	htmlFrame = None
54	helpMode = 'browser'
55	#if sys.platform.lower().startswith('win'): helpMode = 'internal' # need a global control to set this
56
57	htmlFirstUse = True
58
59	[ wxID_FOURCALC, wxID_FOURSEARCH, wxID_FOURCLEAR, wxID_PEAKSMOVE, wxID_PEAKSCLEAR,
60	wxID_CHARGEFLIP, wxID_PEAKSUNIQUE, wxID_PEAKSDELETE, wxID_PEAKSDA,
61	wxID_PEAKSDISTVP, wxID_PEAKSVIEWPT, wxID_FINDEQVPEAKS,wxID_SHOWBONDS,
62	] = [wx.NewId() for item in range(13)]
63
64	[ wxID_PWDRADD, wxID_HKLFADD,wxID_PWDANALYSIS,wxID_DATADELETE,
65	] = [wx.NewId() for item in range(4)]
66
67	[ wxID_ATOMSEDITADD, wxID_ATOMSEDITINSERT, wxID_ATOMSEDITDELETE, wxID_ATOMSREFINE,
68	wxID_ATOMSMODIFY, wxID_ATOMSTRANSFORM, wxID_ATOMSVIEWADD, wxID_ATOMVIEWINSERT,
69	wxID_RELOADDRAWATOMS,wxID_ATOMSDISAGL,wxID_ATOMMOVE,wxID_RBAPPEND,
70	wxID_ASSIGNATMS2RB
71	] = [wx.NewId() for item in range(13)]
72
73	[ wxID_DRAWATOMSTYLE, wxID_DRAWATOMLABEL, wxID_DRAWATOMCOLOR, wxID_DRAWATOMRESETCOLOR,
74	wxID_DRAWVIEWPOINT, wxID_DRAWTRANSFORM, wxID_DRAWDELETE, wxID_DRAWFILLCELL,
75	wxID_DRAWADDEQUIV, wxID_DRAWFILLCOORD, wxID_DRAWDISAGLTOR, wxID_DRAWPLANE,
76	wxID_DRAWDISTVP,
77	] = [wx.NewId() for item in range(13)]
78
79	[ wxID_DRAWRESTRBOND, wxID_DRAWRESTRANGLE, wxID_DRAWRESTRPLANE, wxID_DRAWRESTRCHIRAL,
80	] = [wx.NewId() for item in range(4)]
81
82	[ wxID_CLEARTEXTURE,wxID_REFINETEXTURE,
83	] = [wx.NewId() for item in range(2)]
84
85	[ wxID_PAWLEYLOAD, wxID_PAWLEYDELETE, wxID_PAWLEYESTIMATE,
86	wxID_PAWLEYUPDATE,
87	] = [wx.NewId() for item in range(4)]
88
89	[ wxID_IMCALIBRATE,wxID_IMRECALIBRATE,wxID_IMINTEGRATE, wxID_IMCLEARCALIB,
90	wxID_IMCOPYCONTROLS, wxID_INTEGRATEALL, wxID_IMSAVECONTROLS, wxID_IMLOADCONTROLS,
91	] = [wx.NewId() for item in range(8)]
92
93	[ wxID_MASKCOPY, wxID_MASKSAVE, wxID_MASKLOAD,
94	] = [wx.NewId() for item in range(3)]
95
96	[ wxID_STRSTACOPY, wxID_STRSTAFIT, wxID_STRSTASAVE, wxID_STRSTALOAD,wxID_APPENDDZERO,
97	] = [wx.NewId() for item in range(5)]
98
99	[ wxID_BACKCOPY,wxID_LIMITCOPY,wxID_SAMPLECOPY, wxID_BACKFLAGCOPY, wxID_SAMPLEFLAGCOPY,
100	wxID_SAMPLESAVE, wxID_SAMPLELOAD,
101	] = [wx.NewId() for item in range(7)]
102
103	[ wxID_INSTPRMRESET,wxID_CHANGEWAVETYPE,wxID_INSTCOPY, wxID_INSTFLAGCOPY, wxID_INSTLOAD,
104	wxID_INSTSAVE,
105	] = [wx.NewId() for item in range(6)]
106
107	[ wxID_UNDO,wxID_LSQPEAKFIT,wxID_LSQONECYCLE,wxID_RESETSIGGAM,wxID_CLEARPEAKS,wxID_AUTOSEARCH,
108	] = [wx.NewId() for item in range(6)]
109
110	[ wxID_INDXRELOAD, wxID_INDEXPEAKS, wxID_REFINECELL, wxID_COPYCELL, wxID_MAKENEWPHASE,
111	] = [wx.NewId() for item in range(5)]
112
113	[ wxID_CONSTRAINTADD,wxID_EQUIVADD,wxID_HOLDADD,wxID_FUNCTADD,
114	] = [wx.NewId() for item in range(4)]
115
116	[ wxID_RESTRAINTADD, wxID_RESTSELPHASE,wxID_RESTDELETE, wxID_RESRCHANGEVAL,
117	wxID_RESTCHANGEESD,wxID_AARESTRAINTADD,wxID_AARESTRAINTPLOT,
118	] = [wx.NewId() for item in range(7)]
119
120	[ wxID_RIGIDBODYADD,wxID_DRAWDEFINERB,wxID_RIGIDBODYIMPORT,wxID_RESIDUETORSSEQ,
121	wxID_AUTOFINDRESRB,wxID_GLOBALRESREFINE,wxID_RBREMOVEALL,wxID_COPYRBPARMS,
122	] = [wx.NewId() for item in range(8)]
123
124	[ wxID_SAVESEQSEL,
125	] = [wx.NewId() for item in range(1)]
126
127	[ wxID_SELECTPHASE,
128	] = [wx.NewId() for item in range(1)]
129
130	[ wxID_PDFCOPYCONTROLS, wxID_PDFSAVECONTROLS, wxID_PDFLOADCONTROLS,
131	wxID_PDFCOMPUTE, wxID_PDFCOMPUTEALL, wxID_PDFADDELEMENT, wxID_PDFDELELEMENT,
132	] = [wx.NewId() for item in range(7)]
133
134	VERY_LIGHT_GREY = wx.Colour(235,235,235)
135
136	################################################################################
137	#### GSAS-II class definitions
138	################################################################################
139
140	class ValidatedTxtCtrl(wx.TextCtrl):
141	'''Create a TextCtrl widget that uses a validator to prevent the
142	entry of inappropriate characters and changes color to highlight
143	when invalid input is supplied. As valid values are typed,
144	they are placed into the dict or list where the initial value
145	came from. The type of the initial value must be int, float or str;
146	this type is preserved.
147
148	Float values can be entered in the TextCtrl as numbers or also
149	as algebraic expressions using operators + - / \* () and \\,
150	in addition pi, sind(), cosd(), tand(), and sqrt() can be used,
151	as well as appreviations s, sin, c, cos, t, tan and sq.
152
153	:param wx.Panel parent: name of panel or frame that will be
154	the parent to the TextCtrl
155
156	:param dict/list loc: the dict or list with the initial value to be
157	placed in the TextCtrl
158
159	:param int/str key: the dict key or the list index for the value
160
161	:param bool notBlank: if True (default) blank values are not allowed
162	for str inputs.
163
164	:param number min: Minimum allowed value. If None (default) the
165	lower limit is unbounded
166
167	:param number max: Maximum allowed value. If None (default) the
168	upper limit is unbounded
169
170	:param wx.Size size: an optional size parameter that dictates the
171	size for the TextCtrl. None (the default) indicates that the
172	default size should be used.
173
174	:param function OKcontrol: specifies a function or method that will be
175	called when the input is validated. It is supplied with one argument
176	which is False if the TextCtrl contains an invalid value and True if
177	the value is valid. Note that this function should check all values
178	in the dialog when True, since other entries might be invalid.
179
180	'''
181	def __init__(self,parent,loc,key,notBlank=True,min=None,max=None,
182	size=None,OKcontrol=None):
183	self.result = loc
184	self.key = key
185	self.OKcontrol=OKcontrol
186	self.invalid = None
187	val = loc[key]
188	if isinstance(val,int):
189	wx.TextCtrl.__init__(
190	self,parent,wx.ID_ANY,str(val),
191	validator=NumberValidator(int,result=loc,key=key,min=min,max=max,
192	OKcontrol=OKcontrol)
193	)
194	self.invalid = not self.Validate()
195	elif isinstance(val,int) or isinstance(val,float):
196	wx.TextCtrl.__init__(
197	self,parent,wx.ID_ANY,str(val),
198	validator=NumberValidator(float,result=loc,key=key,min=min,max=max,
199	OKcontrol=OKcontrol)
200	)
201	self.invalid = not self.Validate()
202	elif isinstance(val,str):
203	wx.TextCtrl.__init__(self,parent,wx.ID_ANY,str(val))
204	if notBlank:
205	self.Bind(wx.EVT_CHAR,self._onStringKey)
206	self.ShowStringValidity() # test if valid input
207	else:
208	self.invalid = False
209	else:
210	raise Exception,"ValidatedTxtCtrl Unknown type "+str(type(val))
211	if size: self.SetSize(size)
212
213	def _onStringKey(self,event):
214	event.Skip()
215	if self.invalid: # check for validity after processing the keystroke
216	wx.CallAfter(self.ShowStringValidity,True) # was invalid
217	else:
218	wx.CallAfter(self.ShowStringValidity,False) # was valid
219
220	def ShowStringValidity(self,previousInvalid=None):
221	'''Check if input is valid. Anytime the input is
222	invalid, call self.OKcontrol (if defined) because it is fast.
223	If valid, check for any other invalid entries only when
224	changing from invalid to valid, since that is slower.
225
226	:param bool previousInvalid: True if the TextCtrl contents were
227	invalid prior to the current change.
228
229	'''
230	val = self.GetValue().strip()
231	self.invalid = not val
232	'Set the control colors to show invalid input'
233	if self.invalid:
234	self.SetForegroundColour("red")
235	self.SetBackgroundColour("yellow")
236	self.SetFocus()
237	self.Refresh()
238	if self.OKcontrol:
239	self.OKcontrol(False)
240	else: # valid input
241	self.SetBackgroundColour(
242	wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW))
243	self.SetForegroundColour("black")
244	self.Refresh()
245	self.result[self.key] = val
246	if self.OKcontrol and previousInvalid:
247	self.OKcontrol(True)
248
249	class NumberValidator(wx.PyValidator):
250	'''A validator to be used with a TextCtrl to prevent
251	entering characters other than digits, signs, and for float
252	input, a period and exponents.
253
254	The value is checked for validity after every keystroke
255	If an invalid number is entered, the box is highlighted.
256	If the number is valid, it is saved in result[key]
257
258	:param type typ: data type, int or float
259
260	:param bool positiveonly: used for typ=int. If True, only positive
261	integers are allowed (default False)
262
263	:param number min: Minimum allowed value. If None (default) the
264	lower limit is unbounded
265
266	:param number max: Maximum allowed value. If None (default) the
267	upper limit is unbounded
268
269	:param dict/list result: List or dict where value should be placed when valid
270
271	:param any key: key to use for result (int for list)
272
273	:param function OKcontrol: function or class method to control
274	an OK button for a window.
275	Ignored if None (default)
276	'''
277	def __init__(self, typ, positiveonly=False, min=None, max=None,
278	result=None, key=None, OKcontrol=None):
279	'Create the validator'
280	wx.PyValidator.__init__(self)
281	self.typ = typ
282	self.positiveonly = positiveonly
283	self.min = min
284	self.max = max
285	self.result = result
286	self.key = key
287	self.OKcontrol = OKcontrol
288	self.evaluated = False
289	# When the mouse is moved away or the widget loses focus
290	# display the last saved value
291	self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
292	self.Bind(wx.EVT_KILL_FOCUS, self.OnLeave)
293	if self.typ == int and self.positiveonly:
294	self.validchars = '0123456789'
295	self.Bind(wx.EVT_CHAR, self.OnChar)
296	elif self.typ == int:
297	self.validchars = '0123456789+-'
298	self.Bind(wx.EVT_CHAR, self.OnChar)
299	elif self.typ == float:
300	# allow for above and sind, cosd, sqrt, tand, pi, and abbreviations
301	# also addition, subtraction, division, multiplication, exponentiation
302	self.validchars = '0123456789.-+eE/cosindcqrtap()*'
303	self.Bind(wx.EVT_CHAR, self.OnChar)
304	else:
305	self.validchars = None
306	def Clone(self):
307	'Create a copy of the validator, a strange, but required component'
308	return NumberValidator(typ=self.typ,
309	positiveonly=self.positiveonly,
310	min=self.min, max=self.max,
311	result=self.result, key=self.key,
312	OKcontrol=self.OKcontrol)
313	tc = self.GetWindow()
314	tc.invalid = False # make sure the validity flag is defined in parent
315	def TransferToWindow(self):
316	'Needed by validator, strange, but required component'
317	return True # Prevent wxDialog from complaining.
318	def TransferFromWindow(self):
319	'Needed by validator, strange, but required component'
320	return True # Prevent wxDialog from complaining.
321	def TestValid(self,tc):
322	'''Check if the value is valid by casting the input string
323	into the current type.
324
325	Set the invalid variable in the TextCtrl object accordingly.
326
327	If the value is valid, save it in the dict/list where
328	the initial value was stored, if appropriate.
329	'''
330	tc.invalid = False # assume invalid
331	try:
332	val = self.typ(tc.GetValue())
333	except (ValueError, SyntaxError) as e:
334	if self.typ is float: # for float values, see if an expression can be
335	# evaluated
336	val = G2py3.FormulaEval(tc.GetValue())
337	if val is None:
338	tc.invalid = True
339	return
340	else:
341	self.evaluated = True
342	else:
343	tc.invalid = True
344	return
345	if self.max != None and self.typ == int:
346	if val > self.max:
347	tc.invalid = True
348	if self.max != None and self.typ == int:
349	if val < self.min:
350	tc.invalid = True # invalid
351	if self.key is not None and self.result is not None and not tc.invalid:
352	self.result[self.key] = val
353
354	def ShowValidity(self,tc):
355	'Set the control colors to show invalid input'
356	if tc.invalid:
357	tc.SetForegroundColour("red")
358	tc.SetBackgroundColour("yellow")
359	tc.SetFocus()
360	tc.Refresh()
361	return False
362	else: # valid input
363	tc.SetBackgroundColour(
364	wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW))
365	tc.SetForegroundColour("black")
366	tc.Refresh()
367	return True
368
369	def OnLeave(self, event):
370	'''Show the computed value when an expression is entered to the TextCtrl
371	Make sure that the number fits by truncating decimal places and switching
372	to scientific notation, as needed.
373	Called on loss of focus.
374	'''
375	tc = self.GetWindow()
376	if tc.invalid: return # don't substitute for an invalid expression
377	if not self.evaluated: return # true when an expression is evaluated
378	self.evaluated = False
379	if self.result is not None: # retrieve the stored result
380	val = self.result[self.key]
381	tc.SetValue(G2py3.FormatValue(val))
382
383	def CheckInput(self,previousInvalid):
384	'''called to test every change to the TextCtrl for validity and
385	to change the appearance of the TextCtrl
386
387	Anytime the input is invalid, call self.OKcontrol
388	(if defined) because it is fast.
389	If valid, check for any other invalid entries only when
390	changing from invalid to valid, since that is slower.
391	'''
392	tc = self.GetWindow()
393	self.TestValid(tc)
394	self.ShowValidity(tc)
395	# if invalid and
396	if tc.invalid and self.OKcontrol:
397	self.OKcontrol(False)
398	if not tc.invalid and self.OKcontrol and previousInvalid:
399	self.OKcontrol(True)
400
401	def OnChar(self, event):
402	'''Called each type a key is pressed
403	ignores keys that are not allowed for int and float types
404	'''
405	key = event.GetKeyCode()
406	if key == wx.WXK_RETURN:
407	tc = self.GetWindow()
408	if tc.invalid:
409	self.CheckInput(True)
410	else:
411	self.CheckInput(False)
412	return
413	if key < wx.WXK_SPACE or key == wx.WXK_DELETE or key > 255: # control characters get processed
414	event.Skip()
415	tc = self.GetWindow()
416	if tc.invalid:
417	wx.CallAfter(self.CheckInput,True)
418	else:
419	wx.CallAfter(self.CheckInput,False)
420	return
421	elif chr(key) in self.validchars: # valid char pressed?
422	event.Skip()
423	tc = self.GetWindow()
424	if tc.invalid:
425	wx.CallAfter(self.CheckInput,True)
426	else:
427	wx.CallAfter(self.CheckInput,False)
428	return
429	if not wx.Validator_IsSilent():
430	wx.Bell()
431	return # Returning without calling event.Skip, which eats the keystroke
432
433	################################################################################
434	class ScrolledMultiEditor(wx.Dialog):
435	'''Define a window for editing a potentially large number of dict- or
436	list-contained values with validation for each item. Edited values are
437	automatically placed in their source location. If invalid entries
438	are provided, the TextCtrl is turned yellow and the OK button is disabled.
439
440	The type for each TextCtrl validation is determined by the
441	initial value of the entry (int, float or string).
442	Float values can be entered in the TextCtrl as numbers or also
443	as algebraic expressions using operators + - / \* () and \\,
444	in addition pi, sind(), cosd(), tand(), and sqrt() can be used,
445	as well as appreviations s(), sin(), c(), cos(), t(), tan() and sq().
446
447	:param wx.Frame parent: name of parent window, or may be None
448
449	:param tuple dictlst: a list of dicts or lists containing values to edit
450
451	:param tuple elemlst: a list of keys for each item in a dictlst. Must have the
452	same length as dictlst.
453
454	:param wx.Frame parent: name of parent window, or may be None
455
456	:param tuple prelbl: a list of labels placed before the TextCtrl for each
457	item (optional)
458
459	:param tuple postlbl: a list of labels placed after the TextCtrl for each
460	item (optional)
461
462	:param str title: a title to place in the frame of the dialog
463
464	:param str header: text to place at the top of the window. May contain
465	new line characters.
466
467	:param wx.Size size: a size parameter that dictates the
468	size for the scrolled region of the dialog. The default is
469	(300,250).
470
471	:returns: the wx.Dialog created here. Use .ShowModal() to
472
473	''Example for use of ScrolledMultiEditor:''
474
475	::
476
477	dlg = <pkg>.ScrolledMultiEditor(frame,dictlst,elemlst,prelbl,postlbl,
478	header=header)
479	if dlg.ShowModal() == wx.ID_OK:
480	for d,k in zip(dictlst,elemlst):
481	print d[k]
482
483	''Example definitions for dictlst and elemlst:''
484
485	::
486
487	dictlst = (dict1,list1,dict1,list1)
488	elemlst = ('a', 1, 2, 3)
489
490	This causes items dict1['a'], list1[1], dict1[2] and list1[3] to be edited.
491
492	Note that these items must have int, float or str values assigned to
493	them. The dialog will force these types to be retained. String values
494	that are blank are marked as invalid.
495	'''
496
497	def __init__(self,parent,dictlst,elemlst,prelbl=[],postlbl=[],
498	title='Edit items',header='',size=(300,250)):
499	if len(dictlst) != len(elemlst):
500	raise Exception,"ScrolledMultiEditor error: len(dictlst) != len(elemlst) "+str(len(dictlst))+" != "+str(len(elemlst))
501	wx.Dialog.__init__( # create dialog & sizer
502	self,parent,wx.ID_ANY,title,
503	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
504	mainSizer = wx.BoxSizer(wx.VERTICAL)
505	# ad a header if supplied
506	if header:
507	subSizer = wx.BoxSizer(wx.HORIZONTAL)
508	subSizer.Add((-1,-1),1,wx.EXPAND)
509	subSizer.Add(wx.StaticText(self,wx.ID_ANY,header))
510	subSizer.Add((-1,-1),1,wx.EXPAND)
511	mainSizer.Add(subSizer,0,wx.EXPAND,0)
512	# make OK button now, because we will need it for validation
513	self.OKbtn = wx.Button(self, wx.ID_OK)
514	self.OKbtn.SetDefault()
515	# create scrolled panel and sizer
516	panel = wxscroll.ScrolledPanel(
517	self, wx.ID_ANY,
518	size=size,
519	style = wx.TAB_TRAVERSAL\|wx.SUNKEN_BORDER)
520	subSizer = wx.FlexGridSizer(rows=len(dictlst),cols=3,hgap=2,vgap=2)
521	self.ValidatedControlsList = [] # make list of TextCtrls
522	for i,(d,k) in enumerate(zip(dictlst,elemlst)):
523	if i >= len(prelbl): # label before TextCtrl, or put in a blank
524	subSizer.Add((-1,-1))
525	else:
526	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,str(prelbl[i])))
527	# create the validated TextCrtl, store it and add it to the sizer
528	ctrl = ValidatedTxtCtrl(panel,d,k,OKcontrol=self.ControlOKButton)
529	self.ValidatedControlsList.append(ctrl)
530	subSizer.Add(ctrl)
531	if i >= len(postlbl): # label after TextCtrl, or put in a blank
532	subSizer.Add((-1,-1))
533	else:
534	subSizer.Add(wx.StaticText(panel,wx.ID_ANY,str(postlbl[i])))
535	# finish up ScrolledPanel
536	panel.SetSizer(subSizer)
537	panel.SetAutoLayout(1)
538	panel.SetupScrolling()
539	mainSizer.Add(panel,1, wx.ALL\|wx.EXPAND,1)
540
541	# Sizer for OK/Close buttons. N.B. using Close rather than Cancel because
542	# Cancel would imply that the changes should be discarded. In fact
543	# any valid changes are retained, unless one makes a copy of the
544	# input dicts & lists and restores them.
545	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
546	btnsizer.Add(self.OKbtn)
547	btn = wx.Button(self, wx.ID_CLOSE)
548	btn.Bind(wx.EVT_BUTTON,self._onClose)
549	btnsizer.Add(btn)
550	mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
551	# size out the window. Set it to be enlarged but not made smaller
552	self.SetSizer(mainSizer)
553	mainSizer.Fit(self)
554	self.SetMinSize(self.GetSize())
555
556	def _onClose(self,event):
557	'Close the window'
558	self.EndModal(wx.ID_CANCEL)
559
560	def ControlOKButton(self,setvalue):
561	'''Enable or Disable the OK button for the dialog. Note that this is
562	passed into the ValidatedTxtCtrl for use by validators.
563
564	:param bool setvalue: if True, all entries in the dialog are
565	checked for validity. if False then the OK button is disabled.
566
567	'''
568	if setvalue: # turn button on, do only if all controls show as valid
569	for ctrl in self.ValidatedControlsList:
570	if ctrl.invalid:
571	self.OKbtn.Disable()
572	return
573	else:
574	self.OKbtn.Enable()
575	else:
576	self.OKbtn.Disable()
577
578	################################################################################
579	class SymOpDialog(wx.Dialog):
580	'''Class to select a symmetry operator
581	'''
582	def __init__(self,parent,SGData,New=True,ForceUnit=False):
583	wx.Dialog.__init__(self,parent,-1,'Select symmetry operator',
584	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
585	panel = wx.Panel(self)
586	self.SGData = SGData
587	self.New = New
588	self.Force = ForceUnit
589	self.OpSelected = [0,0,0,[0,0,0],False,False]
590	mainSizer = wx.BoxSizer(wx.VERTICAL)
591	if ForceUnit:
592	choice = ['No','Yes']
593	self.force = wx.RadioBox(panel,-1,'Force to unit cell?',choices=choice)
594	self.force.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
595	mainSizer.Add(self.force,0,wx.ALIGN_CENTER_VERTICAL)
596	mainSizer.Add((5,5),0)
597	if SGData['SGInv']:
598	choice = ['No','Yes']
599	self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
600	self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
601	mainSizer.Add(self.inv,0,wx.ALIGN_CENTER_VERTICAL)
602	mainSizer.Add((5,5),0)
603	if SGData['SGLatt'] != 'P':
604	LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
605	self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
606	self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
607	mainSizer.Add(self.latt,0,wx.ALIGN_CENTER_VERTICAL)
608	mainSizer.Add((5,5),0)
609	if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
610	Ncol = 2
611	else:
612	Ncol = 3
613	OpList = []
614	for M,T in SGData['SGOps']:
615	OpList.append(G2spc.MT2text(M,T))
616	self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
617	majorDimension=Ncol)
618	self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
619	mainSizer.Add(self.oprs,0,wx.ALIGN_CENTER_VERTICAL)
620	mainSizer.Add((5,5),0)
621	mainSizer.Add(wx.StaticText(panel,-1," Choose unit cell?"),0,wx.ALIGN_CENTER_VERTICAL)
622	mainSizer.Add((5,5),0)
623	cellSizer = wx.BoxSizer(wx.HORIZONTAL)
624	cellSizer.Add((5,0),0)
625	cellName = ['X','Y','Z']
626	self.cell = []
627	for i in range(3):
628	self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
629	self.cell[-1].SetRange(-3,3)
630	self.cell[-1].SetValue(0)
631	self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
632	cellSizer.Add(self.cell[-1],0,wx.ALIGN_CENTER_VERTICAL)
633	mainSizer.Add(cellSizer,0,)
634	if self.New:
635	choice = ['No','Yes']
636	self.new = wx.RadioBox(panel,-1,'Generate new positions?',choices=choice)
637	self.new.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
638	mainSizer.Add(self.new,0,wx.ALIGN_CENTER_VERTICAL)
639	mainSizer.Add((5,5),0)
640
641	OkBtn = wx.Button(panel,-1,"Ok")
642	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
643	cancelBtn = wx.Button(panel,-1,"Cancel")
644	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
645	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
646	btnSizer.Add((20,20),1)
647	btnSizer.Add(OkBtn)
648	btnSizer.Add((20,20),1)
649	btnSizer.Add(cancelBtn)
650	btnSizer.Add((20,20),1)
651
652	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
653	panel.SetSizer(mainSizer)
654	panel.Fit()
655	self.Fit()
656
657	def OnOpSelect(self,event):
658	if self.SGData['SGInv']:
659	self.OpSelected[0] = self.inv.GetSelection()
660	if self.SGData['SGLatt'] != 'P':
661	self.OpSelected[1] = self.latt.GetSelection()
662	self.OpSelected[2] = self.oprs.GetSelection()
663	for i in range(3):
664	self.OpSelected[3][i] = float(self.cell[i].GetValue())
665	if self.New:
666	self.OpSelected[4] = self.new.GetSelection()
667	if self.Force:
668	self.OpSelected[5] = self.force.GetSelection()
669
670	def GetSelection(self):
671	return self.OpSelected
672
673	def OnOk(self,event):
674	parent = self.GetParent()
675	parent.Raise()
676	self.EndModal(wx.ID_OK)
677
678	def OnCancel(self,event):
679	parent = self.GetParent()
680	parent.Raise()
681	self.EndModal(wx.ID_CANCEL)
682
683	class DisAglDialog(wx.Dialog):
684	'''Distance Angle Controls dialog
685	'''
686	def __default__(self,data,default):
687	if data:
688	self.data = data
689	else:
690	self.data = {}
691	self.data['Name'] = default['Name']
692	self.data['Factors'] = [0.85,0.85]
693	self.data['AtomTypes'] = default['AtomTypes']
694	self.data['BondRadii'] = default['BondRadii']
695	self.data['AngleRadii'] = default['AngleRadii']
696
697	def __init__(self,parent,data,default):
698	wx.Dialog.__init__(self,parent,-1,'Distance Angle Controls',
699	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
700	self.default = default
701	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
702	self.__default__(data,self.default)
703	self.Draw(self.data)
704
705	def Draw(self,data):
706	self.panel.Destroy()
707	self.panel = wx.Panel(self)
708	mainSizer = wx.BoxSizer(wx.VERTICAL)
709	mainSizer.Add(wx.StaticText(self.panel,-1,'Controls for phase '+data['Name']),
710	0,wx.ALIGN_CENTER_VERTICAL\|wx.LEFT,10)
711	mainSizer.Add((10,10),1)
712
713	radiiSizer = wx.FlexGridSizer(2,3,5,5)
714	radiiSizer.Add(wx.StaticText(self.panel,-1,' Type'),0,wx.ALIGN_CENTER_VERTICAL)
715	radiiSizer.Add(wx.StaticText(self.panel,-1,'Bond radii'),0,wx.ALIGN_CENTER_VERTICAL)
716	radiiSizer.Add(wx.StaticText(self.panel,-1,'Angle radii'),0,wx.ALIGN_CENTER_VERTICAL)
717	self.objList = {}
718	for id,item in enumerate(self.data['AtomTypes']):
719	radiiSizer.Add(wx.StaticText(self.panel,-1,' '+item),0,wx.ALIGN_CENTER_VERTICAL)
720	bRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['BondRadii'][id]),style=wx.TE_PROCESS_ENTER)
721	self.objList[bRadii.GetId()] = ['BondRadii',id]
722	bRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
723	bRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
724	radiiSizer.Add(bRadii,0,wx.ALIGN_CENTER_VERTICAL)
725	aRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['AngleRadii'][id]),style=wx.TE_PROCESS_ENTER)
726	self.objList[aRadii.GetId()] = ['AngleRadii',id]
727	aRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
728	aRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
729	radiiSizer.Add(aRadii,0,wx.ALIGN_CENTER_VERTICAL)
730	mainSizer.Add(radiiSizer,0,wx.EXPAND)
731	factorSizer = wx.FlexGridSizer(2,2,5,5)
732	Names = ['Bond','Angle']
733	for i,name in enumerate(Names):
734	factorSizer.Add(wx.StaticText(self.panel,-1,name+' search factor'),0,wx.ALIGN_CENTER_VERTICAL)
735	bondFact = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['Factors'][i]),style=wx.TE_PROCESS_ENTER)
736	self.objList[bondFact.GetId()] = ['Factors',i]
737	bondFact.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
738	bondFact.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
739	factorSizer.Add(bondFact)
740	mainSizer.Add(factorSizer,0,wx.EXPAND)
741
742	OkBtn = wx.Button(self.panel,-1,"Ok")
743	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
744	ResetBtn = wx.Button(self.panel,-1,'Reset')
745	ResetBtn.Bind(wx.EVT_BUTTON, self.OnReset)
746	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
747	btnSizer.Add((20,20),1)
748	btnSizer.Add(OkBtn)
749	btnSizer.Add(ResetBtn)
750	btnSizer.Add((20,20),1)
751	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
752	self.panel.SetSizer(mainSizer)
753	self.panel.Fit()
754	self.Fit()
755
756	def OnRadiiVal(self,event):
757	Obj = event.GetEventObject()
758	item = self.objList[Obj.GetId()]
759	try:
760	self.data[item[0]][item[1]] = float(Obj.GetValue())
761	except ValueError:
762	pass
763	Obj.SetValue("%.3f"%(self.data[item[0]][item[1]])) #reset in case of error
764
765	def GetData(self):
766	return self.data
767
768	def OnOk(self,event):
769	parent = self.GetParent()
770	parent.Raise()
771	self.EndModal(wx.ID_OK)
772
773	def OnReset(self,event):
774	data = {}
775	self.__default__(data,self.default)
776	self.Draw(self.data)
777
778	class PickTwoDialog(wx.Dialog):
779	'''This does not seem to be in use
780	'''
781	def __init__(self,parent,title,prompt,names,choices):
782	wx.Dialog.__init__(self,parent,-1,title,
783	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
784	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
785	self.prompt = prompt
786	self.choices = choices
787	self.names = names
788	self.Draw()
789
790	def Draw(self):
791	Indx = {}
792
793	def OnSelection(event):
794	Obj = event.GetEventObject()
795	id = Indx[Obj.GetId()]
796	self.choices[id] = Obj.GetValue().encode() #to avoid Unicode versions
797	self.Draw()
798
799	self.panel.DestroyChildren()
800	self.panel.Destroy()
801	self.panel = wx.Panel(self)
802	mainSizer = wx.BoxSizer(wx.VERTICAL)
803	mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
804	for isel,name in enumerate(self.choices):
805	lineSizer = wx.BoxSizer(wx.HORIZONTAL)
806	lineSizer.Add(wx.StaticText(self.panel,-1,'Reference atom '+str(isel+1)),0,wx.ALIGN_CENTER)
807	nameList = self.names[:]
808	if isel:
809	if self.choices[0] in nameList:
810	nameList.remove(self.choices[0])
811	choice = wx.ComboBox(self.panel,-1,value=name,choices=nameList,
812	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
813	Indx[choice.GetId()] = isel
814	choice.Bind(wx.EVT_COMBOBOX, OnSelection)
815	lineSizer.Add(choice,0,wx.ALIGN_CENTER)
816	mainSizer.Add(lineSizer)
817	OkBtn = wx.Button(self.panel,-1,"Ok")
818	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
819	CancelBtn = wx.Button(self.panel,-1,'Cancel')
820	CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
821	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
822	btnSizer.Add((20,20),1)
823	btnSizer.Add(OkBtn)
824	btnSizer.Add(CancelBtn)
825	btnSizer.Add((20,20),1)
826	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
827	self.panel.SetSizer(mainSizer)
828	self.panel.Fit()
829	self.Fit()
830
831	def GetSelection(self):
832	return self.choices
833
834	def OnOk(self,event):
835	parent = self.GetParent()
836	parent.Raise()
837	self.EndModal(wx.ID_OK)
838
839	def OnCancel(self,event):
840	parent = self.GetParent()
841	parent.Raise()
842	self.EndModal(wx.ID_CANCEL)
843
844	class SingleFloatDialog(wx.Dialog):
845	'Dialog to obtain a single float value from user'
846	def __init__(self,parent,title,prompt,value,limits=[0.,1.],format='%.5g'):
847	wx.Dialog.__init__(self,parent,-1,title,
848	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
849	self.panel = wx.Panel(self) #just a dummy - gets destroyed in Draw!
850	self.limits = limits
851	self.value = value
852	self.prompt = prompt
853	self.format = format
854	self.Draw()
855
856	def Draw(self):
857
858	def OnValItem(event):
859	try:
860	val = float(valItem.GetValue())
861	if val < self.limits[0] or val > self.limits[1]:
862	raise ValueError
863	except ValueError:
864	val = self.value
865	self.value = val
866	valItem.SetValue(self.format%(self.value))
867
868	self.panel.Destroy()
869	self.panel = wx.Panel(self)
870	mainSizer = wx.BoxSizer(wx.VERTICAL)
871	mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
872	valItem = wx.TextCtrl(self.panel,-1,value=self.format%(self.value),style=wx.TE_PROCESS_ENTER)
873	mainSizer.Add(valItem,0,wx.ALIGN_CENTER)
874	valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
875	valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
876	OkBtn = wx.Button(self.panel,-1,"Ok")
877	OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
878	CancelBtn = wx.Button(self.panel,-1,'Cancel')
879	CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
880	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
881	btnSizer.Add((20,20),1)
882	btnSizer.Add(OkBtn)
883	btnSizer.Add(CancelBtn)
884	btnSizer.Add((20,20),1)
885	mainSizer.Add(btnSizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP, 10)
886	self.panel.SetSizer(mainSizer)
887	self.panel.Fit()
888	self.Fit()
889
890	def GetValue(self):
891	return self.value
892
893	def OnOk(self,event):
894	parent = self.GetParent()
895	parent.Raise()
896	self.EndModal(wx.ID_OK)
897
898	def OnCancel(self,event):
899	parent = self.GetParent()
900	parent.Raise()
901	self.EndModal(wx.ID_CANCEL)
902
903	################################################################################
904	class SingleStringDialog(wx.Dialog):
905	'''Dialog to obtain a single string value from user
906
907	:param wx.Frame parent: name of parent frame
908	:param str title: title string for dialog
909	:param str prompt: string to tell use what they are inputting
910	:param str value: default input value, if any
911	'''
912	def __init__(self,parent,title,prompt,value='',size=(200,-1)):
913	wx.Dialog.__init__(self,parent,wx.ID_ANY,title,
914	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
915	self.value = value
916	self.prompt = prompt
917	self.CenterOnParent()
918	self.panel = wx.Panel(self)
919	mainSizer = wx.BoxSizer(wx.VERTICAL)
920	mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
921	self.valItem = wx.TextCtrl(self.panel,-1,value=str(self.value),size=size)
922	mainSizer.Add(self.valItem,0,wx.ALIGN_CENTER)
923	btnsizer = wx.StdDialogButtonSizer()
924	OKbtn = wx.Button(self.panel, wx.ID_OK)
925	OKbtn.SetDefault()
926	btnsizer.AddButton(OKbtn)
927	btn = wx.Button(self.panel, wx.ID_CANCEL)
928	btnsizer.AddButton(btn)
929	btnsizer.Realize()
930	mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
931	self.panel.SetSizer(mainSizer)
932	self.panel.Fit()
933	self.Fit()
934
935	def Show(self):
936	'''Use this method after creating the dialog to post it
937	:returns: True if the user pressed OK; False if the User pressed Cancel
938	'''
939	if self.ShowModal() == wx.ID_OK:
940	self.value = self.valItem.GetValue()
941	return True
942	else:
943	return False
944
945	def GetValue(self):
946	'''Use this method to get the value entered by the user
947	:returns: string entered by user
948	'''
949	return self.value
950
951	################################################################################
952	def ItemSelector(ChoiceList, ParentFrame=None,
953	title='Select an item',
954	size=None, header='Item Selector',
955	useCancel=True):
956	''' Provide a wx dialog to select a single item from list of choices
957
958	:param list ChoiceList: a list of choices where one will be selected
959	:param wx.Frame ParentFrame: Name of parent frame (default None)
960	:param str title: heading above list of choices (default 'Select an item')
961	:param wx.Size size: Size for dialog to be created (default None -- size as needed)
962	:param str header: Title to place on window frame (default 'Item Selector')
963	:param bool useCancel: If True (default) both the OK and Cancel buttons are offered
964
965	:returns: the selection index or None
966	'''
967	if useCancel:
968	dlg = wx.SingleChoiceDialog(
969	ParentFrame,title, header, ChoiceList)
970	else:
971	dlg = wx.SingleChoiceDialog(
972	ParentFrame,title, header,ChoiceList,
973	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER\|wx.OK\|wx.CENTRE)
974	if size: dlg.SetSize(size)
975	if dlg.ShowModal() == wx.ID_OK:
976	sel = dlg.GetSelection()
977	return sel
978	else:
979	return None
980	dlg.Destroy()
981
982	################################################################################
983	class GridFractionEditor(wg.PyGridCellEditor):
984	'''A grid cell editor class that allows entry of values as fractions as well
985	as sine and cosine values [as s() and c()]
986	'''
987	def __init__(self,grid):
988	wg.PyGridCellEditor.__init__(self)
989
990	def Create(self, parent, id, evtHandler):
991	self._tc = wx.TextCtrl(parent, id, "")
992	self._tc.SetInsertionPoint(0)
993	self.SetControl(self._tc)
994
995	if evtHandler:
996	self._tc.PushEventHandler(evtHandler)
997
998	self._tc.Bind(wx.EVT_CHAR, self.OnChar)
999
1000	def SetSize(self, rect):
1001	self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
1002	wx.SIZE_ALLOW_MINUS_ONE)
1003
1004	def BeginEdit(self, row, col, grid):
1005	self.startValue = grid.GetTable().GetValue(row, col)
1006	self._tc.SetValue(str(self.startValue))
1007	self._tc.SetInsertionPointEnd()
1008	self._tc.SetFocus()
1009	self._tc.SetSelection(0, self._tc.GetLastPosition())
1010
1011	def EndEdit(self, row, col, grid):
1012	changed = False
1013
1014	val = self._tc.GetValue().lower()
1015
1016	if val != self.startValue:
1017	changed = True
1018	neg = False
1019	if '-' in val:
1020	neg = True
1021	if '/' in val and '.' not in val:
1022	val += '.'
1023	elif 's' in val and not 'sind(' in val:
1024	if neg:
1025	val = '-sind('+val.strip('-s')+')'
1026	else:
1027	val = 'sind('+val.strip('s')+')'
1028	elif 'c' in val and not 'cosd(' in val:
1029	if neg:
1030	val = '-cosd('+val.strip('-c')+')'
1031	else:
1032	val = 'cosd('+val.strip('c')+')'
1033	try:
1034	val = float(eval(val))
1035	except (SyntaxError,NameError):
1036	val = self.startValue
1037	grid.GetTable().SetValue(row, col, val) # update the table
1038
1039	self.startValue = ''
1040	self._tc.SetValue('')
1041	return changed
1042
1043	def Reset(self):
1044	self._tc.SetValue(self.startValue)
1045	self._tc.SetInsertionPointEnd()
1046
1047	def Clone(self):
1048	return GridFractionEditor(grid)
1049
1050	def StartingKey(self, evt):
1051	self.OnChar(evt)
1052	if evt.GetSkipped():
1053	self._tc.EmulateKeyPress(evt)
1054
1055	def OnChar(self, evt):
1056	key = evt.GetKeyCode()
1057	if key == 15:
1058	return
1059	if key > 255:
1060	evt.Skip()
1061	return
1062	char = chr(key)
1063	if char in '.+-/0123456789cosind()':
1064	self._tc.WriteText(char)
1065	else:
1066	evt.Skip()
1067
1068	################################################################################
1069	class MyHelp(wx.Menu):
1070	'''
1071	A class that creates the contents of a help menu.
1072	The menu will start with two entries:
1073
1074	* 'Help on <helpType>': where helpType is a reference to an HTML page to
1075	be opened
1076	* About: opens an About dialog using OnHelpAbout. N.B. on the Mac this
1077	gets moved to the App menu to be consistent with Apple style.
1078
1079	NOTE: for this to work properly with respect to system menus, the title
1080	for the menu must be &Help, or it will not be processed properly:
1081
1082	::
1083
1084	menu.Append(menu=MyHelp(self,...),title="&Help")
1085
1086	'''
1087	def __init__(self,frame,helpType=None,helpLbl=None,morehelpitems=[],title=''):
1088	wx.Menu.__init__(self,title)
1089	self.HelpById = {}
1090	self.frame = frame
1091	self.Append(help='', id=wx.ID_ABOUT, kind=wx.ITEM_NORMAL,
1092	text='&About GSAS-II')
1093	frame.Bind(wx.EVT_MENU, self.OnHelpAbout, id=wx.ID_ABOUT)
1094	if GSASIIpath.whichsvn():
1095	helpobj = self.Append(
1096	help='', id=wx.ID_ANY, kind=wx.ITEM_NORMAL,
1097	text='&Check for updates')
1098	frame.Bind(wx.EVT_MENU, self.OnCheckUpdates, helpobj)
1099	for lbl,indx in morehelpitems:
1100	helpobj = self.Append(text=lbl,
1101	id=wx.ID_ANY, kind=wx.ITEM_NORMAL)
1102	frame.Bind(wx.EVT_MENU, self.OnHelpById, helpobj)
1103	self.HelpById[helpobj.GetId()] = indx
1104	# add a help item only when helpType is specified
1105	if helpType is not None:
1106	self.AppendSeparator()
1107	if helpLbl is None: helpLbl = helpType
1108	helpobj = self.Append(text='Help on '+helpLbl,
1109	id=wx.ID_ANY, kind=wx.ITEM_NORMAL)
1110	frame.Bind(wx.EVT_MENU, self.OnHelpById, helpobj)
1111	self.HelpById[helpobj.GetId()] = helpType
1112
1113	def OnHelpById(self,event):
1114	'''Called when Help on... is pressed in a menu. Brings up
1115	a web page for documentation.
1116	'''
1117	helpType = self.HelpById.get(event.GetId())
1118	if helpType is None:
1119	print 'Error: help lookup failed!',event.GetEventObject()
1120	print 'id=',event.GetId()
1121	else:
1122	ShowHelp(helpType,self.frame)
1123
1124	def OnHelpAbout(self, event):
1125	"Display an 'About GSAS-II' box"
1126	global __version__
1127	info = wx.AboutDialogInfo()
1128	info.Name = 'GSAS-II'
1129	info.Version = __version__ + ' Revision '+str(GSASIIpath.GetVersionNumber())
1130	info.Copyright = '''
1131	Robert B. Von Dreele & Brian H. Toby
1132	Argonne National Laboratory(C)
1133	This product includes software developed
1134	by the UChicago Argonne, LLC, as
1135	Operator of Argonne National Laboratory.
1136	Please cite:
1137	B.H. Toby & R.B. Von Dreele, J. Appl. Cryst. 46, 544-549 (2013) '''
1138	info.Description = '''
1139	General Structure Analysis System - GSAS-II
1140	'''
1141	wx.AboutBox(info)
1142
1143	def OnCheckUpdates(self,event):
1144	'''Check if the GSAS-II repository has an update for the current source files
1145	and perform that update if requested.
1146	'''
1147	if not GSASIIpath.whichsvn():
1148	dlg = wx.MessageDialog(self,'No Subversion','Cannot update GSAS-II because subversion (svn) '+
1149	'was not found.'
1150	,wx.OK)
1151	dlg.ShowModal()
1152	return
1153	wx.BeginBusyCursor()
1154	local = GSASIIpath.svnGetRev()
1155	if local is None:
1156	wx.EndBusyCursor()
1157	dlg = wx.MessageDialog(self.frame,
1158	'Unable to run subversion on the GSAS-II current directory. Is GSAS-II installed correctly?',
1159	'Subversion error',
1160	wx.OK)
1161	dlg.ShowModal()
1162	return
1163	print 'Installed GSAS-II version: '+local
1164	repos = GSASIIpath.svnGetRev(local=False)
1165	wx.EndBusyCursor()
1166	if repos is None:
1167	dlg = wx.MessageDialog(self.frame,
1168	'Unable to access the GSAS-II server. Is this computer on the internet?',
1169	'Server unavailable',
1170	wx.OK)
1171	dlg.ShowModal()
1172	return
1173	print 'GSAS-II version on server: '+repos
1174	if local == repos:
1175	dlg = wx.MessageDialog(self.frame,
1176	'GSAS-II is up-to-date. Version '+local+' is already loaded.',
1177	'GSAS-II Up-to-date',
1178	wx.OK)
1179	dlg.ShowModal()
1180	return
1181	mods = GSASIIpath.svnFindLocalChanges()
1182	if mods:
1183	dlg = wx.MessageDialog(self.frame,
1184	'You have version '+local+
1185	' of GSAS-II installed, but the current version is '+repos+
1186	'. However, you have modified '+str(len(mods))+
1187	' file(s) on your local computer have been modified.'
1188	' Updating could wipe out your local changes. Press OK to start an update:',
1189	'Local GSAS-II Mods',
1190	wx.OK\|wx.CANCEL)
1191	if dlg.ShowModal() != wx.ID_OK: return
1192	else:
1193	dlg = wx.MessageDialog(self.frame,
1194	'You have version '+local+
1195	' of GSAS-II installed, but the current version is '+repos+
1196	'. Press OK to start an update:',
1197	'GSAS-II Updates',
1198	wx.OK\|wx.CANCEL)
1199	if dlg.ShowModal() != wx.ID_OK: return
1200	print 'start updates'
1201	wx.BeginBusyCursor()
1202	moddict = GSASIIpath.svnUpdateDir()
1203	wx.EndBusyCursor()
1204	if moddict is None:
1205	dlg = wx.MessageDialog(self.frame,
1206	'Error accessing the GSAS-II server or performing the update. '+
1207	'Try again later or perform a manual update',
1208	'Update Error',
1209	wx.OK)
1210	dlg.ShowModal()
1211	return
1212	modsbytype = {}
1213	for key in moddict:
1214	typ = moddict[key]
1215	if modsbytype.get(typ) is None:
1216	modsbytype[typ] = []
1217	modsbytype[typ].append(key)
1218	msg = 'Update was completed. Changes will take effect when GSAS-II is next updated. The following files were updated, ordered by status:'
1219	for key in modsbytype:
1220	msg += '\n' + key + ':\n\t'
1221	for fil in modsbytype:
1222	msg += fil + ', '
1223	dlg = wx.MessageDialog(self.frame,msg, 'Update Completed', wx.OK)
1224	dlg.ShowModal()
1225	return
1226
1227	################################################################################
1228	class AddHelp(wx.Menu):
1229	'''This class a single entry for the help menu (used on the Mac only):
1230	'Help on <helpType>': where helpType is a reference to an HTML page to
1231	be opened
1232
1233	NOTE: the title when appending this menu should be '&Help' so the wx handles
1234	it correctly.
1235	'''
1236	def __init__(self,frame,helpType,helpLbl=None,title=''):
1237	wx.Menu.__init__(self,title)
1238	self.frame = frame
1239	if helpLbl is None: helpLbl = helpType
1240	# add a help item only when helpType is specified
1241	helpobj = self.Append(text='Help on '+helpLbl,
1242	id=wx.ID_ANY, kind=wx.ITEM_NORMAL)
1243	frame.Bind(wx.EVT_MENU, self.OnHelpById, helpobj)
1244	self.HelpById = helpType
1245
1246	def OnHelpById(self,event):
1247	'''Called when Help on... is pressed in a menu. Brings up
1248	a web page for documentation.
1249	'''
1250	ShowHelp(self.HelpById,self.frame)
1251
1252	################################################################################
1253	class MyHtmlPanel(wx.Panel):
1254	'''Defines a panel to display Help information'''
1255	def __init__(self, frame, id):
1256	self.frame = frame
1257	wx.Panel.__init__(self, frame, id)
1258	sizer = wx.BoxSizer(wx.VERTICAL)
1259	back = wx.Button(self, -1, "Back")
1260	back.Bind(wx.EVT_BUTTON, self.OnBack)
1261	self.htmlwin = G2HtmlWindow(self, id, size=(750,450))
1262	sizer.Add(self.htmlwin, 1,wx.EXPAND)
1263	sizer.Add(back, 0, wx.ALIGN_LEFT, 0)
1264	self.SetSizer(sizer)
1265	sizer.Fit(frame)
1266	self.Bind(wx.EVT_SIZE,self.OnHelpSize)
1267	def OnHelpSize(self,event): #does the job but weirdly!!
1268	anchor = self.htmlwin.GetOpenedAnchor()
1269	if anchor:
1270	self.htmlwin.ScrollToAnchor(anchor)
1271	wx.CallAfter(self.htmlwin.ScrollToAnchor,anchor)
1272	event.Skip()
1273	def OnBack(self, event):
1274	self.htmlwin.HistoryBack()
1275	def LoadFile(self,file):
1276	pos = file.rfind('#')
1277	if pos != -1:
1278	helpfile = file[:pos]
1279	helpanchor = file[pos+1:]
1280	else:
1281	helpfile = file
1282	helpanchor = None
1283	self.htmlwin.LoadPage(helpfile)
1284	if helpanchor is not None:
1285	self.htmlwin.ScrollToAnchor(helpanchor)
1286	xs,ys = self.htmlwin.GetViewStart()
1287	self.htmlwin.Scroll(xs,ys-1)
1288
1289	class G2HtmlWindow(wx.html.HtmlWindow):
1290	'''Displays help information in a primitive HTML browser type window
1291	'''
1292	def __init__(self, parent, args, *kwargs):
1293	self.parent = parent
1294	wx.html.HtmlWindow.__init__(self, parent, args, *kwargs)
1295	def LoadPage(self, args, *kwargs):
1296	wx.html.HtmlWindow.LoadPage(self, args, *kwargs)
1297	self.TitlePage()
1298	def OnLinkClicked(self, args, *kwargs):
1299	wx.html.HtmlWindow.OnLinkClicked(self, args, *kwargs)
1300	xs,ys = self.GetViewStart()
1301	self.Scroll(xs,ys-1)
1302	self.TitlePage()
1303	def HistoryBack(self, args, *kwargs):
1304	wx.html.HtmlWindow.HistoryBack(self, args, *kwargs)
1305	self.TitlePage()
1306	def TitlePage(self):
1307	self.parent.frame.SetTitle(self.GetOpenedPage() + ' -- ' +
1308	self.GetOpenedPageTitle())
1309
1310	################################################################################
1311	class DataFrame(wx.Frame):
1312	'''Create the dataframe window and all the entries in menus.
1313	The binding is for the menus is not done here, but rather is done
1314	where the functions can be accessed (in various GSASII*GUI modules).
1315	'''
1316	def Bind(self,args,*kwargs):
1317	'''Override the Bind() function: on the Mac the binding is to
1318	the main window, so that menus operate with any window on top.
1319	For other platforms, call the default wx.Frame Bind()
1320	'''
1321	if sys.platform == "darwin": # mac
1322	self.G2frame.Bind(args,*kwargs)
1323	else:
1324	wx.Frame.Bind(self,args,*kwargs)
1325
1326	def PrefillDataMenu(self,menu,helpType,helpLbl=None,empty=False):
1327	'''Create the "standard" part of data frame menus. Note that on Linux and
1328	Windows nothing happens here. On Mac, this menu duplicates the
1329	tree menu, but adds an extra help command for the data item and a separator.
1330	'''
1331	self.datamenu = menu
1332	self.helpType = helpType
1333	self.helpLbl = helpLbl
1334	if sys.platform == "darwin": # mac
1335	self.G2frame.FillMainMenu(menu) # add the data tree menu items
1336	if not empty:
1337	menu.Append(wx.Menu(title=''),title='\|') # add a separator
1338
1339	def PostfillDataMenu(self,empty=False):
1340	'''Create the "standard" part of data frame menus. Note that on Linux and
1341	Windows, this is the standard help Menu. On Mac, this menu duplicates the
1342	tree menu, but adds an extra help command for the data item and a separator.
1343	'''
1344	menu = self.datamenu
1345	helpType = self.helpType
1346	helpLbl = self.helpLbl
1347	if sys.platform == "darwin": # mac
1348	if not empty:
1349	menu.Append(wx.Menu(title=''),title='\|') # add another separator
1350	menu.Append(AddHelp(self.G2frame,helpType=helpType, helpLbl=helpLbl),
1351	title='&Help')
1352	else: # other
1353	menu.Append(menu=MyHelp(self,helpType=helpType, helpLbl=helpLbl),
1354	title='&Help')
1355
1356	def _init_menus(self):
1357	'define all GSAS-II data frame menus'
1358
1359	# for use where no menu or data frame help is provided
1360	self.BlankMenu = wx.MenuBar()
1361
1362	# Controls
1363	self.ControlsMenu = wx.MenuBar()
1364	self.PrefillDataMenu(self.ControlsMenu,helpType='Controls',empty=True)
1365	self.PostfillDataMenu(empty=True)
1366
1367	# Notebook
1368	self.DataNotebookMenu = wx.MenuBar()
1369	self.PrefillDataMenu(self.DataNotebookMenu,helpType='Notebook',empty=True)
1370	self.PostfillDataMenu(empty=True)
1371
1372	# Comments
1373	self.DataCommentsMenu = wx.MenuBar()
1374	self.PrefillDataMenu(self.DataCommentsMenu,helpType='Comments',empty=True)
1375	self.PostfillDataMenu(empty=True)
1376
1377	# Constraints
1378	self.ConstraintMenu = wx.MenuBar()
1379	self.PrefillDataMenu(self.ConstraintMenu,helpType='Constraints')
1380	self.ConstraintEdit = wx.Menu(title='')
1381	self.ConstraintMenu.Append(menu=self.ConstraintEdit, title='Edit')
1382	self.ConstraintEdit.Append(id=wxID_HOLDADD, kind=wx.ITEM_NORMAL,text='Add hold',
1383	help='Add hold on a parameter value')
1384	self.ConstraintEdit.Append(id=wxID_EQUIVADD, kind=wx.ITEM_NORMAL,text='Add equivalence',
1385	help='Add equivalence between parameter values')
1386	self.ConstraintEdit.Append(id=wxID_CONSTRAINTADD, kind=wx.ITEM_NORMAL,text='Add constraint',
1387	help='Add constraint on parameter values')
1388	self.ConstraintEdit.Append(id=wxID_FUNCTADD, kind=wx.ITEM_NORMAL,text='Add New Var',
1389	help='Add variable composed of existing parameter')
1390	self.PostfillDataMenu()
1391
1392	# Rigid bodies
1393	self.VectorRBEdit = wx.Menu(title='')
1394	self.VectorRBEdit.Append(id=wxID_RIGIDBODYADD, kind=wx.ITEM_NORMAL,text='Add rigid body',
1395	help='Add vector rigid body')
1396	self.ResidueRBMenu = wx.Menu(title='')
1397	self.ResidueRBMenu.Append(id=wxID_RIGIDBODYIMPORT, kind=wx.ITEM_NORMAL,text='Import XYZ',
1398	help='Import rigid body XYZ from file')
1399	self.ResidueRBMenu.Append(id=wxID_RESIDUETORSSEQ, kind=wx.ITEM_NORMAL,text='Define sequence',
1400	help='Define torsion sequence')
1401	self.ResidueRBMenu.Append(id=wxID_RIGIDBODYADD, kind=wx.ITEM_NORMAL,text='Import residues',
1402	help='Import residue rigid bodies from macro file')
1403
1404	self.RigidBodyMenu = wx.MenuBar()
1405	self.PrefillDataMenu(self.RigidBodyMenu,helpType='Rigid bodies')
1406	self.RigidBodyMenu.Append(menu=self.VectorRBEdit, title='Edit')
1407	self.PostfillDataMenu()
1408
1409	# Restraints
1410	self.RestraintEdit = wx.Menu(title='')
1411	self.RestraintEdit.Append(id=wxID_RESTSELPHASE, kind=wx.ITEM_NORMAL,text='Select phase',
1412	help='Select phase')
1413	self.RestraintEdit.Append(id=wxID_RESTRAINTADD, kind=wx.ITEM_NORMAL,text='Add restraints',
1414	help='Add restraints')
1415	self.RestraintEdit.Enable(wxID_RESTRAINTADD,True) #gets disenabled if macromolecule phase
1416	self.RestraintEdit.Append(id=wxID_AARESTRAINTADD, kind=wx.ITEM_NORMAL,text='Add residue restraints',
1417	help='Add residue based restraints for macromolecules from macro file')
1418	self.RestraintEdit.Enable(wxID_AARESTRAINTADD,False) #gets enabled if macromolecule phase
1419	self.RestraintEdit.Append(id=wxID_AARESTRAINTPLOT, kind=wx.ITEM_NORMAL,text='Plot residue restraints',
1420	help='Plot selected residue based restraints for macromolecules from macro file')
1421	self.RestraintEdit.Enable(wxID_AARESTRAINTPLOT,False) #gets enabled if macromolecule phase
1422	self.RestraintEdit.Append(id=wxID_RESRCHANGEVAL, kind=wx.ITEM_NORMAL,text='Change value',
1423	help='Change observed value')
1424	self.RestraintEdit.Append(id=wxID_RESTCHANGEESD, kind=wx.ITEM_NORMAL,text='Change esd',
1425	help='Change esd in observed value')
1426	self.RestraintEdit.Append(id=wxID_RESTDELETE, kind=wx.ITEM_NORMAL,text='Delete restraints',
1427	help='Delete selected restraints')
1428
1429	self.RestraintMenu = wx.MenuBar()
1430	self.PrefillDataMenu(self.RestraintMenu,helpType='Restraints')
1431	self.RestraintMenu.Append(menu=self.RestraintEdit, title='Edit')
1432	self.PostfillDataMenu()
1433
1434	# Sequential results
1435	self.SequentialMenu = wx.MenuBar()
1436	self.PrefillDataMenu(self.SequentialMenu,helpType='Sequential',helpLbl='Sequential Refinement')
1437	self.SequentialFile = wx.Menu(title='')
1438	self.SequentialMenu.Append(menu=self.SequentialFile, title='File')
1439	self.SequentialFile.Append(id=wxID_SAVESEQSEL, kind=wx.ITEM_NORMAL,text='Save...',
1440	help='Save selected sequential refinement results')
1441	self.PostfillDataMenu()
1442
1443	# PDR
1444	self.ErrorMenu = wx.MenuBar()
1445	self.PrefillDataMenu(self.ErrorMenu,helpType='PWD Analysis',helpLbl='Powder Fit Error Analysis')
1446	self.ErrorAnal = wx.Menu(title='')
1447	self.ErrorMenu.Append(menu=self.ErrorAnal,title='Analysis')
1448	self.ErrorAnal.Append(id=wxID_PWDANALYSIS,kind=wx.ITEM_NORMAL,text='Analyze',
1449	help='Error analysis on powder pattern')
1450	self.PostfillDataMenu()
1451
1452	# PDR / Limits
1453	self.LimitMenu = wx.MenuBar()
1454	self.PrefillDataMenu(self.LimitMenu,helpType='Limits')
1455	self.LimitEdit = wx.Menu(title='')
1456	self.LimitMenu.Append(menu=self.LimitEdit, title='File')
1457	self.LimitEdit.Append(id=wxID_LIMITCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1458	help='Copy limits to other histograms')
1459	self.PostfillDataMenu()
1460
1461	# PDR / Background
1462	self.BackMenu = wx.MenuBar()
1463	self.PrefillDataMenu(self.BackMenu,helpType='Background')
1464	self.BackEdit = wx.Menu(title='')
1465	self.BackMenu.Append(menu=self.BackEdit, title='File')
1466	self.BackEdit.Append(id=wxID_BACKCOPY, kind=wx.ITEM_NORMAL,text='Copy',
1467	help='Copy background parameters to other histograms')
1468	self.BackEdit.Append(id=wxID_BACKFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1469	help='Copy background refinement flags to other histograms')
1470	self.PostfillDataMenu()
1471
1472	# PDR / Instrument Parameters
1473	self.InstMenu = wx.MenuBar()
1474	self.PrefillDataMenu(self.InstMenu,helpType='Instrument Parameters')
1475	self.InstEdit = wx.Menu(title='')
1476	self.InstMenu.Append(menu=self.InstEdit, title='Operations')
1477	self.InstEdit.Append(help='Reset instrument profile parameters to default',
1478	id=wxID_INSTLOAD, kind=wx.ITEM_NORMAL,text='Load profile...')
1479	self.InstEdit.Append(help='Load instrument profile parameters from file',
1480	id=wxID_INSTSAVE, kind=wx.ITEM_NORMAL,text='Save profile...')
1481	self.InstEdit.Append(help='Save instrument profile parameters to file',
1482	id=wxID_INSTPRMRESET, kind=wx.ITEM_NORMAL,text='Reset profile')
1483	self.InstEdit.Append(help='Copy instrument profile parameters to other histograms',
1484	id=wxID_INSTCOPY, kind=wx.ITEM_NORMAL,text='Copy')
1485	self.InstEdit.Append(id=wxID_INSTFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1486	help='Copy instrument parameter refinement flags to other histograms')
1487	# self.InstEdit.Append(help='Change radiation type (Ka12 - synch)',
1488	# id=wxID_CHANGEWAVETYPE, kind=wx.ITEM_NORMAL,text='Change radiation')
1489	self.PostfillDataMenu()
1490
1491	# PDR / Sample Parameters
1492	self.SampleMenu = wx.MenuBar()
1493	self.PrefillDataMenu(self.SampleMenu,helpType='Sample Parameters')
1494	self.SampleEdit = wx.Menu(title='')
1495	self.SampleMenu.Append(menu=self.SampleEdit, title='File')
1496	self.SampleEdit.Append(id=wxID_SAMPLELOAD, kind=wx.ITEM_NORMAL,text='Load',
1497	help='Load sample parameters from file')
1498	self.SampleEdit.Append(id=wxID_SAMPLESAVE, kind=wx.ITEM_NORMAL,text='Save',
1499	help='Save sample parameters to file')
1500	self.SampleEdit.Append(id=wxID_SAMPLECOPY, kind=wx.ITEM_NORMAL,text='Copy',
1501	help='Copy refinable sample parameters to other histograms')
1502	self.SampleEdit.Append(id=wxID_SAMPLEFLAGCOPY, kind=wx.ITEM_NORMAL,text='Copy flags',
1503	help='Copy sample parameter refinement flags to other histograms')
1504	self.PostfillDataMenu()
1505
1506	# PDR / Peak List
1507	self.PeakMenu = wx.MenuBar()
1508	self.PrefillDataMenu(self.PeakMenu,helpType='Peak List')
1509	self.PeakEdit = wx.Menu(title='')
1510	self.PeakMenu.Append(menu=self.PeakEdit, title='Peak Fitting')
1511	self.AutoSearch = self.PeakEdit.Append(help='Automatic peak search',
1512	id=wxID_AUTOSEARCH, kind=wx.ITEM_NORMAL,text='Auto search')
1513	self.UnDo = self.PeakEdit.Append(help='Undo last least squares refinement',
1514	id=wxID_UNDO, kind=wx.ITEM_NORMAL,text='UnDo')
1515	self.PeakFit = self.PeakEdit.Append(id=wxID_LSQPEAKFIT, kind=wx.ITEM_NORMAL,text='LSQ PeakFit',
1516	help='Peak fitting via least-squares' )
1517	self.PFOneCycle = self.PeakEdit.Append(id=wxID_LSQONECYCLE, kind=wx.ITEM_NORMAL,text='LSQ one cycle',
1518	help='One cycle of Peak fitting via least-squares' )
1519	self.PeakEdit.Append(id=wxID_RESETSIGGAM, kind=wx.ITEM_NORMAL,
1520	text='Reset sig and gam',help='Reset sigma and gamma to global fit' )
1521	self.PeakEdit.Append(id=wxID_CLEARPEAKS, kind=wx.ITEM_NORMAL,text='Clear peaks',
1522	help='Clear the peak list' )
1523	self.PostfillDataMenu()
1524	self.UnDo.Enable(False)
1525	self.PeakFit.Enable(False)
1526	self.PFOneCycle.Enable(False)
1527
1528	# PDR / Index Peak List
1529	self.IndPeaksMenu = wx.MenuBar()
1530	self.PrefillDataMenu(self.IndPeaksMenu,helpType='Index Peak List')
1531	self.IndPeaksEdit = wx.Menu(title='')
1532	self.IndPeaksMenu.Append(menu=self.IndPeaksEdit,title='Operations')
1533	self.IndPeaksEdit.Append(help='Load/Reload index peaks from peak list',id=wxID_INDXRELOAD,
1534	kind=wx.ITEM_NORMAL,text='Load/Reload')
1535	self.PostfillDataMenu()
1536
1537	# PDR / Unit Cells List
1538	self.IndexMenu = wx.MenuBar()
1539	self.PrefillDataMenu(self.IndexMenu,helpType='Unit Cells List')
1540	self.IndexEdit = wx.Menu(title='')
1541	self.IndexMenu.Append(menu=self.IndexEdit, title='Cell Index/Refine')
1542	self.IndexPeaks = self.IndexEdit.Append(help='', id=wxID_INDEXPEAKS, kind=wx.ITEM_NORMAL,
1543	text='Index Cell')
1544	self.CopyCell = self.IndexEdit.Append( id=wxID_COPYCELL, kind=wx.ITEM_NORMAL,text='Copy Cell',
1545	help='Copy selected unit cell from indexing to cell refinement fields')
1546	self.RefineCell = self.IndexEdit.Append( id=wxID_REFINECELL, kind=wx.ITEM_NORMAL,
1547	text='Refine Cell',help='Refine unit cell parameters from indexed peaks')
1548	self.MakeNewPhase = self.IndexEdit.Append( id=wxID_MAKENEWPHASE, kind=wx.ITEM_NORMAL,
1549	text='Make new phase',help='Make new phase from selected unit cell')
1550	self.PostfillDataMenu()
1551	self.IndexPeaks.Enable(False)
1552	self.CopyCell.Enable(False)
1553	self.RefineCell.Enable(False)
1554	self.MakeNewPhase.Enable(False)
1555
1556	# PDR / Reflection Lists
1557	self.ReflMenu = wx.MenuBar()
1558	self.PrefillDataMenu(self.ReflMenu,helpType='Reflection List')
1559	self.ReflEdit = wx.Menu(title='')
1560	self.ReflMenu.Append(menu=self.ReflEdit, title='Reflection List')
1561	self.SelectPhase = self.ReflEdit.Append(help='Select phase for reflection list',id=wxID_SELECTPHASE,
1562	kind=wx.ITEM_NORMAL,text='Select phase')
1563	self.PostfillDataMenu()
1564
1565	# IMG / Image Controls
1566	self.ImageMenu = wx.MenuBar()
1567	self.PrefillDataMenu(self.ImageMenu,helpType='Image Controls')
1568	self.ImageEdit = wx.Menu(title='')
1569	self.ImageMenu.Append(menu=self.ImageEdit, title='Operations')
1570	self.ImageEdit.Append(help='Calibrate detector by fitting to calibrant lines',
1571	id=wxID_IMCALIBRATE, kind=wx.ITEM_NORMAL,text='Calibrate')
1572	self.ImageEdit.Append(help='Recalibrate detector by fitting to calibrant lines',
1573	id=wxID_IMRECALIBRATE, kind=wx.ITEM_NORMAL,text='Recalibrate')
1574	self.ImageEdit.Append(help='Clear calibration data points and rings',id=wxID_IMCLEARCALIB,
1575	kind=wx.ITEM_NORMAL,text='Clear calibration')
1576	self.ImageEdit.Append(help='Integrate selected image',id=wxID_IMINTEGRATE,
1577	kind=wx.ITEM_NORMAL,text='Integrate')
1578	self.ImageEdit.Append(help='Integrate all images selected from list',id=wxID_INTEGRATEALL,
1579	kind=wx.ITEM_NORMAL,text='Integrate all')
1580	self.ImageEdit.Append(help='Copy image controls to other images',
1581	id=wxID_IMCOPYCONTROLS, kind=wx.ITEM_NORMAL,text='Copy Controls')
1582	self.ImageEdit.Append(help='Save image controls to file',
1583	id=wxID_IMSAVECONTROLS, kind=wx.ITEM_NORMAL,text='Save Controls')
1584	self.ImageEdit.Append(help='Load image controls from file',
1585	id=wxID_IMLOADCONTROLS, kind=wx.ITEM_NORMAL,text='Load Controls')
1586	self.PostfillDataMenu()
1587
1588	# IMG / Masks
1589	self.MaskMenu = wx.MenuBar()
1590	self.PrefillDataMenu(self.MaskMenu,helpType='Image Masks')
1591	self.MaskEdit = wx.Menu(title='')
1592	self.MaskMenu.Append(menu=self.MaskEdit, title='Operations')
1593	self.MaskEdit.Append(help='Copy mask to other images',
1594	id=wxID_MASKCOPY, kind=wx.ITEM_NORMAL,text='Copy mask')
1595	self.MaskEdit.Append(help='Save mask to file',
1596	id=wxID_MASKSAVE, kind=wx.ITEM_NORMAL,text='Save mask')
1597	self.MaskEdit.Append(help='Load mask from file',
1598	id=wxID_MASKLOAD, kind=wx.ITEM_NORMAL,text='Load mask')
1599	self.PostfillDataMenu()
1600
1601	# IMG / Stress/Strain
1602	self.StrStaMenu = wx.MenuBar()
1603	self.PrefillDataMenu(self.StrStaMenu,helpType='Stress/Strain')
1604	self.StrStaEdit = wx.Menu(title='')
1605	self.StrStaMenu.Append(menu=self.StrStaEdit, title='Operations')
1606	self.StrStaEdit.Append(help='Append d-zero for one ring',
1607	id=wxID_APPENDDZERO, kind=wx.ITEM_NORMAL,text='Append d-zero')
1608	self.StrStaEdit.Append(help='Fit stress/strain data',
1609	id=wxID_STRSTAFIT, kind=wx.ITEM_NORMAL,text='Fit stress/strain')
1610	self.StrStaEdit.Append(help='Copy stress/strain data to other images',
1611	id=wxID_STRSTACOPY, kind=wx.ITEM_NORMAL,text='Copy stress/strain')
1612	self.StrStaEdit.Append(help='Save stress/strain data to file',
1613	id=wxID_STRSTASAVE, kind=wx.ITEM_NORMAL,text='Save stress/strain')
1614	self.StrStaEdit.Append(help='Load stress/strain data from file',
1615	id=wxID_STRSTALOAD, kind=wx.ITEM_NORMAL,text='Load stress/strain')
1616	self.PostfillDataMenu()
1617
1618	# PDF / PDF Controls
1619	self.PDFMenu = wx.MenuBar()
1620	self.PrefillDataMenu(self.PDFMenu,helpType='PDF Controls')
1621	self.PDFEdit = wx.Menu(title='')
1622	self.PDFMenu.Append(menu=self.PDFEdit, title='PDF Controls')
1623	self.PDFEdit.Append(help='Add element to sample composition',id=wxID_PDFADDELEMENT, kind=wx.ITEM_NORMAL,
1624	text='Add element')
1625	self.PDFEdit.Append(help='Delete element from sample composition',id=wxID_PDFDELELEMENT, kind=wx.ITEM_NORMAL,
1626	text='Delete element')
1627	self.PDFEdit.Append(help='Copy PDF controls', id=wxID_PDFCOPYCONTROLS, kind=wx.ITEM_NORMAL,
1628	text='Copy controls')
1629	# self.PDFEdit.Append(help='Load PDF controls from file',id=wxID_PDFLOADCONTROLS, kind=wx.ITEM_NORMAL,
1630	# text='Load Controls')
1631	# self.PDFEdit.Append(help='Save PDF controls to file', id=wxID_PDFSAVECONTROLS, kind=wx.ITEM_NORMAL,
1632	# text='Save controls')
1633	self.PDFEdit.Append(help='Compute PDF', id=wxID_PDFCOMPUTE, kind=wx.ITEM_NORMAL,
1634	text='Compute PDF')
1635	self.PDFEdit.Append(help='Compute all PDFs', id=wxID_PDFCOMPUTEALL, kind=wx.ITEM_NORMAL,
1636	text='Compute all PDFs')
1637	self.PostfillDataMenu()
1638
1639	# Phase / General tab
1640	self.DataGeneral = wx.MenuBar()
1641	self.PrefillDataMenu(self.DataGeneral,helpType='General', helpLbl='Phase/General')
1642	self.GeneralCalc = wx.Menu(title='')
1643	self.DataGeneral.Append(menu=self.GeneralCalc,title='Compute')
1644	self.GeneralCalc.Append(help='Compute Fourier map',id=wxID_FOURCALC, kind=wx.ITEM_NORMAL,
1645	text='Fourier map')
1646	self.GeneralCalc.Append(help='Search Fourier map',id=wxID_FOURSEARCH, kind=wx.ITEM_NORMAL,
1647	text='Search map')
1648	self.GeneralCalc.Append(help='Run charge flipping',id=wxID_CHARGEFLIP, kind=wx.ITEM_NORMAL,
1649	text='Charge flipping')
1650	self.GeneralCalc.Append(help='Clear map',id=wxID_FOURCLEAR, kind=wx.ITEM_NORMAL,
1651	text='Clear map')
1652	self.PostfillDataMenu()
1653
1654	# Phase / Data tab
1655	self.DataMenu = wx.MenuBar()
1656	self.PrefillDataMenu(self.DataMenu,helpType='Data', helpLbl='Phase/Data')
1657	self.DataEdit = wx.Menu(title='')
1658	self.DataMenu.Append(menu=self.DataEdit, title='Edit')
1659	self.DataEdit.Append(id=wxID_PWDRADD, kind=wx.ITEM_NORMAL,text='Add powder histograms',
1660	help='Select new powder histograms to be used for this phase')
1661	self.DataEdit.Append(id=wxID_HKLFADD, kind=wx.ITEM_NORMAL,text='Add single crystal histograms',
1662	help='Select new single crystal histograms to be used for this phase')
1663	self.DataEdit.Append(id=wxID_DATADELETE, kind=wx.ITEM_NORMAL,text='Delete histograms',
1664	help='Delete histograms from use for this phase')
1665	self.PostfillDataMenu()
1666
1667	# Phase / Atoms tab
1668	self.AtomsMenu = wx.MenuBar()
1669	self.PrefillDataMenu(self.AtomsMenu,helpType='Atoms')
1670	self.AtomEdit = wx.Menu(title='')
1671	self.AtomCompute = wx.Menu(title='')
1672	self.AtomsMenu.Append(menu=self.AtomEdit, title='Edit')
1673	self.AtomsMenu.Append(menu=self.AtomCompute, title='Compute')
1674	self.AtomEdit.Append(id=wxID_ATOMSEDITADD, kind=wx.ITEM_NORMAL,text='Append atom',
1675	help='Appended as an H atom')
1676	self.AtomEdit.Append(id=wxID_ATOMSVIEWADD, kind=wx.ITEM_NORMAL,text='Append view point',
1677	help='Appended as an H atom')
1678	self.AtomEdit.Append(id=wxID_RBAPPEND, kind=wx.ITEM_NORMAL,text='Append rigid body',
1679	help='Append atoms for rigid body')
1680	self.AtomEdit.Append(id=wxID_ATOMSEDITINSERT, kind=wx.ITEM_NORMAL,text='Insert atom',
1681	help='Select atom row to insert before; inserted as an H atom')
1682	self.AtomEdit.Append(id=wxID_ATOMVIEWINSERT, kind=wx.ITEM_NORMAL,text='Insert view point',
1683	help='Select atom row to insert before; inserted as an H atom')
1684	self.AtomEdit.Append(id=wxID_ATOMMOVE, kind=wx.ITEM_NORMAL,text='Move atom to view point',
1685	help='Select single atom to move')
1686	self.AtomEdit.Append(id=wxID_ATOMSEDITDELETE, kind=wx.ITEM_NORMAL,text='Delete atom',
1687	help='Select atoms to delete first')
1688	self.AtomEdit.Append(id=wxID_ATOMSREFINE, kind=wx.ITEM_NORMAL,text='Set atom refinement flags',
1689	help='Select atoms to refine first')
1690	self.AtomEdit.Append(id=wxID_ATOMSMODIFY, kind=wx.ITEM_NORMAL,text='Modify atom parameters',
1691	help='Select atoms to modify first')
1692	self.AtomEdit.Append(id=wxID_ATOMSTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform atoms',
1693	help='Select atoms to transform first')
1694	self.AtomEdit.Append(id=wxID_RELOADDRAWATOMS, kind=wx.ITEM_NORMAL,text='Reload draw atoms',
1695	help='Reload atom drawing list')
1696	submenu = wx.Menu()
1697	self.AtomEdit.AppendMenu(wx.ID_ANY, 'Reimport atoms', submenu,
1698	help='Reimport atoms from file; sequence must match')
1699	# setup a cascade menu for the formats that have been defined
1700	self.ReImportMenuId = {} # points to readers for each menu entry
1701	for reader in self.G2frame.ImportPhaseReaderlist:
1702	item = submenu.Append(
1703	wx.ID_ANY,help=reader.longFormatName,
1704	kind=wx.ITEM_NORMAL,text='reimport coordinates from '+reader.formatName+' file')
1705	self.ReImportMenuId[item.GetId()] = reader
1706	item = submenu.Append(
1707	wx.ID_ANY,
1708	help='Reimport coordinates, try to determine format from file',
1709	kind=wx.ITEM_NORMAL,
1710	text='guess format from file')
1711	self.ReImportMenuId[item.GetId()] = None # try all readers
1712
1713	self.AtomCompute.Append(id=wxID_ATOMSDISAGL, kind=wx.ITEM_NORMAL,text='Distances && Angles',
1714	help='Compute distances & angles for selected atoms')
1715	self.PostfillDataMenu()
1716
1717	# Phase / Draw Options tab
1718	self.DataDrawOptions = wx.MenuBar()
1719	self.PrefillDataMenu(self.DataDrawOptions,helpType='Draw Options', helpLbl='Phase/Draw Options',empty=True)
1720	self.PostfillDataMenu(empty=True)
1721
1722	# Phase / Draw Atoms tab
1723	self.DrawAtomsMenu = wx.MenuBar()
1724	self.PrefillDataMenu(self.DrawAtomsMenu,helpType='Draw Atoms')
1725	self.DrawAtomEdit = wx.Menu(title='')
1726	self.DrawAtomCompute = wx.Menu(title='')
1727	self.DrawAtomRestraint = wx.Menu(title='')
1728	self.DrawAtomRigidBody = wx.Menu(title='')
1729	self.DrawAtomsMenu.Append(menu=self.DrawAtomEdit, title='Edit')
1730	self.DrawAtomsMenu.Append(menu=self.DrawAtomCompute,title='Compute')
1731	self.DrawAtomsMenu.Append(menu=self.DrawAtomRestraint, title='Restraints')
1732	self.DrawAtomsMenu.Append(menu=self.DrawAtomRigidBody, title='Rigid body')
1733	self.DrawAtomEdit.Append(id=wxID_DRAWATOMSTYLE, kind=wx.ITEM_NORMAL,text='Atom style',
1734	help='Select atoms first')
1735	self.DrawAtomEdit.Append(id=wxID_DRAWATOMLABEL, kind=wx.ITEM_NORMAL,text='Atom label',
1736	help='Select atoms first')
1737	self.DrawAtomEdit.Append(id=wxID_DRAWATOMCOLOR, kind=wx.ITEM_NORMAL,text='Atom color',
1738	help='Select atoms first')
1739	self.DrawAtomEdit.Append(id=wxID_DRAWATOMRESETCOLOR, kind=wx.ITEM_NORMAL,text='Reset atom colors',
1740	help='Resets all atom colors to defaults')
1741	self.DrawAtomEdit.Append(id=wxID_DRAWVIEWPOINT, kind=wx.ITEM_NORMAL,text='View point',
1742	help='View point is 1st atom selected')
1743	self.DrawAtomEdit.Append(id=wxID_DRAWADDEQUIV, kind=wx.ITEM_NORMAL,text='Add atoms',
1744	help='Add symmetry & cell equivalents to drawing set from selected atoms')
1745	self.DrawAtomEdit.Append(id=wxID_DRAWTRANSFORM, kind=wx.ITEM_NORMAL,text='Transform atoms',
1746	help='Transform selected atoms by symmetry & cell translations')
1747	self.DrawAtomEdit.Append(id=wxID_DRAWFILLCOORD, kind=wx.ITEM_NORMAL,text='Fill CN-sphere',
1748	help='Fill coordination sphere for selected atoms')
1749	self.DrawAtomEdit.Append(id=wxID_DRAWFILLCELL, kind=wx.ITEM_NORMAL,text='Fill unit cell',
1750	help='Fill unit cell with selected atoms')
1751	self.DrawAtomEdit.Append(id=wxID_DRAWDELETE, kind=wx.ITEM_NORMAL,text='Delete atoms',
1752	help='Delete atoms from drawing set')
1753	self.DrawAtomCompute.Append(id=wxID_DRAWDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
1754	help='Compute distance of selected atoms from view point')
1755	self.DrawAtomCompute.Append(id=wxID_DRAWDISAGLTOR, kind=wx.ITEM_NORMAL,text='Dist. Ang. Tors.',
1756	help='Compute distance, angle or torsion for 2-4 selected atoms')
1757	self.DrawAtomCompute.Append(id=wxID_DRAWPLANE, kind=wx.ITEM_NORMAL,text='Best plane',
1758	help='Compute best plane for 4+ selected atoms')
1759	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRBOND, kind=wx.ITEM_NORMAL,text='Add bond restraint',
1760	help='Add bond restraint for selected atoms (2)')
1761	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRANGLE, kind=wx.ITEM_NORMAL,text='Add angle restraint',
1762	help='Add angle restraint for selected atoms (3: one end 1st)')
1763	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRPLANE, kind=wx.ITEM_NORMAL,text='Add plane restraint',
1764	help='Add plane restraint for selected atoms (4+)')
1765	self.DrawAtomRestraint.Append(id=wxID_DRAWRESTRCHIRAL, kind=wx.ITEM_NORMAL,text='Add chiral restraint',
1766	help='Add chiral restraint for selected atoms (4: center atom 1st)')
1767	self.DrawAtomRigidBody.Append(id=wxID_DRAWDEFINERB, kind=wx.ITEM_NORMAL,text='Define rigid body',
1768	help='Define rigid body with selected atoms')
1769	self.PostfillDataMenu()
1770
1771	# Phase / Texture tab
1772	self.TextureMenu = wx.MenuBar()
1773	self.PrefillDataMenu(self.TextureMenu,helpType='Texture')
1774	self.TextureEdit = wx.Menu(title='')
1775	self.TextureMenu.Append(menu=self.TextureEdit, title='Texture')
1776	self.TextureEdit.Append(id=wxID_REFINETEXTURE, kind=wx.ITEM_NORMAL,text='Refine texture',
1777	help='Refine the texture coefficients from sequential Pawley results')
1778	self.TextureEdit.Append(id=wxID_CLEARTEXTURE, kind=wx.ITEM_NORMAL,text='Clear texture',
1779	help='Clear the texture coefficients' )
1780	self.PostfillDataMenu()
1781
1782	# Phase / Pawley tab
1783	self.PawleyMenu = wx.MenuBar()
1784	self.PrefillDataMenu(self.PawleyMenu,helpType='Pawley')
1785	self.PawleyEdit = wx.Menu(title='')
1786	self.PawleyMenu.Append(menu=self.PawleyEdit,title='Operations')
1787	self.PawleyEdit.Append(id=wxID_PAWLEYLOAD, kind=wx.ITEM_NORMAL,text='Pawley create',
1788	help='Initialize Pawley reflection list')
1789	self.PawleyEdit.Append(id=wxID_PAWLEYESTIMATE, kind=wx.ITEM_NORMAL,text='Pawley estimate',
1790	help='Estimate initial Pawley intensities')
1791	self.PawleyEdit.Append(id=wxID_PAWLEYUPDATE, kind=wx.ITEM_NORMAL,text='Pawley update',
1792	help='Update Pawley intensities with abs(Fobs) from reflection list')
1793	# self.PawleyEdit.Append(id=wxID_PAWLEYDELETE, kind=wx.ITEM_NORMAL,text='Pawley delete',
1794	# help='Delete selected Pawley reflection')
1795	self.PostfillDataMenu()
1796
1797	# Phase / Map peaks tab
1798	self.MapPeaksMenu = wx.MenuBar()
1799	self.PrefillDataMenu(self.MapPeaksMenu,helpType='Map peaks')
1800	self.MapPeaksEdit = wx.Menu(title='')
1801	self.MapPeaksMenu.Append(menu=self.MapPeaksEdit, title='Map peaks')
1802	self.MapPeaksEdit.Append(id=wxID_PEAKSMOVE, kind=wx.ITEM_NORMAL,text='Move peaks',
1803	help='Move selected peaks to atom list')
1804	self.MapPeaksEdit.Append(id=wxID_PEAKSVIEWPT, kind=wx.ITEM_NORMAL,text='View point',
1805	help='View point is 1st peak selected')
1806	self.MapPeaksEdit.Append(id=wxID_PEAKSDISTVP, kind=wx.ITEM_NORMAL,text='View pt. dist.',
1807	help='Compute distance of selected peaks from view point')
1808	self.MapPeaksEdit.Append(id=wxID_SHOWBONDS, kind=wx.ITEM_NORMAL,text='Hide bonds',
1809	help='Hide or show bonds between peak positions')
1810	self.MapPeaksEdit.Append(id=wxID_PEAKSDA, kind=wx.ITEM_NORMAL,text='Calc dist/ang',
1811	help='Calculate distance or angle for selection')
1812	self.MapPeaksEdit.Append(id=wxID_FINDEQVPEAKS, kind=wx.ITEM_NORMAL,text='Equivalent peaks',
1813	help='Find equivalent peaks')
1814	self.MapPeaksEdit.Append(id=wxID_PEAKSUNIQUE, kind=wx.ITEM_NORMAL,text='Unique peaks',
1815	help='Select unique set')
1816	self.MapPeaksEdit.Append(id=wxID_PEAKSDELETE, kind=wx.ITEM_NORMAL,text='Delete peaks',
1817	help='Delete selected peaks')
1818	self.MapPeaksEdit.Append(id=wxID_PEAKSCLEAR, kind=wx.ITEM_NORMAL,text='Clear peaks',
1819	help='Clear the map peak list')
1820	self.PostfillDataMenu()
1821
1822	# Phase / Rigid bodies tab
1823	self.RigidBodiesMenu = wx.MenuBar()
1824	self.PrefillDataMenu(self.RigidBodiesMenu,helpType='Rigid bodies')
1825	self.RigidBodiesEdit = wx.Menu(title='')
1826	self.RigidBodiesMenu.Append(menu=self.RigidBodiesEdit, title='Edit')
1827	self.RigidBodiesEdit.Append(id=wxID_ASSIGNATMS2RB, kind=wx.ITEM_NORMAL,text='Assign atoms to rigid body',
1828	help='Select & position rigid body in structure of existing atoms')
1829	self.RigidBodiesEdit.Append(id=wxID_AUTOFINDRESRB, kind=wx.ITEM_NORMAL,text='Auto find residues',
1830	help='Auto find of residue RBs in macromolecule')
1831	self.RigidBodiesEdit.Append(id=wxID_COPYRBPARMS, kind=wx.ITEM_NORMAL,text='Copy rigid body parms',
1832	help='Copy rigid body location & TLS parameters')
1833	self.RigidBodiesEdit.Append(id=wxID_GLOBALRESREFINE, kind=wx.ITEM_NORMAL,text='Global residue refine',
1834	help='Global setting of residue RB refinement flags')
1835	self.RigidBodiesEdit.Append(id=wxID_RBREMOVEALL, kind=wx.ITEM_NORMAL,text='Remove all rigid bodies',
1836	help='Remove all rigid body assignment for atoms')
1837	self.PostfillDataMenu()
1838	# end of GSAS-II menu definitions
1839
1840	def _init_ctrls(self, parent,name=None,size=None,pos=None):
1841	wx.Frame.__init__(self,parent=parent,
1842	style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX \| wx.FRAME_FLOAT_ON_PARENT ,
1843	size=size,pos=pos,title='GSAS-II data display')
1844	self._init_menus()
1845	if name:
1846	self.SetLabel(name)
1847	self.Show()
1848
1849	def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
1850	self.G2frame = frame
1851	self._init_ctrls(parent,name,size,pos)
1852	self.data = data
1853	clientSize = wx.ClientDisplayRect()
1854	Size = self.GetSize()
1855	xPos = clientSize[2]-Size[0]
1856	self.SetPosition(wx.Point(xPos,clientSize[1]+250))
1857	self.AtomGrid = []
1858	self.selectedRow = 0
1859
1860	def setSizePosLeft(self,Width):
1861	clientSize = wx.ClientDisplayRect()
1862	Width[1] = min(Width[1],clientSize[2]-300)
1863	Width[0] = max(Width[0],300)
1864	self.SetSize(Width)
1865	# self.SetPosition(wx.Point(clientSize[2]-Width[0],clientSize[1]+250))
1866
1867	def Clear(self):
1868	self.ClearBackground()
1869	self.DestroyChildren()
1870
1871	################################################################################
1872	##### GSNotebook
1873	################################################################################
1874
1875	class GSNoteBook(wx.aui.AuiNotebook):
1876	'''Notebook used in various locations; implemented with wx.aui extension
1877	'''
1878	def __init__(self, parent, name='',size = None):
1879	wx.aui.AuiNotebook.__init__(self, parent, -1,
1880	style=wx.aui.AUI_NB_TOP \|
1881	wx.aui.AUI_NB_SCROLL_BUTTONS)
1882	if size: self.SetSize(size)
1883
1884	def Clear(self):
1885	GSNoteBook.DeleteAllPages(self)
1886
1887	def FindPage(self,name):
1888	numPage = self.GetPageCount()
1889	for page in range(numPage):
1890	if self.GetPageText(page) == name:
1891	return page
1892
1893	def ChangeSelection(self,page):
1894	# in the wx.Notebook ChangeSelection is like SetSelection, but it
1895	# does not invoke the event related to pressing the tab button
1896	# I don't see a way to do that in aui.
1897	oldPage = self.GetSelection()
1898	self.SetSelection(page)
1899	return oldPage
1900
1901	# def __getattribute__(self,name):
1902	# '''This method provides a way to print out a message every time
1903	# that a method in a class is called -- to see what all the calls
1904	# might be, or where they might be coming from.
1905	# Cute trick for debugging!
1906	# '''
1907	# attr = object.__getattribute__(self, name)
1908	# if hasattr(attr, '__call__'):
1909	# def newfunc(args, *kwargs):
1910	# print('GSauiNoteBook calling %s' %attr.__name__)
1911	# result = attr(args, *kwargs)
1912	# return result
1913	# return newfunc
1914	# else:
1915	# return attr
1916
1917	################################################################################
1918	##### GSGrid
1919	################################################################################
1920
1921	class GSGrid(wg.Grid):
1922	'''Basic wx.Grid implementation
1923	'''
1924	def __init__(self, parent, name=''):
1925	wg.Grid.__init__(self,parent,-1,name=name)
1926	#self.SetSize(parent.GetClientSize())
1927	# above removed to speed drawing of initial grid
1928	# does not appear to be needed
1929
1930	def Clear(self):
1931	wg.Grid.ClearGrid(self)
1932
1933	def SetCellStyle(self,r,c,color="white",readonly=True):
1934	self.SetCellBackgroundColour(r,c,color)
1935	self.SetReadOnly(r,c,isReadOnly=readonly)
1936
1937	def GetSelection(self):
1938	#this is to satisfy structure drawing stuff in G2plt when focus changes
1939	return None
1940
1941	################################################################################
1942	##### Table
1943	################################################################################
1944
1945	class Table(wg.PyGridTableBase):
1946	'''Basic data table for use with GSgrid
1947	'''
1948	def __init__(self, data=[], rowLabels=None, colLabels=None, types = None):
1949	wg.PyGridTableBase.__init__(self)
1950	self.colLabels = colLabels
1951	self.rowLabels = rowLabels
1952	self.dataTypes = types
1953	self.data = data
1954
1955	def AppendRows(self, numRows=1):
1956	self.data.append([])
1957	return True
1958
1959	def CanGetValueAs(self, row, col, typeName):
1960	if self.dataTypes:
1961	colType = self.dataTypes[col].split(':')[0]
1962	if typeName == colType:
1963	return True
1964	else:
1965	return False
1966	else:
1967	return False
1968
1969	def CanSetValueAs(self, row, col, typeName):
1970	return self.CanGetValueAs(row, col, typeName)
1971
1972	def DeleteRow(self,pos):
1973	data = self.GetData()
1974	self.SetData([])
1975	new = []
1976	for irow,row in enumerate(data):
1977	if irow <> pos:
1978	new.append(row)
1979	self.SetData(new)
1980
1981	def GetColLabelValue(self, col):
1982	if self.colLabels:
1983	return self.colLabels[col]
1984
1985	def GetData(self):
1986	data = []
1987	for row in range(self.GetNumberRows()):
1988	data.append(self.GetRowValues(row))
1989	return data
1990
1991	def GetNumberCols(self):
1992	try:
1993	return len(self.colLabels)
1994	except TypeError:
1995	return None
1996
1997	def GetNumberRows(self):
1998	return len(self.data)
1999
2000	def GetRowLabelValue(self, row):
2001	if self.rowLabels:
2002	return self.rowLabels[row]
2003
2004	def GetColValues(self, col):
2005	data = []
2006	for row in range(self.GetNumberRows()):
2007	data.append(self.GetValue(row, col))
2008	return data
2009
2010	def GetRowValues(self, row):
2011	data = []
2012	for col in range(self.GetNumberCols()):
2013	data.append(self.GetValue(row, col))
2014	return data
2015
2016	def GetTypeName(self, row, col):
2017	try:
2018	return self.dataTypes[col]
2019	except TypeError:
2020	return None
2021
2022	def GetValue(self, row, col):
2023	try:
2024	return self.data[row][col]
2025	except IndexError:
2026	return None
2027
2028	def InsertRows(self, pos, rows):
2029	for row in range(rows):
2030	self.data.insert(pos,[])
2031	pos += 1
2032
2033	def IsEmptyCell(self,row,col):
2034	try:
2035	return not self.data[row][col]
2036	except IndexError:
2037	return True
2038
2039	def OnKeyPress(self, event):
2040	dellist = self.GetSelectedRows()
2041	if event.GetKeyCode() == wx.WXK_DELETE and dellist:
2042	grid = self.GetView()
2043	for i in dellist: grid.DeleteRow(i)
2044
2045	def SetColLabelValue(self, col, label):
2046	numcols = self.GetNumberCols()
2047	if col > numcols-1:
2048	self.colLabels.append(label)
2049	else:
2050	self.colLabels[col]=label
2051
2052	def SetData(self,data):
2053	for row in range(len(data)):
2054	self.SetRowValues(row,data[row])
2055
2056	def SetRowLabelValue(self, row, label):
2057	self.rowLabels[row]=label
2058
2059	def SetRowValues(self,row,data):
2060	self.data[row] = data
2061
2062	def SetValue(self, row, col, value):
2063	def innerSetValue(row, col, value):
2064	try:
2065	self.data[row][col] = value
2066	except TypeError:
2067	return
2068	except IndexError:
2069	print row,col,value
2070	# add a new row
2071	if row > self.GetNumberRows():
2072	self.data.append([''] * self.GetNumberCols())
2073	elif col > self.GetNumberCols():
2074	for row in range(self.GetNumberRows):
2075	self.data[row].append('')
2076	print self.data
2077	self.data[row][col] = value
2078	innerSetValue(row, col, value)
2079
2080	################################################################################
2081	#### Help
2082	################################################################################
2083
2084	def ShowHelp(helpType,frame):
2085	'''Called to bring up a web page for documentation.'''
2086	global htmlFirstUse
2087	# look up a definition for help info from dict
2088	helplink = helpLocDict.get(helpType)
2089	if helplink is None:
2090	# no defined link to use, create a default based on key
2091	helplink = 'gsasII.html#'+helpType.replace(' ','_')
2092	helplink = os.path.join(path2GSAS2,'help',helplink)
2093	if helpMode == 'internal':
2094	try:
2095	htmlPanel.LoadFile(helplink)
2096	htmlFrame.Raise()
2097	except:
2098	htmlFrame = wx.Frame(frame, -1, size=(610, 510))
2099	htmlFrame.Show(True)
2100	htmlFrame.SetTitle("HTML Window") # N.B. reset later in LoadFile
2101	htmlPanel = MyHtmlPanel(htmlFrame,-1)
2102	htmlPanel.LoadFile(helplink)
2103	else:
2104	pfx = "file://"
2105	if sys.platform.lower().startswith('win'):
2106	pfx = ''
2107	if htmlFirstUse:
2108	webbrowser.open_new(pfx+helplink)
2109	htmlFirstUse = False
2110	else:
2111	webbrowser.open(pfx+helplink, new=0, autoraise=True)
2112
2113	################################################################################
2114	##### Notebook
2115	################################################################################
2116
2117	def UpdateNotebook(G2frame,data):
2118	'''Called when the data tree notebook entry is selected. Allows for
2119	editing of the text in that tree entry
2120	'''
2121	def OnNoteBook(event):
2122	data = G2frame.dataDisplay.GetValue()
2123	G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Notebook'),data)
2124
2125	if G2frame.dataDisplay:
2126	G2frame.dataDisplay.Destroy()
2127	G2frame.dataFrame.SetLabel('Notebook')
2128	G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2129	style=wx.TE_MULTILINE\|wx.TE_PROCESS_ENTER \| wx.TE_DONTWRAP)
2130	G2frame.dataDisplay.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
2131	G2frame.dataDisplay.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
2132	for line in data:
2133	G2frame.dataDisplay.AppendText(line+"\n")
2134	G2frame.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
2135	G2frame.dataFrame.setSizePosLeft([400,250])
2136
2137	################################################################################
2138	##### Controls
2139	################################################################################
2140
2141	def UpdateControls(G2frame,data):
2142	'''Edit overall GSAS-II controls in main Controls data tree entry
2143	'''
2144	#patch
2145	if 'deriv type' not in data:
2146	data = {}
2147	data['deriv type'] = 'analytic Hessian'
2148	data['min dM/M'] = 0.0001
2149	data['shift factor'] = 1.
2150	data['max cyc'] = 3
2151	data['F**2'] = True
2152	data['minF/sig'] = 0
2153	if 'shift factor' not in data:
2154	data['shift factor'] = 1.
2155	if 'max cyc' not in data:
2156	data['max cyc'] = 3
2157	if 'F**2' not in data:
2158	data['F**2'] = True
2159	data['minF/sig'] = 0
2160	#end patch
2161
2162	def SeqSizer():
2163
2164	def OnSelectData(event):
2165	choices = ['All',]+GetPatternTreeDataNames(G2frame,['PWDR',])
2166	sel = []
2167	if 'Seq Data' in data:
2168	for item in data['Seq Data']:
2169	sel.append(choices.index(item))
2170	names = []
2171	dlg = wx.MultiChoiceDialog(G2frame,'Select data:','Sequential refinement',choices)
2172	dlg.SetSelections(sel)
2173	if dlg.ShowModal() == wx.ID_OK:
2174	sel = dlg.GetSelections()
2175	for i in sel: names.append(choices[i])
2176	if 'All' in names:
2177	names = choices[1:]
2178	data['Seq Data'] = names
2179	dlg.Destroy()
2180	reverseSel.Enable(True)
2181
2182	def OnReverse(event):
2183	data['Reverse Seq'] = reverseSel.GetValue()
2184
2185	seqSizer = wx.BoxSizer(wx.HORIZONTAL)
2186	seqSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sequential Refinement Powder Data: '),0,wx.ALIGN_CENTER_VERTICAL)
2187	selSeqData = wx.Button(G2frame.dataDisplay,-1,label=' Select data')
2188	selSeqData.Bind(wx.EVT_BUTTON,OnSelectData)
2189	seqSizer.Add(selSeqData,0,wx.ALIGN_CENTER_VERTICAL)
2190	seqSizer.Add((5,0),0)
2191	reverseSel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Reverse order?')
2192	reverseSel.Bind(wx.EVT_CHECKBOX,OnReverse)
2193	if 'Seq Data' not in data:
2194	reverseSel.Enable(False)
2195	if 'Reverse Seq' in data:
2196	reverseSel.SetValue(data['Reverse Seq'])
2197	seqSizer.Add(reverseSel,0,wx.ALIGN_CENTER_VERTICAL)
2198	return seqSizer
2199
2200	def LSSizer():
2201
2202	def OnDerivType(event):
2203	data['deriv type'] = derivSel.GetValue()
2204	derivSel.SetValue(data['deriv type'])
2205	wx.CallAfter(UpdateControls,G2frame,data)
2206
2207	def OnConvergence(event):
2208	try:
2209	value = max(1.e-9,min(1.0,float(Cnvrg.GetValue())))
2210	except ValueError:
2211	value = 0.0001
2212	data['min dM/M'] = value
2213	Cnvrg.SetValue('%.2g'%(value))
2214
2215	def OnMaxCycles(event):
2216	data['max cyc'] = int(maxCyc.GetValue())
2217	maxCyc.SetValue(str(data['max cyc']))
2218
2219	def OnFactor(event):
2220	try:
2221	value = min(max(float(Factr.GetValue()),0.00001),100.)
2222	except ValueError:
2223	value = 1.0
2224	data['shift factor'] = value
2225	Factr.SetValue('%.5f'%(value))
2226
2227	def OnFsqRef(event):
2228	data['F**2'] = fsqRef.GetValue()
2229
2230	def OnMinSig(event):
2231	try:
2232	value = min(max(float(minSig.GetValue()),0.),5.)
2233	except ValueError:
2234	value = 1.0
2235	data['minF/sig'] = value
2236	minSig.SetValue('%.2f'%(value))
2237
2238	LSSizer = wx.FlexGridSizer(cols=4,vgap=5,hgap=5)
2239	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement derivatives: '),0,wx.ALIGN_CENTER_VERTICAL)
2240	Choice=['analytic Jacobian','numeric','analytic Hessian']
2241	derivSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['deriv type'],choices=Choice,
2242	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
2243	derivSel.SetValue(data['deriv type'])
2244	derivSel.Bind(wx.EVT_COMBOBOX, OnDerivType)
2245
2246	LSSizer.Add(derivSel,0,wx.ALIGN_CENTER_VERTICAL)
2247	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min delta-M/M: '),0,wx.ALIGN_CENTER_VERTICAL)
2248	Cnvrg = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2g'%(data['min dM/M']),style=wx.TE_PROCESS_ENTER)
2249	Cnvrg.Bind(wx.EVT_TEXT_ENTER,OnConvergence)
2250	Cnvrg.Bind(wx.EVT_KILL_FOCUS,OnConvergence)
2251	LSSizer.Add(Cnvrg,0,wx.ALIGN_CENTER_VERTICAL)
2252	if 'Hessian' in data['deriv type']:
2253	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max cycles: '),0,wx.ALIGN_CENTER_VERTICAL)
2254	Choice = ['0','1','2','3','5','10','15','20']
2255	maxCyc = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['max cyc']),choices=Choice,
2256	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
2257	maxCyc.SetValue(str(data['max cyc']))
2258	maxCyc.Bind(wx.EVT_COMBOBOX, OnMaxCycles)
2259	LSSizer.Add(maxCyc,0,wx.ALIGN_CENTER_VERTICAL)
2260	else:
2261	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial shift factor: '),0,wx.ALIGN_CENTER_VERTICAL)
2262	Factr = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.5f'%(data['shift factor']),style=wx.TE_PROCESS_ENTER)
2263	Factr.Bind(wx.EVT_TEXT_ENTER,OnFactor)
2264	Factr.Bind(wx.EVT_KILL_FOCUS,OnFactor)
2265	LSSizer.Add(Factr,0,wx.ALIGN_CENTER_VERTICAL)
2266	if G2frame.Sngl:
2267	LSSizer.Add((1,0),)
2268	LSSizer.Add((1,0),)
2269	fsqRef = wx.CheckBox(G2frame.dataDisplay,-1,label='Refine HKLF as F^2? ')
2270	fsqRef.SetValue(data['F**2'])
2271	fsqRef.Bind(wx.EVT_CHECKBOX,OnFsqRef)
2272	LSSizer.Add(fsqRef,0,wx.ALIGN_CENTER_VERTICAL)
2273	LSSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label='Min obs/sig (0-5): '),0,wx.ALIGN_CENTER_VERTICAL)
2274	minSig = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2f'%(data['minF/sig']),style=wx.TE_PROCESS_ENTER)
2275	minSig.Bind(wx.EVT_TEXT_ENTER,OnMinSig)
2276	minSig.Bind(wx.EVT_KILL_FOCUS,OnMinSig)
2277	LSSizer.Add(minSig,0,wx.ALIGN_CENTER_VERTICAL)
2278	return LSSizer
2279
2280	if G2frame.dataDisplay:
2281	G2frame.dataDisplay.Destroy()
2282	if not G2frame.dataFrame.GetStatusBar():
2283	Status = G2frame.dataFrame.CreateStatusBar()
2284	Status.SetStatusText('')
2285	G2frame.dataFrame.SetLabel('Controls')
2286	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
2287	SetDataMenuBar(G2frame,G2frame.dataFrame.ControlsMenu)
2288	mainSizer = wx.BoxSizer(wx.VERTICAL)
2289	mainSizer.Add((5,5),0)
2290	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement Controls:'),0,wx.ALIGN_CENTER_VERTICAL)
2291	mainSizer.Add(LSSizer())
2292	mainSizer.Add((5,5),0)
2293	mainSizer.Add(SeqSizer())
2294	mainSizer.Add((5,5),0)
2295
2296	mainSizer.Layout()
2297	G2frame.dataDisplay.SetSizer(mainSizer)
2298	G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
2299	G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
2300
2301	################################################################################
2302	##### Comments
2303	################################################################################
2304
2305	def UpdateComments(G2frame,data):
2306
2307	if G2frame.dataDisplay:
2308	G2frame.dataDisplay.Destroy()
2309	G2frame.dataFrame.SetLabel('Comments')
2310	G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2311	style=wx.TE_MULTILINE\|wx.TE_READONLY\|wx.TE_DONTWRAP)
2312	for line in data:
2313	G2frame.dataDisplay.AppendText(line+'\n')
2314	G2frame.dataFrame.setSizePosLeft([400,250])
2315
2316	################################################################################
2317	##### Sequential Results
2318	################################################################################
2319
2320	def UpdateSeqResults(G2frame,data):
2321	"""
2322	Called when the Sequential Results data tree entry is selected
2323	to show results from a sequential refinement.
2324
2325	:param wx.Frame G2frame: main GSAS-II data tree windows
2326
2327	:param dict data: a dictionary containing the following items:
2328
2329	* 'histNames' - list of histogram names in order as processed by Sequential Refinement
2330	* 'varyList' - list of variables - identical over all refinements in sequence
2331	* 'histName' - dictionaries for all data sets processed, which contains:
2332
2333	* 'variables'- result[0] from leastsq call
2334	* 'varyList' - list of variables; same as above
2335	* 'sig' - esds for variables
2336	* 'covMatrix' - covariance matrix from individual refinement
2337	* 'title' - histogram name; same as dict item name
2338	* 'newAtomDict' - new atom parameters after shifts applied
2339	* 'newCellDict' - new cell parameters after shifts to A0-A5 applied'
2340	"""
2341	if not data:
2342	print 'No sequential refinement results'
2343	return
2344	histNames = data['histNames']
2345
2346	def GetSampleParms():
2347	sampleParmDict = {'Temperature':[],'Pressure':[],'Humidity':[],'Voltage':[],'Force':[],}
2348	sampleParm = {}
2349	for name in histNames:
2350	Id = GetPatternTreeItemId(G2frame,G2frame.root,name)
2351	sampleData = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
2352	for item in sampleParmDict:
2353	sampleParmDict[item].append(sampleData[item])
2354	for item in sampleParmDict:
2355	frstValue = sampleParmDict[item][0]
2356	if np.any(np.array(sampleParmDict[item])-frstValue):
2357	sampleParm[item] = sampleParmDict[item]
2358	return sampleParm
2359
2360	def GetRwps():
2361	Rwps = []
2362	for name in histNames:
2363	Rwps.append(data[name]['Rvals']['Rwp'])
2364	return Rwps
2365
2366	def GetSigData(parm):
2367	sigData = []
2368	for name in histNames:
2369	sigList = data[name]['sig']
2370	if colLabels[parm] in atomList:
2371	sigData.append(sigList[colLabels.index(atomList[colLabels[parm]])-1])
2372	elif colLabels[parm] in cellList:
2373	sigData.append(sigList[colLabels.index(cellList[colLabels[parm]])-1])
2374	else:
2375	sigData.append(sigList[parm-1])
2376	return sigData
2377
2378	def Select(event):
2379	cols = G2frame.dataDisplay.GetSelectedCols()
2380	rows = G2frame.dataDisplay.GetSelectedRows()
2381	if cols:
2382	plotData = []
2383	plotSig = []
2384	plotNames = []
2385	for col in cols:
2386	plotData.append(G2frame.SeqTable.GetColValues(col))
2387	if col: #not Rwp
2388	plotSig.append(GetSigData(col))
2389	else:
2390	plotSig.append(0.0)
2391	plotNames.append(G2frame.SeqTable.GetColLabelValue(col))
2392	plotData = np.array(plotData)
2393	G2plt.PlotSeq(G2frame,plotData,plotSig,plotNames,sampleParms)
2394	elif rows:
2395	name = histNames[rows[0]] #only does 1st one selected
2396	G2plt.PlotCovariance(G2frame,data[name])
2397
2398	def OnSaveSelSeq(event):
2399	cols = G2frame.dataDisplay.GetSelectedCols()
2400	if cols:
2401	numRows = G2frame.SeqTable.GetNumberRows()
2402	dataNames = []
2403	saveNames = [G2frame.SeqTable.GetRowLabelValue(r) for r in range(numRows)]
2404	saveData = []
2405	for col in cols:
2406	dataNames.append(G2frame.SeqTable.GetColLabelValue(col))
2407	if col: #not Rwp
2408	saveData.append(zip(G2frame.SeqTable.GetColValues(col),GetSigData(col)))
2409	else:
2410	saveData.append(zip(G2frame.SeqTable.GetColValues(col),0.0))
2411	lenName = len(saveNames[0])
2412	saveData = np.swapaxes(np.array(saveData),0,1)
2413	dlg = wx.FileDialog(G2frame, 'Choose text output file for your selection', '.', '',
2414	'Text output file (.txt)\|.txt',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT\|wx.CHANGE_DIR)
2415	try:
2416	if dlg.ShowModal() == wx.ID_OK:
2417	SeqTextFile = dlg.GetPath()
2418	SeqTextFile = G2IO.FileDlgFixExt(dlg,SeqTextFile)
2419	SeqFile = open(SeqTextFile,'w')
2420	line = ' %s '%('name'.center(lenName))
2421	for item in dataNames:
2422	line += ' %12s %12s '%(item.center(12),'esd'.center(12))
2423	line += '\n'
2424	SeqFile.write(line)
2425	for i,item in enumerate(saveData):
2426	line = " '%s' "%(saveNames[i])
2427	for val,esd in item:
2428	line += ' %12.6f %12.6f '%(val,esd)
2429	line += '\n'
2430	SeqFile.write(line)
2431	SeqFile.close()
2432	finally:
2433	dlg.Destroy()
2434
2435
2436	if G2frame.dataDisplay:
2437	G2frame.dataDisplay.Destroy()
2438	atomList = {}
2439	newAtomDict = data[histNames[0]]['newAtomDict']
2440	for item in newAtomDict:
2441	if item in data['varyList']:
2442	atomList[newAtomDict[item][0]] = item
2443	cellList = {}
2444	newCellDict = data[histNames[0]]['newCellDict']
2445	for item in newCellDict:
2446	if item in data['varyList']:
2447	cellList[newCellDict[item][0]] = item
2448	sampleParms = GetSampleParms()
2449	Rwps = GetRwps()
2450	SetDataMenuBar(G2frame,G2frame.dataFrame.SequentialMenu)
2451	G2frame.dataFrame.SetLabel('Sequential refinement results')
2452	G2frame.dataFrame.CreateStatusBar()
2453	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeq, id=wxID_SAVESEQSEL)
2454	colLabels = ['Rwp',]+data['varyList']+atomList.keys()+cellList.keys()
2455	Types = (len(data['varyList']+atomList.keys()+cellList.keys())+1)*[wg.GRID_VALUE_FLOAT,]
2456	seqList = [[Rwps[i],]+list(data[name]['variables']) for i,name in enumerate(histNames)]
2457	for i,item in enumerate(seqList):
2458	newAtomDict = data[histNames[i]]['newAtomDict']
2459	newCellDict = data[histNames[i]]['newCellDict']
2460	item += [newAtomDict[atomList[parm]][1] for parm in atomList.keys()]
2461	item += [newCellDict[cellList[parm]][1] for parm in cellList.keys()]
2462	G2frame.SeqTable = Table(seqList,colLabels=colLabels,rowLabels=histNames,types=Types)
2463	G2frame.dataDisplay = GSGrid(parent=G2frame.dataFrame)
2464	G2frame.dataDisplay.SetTable(G2frame.SeqTable, True)
2465	G2frame.dataDisplay.EnableEditing(False)
2466	G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, Select)
2467	G2frame.dataDisplay.SetRowLabelSize(8*len(histNames[0])) #pretty arbitrary 8
2468	G2frame.dataDisplay.SetMargins(0,0)
2469	G2frame.dataDisplay.AutoSizeColumns(True)
2470	G2frame.dataFrame.setSizePosLeft([700,350])
2471
2472	################################################################################
2473	##### Main PWDR panel
2474	################################################################################
2475
2476	def UpdatePWHKPlot(G2frame,kind,item):
2477	'''Needs a doc string
2478	'''
2479
2480	def OnErrorAnalysis(event):
2481	G2plt.PlotDeltSig(G2frame,kind)
2482
2483	def OnWtFactor(event):
2484	try:
2485	val = float(wtval.GetValue())
2486	except ValueError:
2487	val = data[0]['wtFactor']
2488	data[0]['wtFactor'] = val
2489	wtval.SetValue('%.3f'%(val))
2490
2491	data = G2frame.PatternTree.GetItemPyData(item)
2492	if 'wtFactor' not in data[0]:
2493	data[0] = {'wtFactor':1.0}
2494	if G2frame.dataDisplay:
2495	G2frame.dataDisplay.Destroy()
2496	SetDataMenuBar(G2frame,G2frame.dataFrame.ErrorMenu)
2497	G2frame.dataFrame.Bind(wx.EVT_MENU,OnErrorAnalysis, id=wxID_PWDANALYSIS)
2498	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
2499
2500	mainSizer = wx.BoxSizer(wx.VERTICAL)
2501	mainSizer.Add((5,5),)
2502	wtSizer = wx.BoxSizer(wx.HORIZONTAL)
2503	wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Weight factor: '),0,wx.ALIGN_CENTER_VERTICAL)
2504	wtval = wx.TextCtrl(G2frame.dataDisplay,-1,'%.3f'%(data[0]['wtFactor']),style=wx.TE_PROCESS_ENTER)
2505	wtval.Bind(wx.EVT_TEXT_ENTER,OnWtFactor)
2506	wtval.Bind(wx.EVT_KILL_FOCUS,OnWtFactor)
2507	wtSizer.Add(wtval,0,wx.ALIGN_CENTER_VERTICAL)
2508	mainSizer.Add(wtSizer)
2509	mainSizer.Layout()
2510	G2frame.dataDisplay.SetSizer(mainSizer)
2511	G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
2512	G2frame.PatternTree.SetItemPyData(item,data)
2513	if kind == 'PWDR':
2514	G2plt.PlotPatterns(G2frame,newPlot=True)
2515	elif kind == 'HKLF':
2516	G2plt.PlotSngl(G2frame,newPlot=True)
2517
2518	################################################################################
2519	##### HKLF controls
2520	################################################################################
2521
2522	def UpdateHKLControls(G2frame,data):
2523	'''Needs a doc string
2524	'''
2525
2526	def OnScaleSlider(event):
2527	scale = int(scaleSel.GetValue())/1000.
2528	scaleSel.SetValue(int(scale*1000.))
2529	data['Scale'] = scale*1.
2530	G2plt.PlotSngl(G2frame)
2531
2532	def OnLayerSlider(event):
2533	layer = layerSel.GetValue()
2534	data['Layer'] = layer
2535	G2plt.PlotSngl(G2frame)
2536
2537	def OnSelZone(event):
2538	data['Zone'] = zoneSel.GetValue()
2539	izone = zones.index(data['Zone'])
2540	layerSel.SetRange(maxValue=HKLmax[izone],minValue=HKLmin[izone])
2541	G2plt.PlotSngl(G2frame,newPlot=True)
2542
2543	def OnSelType(event):
2544	data['Type'] = typeSel.GetValue()
2545	G2plt.PlotSngl(G2frame)
2546
2547	def SetStatusLine():
2548	Status.SetStatusText("")
2549
2550	if G2frame.dataDisplay:
2551	G2frame.dataDisplay.Destroy()
2552	if not G2frame.dataFrame.GetStatusBar():
2553	Status = G2frame.dataFrame.CreateStatusBar()
2554	SetStatusLine()
2555	zones = ['100','010','001']
2556	HKLmax = data['HKLmax']
2557	HKLmin = data['HKLmin']
2558	typeChoices = ['Fosq','Fo','\|DFsq\|/sig','\|DFsq\|>sig','\|DFsq\|>3sig']
2559	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
2560	SetDataMenuBar(G2frame)
2561	G2frame.dataFrame.SetTitle('HKL Plot Controls')
2562	mainSizer = wx.BoxSizer(wx.VERTICAL)
2563	mainSizer.Add((5,10),0)
2564
2565	scaleSizer = wx.BoxSizer(wx.HORIZONTAL)
2566	scaleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Scale'),0,
2567	wx.ALIGN_CENTER_VERTICAL\|wx.EXPAND)
2568	scaleSel = wx.Slider(parent=G2frame.dataDisplay,maxValue=1000,minValue=1,
2569	style=wx.SL_HORIZONTAL,value=int(data['Scale']*10))
2570	scaleSizer.Add(scaleSel,1,wx.EXPAND\|wx.RIGHT\|wx.ALIGN_CENTER_VERTICAL)
2571	scaleSel.SetLineSize(10)
2572	scaleSel.SetPageSize(10)
2573	scaleSel.Bind(wx.EVT_SLIDER, OnScaleSlider)
2574	mainSizer.Add(scaleSizer,0,wx.EXPAND\|wx.RIGHT)
2575	mainSizer.Add((0,10),0)
2576
2577	zoneSizer = wx.BoxSizer(wx.HORIZONTAL)
2578	zoneSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Zone '),0,
2579	wx.ALIGN_CENTER_VERTICAL)
2580	zoneSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['Zone'],choices=['100','010','001'],
2581	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
2582	zoneSel.Bind(wx.EVT_COMBOBOX, OnSelZone)
2583	zoneSizer.Add(zoneSel,0,wx.ALIGN_CENTER_VERTICAL)
2584	zoneSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Plot type '),0,
2585	wx.ALIGN_CENTER_VERTICAL)
2586	typeSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['Type'],choices=typeChoices,
2587	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
2588	typeSel.Bind(wx.EVT_COMBOBOX, OnSelType)
2589	zoneSizer.Add(typeSel,0,wx.ALIGN_CENTER_VERTICAL)
2590	zoneSizer.Add((10,0),0)
2591	mainSizer.Add(zoneSizer,0,wx.EXPAND\|wx.RIGHT)
2592	mainSizer.Add((0,10),0)
2593
2594	izone = zones.index(data['Zone'])
2595	layerSizer = wx.BoxSizer(wx.HORIZONTAL)
2596	layerSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Layer'),0,
2597	wx.ALIGN_CENTER_VERTICAL\|wx.EXPAND)
2598	layerSel = wx.Slider(parent=G2frame.dataDisplay,maxValue=HKLmax[izone],minValue=HKLmin[izone],
2599	style=wx.SL_HORIZONTAL\|wx.SL_AUTOTICKS\|wx.SL_LABELS,value=0)
2600	layerSel.SetLineSize(1)
2601	layerSel.SetPageSize(1)
2602	layerSel.Bind(wx.EVT_SLIDER, OnLayerSlider)
2603	layerSizer.Add(layerSel,1,wx.EXPAND\|wx.RIGHT\|wx.ALIGN_CENTER_VERTICAL)
2604	layerSizer.Add((10,0),0)
2605	mainSizer.Add(layerSizer,1,wx.EXPAND\|wx.RIGHT)
2606
2607
2608	mainSizer.Layout()
2609	G2frame.dataDisplay.SetSizer(mainSizer)
2610	G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
2611	G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
2612
2613	################################################################################
2614	##### Pattern tree routines
2615	################################################################################
2616
2617	def GetPatternTreeDataNames(G2frame,dataTypes):
2618	'''Needs a doc string
2619	'''
2620	names = []
2621	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
2622	while item:
2623	name = G2frame.PatternTree.GetItemText(item)
2624	if name[:4] in dataTypes:
2625	names.append(name)
2626	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
2627	return names
2628
2629	def GetPatternTreeItemId(G2frame, parentId, itemText):
2630	'''Needs a doc string
2631	'''
2632	item, cookie = G2frame.PatternTree.GetFirstChild(parentId)
2633	while item:
2634	if G2frame.PatternTree.GetItemText(item) == itemText:
2635	return item
2636	item, cookie = G2frame.PatternTree.GetNextChild(parentId, cookie)
2637	return 0
2638
2639	def MovePatternTreeToGrid(G2frame,item):
2640	'''Needs a doc string
2641	'''
2642
2643	# print G2frame.PatternTree.GetItemText(item)
2644
2645	oldPage = None # will be set later if already on a Phase item
2646	if G2frame.dataFrame:
2647	SetDataMenuBar(G2frame)
2648	if G2frame.dataFrame.GetLabel() == 'Comments':
2649	try:
2650	data = [G2frame.dataDisplay.GetValue()]
2651	G2frame.dataDisplay.Clear()
2652	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Comments')
2653	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
2654	except: #clumsy but avoids dead window problem when opening another project
2655	pass
2656	elif G2frame.dataFrame.GetLabel() == 'Notebook':
2657	try:
2658	data = [G2frame.dataDisplay.GetValue()]
2659	G2frame.dataDisplay.Clear()
2660	Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Notebook')
2661	if Id: G2frame.PatternTree.SetItemPyData(Id,data)
2662	except: #clumsy but avoids dead window problem when opening another project
2663	pass
2664	elif 'Phase Data for' in G2frame.dataFrame.GetLabel():
2665	if G2frame.dataDisplay:
2666	oldPage = G2frame.dataDisplay.GetSelection()
2667	G2frame.dataFrame.Clear()
2668	G2frame.dataFrame.SetLabel('')
2669	else:
2670	#create the frame for the data item window
2671	G2frame.dataFrame = DataFrame(parent=G2frame.mainPanel,frame=G2frame)
2672	G2frame.dataFrame.PhaseUserSize = None
2673
2674	G2frame.dataFrame.Raise()
2675	G2frame.PickId = 0
2676	parentID = G2frame.root
2677	for i in G2frame.ExportPattern: i.Enable(False)
2678	defWid = [250,150]
2679	if item != G2frame.root:
2680	parentID = G2frame.PatternTree.GetItemParent(item)
2681	if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
2682	G2frame.PatternId = item
2683	G2frame.PickId = item
2684	if G2frame.PatternTree.GetItemText(item) == 'Notebook':
2685	SetDataMenuBar(G2frame,G2frame.dataFrame.DataNotebookMenu)
2686	G2frame.PatternId = 0
2687	for i in G2frame.ExportPattern: i.Enable(False)
2688	data = G2frame.PatternTree.GetItemPyData(item)
2689	UpdateNotebook(G2frame,data)
2690	elif G2frame.PatternTree.GetItemText(item) == 'Controls':
2691	G2frame.PatternId = 0
2692	for i in G2frame.ExportPattern: i.Enable(False)
2693	data = G2frame.PatternTree.GetItemPyData(item)
2694	if not data: #fill in defaults
2695	data = {
2696	#least squares controls
2697	'deriv type':'analytic Hessian','min dM/M':0.0001,'shift factor':1.0,'max cyc':3}
2698	G2frame.PatternTree.SetItemPyData(item,data)
2699	for i in G2frame.Refine: i.Enable(True)
2700	for i in G2frame.SeqRefine: i.Enable(True)
2701	UpdateControls(G2frame,data)
2702	elif G2frame.PatternTree.GetItemText(item) == 'Sequential results':
2703	data = G2frame.PatternTree.GetItemPyData(item)
2704	UpdateSeqResults(G2frame,data)
2705	elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
2706	data = G2frame.PatternTree.GetItemPyData(item)
2707	G2frame.dataFrame.setSizePosLeft(defWid)
2708	text = ''
2709	if 'Rvals' in data:
2710	Nvars = len(data['varyList'])
2711	Rvals = data['Rvals']
2712	text = '\nFinal residuals: \nRw = %.3f%% \nchi**2 = %.1f \nGOF = %.2f'%(Rvals['Rwp'],Rvals['chisq'],Rvals['GOF'])
2713	text += '\nNobs = %d \nNvals = %d'%(Rvals['Nobs'],Nvars)
2714	if 'lamMax' in Rvals:
2715	text += '\nlog10 MaxLambda = %.1f'%(np.log10(Rvals['lamMax']))
2716	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2717	value='See plot window for covariance display'+text,style=wx.TE_MULTILINE)
2718	G2plt.PlotCovariance(G2frame,data)
2719	elif G2frame.PatternTree.GetItemText(item) == 'Constraints':
2720	data = G2frame.PatternTree.GetItemPyData(item)
2721	G2cnstG.UpdateConstraints(G2frame,data)
2722	elif G2frame.PatternTree.GetItemText(item) == 'Rigid bodies':
2723	data = G2frame.PatternTree.GetItemPyData(item)
2724	G2cnstG.UpdateRigidBodies(G2frame,data)
2725	elif G2frame.PatternTree.GetItemText(item) == 'Restraints':
2726	data = G2frame.PatternTree.GetItemPyData(item)
2727	Phases = G2frame.GetPhaseData()
2728	phase = ''
2729	phaseName = ''
2730	if Phases:
2731	phaseName = Phases.keys()[0]
2732	G2frame.dataFrame.setSizePosLeft(defWid)
2733	G2restG.UpdateRestraints(G2frame,data,Phases,phaseName)
2734	elif 'IMG' in G2frame.PatternTree.GetItemText(item):
2735	G2frame.Image = item
2736	G2plt.PlotImage(G2frame,newPlot=True)
2737	elif 'PKS' in G2frame.PatternTree.GetItemText(item):
2738	G2plt.PlotPowderLines(G2frame)
2739	elif 'PWDR' in G2frame.PatternTree.GetItemText(item):
2740	for i in G2frame.ExportPattern: i.Enable(True)
2741	UpdatePWHKPlot(G2frame,'PWDR',item)
2742	elif 'HKLF' in G2frame.PatternTree.GetItemText(item):
2743	G2frame.Sngl = item
2744	UpdatePWHKPlot(G2frame,'HKLF',item)
2745	elif 'PDF' in G2frame.PatternTree.GetItemText(item):
2746	G2frame.PatternId = item
2747	for i in G2frame.ExportPDF: i.Enable(True)
2748	G2plt.PlotISFG(G2frame,type='S(Q)')
2749	elif G2frame.PatternTree.GetItemText(item) == 'Phases':
2750	G2frame.dataFrame.setSizePosLeft(defWid)
2751	wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
2752	value='Select one phase to see its parameters')
2753	elif 'I(Q)' in G2frame.PatternTree.GetItemText(item):
2754	G2frame.PickId = item
2755	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2756	G2plt.PlotISFG(G2frame,type='I(Q)',newPlot=True)
2757	elif 'S(Q)' in G2frame.PatternTree.GetItemText(item):
2758	G2frame.PickId = item
2759	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2760	G2plt.PlotISFG(G2frame,type='S(Q)',newPlot=True)
2761	elif 'F(Q)' in G2frame.PatternTree.GetItemText(item):
2762	G2frame.PickId = item
2763	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2764	G2plt.PlotISFG(G2frame,type='F(Q)',newPlot=True)
2765	elif 'G(R)' in G2frame.PatternTree.GetItemText(item):
2766	G2frame.PickId = item
2767	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2768	G2plt.PlotISFG(G2frame,type='G(R)',newPlot=True)
2769	elif G2frame.PatternTree.GetItemText(parentID) == 'Phases':
2770	G2frame.PickId = item
2771	data = G2frame.PatternTree.GetItemPyData(item)
2772	G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
2773	elif G2frame.PatternTree.GetItemText(item) == 'Comments':
2774	SetDataMenuBar(G2frame,G2frame.dataFrame.DataCommentsMenu)
2775	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2776	G2frame.PickId = item
2777	data = G2frame.PatternTree.GetItemPyData(item)
2778	UpdateComments(G2frame,data)
2779	elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
2780	G2frame.dataFrame.SetTitle('Image Controls')
2781	G2frame.PickId = item
2782	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
2783	masks = G2frame.PatternTree.GetItemPyData(
2784	GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
2785	data = G2frame.PatternTree.GetItemPyData(item)
2786	G2imG.UpdateImageControls(G2frame,data,masks)
2787	G2plt.PlotImage(G2frame)
2788	elif G2frame.PatternTree.GetItemText(item) == 'Masks':
2789	G2frame.dataFrame.SetTitle('Masks')
2790	G2frame.PickId = item
2791	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
2792	data = G2frame.PatternTree.GetItemPyData(item)
2793	G2imG.UpdateMasks(G2frame,data)
2794	G2plt.PlotImage(G2frame)
2795	elif G2frame.PatternTree.GetItemText(item) == 'Stress/Strain':
2796	G2frame.dataFrame.SetTitle('Stress/Strain')
2797	G2frame.PickId = item
2798	G2frame.Image = G2frame.PatternTree.GetItemParent(item)
2799	data = G2frame.PatternTree.GetItemPyData(item)
2800	G2imG.UpdateStressStrain(G2frame,data)
2801	G2plt.PlotImage(G2frame)
2802	elif G2frame.PatternTree.GetItemText(item) == 'HKL Plot Controls':
2803	G2frame.PickId = item
2804	G2frame.Sngl = G2frame.PatternTree.GetItemParent(item)
2805	data = G2frame.PatternTree.GetItemPyData(item)
2806	UpdateHKLControls(G2frame,data)
2807	G2plt.PlotSngl(G2frame)
2808	elif G2frame.PatternTree.GetItemText(item) == 'PDF Controls':
2809	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2810	for i in G2frame.ExportPDF: i.Enable(True)
2811	G2frame.PickId = item
2812	data = G2frame.PatternTree.GetItemPyData(item)
2813	G2pdG.UpdatePDFGrid(G2frame,data)
2814	G2plt.PlotISFG(G2frame,type='I(Q)')
2815	G2plt.PlotISFG(G2frame,type='S(Q)')
2816	G2plt.PlotISFG(G2frame,type='F(Q)')
2817	G2plt.PlotISFG(G2frame,type='G(R)')
2818	elif G2frame.PatternTree.GetItemText(item) == 'Peak List':
2819	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2820	for i in G2frame.ExportPeakList: i.Enable(True)
2821	G2frame.PickId = item
2822	data = G2frame.PatternTree.GetItemPyData(item)
2823	G2pdG.UpdatePeakGrid(G2frame,data)
2824	G2plt.PlotPatterns(G2frame)
2825	elif G2frame.PatternTree.GetItemText(item) == 'Background':
2826	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2827	G2frame.PickId = item
2828	data = G2frame.PatternTree.GetItemPyData(item)
2829	G2pdG.UpdateBackground(G2frame,data)
2830	G2plt.PlotPatterns(G2frame)
2831	elif G2frame.PatternTree.GetItemText(item) == 'Limits':
2832	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2833	G2frame.PickId = item
2834	data = G2frame.PatternTree.GetItemPyData(item)
2835	G2pdG.UpdateLimitsGrid(G2frame,data)
2836	G2plt.PlotPatterns(G2frame)
2837	elif G2frame.PatternTree.GetItemText(item) == 'Instrument Parameters':
2838	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2839	G2frame.PickId = item
2840	data = G2frame.PatternTree.GetItemPyData(item)[0]
2841	G2pdG.UpdateInstrumentGrid(G2frame,data)
2842	G2plt.PlotPeakWidths(G2frame)
2843	elif G2frame.PatternTree.GetItemText(item) == 'Sample Parameters':
2844	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2845	G2frame.PickId = item
2846	data = G2frame.PatternTree.GetItemPyData(item)
2847
2848	if 'Temperature' not in data: #temp fix for old gpx files
2849	data = {'Scale':[1.0,True],'Type':'Debye-Scherrer','Absorption':[0.0,False],'DisplaceX':[0.0,False],
2850	'DisplaceY':[0.0,False],'Diffuse':[],'Temperature':300.,'Pressure':1.0,'Humidity':0.0,'Voltage':0.0,
2851	'Force':0.0,'Gonio. radius':200.0}
2852	G2frame.PatternTree.SetItemPyData(item,data)
2853
2854	G2pdG.UpdateSampleGrid(G2frame,data)
2855	G2plt.PlotPatterns(G2frame)
2856	elif G2frame.PatternTree.GetItemText(item) == 'Index Peak List':
2857	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2858	for i in G2frame.ExportPeakList: i.Enable(True)
2859	G2frame.PickId = item
2860	data = G2frame.PatternTree.GetItemPyData(item)
2861	G2pdG.UpdateIndexPeaksGrid(G2frame,data)
2862	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
2863	G2plt.PlotPowderLines(G2frame)
2864	else:
2865	G2plt.PlotPatterns(G2frame)
2866	elif G2frame.PatternTree.GetItemText(item) == 'Unit Cells List':
2867	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2868	G2frame.PickId = item
2869	data = G2frame.PatternTree.GetItemPyData(item)
2870	if not data:
2871	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
2872	data.append([0,0,0,0,0,0,0,0,0,0,0,0,0,0]) #Bravais lattice flags
2873	data.append([]) #empty cell list
2874	data.append([]) #empty dmin
2875	G2frame.PatternTree.SetItemPyData(item,data)
2876	G2pdG.UpdateUnitCellsGrid(G2frame,data)
2877	if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
2878	G2plt.PlotPowderLines(G2frame)
2879	else:
2880	G2plt.PlotPatterns(G2frame)
2881	elif G2frame.PatternTree.GetItemText(item) == 'Reflection Lists': #powder reflections
2882	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2883	G2frame.PickId = item
2884	data = G2frame.PatternTree.GetItemPyData(item)
2885	G2frame.RefList = ''
2886	if len(data):
2887	G2frame.RefList = data.keys()[0]
2888	G2pdG.UpdateReflectionGrid(G2frame,data)
2889	G2plt.PlotPatterns(G2frame)
2890	elif G2frame.PatternTree.GetItemText(item) == 'Reflection List': #HKLF reflections
2891	G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
2892	name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
2893	data = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
2894	G2pdG.UpdateReflectionGrid(G2frame,data,HKLF=True,Name=name)
2895
2896	def SetDataMenuBar(G2frame,menu=None):
2897	'''Set the menu for the data frame. On the Mac put this
2898	menu for the data tree window instead.
2899
2900	Note that data frame items do not have menus, for these (menu=None)
2901	display a blank menu or on the Mac display the standard menu for
2902	the data tree window.
2903	'''
2904	if sys.platform == "darwin":
2905	if menu is None:
2906	G2frame.SetMenuBar(G2frame.GSASIIMenu)
2907	else:
2908	G2frame.SetMenuBar(menu)
2909	else:
2910	if menu is None:
2911	G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
2912	else:
2913	G2frame.dataFrame.SetMenuBar(menu)
2914
2915	def HorizontalLine(sizer,parent):
2916	'''Draws a horizontal line as wide as the window.
2917	This shows up on the Mac as a very thin line, no matter what I do
2918	'''
2919	line = wx.StaticLine(parent,-1, size=(-1,3), style=wx.LI_HORIZONTAL)
2920	sizer.Add(line, 0, wx.EXPAND\|wx.ALIGN_CENTER\|wx.ALL, 10)
2921
2922	if __name__ == '__main__':
2923	# test ScrolledMultiEditor
2924	app = wx.PySimpleApp()
2925	frm = wx.Frame(None) # create a frame
2926	frm.Show(True)
2927	Data1 = {
2928	'Order':0,
2929	'omega':'string',
2930	'chi':2.0,
2931	'phi':'',
2932	}
2933	elemlst = sorted(Data1.keys())
2934	postlbl = sorted(Data1.keys())
2935	dictlst = len(elemlst)*[Data1,]
2936
2937	Data2 = list(range(100))
2938	elemlst += range(2,60)
2939	postlbl += range(2,60)
2940	dictlst += len(range(2,60))*[Data2,]
2941
2942	prelbl = range(len(elemlst))
2943	postlbl[1] = "a very long label for the 2nd item to force a horiz. scrollbar"
2944	header="""This is a longer\nmultiline and perhaps silly header"""
2945	dlg = ScrolledMultiEditor(frm,dictlst,elemlst,prelbl,postlbl,
2946	header=header)
2947	print Data1
2948	if dlg.ShowModal() == wx.ID_OK:
2949	for d,k in zip(dictlst,elemlst):
2950	print k,d[k]
2951	#app.MainLoop()

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

Download in other formats: