Changeset 468 for trunk

Timestamp:

Feb 2, 2012 11:27:53 AM (13 years ago)

Author:

vondreele

Message:

changed self to G2frame everywhere in all "sub" files that use it
fixed creation of 'bak' files
now force save of a new gpx file before 1st peak fit so
GSAS.save is put in a sensible directory

Location:

trunk

Files:

• GSASII.py (modified) (1 diff)
• GSASIIIO.py (modified) (24 diffs)
• GSASIIgrid.py (modified) (37 diffs)
• GSASIIimgGUI.py (modified) (52 diffs)
• GSASIIphsGUI.py (modified) (88 diffs)
• GSASIIplot.py (modified) (100 diffs)
• GSASIIpwdGUI.py (modified) (100 diffs)

trunk/GSASII.py ¶

@@ -1139 +1139 @@
         dlg = wx.FileDialog(self, 'Choose GSAS-II project file name', '.', '', 
             'GSAS-II project file (*.gpx)|*.gpx',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
-        if self.dirname:
-            dlg.SetDirectory(self.dirname)
         try:
             if dlg.ShowModal() == wx.ID_OK:

trunk/GSASIIIO.py ¶

@@ -36 +36 @@
         return 0
 
-def SelectPowderData(self, filename):
+def SelectPowderData(G2frame, filename):
     """Selects banks of data from a filename of any GSAS powder data format
     Input - filename: any GSAS powder data formatted file (currently STD, FXYE, FXY & ESD)
@@ -48 +48 @@
 First line of this file:
 '''+File.readline()
-    dlg = wx.MessageDialog(self, Title, 'Is this the file you want?', 
+    dlg = wx.MessageDialog(G2frame, Title, 'Is this the file you want?', 
         wx.YES_NO | wx.ICON_QUESTION)
     try:
@@ -58 +58 @@
     
     if '.xye' in filename:      #Topas style xye file (e.g. 2-th, I, sig) - no iparm file/no BANK record
-        dlg = wx.MessageDialog(self,'''Is this laboratory Cu Ka1/Ka2 data? 
+        dlg = wx.MessageDialog(G2frame,'''Is this laboratory Cu Ka1/Ka2 data? 
 (No = 0.6A wavelength synchrotron data)
 Change wavelength in Instrument Parameters if needed''','Data type?',
@@ -84 +84 @@
         
     else:                       #GSAS style fxye or fxy file (e.g. 100*2-th, I, sig)
-        self.IparmName = GetInstrumentFile(self,filename)
-        if self.IparmName:
-            Iparm = GetInstrumentData(self.IparmName)
+        G2frame.IparmName = GetInstrumentFile(G2frame,filename)
+        if G2frame.IparmName:
+            Iparm = GetInstrumentData(G2frame.IparmName)
         else:
             Iparm = {}                                               #Assume CuKa lab data if no iparm file
@@ -124 +124 @@
         result = [0]
         if len(Banks) >= 2:
-            dlg = wx.MultiChoiceDialog(self, 'Which scans do you want?', 'Select scans', Banks, wx.CHOICEDLG_STYLE)
+            dlg = wx.MultiChoiceDialog(G2frame, 'Which scans do you want?', 'Select scans', Banks, wx.CHOICEDLG_STYLE)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -135 +135 @@
             FoundData.append((filename,Pos[i],Banks[i]))
     else:
-        dlg = wx.MessageDialog(self, 'ERROR - this is not a GSAS powder data file', 'No BANK records', wx.OK | wx.ICON_ERROR)
+        dlg = wx.MessageDialog(G2frame, 'ERROR - this is not a GSAS powder data file', 'No BANK records', wx.OK | wx.ICON_ERROR)
         try:
             result = dlg.ShowModal()
@@ -142 +142 @@
     return FoundData,Iparm,Comments,Temperature
 
-def GetInstrumentFile(self,filename):
+def GetInstrumentFile(G2frame,filename):
     import os.path as op
-    dlg = wx.FileDialog(self,'Choose an instrument file','.', '', 'GSAS iparm file (*.prm)|*.prm|All files(*.*)|*.*', 
+    dlg = wx.FileDialog(G2frame,'Choose an instrument file','.', '', 'GSAS iparm file (*.prm)|*.prm|All files(*.*)|*.*', 
         wx.OPEN|wx.CHANGE_DIR)
     Tname = filename[:filename.index('.')]+'.prm'
     if op.exists(Tname):
-        self.IparmName = Tname        
-    if self.IparmName: dlg.SetFilename(self.IparmName)
+        G2frame.IparmName = Tname        
+    if G2frame.IparmName: dlg.SetFilename(G2frame.IparmName)
     filename = ''
     try:
@@ -472 +472 @@
     return [np.array(x),np.array(y),np.array(w),np.zeros(N),np.zeros(N),np.zeros(N)]
     
-def CheckImageFile(self,imagefile):
+def CheckImageFile(G2frame,imagefile):
     if not ospath.exists(imagefile):
-        dlg = wx.FileDialog(self, 'Bad image file name; choose name', '.', '',\
+        dlg = wx.FileDialog(G2frame, 'Bad image file name; choose name', '.', '',\
         'Any image file (*.tif;*.tiff;*.mar*;*.avg;*.sum;*.img)\
         |*.tif;*.tiff;*.mar*;*.avg;*.sum;*.img|\
@@ -492 +492 @@
     return imagefile
         
-def GetImageData(self,imagefile,imageOnly=False):        
+def GetImageData(G2frame,imagefile,imageOnly=False):        
     ext = ospath.splitext(imagefile)[1]
     Comments = []
@@ -795 +795 @@
         return head,data,Npix,image
     
-def ProjFileOpen(self):
-    file = open(self.GSASprojectfile,'rb')
-    print 'load from file: ',self.GSASprojectfile
+def ProjFileOpen(G2frame):
+    file = open(G2frame.GSASprojectfile,'rb')
+    print 'load from file: ',G2frame.GSASprojectfile
     wx.BeginBusyCursor()
     try:
@@ -807 +807 @@
             datum = data[0]
             
-            Id = self.PatternTree.AppendItem(parent=self.root,text=datum[0])
+            Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=datum[0])
             if 'PWDR' in datum[0]:                
-                self.PatternTree.SetItemPyData(Id,datum[1][:3])     #temp. trim off junk
+                G2frame.PatternTree.SetItemPyData(Id,datum[1][:3])     #temp. trim off junk
             else:
-                self.PatternTree.SetItemPyData(Id,datum[1])
+                G2frame.PatternTree.SetItemPyData(Id,datum[1])
             for datus in data[1:]:
-                sub = self.PatternTree.AppendItem(Id,datus[0])
-                self.PatternTree.SetItemPyData(sub,datus[1])
+                sub = G2frame.PatternTree.AppendItem(Id,datus[0])
+                G2frame.PatternTree.SetItemPyData(sub,datus[1])
             if 'IMG' in datum[0]:                   #retreive image default flag & data if set
-                Data = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Image Controls'))
+                Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls'))
                 if Data['setDefault']:
-                    self.imageDefault = Data                
+                    G2frame.imageDefault = Data                
         file.close()
         
@@ -824 +824 @@
         wx.EndBusyCursor()
     print 'project load successful'
-    self.NewPlot = True
-    
-def ProjFileSave(self):
-    if not self.PatternTree.IsEmpty():
-        file = open(self.GSASprojectfile,'wb')
-        print 'save to file: ',self.GSASprojectfile
+    G2frame.NewPlot = True
+    
+def ProjFileSave(G2frame):
+    if not G2frame.PatternTree.IsEmpty():
+        file = open(G2frame.GSASprojectfile,'wb')
+        print 'save to file: ',G2frame.GSASprojectfile
         wx.BeginBusyCursor()
         try:
-            item, cookie = self.PatternTree.GetFirstChild(self.root)
+            item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
             while item:
                 data = []
-                name = self.PatternTree.GetItemText(item)
-                data.append([name,self.PatternTree.GetItemPyData(item)])
-                item2, cookie2 = self.PatternTree.GetFirstChild(item)
+                name = G2frame.PatternTree.GetItemText(item)
+                data.append([name,G2frame.PatternTree.GetItemPyData(item)])
+                item2, cookie2 = G2frame.PatternTree.GetFirstChild(item)
                 while item2:
-                    name = self.PatternTree.GetItemText(item2)
-                    data.append([name,self.PatternTree.GetItemPyData(item2)])
-                    item2, cookie2 = self.PatternTree.GetNextChild(item, cookie2)                            
-                item, cookie = self.PatternTree.GetNextChild(self.root, cookie)                            
+                    name = G2frame.PatternTree.GetItemText(item2)
+                    data.append([name,G2frame.PatternTree.GetItemPyData(item2)])
+                    item2, cookie2 = G2frame.PatternTree.GetNextChild(item, cookie2)                            
+                item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)                            
                 cPickle.dump(data,file,1)
             file.close()
@@ -1047 +1047 @@
     for name in files:
         name = name.split('.')
-        if len(name) == 3 and name[0] == Name and 'bak' in name[1]:
+        if len(name) >= 3 and name[0] == Name and 'bak' in name[-2]:
             if makeBack:
-                last = max(last,int(name[1].strip('bak'))+1)
+                last = max(last,int(name[-2].strip('bak'))+1)
             else:
-                last = max(last,int(name[1].strip('bak')))
-    GPXback = ospath.join(GPXpath,ospath.splitext(GPXname)[0]+'.bak'+str(last)+'.gpx')
+                last = max(last,int(name[-2].strip('bak')))
+    GPXback = ospath.join(GPXpath,GPXname.rstrip('.'.join(name[-2:]))+'.bak'+str(last)+'.gpx')
     dfu.copy_file(GPXfile,GPXback)
     return GPXback
@@ -1186 +1186 @@
     return HKLFdata
     
-def SaveIntegration(self,PickId,data):
-    azms = self.Integrate[1]
-    X = self.Integrate[2][:-1]
+def SaveIntegration(G2frame,PickId,data):
+    azms = G2frame.Integrate[1]
+    X = G2frame.Integrate[2][:-1]
     Xminmax = [X[0],X[-1]]
     N = len(X)
-    Id = self.PatternTree.GetItemParent(PickId)
-    name = self.PatternTree.GetItemText(Id)
+    Id = G2frame.PatternTree.GetItemParent(PickId)
+    name = G2frame.PatternTree.GetItemText(Id)
     name = name.replace('IMG ','PWDR ')
-    Comments = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,Id, 'Comments'))
+    Comments = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Comments'))
     names = ['Type','Lam','Zero','Polariz.','U','V','W','X','Y','SH/L','Azimuth'] 
     codes = [0 for i in range(11)]
@@ -1205 +1205 @@
             Azms.append((azms[i+1]+azm)/2.)
     for i,azm in enumerate(azms[:-1]):
-        item, cookie = self.PatternTree.GetFirstChild(self.root)
+        item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
         Id = 0
         while item:
-            Name = self.PatternTree.GetItemText(item)
+            Name = G2frame.PatternTree.GetItemText(item)
             if name == Name:
                 Id = item
-            item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+            item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
         parms = ['PXC',data['wavelength'],0.0,0.99,1.0,-0.10,0.4,0.30,1.0,0.0001,Azms[i]]    #set polarization for synchrotron radiation!
-        Y = self.Integrate[0][i]
+        Y = G2frame.Integrate[0][i]
         W = 1./Y                    #probably not true
         Sample = G2pdG.SetDefaultSample()
         if Id:
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id, 'Comments'),Comments)                    
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Limits'),[tuple(Xminmax),Xminmax])
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Background'),[['chebyschev',1,3,1.0,0.0,0.0],
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Comments'),Comments)                    
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),[tuple(Xminmax),Xminmax])
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),[['chebyschev',1,3,1.0,0.0,0.0],
                             {'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]}])
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Instrument Parameters'),[tuple(parms),parms[:],codes,names])
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Peak List'),[])
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Index Peak List'),[])
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Unit Cells List'),[])             
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Reflection Lists'),{})             
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'),[tuple(parms),parms[:],codes,names])
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Peak List'),[])
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Index Peak List'),[])
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Unit Cells List'),[])             
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Reflection Lists'),{})             
         else:
-            Id = self.PatternTree.AppendItem(parent=self.root,text=name+" Azm= %.2f"%(Azms[i]))
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Comments'),Comments)                    
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Limits'),[tuple(Xminmax),Xminmax])
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Background'),[['chebyschev',1,3,1.0,0.0,0.0],
+            Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=name+" Azm= %.2f"%(Azms[i]))
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Comments'),Comments)                    
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Limits'),[tuple(Xminmax),Xminmax])
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Background'),[['chebyschev',1,3,1.0,0.0,0.0],
                             {'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]}])
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Instrument Parameters'),[tuple(parms),parms[:],codes,names])
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Sample Parameters'),Sample)
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Peak List'),[])
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Index Peak List'),[])
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Unit Cells List'),[])
-            self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Reflection Lists'),{})             
-        self.PatternTree.SetItemPyData(Id,[[''],[np.array(X),np.array(Y),np.array(W),np.zeros(N),np.zeros(N),np.zeros(N)]])
-    self.PatternTree.SelectItem(Id)
-    self.PatternTree.Expand(Id)
-    self.PatternId = Id
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Instrument Parameters'),[tuple(parms),parms[:],codes,names])
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Sample Parameters'),Sample)
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Peak List'),[])
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Index Peak List'),[])
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Unit Cells List'),[])
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Reflection Lists'),{})             
+        G2frame.PatternTree.SetItemPyData(Id,[[''],[np.array(X),np.array(Y),np.array(W),np.zeros(N),np.zeros(N),np.zeros(N)]])
+    G2frame.PatternTree.SelectItem(Id)
+    G2frame.PatternTree.Expand(Id)
+    G2frame.PatternId = Id
             
-def powderFxyeSave(self,exports,powderfile):
+def powderFxyeSave(G2frame,exports,powderfile):
     head,tail = ospath.split(powderfile)
     name,ext = tail.split('.')
@@ -1251 +1251 @@
         prmname = filename.strip(ext)+'prm'
         prm = open(prmname,'w')      #old style GSAS parm file
-        PickId = G2gd.GetPatternTreeItemId(self, self.root, export)
-        Values,Names = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self, \
+        PickId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, export)
+        Values,Names = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame, \
             PickId, 'Instrument Parameters'))[1::2]     #get values & names
         Inst = dict(zip(Names,Values))
@@ -1274 +1274 @@
         print 'save powder pattern to file: ',filename
         try:
-            x,y,w,yc,yb,yd = self.PatternTree.GetItemPyData(PickId)[1]
+            x,y,w,yc,yb,yd = G2frame.PatternTree.GetItemPyData(PickId)[1]
             file.write(powderfile+'\n')
             file.write('BANK 1 %d %d CONS %.2f %.2f 0 0 FXYE\n'%(len(x),len(x),\
@@ -1287 +1287 @@
         print 'powder pattern file written'
         
-def powderXyeSave(self,exports,powderfile):
+def powderXyeSave(G2frame,exports,powderfile):
     head,tail = ospath.split(powderfile)
     name,ext = tail.split('.')
     for i,export in enumerate(exports):
         filename = ospath.join(head,name+'-%03d.'%(i)+ext)
-        PickId = G2gd.GetPatternTreeItemId(self, self.root, export)
+        PickId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, export)
         file = open(filename,'w')
         file.write('#%s\n'%(export))
@@ -1298 +1298 @@
         wx.BeginBusyCursor()
         try:
-            x,y,w,yc,yb,yd = self.PatternTree.GetItemPyData(PickId)[1]
+            x,y,w,yc,yb,yd = G2frame.PatternTree.GetItemPyData(PickId)[1]
             s = list(np.sqrt(1./np.array(w)))        
             XYW = zip(x,y,s)
@@ -1308 +1308 @@
         print 'powder pattern file written'
         
-def PDFSave(self,exports):    
+def PDFSave(G2frame,exports):    
     for export in exports:
-        PickId = G2gd.GetPatternTreeItemId(self, self.root, export)
+        PickId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, export)
         SQname = 'S(Q)'+export[4:]
         GRname = 'G(R)'+export[4:]
-        sqfilename = ospath.join(self.dirname,export.replace(' ','_')[5:]+'.sq')
-        grfilename = ospath.join(self.dirname,export.replace(' ','_')[5:]+'.gr')
-        sqId = G2gd.GetPatternTreeItemId(self, PickId, SQname)
-        grId = G2gd.GetPatternTreeItemId(self, PickId, GRname)
-        sqdata = np.array(self.PatternTree.GetItemPyData(sqId)[1][:2]).T
-        grdata = np.array(self.PatternTree.GetItemPyData(grId)[1][:2]).T
+        sqfilename = ospath.join(G2frame.dirname,export.replace(' ','_')[5:]+'.sq')
+        grfilename = ospath.join(G2frame.dirname,export.replace(' ','_')[5:]+'.gr')
+        sqId = G2gd.GetPatternTreeItemId(G2frame, PickId, SQname)
+        grId = G2gd.GetPatternTreeItemId(G2frame, PickId, GRname)
+        sqdata = np.array(G2frame.PatternTree.GetItemPyData(sqId)[1][:2]).T
+        grdata = np.array(G2frame.PatternTree.GetItemPyData(grId)[1][:2]).T
         sqfile = open(sqfilename,'w')
         grfile = open(grfilename,'w')
@@ -1332 +1332 @@
         grfile.close()
     
-def PeakListSave(self,file,peaks):
-    print 'save peak list to file: ',self.peaklistfile
+def PeakListSave(G2frame,file,peaks):
+    print 'save peak list to file: ',G2frame.peaklistfile
     if not peaks:
-        dlg = wx.MessageDialog(self, 'No peaks!', 'Nothing to save!', wx.OK)
+        dlg = wx.MessageDialog(G2frame, 'No peaks!', 'Nothing to save!', wx.OK)
         try:
             result = dlg.ShowModal()
@@ -1346 +1346 @@
     print 'peak list saved'
               
-def IndexPeakListSave(self,peaks):
-    file = open(self.peaklistfile,'wa')
-    print 'save index peak list to file: ',self.peaklistfile
+def IndexPeakListSave(G2frame,peaks):
+    file = open(G2frame.peaklistfile,'wa')
+    print 'save index peak list to file: ',G2frame.peaklistfile
     wx.BeginBusyCursor()
     try:
         if not peaks:
-            dlg = wx.MessageDialog(self, 'No peaks!', 'Nothing to save!', wx.OK)
+            dlg = wx.MessageDialog(G2frame, 'No peaks!', 'Nothing to save!', wx.OK)
             try:
                 result = dlg.ShowModal()
@@ -1365 +1365 @@
     print 'index peak list saved'
     
-def ReadEXPPhase(self,filename):
+def ReadEXPPhase(G2frame,filename):
     shModels = ['cylindrical','none','shear - 2/m','rolling - mmm']
     textureData = {'Order':0,'Model':'cylindrical','Sample omega':[False,0.0],
@@ -1390 +1390 @@
             PNames.append(Expr[n][key])
     if Num < 8:
-        dlg = wx.SingleChoiceDialog(self, 'Which phase to read?', 'Read phase data', PNames, wx.CHOICEDLG_STYLE)
+        dlg = wx.SingleChoiceDialog(G2frame, 'Which phase to read?', 'Read phase data', PNames, wx.CHOICEDLG_STYLE)
         try:
             if dlg.ShowModal() == wx.ID_OK:

trunk/GSASIIgrid.py ¶

@@ -708 +708 @@
         innerSetValue(row, col, value)
                 
-def UpdateNotebook(self,data):        
+def UpdateNotebook(G2frame,data):        
     if data:
-        self.dataFrame.SetLabel('Notebook')
-        self.dataDisplay = wx.TextCtrl(parent=self.dataFrame,size=self.dataFrame.GetClientSize(),
+        G2frame.dataFrame.SetLabel('Notebook')
+        G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
             style=wx.TE_MULTILINE|wx.TE_PROCESS_ENTER | wx.TE_DONTWRAP)
         for line in data:
-            self.dataDisplay.AppendText(line+"\n")
-            self.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
-            
-def UpdateControls(self,data):
+            G2frame.dataDisplay.AppendText(line+"\n")
+            G2frame.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
+            
+def UpdateControls(G2frame,data):
     #patch
     if 'deriv type' not in data:
@@ -737 +737 @@
         
         def OnSelectData(event):
-            choices = ['All',]+GetPatternTreeDataNames(self,['PWDR',])
+            choices = ['All',]+GetPatternTreeDataNames(G2frame,['PWDR',])
             sel = []
             if 'Seq Data' in data:
@@ -743 +743 @@
                     sel.append(choices.index(item))
             names = []
-            dlg = wx.MultiChoiceDialog(self,'Select data:','Sequential refinement',choices)
+            dlg = wx.MultiChoiceDialog(G2frame,'Select data:','Sequential refinement',choices)
             dlg.SetSelections(sel)
             if dlg.ShowModal() == wx.ID_OK:
@@ -758 +758 @@
                     
         seqSizer = wx.BoxSizer(wx.HORIZONTAL)
-        seqSizer.Add(wx.StaticText(self.dataDisplay,label=' Sequential Refinement Powder Data: '),0,wx.ALIGN_CENTER_VERTICAL)
-        selSeqData = wx.Button(self.dataDisplay,-1,label=' Select data')
+        seqSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sequential Refinement Powder Data: '),0,wx.ALIGN_CENTER_VERTICAL)
+        selSeqData = wx.Button(G2frame.dataDisplay,-1,label=' Select data')
         selSeqData.Bind(wx.EVT_BUTTON,OnSelectData)
         seqSizer.Add(selSeqData,0,wx.ALIGN_CENTER_VERTICAL)
         seqSizer.Add((5,0),0)
-        reverseSel = wx.CheckBox(self.dataDisplay,-1,label=' Reverse order?')
+        reverseSel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Reverse order?')
         reverseSel.Bind(wx.EVT_CHECKBOX,OnReverse)
         if 'Seq Data' not in data:
@@ -777 +777 @@
             data['deriv type'] = derivSel.GetValue()
             derivSel.SetValue(data['deriv type'])
-            wx.CallAfter(UpdateControls,self,data)
+            wx.CallAfter(UpdateControls,G2frame,data)
             
         def OnConvergence(event):
@@ -800 +800 @@
         
         LSSizer = wx.FlexGridSizer(cols=6,vgap=5,hgap=5)
-        LSSizer.Add(wx.StaticText(self.dataDisplay,label=' Refinement derivatives: '),0,wx.ALIGN_CENTER_VERTICAL)
+        LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement derivatives: '),0,wx.ALIGN_CENTER_VERTICAL)
         Choice=['analytic Jacobian','numeric','analytic Hessian']
-        derivSel = wx.ComboBox(parent=self.dataDisplay,value=data['deriv type'],choices=Choice,
+        derivSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['deriv type'],choices=Choice,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         derivSel.SetValue(data['deriv type'])
@@ -808 +808 @@
             
         LSSizer.Add(derivSel,0,wx.ALIGN_CENTER_VERTICAL)
-        LSSizer.Add(wx.StaticText(self.dataDisplay,label=' Min delta-M/M: '),0,wx.ALIGN_CENTER_VERTICAL)
-        Cnvrg = wx.TextCtrl(self.dataDisplay,-1,value='%.2g'%(data['min dM/M']),style=wx.TE_PROCESS_ENTER)
+        LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min delta-M/M: '),0,wx.ALIGN_CENTER_VERTICAL)
+        Cnvrg = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2g'%(data['min dM/M']),style=wx.TE_PROCESS_ENTER)
         Cnvrg.Bind(wx.EVT_TEXT_ENTER,OnConvergence)
         Cnvrg.Bind(wx.EVT_KILL_FOCUS,OnConvergence)
         LSSizer.Add(Cnvrg,0,wx.ALIGN_CENTER_VERTICAL)
         if 'Hessian' in data['deriv type']:
-            LSSizer.Add(wx.StaticText(self.dataDisplay,label=' Max cycles: '),0,wx.ALIGN_CENTER_VERTICAL)
+            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max cycles: '),0,wx.ALIGN_CENTER_VERTICAL)
             Choice = ['0','1','2','3','5','10','15','20']
-            maxCyc = wx.ComboBox(parent=self.dataDisplay,value=str(data['max cyc']),choices=Choice,
+            maxCyc = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['max cyc']),choices=Choice,
                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
             maxCyc.SetValue(str(data['max cyc']))
@@ -822 +822 @@
             LSSizer.Add(maxCyc,0,wx.ALIGN_CENTER_VERTICAL)
         else:
-            LSSizer.Add(wx.StaticText(self.dataDisplay,label=' Initial shift factor: '),0,wx.ALIGN_CENTER_VERTICAL)
-            Factr = wx.TextCtrl(self.dataDisplay,-1,value='%.5f'%(data['shift factor']),style=wx.TE_PROCESS_ENTER)
+            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial shift factor: '),0,wx.ALIGN_CENTER_VERTICAL)
+            Factr = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.5f'%(data['shift factor']),style=wx.TE_PROCESS_ENTER)
             Factr.Bind(wx.EVT_TEXT_ENTER,OnFactor)
             Factr.Bind(wx.EVT_KILL_FOCUS,OnFactor)
@@ -829 +829 @@
         return LSSizer
         
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
         Status.SetStatusText('')
-    self.dataFrame.SetLabel('Controls')
-    self.dataDisplay = wx.Panel(self.dataFrame)
-    self.dataFrame.SetMenuBar(self.dataFrame.ControlsMenu)
+    G2frame.dataFrame.SetLabel('Controls')
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.ControlsMenu)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,5),0)
-    mainSizer.Add(wx.StaticText(self.dataDisplay,label=' Refinement Controls:'),0,wx.ALIGN_CENTER_VERTICAL)    
+    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement Controls:'),0,wx.ALIGN_CENTER_VERTICAL)    
     mainSizer.Add(LSSizer())
     mainSizer.Add((5,5),0)
@@ -845 +845 @@
     mainSizer.Add((5,5),0)
         
-    mainSizer.Add(wx.StaticText(self.dataDisplay,label=' Density Map Controls:'),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Density Map Controls:'),0,wx.ALIGN_CENTER_VERTICAL)
 
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    self.dataDisplay.SetSize(mainSizer.Fit(self.dataFrame))
-    self.dataFrame.setSizePosLeft(mainSizer.Fit(self.dataFrame))
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
+    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
      
-def UpdateComments(self,data):                   
-    self.dataFrame.SetLabel('Comments')
-    self.dataDisplay = wx.TextCtrl(parent=self.dataFrame,size=self.dataFrame.GetClientSize(),
+def UpdateComments(G2frame,data):                   
+    G2frame.dataFrame.SetLabel('Comments')
+    G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
         style=wx.TE_MULTILINE|wx.TE_PROCESS_ENTER | wx.TE_DONTWRAP)
     for line in data:
         if line[-1] == '\n':
-            self.dataDisplay.AppendText(line)
+            G2frame.dataDisplay.AppendText(line)
         else:
-            self.dataDisplay.AppendText(line+'\n')
-            
-def UpdateSeqResults(self,data):
+            G2frame.dataDisplay.AppendText(line+'\n')
+            
+def UpdateSeqResults(G2frame,data):
     """ 
     input:
@@ -886 +886 @@
         sampleParm = {}
         for name in histNames:
-            Id = GetPatternTreeItemId(self,self.root,name)
-            sampleData = self.PatternTree.GetItemPyData(GetPatternTreeItemId(self,Id,'Sample Parameters'))
+            Id = GetPatternTreeItemId(G2frame,G2frame.root,name)
+            sampleData = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
             for item in sampleParmDict:
                 sampleParmDict[item].append(sampleData[item])
@@ -909 +909 @@
     
     def Select(event):
-        cols = self.dataDisplay.GetSelectedCols()
-        rows = self.dataDisplay.GetSelectedRows()
+        cols = G2frame.dataDisplay.GetSelectedCols()
+        rows = G2frame.dataDisplay.GetSelectedRows()
         if cols:
             plotData = []
@@ -916 +916 @@
             plotNames = []
             for col in cols:
-                plotData.append(self.SeqTable.GetColValues(col))
+                plotData.append(G2frame.SeqTable.GetColValues(col))
                 plotSig.append(GetSigData(col))
-                plotNames.append(self.SeqTable.GetColLabelValue(col))
+                plotNames.append(G2frame.SeqTable.GetColLabelValue(col))
             plotData = np.array(plotData)
-            G2plt.PlotSeq(self,plotData,plotSig,plotNames,sampleParms)
+            G2plt.PlotSeq(G2frame,plotData,plotSig,plotNames,sampleParms)
         elif rows:
             name = histNames[rows[0]]
-            G2plt.PlotCovariance(self,Data=data[name])
+            G2plt.PlotCovariance(G2frame,Data=data[name])
                
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
     cellList = {}
     newCellDict = data[histNames[0]]['newCellDict']
@@ -938 +938 @@
             atomList[newAtomDict[item][0]] = item
     sampleParms = GetSampleParms()
-    self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
-    self.dataFrame.SetLabel('Sequental refinement results')
-    self.dataFrame.CreateStatusBar()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
+    G2frame.dataFrame.SetLabel('Sequental refinement results')
+    G2frame.dataFrame.CreateStatusBar()
     colLabels = data['varyList']+atomList.keys()+cellList.keys()
     Types = len(data['varyList']+atomList.keys()+cellList.keys())*[wg.GRID_VALUE_FLOAT,]
@@ -950 +950 @@
         item += [newAtomDict[atomList[parm]][1] for parm in atomList.keys()]
         item += [newCellDict[cellList[parm]][1] for parm in cellList.keys()]
-    self.SeqTable = Table(seqList,colLabels=colLabels,rowLabels=histNames,types=Types)
-    self.dataDisplay = GSGrid(parent=self.dataFrame)
-    self.dataDisplay.SetTable(self.SeqTable, True)
-    self.dataDisplay.EnableEditing(False)
-    self.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, Select)
-    self.dataDisplay.SetRowLabelSize(8*len(histNames[0]))       #pretty arbitrary 8
-    self.dataDisplay.SetMargins(0,0)
-    self.dataDisplay.AutoSizeColumns(True)
-    self.dataFrame.setSizePosLeft([700,350])
+    G2frame.SeqTable = Table(seqList,colLabels=colLabels,rowLabels=histNames,types=Types)
+    G2frame.dataDisplay = GSGrid(parent=G2frame.dataFrame)
+    G2frame.dataDisplay.SetTable(G2frame.SeqTable, True)
+    G2frame.dataDisplay.EnableEditing(False)
+    G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, Select)
+    G2frame.dataDisplay.SetRowLabelSize(8*len(histNames[0]))       #pretty arbitrary 8
+    G2frame.dataDisplay.SetMargins(0,0)
+    G2frame.dataDisplay.AutoSizeColumns(True)
+    G2frame.dataFrame.setSizePosLeft([700,350])
     
-def UpdateConstraints(self,data):             
+def UpdateConstraints(G2frame,data):             
 #    data.update({'Hist':[],'HAP':[],'Phase':[]})       #empty dict - fill it
     if not data:
         data.update({'Hist':[],'HAP':[],'Phase':[]})       #empty dict - fill it
-    Histograms,Phases = self.GetUsedHistogramsAndPhasesfromTree()
+    Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
     AtomDict = dict([Phases[phase]['pId'],Phases[phase]['Atoms']] for phase in Phases)
     Natoms,phaseVary,phaseDict,pawleyLookup,FFtable,BLtable = G2str.GetPhaseData(Phases,Print=False)
@@ -991 +991 @@
     Indx = {}
     scope = {}                          #filled out later
-    self.Page = [0,'phs']
+    G2frame.Page = [0,'phs']
     
     def GetPHlegends(Phases,Histograms):
@@ -1034 +1034 @@
         if page[1] == 'phs':
             atchoice = [item+' for '+phaseAtNames[item] for item in varList]
-            dlg = wx.MultiChoiceDialog(self,'Select more variables:'+legend,FrstVarb+' and:',atchoice)
+            dlg = wx.MultiChoiceDialog(G2frame,'Select more variables:'+legend,FrstVarb+' and:',atchoice)
         else:
-            dlg = wx.MultiChoiceDialog(self,'Select more variables:'+legend,FrstVarb+' and:',varList)
+            dlg = wx.MultiChoiceDialog(G2frame,'Select more variables:'+legend,FrstVarb+' and:',varList)
         varbs = [FrstVarb,]
         if dlg.ShowModal() == wx.ID_OK:
@@ -1062 +1062 @@
             Atoms = Phase['Atoms']
         constr = []
-        page = self.Page
+        page = G2frame.Page
         choice = scope[page[1]]
         if page[1] == 'phs':
             atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],atchoice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
         else:    
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],choice[2])
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
         if dlg.ShowModal() == wx.ID_OK:
             sel = dlg.GetSelection()
@@ -1078 +1078 @@
     def OnAddEquivalence(event):
         constr = []
-        page = self.Page
+        page = G2frame.Page
         choice = scope[page[1]]
         if page[1] == 'phs':
             atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],atchoice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
         else:    
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],choice[2])
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
         if dlg.ShowModal() == wx.ID_OK:
             sel = dlg.GetSelection()
@@ -1097 +1097 @@
     def OnAddFunction(event):
         constr = []
-        page = self.Page
+        page = G2frame.Page
         choice = scope[page[1]]
         if page[1] == 'phs':
             atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],atchoice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
         else:    
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],choice[2])
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
         if dlg.ShowModal() == wx.ID_OK:
             sel = dlg.GetSelection()
@@ -1116 +1116 @@
     def OnAddConstraint(event):
         constr = []
-        page = self.Page
+        page = G2frame.Page
         choice = scope[page[1]]
         if page[1] == 'phs':
             atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],atchoice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
         else:    
-            dlg = wx.SingleChoiceDialog(self,'Select 1st variable:'+choice[1],choice[0],choice[2])
+            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
         if dlg.ShowModal() == wx.ID_OK:
             sel = dlg.GetSelection()
@@ -1198 +1198 @@
             constType = 'Equivalence'
             extra = '; sum = 0'
-        dlg = self.SumDialog(self,constType,'Enter value for each term in constraint'+extra,'',items)
+        dlg = G2frame.SumDialog(G2frame,constType,'Enter value for each term in constraint'+extra,'',items)
         try:
             if dlg.ShowModal() == wx.ID_OK:
@@ -1224 +1224 @@
         HAPConstr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
         Size[1] = min(Size[1],250)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
         
     def UpdateHistConstr():
@@ -1239 +1239 @@
         HistConstr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
         Size[1] = min(Size[1],250)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
         
     def UpdatePhaseConstr():
@@ -1254 +1254 @@
         PhaseConstr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
         Size[1] = min(Size[1],250)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
     
     def OnPageChanged(event):
@@ -1260 +1260 @@
             page = event.GetSelection()
         else:
-            page = self.dataDisplay.GetSelection()
-        oldPage = self.dataDisplay.ChangeSelection(page)
-        text = self.dataDisplay.GetPageText(page)
+            page = G2frame.dataDisplay.GetSelection()
+        oldPage = G2frame.dataDisplay.ChangeSelection(page)
+        text = G2frame.dataDisplay.GetPageText(page)
         if text == 'Histogram/Phase constraints':
-            self.Page = [page,'hap']
+            G2frame.Page = [page,'hap']
             UpdateHAPConstr()
         elif text == 'Histogram constraints':
-            self.Page = [page,'hst']
+            G2frame.Page = [page,'hst']
             UpdateHistConstr()
         elif text == 'Phase constraints':
-            self.Page = [page,'phs']
+            G2frame.Page = [page,'phs']
             UpdatePhaseConstr()
 
@@ -1280 +1280 @@
         'hap':['HAP variables:',phlegend,hapList,'HAP',UpdateHAPConstr],
         'phs':['Phase variables:',plegend,phaseList,'Phase',UpdatePhaseConstr]}
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
-    self.dataFrame.SetMenuBar(self.dataFrame.ConstraintMenu)
-    self.dataFrame.SetLabel('Constraints')
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.ConstraintMenu)
+    G2frame.dataFrame.SetLabel('Constraints')
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
     SetStatusLine('')
     
-    self.dataFrame.SetMenuBar(self.dataFrame.ConstraintMenu)
-    self.dataFrame.Bind(wx.EVT_MENU, OnAddConstraint, id=wxID_CONSTRAINTADD)
-    self.dataFrame.Bind(wx.EVT_MENU, OnAddFunction, id=wxID_FUNCTADD)
-    self.dataFrame.Bind(wx.EVT_MENU, OnAddEquivalence, id=wxID_EQUIVADD)
-    self.dataFrame.Bind(wx.EVT_MENU, OnAddHold, id=wxID_HOLDADD)
-    self.dataDisplay = GSNoteBook(parent=self.dataFrame,size=self.dataFrame.GetClientSize())
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.ConstraintMenu)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddConstraint, id=wxID_CONSTRAINTADD)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddFunction, id=wxID_FUNCTADD)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddEquivalence, id=wxID_EQUIVADD)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddHold, id=wxID_HOLDADD)
+    G2frame.dataDisplay = GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     
-    PhaseConstr = wx.ScrolledWindow(self.dataDisplay)
-    self.dataDisplay.AddPage(PhaseConstr,'Phase constraints')
-    HAPConstr = wx.ScrolledWindow(self.dataDisplay)
-    self.dataDisplay.AddPage(HAPConstr,'Histogram/Phase constraints')
-    HistConstr = wx.ScrolledWindow(self.dataDisplay)
-    self.dataDisplay.AddPage(HistConstr,'Histogram constraints')
+    PhaseConstr = wx.ScrolledWindow(G2frame.dataDisplay)
+    G2frame.dataDisplay.AddPage(PhaseConstr,'Phase constraints')
+    HAPConstr = wx.ScrolledWindow(G2frame.dataDisplay)
+    G2frame.dataDisplay.AddPage(HAPConstr,'Histogram/Phase constraints')
+    HistConstr = wx.ScrolledWindow(G2frame.dataDisplay)
+    G2frame.dataDisplay.AddPage(HistConstr,'Histogram constraints')
     UpdatePhaseConstr()
 
-    self.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)
+    G2frame.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)
     
     
-def UpdateRestraints(self,data):
+def UpdateRestraints(G2frame,data):
 
     def OnAddRestraint(event):
-        page = self.dataDisplay.GetSelection()
-        print self.dataDisplay.GetPageText(page)
+        page = G2frame.dataDisplay.GetSelection()
+        print G2frame.dataDisplay.GetPageText(page)
 
     def UpdateAtomRestr():
@@ -1322 +1322 @@
 
         dataDisplay.SetSizer(mainSizer)
-        Size = mainSizer.Fit(self.dataFrame)
+        Size = mainSizer.Fit(G2frame.dataFrame)
         Size[1] += 26                           #compensate for status bar
         dataDisplay.SetSize(Size)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
         
     def UpdatePhaseRestr():
@@ -1337 +1337 @@
 
         dataDisplay.SetSizer(mainSizer)
-        Size = mainSizer.Fit(self.dataFrame)
+        Size = mainSizer.Fit(G2frame.dataFrame)
         Size[1] += 26                           #compensate for status bar
         dataDisplay.SetSize(Size)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
     
     def OnPageChanged(event):
         page = event.GetSelection()
-        text = self.dataDisplay.GetPageText(page)
+        text = G2frame.dataDisplay.GetPageText(page)
         if text == 'Atom restraints':
-            self.dataFrame.SetMenuBar(self.dataFrame.RestraintMenu)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.RestraintMenu)
             UpdateAtomRestr()
         elif text == 'Phase restraints':
             UpdatePhaseRestr()
-            self.dataFrame.SetMenuBar(self.dataFrame.RestraintMenu)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.RestraintMenu)
         event.Skip()
 
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
-    self.dataFrame.SetMenuBar(self.dataFrame.RestraintMenu)
-    self.dataFrame.SetLabel('restraints')
-    self.dataFrame.CreateStatusBar()
-    self.dataFrame.Bind(wx.EVT_MENU, OnAddRestraint, id=wxID_RESTRAINTADD)
-    self.dataDisplay = GSNoteBook(parent=self.dataFrame,size=self.dataFrame.GetClientSize())
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.RestraintMenu)
+    G2frame.dataFrame.SetLabel('restraints')
+    G2frame.dataFrame.CreateStatusBar()
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddRestraint, id=wxID_RESTRAINTADD)
+    G2frame.dataDisplay = GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     
-    PhaseRestr = wx.ScrolledWindow(self.dataDisplay)
-    self.dataDisplay.AddPage(PhaseRestr,'Phase restraints')
-    AtomRestr = wx.ScrolledWindow(self.dataDisplay)
-    self.dataDisplay.AddPage(AtomRestr,'Atom restraints')
+    PhaseRestr = wx.ScrolledWindow(G2frame.dataDisplay)
+    G2frame.dataDisplay.AddPage(PhaseRestr,'Phase restraints')
+    AtomRestr = wx.ScrolledWindow(G2frame.dataDisplay)
+    G2frame.dataDisplay.AddPage(AtomRestr,'Atom restraints')
     UpdatePhaseRestr()
 #    AtomRestrData = data['AtomRestr']
 
-    self.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)        
+    G2frame.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)        
              
-def UpdateHKLControls(self,data):
+def UpdateHKLControls(G2frame,data):
     
     def OnScaleSlider(event):
@@ -1376 +1376 @@
         scaleSel.SetValue(int(scale*1000.))
         data['Scale'] = scale*10.
-        G2plt.PlotSngl(self)
+        G2plt.PlotSngl(G2frame)
         
     def OnLayerSlider(event):
         layer = layerSel.GetValue()
         data['Layer'] = layer
-        G2plt.PlotSngl(self)
+        G2plt.PlotSngl(G2frame)
         
     def OnSelZone(event):
         data['Zone'] = zoneSel.GetValue()
-        G2plt.PlotSngl(self,newPlot=True)
+        G2plt.PlotSngl(G2frame,newPlot=True)
         
     def OnSelType(event):
         data['Type'] = typeSel.GetValue()
-        G2plt.PlotSngl(self)
+        G2plt.PlotSngl(G2frame)
         
     def SetStatusLine():
         Status.SetStatusText("look at me!!!")
                                       
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
     SetStatusLine()
     zones = ['100','010','001']
@@ -1406 +1406 @@
     else:
         typeChoices = ['Fosq','Fo']
-    self.dataDisplay = wx.Panel(self.dataFrame)
-    self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,10),0)
     
     scaleSizer = wx.BoxSizer(wx.HORIZONTAL)
-    scaleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Scale'),0,
+    scaleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Scale'),0,
         wx.ALIGN_CENTER_VERTICAL|wx.EXPAND)
-    scaleSel = wx.Slider(parent=self.dataDisplay,maxValue=1000,minValue=100,
+    scaleSel = wx.Slider(parent=G2frame.dataDisplay,maxValue=1000,minValue=100,
         style=wx.SL_HORIZONTAL,value=int(data['Scale']*100))
     scaleSizer.Add(scaleSel,1,wx.EXPAND|wx.RIGHT|wx.ALIGN_CENTER_VERTICAL)
@@ -1423 +1423 @@
     
     zoneSizer = wx.BoxSizer(wx.HORIZONTAL)
-    zoneSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Zone  '),0,
+    zoneSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Zone  '),0,
         wx.ALIGN_CENTER_VERTICAL)
-    zoneSel = wx.ComboBox(parent=self.dataDisplay,value=data['Zone'],choices=['100','010','001'],
+    zoneSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['Zone'],choices=['100','010','001'],
         style=wx.CB_READONLY|wx.CB_DROPDOWN)
     zoneSel.Bind(wx.EVT_COMBOBOX, OnSelZone)
     zoneSizer.Add(zoneSel,0,wx.ALIGN_CENTER_VERTICAL)
-    zoneSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Plot type  '),0,
+    zoneSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Plot type  '),0,
         wx.ALIGN_CENTER_VERTICAL)        
-    typeSel = wx.ComboBox(parent=self.dataDisplay,value=data['Type'],choices=typeChoices,
+    typeSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['Type'],choices=typeChoices,
         style=wx.CB_READONLY|wx.CB_DROPDOWN)
     typeSel.Bind(wx.EVT_COMBOBOX, OnSelType)
@@ -1440 +1440 @@
     izone = zones.index(data['Zone'])
     layerSizer = wx.BoxSizer(wx.HORIZONTAL)
-    layerSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Layer'),0,
+    layerSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Layer'),0,
         wx.ALIGN_CENTER_VERTICAL|wx.EXPAND)
-    layerSel = wx.Slider(parent=self.dataDisplay,maxValue=HKLmax[izone],minValue=HKLmin[izone],
+    layerSel = wx.Slider(parent=G2frame.dataDisplay,maxValue=HKLmax[izone],minValue=HKLmin[izone],
         style=wx.SL_HORIZONTAL|wx.SL_AUTOTICKS|wx.SL_LABELS,value=0)
     layerSel.SetLineSize(1)
@@ -1453 +1453 @@
         
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    self.dataDisplay.SetSize(mainSizer.Fit(self.dataFrame))
-    self.dataFrame.setSizePosLeft(mainSizer.Fit(self.dataFrame))
-
-def GetPatternTreeDataNames(self,dataTypes):
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
+    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
+
+def GetPatternTreeDataNames(G2frame,dataTypes):
     names = []
-    item, cookie = self.PatternTree.GetFirstChild(self.root)        
+    item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)        
     while item:
-        name = self.PatternTree.GetItemText(item)
+        name = G2frame.PatternTree.GetItemText(item)
         if name[:4] in dataTypes:
             names.append(name)
-        item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+        item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     return names
                           
-def GetPatternTreeItemId(self, parentId, itemText):
-    item, cookie = self.PatternTree.GetFirstChild(parentId)
+def GetPatternTreeItemId(G2frame, parentId, itemText):
+    item, cookie = G2frame.PatternTree.GetFirstChild(parentId)
     while item:
-        if self.PatternTree.GetItemText(item) == itemText:
+        if G2frame.PatternTree.GetItemText(item) == itemText:
             return item
-        item, cookie = self.PatternTree.GetNextChild(parentId, cookie)
+        item, cookie = G2frame.PatternTree.GetNextChild(parentId, cookie)
     return 0                
 
-def MovePatternTreeToGrid(self,item):
+def MovePatternTreeToGrid(G2frame,item):
     
-#    print self.PatternTree.GetItemText(item)
+#    print G2frame.PatternTree.GetItemText(item)
     
     oldPage = 0
-    if self.dataFrame:
-        self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
-        if self.dataFrame.GetLabel() == 'Comments':
-            data = [self.dataDisplay.GetValue()]
-            self.dataDisplay.Clear() 
-            Id = GetPatternTreeItemId(self,self.root, 'Comments')
-            if Id: self.PatternTree.SetItemPyData(Id,data)
-        elif self.dataFrame.GetLabel() == 'Notebook':
-            data = [self.dataDisplay.GetValue()]
-            self.dataDisplay.Clear() 
-            Id = GetPatternTreeItemId(self,self.root, 'Notebook')
-            if Id: self.PatternTree.SetItemPyData(Id,data)
-        elif 'Phase Data for' in self.dataFrame.GetLabel():
-            if self.dataDisplay: 
-                oldPage = self.dataDisplay.GetSelection()
-        self.dataFrame.Clear()
-        self.dataFrame.SetLabel('')
+    if G2frame.dataFrame:
+        G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
+        if G2frame.dataFrame.GetLabel() == 'Comments':
+            data = [G2frame.dataDisplay.GetValue()]
+            G2frame.dataDisplay.Clear() 
+            Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Comments')
+            if Id: G2frame.PatternTree.SetItemPyData(Id,data)
+        elif G2frame.dataFrame.GetLabel() == 'Notebook':
+            data = [G2frame.dataDisplay.GetValue()]
+            G2frame.dataDisplay.Clear() 
+            Id = GetPatternTreeItemId(G2frame,G2frame.root, 'Notebook')
+            if Id: G2frame.PatternTree.SetItemPyData(Id,data)
+        elif 'Phase Data for' in G2frame.dataFrame.GetLabel():
+            if G2frame.dataDisplay: 
+                oldPage = G2frame.dataDisplay.GetSelection()
+        G2frame.dataFrame.Clear()
+        G2frame.dataFrame.SetLabel('')
     else:
         #create the frame for the data item window
-        self.dataFrame = DataFrame(parent=self.mainPanel)
-
-    self.dataFrame.Raise()            
-    self.PickId = 0
-    parentID = self.root
-    self.ExportPattern.Enable(False)
+        G2frame.dataFrame = DataFrame(parent=G2frame.mainPanel)
+
+    G2frame.dataFrame.Raise()            
+    G2frame.PickId = 0
+    parentID = G2frame.root
+    G2frame.ExportPattern.Enable(False)
     defWid = [250,150]
-    if item != self.root:
-        parentID = self.PatternTree.GetItemParent(item)
-    if self.PatternTree.GetItemParent(item) == self.root:
-        self.PatternId = item
-        self.PickId = item
-        if self.PatternTree.GetItemText(item) == 'Notebook':
-            self.dataFrame.SetMenuBar(self.dataFrame.DataNotebookMenu)
-            self.PatternId = 0
-            self.ExportPattern.Enable(False)
-            data = self.PatternTree.GetItemPyData(item)
-            UpdateNotebook(self,data)
-        elif self.PatternTree.GetItemText(item) == 'Controls':
-            self.PatternId = 0
-            self.ExportPattern.Enable(False)
-            data = self.PatternTree.GetItemPyData(item)
+    if item != G2frame.root:
+        parentID = G2frame.PatternTree.GetItemParent(item)
+    if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
+        G2frame.PatternId = item
+        G2frame.PickId = item
+        if G2frame.PatternTree.GetItemText(item) == 'Notebook':
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.DataNotebookMenu)
+            G2frame.PatternId = 0
+            G2frame.ExportPattern.Enable(False)
+            data = G2frame.PatternTree.GetItemPyData(item)
+            UpdateNotebook(G2frame,data)
+        elif G2frame.PatternTree.GetItemText(item) == 'Controls':
+            G2frame.PatternId = 0
+            G2frame.ExportPattern.Enable(False)
+            data = G2frame.PatternTree.GetItemPyData(item)
             if not data:           #fill in defaults
                 data = {
@@ -1530 +1530 @@
                     #distance/angle controls
                     'distMax':0.0,'angleMax':0.0,'useMapPeaks':False}
-                self.PatternTree.SetItemPyData(item,data)                             
-            self.Refine.Enable(True)
-            self.SeqRefine.Enable(True)
-            UpdateControls(self,data)
-        elif self.PatternTree.GetItemText(item) == 'Sequental results':
-            data = self.PatternTree.GetItemPyData(item)
-            UpdateSeqResults(self,data)            
-        elif self.PatternTree.GetItemText(item) == 'Covariance':
-            data = self.PatternTree.GetItemPyData(item)
-            self.dataFrame.setSizePosLeft(defWid)
-            wx.TextCtrl(parent=self.dataFrame,size=self.dataFrame.GetClientSize(),
+                G2frame.PatternTree.SetItemPyData(item,data)                             
+            G2frame.Refine.Enable(True)
+            G2frame.SeqRefine.Enable(True)
+            UpdateControls(G2frame,data)
+        elif G2frame.PatternTree.GetItemText(item) == 'Sequental results':
+            data = G2frame.PatternTree.GetItemPyData(item)
+            UpdateSeqResults(G2frame,data)            
+        elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
+            data = G2frame.PatternTree.GetItemPyData(item)
+            G2frame.dataFrame.setSizePosLeft(defWid)
+            wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
                         value='See plot window for covariance display')
-            G2plt.PlotCovariance(self)
-        elif self.PatternTree.GetItemText(item) == 'Constraints':
-            data = self.PatternTree.GetItemPyData(item)
-            UpdateConstraints(self,data)
-        elif self.PatternTree.GetItemText(item) == 'Restraints':
-            data = self.PatternTree.GetItemPyData(item)
-            UpdateRestraints(self,data)
-        elif 'IMG' in self.PatternTree.GetItemText(item):
-            self.Image = item
-            G2plt.PlotImage(self,newPlot=True)
-        elif 'PKS' in self.PatternTree.GetItemText(item):
-            G2plt.PlotPowderLines(self)
-        elif 'PWDR' in self.PatternTree.GetItemText(item):
-            self.ExportPattern.Enable(True)
-            self.dataFrame.setSizePosLeft(defWid)
-            wx.TextCtrl(parent=self.dataFrame,size=self.dataFrame.GetClientSize(),
+            G2plt.PlotCovariance(G2frame)
+        elif G2frame.PatternTree.GetItemText(item) == 'Constraints':
+            data = G2frame.PatternTree.GetItemPyData(item)
+            UpdateConstraints(G2frame,data)
+        elif G2frame.PatternTree.GetItemText(item) == 'Restraints':
+            data = G2frame.PatternTree.GetItemPyData(item)
+            UpdateRestraints(G2frame,data)
+        elif 'IMG' in G2frame.PatternTree.GetItemText(item):
+            G2frame.Image = item
+            G2plt.PlotImage(G2frame,newPlot=True)
+        elif 'PKS' in G2frame.PatternTree.GetItemText(item):
+            G2plt.PlotPowderLines(G2frame)
+        elif 'PWDR' in G2frame.PatternTree.GetItemText(item):
+            G2frame.ExportPattern.Enable(True)
+            G2frame.dataFrame.setSizePosLeft(defWid)
+            wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
                 style=wx.TE_MULTILINE,
                 value='See plot window for powder data display\nor select a data item in histogram')
-            G2plt.PlotPatterns(self,newPlot=True)
-        elif 'HKLF' in self.PatternTree.GetItemText(item):
-            self.Sngl = item
-            G2plt.PlotSngl(self,newPlot=True)
-        elif 'PDF' in self.PatternTree.GetItemText(item):
-            self.PatternId = item
-            self.ExportPDF.Enable(True)
-            G2plt.PlotISFG(self,type='S(Q)')
-        elif self.PatternTree.GetItemText(item) == 'Phases':
-            self.dataFrame.setSizePosLeft(defWid)
-            wx.TextCtrl(parent=self.dataFrame,size=self.dataFrame.GetClientSize(),
+            G2plt.PlotPatterns(G2frame,newPlot=True)
+        elif 'HKLF' in G2frame.PatternTree.GetItemText(item):
+            G2frame.Sngl = item
+            G2plt.PlotSngl(G2frame,newPlot=True)
+        elif 'PDF' in G2frame.PatternTree.GetItemText(item):
+            G2frame.PatternId = item
+            G2frame.ExportPDF.Enable(True)
+            G2plt.PlotISFG(G2frame,type='S(Q)')
+        elif G2frame.PatternTree.GetItemText(item) == 'Phases':
+            G2frame.dataFrame.setSizePosLeft(defWid)
+            wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
                 value='Select one phase to see its parameters')            
-    elif 'I(Q)' in self.PatternTree.GetItemText(item):
-        self.PickId = item
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        G2plt.PlotISFG(self,type='I(Q)',newPlot=True)
-    elif 'S(Q)' in self.PatternTree.GetItemText(item):
-        self.PickId = item
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        G2plt.PlotISFG(self,type='S(Q)',newPlot=True)
-    elif 'F(Q)' in self.PatternTree.GetItemText(item):
-        self.PickId = item
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        G2plt.PlotISFG(self,type='F(Q)',newPlot=True)
-    elif 'G(R)' in self.PatternTree.GetItemText(item):
-        self.PickId = item
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        G2plt.PlotISFG(self,type='G(R)',newPlot=True)            
-    elif self.PatternTree.GetItemText(parentID) == 'Phases':
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)            
-        G2phG.UpdatePhaseData(self,item,data,oldPage)
-    elif self.PatternTree.GetItemText(item) == 'Comments':
-        self.dataFrame.SetMenuBar(self.dataFrame.DataCommentsMenu)
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        UpdateComments(self,data)
-    elif self.PatternTree.GetItemText(item) == 'Image Controls':
-        self.dataFrame.SetTitle('Image Controls')
-        self.PickId = item
-        self.Image = self.PatternTree.GetItemParent(item)
-        masks = self.PatternTree.GetItemPyData(
-            GetPatternTreeItemId(self,self.Image, 'Masks'))
-        data = self.PatternTree.GetItemPyData(item)
-        G2imG.UpdateImageControls(self,data,masks)
-        G2plt.PlotImage(self)
-    elif self.PatternTree.GetItemText(item) == 'Masks':
-        self.dataFrame.SetTitle('Masks')
-        self.PickId = item
-        self.Image = self.PatternTree.GetItemParent(item)
-        data = self.PatternTree.GetItemPyData(item)
-        G2imG.UpdateMasks(self,data)
-        G2plt.PlotImage(self)
-    elif self.PatternTree.GetItemText(item) == 'HKL Plot Controls':
-        self.PickId = item
-        self.Sngl = self.PatternTree.GetItemParent(item)
-        data = self.PatternTree.GetItemPyData(item)
-        UpdateHKLControls(self,data)
-        G2plt.PlotSngl(self)
-    elif self.PatternTree.GetItemText(item) == 'PDF Controls':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.ExportPDF.Enable(True)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        G2pdG.UpdatePDFGrid(self,data)
-        G2plt.PlotISFG(self,type='I(Q)')
-        G2plt.PlotISFG(self,type='S(Q)')
-        G2plt.PlotISFG(self,type='F(Q)')
-        G2plt.PlotISFG(self,type='G(R)')
-    elif self.PatternTree.GetItemText(item) == 'Peak List':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.ExportPeakList.Enable(True)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        G2pdG.UpdatePeakGrid(self,data)
-        G2plt.PlotPatterns(self)
-    elif self.PatternTree.GetItemText(item) == 'Background':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        G2pdG.UpdateBackground(self,data)
-        G2plt.PlotPatterns(self)
-    elif self.PatternTree.GetItemText(item) == 'Limits':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        G2pdG.UpdateLimitsGrid(self,data)
-        G2plt.PlotPatterns(self)
-    elif self.PatternTree.GetItemText(item) == 'Instrument Parameters':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        G2pdG.UpdateInstrumentGrid(self,data)
-        G2plt.PlotPeakWidths(self)
-    elif self.PatternTree.GetItemText(item) == 'Sample Parameters':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
+    elif 'I(Q)' in G2frame.PatternTree.GetItemText(item):
+        G2frame.PickId = item
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2plt.PlotISFG(G2frame,type='I(Q)',newPlot=True)
+    elif 'S(Q)' in G2frame.PatternTree.GetItemText(item):
+        G2frame.PickId = item
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2plt.PlotISFG(G2frame,type='S(Q)',newPlot=True)
+    elif 'F(Q)' in G2frame.PatternTree.GetItemText(item):
+        G2frame.PickId = item
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2plt.PlotISFG(G2frame,type='F(Q)',newPlot=True)
+    elif 'G(R)' in G2frame.PatternTree.GetItemText(item):
+        G2frame.PickId = item
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2plt.PlotISFG(G2frame,type='G(R)',newPlot=True)            
+    elif G2frame.PatternTree.GetItemText(parentID) == 'Phases':
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)            
+        G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
+    elif G2frame.PatternTree.GetItemText(item) == 'Comments':
+        G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.DataCommentsMenu)
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        UpdateComments(G2frame,data)
+    elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
+        G2frame.dataFrame.SetTitle('Image Controls')
+        G2frame.PickId = item
+        G2frame.Image = G2frame.PatternTree.GetItemParent(item)
+        masks = G2frame.PatternTree.GetItemPyData(
+            GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2imG.UpdateImageControls(G2frame,data,masks)
+        G2plt.PlotImage(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Masks':
+        G2frame.dataFrame.SetTitle('Masks')
+        G2frame.PickId = item
+        G2frame.Image = G2frame.PatternTree.GetItemParent(item)
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2imG.UpdateMasks(G2frame,data)
+        G2plt.PlotImage(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'HKL Plot Controls':
+        G2frame.PickId = item
+        G2frame.Sngl = G2frame.PatternTree.GetItemParent(item)
+        data = G2frame.PatternTree.GetItemPyData(item)
+        UpdateHKLControls(G2frame,data)
+        G2plt.PlotSngl(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'PDF Controls':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.ExportPDF.Enable(True)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2pdG.UpdatePDFGrid(G2frame,data)
+        G2plt.PlotISFG(G2frame,type='I(Q)')
+        G2plt.PlotISFG(G2frame,type='S(Q)')
+        G2plt.PlotISFG(G2frame,type='F(Q)')
+        G2plt.PlotISFG(G2frame,type='G(R)')
+    elif G2frame.PatternTree.GetItemText(item) == 'Peak List':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.ExportPeakList.Enable(True)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2pdG.UpdatePeakGrid(G2frame,data)
+        G2plt.PlotPatterns(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Background':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2pdG.UpdateBackground(G2frame,data)
+        G2plt.PlotPatterns(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Limits':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2pdG.UpdateLimitsGrid(G2frame,data)
+        G2plt.PlotPatterns(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Instrument Parameters':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2pdG.UpdateInstrumentGrid(G2frame,data)
+        G2plt.PlotPeakWidths(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Sample Parameters':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
 
         if 'Temperature' not in data:           #temp fix for old gpx files
@@ -1664 +1664 @@
                 'DisplaceY':[0.0,False],'Diffuse':[],'Temperature':300.,'Pressure':1.0,'Humidity':0.0,'Voltage':0.0,
                 'Force':0.0,'Gonio. radius':200.0}
-            self.PatternTree.SetItemPyData(item,data)
+            G2frame.PatternTree.SetItemPyData(item,data)
     
-        G2pdG.UpdateSampleGrid(self,data)
-        G2plt.PlotPatterns(self)
-    elif self.PatternTree.GetItemText(item) == 'Index Peak List':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.ExportPeakList.Enable(True)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        G2pdG.UpdateIndexPeaksGrid(self,data)
-        if 'PKS' in self.PatternTree.GetItemText(self.PatternId):
-            G2plt.PlotPowderLines(self)
+        G2pdG.UpdateSampleGrid(G2frame,data)
+        G2plt.PlotPatterns(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Index Peak List':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.ExportPeakList.Enable(True)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2pdG.UpdateIndexPeaksGrid(G2frame,data)
+        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
+            G2plt.PlotPowderLines(G2frame)
         else:
-            G2plt.PlotPatterns(self)
-    elif self.PatternTree.GetItemText(item) == 'Unit Cells List':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
+            G2plt.PlotPatterns(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Unit Cells List':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
         if not data:
             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
@@ -1687 +1687 @@
             data.append([])                                 #empty cell list
             data.append([])                                 #empty dmin
-            self.PatternTree.SetItemPyData(item,data)                             
-        G2pdG.UpdateUnitCellsGrid(self,data)
-        if 'PKS' in self.PatternTree.GetItemText(self.PatternId):
-            G2plt.PlotPowderLines(self)
+            G2frame.PatternTree.SetItemPyData(item,data)                             
+        G2pdG.UpdateUnitCellsGrid(G2frame,data)
+        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
+            G2plt.PlotPowderLines(G2frame)
         else:
-            G2plt.PlotPatterns(self)
-    elif self.PatternTree.GetItemText(item) == 'Reflection Lists':
-        self.PatternId = self.PatternTree.GetItemParent(item)
-        self.PickId = item
-        data = self.PatternTree.GetItemPyData(item)
-        self.RefList = ''
+            G2plt.PlotPatterns(G2frame)
+    elif G2frame.PatternTree.GetItemText(item) == 'Reflection Lists':
+        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
+        G2frame.PickId = item
+        data = G2frame.PatternTree.GetItemPyData(item)
+        G2frame.RefList = ''
         if len(data):
-            self.RefList = data.keys()[0]
-        G2pdG.UpdateReflectionGrid(self,data)
-        G2plt.PlotPatterns(self)
+            G2frame.RefList = data.keys()[0]
+        G2pdG.UpdateReflectionGrid(G2frame,data)
+        G2plt.PlotPatterns(G2frame)

trunk/GSASIIimgGUI.py ¶

@@ -29 +29 @@
 
                     
-def UpdateImageControls(self,data,masks):
+def UpdateImageControls(G2frame,data,masks):
     import ImageCalibrants as calFile
     
@@ -37 +37 @@
     def OnNewColorBar(event):
         data['color'] = colSel.GetValue()
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnNewCalibrant(event):
@@ -60 +60 @@
         else:
             data['setRings'] = True
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
 
     def OnCalibDmin(event):
@@ -103 +103 @@
         maxSel.SetValue(int(100*sqrtDeltOne/sqrtDeltZero))
         minSel.SetValue(int(100*(data['range'][1][0]/DeltOne)))
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnMinVal(event):
@@ -115 +115 @@
         minVal.SetValue('%.0f'%(data['range'][1][0]))
         minSel.SetValue(int(100*(data['range'][1][0]-max(0.0,data['range'][0][0]))/DeltOne))
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnMaxSlider(event):
@@ -125 +125 @@
         minSel.SetValue(int(100*(data['range'][1][0]/DeltOne)))
         maxVal.SetValue('%.0f'%(data['range'][1][1]))
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnMinSlider(event):
@@ -132 +132 @@
         data['range'][1][0] = max(0.0,min(data['range'][1][1]-1,imin))
         minVal.SetValue('%.0f'%(data['range'][1][0]))
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnNumOutChans(event):
@@ -153 +153 @@
             pass
         outAzim.SetValue(str(data['outAzimuths']))          #reset in case of error        
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnWavelength(event):
@@ -170 +170 @@
         else:
             data['showLines'] = True
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnSetDefault(event):
         import copy
         if data['setDefault']:
-            self.imageDefault = {}
+            G2frame.imageDefault = {}
             data['setDefault'] = False
         else:
-            self.imageDefault = copy.copy(data)
+            G2frame.imageDefault = copy.copy(data)
             data['setDefault'] = True
             
     def OnIOtth(event):
-        Ltth = max(float(self.InnerTth.GetValue()),0.001)
-        Utth = float(self.OuterTth.GetValue())
+        Ltth = max(float(G2frame.InnerTth.GetValue()),0.001)
+        Utth = float(G2frame.OuterTth.GetValue())
         if Ltth > Utth:
             Ltth,Utth = Utth,Ltth
         data['IOtth'] = [Ltth,Utth]
-        self.InnerTth.SetValue("%8.3f" % (Ltth))
-        self.OuterTth.SetValue("%8.2f" % (Utth))
-        G2plt.PlotExposedImage(self,event=event)
+        G2frame.InnerTth.SetValue("%8.3f" % (Ltth))
+        G2frame.OuterTth.SetValue("%8.2f" % (Utth))
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnFullIntegrate(event):
-        Lazm =int(self.Lazim.GetValue())
+        Lazm =int(G2frame.Lazim.GetValue())
         if data['fullIntegrate']:
             data['fullIntegrate'] = False
@@ -199 +199 @@
             data['fullIntegrate'] = True
             data['LRazimuth'] = [Lazm,Lazm+360]
-        UpdateImageControls(self,data,masks)
-        G2plt.PlotExposedImage(self,event=event)
+        UpdateImageControls(G2frame,data,masks)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnLRazim(event):
-        Lazm =int(self.Lazim.GetValue())
+        Lazm =int(G2frame.Lazim.GetValue())
         if data['fullIntegrate']:
-           self.Razim.SetValue("%6d" % (Lazm+360))
-        Razm = int(self.Razim.GetValue())
+           G2frame.Razim.SetValue("%6d" % (Lazm+360))
+        Razm = int(G2frame.Razim.GetValue())
         if Lazm > Razm:
             Lazm -= 360
         data['LRazimuth'] = [Lazm,Razm]
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnBackImage(event):
@@ -227 +227 @@
         data['rings'] = []
         data['ellipses'] = []
-#        self.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=False)    
-        G2plt.PlotExposedImage(self,event=event)
+#        G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=False)    
+        G2plt.PlotExposedImage(G2frame,event=event)
             
     def OnCalibrate(event):        
-        self.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=True)    
-        self.dataFrame.GetStatusBar().SetStatusText('Select > 4 points on 1st used ring; LB to pick, RB on point to delete else RB to finish')
-        self.ifGetRing = True
+        G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=True)    
+        G2frame.dataFrame.GetStatusBar().SetStatusText('Select > 4 points on 1st used ring; LB to pick, RB on point to delete else RB to finish')
+        G2frame.ifGetRing = True
         
     def OnRecalibrate(event):
-        G2img.ImageRecalibrate(self,data)
-        UpdateImageControls(self,data,masks)
+        G2img.ImageRecalibrate(G2frame,data)
+        UpdateImageControls(G2frame,data,masks)
         
     def OnIntegrate(event):
@@ -245 +245 @@
             backImg = data['background image'][0]
             backScale = data['background image'][1]
-            id = G2gd.GetPatternTreeItemId(self, self.root, backImg)
-            Npix,imagefile = self.PatternTree.GetItemPyData(id)
-            backImage = G2IO.GetImageData(self,imagefile,True)*backScale
-            sumImage = self.ImageZ+backImage
+            id = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, backImg)
+            Npix,imagefile = G2frame.PatternTree.GetItemPyData(id)
+            backImage = G2IO.GetImageData(G2frame,imagefile,True)*backScale
+            sumImage = G2frame.ImageZ+backImage
             sumMin = np.min(sumImage)
             sumMax = np.max(sumImage)
             maskCopy['Thresholds'] = [(sumMin,sumMax),[sumMin,sumMax]]
-            self.Integrate = G2img.ImageIntegrate(sumImage,data,maskCopy)
+            G2frame.Integrate = G2img.ImageIntegrate(sumImage,data,maskCopy)
         else:
-            self.Integrate = G2img.ImageIntegrate(self.ImageZ,data,masks)
-        G2plt.PlotIntegration(self,newPlot=True)
-        G2IO.SaveIntegration(self,self.PickId,data)
-        self.MakePDF.Enable(True)
+            G2frame.Integrate = G2img.ImageIntegrate(G2frame.ImageZ,data,masks)
+        G2plt.PlotIntegration(G2frame,newPlot=True)
+        G2IO.SaveIntegration(G2frame,G2frame.PickId,data)
+        G2frame.MakePDF.Enable(True)
         
     def OnIntegrateAll(event):
@@ -263 +263 @@
         TextList = [[False,'All IMG',0]]
         Names = []
-        if self.PatternTree.GetCount():
-            id, cookie = self.PatternTree.GetFirstChild(self.root)
+        if G2frame.PatternTree.GetCount():
+            id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
             while id:
-                name = self.PatternTree.GetItemText(id)
+                name = G2frame.PatternTree.GetItemText(id)
                 Names.append(name)
                 if 'IMG' in name:
                     TextList.append([False,name,id])
-                id, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+                id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
             if len(TextList) == 1:
-                self.ErrorDialog('Nothing to integrate','There must some "IMG" patterns')
+                G2frame.ErrorDialog('Nothing to integrate','There must some "IMG" patterns')
                 return
-            dlg = self.CopyDialog(self,'Image integration controls','Select images to integrate:',TextList)
+            dlg = G2frame.CopyDialog(G2frame,'Image integration controls','Select images to integrate:',TextList)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -284 +284 @@
                         ifintegrate,name,id = item
                         if ifintegrate:
-                            id = G2gd.GetPatternTreeItemId(self, self.root, name)
-                            Npix,imagefile = self.PatternTree.GetItemPyData(id)
-                            image = G2IO.GetImageData(self,imagefile,True)
-                            Id = G2gd.GetPatternTreeItemId(self,id, 'Image Controls')
-                            Data = self.PatternTree.GetItemPyData(Id)
+                            id = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, name)
+                            Npix,imagefile = G2frame.PatternTree.GetItemPyData(id)
+                            image = G2IO.GetImageData(G2frame,imagefile,True)
+                            Id = G2gd.GetPatternTreeItemId(G2frame,id, 'Image Controls')
+                            Data = G2frame.PatternTree.GetItemPyData(Id)
                             backImage = []
                             if Data['background image'][0]:
                                 backImg = Data['background image'][0]
                                 backScale = Data['background image'][1]
-                                id = G2gd.GetPatternTreeItemId(self, self.root, backImg)
-                                Npix,imagefile = self.PatternTree.GetItemPyData(id)
-                                backImage = G2IO.GetImageData(self,imagefile,True)*backScale
+                                id = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, backImg)
+                                Npix,imagefile = G2frame.PatternTree.GetItemPyData(id)
+                                backImage = G2IO.GetImageData(G2frame,imagefile,True)*backScale
                             try:
-                                Masks = self.PatternTree.GetItemPyData(
-                                    G2gd.GetPatternTreeItemId(self,self.Image, 'Masks'))
+                                Masks = G2frame.PatternTree.GetItemPyData(
+                                    G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
                             except TypeError:       #missing Masks
                                 Imin,Imax = Data['Range']
                                 Masks = {'Points':[],'Rings':[],'Arcs':[],'Polygons':[],'Thresholds':[(Imin,Imax),[Imin,Imax]]}
-                                self.PatternTree.SetItemPyData(
-                                    G2gd.GetPatternTreeItemId(self,self.Image, 'Masks'),Masks)
+                                G2frame.PatternTree.SetItemPyData(
+                                    G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'),Masks)
                             if len(backImage):                                
-                                self.Integrate = G2img.ImageIntegrate(image+backImage,Data,Masks)
+                                G2frame.Integrate = G2img.ImageIntegrate(image+backImage,Data,Masks)
                             else:
-                                self.Integrate = G2img.ImageIntegrate(image,Data,Masks)
-#                            G2plt.PlotIntegration(self,newPlot=True,event=event)
-                            G2IO.SaveIntegration(self,Id,Data)
+                                G2frame.Integrate = G2img.ImageIntegrate(image,Data,Masks)
+#                            G2plt.PlotIntegration(G2frame,newPlot=True,event=event)
+                            G2IO.SaveIntegration(G2frame,Id,Data)
             finally:
                 dlg.Destroy()
@@ -317 +317 @@
         TextList = [[False,'All IMG',0]]
         Names = []
-        if self.PatternTree.GetCount():
-            id, cookie = self.PatternTree.GetFirstChild(self.root)
+        if G2frame.PatternTree.GetCount():
+            id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
             while id:
-                name = self.PatternTree.GetItemText(id)
+                name = G2frame.PatternTree.GetItemText(id)
                 Names.append(name)
                 if 'IMG' in name:
-                    if id == self.Image:
+                    if id == G2frame.Image:
                         Source = name
-                        Data = copy.deepcopy(self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'Image Controls')))
+                        Data = copy.deepcopy(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'Image Controls')))
                         Data['showLines'] = True
                         Data['ring'] = []
@@ -333 +333 @@
                     else:
                         TextList.append([False,name,id])
-                id, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+                id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
             if len(TextList) == 1:
-                self.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
+                G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
                 return
-            dlg = self.CopyDialog(self,'Copy image controls','Copy controls from '+Source+' to:',TextList)
+            dlg = G2frame.CopyDialog(G2frame,'Copy image controls','Copy controls from '+Source+' to:',TextList)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -347 +347 @@
                         ifcopy,name,id = item
                         if ifcopy:
-                            oldData = copy.deepcopy(self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'Image Controls')))
+                            oldData = copy.deepcopy(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'Image Controls')))
                             Data['range'] = oldData['range']
                             Data['size'] = oldData['size']                                
@@ -353 +353 @@
                             Data['rings'] = []
                             Data['ellipses'] = []
-                            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'Image Controls'),copy.deepcopy(Data))
+                            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'Image Controls'),copy.deepcopy(Data))
             finally:
                 dlg.Destroy()
                 
     def OnSaveControls(event):
-        dlg = wx.FileDialog(self, 'Choose image controls file', '.', '', 
+        dlg = wx.FileDialog(G2frame, 'Choose image controls file', '.', '', 
             'image control files (*.imctrl)|*.imctrl',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
         try:
@@ -377 +377 @@
         cntlList = ['wavelength','distance','tilt','rotation',
             'fullIntegrate','outAzimuths','LRazimuth','IOtth']
-        dlg = wx.FileDialog(self, 'Choose image controls file', '.', '', 
+        dlg = wx.FileDialog(G2frame, 'Choose image controls file', '.', '', 
             'image control files (*.imctrl)|*.imctrl',wx.OPEN|wx.CHANGE_DIR)
         try:
@@ -402 +402 @@
                     S = File.readline()
                 data.update(save)
-                UpdateImageControls(self,data,masks)
-                G2plt.PlotExposedImage(self,event=event)
+                UpdateImageControls(G2frame,data,masks)
+                G2plt.PlotExposedImage(G2frame,event=event)
                 
                 File.close()
@@ -423 +423 @@
         data['type'] = 'PWDR'
     typeDict = {'PWDR':typeList[0],'SASD':typeList[1],'REFL':typeList[2]}
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
-    self.dataFrame.SetMenuBar(self.dataFrame.ImageMenu)
-    if not self.dataFrame.GetStatusBar():
-        self.dataFrame.CreateStatusBar()
-    self.dataFrame.Bind(wx.EVT_MENU, OnCalibrate, id=G2gd.wxID_IMCALIBRATE)
-    self.dataFrame.Bind(wx.EVT_MENU, OnRecalibrate, id=G2gd.wxID_IMRECALIBRATE)
-    self.dataFrame.Bind(wx.EVT_MENU, OnClearCalib, id=G2gd.wxID_IMCLEARCALIB)
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.ImageMenu)
+    if not G2frame.dataFrame.GetStatusBar():
+        G2frame.dataFrame.CreateStatusBar()
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCalibrate, id=G2gd.wxID_IMCALIBRATE)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnRecalibrate, id=G2gd.wxID_IMRECALIBRATE)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnClearCalib, id=G2gd.wxID_IMCLEARCALIB)
     if not data['rings']:
-        self.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=False)    
-    self.dataFrame.Bind(wx.EVT_MENU, OnIntegrate, id=G2gd.wxID_IMINTEGRATE)
-    self.dataFrame.Bind(wx.EVT_MENU, OnIntegrateAll, id=G2gd.wxID_INTEGRATEALL)
-    self.dataFrame.Bind(wx.EVT_MENU, OnCopyControls, id=G2gd.wxID_IMCOPYCONTROLS)
-    self.dataFrame.Bind(wx.EVT_MENU, OnSaveControls, id=G2gd.wxID_IMSAVECONTROLS)
-    self.dataFrame.Bind(wx.EVT_MENU, OnLoadControls, id=G2gd.wxID_IMLOADCONTROLS)
-    self.dataDisplay = wx.Panel(self.dataFrame)
+        G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=False)    
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnIntegrate, id=G2gd.wxID_IMINTEGRATE)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnIntegrateAll, id=G2gd.wxID_INTEGRATEALL)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyControls, id=G2gd.wxID_IMCOPYCONTROLS)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveControls, id=G2gd.wxID_IMSAVECONTROLS)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadControls, id=G2gd.wxID_IMLOADCONTROLS)
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,10),0)
     
     comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Type of image data: '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    typeSel = wx.ComboBox(parent=self.dataDisplay,value=typeDict[data['type']],choices=typeList,
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Type of image data: '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    typeSel = wx.ComboBox(parent=G2frame.dataDisplay,value=typeDict[data['type']],choices=typeList,
         style=wx.CB_READONLY|wx.CB_DROPDOWN)
     typeSel.SetValue(data['type'])
     typeSel.Bind(wx.EVT_COMBOBOX, OnDataType)
     comboSizer.Add(typeSel,0,wx.ALIGN_CENTER_VERTICAL)
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Color bar '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    colSel = wx.ComboBox(parent=self.dataDisplay,value=data['color'],choices=colorList,
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Color bar '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    colSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['color'],choices=colorList,
         style=wx.CB_READONLY|wx.CB_DROPDOWN|wx.CB_SORT)
     colSel.Bind(wx.EVT_COMBOBOX, OnNewColorBar)
     comboSizer.Add(colSel,0,wx.ALIGN_CENTER_VERTICAL)
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Azimuth offset '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    azmthOff = wx.TextCtrl(parent=self.dataDisplay,value=("%.2f" % (data['azmthOff'])),
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Azimuth offset '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    azmthOff = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f" % (data['azmthOff'])),
         style=wx.TE_PROCESS_ENTER)
     azmthOff.Bind(wx.EVT_TEXT_ENTER,OnAzmthOff)
@@ -472 +472 @@
     DeltOne = data['range'][1][1]-max(0.0,data['range'][0][0])
     sqrtDeltOne = math.sqrt(DeltOne)
-    maxSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Max intensity'),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    maxSel = wx.Slider(parent=self.dataDisplay,style=wx.SL_HORIZONTAL,
+    maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max intensity'),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    maxSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
         value=int(100*sqrtDeltOne/sqrtDeltZero))
     maxSizer.Add(maxSel,1,wx.EXPAND)
     maxSel.Bind(wx.EVT_SLIDER, OnMaxSlider)
-    maxVal = wx.TextCtrl(parent=self.dataDisplay,value='%.0f'%(data['range'][1][1]))
+    maxVal = wx.TextCtrl(parent=G2frame.dataDisplay,value='%.0f'%(data['range'][1][1]))
     maxVal.Bind(wx.EVT_TEXT_ENTER,OnMaxVal)    
     maxVal.Bind(wx.EVT_KILL_FOCUS,OnMaxVal)
     maxSizer.Add(maxVal,0,wx.ALIGN_CENTER_VERTICAL)    
-    maxSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Min intensity'),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    minSel = wx.Slider(parent=self.dataDisplay,style=wx.SL_HORIZONTAL,
+    maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min intensity'),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    minSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
         value=int(100*(data['range'][1][0]-max(0.0,data['range'][0][0]))/DeltOne))
     maxSizer.Add(minSel,1,wx.EXPAND)
     minSel.Bind(wx.EVT_SLIDER, OnMinSlider)
-    minVal = wx.TextCtrl(parent=self.dataDisplay,value='%.0f'%(data['range'][1][0]))
+    minVal = wx.TextCtrl(parent=G2frame.dataDisplay,value='%.0f'%(data['range'][1][0]))
     minVal.Bind(wx.EVT_TEXT_ENTER,OnMinVal)    
     minVal.Bind(wx.EVT_KILL_FOCUS,OnMinVal)
@@ -495 +495 @@
     
     dataSizer = wx.FlexGridSizer(6,4,5,5)
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Calibration coefficients'),0,
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration coefficients'),0,
         wx.ALIGN_CENTER_VERTICAL)    
     dataSizer.Add((5,0),0)
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Integration coefficients'),0,
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Integration coefficients'),0,
         wx.ALIGN_CENTER_VERTICAL)    
     dataSizer.Add((5,0),0)
     
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Beam center X,Y'),0,
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Beam center X,Y'),0,
         wx.ALIGN_CENTER_VERTICAL)
     cent = data['center']
-    centText = wx.TextCtrl(parent=self.dataDisplay,value=("%8.3f,%8.3f" % (cent[0],cent[1])),style=wx.TE_READONLY)
+    centText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%8.3f,%8.3f" % (cent[0],cent[1])),style=wx.TE_READONLY)
     centText.SetBackgroundColour(VERY_LIGHT_GREY)
     dataSizer.Add(centText,0,wx.ALIGN_CENTER_VERTICAL)
     
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Inner/Outer 2-theta'),0,
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Inner/Outer 2-theta'),0,
         wx.ALIGN_CENTER_VERTICAL)
         
     IOtth = data['IOtth']
     littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-    self.InnerTth = wx.TextCtrl(parent=self.dataDisplay,
+    G2frame.InnerTth = wx.TextCtrl(parent=G2frame.dataDisplay,
         value=("%8.3f" % (IOtth[0])),style=wx.TE_PROCESS_ENTER)
-    self.InnerTth.Bind(wx.EVT_TEXT_ENTER,OnIOtth)
-    self.InnerTth.Bind(wx.EVT_KILL_FOCUS,OnIOtth)
-    littleSizer.Add(self.InnerTth,0,wx.ALIGN_CENTER_VERTICAL)
-    self.OuterTth = wx.TextCtrl(parent=self.dataDisplay,
+    G2frame.InnerTth.Bind(wx.EVT_TEXT_ENTER,OnIOtth)
+    G2frame.InnerTth.Bind(wx.EVT_KILL_FOCUS,OnIOtth)
+    littleSizer.Add(G2frame.InnerTth,0,wx.ALIGN_CENTER_VERTICAL)
+    G2frame.OuterTth = wx.TextCtrl(parent=G2frame.dataDisplay,
         value=("%8.2f" % (IOtth[1])),style=wx.TE_PROCESS_ENTER)
-    self.OuterTth.Bind(wx.EVT_TEXT_ENTER,OnIOtth)
-    self.OuterTth.Bind(wx.EVT_KILL_FOCUS,OnIOtth)
-    littleSizer.Add(self.OuterTth,0,wx.ALIGN_CENTER_VERTICAL)
+    G2frame.OuterTth.Bind(wx.EVT_TEXT_ENTER,OnIOtth)
+    G2frame.OuterTth.Bind(wx.EVT_KILL_FOCUS,OnIOtth)
+    littleSizer.Add(G2frame.OuterTth,0,wx.ALIGN_CENTER_VERTICAL)
     dataSizer.Add(littleSizer,0,)
        
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Wavelength'),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    waveSel = wx.TextCtrl(parent=self.dataDisplay,value=("%6.5f" % (data['wavelength'])),
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Wavelength'),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    waveSel = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%6.5f" % (data['wavelength'])),
         style=wx.TE_PROCESS_ENTER)
     waveSel.Bind(wx.EVT_TEXT_ENTER,OnWavelength)
@@ -534 +534 @@
     dataSizer.Add(waveSel,0,wx.ALIGN_CENTER_VERTICAL)
          
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Start/End azimuth'),0,
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start/End azimuth'),0,
         wx.ALIGN_CENTER_VERTICAL)
     LRazim = data['LRazimuth']
     littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-    self.Lazim = wx.TextCtrl(parent=self.dataDisplay,
+    G2frame.Lazim = wx.TextCtrl(parent=G2frame.dataDisplay,
         value=("%6d" % (LRazim[0])),style=wx.TE_PROCESS_ENTER)
-    self.Lazim.Bind(wx.EVT_TEXT_ENTER,OnLRazim)
-    self.Lazim.Bind(wx.EVT_KILL_FOCUS,OnLRazim)
-    littleSizer.Add(self.Lazim,0,wx.ALIGN_CENTER_VERTICAL)
-    self.Razim = wx.TextCtrl(parent=self.dataDisplay,
+    G2frame.Lazim.Bind(wx.EVT_TEXT_ENTER,OnLRazim)
+    G2frame.Lazim.Bind(wx.EVT_KILL_FOCUS,OnLRazim)
+    littleSizer.Add(G2frame.Lazim,0,wx.ALIGN_CENTER_VERTICAL)
+    G2frame.Razim = wx.TextCtrl(parent=G2frame.dataDisplay,
         value=("%6d" % (LRazim[1])),style=wx.TE_PROCESS_ENTER)
-    self.Razim.Bind(wx.EVT_TEXT_ENTER,OnLRazim)
-    self.Razim.Bind(wx.EVT_KILL_FOCUS,OnLRazim)
+    G2frame.Razim.Bind(wx.EVT_TEXT_ENTER,OnLRazim)
+    G2frame.Razim.Bind(wx.EVT_KILL_FOCUS,OnLRazim)
     if data['fullIntegrate']:
-        self.Razim.Enable(False)
-        self.Razim.SetBackgroundColour(VERY_LIGHT_GREY)
-        self.Razim.SetValue("%6d" % (LRazim[0]+360))
-    littleSizer.Add(self.Razim,0,wx.ALIGN_CENTER_VERTICAL)
+        G2frame.Razim.Enable(False)
+        G2frame.Razim.SetBackgroundColour(VERY_LIGHT_GREY)
+        G2frame.Razim.SetValue("%6d" % (LRazim[0]+360))
+    littleSizer.Add(G2frame.Razim,0,wx.ALIGN_CENTER_VERTICAL)
     dataSizer.Add(littleSizer,0,)
        
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Distance'),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    distSel = wx.TextCtrl(parent=self.dataDisplay,value=("%8.3f"%(data['distance'])),style=wx.TE_READONLY)
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Distance'),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    distSel = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%8.3f"%(data['distance'])),style=wx.TE_READONLY)
     distSel.SetBackgroundColour(VERY_LIGHT_GREY)
     dataSizer.Add(distSel,0,wx.ALIGN_CENTER_VERTICAL)
 
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' No. 2-theta/azimuth bins'),0,
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' No. 2-theta/azimuth bins'),0,
         wx.ALIGN_CENTER_VERTICAL)
     littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-    outChan = wx.TextCtrl(parent=self.dataDisplay,value=str(data['outChannels']),style=wx.TE_PROCESS_ENTER)
+    outChan = wx.TextCtrl(parent=G2frame.dataDisplay,value=str(data['outChannels']),style=wx.TE_PROCESS_ENTER)
     outChan.Bind(wx.EVT_TEXT_ENTER,OnNumOutChans)
     outChan.Bind(wx.EVT_KILL_FOCUS,OnNumOutChans)
     littleSizer.Add(outChan,0,wx.ALIGN_CENTER_VERTICAL)
-    outAzim = wx.TextCtrl(parent=self.dataDisplay,value=str(data['outAzimuths']),style=wx.TE_PROCESS_ENTER)
+    outAzim = wx.TextCtrl(parent=G2frame.dataDisplay,value=str(data['outAzimuths']),style=wx.TE_PROCESS_ENTER)
     outAzim.Bind(wx.EVT_TEXT_ENTER,OnNumOutAzms)
     outAzim.Bind(wx.EVT_KILL_FOCUS,OnNumOutAzms)
@@ -573 +573 @@
     dataSizer.Add(littleSizer,0,)
 
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Tilt angle'),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    tiltSel = wx.TextCtrl(parent=self.dataDisplay,value=("%9.3f"%(data['tilt'])),style=wx.TE_READONLY)
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Tilt angle'),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    tiltSel = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%9.3f"%(data['tilt'])),style=wx.TE_READONLY)
     tiltSel.SetBackgroundColour(VERY_LIGHT_GREY)
     dataSizer.Add(tiltSel,0,wx.ALIGN_CENTER_VERTICAL)
-    showLines = wx.CheckBox(parent=self.dataDisplay,label='Show integration limits?')
+    showLines = wx.CheckBox(parent=G2frame.dataDisplay,label='Show integration limits?')
     dataSizer.Add(showLines,0,wx.ALIGN_CENTER_VERTICAL)
     showLines.Bind(wx.EVT_CHECKBOX, OnShowLines)
     showLines.SetValue(data['showLines'])
-    fullIntegrate = wx.CheckBox(parent=self.dataDisplay,label='Do full integration?')
+    fullIntegrate = wx.CheckBox(parent=G2frame.dataDisplay,label='Do full integration?')
     dataSizer.Add(fullIntegrate,0,wx.ALIGN_CENTER_VERTICAL)
     fullIntegrate.Bind(wx.EVT_CHECKBOX, OnFullIntegrate)
     fullIntegrate.SetValue(data['fullIntegrate'])
     
-    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Tilt rotation'),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    rotSel = wx.TextCtrl(parent=self.dataDisplay,value=("%9.3f"%(data['rotation']-90.)),style=wx.TE_READONLY) #kluge to get rotation from vertical - see GSASIIimage
+    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Tilt rotation'),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    rotSel = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%9.3f"%(data['rotation']-90.)),style=wx.TE_READONLY) #kluge to get rotation from vertical - see GSASIIimage
     rotSel.SetBackgroundColour(VERY_LIGHT_GREY)
     dataSizer.Add(rotSel,0,wx.ALIGN_CENTER_VERTICAL)
-    setDefault = wx.CheckBox(parent=self.dataDisplay,label='Use as default for all images?')
+    setDefault = wx.CheckBox(parent=G2frame.dataDisplay,label='Use as default for all images?')
     dataSizer.Add(setDefault,0,wx.ALIGN_CENTER_VERTICAL)
     setDefault.Bind(wx.EVT_CHECKBOX, OnSetDefault)
@@ -598 +598 @@
     dataSizer.Add((5,5),0)
     
-    dataSizer.Add(wx.StaticText(self.dataDisplay,-1,' Background image'),0,wx.ALIGN_CENTER_VERTICAL)
-    Choices = ['',]+G2gd.GetPatternTreeDataNames(self,['IMG ',])
-    backImage = wx.ComboBox(parent=self.dataDisplay,value=data['background image'][0],choices=Choices,
+    dataSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background image'),0,wx.ALIGN_CENTER_VERTICAL)
+    Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
+    backImage = wx.ComboBox(parent=G2frame.dataDisplay,value=data['background image'][0],choices=Choices,
         style=wx.CB_READONLY|wx.CB_DROPDOWN)
     backImage.Bind(wx.EVT_COMBOBOX,OnBackImage)
     dataSizer.Add(backImage)
-    dataSizer.Add(wx.StaticText(self.dataDisplay,-1,' multiplier'),0,wx.ALIGN_CENTER_VERTICAL)
-    backMult =  wx.TextCtrl(parent=self.dataDisplay,value=("%.3f" % (data['background image'][1])),
+    dataSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' multiplier'),0,wx.ALIGN_CENTER_VERTICAL)
+    backMult =  wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (data['background image'][1])),
         style=wx.TE_PROCESS_ENTER)
     backMult.Bind(wx.EVT_TEXT_ENTER,OnBackMult)
@@ -613 +613 @@
     mainSizer.Add((5,5),0)        
     mainSizer.Add(dataSizer,0)
-    mainSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Calibration controls:'),0,
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration controls:'),0,
         wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)
     calibSizer = wx.FlexGridSizer(2,3,5,5)
     comboSizer = wx.BoxSizer(wx.HORIZONTAL)    
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Calibrant '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    calSel = wx.ComboBox(parent=self.dataDisplay,value=data['calibrant'],choices=calList,
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibrant '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    calSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['calibrant'],choices=calList,
         style=wx.CB_READONLY|wx.CB_DROPDOWN|wx.CB_SORT)
     calSel.Bind(wx.EVT_COMBOBOX, OnNewCalibrant)
@@ -627 +627 @@
     
     comboSizer = wx.BoxSizer(wx.HORIZONTAL)    
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Calib lines to skip   '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    calibSkip  = wx.ComboBox(parent=self.dataDisplay,value=str(data['calibskip']),choices=[str(i) for i in range(25)],
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calib lines to skip   '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    calibSkip  = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['calibskip']),choices=[str(i) for i in range(25)],
         style=wx.CB_READONLY|wx.CB_DROPDOWN)
     calibSkip.Bind(wx.EVT_COMBOBOX, OnCalibSkip)
@@ -636 +636 @@
     
     comboSizer = wx.BoxSizer(wx.HORIZONTAL)        
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Min calib d-spacing '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    calibDmin = wx.TextCtrl(parent=self.dataDisplay,value=("%.2f" % (data['calibdmin'])),
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min calib d-spacing '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    calibDmin = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f" % (data['calibdmin'])),
         style=wx.TE_PROCESS_ENTER)
     calibDmin.Bind(wx.EVT_TEXT_ENTER,OnCalibDmin)
@@ -646 +646 @@
     
     comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Min ring I/Ib '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    cutOff = wx.TextCtrl(parent=self.dataDisplay,value=("%.1f" % (data['cutoff'])),
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min ring I/Ib '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    cutOff = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.1f" % (data['cutoff'])),
         style=wx.TE_PROCESS_ENTER)
     cutOff.Bind(wx.EVT_TEXT_ENTER,OnCutOff)
@@ -656 +656 @@
     
     comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-    comboSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Pixel search range '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    pixLimit = wx.ComboBox(parent=self.dataDisplay,value=str(data['pixLimit']),choices=['1','2','5','10','15','20'],
+    comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Pixel search range '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    pixLimit = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['pixLimit']),choices=['1','2','5','10','15','20'],
         style=wx.CB_READONLY|wx.CB_DROPDOWN)
     pixLimit.Bind(wx.EVT_COMBOBOX, OnPixLimit)
@@ -665 +665 @@
     
     comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-    setRings = wx.CheckBox(parent=self.dataDisplay,label='Show ring picks?')
+    setRings = wx.CheckBox(parent=G2frame.dataDisplay,label='Show ring picks?')
     comboSizer.Add(setRings,0)
     setRings.Bind(wx.EVT_CHECKBOX, OnSetRings)
@@ -674 +674 @@
         
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    fitSize = mainSizer.Fit(self.dataFrame)
-    self.dataFrame.setSizePosLeft(fitSize)
-    self.dataDisplay.SetSize(fitSize)
-    
-def UpdateMasks(self,data):
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    fitSize = mainSizer.Fit(G2frame.dataFrame)
+    G2frame.dataFrame.setSizePosLeft(fitSize)
+    G2frame.dataDisplay.SetSize(fitSize)
+    
+def UpdateMasks(G2frame,data):
     
     def OnTextMsg(event):
@@ -697 +697 @@
         lowerThreshold.SetValue("%8d" % (lower))
         upperThreshold.SetValue("%8d" % (upper))
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnSpotDiameter(event):
@@ -707 +707 @@
         Obj.SetValue("%.2f"%(diameter))
         data['Points'][spotIds.index(Obj.GetId())][2] = diameter
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnDeleteSpot(event):
         Obj = event.GetEventObject()
         del(data['Points'][delSpotId.index(Obj)])
-        UpdateMasks(self,data)
-        G2plt.PlotExposedImage(self,event=event)
+        UpdateMasks(G2frame,data)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnRingThickness(event):
@@ -723 +723 @@
         Obj.SetValue("%.3f"%(thick))
         data['Rings'][ringIds.index(Obj.GetId())][1] = thick
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnDeleteRing(event):
         Obj = event.GetEventObject()
         del(data['Rings'][delRingId.index(Obj)])
-        UpdateMasks(self,data)
-        G2plt.PlotExposedImage(self,event=event)
+        UpdateMasks(G2frame,data)
+        G2plt.PlotExposedImage(G2frame,event=event)
 
     def OnArcThickness(event):
@@ -739 +739 @@
         Obj.SetValue("%.3f"%(thick))
         data['Arcs'][arcIds.index(Obj.GetId())][2] = thick
-        G2plt.PlotExposedImage(self,event=event)
+        G2plt.PlotExposedImage(G2frame,event=event)
         
     def OnDeleteArc(event):
         Obj = event.GetEventObject()
         del(data['Arcs'][delArcId.index(Obj)])
-        UpdateMasks(self,data)
-        G2plt.PlotExposedImage(self,event=event)
+        UpdateMasks(G2frame,data)
+        G2plt.PlotExposedImage(G2frame,event=event)
 
     def OnDeletePoly(event):
         Obj = event.GetEventObject()
         del(data['Polygons'][delPolyId.index(Obj)])
-        UpdateMasks(self,data)
-        G2plt.PlotExposedImage(self,event=event)
+        UpdateMasks(G2frame,data)
+        G2plt.PlotExposedImage(G2frame,event=event)
 
     def OnCopyMask(event):
@@ -757 +757 @@
         TextList = [[False,'All IMG',0]]
         Names = []
-        if self.PatternTree.GetCount():
-            id, cookie = self.PatternTree.GetFirstChild(self.root)
+        if G2frame.PatternTree.GetCount():
+            id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
             while id:
-                name = self.PatternTree.GetItemText(id)
+                name = G2frame.PatternTree.GetItemText(id)
                 Names.append(name)
                 if 'IMG' in name:
-                    if id == self.Image:
+                    if id == G2frame.Image:
                         Source = name
-                        Mask = copy.deepcopy(self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'Masks')))
+                        Mask = copy.deepcopy(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'Masks')))
                         del Mask['Thresholds']
                     else:
                         TextList.append([False,name,id])
-                id, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+                id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
             if len(TextList) == 1:
-                self.ErrorDialog('Nothing to copy mask to','There must be more than one "IMG" pattern')
+                G2frame.ErrorDialog('Nothing to copy mask to','There must be more than one "IMG" pattern')
                 return
-            dlg = self.CopyDialog(self,'Copy mask information','Copy mask from '+Source+' to:',TextList)
+            dlg = G2frame.CopyDialog(G2frame,'Copy mask information','Copy mask from '+Source+' to:',TextList)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -783 +783 @@
                         ifcopy,name,id = item
                         if ifcopy:
-                            mask = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'Masks'))
+                            mask = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'Masks'))
                             mask.update(Mask)                                
-                            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'Masks'),copy.deepcopy(mask))
+                            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'Masks'),copy.deepcopy(mask))
             finally:
                 dlg.Destroy()
                 
     def OnSaveMask(event):
-        dlg = wx.FileDialog(self, 'Choose image mask file', '.', '', 
+        dlg = wx.FileDialog(G2frame, 'Choose image mask file', '.', '', 
             'image mask files (*.immask)|*.immask',wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.CHANGE_DIR)
         try:
@@ -805 +805 @@
         
     def OnLoadMask(event):
-        dlg = wx.FileDialog(self, 'Choose image mask file', '.', '', 
+        dlg = wx.FileDialog(G2frame, 'Choose image mask file', '.', '', 
             'image mask files (*.immask)|*.immask',wx.OPEN|wx.CHANGE_DIR)
         try:
@@ -822 +822 @@
                     S = File.readline()
                 data.update(save)
-                UpdateMasks(self,data)
-                G2plt.PlotExposedImage(self,event=event)
+                UpdateMasks(G2frame,data)
+                G2plt.PlotExposedImage(G2frame,event=event)
                 
                 File.close()
@@ -829 +829 @@
             dlg.Destroy()
         
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
-    self.dataFrame.SetMenuBar(self.dataFrame.MaskMenu)
-    self.dataFrame.Bind(wx.EVT_MENU, OnCopyMask, id=G2gd.wxID_MASKCOPY)
-    self.dataFrame.Bind(wx.EVT_MENU, OnLoadMask, id=G2gd.wxID_MASKLOAD)
-    self.dataFrame.Bind(wx.EVT_MENU, OnSaveMask, id=G2gd.wxID_MASKSAVE)    
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.MaskMenu)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyMask, id=G2gd.wxID_MASKCOPY)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadMask, id=G2gd.wxID_MASKLOAD)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveMask, id=G2gd.wxID_MASKSAVE)    
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
         Status.SetStatusText("To add mask: On 2D Powder Image, key a:arc, r:ring, s:spot, p:polygon")
-    self.dataDisplay = wx.Panel(self.dataFrame)
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,10),0)
@@ -849 +849 @@
     
     littleSizer = wx.FlexGridSizer(2,3,0,5)
-    littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Lower/Upper limits '),0,
-        wx.ALIGN_CENTER_VERTICAL)
-    Text = wx.TextCtrl(self.dataDisplay,value=("%8d" % (thresh[0][0])),style=wx.TE_READONLY)
+    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper limits '),0,
+        wx.ALIGN_CENTER_VERTICAL)
+    Text = wx.TextCtrl(G2frame.dataDisplay,value=("%8d" % (thresh[0][0])),style=wx.TE_READONLY)
     littleSizer.Add(Text,0,wx.ALIGN_CENTER_VERTICAL)
     Text.SetBackgroundColour(VERY_LIGHT_GREY)
-    Text = wx.TextCtrl(self.dataDisplay,value=("%8d" % (thresh[0][1])),style=wx.TE_READONLY)
+    Text = wx.TextCtrl(G2frame.dataDisplay,value=("%8d" % (thresh[0][1])),style=wx.TE_READONLY)
     littleSizer.Add(Text,0,wx.ALIGN_CENTER_VERTICAL)
     Text.SetBackgroundColour(VERY_LIGHT_GREY)
-    littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Lower/Upper thresholds '),
+    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper thresholds '),
         0,wx.ALIGN_CENTER_VERTICAL)
-    lowerThreshold = wx.TextCtrl(parent=self.dataDisplay,
+    lowerThreshold = wx.TextCtrl(parent=G2frame.dataDisplay,
         value=("%8d" % (thresh[1][0])),style=wx.TE_PROCESS_ENTER)
     lowerThreshold.Bind(wx.EVT_TEXT_ENTER,OnThreshold)
     lowerThreshold.Bind(wx.EVT_KILL_FOCUS,OnThreshold)
     littleSizer.Add(lowerThreshold,0,wx.ALIGN_CENTER_VERTICAL)
-    upperThreshold = wx.TextCtrl(parent=self.dataDisplay,
+    upperThreshold = wx.TextCtrl(parent=G2frame.dataDisplay,
         value=("%8d" % (thresh[1][1])),style=wx.TE_PROCESS_ENTER)
     upperThreshold.Bind(wx.EVT_TEXT_ENTER,OnThreshold)
@@ -874 +874 @@
     if spots:
         littleSizer = wx.FlexGridSizer(len(spots)+2,3,0,5)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Spot masks:'),0,
-            wx.ALIGN_CENTER_VERTICAL)
-        littleSizer.Add((5,0),0)
-        littleSizer.Add((5,0),0)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' position, mm'),0,
-            wx.ALIGN_CENTER_VERTICAL)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' diameter, mm'),0,
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Spot masks:'),0,
+            wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add((5,0),0)
+        littleSizer.Add((5,0),0)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' position, mm'),0,
+            wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' diameter, mm'),0,
             wx.ALIGN_CENTER_VERTICAL)
         littleSizer.Add((5,0),0)
         for x,y,d in spots:
-            spotText = wx.TextCtrl(parent=self.dataDisplay,value=("%.2f,%.2f" % (x,y)),
+            spotText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f,%.2f" % (x,y)),
                 style=wx.TE_READONLY)
             spotText.SetBackgroundColour(VERY_LIGHT_GREY)
             littleSizer.Add(spotText,0,wx.ALIGN_CENTER_VERTICAL)
             spotText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
-            spotDiameter = wx.TextCtrl(parent=self.dataDisplay,value=("%.2f" % (d)),
+            spotDiameter = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f" % (d)),
                 style=wx.TE_PROCESS_ENTER)
             littleSizer.Add(spotDiameter,0,wx.ALIGN_CENTER_VERTICAL)
@@ -895 +895 @@
             spotDiameter.Bind(wx.EVT_KILL_FOCUS,OnSpotDiameter)
             spotIds.append(spotDiameter.GetId())
-            spotDelete = wx.CheckBox(parent=self.dataDisplay,label='delete?')
+            spotDelete = wx.CheckBox(parent=G2frame.dataDisplay,label='delete?')
             spotDelete.Bind(wx.EVT_CHECKBOX,OnDeleteSpot)
             delSpotId.append(spotDelete)
@@ -904 +904 @@
     if rings:
         littleSizer = wx.FlexGridSizer(len(rings)+2,3,0,5)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Ring masks:'),0,
-            wx.ALIGN_CENTER_VERTICAL)
-        littleSizer.Add((5,0),0)
-        littleSizer.Add((5,0),0)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' 2-theta,deg'),0,
-            wx.ALIGN_CENTER_VERTICAL)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' thickness, deg'),0,
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Ring masks:'),0,
+            wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add((5,0),0)
+        littleSizer.Add((5,0),0)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,
+            wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,
             wx.ALIGN_CENTER_VERTICAL)
         littleSizer.Add((5,0),0)
         for tth,thick in rings:
-            ringText = wx.TextCtrl(parent=self.dataDisplay,value=("%.3f" % (tth)),
+            ringText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (tth)),
                 style=wx.TE_READONLY)
             ringText.SetBackgroundColour(VERY_LIGHT_GREY)
             ringText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
             littleSizer.Add(ringText,0,wx.ALIGN_CENTER_VERTICAL)
-            ringThick = wx.TextCtrl(parent=self.dataDisplay,value=("%.3f" % (thick)),
+            ringThick = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (thick)),
                 style=wx.TE_PROCESS_ENTER)
             littleSizer.Add(ringThick,0,wx.ALIGN_CENTER_VERTICAL)
@@ -925 +925 @@
             ringThick.Bind(wx.EVT_KILL_FOCUS,OnRingThickness)
             ringIds.append(ringThick.GetId())
-            ringDelete = wx.CheckBox(parent=self.dataDisplay,label='delete?')
+            ringDelete = wx.CheckBox(parent=G2frame.dataDisplay,label='delete?')
             ringDelete.Bind(wx.EVT_CHECKBOX,OnDeleteRing)
             delRingId.append(ringDelete)
@@ -934 +934 @@
     if arcs:
         littleSizer = wx.FlexGridSizer(len(rings)+2,4,0,5)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Arc masks:'),0,
-            wx.ALIGN_CENTER_VERTICAL)
-        littleSizer.Add((5,0),0)
-        littleSizer.Add((5,0),0)
-        littleSizer.Add((5,0),0)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' 2-theta,deg'),0,
-            wx.ALIGN_CENTER_VERTICAL)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' azimuth, deg'),0,
-            wx.ALIGN_CENTER_VERTICAL)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' thickness, deg'),0,
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Arc masks:'),0,
+            wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add((5,0),0)
+        littleSizer.Add((5,0),0)
+        littleSizer.Add((5,0),0)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,
+            wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' azimuth, deg'),0,
+            wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,
             wx.ALIGN_CENTER_VERTICAL)
         littleSizer.Add((5,0),0)
         for tth,azimuth,thick in arcs:
-            arcText = wx.TextCtrl(parent=self.dataDisplay,value=("%.3f" % (tth)),
+            arcText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (tth)),
                 style=wx.TE_READONLY)
             arcText.SetBackgroundColour(VERY_LIGHT_GREY)
             arcText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
             littleSizer.Add(arcText,0,wx.ALIGN_CENTER_VERTICAL)
-            azmText = wx.TextCtrl(parent=self.dataDisplay,value=("%d,%d" % (azimuth[0],azimuth[1])),
+            azmText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%d,%d" % (azimuth[0],azimuth[1])),
                 style=wx.TE_READONLY)
             azmText.SetBackgroundColour(VERY_LIGHT_GREY)
             azmText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
             littleSizer.Add(azmText,0,wx.ALIGN_CENTER_VERTICAL)
-            arcThick = wx.TextCtrl(parent=self.dataDisplay,value=("%.3f" % (thick)),
+            arcThick = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (thick)),
                 style=wx.TE_PROCESS_ENTER)
             littleSizer.Add(arcThick,0,wx.ALIGN_CENTER_VERTICAL)
@@ -963 +963 @@
             arcThick.Bind(wx.EVT_KILL_FOCUS,OnArcThickness)
             arcIds.append(arcThick.GetId())
-            arcDelete = wx.CheckBox(parent=self.dataDisplay,label='delete?')
+            arcDelete = wx.CheckBox(parent=G2frame.dataDisplay,label='delete?')
             arcDelete.Bind(wx.EVT_CHECKBOX,OnDeleteArc)
             delArcId.append(arcDelete)
@@ -972 +972 @@
     if polygons:
         littleSizer = wx.FlexGridSizer(len(polygons)+2,2,0,5)
-        littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Polygon masks:'),0,
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Polygon masks:'),0,
             wx.ALIGN_CENTER_VERTICAL)
         littleSizer.Add((5,0),0)
@@ -980 +980 @@
                 for x,y in polygon:
                     polyList.append("%.2f, %.2f"%(x,y))
-                polyText = wx.ComboBox(self.dataDisplay,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
+                polyText = wx.ComboBox(G2frame.dataDisplay,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
                 littleSizer.Add(polyText,0,wx.ALIGN_CENTER_VERTICAL)
-                polyDelete = wx.CheckBox(parent=self.dataDisplay,label='delete?')
+                polyDelete = wx.CheckBox(parent=G2frame.dataDisplay,label='delete?')
                 polyDelete.Bind(wx.EVT_CHECKBOX,OnDeletePoly)
                 delPolyId.append(polyDelete)
@@ -988 +988 @@
         mainSizer.Add(littleSizer,0,)
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    self.dataDisplay.SetSize(mainSizer.Fit(self.dataFrame))
-    self.dataFrame.setSizePosLeft(mainSizer.Fit(self.dataFrame))    
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
+    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))    

trunk/GSASIIphsGUI.py ¶

@@ -228 +228 @@
         self.Draw(self.data)
         
-def UpdatePhaseData(self,Item,data,oldPage):
+def UpdatePhaseData(G2frame,Item,data,oldPage):
 
     Atoms = []
-    if self.dataDisplay:
-        self.dataDisplay.Destroy()
-    PhaseName = self.PatternTree.GetItemText(Item)
-    self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
-    self.dataFrame.SetLabel('Phase Data for '+PhaseName)
-    self.dataFrame.CreateStatusBar()
-    self.dataDisplay = G2gd.GSNoteBook(parent=self.dataFrame,size=self.dataFrame.GetClientSize())
+    if G2frame.dataDisplay:
+        G2frame.dataDisplay.Destroy()
+    PhaseName = G2frame.PatternTree.GetItemText(Item)
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
+    G2frame.dataFrame.SetLabel('Phase Data for '+PhaseName)
+    G2frame.dataFrame.CreateStatusBar()
+    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
 
     def SetupGeneral():
@@ -256 +256 @@
         generalData['AtomMass'] = []
         generalData['Color'] = []
-        generalData['Mydir'] = self.dirname
+        generalData['Mydir'] = G2frame.dirname
         cx,ct,cs,cia = [3,1,7,9]
         generalData['AtomPtrs'] = [cx,ct,cs,cia]
@@ -294 +294 @@
         'Drawing':{}
         '''
-        self.dataFrame.SetMenuBar(self.dataFrame.DataGeneral) # do this here, since this is called from all over
+        G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.DataGeneral) # do this here, since this is called from all over
         
         phaseTypes = ['nuclear','modulated','magnetic','macromolecular','Pawley']
@@ -303 +303 @@
             oldName = generalData['Name']
             generalData['Name'] = NameTxt.GetValue()
-            self.G2plotNB.Rename(oldName,generalData['Name'])
-            self.dataFrame.SetLabel('Phase Data for '+generalData['Name'])
-            self.PatternTree.SetItemText(Item,generalData['Name'])
+            G2frame.G2plotNB.Rename(oldName,generalData['Name'])
+            G2frame.dataFrame.SetLabel('Phase Data for '+generalData['Name'])
+            G2frame.PatternTree.SetItemText(Item,generalData['Name'])
             #Hmm, need to change phase name key in Reflection Lists for each histogram
                         
@@ -314 +314 @@
                 UpdateGeneral()         #must use this way!
                 if generalData['Type'] == 'Pawley':
-                    if self.dataDisplay.FindPage('Atoms'):
-                        self.dataDisplay.DeletePage(self.dataDisplay.FindPage('Atoms'))
-                        self.dataDisplay.DeletePage(self.dataDisplay.FindPage('Draw Options'))
-                        self.dataDisplay.DeletePage(self.dataDisplay.FindPage('Draw Atoms'))
-                    if not self.dataDisplay.FindPage('Pawley reflections'):
-                        self.PawleyRefl = G2gd.GSGrid(self.dataDisplay)      
-                        self.dataDisplay.AddPage(self.PawleyRefl,'Pawley reflections')
+                    if G2frame.dataDisplay.FindPage('Atoms'):
+                        G2frame.dataDisplay.DeletePage(G2frame.dataDisplay.FindPage('Atoms'))
+                        G2frame.dataDisplay.DeletePage(G2frame.dataDisplay.FindPage('Draw Options'))
+                        G2frame.dataDisplay.DeletePage(G2frame.dataDisplay.FindPage('Draw Atoms'))
+                    if not G2frame.dataDisplay.FindPage('Pawley reflections'):
+                        G2frame.PawleyRefl = G2gd.GSGrid(G2frame.dataDisplay)      
+                        G2frame.dataDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
             else:
                 TypeTxt.SetValue(generalData['Type'])                
@@ -591 +591 @@
 
         dataDisplay.SetSizer(mainSizer)
-        Size = mainSizer.Fit(self.dataFrame)
+        Size = mainSizer.Fit(G2frame.dataFrame)
         Size[1] += 26                           #compensate for status bar
         dataDisplay.SetSize(Size)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
 
     def FillAtomsGrid():
 
-        self.dataFrame.setSizePosLeft([700,300])
+        G2frame.dataFrame.setSizePosLeft([700,300])
         generalData = data['General']
         atomData = data['Atoms']
@@ -605 +605 @@
         if atomData:
             for item in Items:    
-                self.dataFrame.AtomsMenu.Enable(item,True)
+                G2frame.dataFrame.AtomsMenu.Enable(item,True)
         else:
             for item in Items:
-                self.dataFrame.AtomsMenu.Enable(item,False)            
+                G2frame.dataFrame.AtomsMenu.Enable(item,False)            
             
         AAchoice = ": ,ALA,ARG,ASN,ASP,CYS,GLN,GLU,GLY,HIS,ILE,LEU,LYS,MET,PHE,PRO,SER,THR,TRP,TYR,VAL,MSE,HOH,UNK"
@@ -644 +644 @@
                     elif Type in ['magnetic',]:
                         choice = ['F - site fraction','X - coordinates','U - thermal parameters','M - magnetic moment']
-                    dlg = wx.MultiChoiceDialog(self,'Select','Refinement controls',choice)
+                    dlg = wx.MultiChoiceDialog(G2frame,'Select','Refinement controls',choice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelections()
@@ -653 +653 @@
                 elif Atoms.GetColLabelValue(c) == 'I/A':
                     choice = ['Isotropic','Anisotropic']
-                    dlg = wx.SingleChoiceDialog(self,'Select','Thermal Motion',choice)
+                    dlg = wx.SingleChoiceDialog(G2frame,'Select','Thermal Motion',choice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelection()
@@ -660 +660 @@
                 elif Atoms.GetColLabelValue(c) == 'Type':
                     choice = generalData['AtomTypes']
-                    dlg = wx.SingleChoiceDialog(self,'Select','Atom types',choice)
+                    dlg = wx.SingleChoiceDialog(G2frame,'Select','Atom types',choice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelection()
@@ -675 +675 @@
                             choice.append(str(atomData[r][c]))
                     choice.sort()
-                    dlg = wx.SingleChoiceDialog(self,'Select','Residue',choice)
+                    dlg = wx.SingleChoiceDialog(G2frame,'Select','Residue',choice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelection()
@@ -689 +689 @@
                         if str(atomData[r][c]) not in choice:
                             choice.append(str(atomData[r][c]))
-                    dlg = wx.SingleChoiceDialog(self,'Select','Residue no.',choice)
+                    dlg = wx.SingleChoiceDialog(G2frame,'Select','Residue no.',choice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelection()
@@ -703 +703 @@
                         if atomData[r][c] not in choice:
                             choice.append(atomData[r][c])
-                    dlg = wx.SingleChoiceDialog(self,'Select','Chain',choice)
+                    dlg = wx.SingleChoiceDialog(G2frame,'Select','Chain',choice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelection()
@@ -815 +815 @@
             r,c =  event.GetRow(),event.GetCol()
             if Atoms.GetColLabelValue(c) == 'Type':
-                PE = G2elem.PickElement(self)
+                PE = G2elem.PickElement(G2frame)
                 if PE.ShowModal() == wx.ID_OK:
                     atomData[r][c] = PE.Elem.strip()
@@ -869 +869 @@
         SGData = data['General']['SGData']
         if SGData['SGPolax']:
-            self.dataFrame.SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'])
+            G2frame.dataFrame.SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'])
         table = []
         rowLabels = []
@@ -944 +944 @@
         if 'Atoms' in data['Drawing']:            
             DrawAtomAdd(data['Drawing'],atomData[-1])
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
     def OnAtomInsert(event):
@@ -990 +990 @@
                 DrawAtomsDeleteByIDs(IDs)
                 FillAtomsGrid()
-                G2plt.PlotStructure(self,data)
+                G2plt.PlotStructure(G2frame,data)
         event.StopPropagation()
 
@@ -1005 +1005 @@
             elif Type == 'magnetic':
                 choice = ['F - site fraction','X - coordinates','U - thermal parameters','M - magnetic moment']
-            dlg = wx.MultiChoiceDialog(self,'Select','Refinement controls',choice)
+            dlg = wx.MultiChoiceDialog(G2frame,'Select','Refinement controls',choice)
             if dlg.ShowModal() == wx.ID_OK:
                 sel = dlg.GetSelections()
@@ -1034 +1034 @@
             generalData = data['General']
             SGData = generalData['SGData']
-            dlg = SymOpDialog(self,SGData,True)
+            dlg = SymOpDialog(G2frame,SGData,True)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -1080 +1080 @@
             if 'DisAglCtls' in generalData:
                 DisAglCtls = generalData['DisAglCtls']
-            dlg = DisAglDialog(self,DisAglCtls,generalData)
+            dlg = DisAglDialog(G2frame,DisAglCtls,generalData)
             if dlg.ShowModal() == wx.ID_OK:
                 DisAglCtls = dlg.GetData()
@@ -1100 +1100 @@
             if 'pId' in data:
                 DisAglData['pId'] = data['pId']
-                DisAglData['covData'] = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.root, 'Covariance'))
+                DisAglData['covData'] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
             G2str.DistAngle(DisAglCtls,DisAglData)
             
@@ -1230 +1230 @@
                 choice.sort()
 
-                dlg = wx.MultiChoiceDialog(self,'Select',name,choice)
+                dlg = wx.MultiChoiceDialog(G2frame,'Select',name,choice)
                 if dlg.ShowModal() == wx.ID_OK:
                     sel = dlg.GetSelections()
@@ -1246 +1246 @@
                             drawAtoms.SelectRow(row,True)
                             drawingData['selectedAtoms'].append(row)
-                    G2plt.PlotStructure(self,data)                    
+                    G2plt.PlotStructure(G2frame,data)                    
                 dlg.Destroy()
                 
@@ -1259 +1259 @@
                 noSkip = True
                 if drawAtoms.GetColLabelValue(c) == 'Style':
-                    dlg = wx.SingleChoiceDialog(self,'Select','Atom drawing style',styleChoice)
+                    dlg = wx.SingleChoiceDialog(G2frame,'Select','Atom drawing style',styleChoice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelection()
@@ -1267 +1267 @@
                             drawAtoms.SetCellValue(r,c,parms)
                         FindBondsDraw()
-                        G2plt.PlotStructure(self,data)
+                        G2plt.PlotStructure(G2frame,data)
                     dlg.Destroy()
                 elif drawAtoms.GetColLabelValue(c) == 'Label':
-                    dlg = wx.SingleChoiceDialog(self,'Select','Atom labelling style',labelChoice)
+                    dlg = wx.SingleChoiceDialog(G2frame,'Select','Atom labelling style',labelChoice)
                     if dlg.ShowModal() == wx.ID_OK:
                         sel = dlg.GetSelection()
@@ -1279 +1279 @@
                     dlg.Destroy()                    
                 elif drawAtoms.GetColLabelValue(c) == 'Color':
-                    dlg = wx.ColourDialog(self)
+                    dlg = wx.ColourDialog(G2frame)
                     if dlg.ShowModal() == wx.ID_OK:
                         color = dlg.GetColourData().GetColour()
@@ -1315 +1315 @@
                     colors.SetCustomColour(0,color)
                     colors.SetColour(color)
-                    dlg = wx.ColourDialog(self,colors)
+                    dlg = wx.ColourDialog(G2frame,colors)
                     dlg.GetColourData().SetCustomColour(0,color)
                     if dlg.ShowModal() == wx.ID_OK:
@@ -1328 +1328 @@
                     event.StopPropagation()
                     UpdateDrawAtoms()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
                     
         def RowSelect(event):
@@ -1349 +1349 @@
             drawingData['selectedAtoms'] = []
             drawingData['selectedAtoms'] = drawAtoms.GetSelectedRows()
-            G2plt.PlotStructure(self,data)                    
+            G2plt.PlotStructure(G2frame,data)                    
                 
         table = []
@@ -1384 +1384 @@
            if colLabels[c] not in ['Style','Label','Color']:
                 drawAtoms.SetColAttr(c,attr)
-        self.dataFrame.setSizePosLeft([600,300])
+        G2frame.dataFrame.setSizePosLeft([600,300])
         
         FindBondsDraw()
         drawAtoms.ClearSelection()
-        G2plt.PlotStructure(self,data)
+        G2plt.PlotStructure(G2frame,data)
 
     def DrawAtomStyle(event):
@@ -1400 +1400 @@
                 styleChoice = [' ','lines','vdW balls','sticks','balls & sticks','ellipsoids',
                 'backbone','ribbons','schematic']
-            dlg = wx.SingleChoiceDialog(self,'Select','Atom drawing style',styleChoice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select','Atom drawing style',styleChoice)
             if dlg.ShowModal() == wx.ID_OK:
                 sel = dlg.GetSelection()
@@ -1410 +1410 @@
             FindBondsDraw()
             drawAtoms.ClearSelection()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
     def DrawAtomLabel(event):
@@ -1421 +1421 @@
             if generalData['Type'] == 'macromolecular':
                 styleChoice = [' ','type','name','number','residue','1-letter','chain']
-            dlg = wx.SingleChoiceDialog(self,'Select','Atom label style',styleChoice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select','Atom label style',styleChoice)
             if dlg.ShowModal() == wx.ID_OK:
                 sel = dlg.GetSelection()
@@ -1430 +1430 @@
             dlg.Destroy()
             drawAtoms.ClearSelection()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
     def DrawAtomColor(event):
@@ -1437 +1437 @@
         if indx:
             if len(indx) > 1:
-                self.dataFrame.SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK')
+                G2frame.dataFrame.SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK')
             else:
-                self.dataFrame.SetStatusText('Change color, Add to Custom Colors, then OK')
+                G2frame.dataFrame.SetStatusText('Change color, Add to Custom Colors, then OK')
             generalData = data['General']
             atomData = data['Drawing']['Atoms']
@@ -1455 +1455 @@
             for i,color in enumerate(atmColors):
                 colors.SetCustomColour(i,color)
-            dlg = wx.ColourDialog(self,colors)
+            dlg = wx.ColourDialog(G2frame,colors)
             if dlg.ShowModal() == wx.ID_OK:
                 for i in range(len(atmColors)):                    
@@ -1469 +1469 @@
             drawAtoms.ClearSelection()
             dlg.Destroy()
-            self.dataFrame.SetStatusText('')
+            G2frame.dataFrame.SetStatusText('')
             
     def ResetAtomColors(event):
@@ -1480 +1480 @@
         UpdateDrawAtoms()
         drawAtoms.ClearSelection()
-        G2plt.PlotStructure(self,data)        
+        G2plt.PlotStructure(G2frame,data)        
         
     def SetViewPoint(event):
@@ -1489 +1489 @@
             data['Drawing']['viewPoint'] = [atomData[indx[0]][cx:cx+3],[indx[0],0]]
             drawAtoms.ClearSelection()                                  #do I really want to do this?
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
     def noDuplicate(xyz,atomData):                  #be careful where this is used - it's slow
@@ -1509 +1509 @@
             generalData = data['General']
             SGData = generalData['SGData']
-            dlg = SymOpDialog(self,SGData,False)
+            dlg = SymOpDialog(G2frame,SGData,False)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -1540 +1540 @@
             UpdateDrawAtoms()
             drawAtoms.ClearSelection()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
     def TransformSymEquiv(event):
@@ -1554 +1554 @@
             generalData = data['General']
             SGData = generalData['SGData']
-            dlg = SymOpDialog(self,SGData,False)
+            dlg = SymOpDialog(G2frame,SGData,False)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -1584 +1584 @@
             UpdateDrawAtoms()
             drawAtoms.ClearSelection()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
     def FillCoordSphere(event):
@@ -1627 +1627 @@
             UpdateDrawAtoms()
             drawAtoms.ClearSelection()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
     def FillUnitCell(event):
@@ -1680 +1680 @@
             UpdateDrawAtoms()
             drawAtoms.ClearSelection()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
     def FindBondsToo():                         #works but slow for large structures - keep as reference
@@ -1752 +1752 @@
             if atomA[2] in ['lines','sticks','ellipsoids','balls & sticks','polyhedra']:
                 Dx = Atoms-atomA[1]
-                dist = ma.masked_less(np.sqrt(np.sum(np.inner(Amat,Dx)**2,axis=0)),0.5) #gets rid of self & disorder "bonds" < 0.5A
+                dist = ma.masked_less(np.sqrt(np.sum(np.inner(Amat,Dx)**2,axis=0)),0.5) #gets rid of G2frame & disorder "bonds" < 0.5A
                 sumR = atomA[3]+Radii
                 IndB = ma.nonzero(ma.masked_greater(dist-data['Drawing']['radiusFactor']*sumR,0.))                 #get indices of bonded atoms
@@ -1789 +1789 @@
             UpdateDrawAtoms()
             drawAtoms.ClearSelection()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
         event.StopPropagation()
         
@@ -1796 +1796 @@
         UpdateDrawAtoms()
         drawAtoms.ClearSelection()
-        G2plt.PlotStructure(self,data)
+        G2plt.PlotStructure(G2frame,data)
         event.StopPropagation()
         
@@ -1848 +1848 @@
         if 'pId' in data:
             TorsionData['pId'] = data['pId']
-            TorsionData['covData'] = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.root, 'Covariance'))
+            TorsionData['covData'] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
         G2str.Torsion(TorsionData)
         
@@ -1890 +1890 @@
             drawingData['Zclip'] = Zclip.GetValue()
             ZclipTxt.SetLabel('Z clipping: '+'%.2fA'%(drawingData['Zclip']*drawingData['cameraPos']/100.))
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
         def OnCameraPos(event):
@@ -1896 +1896 @@
             cameraPosTxt.SetLabel('Camera Distance: '+'%.2f'%(drawingData['cameraPos']))
             ZclipTxt.SetLabel('Z clipping: '+'%.2fA'%(drawingData['Zclip']*drawingData['cameraPos']/100.))
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnBackColor(event):
             drawingData['backColor'] = event.GetValue()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnBallScale(event):
             drawingData['ballScale'] = ballScale.GetValue()/100.
             ballScaleTxt.SetLabel('Ball scale: '+'%.2f'%(drawingData['ballScale']))
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnVdWScale(event):
             drawingData['vdwScale'] = vdwScale.GetValue()/100.
             vdwScaleTxt.SetLabel('van der Waals scale: '+'%.2f'%(drawingData['vdwScale']))
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnEllipseProb(event):
             drawingData['ellipseProb'] = ellipseProb.GetValue()
             ellipseProbTxt.SetLabel('Ellipsoid probability: '+'%d%%'%(drawingData['ellipseProb']))
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnBondRadius(event):
             drawingData['bondRadius'] = bondRadius.GetValue()/100.
             bondRadiusTxt.SetLabel('Bond radius, A: '+'%.2f'%(drawingData['bondRadius']))
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnShowABC(event):
             drawingData['showABC'] = showABC.GetValue()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnShowUnitCell(event):
             drawingData['unitCellBox'] = unitCellBox.GetValue()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnShowHyd(event):
             drawingData['showHydrogen'] = showHydrogen.GetValue()
             FindBondsDraw()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         def OnSizeHatoms(event):
@@ -1942 +1942 @@
             drawingData['sizeH'] = value
             sizeH.SetValue("%.2f"%(value))
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
             
         def OnRadFactor(event):
@@ -1952 +1952 @@
             radFactor.SetValue("%.2f"%(value))
             FindBondsDraw()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
 
         dataDisplay = wx.Panel(drawOptions)
@@ -2055 +2055 @@
 
         dataDisplay.SetSizer(mainSizer)
-        Size = mainSizer.Fit(self.dataFrame)
+        Size = mainSizer.Fit(G2frame.dataFrame)
         Size[1] += 26                           #compensate for status bar
         dataDisplay.SetSize(Size)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
         
     def UpdateTexture():
@@ -2078 +2078 @@
         shModels = ['cylindrical','none','shear - 2/m','rolling - mmm']
         SamSym = dict(zip(shModels,['0','-1','2/m','mmm']))
-        if generalData['Type'] == 'Pawley' and G2gd.GetPatternTreeItemId(self,self.root,'Sequental results'):
-            self.dataFrame.RefineTexture.Enable(True)
+        if generalData['Type'] == 'Pawley' and G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequental results'):
+            G2frame.dataFrame.RefineTexture.Enable(True)
         shAngles = ['omega','chi','phi']
         
@@ -2096 +2096 @@
             textureData['SH Coeff'][1] = SetSHCoef()
             wx.CallAfter(UpdateTexture)
-            G2plt.PlotTexture(self,data,newPlot=False)
+            G2plt.PlotTexture(G2frame,data,newPlot=False)
                         
         def OnShModel(event):
@@ -2103 +2103 @@
             textureData['SH Coeff'][1] = SetSHCoef()
             wx.CallAfter(UpdateTexture)
-            G2plt.PlotTexture(self,data,newPlot=False)
+            G2plt.PlotTexture(G2frame,data,newPlot=False)
             
         def OnSHRefine(event):
@@ -2116 +2116 @@
         def OnProjSel(event):
             Obj = event.GetEventObject()
-            self.Projection = Obj.GetValue()
-            G2plt.PlotTexture(self,data,newPlot=False)
+            G2frame.Projection = Obj.GetValue()
+            G2plt.PlotTexture(G2frame,data,newPlot=False)
             
         def OnColorSel(event):
             Obj = event.GetEventObject()
-            self.ContourColor = Obj.GetValue()
-            G2plt.PlotTexture(self,data,newPlot=False)
+            G2frame.ContourColor = Obj.GetValue()
+            G2plt.PlotTexture(G2frame,data,newPlot=False)
             
         def OnAngRef(event):
@@ -2145 +2145 @@
             Obj.SetValue('%8.3f'%(value))
             textureData['SH Coeff'][1][ODFIndx[Obj.GetId()]] = value
-            G2plt.PlotTexture(self,data,newPlot=False)
+            G2plt.PlotTexture(G2frame,data,newPlot=False)
             
         def OnPfType(event):
@@ -2151 +2151 @@
             textureData['PlotType'] = Obj.GetValue()
             wx.CallAfter(UpdateTexture)
-            G2plt.PlotTexture(self,data)
+            G2plt.PlotTexture(G2frame,data)
             
         def OnPFValue(event):
@@ -2174 +2174 @@
                 Obj.SetValue('%3.1f %3.1f %3.1f'%(xyz[0],xyz[1],xyz[2]))
                 textureData['PFxyz'] = xyz
-            G2plt.PlotTexture(self,data)
+            G2plt.PlotTexture(G2frame,data)
 
         if Texture.GetSizer():
@@ -2216 +2216 @@
         if 'Axial' not in textureData['PlotType']:
             PTSizer.Add(wx.StaticText(Texture,-1,' Projection type: '),0,wx.ALIGN_CENTER_VERTICAL)
-            projSel = wx.ComboBox(Texture,-1,value=self.Projection,choices=['equal area','stereographic','3D display'],
+            projSel = wx.ComboBox(Texture,-1,value=G2frame.Projection,choices=['equal area','stereographic','3D display'],
                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
             projSel.Bind(wx.EVT_COMBOBOX,OnProjSel)
@@ -2235 +2235 @@
             choice = [m for m in mpl.cm.datad.keys() if not m.endswith("_r")]
             choice.sort()
-            colorSel = wx.ComboBox(Texture,-1,value=self.ContourColor,choices=choice,
+            colorSel = wx.ComboBox(Texture,-1,value=G2frame.ContourColor,choices=choice,
                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
             colorSel.Bind(wx.EVT_COMBOBOX,OnColorSel)
@@ -2277 +2277 @@
         mainSizer.Add(angSizer,0,wx.ALIGN_CENTER_VERTICAL)
         Texture.SetSizer(mainSizer,True)
-        mainSizer.Fit(self.dataFrame)
+        mainSizer.Fit(G2frame.dataFrame)
         Size = mainSizer.GetMinSize()
         Size[0] += 40
@@ -2284 +2284 @@
         Texture.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
         Size[1] = min(Size[1],450)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
         
     def UpdateDData():
         UseList = data['Histograms']
         if UseList:
-            self.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,True)
-            self.Refine.Enable(True)
+            G2frame.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,True)
+            G2frame.Refine.Enable(True)
         else:
-            self.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,False)
-            self.Refine.Enable(False)            
+            G2frame.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,False)
+            G2frame.Refine.Enable(False)            
         generalData = data['General']        
         SGData = generalData['SGData']
@@ -2304 +2304 @@
             generalData['Data plot type'] = Obj.GetStringSelection()
             wx.CallAfter(UpdateDData)
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
             
         def OnPOhkl(event):
@@ -2318 +2318 @@
             h,k,l = hkl
             Obj.SetValue('%3d %3d %3d'%(h,k,l)) 
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
         
         def OnShowData(event):
@@ -2325 +2325 @@
             UseList[hist]['Show'] = Obj.GetValue()
             wx.CallAfter(UpdateDData)
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
             
         def OnCopyData(event):
@@ -2339 +2339 @@
             if UseList:
                 copyList = []
-                dlg = wx.MultiChoiceDialog(self, 
+                dlg = wx.MultiChoiceDialog(G2frame, 
                     'Copy parameters to which histograms?', 'Copy parameters', 
                     keyList, wx.CHOICEDLG_STYLE)
@@ -2373 +2373 @@
             hist = Indx[Obj.GetId()]
             UseList[hist]['Size'][0] = Obj.GetValue()
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
             wx.CallAfter(UpdateDData)
             
@@ -2405 +2405 @@
                     pass
                 Obj.SetValue("%.3f"%(UseList[hist]['Size'][1][pid]))          #reset in case of error
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
             
         def OnSizeAxis(event):            
@@ -2425 +2425 @@
             hist = Indx[Obj.GetId()]
             UseList[hist]['Mustrain'][0] = Obj.GetValue()
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
             wx.CallAfter(UpdateDData)
             
@@ -2456 +2456 @@
             else:
                 Obj.SetValue("%.1f"%(UseList[hist]['Mustrain'][1][pid]))          #reset in case of error
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
             
         def OnStrainAxis(event):
@@ -2471 +2471 @@
             h,k,l = hkl
             Obj.SetValue('%3d %3d %3d'%(h,k,l)) 
-            G2plt.PlotSizeStrainPO(self,data)
+            G2plt.PlotSizeStrainPO(G2frame,data)
             
         def OnHstrainRef(event):
@@ -2889 +2889 @@
 
         DData.SetSizer(mainSizer,True)
-        mainSizer.FitInside(self.dataFrame)
+        mainSizer.FitInside(G2frame.dataFrame)
         Size = mainSizer.GetMinSize()
         Size[0] += 40
@@ -2896 +2896 @@
         DData.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
         Size[1] = min(Size[1],450)
-        self.dataFrame.setSizePosLeft(Size)
+        G2frame.dataFrame.setSizePosLeft(Size)
         
     def OnHklfAdd(event):
@@ -2902 +2902 @@
         keyList = UseList.keys()
         TextList = []
-        if self.PatternTree.GetCount():
-            item, cookie = self.PatternTree.GetFirstChild(self.root)
+        if G2frame.PatternTree.GetCount():
+            item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
             while item:
-                name = self.PatternTree.GetItemText(item)
+                name = G2frame.PatternTree.GetItemText(item)
                 if name not in keyList and 'HKLF' in name:
                     TextList.append(name)
-                item, cookie = self.PatternTree.GetNextChild(self.root, cookie)                        
-            dlg = wx.MultiChoiceDialog(self, 'Which new data to use?', 'Use data', TextList, wx.CHOICEDLG_STYLE)
+                item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)                        
+            dlg = wx.MultiChoiceDialog(G2frame, 'Which new data to use?', 'Use data', TextList, wx.CHOICEDLG_STYLE)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -2931 +2931 @@
         keyList = UseList.keys()
         TextList = ['All PWDR']
-        if self.PatternTree.GetCount():
-            item, cookie = self.PatternTree.GetFirstChild(self.root)
+        if G2frame.PatternTree.GetCount():
+            item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
             while item:
-                name = self.PatternTree.GetItemText(item)
+                name = G2frame.PatternTree.GetItemText(item)
                 if name not in keyList and 'PWDR' in name:
                     TextList.append(name)
-                item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
-            dlg = wx.MultiChoiceDialog(self, 'Which new data to use?', 'Use data', TextList, wx.CHOICEDLG_STYLE)
+                item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
+            dlg = wx.MultiChoiceDialog(G2frame, 'Which new data to use?', 'Use data', TextList, wx.CHOICEDLG_STYLE)
             try:
                 if dlg.ShowModal() == wx.ID_OK:
@@ -2946 +2946 @@
                         newList = TextList[1:]
                     for histoName in newList:
-                        pId = G2gd.GetPatternTreeItemId(self,self.root,histoName)
+                        pId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
                         UseList[histoName] = {'Histogram':histoName,'Show':False,
                             'Scale':[1.0,False],'Pref.Ori.':['MD',1.0,False,[0,0,1],0,{}],
@@ -2954 +2954 @@
                             'HStrain':[NDij*[0.0,],NDij*[False,]],                          
                             'Extinction':[0.0,False]}
-                        refList = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,pId,'Reflection Lists'))
+                        refList = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,pId,'Reflection Lists'))
                         refList[generalData['Name']] = []                       
                     data['Histograms'] = UseList
@@ -2968 +2968 @@
         if UseList:
             DelList = []
-            dlg = wx.MultiChoiceDialog(self, 
+            dlg = wx.MultiChoiceDialog(G2frame, 
                 'Which histogram to delete from this phase?', 'Delete histogram', 
                 keyList, wx.CHOICEDLG_STYLE)
@@ -2987 +2987 @@
                         
         def KeyEditPawleyGrid(event):
-            colList = self.PawleyRefl.GetSelectedCols()
+            colList = G2frame.PawleyRefl.GetSelectedCols()
             PawleyPeaks = data['Pawley ref']
             if event.GetKeyCode() == wx.WXK_RETURN:
@@ -2996 +2996 @@
                 event.Skip(True)
             elif colList:
-                self.PawleyRefl.ClearSelection()
+                G2frame.PawleyRefl.ClearSelection()
                 key = event.GetKeyCode()
                 for col in colList:
@@ -3014 +3014 @@
                 2*[wg.GRID_VALUE_FLOAT+':10,2',]
             PawleyTable = G2gd.Table(PawleyPeaks,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            self.PawleyRefl.SetTable(PawleyTable, True)
-            self.PawleyRefl.Bind(wx.EVT_KEY_DOWN, KeyEditPawleyGrid)                 
-            self.PawleyRefl.SetMargins(0,0)
-            self.PawleyRefl.AutoSizeColumns(False)
-            self.dataFrame.setSizePosLeft([500,300])
+            G2frame.PawleyRefl.SetTable(PawleyTable, True)
+            G2frame.PawleyRefl.Bind(wx.EVT_KEY_DOWN, KeyEditPawleyGrid)                 
+            G2frame.PawleyRefl.SetMargins(0,0)
+            G2frame.PawleyRefl.AutoSizeColumns(False)
+            G2frame.dataFrame.setSizePosLeft([500,300])
                     
     def OnPawleyLoad(event):
@@ -3047 +3047 @@
             return
         HistoNames = Histograms.keys()
-        PatternId = G2gd.GetPatternTreeItemId(self,self.root,HistoNames[0])
-        xdata = self.PatternTree.GetItemPyData(PatternId)[1]
-        Inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId,'Instrument Parameters'))
+        PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistoNames[0])
+        xdata = G2frame.PatternTree.GetItemPyData(PatternId)[1]
+        Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Instrument Parameters'))
         Inst = dict(zip(Inst[3],Inst[1]))
-        Sample = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId,'Sample Parameters'))
+        Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Sample Parameters'))
         if 'Lam' in Inst:
             wave = Inst['Lam']
@@ -3075 +3075 @@
                             
     def OnPawleyDelete(event):
-        dlg = wx.MessageDialog(self,'Do you really want to delete Pawley reflections?','Delete', 
+        dlg = wx.MessageDialog(G2frame,'Do you really want to delete Pawley reflections?','Delete', 
             wx.YES_NO | wx.ICON_QUESTION)
         try:
@@ -3093 +3093 @@
     def OnPageChanged(event):
         page = event.GetSelection()
-        text = self.dataDisplay.GetPageText(page)
+        text = G2frame.dataDisplay.GetPageText(page)
         if text == 'Atoms':
-            self.dataFrame.SetMenuBar(self.dataFrame.AtomsMenu)
-            self.dataFrame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
-            self.dataFrame.Bind(wx.EVT_MENU, OnAtomTestAdd, id=G2gd.wxID_ATOMSTESTADD)
-            self.dataFrame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
-            self.dataFrame.Bind(wx.EVT_MENU, OnAtomTestInsert, id=G2gd.wxID_ATONTESTINSERT)
-            self.dataFrame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
-            self.dataFrame.Bind(wx.EVT_MENU, AtomRefine, id=G2gd.wxID_ATOMSREFINE)
-            self.dataFrame.Bind(wx.EVT_MENU, AtomModify, id=G2gd.wxID_ATOMSMODIFY)
-            self.dataFrame.Bind(wx.EVT_MENU, AtomTransform, id=G2gd.wxID_ATOMSTRANSFORM)
-            self.dataFrame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
-            self.dataFrame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.AtomsMenu)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomTestAdd, id=G2gd.wxID_ATOMSTESTADD)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomTestInsert, id=G2gd.wxID_ATONTESTINSERT)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, AtomRefine, id=G2gd.wxID_ATOMSREFINE)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, AtomModify, id=G2gd.wxID_ATOMSMODIFY)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, AtomTransform, id=G2gd.wxID_ATOMSTRANSFORM)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
             FillAtomsGrid()
         elif text == 'General':
             UpdateGeneral()
         elif text == 'Data':
-            self.dataFrame.SetMenuBar(self.dataFrame.DataMenu)
-            self.dataFrame.Bind(wx.EVT_MENU, OnPwdrAdd, id=G2gd.wxID_PWDRADD)
-            self.dataFrame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2gd.wxID_HKLFADD)
-            self.dataFrame.Bind(wx.EVT_MENU, OnDataDelete, id=G2gd.wxID_DATADELETE)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.DataMenu)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnPwdrAdd, id=G2gd.wxID_PWDRADD)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2gd.wxID_HKLFADD)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataDelete, id=G2gd.wxID_DATADELETE)
             UpdateDData()
-            G2plt.PlotSizeStrainPO(self,data,Start=True)
+            G2plt.PlotSizeStrainPO(G2frame,data,Start=True)
         elif text == 'Draw Options':
-            self.dataFrame.SetMenuBar(self.dataFrame.DataDrawOptions)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.DataDrawOptions)
             UpdateDrawOptions()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
         elif text == 'Draw Atoms':
-            self.dataFrame.SetMenuBar(self.dataFrame.DrawAtomsMenu)
-            self.dataFrame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2gd.wxID_DRAWATOMSTYLE)
-            self.dataFrame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2gd.wxID_DRAWATOMLABEL)
-            self.dataFrame.Bind(wx.EVT_MENU, DrawAtomColor, id=G2gd.wxID_DRAWATOMCOLOR)
-            self.dataFrame.Bind(wx.EVT_MENU, ResetAtomColors, id=G2gd.wxID_DRAWATOMRESETCOLOR)
-            self.dataFrame.Bind(wx.EVT_MENU, SetViewPoint, id=G2gd.wxID_DRAWVIEWPOINT)
-            self.dataFrame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2gd.wxID_DRAWADDEQUIV)
-            self.dataFrame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2gd.wxID_DRAWTRANSFORM)
-            self.dataFrame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2gd.wxID_DRAWFILLCOORD)            
-            self.dataFrame.Bind(wx.EVT_MENU, FillUnitCell, id=G2gd.wxID_DRAWFILLCELL)
-            self.dataFrame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2gd.wxID_DRAWDELETE)
-            self.dataFrame.Bind(wx.EVT_MENU, OnDrawDistAngle, id=G2gd.wxID_DRAWDISAGL)
-            self.dataFrame.Bind(wx.EVT_MENU, OnDrawTorsion, id=G2gd.wxID_DRAWTORSION)
-            self.dataFrame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2gd.wxID_DRAWPLANE)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.DrawAtomsMenu)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2gd.wxID_DRAWATOMSTYLE)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2gd.wxID_DRAWATOMLABEL)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomColor, id=G2gd.wxID_DRAWATOMCOLOR)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, ResetAtomColors, id=G2gd.wxID_DRAWATOMRESETCOLOR)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, SetViewPoint, id=G2gd.wxID_DRAWVIEWPOINT)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2gd.wxID_DRAWADDEQUIV)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2gd.wxID_DRAWTRANSFORM)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2gd.wxID_DRAWFILLCOORD)            
+            G2frame.dataFrame.Bind(wx.EVT_MENU, FillUnitCell, id=G2gd.wxID_DRAWFILLCELL)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2gd.wxID_DRAWDELETE)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawDistAngle, id=G2gd.wxID_DRAWDISAGL)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawTorsion, id=G2gd.wxID_DRAWTORSION)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2gd.wxID_DRAWPLANE)
             UpdateDrawAtoms()
-            G2plt.PlotStructure(self,data)
+            G2plt.PlotStructure(G2frame,data)
         elif text == 'Pawley reflections':
-            self.dataFrame.SetMenuBar(self.dataFrame.PawleyMenu)
-            self.dataFrame.Bind(wx.EVT_MENU, OnPawleyLoad, id=G2gd.wxID_PAWLEYLOAD)
-            self.dataFrame.Bind(wx.EVT_MENU, OnPawleyEstimate, id=G2gd.wxID_PAWLEYESTIMATE)
-            self.dataFrame.Bind(wx.EVT_MENU, OnPawleyDelete, id=G2gd.wxID_PAWLEYDELETE)            
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.PawleyMenu)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyLoad, id=G2gd.wxID_PAWLEYLOAD)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyEstimate, id=G2gd.wxID_PAWLEYESTIMATE)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyDelete, id=G2gd.wxID_PAWLEYDELETE)            
             FillPawleyReflectionsGrid()
         elif text == 'Texture':
-            self.dataFrame.SetMenuBar(self.dataFrame.TextureMenu)
-            self.dataFrame.Bind(wx.EVT_MENU, OnTextureRefine, id=G2gd.wxID_REFINETEXTURE)
-            self.dataFrame.Bind(wx.EVT_MENU, OnTextureClear, id=G2gd.wxID_CLEARTEXTURE)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.TextureMenu)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnTextureRefine, id=G2gd.wxID_REFINETEXTURE)
+            G2frame.dataFrame.Bind(wx.EVT_MENU, OnTextureClear, id=G2gd.wxID_CLEARTEXTURE)
             UpdateTexture()                        
-            G2plt.PlotTexture(self,data,Start=True)
+            G2plt.PlotTexture(G2frame,data,Start=True)
         else:
-            self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
+            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
         event.Skip()
         
-    General = wx.Window(self.dataDisplay)
-    self.dataDisplay.AddPage(General,'General')
+    General = wx.Window(G2frame.dataDisplay)
+    G2frame.dataDisplay.AddPage(General,'General')
     SetupGeneral()
     GeneralData = data['General']
@@ -3160 +3160 @@
 
     if GeneralData['Type'] == 'Pawley':
-        DData = wx.ScrolledWindow(self.dataDisplay)
-        self.dataDisplay.AddPage(DData,'Data')
-        self.PawleyRefl = G2gd.GSGrid(self.dataDisplay)
-        self.dataDisplay.AddPage(self.PawleyRefl,'Pawley reflections')
-        Texture = wx.ScrolledWindow(self.dataDisplay)
-        self.dataDisplay.AddPage(Texture,'Texture')
+        DData = wx.ScrolledWindow(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(DData,'Data')
+        G2frame.PawleyRefl = G2gd.GSGrid(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
+        Texture = wx.ScrolledWindow(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(Texture,'Texture')
     else:
-        DData = wx.ScrolledWindow(self.dataDisplay)
-        self.dataDisplay.AddPage(DData,'Data')
-        Texture = wx.ScrolledWindow(self.dataDisplay)
-        self.dataDisplay.AddPage(Texture,'Texture')
-        Atoms = G2gd.GSGrid(self.dataDisplay)
-        self.dataDisplay.AddPage(Atoms,'Atoms')
-        drawOptions = wx.Window(self.dataDisplay)
-        self.dataDisplay.AddPage(drawOptions,'Draw Options')
-        drawAtoms = G2gd.GSGrid(self.dataDisplay)
-        self.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
-
-    self.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)
-    self.dataDisplay.SetSelection(oldPage)
+        DData = wx.ScrolledWindow(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(DData,'Data')
+        Texture = wx.ScrolledWindow(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(Texture,'Texture')
+        Atoms = G2gd.GSGrid(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(Atoms,'Atoms')
+        drawOptions = wx.Window(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(drawOptions,'Draw Options')
+        drawAtoms = G2gd.GSGrid(G2frame.dataDisplay)
+        G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
+
+    G2frame.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)
+    G2frame.dataDisplay.SetSelection(oldPage)
     
             

trunk/GSASIIplot.py ¶

@@ -301 +301 @@
         Page.canvas.draw()
        
-def PlotPatterns(self,newPlot=False):
+def PlotPatterns(G2frame,newPlot=False):
     '''Powder pattern plotting package - displays single or multiple powder patterns as intensity vs
     2-theta or q (future TOF). Can display multiple patterns as "waterfall plots" or contour plots. Log I 
@@ -309 +309 @@
     
     def OnKeyBox(event):
-        if self.G2plotNB.nb.GetSelection() == self.G2plotNB.plotList.index('Powder Patterns'):
+        if G2frame.G2plotNB.nb.GetSelection() == G2frame.G2plotNB.plotList.index('Powder Patterns'):
             event.key = cb.GetValue()[0]
             cb.SetValue(' key press')
@@ -317 +317 @@
         newPlot = False
         if event.key == 'w':
-            if self.Weight:
-                self.Weight = False
+            if G2frame.Weight:
+                G2frame.Weight = False
             else:
-                self.Weight = True
-            print 'plot weighting:',self.Weight
+                G2frame.Weight = True
+            print 'plot weighting:',G2frame.Weight
         elif event.key == 'n':
-            if self.Contour:
+            if G2frame.Contour:
                 pass
             else:
-                if self.logPlot:
-                    self.logPlot = False
+                if G2frame.logPlot:
+                    G2frame.logPlot = False
                 else:
-                    self.Offset[0] = 0
-                    self.logPlot = True
+                    G2frame.Offset[0] = 0
+                    G2frame.logPlot = True
         elif event.key == 'u':
-            if self.Contour:
-                self.Cmax = min(1.0,self.Cmax*1.2)
-            elif self.logPlot:
+            if G2frame.Contour:
+                G2frame.Cmax = min(1.0,G2frame.Cmax*1.2)
+            elif G2frame.logPlot:
                 pass
-            elif self.Offset[0] < 100.:
-                self.Offset[0] += 1.
+            elif G2frame.Offset[0] < 100.:
+                G2frame.Offset[0] += 1.
         elif event.key == 'd':
-            if self.Contour:
-                self.Cmax = max(0.0,self.Cmax*0.8)
-            elif self.logPlot:
+            if G2frame.Contour:
+                G2frame.Cmax = max(0.0,G2frame.Cmax*0.8)
+            elif G2frame.logPlot:
                 pass
-            elif self.Offset[0] > 0.:
-                self.Offset[0] -= 1.
+            elif G2frame.Offset[0] > 0.:
+                G2frame.Offset[0] -= 1.
         elif event.key == 'l':
-            self.Offset[1] -= 1.
+            G2frame.Offset[1] -= 1.
         elif event.key == 'r':
-            self.Offset[1] += 1.
+            G2frame.Offset[1] += 1.
         elif event.key == 'o':
-            self.Offset = [0,0]
+            G2frame.Offset = [0,0]
         elif event.key == 'c':
             newPlot = True
-            if self.Contour:
-                self.Contour = False
+            if G2frame.Contour:
+                G2frame.Contour = False
             else:
-                self.Contour = True
-                self.SinglePlot = False
-                self.Offset = [0.,0.]
+                G2frame.Contour = True
+                G2frame.SinglePlot = False
+                G2frame.Offset = [0.,0.]
         elif event.key == 'q':
             newPlot = True
-            if self.qPlot:
-                self.qPlot = False
+            if G2frame.qPlot:
+                G2frame.qPlot = False
             else:
-                self.qPlot = True
+                G2frame.qPlot = True
         elif event.key == 's':
-            if self.Contour:
+            if G2frame.Contour:
                 choice = [m for m in mpl.cm.datad.keys() if not m.endswith("_r")]
                 choice.sort()
-                dlg = wx.SingleChoiceDialog(self,'Select','Color scheme',choice)
+                dlg = wx.SingleChoiceDialog(G2frame,'Select','Color scheme',choice)
                 if dlg.ShowModal() == wx.ID_OK:
                     sel = dlg.GetSelection()
-                    self.ContourColor = choice[sel]
+                    G2frame.ContourColor = choice[sel]
                 else:
-                    self.ContourColor = 'Paired'
+                    G2frame.ContourColor = 'Paired'
                 dlg.Destroy()
             else:                
-                if self.SinglePlot:
-                    self.SinglePlot = False
+                if G2frame.SinglePlot:
+                    G2frame.SinglePlot = False
                 else:
-                    self.SinglePlot = True
+                    G2frame.SinglePlot = True
         elif event.key == '+':
-            if self.PickId:
-                self.PickId = False
+            if G2frame.PickId:
+                G2frame.PickId = False
         elif event.key == 'i':                  #for smoothing contour plot
             choice = ['nearest','bilinear','bicubic','spline16','spline36','hanning',
                'hamming','hermite','kaiser','quadric','catrom','gaussian','bessel',
                'mitchell','sinc','lanczos']
-            dlg = wx.SingleChoiceDialog(self,'Select','Interpolation',choice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select','Interpolation',choice)
             if dlg.ShowModal() == wx.ID_OK:
                 sel = dlg.GetSelection()
-                self.Interpolate = choice[sel]
+                G2frame.Interpolate = choice[sel]
             else:
-                self.Interpolate = 'nearest'
+                G2frame.Interpolate = 'nearest'
             dlg.Destroy()
             
-        PlotPatterns(self,newPlot=newPlot)
+        PlotPatterns(G2frame,newPlot=newPlot)
         
     def OnMotion(event):
@@ -404 +404 @@
             Page.canvas.SetCursor(wx.CROSS_CURSOR)
             try:
-                Values,Names = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Instrument Parameters'))[1::2]
+                Values,Names = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[1::2]
                 Parms = dict(zip(Names,Values))
                 try:
@@ -410 +410 @@
                 except KeyError:
                     wave = Parms['Lam1']
-                if self.qPlot:
+                if G2frame.qPlot:
                     xpos = 2.0*asind(xpos*wave/(4*math.pi))
                 dsp = 0.0
                 if abs(xpos) > 0.:                  #avoid possible singularity at beam center
                     dsp = wave/(2.*sind(abs(xpos)/2.0))
-                if self.Contour:
-                    self.G2plotNB.status.SetStatusText('2-theta =%9.3f d =%9.5f pattern ID =%5d'%(xpos,dsp,int(ypos)),1)
+                if G2frame.Contour:
+                    G2frame.G2plotNB.status.SetStatusText('2-theta =%9.3f d =%9.5f pattern ID =%5d'%(xpos,dsp,int(ypos)),1)
                 else:
-                    self.G2plotNB.status.SetStatusText('2-theta =%9.3f d =%9.5f Intensity =%9.1f'%(xpos,dsp,ypos),1)
-                if self.itemPicked:
+                    G2frame.G2plotNB.status.SetStatusText('2-theta =%9.3f d =%9.5f Intensity =%9.1f'%(xpos,dsp,ypos),1)
+                if G2frame.itemPicked:
                     Page.canvas.SetToolTipString('%9.3f'%(xpos))
-                if self.PickId:
+                if G2frame.PickId:
                     found = []
-                    if self.PatternTree.GetItemText(self.PickId) in ['Index Peak List','Unit Cells List','Reflection Lists']:
+                    if G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Index Peak List','Unit Cells List','Reflection Lists']:
                         if len(HKL):
                             view = Page.toolbar._views.forward()[0][:2]
@@ -435 +435 @@
 
             except TypeError:
-                self.G2plotNB.status.SetStatusText('Select PWDR powder pattern first',1)
+                G2frame.G2plotNB.status.SetStatusText('Select PWDR powder pattern first',1)
                                                    
     def OnPick(event):
-        if self.itemPicked is not None: return
-        PatternId = self.PatternId
+        if G2frame.itemPicked is not None: return
+        PatternId = G2frame.PatternId
         try:
-            Values,Names = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Instrument Parameters'))[1::2]
+            Values,Names = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[1::2]
         except TypeError:
             return
@@ -449 +449 @@
         except KeyError:
             wave = Parms['Lam1']
-        PickId = self.PickId
+        PickId = G2frame.PickId
         pick = event.artist
         mouse = event.mouseevent       
@@ -456 +456 @@
         ind = event.ind
         xy = list(zip(np.take(xpos,ind),np.take(ypos,ind))[0])
-        if self.PatternTree.GetItemText(PickId) == 'Peak List':
+        if G2frame.PatternTree.GetItemText(PickId) == 'Peak List':
             if ind.all() != [0]:                                    #picked a data point
                 if 'C' in Parms['Type']:                            #CW data - TOF later in an elif
                     ins = [Parms[x] for x in ['U','V','W','X','Y']]
-                    if self.qPlot:                              #qplot - convert back to 2-theta
+                    if G2frame.qPlot:                              #qplot - convert back to 2-theta
                         xy[0] = 2.0*asind(xy[0]*wave/(4*math.pi))
                     sig = ins[0]*tand(xy[0]/2.0)**2+ins[1]*tand(xy[0]/2.0)+ins[2]
                     gam = ins[3]/cosd(xy[0]/2.0)+ins[4]*tand(xy[0]/2.0)           
-                    data = self.PatternTree.GetItemPyData(self.PickId)
+                    data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
                     XY = [xy[0],0, xy[1],1, sig,0, gam,0]       #default refine intensity 1st
                 data.append(XY)
-                G2pdG.UpdatePeakGrid(self,data)
-                PlotPatterns(self)
+                G2pdG.UpdatePeakGrid(G2frame,data)
+                PlotPatterns(G2frame)
             else:                                                   #picked a peak list line
-                self.itemPicked = pick
-        elif self.PatternTree.GetItemText(PickId) == 'Limits':
+                G2frame.itemPicked = pick
+        elif G2frame.PatternTree.GetItemText(PickId) == 'Limits':
             if ind.all() != [0]:                                    #picked a data point
-                LimitId = G2gd.GetPatternTreeItemId(self,PatternId, 'Limits')
-                data = self.PatternTree.GetItemPyData(LimitId)
+                LimitId = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits')
+                data = G2frame.PatternTree.GetItemPyData(LimitId)
                 if 'C' in Parms['Type']:                            #CW data - TOF later in an elif
-                    if self.qPlot:                              #qplot - convert back to 2-theta
+                    if G2frame.qPlot:                              #qplot - convert back to 2-theta
                         xy[0] = 2.0*asind(xy[0]*wave/(4*math.pi))
                 if mouse.button==1:
@@ -482 +482 @@
                 if mouse.button==3:
                     data[1][1] = max(xy[0],data[1][0])
-                self.PatternTree.SetItemPyData(LimitId,data)
-                G2pdG.UpdateLimitsGrid(self,data)
-                PlotPatterns(self)
+                G2frame.PatternTree.SetItemPyData(LimitId,data)
+                G2pdG.UpdateLimitsGrid(G2frame,data)
+                PlotPatterns(G2frame)
             else:                                                   #picked a limit line
-                self.itemPicked = pick
-        elif self.PatternTree.GetItemText(PickId) == 'Reflection Lists':
-            self.itemPicked = pick
+                G2frame.itemPicked = pick
+        elif G2frame.PatternTree.GetItemText(PickId) == 'Reflection Lists':
+            G2frame.itemPicked = pick
             pick = str(pick)
         
     def OnRelease(event):
-        if self.itemPicked is None: return
-        Values,Names = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Instrument Parameters'))[1::2]
+        if G2frame.itemPicked is None: return
+        Values,Names = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[1::2]
         Parms = dict(zip(Names,Values))
         try:
@@ -500 +500 @@
             wave = Parms['Lam1']
         xpos = event.xdata
-        PickId = self.PickId
-        if self.PatternTree.GetItemText(PickId) in ['Peak List','Limits'] and xpos:
+        PickId = G2frame.PickId
+        if G2frame.PatternTree.GetItemText(PickId) in ['Peak List','Limits'] and xpos:
             lines = []
-            for line in self.Lines: lines.append(line.get_xdata()[0])
-            lineNo = lines.index(self.itemPicked.get_xdata()[0])
+            for line in G2frame.Lines: lines.append(line.get_xdata()[0])
+            lineNo = lines.index(G2frame.itemPicked.get_xdata()[0])
             if  lineNo in [0,1]:
-                LimitId = G2gd.GetPatternTreeItemId(self,self.PatternId, 'Limits')
-                data = self.PatternTree.GetItemPyData(LimitId)
-                if self.qPlot:
+                LimitId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits')
+                data = G2frame.PatternTree.GetItemPyData(LimitId)
+                if G2frame.qPlot:
                     data[1][lineNo] = 2.0*asind(wave*xpos/(4*math.pi))
                 else:
                     data[1][lineNo] = xpos
-                self.PatternTree.SetItemPyData(LimitId,data)
-                if self.PatternTree.GetItemText(self.PickId) == 'Limits':
-                    G2pdG.UpdateLimitsGrid(self,data)
+                G2frame.PatternTree.SetItemPyData(LimitId,data)
+                if G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Limits':
+                    G2pdG.UpdateLimitsGrid(G2frame,data)
             else:
-                PeakId = G2gd.GetPatternTreeItemId(self,self.PatternId, 'Peak List')
-                data = self.PatternTree.GetItemPyData(PeakId)
+                PeakId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List')
+                data = G2frame.PatternTree.GetItemPyData(PeakId)
 #                print 'peaks',xpos
                 if event.button == 3:
                     del data[lineNo-2]
                 else:
-                    if self.qPlot:
+                    if G2frame.qPlot:
                         data[lineNo-2][0] = 2.0*asind(wave*xpos/(4*math.pi))
                     else:
                         data[lineNo-2][0] = xpos
-                self.PatternTree.SetItemPyData(PeakId,data)
-                G2pdG.UpdatePeakGrid(self,data)
-        elif self.PatternTree.GetItemText(PickId) == 'Reflection Lists' and xpos:
-            Phases = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId,'Reflection Lists'))
-            pick = str(self.itemPicked).split('(')[1].strip(')')
+                G2frame.PatternTree.SetItemPyData(PeakId,data)
+                G2pdG.UpdatePeakGrid(G2frame,data)
+        elif G2frame.PatternTree.GetItemText(PickId) == 'Reflection Lists' and xpos:
+            Phases = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
+            pick = str(G2frame.itemPicked).split('(')[1].strip(')')
             if 'Line' not in pick:       #avoid data points, etc.
                 num = Phases.keys().index(pick)
                 if num:
-                    self.refDelt = -(event.ydata-self.refOffset)/(num*Ymax)
+                    G2frame.refDelt = -(event.ydata-G2frame.refOffset)/(num*Ymax)
                 else:       #1st row of refl ticks
-                    self.refOffset = event.ydata
-        PlotPatterns(self)
-        self.itemPicked = None    
+                    G2frame.refOffset = event.ydata
+        PlotPatterns(G2frame)
+        G2frame.itemPicked = None    
 
     xylim = []
     try:
-        plotNum = self.G2plotNB.plotList.index('Powder Patterns')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('Powder Patterns')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         if not newPlot:
             Plot = Page.figure.gca()          #get previous powder plot & get limits
@@ -551 +551 @@
     except ValueError:
         newPlot = True
-        self.Cmax = 1.0
-        Plot = self.G2plotNB.addMpl('Powder Patterns').gca()
-        plotNum = self.G2plotNB.plotList.index('Powder Patterns')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        G2frame.Cmax = 1.0
+        Plot = G2frame.G2plotNB.addMpl('Powder Patterns').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('Powder Patterns')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('key_press_event', OnPlotKeyPress)
         Page.canvas.mpl_connect('motion_notify_event', OnMotion)
@@ -560 +560 @@
         Page.canvas.mpl_connect('button_release_event', OnRelease)
     Page.SetFocus()
-    self.G2plotNB.status.DestroyChildren()
-    if self.Contour:
+    G2frame.G2plotNB.status.DestroyChildren()
+    if G2frame.Contour:
         Choice = (' key press','d: lower contour max','u: raise contour max',
             'i: interpolation method','s: color scheme','c: contour off')
     else:
-        if self.logPlot:
+        if G2frame.logPlot:
             Choice = (' key press','n: log(I) off','l: offset left','r: offset right',
                 'c: contour on','q: toggle q plot','s: toggle single plot','+: no selection')
@@ -572 +572 @@
                 'u: offset up','o: reset offset','n: log(I) on','c: contour on',
                 'q: toggle q plot','s: toggle single plot','+: no selection')
-    cb = wx.ComboBox(self.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
+    cb = wx.ComboBox(G2frame.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
         choices=Choice)
     cb.Bind(wx.EVT_COMBOBOX, OnKeyBox)
     cb.SetValue(' key press')
     
-    PickId = self.PickId
-    PatternId = self.PatternId
+    PickId = G2frame.PickId
+    PatternId = G2frame.PatternId
     colors=['b','g','r','c','m','k']
     Lines = []
-    if self.SinglePlot:
-        Pattern = self.PatternTree.GetItemPyData(PatternId)
-        Pattern.append(self.PatternTree.GetItemText(PatternId))
+    if G2frame.SinglePlot:
+        Pattern = G2frame.PatternTree.GetItemPyData(PatternId)
+        Pattern.append(G2frame.PatternTree.GetItemText(PatternId))
         PlotList = [Pattern,]
-        ParmList = [self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,
-            self.PatternId, 'Instrument Parameters'))[1],]
+        ParmList = [G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
+            G2frame.PatternId, 'Instrument Parameters'))[1],]
     else:        
         PlotList = []
         ParmList = []
-        item, cookie = self.PatternTree.GetFirstChild(self.root)
+        item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
         while item:
-            if 'PWDR' in self.PatternTree.GetItemText(item):
-                Pattern = self.PatternTree.GetItemPyData(item)
+            if 'PWDR' in G2frame.PatternTree.GetItemText(item):
+                Pattern = G2frame.PatternTree.GetItemPyData(item)
                 if len(Pattern) < 3:                    # put name on end if needed
-                    Pattern.append(self.PatternTree.GetItemText(item))
+                    Pattern.append(G2frame.PatternTree.GetItemText(item))
                 PlotList.append(Pattern)
-                ParmList.append(self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,
+                ParmList.append(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
                     item,'Instrument Parameters'))[1])
-            item, cookie = self.PatternTree.GetNextChild(self.root, cookie)                
+            item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)                
     Ymax = 1.0
     lenX = 0
-    if self.PatternTree.GetItemText(PickId) in ['Reflection Lists']:
-        Phases = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId,'Reflection Lists'))
+    if G2frame.PatternTree.GetItemText(PickId) in ['Reflection Lists']:
+        Phases = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
         HKL = []
         if Phases:
-            for peak in Phases[self.RefList]:
+            for peak in Phases[G2frame.RefList]:
                 HKL.append(peak[:6])
             HKL = np.array(HKL)
     else:
-        HKL = np.array(self.HKL)
+        HKL = np.array(G2frame.HKL)
     for Pattern in PlotList:
         xye = Pattern[1]
         Ymax = max(Ymax,max(xye[1]))
-    offset = self.Offset[0]*Ymax/100.0
-    Title = 'Powder Patterns: '+os.path.split(self.GSASprojectfile)[1]
-    if self.logPlot:
+    offset = G2frame.Offset[0]*Ymax/100.0
+    Title = 'Powder Patterns: '+os.path.split(G2frame.GSASprojectfile)[1]
+    if G2frame.logPlot:
         Title = 'log('+Title+')'
     Plot.set_title(Title)
-    if self.qPlot:
+    if G2frame.qPlot:
         Plot.set_xlabel(r'$q, \AA^{-1}$',fontsize=14)
     else:        
         Plot.set_xlabel(r'$\mathsf{2\theta}$',fontsize=14)
     Plot.set_ylabel('Intensity',fontsize=12)
-    if self.Contour:
+    if G2frame.Contour:
         ContourZ = []
         ContourY = []
         Nseq = 0
     if len(PlotList) < 2:
-        self.Contour = False
+        G2frame.Contour = False
     for N,Pattern in enumerate(PlotList):
         Parms = ParmList[N]
@@ -636 +636 @@
         xye = np.array(Pattern[1])
         if PickId:
-            ifpicked = Pattern[2] == self.PatternTree.GetItemText(PatternId)
-            LimitId = G2gd.GetPatternTreeItemId(self,PatternId, 'Limits')
-        if self.qPlot:
-            Id = G2gd.GetPatternTreeItemId(self,self.root, Pattern[2])
+            ifpicked = Pattern[2] == G2frame.PatternTree.GetItemText(PatternId)
+            LimitId = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits')
+        if G2frame.qPlot:
+            Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, Pattern[2])
             X = 4*np.pi*npsind(xye[0]/2.0)/Parms[1]
         else:
@@ -647 +647 @@
         Y = xye[1]+offset*N
         if LimitId:
-            limits = np.array(self.PatternTree.GetItemPyData(LimitId))
-            if self.qPlot:
+            limits = np.array(G2frame.PatternTree.GetItemPyData(LimitId))
+            if G2frame.qPlot:
                 limits = 4*np.pi*npsind(limits/2.0)/Parms[1]
             Lines.append(Plot.axvline(limits[1][0],color='g',dashes=(5,5),picker=3.))    
             Lines.append(Plot.axvline(limits[1][1],color='r',dashes=(5,5),picker=3.))                    
-        if self.Contour:
+        if G2frame.Contour:
             
             if lenX == len(X):
@@ -661 +661 @@
                 Plot.set_ylabel('Data sequence',fontsize=12)
         else:
-            X += self.Offset[1]*.005*N
+            X += G2frame.Offset[1]*.005*N
             if ifpicked:
                 Z = xye[3]+offset*N
                 W = xye[4]+offset*N
-                D = xye[5]-Ymax*self.delOffset
-                if self.Weight:
+                D = xye[5]-Ymax*G2frame.delOffset
+                if G2frame.Weight:
                     W2 = np.sqrt(xye[2])
-                    D *= W2-Ymax*self.delOffset
-                if self.logPlot:
+                    D *= W2-Ymax*G2frame.delOffset
+                if G2frame.logPlot:
                     Plot.semilogy(X,Y,colors[N%6]+'+',picker=3.,clip_on=False,nonposy='mask')
                     Plot.semilogy(X,Z,colors[(N+1)%6],picker=False,nonposy='mask')
@@ -680 +680 @@
                     Plot.axhline(0.,color=wx.BLACK)
                 Page.canvas.SetToolTipString('')
-                if self.PatternTree.GetItemText(PickId) == 'Peak List':
+                if G2frame.PatternTree.GetItemText(PickId) == 'Peak List':
                     tip = 'On data point: Pick peak - L or R MB. On line: L-move, R-delete'
                     Page.canvas.SetToolTipString(tip)
-                    data = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Peak List'))
+                    data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
                     for item in data:
-                        if self.qPlot:
+                        if G2frame.qPlot:
                             Lines.append(Plot.axvline(4*math.pi*sind(item[0]/2.)/Parms[1],color=colors[N%6],picker=2.))
                         else:
                             Lines.append(Plot.axvline(item[0],color=colors[N%6],picker=2.))
-                if self.PatternTree.GetItemText(PickId) == 'Limits':
+                if G2frame.PatternTree.GetItemText(PickId) == 'Limits':
                     tip = 'On data point: Lower limit - L MB; Upper limit - R MB. On limit: MB down to move'
                     Page.canvas.SetToolTipString(tip)
-                    data = self.LimitsTable.GetData()
+                    data = G2frame.LimitsTable.GetData()
             else:
-                if self.logPlot:
+                if G2frame.logPlot:
                     Plot.semilogy(X,Y,colors[N%6],picker=False,nonposy='clip')
                 else:
                     Plot.plot(X,Y,colors[N%6],picker=False)
-    if PickId and not self.Contour:
-        Values,Names = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Instrument Parameters'))[1::2]
+    if PickId and not G2frame.Contour:
+        Values,Names = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))[1::2]
         Parms = dict(zip(Names,Values))
         try:
@@ -705 +705 @@
         except KeyError:
             wave = Parms['Lam1']
-        if self.PatternTree.GetItemText(PickId) in ['Index Peak List','Unit Cells List']:
-            peaks = np.array((self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Index Peak List'))))
+        if G2frame.PatternTree.GetItemText(PickId) in ['Index Peak List','Unit Cells List']:
+            peaks = np.array((G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))))
             for peak in peaks:
-                if self.qPlot:
+                if G2frame.qPlot:
                     Plot.axvline(4*np.pi*sind(peak[0]/2.0)/wave,color='b')
                 else:
                     Plot.axvline(peak[0],color='b')
-            for hkl in self.HKL:
-                if self.qPlot:
+            for hkl in G2frame.HKL:
+                if G2frame.qPlot:
                     Plot.axvline(4*np.pi*sind(hkl[5]/2.0)/wave,color='r',dashes=(5,5))
                 else:
                     Plot.axvline(hkl[5],color='r',dashes=(5,5))
-        elif self.PatternTree.GetItemText(PickId) in ['Reflection Lists']:
-            Phases = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId,'Reflection Lists'))
+        elif G2frame.PatternTree.GetItemText(PickId) in ['Reflection Lists']:
+            Phases = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
             for pId,phase in enumerate(Phases):
                 peaks = Phases[phase]
                 peak = np.array([[peak[4],peak[5]] for peak in peaks])
-                pos = self.refOffset-pId*Ymax*self.refDelt*np.ones_like(peak)
-                if self.qPlot:
+                pos = G2frame.refOffset-pId*Ymax*G2frame.refDelt*np.ones_like(peak)
+                if G2frame.qPlot:
                     Plot.plot(2*np.pi/peak.T[0],pos,colors[pId%6]+'|',mew=1,ms=8,picker=3.,label=phase)
                 else:
@@ -730 +730 @@
             Plot.legend(handles[::2],legends[::2],title='Phases',loc='best')    #skip every other one
             
-    if self.Contour:
-        acolor = mpl.cm.get_cmap(self.ContourColor)
-        Img = Plot.imshow(ContourZ,cmap=acolor,vmin=0,vmax=Ymax*self.Cmax,interpolation=self.Interpolate, 
+    if G2frame.Contour:
+        acolor = mpl.cm.get_cmap(G2frame.ContourColor)
+        Img = Plot.imshow(ContourZ,cmap=acolor,vmin=0,vmax=Ymax*G2frame.Cmax,interpolation=G2frame.Interpolate, 
             extent=[ContourX[0],ContourX[-1],ContourY[0],ContourY[-1]],aspect='auto',origin='lower')
         Page.figure.colorbar(Img)
     else:
-        self.Lines = Lines
+        G2frame.Lines = Lines
     if not newPlot:
         Page.toolbar.push_current()
@@ -746 +746 @@
     else:
         Page.canvas.draw()
-    self.Pwdr = True
+    G2frame.Pwdr = True
     
-def PlotISFG(self,newPlot=False,type=''):
+def PlotISFG(G2frame,newPlot=False,type=''):
     ''' PLotting package for PDF analysis; displays I(q), S(q), F(q) and G(r) as single 
     or multiple plots with waterfall and contour plots as options
     '''
     if not type:
-        type = self.G2plotNB.plotList[self.G2plotNB.nb.GetSelection()]
+        type = G2frame.G2plotNB.plotList[G2frame.G2plotNB.nb.GetSelection()]
     if type not in ['I(Q)','S(Q)','F(Q)','G(R)']:
         return
@@ -761 +761 @@
         newPlot = False
         if event.key == 'u':
-            if self.Contour:
-                self.Cmax = min(1.0,self.Cmax*1.2)
-            elif self.Offset[0] < 100.:
-                self.Offset[0] += 1.
+            if G2frame.Contour:
+                G2frame.Cmax = min(1.0,G2frame.Cmax*1.2)
+            elif G2frame.Offset[0] < 100.:
+                G2frame.Offset[0] += 1.
         elif event.key == 'd':
-            if self.Contour:
-                self.Cmax = max(0.0,self.Cmax*0.8)
-            elif self.Offset[0] > 0.:
-                self.Offset[0] -= 1.
+            if G2frame.Contour:
+                G2frame.Cmax = max(0.0,G2frame.Cmax*0.8)
+            elif G2frame.Offset[0] > 0.:
+                G2frame.Offset[0] -= 1.
         elif event.key == 'l':
-            self.Offset[1] -= 1.
+            G2frame.Offset[1] -= 1.
         elif event.key == 'r':
-            self.Offset[1] += 1.
+            G2frame.Offset[1] += 1.
         elif event.key == 'o':
-            self.Offset = [0,0]
+            G2frame.Offset = [0,0]
         elif event.key == 'c':
             newPlot = True
-            if self.Contour:
-                self.Contour = False
+            if G2frame.Contour:
+                G2frame.Contour = False
             else:
-                self.Contour = True
-                self.SinglePlot = False
-                self.Offset = [0.,0.]
+                G2frame.Contour = True
+                G2frame.SinglePlot = False
+                G2frame.Offset = [0.,0.]
         elif event.key == 's':
-            if self.Contour:
+            if G2frame.Contour:
                 choice = [m for m in mpl.cm.datad.keys() if not m.endswith("_r")]
                 choice.sort()
-                dlg = wx.SingleChoiceDialog(self,'Select','Color scheme',choice)
+                dlg = wx.SingleChoiceDialog(G2frame,'Select','Color scheme',choice)
                 if dlg.ShowModal() == wx.ID_OK:
                     sel = dlg.GetSelection()
-                    self.ContourColor = choice[sel]
+                    G2frame.ContourColor = choice[sel]
                 else:
-                    self.ContourColor = 'Paired'
+                    G2frame.ContourColor = 'Paired'
                 dlg.Destroy()
             else:                
-                if self.SinglePlot:
-                    self.SinglePlot = False
+                if G2frame.SinglePlot:
+                    G2frame.SinglePlot = False
                 else:
-                    self.SinglePlot = True
+                    G2frame.SinglePlot = True
         elif event.key == 'i':                  #for smoothing contour plot
             choice = ['nearest','bilinear','bicubic','spline16','spline36','hanning',
                'hamming','hermite','kaiser','quadric','catrom','gaussian','bessel',
                'mitchell','sinc','lanczos']
-            dlg = wx.SingleChoiceDialog(self,'Select','Interpolation',choice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select','Interpolation',choice)
             if dlg.ShowModal() == wx.ID_OK:
                 sel = dlg.GetSelection()
-                self.Interpolate = choice[sel]
+                G2frame.Interpolate = choice[sel]
             else:
-                self.Interpolate = 'nearest'
+                G2frame.Interpolate = 'nearest'
             dlg.Destroy()
-        elif event.key == 't' and not self.Contour:
-            if self.Legend:
-                self.Legend = False
+        elif event.key == 't' and not G2frame.Contour:
+            if G2frame.Legend:
+                G2frame.Legend = False
             else:
-                self.Legend = True
+                G2frame.Legend = True
             
             
-        PlotISFG(self,newPlot=newPlot,type=type)
+        PlotISFG(G2frame,newPlot=newPlot,type=type)
         
     def OnKeyBox(event):
-        if self.G2plotNB.nb.GetSelection() == self.G2plotNB.plotList.index(type):
+        if G2frame.G2plotNB.nb.GetSelection() == G2frame.G2plotNB.plotList.index(type):
             event.key = cb.GetValue()[0]
             cb.SetValue(' key press')
@@ -832 +832 @@
             Page.canvas.SetCursor(wx.CROSS_CURSOR)
             try:
-                if self.Contour:
-                    self.G2plotNB.status.SetStatusText('R =%.3fA pattern ID =%5d'%(xpos,int(ypos)),1)
+                if G2frame.Contour:
+                    G2frame.G2plotNB.status.SetStatusText('R =%.3fA pattern ID =%5d'%(xpos,int(ypos)),1)
                 else:
-                    self.G2plotNB.status.SetStatusText('R =%.3fA %s =%.2f'%(xpos,type,ypos),1)                   
+                    G2frame.G2plotNB.status.SetStatusText('R =%.3fA %s =%.2f'%(xpos,type,ypos),1)                   
             except TypeError:
-                self.G2plotNB.status.SetStatusText('Select '+type+' pattern first',1)
+                G2frame.G2plotNB.status.SetStatusText('Select '+type+' pattern first',1)
     
     xylim = []
     try:
-        plotNum = self.G2plotNB.plotList.index(type)
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index(type)
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         if not newPlot:
             Plot = Page.figure.gca()          #get previous plot & get limits
@@ -850 +850 @@
     except ValueError:
         newPlot = True
-        self.Cmax = 1.0
-        Plot = self.G2plotNB.addMpl(type).gca()
-        plotNum = self.G2plotNB.plotList.index(type)
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        G2frame.Cmax = 1.0
+        Plot = G2frame.G2plotNB.addMpl(type).gca()
+        plotNum = G2frame.G2plotNB.plotList.index(type)
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('key_press_event', OnPlotKeyPress)
         Page.canvas.mpl_connect('motion_notify_event', OnMotion)
     
     Page.SetFocus()
-    self.G2plotNB.status.DestroyChildren()
-    if self.Contour:
+    G2frame.G2plotNB.status.DestroyChildren()
+    if G2frame.Contour:
         Choice = (' key press','d: lower contour max','u: raise contour max',
             'i: interpolation method','s: color scheme','c: contour off')
@@ -865 +865 @@
         Choice = (' key press','l: offset left','r: offset right','d: offset down','u: offset up',
             'o: reset offset','t: toggle legend','c: contour on','s: toggle single plot')
-    cb = wx.ComboBox(self.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
+    cb = wx.ComboBox(G2frame.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
         choices=Choice)
     cb.Bind(wx.EVT_COMBOBOX, OnKeyBox)
     cb.SetValue(' key press')
-    PatternId = self.PatternId
-    PickId = self.PickId
+    PatternId = G2frame.PatternId
+    PickId = G2frame.PickId
     Plot.set_title(type)
     if type == 'G(R)':
@@ -878 +878 @@
     Plot.set_ylabel(r''+type,fontsize=14)
     colors=['b','g','r','c','m','k']
-    name = self.PatternTree.GetItemText(PatternId)[4:]
+    name = G2frame.PatternTree.GetItemText(PatternId)[4:]
     Pattern = []    
-    if self.SinglePlot:
-        name = self.PatternTree.GetItemText(PatternId)
+    if G2frame.SinglePlot:
+        name = G2frame.PatternTree.GetItemText(PatternId)
         name = type+name[4:]
-        Id = G2gd.GetPatternTreeItemId(self,PatternId,name)
-        Pattern = self.PatternTree.GetItemPyData(Id)
+        Id = G2gd.GetPatternTreeItemId(G2frame,PatternId,name)
+        Pattern = G2frame.PatternTree.GetItemPyData(Id)
         if Pattern:
             Pattern.append(name)
@@ -890 +890 @@
     else:
         PlotList = []
-        item, cookie = self.PatternTree.GetFirstChild(self.root)
+        item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
         while item:
-            if 'PDF' in self.PatternTree.GetItemText(item):
-                name = type+self.PatternTree.GetItemText(item)[4:]
-                Id = G2gd.GetPatternTreeItemId(self,item,name)
-                Pattern = self.PatternTree.GetItemPyData(Id)
+            if 'PDF' in G2frame.PatternTree.GetItemText(item):
+                name = type+G2frame.PatternTree.GetItemText(item)[4:]
+                Id = G2gd.GetPatternTreeItemId(G2frame,item,name)
+                Pattern = G2frame.PatternTree.GetItemPyData(Id)
                 if Pattern:
                     Pattern.append(name)
                     PlotList.append(Pattern)
-            item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
-    PDFdata = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'PDF Controls'))
+            item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
+    PDFdata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'PDF Controls'))
     numbDen = G2pwd.GetNumDensity(PDFdata['ElList'],PDFdata['Form Vol'])
     Xb = [0.,10.]
@@ -909 +909 @@
         xye = Pattern[1]
         Ymax = max(Ymax,max(xye[1]))
-    offset = self.Offset[0]*Ymax/100.0
-    if self.Contour:
+    offset = G2frame.Offset[0]*Ymax/100.0
+    if G2frame.Contour:
         ContourZ = []
         ContourY = []
@@ -917 +917 @@
         xye = Pattern[1]
         if PickId:
-            ifpicked = Pattern[2] == self.PatternTree.GetItemText(PatternId)
+            ifpicked = Pattern[2] == G2frame.PatternTree.GetItemText(PatternId)
         X = xye[0]
         if not lenX:
             lenX = len(X)           
         Y = xye[1]+offset*N
-        if self.Contour:
+        if G2frame.Contour:
             if lenX == len(X):
                 ContourY.append(N)
@@ -930 +930 @@
                 Plot.set_ylabel('Data sequence',fontsize=12)
         else:
-            X = xye[0]+self.Offset[1]*.005*N
+            X = xye[0]+G2frame.Offset[1]*.005*N
             if ifpicked:
                 Plot.plot(X,Y,colors[N%6]+'+',picker=3.,clip_on=False)
                 Page.canvas.SetToolTipString('')
             else:
-                if self.Legend:
+                if G2frame.Legend:
                     Plot.plot(X,Y,colors[N%6],picker=False,label='Azm:'+Pattern[2].split('=')[1])
                 else:
@@ -945 +945 @@
             elif type == 'S(Q)':
                 Plot.axhline(1.,color=wx.BLACK)
-    if self.Contour:
-        acolor = mpl.cm.get_cmap(self.ContourColor)
-        Img = Plot.imshow(ContourZ,cmap=acolor,vmin=0,vmax=Ymax*self.Cmax,interpolation=self.Interpolate, 
+    if G2frame.Contour:
+        acolor = mpl.cm.get_cmap(G2frame.ContourColor)
+        Img = Plot.imshow(ContourZ,cmap=acolor,vmin=0,vmax=Ymax*G2frame.Cmax,interpolation=G2frame.Interpolate, 
             extent=[ContourX[0],ContourX[-1],ContourY[0],ContourY[-1]],aspect='auto',origin='lower')
         Page.figure.colorbar(Img)
-    elif self.Legend:
+    elif G2frame.Legend:
         Plot.legend(loc='best')
     if not newPlot:
@@ -962 +962 @@
         Page.canvas.draw()
         
-def PlotXY(self,XY,newPlot=False,type=''):
+def PlotXY(G2frame,XY,newPlot=False,type=''):
     '''simple plot of xy data, used for diagnostic purposes
     '''
@@ -971 +971 @@
             Page.canvas.SetCursor(wx.CROSS_CURSOR)
             try:
-                self.G2plotNB.status.SetStatusText('X =%9.3f %s =%9.3f'%(xpos,type,ypos),1)                   
+                G2frame.G2plotNB.status.SetStatusText('X =%9.3f %s =%9.3f'%(xpos,type,ypos),1)                   
             except TypeError:
-                self.G2plotNB.status.SetStatusText('Select '+type+' pattern first',1)
+                G2frame.G2plotNB.status.SetStatusText('Select '+type+' pattern first',1)
 
     try:
-        plotNum = self.G2plotNB.plotList.index(type)
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index(type)
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         if not newPlot:
             Plot = Page.figure.gca()
@@ -985 +985 @@
     except ValueError:
         newPlot = True
-        Plot = self.G2plotNB.addMpl(type).gca()
-        plotNum = self.G2plotNB.plotList.index(type)
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl(type).gca()
+        plotNum = G2frame.G2plotNB.plotList.index(type)
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('motion_notify_event', OnMotion)
     
     Page.SetFocus()
-    self.G2plotNB.status.DestroyChildren()
+    G2frame.G2plotNB.status.DestroyChildren()
     Plot.set_title(type)
     Plot.set_xlabel(r'X',fontsize=14)
@@ -1011 +1011 @@
         Page.canvas.draw()
 
-def PlotPowderLines(self):
+def PlotPowderLines(G2frame):
     ''' plotting of powder lines (i.e. no powder pattern) as sticks
     '''
@@ -1020 +1020 @@
         if xpos:                                        #avoid out of frame mouse position
             Page.canvas.SetCursor(wx.CROSS_CURSOR)
-            self.G2plotNB.status.SetFields(['','2-theta =%9.3f '%(xpos,)])
-            if self.PickId and self.PatternTree.GetItemText(self.PickId) in ['Index Peak List','Unit Cells List']:
+            G2frame.G2plotNB.status.SetFields(['','2-theta =%9.3f '%(xpos,)])
+            if G2frame.PickId and G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Index Peak List','Unit Cells List']:
                 found = []
                 if len(HKL):
@@ -1034 +1034 @@
 
     try:
-        plotNum = self.G2plotNB.plotList.index('Powder Lines')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('Powder Lines')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.figure.clf()
         Plot = Page.figure.gca()
     except ValueError:
-        Plot = self.G2plotNB.addMpl('Powder Lines').gca()
-        plotNum = self.G2plotNB.plotList.index('Powder Lines')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl('Powder Lines').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('Powder Lines')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('motion_notify_event', OnMotion)
         
@@ -1047 +1047 @@
     Plot.set_title('Powder Pattern Lines')
     Plot.set_xlabel(r'$\mathsf{2\theta}$',fontsize=14)
-    PickId = self.PickId
-    PatternId = self.PatternId
-    peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Index Peak List'))
+    PickId = G2frame.PickId
+    PatternId = G2frame.PatternId
+    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
     for peak in peaks:
         Plot.axvline(peak[0],color='b')
-    HKL = np.array(self.HKL)
-    for hkl in self.HKL:
+    HKL = np.array(G2frame.HKL)
+    for hkl in G2frame.HKL:
         Plot.axvline(hkl[5],color='r',dashes=(5,5))
     xmin = peaks[0][0]
@@ -1063 +1063 @@
     Page.toolbar.push_current()
 
-def PlotPeakWidths(self):
+def PlotPeakWidths(G2frame):
     ''' Plotting of instrument broadening terms as function of 2-theta (future TOF)
     Seen when "Instrument Parameters" chosen from powder pattern data tree
     '''
-    PatternId = self.PatternId
-    limitID = G2gd.GetPatternTreeItemId(self,PatternId, 'Limits')
+    PatternId = G2frame.PatternId
+    limitID = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits')
     if limitID:
-        limits = self.PatternTree.GetItemPyData(limitID)
+        limits = G2frame.PatternTree.GetItemPyData(limitID)
     else:
         return
-    instParms = self.PatternTree.GetItemPyData( \
-        G2gd.GetPatternTreeItemId(self,PatternId, 'Instrument Parameters'))
+    instParms = G2frame.PatternTree.GetItemPyData( \
+        G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
     if instParms[0][0] in ['PXC','PNC']:
         lam = instParms[1][1]
@@ -1081 +1081 @@
         else:
             GU,GV,GW,LX,LY = instParms[0][4:9]
-    peakID = G2gd.GetPatternTreeItemId(self,PatternId, 'Peak List')
+    peakID = G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List')
     if peakID:
-        peaks = self.PatternTree.GetItemPyData(peakID)
+        peaks = G2frame.PatternTree.GetItemPyData(peakID)
     else:
         peaks = []
     
     try:
-        plotNum = self.G2plotNB.plotList.index('Peak Widths')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('Peak Widths')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.figure.clf()
         Plot = Page.figure.gca()
     except ValueError:
-        Plot = self.G2plotNB.addMpl('Peak Widths').gca()
-        plotNum = self.G2plotNB.plotList.index('Peak Widths')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl('Peak Widths').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('Peak Widths')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
     Page.SetFocus()
     
@@ -1153 +1153 @@
     Page.canvas.draw()
     
-def PlotSizeStrainPO(self,data,Start=False):
+def PlotSizeStrainPO(G2frame,data,Start=False):
     '''Plot 3D mustrain/size/preferred orientation figure. In this instance data is for a phase
     '''
     
-    PatternId = self.PatternId
+    PatternId = G2frame.PatternId
     generalData = data['General']
     SGData = generalData['SGData']
@@ -1173 +1173 @@
     plotDict = {'Mustrain':'Mustrain','Size':'Size','Preferred orientation':'Pref.Ori.'}
     for ptype in plotDict:
-        self.G2plotNB.Delete(ptype)        
+        G2frame.G2plotNB.Delete(ptype)        
 
     for item in useList:
@@ -1184 +1184 @@
 
     if plotType in ['Mustrain','Size']:
-        Plot = mp3d.Axes3D(self.G2plotNB.add3D(plotType))
+        Plot = mp3d.Axes3D(G2frame.G2plotNB.add3D(plotType))
     else:
-        Plot = self.G2plotNB.addMpl(plotType).gca()        
-    plotNum = self.G2plotNB.plotList.index(plotType)
-    Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl(plotType).gca()        
+    plotNum = G2frame.G2plotNB.plotList.index(plotType)
+    Page = G2frame.G2plotNB.nb.GetPage(plotNum)
     Page.SetFocus()
-    self.G2plotNB.status.SetStatusText('Adjust frame size to get desired aspect ratio',1)
+    G2frame.G2plotNB.status.SetStatusText('Adjust frame size to get desired aspect ratio',1)
     if not Page.IsShown():
         Page.Show()
@@ -1307 +1307 @@
     Page.canvas.draw()
     
-def PlotTexture(self,data,newPlot=False,Start=False):
+def PlotTexture(G2frame,data,newPlot=False,Start=False):
     '''Pole figure, inverse pole figure, 3D pole distribution and 3D inverse pole distribution
     plotting.
@@ -1315 +1315 @@
     shModels = ['cylindrical','none','shear - 2/m','rolling - mmm']
     SamSym = dict(zip(shModels,['0','-1','2/m','mmm']))
-    PatternId = self.PatternId
+    PatternId = G2frame.PatternId
     generalData = data['General']
     SGData = generalData['SGData']
     textureData = generalData['SH Texture']
-    self.G2plotNB.Delete('Texture')
+    G2frame.G2plotNB.Delete('Texture')
     if not textureData['Order']:
         return                  #no plot!!
@@ -1341 +1341 @@
                 r = xpos**2+ypos**2
                 if r <= 1.0:
-                    if 'equal' in self.Projection: 
+                    if 'equal' in G2frame.Projection: 
                         r,p = 2.*npasind(np.sqrt(r)*sq2),npatan2d(ypos,xpos)
                     else:
@@ -1349 +1349 @@
                     y,x,z = list(xyz/np.max(np.abs(xyz)))
                     
-                    self.G2plotNB.status.SetFields(['',
+                    G2frame.G2plotNB.status.SetFields(['',
                         'psi =%9.3f, beta =%9.3f, MRD =%9.3f hkl=%5.2f,%5.2f,%5.2f'%(r,p,ipf,x,y,z)])
                                     
@@ -1359 +1359 @@
                 if z <= 1.0:
                     z = np.sqrt(z)
-                    if 'equal' in self.Projection: 
+                    if 'equal' in G2frame.Projection: 
                         r,p = 2.*npasind(z*sq2),npatan2d(ypos,xpos)
                     else:
                         r,p = 2.*npatand(z),npatan2d(ypos,xpos)
                     pf = G2lat.polfcal(ODFln,SamSym[textureData['Model']],np.array([r,]),np.array([p,]))
-                    self.G2plotNB.status.SetFields(['','phi =%9.3f, gam =%9.3f, MRD =%9.3f'%(r,p,pf)])
+                    G2frame.G2plotNB.status.SetFields(['','phi =%9.3f, gam =%9.3f, MRD =%9.3f'%(r,p,pf)])
     
-    if self.Projection == '3D display' and 'Axial'  not in SHData['PlotType']:               
-        Plot = mp3d.Axes3D(self.G2plotNB.add3D('Texture'))
+    if G2frame.Projection == '3D display' and 'Axial'  not in SHData['PlotType']:               
+        Plot = mp3d.Axes3D(G2frame.G2plotNB.add3D('Texture'))
     else:
-        Plot = self.G2plotNB.addMpl('Texture').gca()
-    plotNum = self.G2plotNB.plotList.index('Texture')
-    Page = self.G2plotNB.nb.GetPage(plotNum)
-    if self.Projection == '3D display':
+        Plot = G2frame.G2plotNB.addMpl('Texture').gca()
+    plotNum = G2frame.G2plotNB.plotList.index('Texture')
+    Page = G2frame.G2plotNB.nb.GetPage(plotNum)
+    if G2frame.Projection == '3D display':
         pass
     else:
@@ -1378 +1378 @@
 
     Page.SetFocus()
-    self.G2plotNB.status.SetFields(['',''])    
+    G2frame.G2plotNB.status.SetFields(['',''])    
     PH = np.array(SHData['PFhkl'])
     phi,beta = G2lat.CrsAng(PH,cell,SGData)
@@ -1402 +1402 @@
             X,Y = np.meshgrid(np.linspace(1.,-1.,npts),np.linspace(-1.,1.,npts))
             R,P = np.sqrt(X**2+Y**2).flatten(),npatan2d(X,Y).flatten()
-            if 'equal' in self.Projection:
+            if 'equal' in G2frame.Projection:
                 R = np.where(R <= 1.,2.*npasind(R*sq2),0.0)
             else:
@@ -1412 +1412 @@
             Plot.clabel(CS,fontsize=9,inline=1)
             try:
-                Img = Plot.imshow(Z.T,aspect='equal',cmap=self.ContourColor,extent=[-1,1,-1,1])
+                Img = Plot.imshow(Z.T,aspect='equal',cmap=G2frame.ContourColor,extent=[-1,1,-1,1])
             except ValueError:
                 pass
@@ -1419 +1419 @@
                 newPlot = False
             Plot.set_title('Inverse pole figure for XYZ='+str(SHData['PFxyz']))
-            Plot.set_xlabel(self.Projection.capitalize()+' projection')
+            Plot.set_xlabel(G2frame.Projection.capitalize()+' projection')
                         
         else:
             X,Y = np.meshgrid(np.linspace(1.,-1.,npts),np.linspace(-1.,1.,npts))
             R,P = np.sqrt(X**2+Y**2).flatten(),npatan2d(X,Y).flatten()
-            if 'equal' in self.Projection:
+            if 'equal' in G2frame.Projection:
                 R = np.where(R <= 1.,2.*npasind(R*sq2),0.0)
             else:
@@ -1436 +1436 @@
             except ValueError:
                 pass
-            Img = Plot.imshow(Z.T,aspect='equal',cmap=self.ContourColor,extent=[-1,1,-1,1])
+            Img = Plot.imshow(Z.T,aspect='equal',cmap=G2frame.ContourColor,extent=[-1,1,-1,1])
             if newPlot:
 #                Page.figure.colorbar(Img)    #colorbar fails - crashes gsasii
                 newPlot = False
             Plot.set_title('Pole figure for HKL='+str(SHData['PFhkl']))
-            Plot.set_xlabel(self.Projection.capitalize()+' projection')
+            Plot.set_xlabel(G2frame.Projection.capitalize()+' projection')
     Page.canvas.draw()
 
-def PlotCovariance(self,Data={}):
+def PlotCovariance(G2frame,Data={}):
     if not Data:
-        Data = self.PatternTree.GetItemPyData(
-            G2gd.GetPatternTreeItemId(self,self.root, 'Covariance'))
+        Data = G2frame.PatternTree.GetItemPyData(
+            G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
     if not Data:
         print 'No covariance matrix available'
@@ -1466 +1466 @@
             choice = [m for m in mpl.cm.datad.keys() if not m.endswith("_r")]
             choice.sort()
-            dlg = wx.SingleChoiceDialog(self,'Select','Color scheme',choice)
+            dlg = wx.SingleChoiceDialog(G2frame,'Select','Color scheme',choice)
             if dlg.ShowModal() == wx.ID_OK:
                 sel = dlg.GetSelection()
-                self.VcovColor = choice[sel]
+                G2frame.VcovColor = choice[sel]
             else:
-                self.VcovColor = 'RdYlGn'
+                G2frame.VcovColor = 'RdYlGn'
             dlg.Destroy()
-        PlotCovariance(self)
+        PlotCovariance(G2frame)
 
     def OnMotion(event):
@@ -1495 +1495 @@
                     msg = '%s - %s: %5.3f'%(varyList[xpos],varyList[ypos],covArray[xpos][ypos])
                 Page.canvas.SetToolTipString(msg)
-                self.G2plotNB.status.SetFields(['Key: s to change colors',msg])
+                G2frame.G2plotNB.status.SetFields(['Key: s to change colors',msg])
     try:
-        plotNum = self.G2plotNB.plotList.index('Covariance')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('Covariance')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.figure.clf()
         Plot = Page.figure.gca()
@@ -1504 +1504 @@
             Page.Show()
     except ValueError:
-        Plot = self.G2plotNB.addMpl('Covariance').gca()
-        plotNum = self.G2plotNB.plotList.index('Covariance')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl('Covariance').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('Covariance')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('motion_notify_event', OnMotion)
         Page.canvas.mpl_connect('key_press_event', OnPlotKeyPress)
 
     Page.SetFocus()
-    self.G2plotNB.status.SetFields(['',''])    
-    acolor = mpl.cm.get_cmap(self.VcovColor)
+    G2frame.G2plotNB.status.SetFields(['',''])    
+    acolor = mpl.cm.get_cmap(G2frame.VcovColor)
     Img = Plot.imshow(covArray,aspect='equal',cmap=acolor,interpolation='nearest',origin='lower')
     imgAx = Img.get_axes()
@@ -1524 +1524 @@
     Page.canvas.draw()
     
-def PlotSeq(self,SeqData,SeqSig,SeqNames,sampleParm):
+def PlotSeq(G2frame,SeqData,SeqSig,SeqNames,sampleParm):
     
     def OnKeyPress(event):
         if event.key == 's' and sampleParm:
-            if self.xAxis:
-                self.xAxis = False
+            if G2frame.xAxis:
+                G2frame.xAxis = False
             else:
-                self.xAxis = True
+                G2frame.xAxis = True
             Draw(False)
     try:
-        plotNum = self.G2plotNB.plotList.index('Sequential refinement')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('Sequential refinement')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.figure.clf()
         Plot = Page.figure.gca()
@@ -1541 +1541 @@
             Page.Show()
     except ValueError:
-        Plot = self.G2plotNB.addMpl('Sequential refinement').gca()
-        plotNum = self.G2plotNB.plotList.index('Sequential refinement')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl('Sequential refinement').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('Sequential refinement')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('key_press_event', OnKeyPress)
-        self.xAxis = False
+        G2frame.xAxis = False
         
     def Draw(newPlot):
         Page.SetFocus()
-        self.G2plotNB.status.SetFields(['','press s to toggle x-axis = sample environment parameter'])
+        G2frame.G2plotNB.status.SetFields(['','press s to toggle x-axis = sample environment parameter'])
         if len(SeqData):
             Plot.clear()
-            if self.xAxis:    
+            if G2frame.xAxis:    
                 xName = sampleParm.keys()[0]
                 X = sampleParm[xName]
@@ -1566 +1566 @@
     Draw(True)
             
-def PlotExposedImage(self,newPlot=False,event=None):
+def PlotExposedImage(G2frame,newPlot=False,event=None):
     '''General access module for 2D image plotting
     '''
-    plotNo = self.G2plotNB.nb.GetSelection()
-    if self.G2plotNB.nb.GetPageText(plotNo) == '2D Powder Image':
-        PlotImage(self,newPlot,event,newImage=True)
-    elif self.G2plotNB.nb.GetPageText(plotNo) == '2D Integration':
-        PlotIntegration(self,newPlot,event)
+    plotNo = G2frame.G2plotNB.nb.GetSelection()
+    if G2frame.G2plotNB.nb.GetPageText(plotNo) == '2D Powder Image':
+        PlotImage(G2frame,newPlot,event,newImage=True)
+    elif G2frame.G2plotNB.nb.GetPageText(plotNo) == '2D Integration':
+        PlotIntegration(G2frame,newPlot,event)
 
-def PlotImage(self,newPlot=False,event=None,newImage=True):
+def PlotImage(G2frame,newPlot=False,event=None,newImage=True):
     '''Plot of 2D detector images as contoured plot. Also plot calibration ellipses,
     masks, etc.
@@ -1584 +1584 @@
     global Data,Masks
     colors=['b','g','r','c','m','k']
-    Data = self.PatternTree.GetItemPyData(
-        G2gd.GetPatternTreeItemId(self,self.Image, 'Image Controls'))
-    Masks = self.PatternTree.GetItemPyData(
-        G2gd.GetPatternTreeItemId(self,self.Image, 'Masks'))
+    Data = G2frame.PatternTree.GetItemPyData(
+        G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
+    Masks = G2frame.PatternTree.GetItemPyData(
+        G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
 
     def OnImMotion(event):
@@ -1594 +1594 @@
         if event.xdata and event.ydata:                 #avoid out of frame errors
             Page.canvas.SetCursor(wx.CROSS_CURSOR)
-            item = self.itemPicked
+            item = G2frame.itemPicked
             pixelSize = Data['pixelSize']
             scalex = 1000./pixelSize[0]
             scaley = 1000./pixelSize[1]
-            if item and self.PatternTree.GetItemText(self.PickId) == 'Image Controls':
+            if item and G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Image Controls':
                 if 'Text' in str(item):
                     Page.canvas.SetToolTipString('%8.3f %8.3fmm'%(event.xdata,event.ydata))
@@ -1617 +1617 @@
                 Int = 0
                 if (0 <= xpix <= sizexy[0]) and (0 <= ypix <= sizexy[1]):
-                    Int = self.ImageZ[ypix][xpix]
+                    Int = G2frame.ImageZ[ypix][xpix]
                 tth,azm,dsp = G2img.GetTthAzmDsp(xpos,ypos,Data)
                 Q = 2.*math.pi/dsp
-                if self.setPoly:
-                    self.G2plotNB.status.SetFields(['','Polygon mask pick - LB next point, RB close polygon'])
+                if G2frame.setPoly:
+                    G2frame.G2plotNB.status.SetFields(['','Polygon mask pick - LB next point, RB close polygon'])
                 else:
-                    self.G2plotNB.status.SetFields(\
+                    G2frame.G2plotNB.status.SetFields(\
                         ['','Detector 2-th =%9.3fdeg, dsp =%9.3fA, Q = %6.5fA-1, azm = %7.2fdeg, I = %6d'%(tth,dsp,Q,azm,Int)])
 
     def OnImPlotKeyPress(event):
         try:
-            PickName = self.PatternTree.GetItemText(self.PickId)
+            PickName = G2frame.PatternTree.GetItemText(G2frame.PickId)
         except TypeError:
             return
@@ -1646 +1646 @@
                 Masks['Arcs'].append([tth,[azm-5,azm+5],0.1])
             elif event.key == 'p':
-                self.setPoly = True
+                G2frame.setPoly = True
                 Masks['Polygons'].append([])
-                self.G2plotNB.status.SetFields(['','Polygon mask active - LB pick next point, RB close polygon'])
-            G2imG.UpdateMasks(self,Masks)
+                G2frame.G2plotNB.status.SetFields(['','Polygon mask active - LB pick next point, RB close polygon'])
+            G2imG.UpdateMasks(G2frame,Masks)
         elif PickName == 'Image Controls':
             if event.key == 'c':
@@ -1656 +1656 @@
                     return
                 Ypos = event.ydata
-                dlg = wx.MessageDialog(self,'Are you sure you want to change the center?',
+                dlg = wx.MessageDialog(G2frame,'Are you sure you want to change the center?',
                     'Center change',style=wx.OK|wx.CANCEL)
                 try:
@@ -1662 +1662 @@
                         print 'move center to: ',Xpos,Ypos
                         Data['center'] = [Xpos,Ypos]
-                        G2imG.UpdateImageControls(self,Data,Masks)
+                        G2imG.UpdateImageControls(G2frame,Data,Masks)
                 finally:
                     dlg.Destroy()
             elif event.key == 'l':
-                if self.logPlot:
-                    self.logPlot = False
+                if G2frame.logPlot:
+                    G2frame.logPlot = False
                 else:
-                    self.logPlot = True
-        PlotImage(self,newImage=True)
+                    G2frame.logPlot = True
+        PlotImage(G2frame,newImage=True)
             
     def OnKeyBox(event):
-        if self.G2plotNB.nb.GetSelection() == self.G2plotNB.plotList.index('2D Powder Image'):
+        if G2frame.G2plotNB.nb.GetSelection() == G2frame.G2plotNB.plotList.index('2D Powder Image'):
             event.key = cb.GetValue()[0]
             cb.SetValue(' key press')
@@ -1680 +1680 @@
                         
     def OnImPick(event):
-        if self.PatternTree.GetItemText(self.PickId) not in ['Image Controls','Masks']:
+        if G2frame.PatternTree.GetItemText(G2frame.PickId) not in ['Image Controls','Masks']:
             return
-        if self.setPoly:
+        if G2frame.setPoly:
             polygon = Masks['Polygons'][-1]
             xpos,ypos = event.mouseevent.xdata,event.mouseevent.ydata
@@ -1689 +1689 @@
                     x0,y0 = polygon[0]
                     polygon.append([x0,y0])
-                    self.setPoly = False
-                    self.G2plotNB.status.SetFields(['','Polygon closed - RB drag a vertex to change shape'])
+                    G2frame.setPoly = False
+                    G2frame.G2plotNB.status.SetFields(['','Polygon closed - RB drag a vertex to change shape'])
                 else:
-                    self.G2plotNB.status.SetFields(['','New polygon point: %.1f,%.1f'%(xpos,ypos)])
+                    G2frame.G2plotNB.status.SetFields(['','New polygon point: %.1f,%.1f'%(xpos,ypos)])
                     polygon.append([xpos,ypos])
-                G2imG.UpdateMasks(self,Masks)
+                G2imG.UpdateMasks(G2frame,Masks)
         else:
-            if self.itemPicked is not None: return
-            self.itemPicked = event.artist
-            self.mousePicked = event.mouseevent
+            if G2frame.itemPicked is not None: return
+            G2frame.itemPicked = event.artist
+            G2frame.mousePicked = event.mouseevent
         
     def OnImRelease(event):
         try:
-            PickName = self.PatternTree.GetItemText(self.PickId)
+            PickName = G2frame.PatternTree.GetItemText(G2frame.PickId)
         except TypeError:
             return
@@ -1711 +1711 @@
         scaley = 1000./pixelSize[1]
         pixLimit = Data['pixLimit']
-        if self.itemPicked is None and PickName == 'Image Controls':
+        if G2frame.itemPicked is None and PickName == 'Image Controls':
 #            sizexy = Data['size']
             Xpos = event.xdata
-            if not (Xpos and self.ifGetRing):                   #got point out of frame
+            if not (Xpos and G2frame.ifGetRing):                   #got point out of frame
                 return
             Ypos = event.ydata
@@ -1721 +1721 @@
                     Xpix = Xpos*scalex
                     Ypix = Ypos*scaley
-                    xpos,ypos,I,J = G2img.ImageLocalMax(self.ImageZ,pixLimit,Xpix,Ypix)
+                    xpos,ypos,I,J = G2img.ImageLocalMax(G2frame.ImageZ,pixLimit,Xpix,Ypix)
                     if I and J:
                         xpos += .5                              #shift to pixel center
@@ -1729 +1729 @@
                         Data['ring'].append([xpos,ypos])
                 elif event.button == 3:
-                    self.dataFrame.GetStatusBar().SetStatusText('Calibrating...')
-                    if G2img.ImageCalibrate(self,Data):
-                        self.dataFrame.GetStatusBar().SetStatusText('Calibration successful - Show ring picks to check')
+                    G2frame.dataFrame.GetStatusBar().SetStatusText('Calibrating...')
+                    if G2img.ImageCalibrate(G2frame,Data):
+                        G2frame.dataFrame.GetStatusBar().SetStatusText('Calibration successful - Show ring picks to check')
                         print 'Calibration successful'
                     else:
-                        self.dataFrame.GetStatusBar().SetStatusText('Calibration failed - Show ring picks to diagnose')
+                        G2frame.dataFrame.GetStatusBar().SetStatusText('Calibration failed - Show ring picks to diagnose')
                         print 'Calibration failed'
-                    self.ifGetRing = False
-                    G2imG.UpdateImageControls(self,Data,Masks)
+                    G2frame.ifGetRing = False
+                    G2imG.UpdateImageControls(G2frame,Data,Masks)
                     return
-                PlotImage(self,newImage=False)
+                PlotImage(G2frame,newImage=False)
             return
         else:
@@ -1745 +1745 @@
             if xpos:                                        #avoid out of frame mouse position
                 ypos = event.ydata
-                if self.ifGetRing:                          #delete a calibration ring pick
+                if G2frame.ifGetRing:                          #delete a calibration ring pick
                     xypos = [xpos,ypos]
                     rings = Data['ring']
@@ -1753 +1753 @@
                 else:
                     tth,azm,dsp = G2img.GetTthAzmDsp(xpos,ypos,Data)
-                    itemPicked = str(self.itemPicked)
+                    itemPicked = str(G2frame.itemPicked)
                     if 'Line2D' in itemPicked and PickName == 'Image Controls':
                         if 'line1' in itemPicked:
@@ -1777 +1777 @@
                             Data['IOtth'][0],Data['IOtth'][1] = Data['IOtth'][1],Data['IOtth'][0]
                             
-                        self.InnerTth.SetValue("%8.2f" % (Data['IOtth'][0]))
-                        self.OuterTth.SetValue("%8.2f" % (Data['IOtth'][1]))
-                        self.Lazim.SetValue("%6d" % (Data['LRazimuth'][0]))
-                        self.Razim.SetValue("%6d" % (Data['LRazimuth'][1]))
+                        G2frame.InnerTth.SetValue("%8.2f" % (Data['IOtth'][0]))
+                        G2frame.OuterTth.SetValue("%8.2f" % (Data['IOtth'][1]))
+                        G2frame.Lazim.SetValue("%6d" % (Data['LRazimuth'][0]))
+                        G2frame.Razim.SetValue("%6d" % (Data['LRazimuth'][1]))
                     elif 'Circle' in itemPicked and PickName == 'Masks':
                         spots = Masks['Points']
@@ -1788 +1788 @@
                             if np.allclose(np.array([spot[:2]]),newPos):
                                 spot[:2] = xpos,ypos
-                        G2imG.UpdateMasks(self,Masks)
+                        G2imG.UpdateMasks(G2frame,Masks)
                     elif 'Line2D' in itemPicked and PickName == 'Masks':
-                        Obj = self.itemPicked.findobj()
+                        Obj = G2frame.itemPicked.findobj()
                         rings = Masks['Rings']
                         arcs = Masks['Arcs']
                         polygons = Masks['Polygons']
-                        for ring in self.ringList:
+                        for ring in G2frame.ringList:
                             if Obj == ring[0]:
                                 rN = ring[1]
@@ -1801 +1801 @@
                                 else:
                                     rings[rN][0] = G2img.GetTth(xpos,ypos,Data)+rings[rN][1]/2.
-                        for arc in self.arcList:
+                        for arc in G2frame.arcList:
                             if Obj == arc[0]:
                                 aN = arc[1]
@@ -1812 +1812 @@
                                 else:
                                     arcs[aN][1][1] = int(G2img.GetAzm(xpos,ypos,Data))
-                        for poly in self.polyList:
+                        for poly in G2frame.polyList:
                             if Obj == poly[0]:
-                                ind = self.itemPicked.contains(self.mousePicked)[1]['ind'][0]
-                                oldPos = np.array([self.mousePicked.xdata,self.mousePicked.ydata])
+                                ind = G2frame.itemPicked.contains(G2frame.mousePicked)[1]['ind'][0]
+                                oldPos = np.array([G2frame.mousePicked.xdata,G2frame.mousePicked.ydata])
                                 pN = poly[1]
                                 for i,xy in enumerate(polygons[pN]):
                                     if np.allclose(np.array([xy]),oldPos,atol=1.0):
                                         polygons[pN][i] = xpos,ypos
-                        G2imG.UpdateMasks(self,Masks)
+                        G2imG.UpdateMasks(G2frame,Masks)
 #                    else:                  #keep for future debugging
-#                        print str(self.itemPicked),event.xdata,event.ydata,event.button
-                PlotImage(self,newImage=True)
-            self.itemPicked = None
+#                        print str(G2frame.itemPicked),event.xdata,event.ydata,event.button
+                PlotImage(G2frame,newImage=True)
+            G2frame.itemPicked = None
             
     try:
-        plotNum = self.G2plotNB.plotList.index('2D Powder Image')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('2D Powder Image')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         if not newPlot:
             Plot = Page.figure.gca()          #get previous powder plot & get limits
@@ -1837 +1837 @@
         
     except ValueError:
-        Plot = self.G2plotNB.addMpl('2D Powder Image').gca()
-        plotNum = self.G2plotNB.plotList.index('2D Powder Image')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl('2D Powder Image').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('2D Powder Image')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('key_press_event', OnImPlotKeyPress)
         Page.canvas.mpl_connect('motion_notify_event', OnImMotion)
@@ -1847 +1847 @@
     if not event:                       #event from GUI TextCtrl - don't want focus to change to plot!!!
         Page.SetFocus()
-    Title = self.PatternTree.GetItemText(self.Image)[4:]
-    self.G2plotNB.status.DestroyChildren()
-    if self.logPlot:
+    Title = G2frame.PatternTree.GetItemText(G2frame.Image)[4:]
+    G2frame.G2plotNB.status.DestroyChildren()
+    if G2frame.logPlot:
         Title = 'log('+Title+')'
     Plot.set_title(Title)
     try:
-        if self.PatternTree.GetItemText(self.PickId) in ['Image Controls',]:
+        if G2frame.PatternTree.GetItemText(G2frame.PickId) in ['Image Controls',]:
             Choice = (' key press','l: log(I) on',)
-            if self.logPlot:
+            if G2frame.logPlot:
                 Choice[1] = 'l: log(I) off'
-            cb = wx.ComboBox(self.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
+            cb = wx.ComboBox(G2frame.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
                 choices=Choice)
             cb.Bind(wx.EVT_COMBOBOX, OnKeyBox)
@@ -1863 +1863 @@
     except TypeError:
         pass
-    size,imagefile = self.PatternTree.GetItemPyData(self.Image)
-    if imagefile != self.oldImagefile:
-        imagefile = G2IO.CheckImageFile(self,imagefile)
+    size,imagefile = G2frame.PatternTree.GetItemPyData(G2frame.Image)
+    if imagefile != G2frame.oldImagefile:
+        imagefile = G2IO.CheckImageFile(G2frame,imagefile)
         if not imagefile:
-            self.G2plotNB.Delete('2D Powder Image')
+            G2frame.G2plotNB.Delete('2D Powder Image')
             return
-        self.PatternTree.SetItemPyData(self.Image,[size,imagefile])
-        self.ImageZ = G2IO.GetImageData(self,imagefile,imageOnly=True)
-#        print self.ImageZ.shape,self.ImageZ.size,Data['size'] #might be useful debugging line
-        self.oldImagefile = imagefile
+        G2frame.PatternTree.SetItemPyData(G2frame.Image,[size,imagefile])
+        G2frame.ImageZ = G2IO.GetImageData(G2frame,imagefile,imageOnly=True)
+#        print G2frame.ImageZ.shape,G2frame.ImageZ.size,Data['size'] #might be useful debugging line
+        G2frame.oldImagefile = imagefile
 
     imScale = 1
-    if len(self.ImageZ) > 1024:
-        imScale = len(self.ImageZ)/1024
+    if len(G2frame.ImageZ) > 1024:
+        imScale = len(G2frame.ImageZ)/1024
     sizexy = Data['size']
     pixelSize = Data['pixelSize']
@@ -1896 +1896 @@
             
         if newImage:                    
-            MA = ma.masked_greater(ma.masked_less(self.ImageZ,Zlim[0]),Zlim[1])
+            MA = ma.masked_greater(ma.masked_less(G2frame.ImageZ,Zlim[0]),Zlim[1])
             MaskA = ma.getmaskarray(MA)
             A = G2img.ImageCompress(MA,imScale)
             AM = G2img.ImageCompress(MaskA,imScale)
-            if self.logPlot:
+            if G2frame.logPlot:
                 A = np.where(A>0,np.log(A),0)
                 AM = np.where(AM>0,np.log(AM),0)
@@ -1908 +1908 @@
             Img = Plot.imshow(A,aspect='equal',cmap=acolor,
                 interpolation='nearest',vmin=Imin,vmax=Imax,extent=[0,Xmax,Ymax,0])
-            if self.setPoly:
+            if G2frame.setPoly:
                 Img.set_picker(True)
     
@@ -1966 +1966 @@
         for x,y,d in spots:
             Plot.add_artist(Circle((x,y),radius=d/2,fc='none',ec='r',picker=3))
-        self.ringList = []
+        G2frame.ringList = []
         for iring,(tth,thick) in enumerate(rings):
             wave = Data['wavelength']
             x1,y1 = np.hsplit(np.array(G2img.makeIdealRing(G2img.GetEllipse(Dsp(tth+thick/2.,wave),Data))),2)
             x2,y2 = np.hsplit(np.array(G2img.makeIdealRing(G2img.GetEllipse(Dsp(tth-thick/2.,wave),Data))),2)
-            self.ringList.append([Plot.plot(x1,y1,'r',picker=3),iring,'o'])            
-            self.ringList.append([Plot.plot(x2,y2,'r',picker=3),iring,'i'])
-        self.arcList = []
+            G2frame.ringList.append([Plot.plot(x1,y1,'r',picker=3),iring,'o'])            
+            G2frame.ringList.append([Plot.plot(x2,y2,'r',picker=3),iring,'i'])
+        G2frame.arcList = []
         for iarc,(tth,azm,thick) in enumerate(arcs):            
             wave = Data['wavelength']
             x1,y1 = np.hsplit(np.array(G2img.makeIdealRing(G2img.GetEllipse(Dsp(tth+thick/2.,wave),Data),azm)),2)
             x2,y2 = np.hsplit(np.array(G2img.makeIdealRing(G2img.GetEllipse(Dsp(max(0.01,tth-thick/2.),wave),Data),azm)),2)
-            self.arcList.append([Plot.plot(x1,y1,'r',picker=3),iarc,'o'])            
-            self.arcList.append([Plot.plot(x2,y2,'r',picker=3),iarc,'i'])
-            self.arcList.append([Plot.plot([x1[0],x2[0]],[y1[0],y2[0]],'r',picker=3),iarc,'l'])
-            self.arcList.append([Plot.plot([x1[-1],x2[-1]],[y1[-1],y2[-1]],'r',picker=3),iarc,'u'])
-        self.polyList = []
+            G2frame.arcList.append([Plot.plot(x1,y1,'r',picker=3),iarc,'o'])            
+            G2frame.arcList.append([Plot.plot(x2,y2,'r',picker=3),iarc,'i'])
+            G2frame.arcList.append([Plot.plot([x1[0],x2[0]],[y1[0],y2[0]],'r',picker=3),iarc,'l'])
+            G2frame.arcList.append([Plot.plot([x1[-1],x2[-1]],[y1[-1],y2[-1]],'r',picker=3),iarc,'u'])
+        G2frame.polyList = []
         for ipoly,polygon in enumerate(polygons):
             x,y = np.hsplit(np.array(polygon),2)
-            self.polyList.append([Plot.plot(x,y,'r+',picker=10),ipoly])
+            G2frame.polyList.append([Plot.plot(x,y,'r+',picker=10),ipoly])
             Plot.plot(x,y,'r')            
         if newImage:
@@ -2004 +2004 @@
         wx.EndBusyCursor()
         
-def PlotIntegration(self,newPlot=False,event=None):
+def PlotIntegration(G2frame,newPlot=False,event=None):
     '''Plot of 2D image after image integration with 2-theta and azimuth as coordinates
     '''
@@ -2014 +2014 @@
         tth = event.xdata
         if azm and tth:
-            self.G2plotNB.status.SetFields(\
+            G2frame.G2plotNB.status.SetFields(\
                 ['','Detector 2-th =%9.3fdeg, azm = %7.2fdeg'%(tth,azm)])
                                 
     try:
-        plotNum = self.G2plotNB.plotList.index('2D Integration')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('2D Integration')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         if not newPlot:
             Plot = Page.figure.gca()          #get previous plot & get limits
@@ -2027 +2027 @@
         
     except ValueError:
-        Plot = self.G2plotNB.addMpl('2D Integration').gca()
-        plotNum = self.G2plotNB.plotList.index('2D Integration')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl('2D Integration').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('2D Integration')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('motion_notify_event', OnMotion)
         Page.views = False
@@ -2036 +2036 @@
         Page.SetFocus()
         
-    Data = self.PatternTree.GetItemPyData(
-        G2gd.GetPatternTreeItemId(self,self.Image, 'Image Controls'))
-    image = self.Integrate[0]
-    xsc = self.Integrate[1]
-    ysc = self.Integrate[2]
+    Data = G2frame.PatternTree.GetItemPyData(
+        G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
+    image = G2frame.Integrate[0]
+    xsc = G2frame.Integrate[1]
+    ysc = G2frame.Integrate[2]
     Imin,Imax = Data['range'][1]
     acolor = mpl.cm.get_cmap(Data['color'])
-    Plot.set_title(self.PatternTree.GetItemText(self.Image)[4:])
+    Plot.set_title(G2frame.PatternTree.GetItemText(G2frame.Image)[4:])
     Plot.set_ylabel('azimuth',fontsize=12)
     Plot.set_xlabel('2-theta',fontsize=12)
@@ -2066 +2066 @@
         Page.canvas.draw()
                 
-def PlotTRImage(self,tax,tay,taz,newPlot=False):
+def PlotTRImage(G2frame,tax,tay,taz,newPlot=False):
     '''a test plot routine - not normally used
     ''' 
@@ -2076 +2076 @@
         tth = event.ydata
         if azm and tth:
-            self.G2plotNB.status.SetFields(\
+            G2frame.G2plotNB.status.SetFields(\
                 ['','Detector 2-th =%9.3fdeg, azm = %7.2fdeg'%(tth,azm)])
                                 
     try:
-        plotNum = self.G2plotNB.plotList.index('2D Transformed Powder Image')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        plotNum = G2frame.G2plotNB.plotList.index('2D Transformed Powder Image')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         if not newPlot:
             Plot = Page.figure.gca()          #get previous plot & get limits
@@ -2089 +2089 @@
         
     except ValueError:
-        Plot = self.G2plotNB.addMpl('2D Transformed Powder Image').gca()
-        plotNum = self.G2plotNB.plotList.index('2D Transformed Powder Image')
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addMpl('2D Transformed Powder Image').gca()
+        plotNum = G2frame.G2plotNB.plotList.index('2D Transformed Powder Image')
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.canvas.mpl_connect('motion_notify_event', OnMotion)
         Page.views = False
@@ -2097 +2097 @@
     Page.SetFocus()
         
-    Data = self.PatternTree.GetItemPyData(
-        G2gd.GetPatternTreeItemId(self,self.Image, 'Image Controls'))
+    Data = G2frame.PatternTree.GetItemPyData(
+        G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
     Imin,Imax = Data['range'][1]
     step = (Imax-Imin)/5.
     V = np.arange(Imin,Imax,step)
     acolor = mpl.cm.get_cmap(Data['color'])
-    Plot.set_title(self.PatternTree.GetItemText(self.Image)[4:])
+    Plot.set_title(G2frame.PatternTree.GetItemText(G2frame.Image)[4:])
     Plot.set_xlabel('azimuth',fontsize=12)
     Plot.set_ylabel('2-theta',fontsize=12)
@@ -2139 +2139 @@
         Page.canvas.draw()
         
-def PlotStructure(self,data):
+def PlotStructure(G2frame,data):
     '''Crystal structure plotting package. Can show structures as balls, sticks, lines,
     thermal motion ellipsoids and polyhedra
@@ -2183 +2183 @@
         im.save(Fname,mode)
         cb.SetValue(' Save as:')
-        self.G2plotNB.status.SetStatusText('Drawing saved to: '+Fname,1)
+        G2frame.G2plotNB.status.SetStatusText('Drawing saved to: '+Fname,1)
     
     def GetTruePosition(xy,Add=False):
@@ -2230 +2230 @@
                 SetTestRotZ(newxy)
             x,y,z = drawingData['testPos'][0]
-            self.G2plotNB.status.SetStatusText('moving test point %.4f,%.4f,%.4f'%(x,y,z),1)
+            G2frame.G2plotNB.status.SetStatusText('moving test point %.4f,%.4f,%.4f'%(x,y,z),1)
                                 
         if event.Dragging() and not event.ControlDown():
@@ -2236 +2236 @@
                 SetRotation(newxy)
                 angX,angY,angZ = drawingData['Rotation'][:3]
-                self.G2plotNB.status.SetStatusText('New rotation: %.2f, %.2f ,%.2f'%(angX,angY,angZ),1)
+                G2frame.G2plotNB.status.SetStatusText('New rotation: %.2f, %.2f ,%.2f'%(angX,angY,angZ),1)
             elif event.RightIsDown():
                 SetTranslation(newxy)
                 Tx,Ty,Tz = drawingData['viewPoint'][0]
-                self.G2plotNB.status.SetStatusText('New view point: %.4f, %.4f, %.4f'%(Tx,Ty,Tz),1)
+                G2frame.G2plotNB.status.SetStatusText('New view point: %.4f, %.4f, %.4f'%(Tx,Ty,Tz),1)
             elif event.MiddleIsDown():
                 SetRotationZ(newxy)
                 angX,angY,angZ = drawingData['Rotation'][:3]
-                self.G2plotNB.status.SetStatusText('New rotation: %.2f, %.2f, %.2f'%(angX,angY,angZ),1)
+                G2frame.G2plotNB.status.SetStatusText('New rotation: %.2f, %.2f, %.2f'%(angX,angY,angZ),1)
         Draw()
         
@@ -2252 +2252 @@
         drawingData['cameraPos'] += event.GetWheelRotation()/24
         drawingData['cameraPos'] = max(10,min(500,drawingData['cameraPos']))
-        self.G2plotNB.status.SetStatusText('New camera distance: %.2f'%(drawingData['cameraPos']),1)
+        G2frame.G2plotNB.status.SetStatusText('New camera distance: %.2f'%(drawingData['cameraPos']),1)
         page = getSelection()
         if page:
-            if self.dataDisplay.GetPageText(page) == 'Draw Options':
-                panel = self.dataDisplay.GetPage(page).GetChildren()[0].GetChildren()
+            if G2frame.dataDisplay.GetPageText(page) == 'Draw Options':
+                panel = G2frame.dataDisplay.GetPage(page).GetChildren()[0].GetChildren()
                 names = [child.GetName() for child in panel]
                 panel[names.index('cameraPos')].SetLabel('Camera Position: '+'%.2f'%(drawingData['cameraPos']))
@@ -2264 +2264 @@
     def getSelection():
         try:
-            return self.dataDisplay.GetSelection()
+            return G2frame.dataDisplay.GetSelection()
         except AttributeError:
-            print self.dataDisplay.GetLabel()
-            self.G2plotNB.status.SetStatusText('Select this from Phase data window!')
+            print G2frame.dataDisplay.GetLabel()
+            G2frame.G2plotNB.status.SetStatusText('Select this from Phase data window!')
             return 0
             
@@ -2273 +2273 @@
         page = getSelection()
         if page:
-            if self.dataDisplay.GetPageText(page) == 'Draw Options':
-                panel = self.dataDisplay.GetPage(page).GetChildren()[0].GetChildren()
+            if G2frame.dataDisplay.GetPageText(page) == 'Draw Options':
+                panel = G2frame.dataDisplay.GetPage(page).GetChildren()[0].GetChildren()
                 names = [child.GetName() for child in panel]
                 panel[names.index('viewPoint')].SetValue('%.3f, %.3f, %.3f'%(VP[0],VP[1],VP[2]))
@@ -2281 +2281 @@
         page = getSelection()
         if page:
-            if self.dataDisplay.GetPageText(page) == 'Draw Atoms':
-                self.dataDisplay.GetPage(page).ClearSelection()      #this is the Atoms grid in Draw Atoms
-            elif self.dataDisplay.GetPageText(page) == 'Atoms':
-                self.dataDisplay.GetPage(page).ClearSelection()      #this is the Atoms grid in Atoms
+            if G2frame.dataDisplay.GetPageText(page) == 'Draw Atoms':
+                G2frame.dataDisplay.GetPage(page).ClearSelection()      #this is the Atoms grid in Draw Atoms
+            elif G2frame.dataDisplay.GetPageText(page) == 'Atoms':
+                G2frame.dataDisplay.GetPage(page).ClearSelection()      #this is the Atoms grid in Atoms
                     
     def SetSelectedAtoms(ind,Add=False):
         page = getSelection()
         if page:
-            if self.dataDisplay.GetPageText(page) == 'Draw Atoms':
-                self.dataDisplay.GetPage(page).SelectRow(ind,Add)      #this is the Atoms grid in Draw Atoms
-            elif self.dataDisplay.GetPageText(page) == 'Atoms':
+            if G2frame.dataDisplay.GetPageText(page) == 'Draw Atoms':
+                G2frame.dataDisplay.GetPage(page).SelectRow(ind,Add)      #this is the Atoms grid in Draw Atoms
+            elif G2frame.dataDisplay.GetPageText(page) == 'Atoms':
                 Id = drawAtoms[ind][-2]
                 for i,atom in enumerate(atomData):
                     if atom[-1] == Id:
-                        self.dataDisplay.GetPage(page).SelectRow(i)      #this is the Atoms grid in Atoms
+                        G2frame.dataDisplay.GetPage(page).SelectRow(i)      #this is the Atoms grid in Atoms
                   
     def GetSelectedAtoms():
@@ -2301 +2301 @@
         Ind = []
         if page:
-            if self.dataDisplay.GetPageText(page) == 'Draw Atoms':
-                Ind = self.dataDisplay.GetPage(page).GetSelectedRows()      #this is the Atoms grid in Draw Atoms
-            elif self.dataDisplay.GetPageText(page) == 'Atoms':
-                Ind = self.dataDisplay.GetPage(page).GetSelectedRows()      #this is the Atoms grid in Atoms
+            if G2frame.dataDisplay.GetPageText(page) == 'Draw Atoms':
+                Ind = G2frame.dataDisplay.GetPage(page).GetSelectedRows()      #this is the Atoms grid in Draw Atoms
+            elif G2frame.dataDisplay.GetPageText(page) == 'Atoms':
+                Ind = G2frame.dataDisplay.GetPage(page).GetSelectedRows()      #this is the Atoms grid in Atoms
         return Ind
                                        
@@ -2612 +2612 @@
             x,y,z = drawingData['testPos'][0]
 #            if altDown:
-#                self.G2plotNB.status.SetStatusText('moving test point %.4f,%.4f,%.4f'%(x,y,z),1)
+#                G2frame.G2plotNB.status.SetStatusText('moving test point %.4f,%.4f,%.4f'%(x,y,z),1)
 #            else:
-#                self.G2plotNB.status.SetStatusText('test point %.4f,%.4f,%.4f'%(x,y,z),1)            
+#                G2frame.G2plotNB.status.SetStatusText('test point %.4f,%.4f,%.4f'%(x,y,z),1)            
             RenderUnitVectors(x,y,z)
         Backbone = []
@@ -2712 +2712 @@
         
     try:
-        plotNum = self.G2plotNB.plotList.index(generalData['Name'])
-        Page = self.G2plotNB.nb.GetPage(plotNum)        
+        plotNum = G2frame.G2plotNB.plotList.index(generalData['Name'])
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)        
     except ValueError:
-        Plot = self.G2plotNB.addOgl(generalData['Name'])
-        plotNum = self.G2plotNB.plotList.index(generalData['Name'])
-        Page = self.G2plotNB.nb.GetPage(plotNum)
+        Plot = G2frame.G2plotNB.addOgl(generalData['Name'])
+        plotNum = G2frame.G2plotNB.plotList.index(generalData['Name'])
+        Page = G2frame.G2plotNB.nb.GetPage(plotNum)
         Page.views = False
         view = False
         altDown = False
     Page.SetFocus()
-    cb = wx.ComboBox(self.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
+    cb = wx.ComboBox(G2frame.G2plotNB.status,style=wx.CB_DROPDOWN|wx.CB_READONLY,
         choices=(' save as:','jpeg','tiff','bmp'))
     cb.Bind(wx.EVT_COMBOBOX, OnKeyBox)

trunk/GSASIIpwdGUI.py ¶

@@ -31 +31 @@
 asind = lambda x: 180.*math.asin(x)/math.pi
     
-def IsHistogramInAnyPhase(self,histoName):
-    phases = G2gd.GetPatternTreeItemId(self,self.root,'Phases')
+def IsHistogramInAnyPhase(G2frame,histoName):
+    phases = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
     if phases:
-        item, cookie = self.PatternTree.GetFirstChild(phases)
+        item, cookie = G2frame.PatternTree.GetFirstChild(phases)
         while item:
-            data = self.PatternTree.GetItemPyData(item)
+            data = G2frame.PatternTree.GetItemPyData(item)
             histoList = data['Histograms'].keys()
             if histoName in histoList:
                 return True
-            item, cookie = self.PatternTree.GetNextChild(phases, cookie)
+            item, cookie = G2frame.PatternTree.GetNextChild(phases, cookie)
         return False
     else:
@@ -52 +52 @@
         'Omega':0.0,'Chi':0.0,'Phi':0.0}    
        
-def UpdatePeakGrid(self, data):
-    if self.dataDisplay:
-        self.dataFrame.Clear()
+def UpdatePeakGrid(G2frame, data):
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
     
     def OnUnDo(event):
         DoUnDo()
-        self.dataFrame.UnDo.Enable(False)
+        G2frame.dataFrame.UnDo.Enable(False)
         
     def DoUnDo():
         print 'Undo last refinement'
-        file = open(self.undofile,'rb')
-        PatternId = self.PatternId
+        file = open(G2frame.undofile,'rb')
+        PatternId = G2frame.PatternId
         for item in ['Background','Instrument Parameters','Peak List']:
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, item),cPickle.load(file))
-            if self.dataDisplay.GetName() == item:
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item),cPickle.load(file))
+            if G2frame.dataDisplay.GetName() == item:
                 if item == 'Background':
-                    UpdateBackground(self,self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, item)))
+                    UpdateBackground(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
                 elif item == 'Instrument Parameters':
-                    UpdateInstrumentGrid(self,self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, item)))
+                    UpdateInstrumentGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
                 elif item == 'Peak List':
-                    UpdatePeakGrid(self,self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, item)))
+                    UpdatePeakGrid(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
             print item,' recovered'
         file.close()
         
     def SaveState():
-        self.undofile = self.dirname+'\\GSASII.save'
-        file = open(self.undofile,'wb')
-        PatternId = self.PatternId
+        G2frame.undofile = G2frame.dirname+'\\GSASII.save'
+        file = open(G2frame.undofile,'wb')
+        PatternId = G2frame.PatternId
         for item in ['Background','Instrument Parameters','Peak List']:
-            cPickle.dump(self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId,item)),file,1)
+            cPickle.dump(G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,item)),file,1)
         file.close()
-        self.dataFrame.UnDo.Enable(True)
+        G2frame.dataFrame.UnDo.Enable(True)
         
     def OnLSQPeakFit(event):
+        if not G2frame.GSASprojectfile:            #force a save of the gpx file so SaveState can wirte in the same directory
+            G2frame.OnFileSaveas(event)
         OnPeakFit('LSQ')
         
@@ -92 +94 @@
         
     def OnClearPeaks(event):
-        dlg = wx.MessageDialog(self,'Delete all peaks?','Clear peak list',wx.OK|wx.CANCEL)
+        dlg = wx.MessageDialog(G2frame,'Delete all peaks?','Clear peak list',wx.OK|wx.CANCEL)
         try:
             if dlg.ShowModal() == wx.ID_OK:
@@ -98 +100 @@
         finally:
             dlg.Destroy()
-        UpdatePeakGrid(self,peaks)
-        G2plt.PlotPatterns(self)
+        UpdatePeakGrid(G2frame,peaks)
+        G2plt.PlotPatterns(G2frame)
         
     def OnPeakFit(FitPgm,oneCycle=False):
         SaveState()
-        controls = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.root, 'Controls'))
+        controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
         if not controls:
             controls = {'deriv type':'analytic','min dM/M':0.0001,}     #fill in defaults if needed
         print 'Peak Fitting with '+controls['deriv type']+' derivatives:'
-        PatternId = self.PatternId
-        PickId = self.PickId
-        peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Peak List'))
+        PatternId = G2frame.PatternId
+        PickId = G2frame.PickId
+        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
         if not peaks:
-            self.ErrorDialog('No peaks!','Nothing to fit!')
+            G2frame.ErrorDialog('No peaks!','Nothing to fit!')
             return
-        background = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Background'))
-        limits = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Limits'))[1]
-        inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Instrument Parameters'))
-        data = self.PatternTree.GetItemPyData(PatternId)[1]
+        background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Background'))
+        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
+        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
+        data = G2frame.PatternTree.GetItemPyData(PatternId)[1]
         wx.BeginBusyCursor()
         try:
@@ -122 +124 @@
         finally:
             wx.EndBusyCursor()    
-        UpdatePeakGrid(self,peaks)
-        G2plt.PlotPatterns(self)
+        UpdatePeakGrid(G2frame,peaks)
+        G2plt.PlotPatterns(G2frame)
         print 'finished'
         return
         
     def OnResetSigGam(event):
-        PatternId = self.PatternId
-        PickId = self.PickId
-        peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Peak List'))
+        PatternId = G2frame.PatternId
+        PickId = G2frame.PickId
+        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
         if not peaks:
-            self.ErrorDialog('No peaks!','Nothing to do!')
+            G2frame.ErrorDialog('No peaks!','Nothing to do!')
             return
-        inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Instrument Parameters'))
+        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Instrument Parameters'))
         Inst = dict(zip(inst[3],inst[1]))
         print len(Inst['Type'])
@@ -141 +143 @@
                 peak[4] = Inst['U']*tand(peak[0]/2.0)**2+Inst['V']*tand(peak[0]/2.0)+Inst['W']
                 peak[6] = Inst['X']/cosd(peak[0]/2.0)+Inst['Y']*tand(peak[0]/2.0)
-        UpdatePeakGrid(self,peaks)
+        UpdatePeakGrid(G2frame,peaks)
                 
     def RefreshPeakGrid(event):
@@ -147 +149 @@
         
         event.StopPropagation()
-        data = self.PeakTable.GetData()
+        data = G2frame.PeakTable.GetData()
         T = []
         for peak in data:T.append(peak[0])
@@ -157 +159 @@
         
     def setBackgroundColors():
-       for r in range(self.dataDisplay.GetNumberRows()):
-           for c in range(self.dataDisplay.GetNumberCols()):
-               if self.dataDisplay.GetColLabelValue(c) in ['position','intensity','sigma','gamma']:
-                   if float(self.dataDisplay.GetCellValue(r,c)) < 0.:
-                       self.dataDisplay.SetCellBackgroundColour(r,c,wx.RED)
+       for r in range(G2frame.dataDisplay.GetNumberRows()):
+           for c in range(G2frame.dataDisplay.GetNumberCols()):
+               if G2frame.dataDisplay.GetColLabelValue(c) in ['position','intensity','sigma','gamma']:
+                   if float(G2frame.dataDisplay.GetCellValue(r,c)) < 0.:
+                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.RED)
                    else:
-                       self.dataDisplay.SetCellBackgroundColour(r,c,wx.WHITE)
+                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.WHITE)
                                                   
     def KeyEditPeakGrid(event):
-        rowList = self.dataDisplay.GetSelectedRows()
-        colList = self.dataDisplay.GetSelectedCols()
-        selectList = self.dataDisplay.GetSelectedCells()
-        data = self.PatternTree.GetItemPyData(self.PickId)
+        rowList = G2frame.dataDisplay.GetSelectedRows()
+        colList = G2frame.dataDisplay.GetSelectedCols()
+        selectList = G2frame.dataDisplay.GetSelectedCells()
+        data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
         if event.GetKeyCode() == wx.WXK_RETURN:
             event.Skip(True)
@@ -177 +179 @@
             event.Skip(True)
         elif rowList:
-            self.dataDisplay.ClearSelection()
+            G2frame.dataDisplay.ClearSelection()
             if event.GetKeyCode() == wx.WXK_DELETE:
-                self.dataDisplay.ClearGrid()
+                G2frame.dataDisplay.ClearGrid()
                 rowList.reverse()
                 nDel = 0
                 for row in rowList:
-                    self.PeakTable.DeleteRow(row)
+                    G2frame.PeakTable.DeleteRow(row)
                     nDel += 1
                 if nDel:
-                    msg = wg.GridTableMessage(self.PeakTable, 
+                    msg = wg.GridTableMessage(G2frame.PeakTable, 
                         wg.GRIDTABLE_NOTIFY_ROWS_DELETED,0,nDel)
-                    self.dataDisplay.ProcessTableMessage(msg)
-                data = self.PeakTable.GetData()
-                self.PatternTree.SetItemPyData(self.PickId,data[:-nDel])
-                self.dataDisplay.ForceRefresh()
+                    G2frame.dataDisplay.ProcessTableMessage(msg)
+                data = G2frame.PeakTable.GetData()
+                G2frame.PatternTree.SetItemPyData(G2frame.PickId,data[:-nDel])
+                G2frame.dataDisplay.ForceRefresh()
                 setBackgroundColors()
-                if not len(self.PatternTree.GetItemPyData(self.PickId)): 
-                    self.dataFrame.PeakFit.Enable(False)
+                if not len(G2frame.PatternTree.GetItemPyData(G2frame.PickId)): 
+                    G2frame.dataFrame.PeakFit.Enable(False)
                         
         elif colList:
-            self.dataDisplay.ClearSelection()
+            G2frame.dataDisplay.ClearSelection()
             key = event.GetKeyCode()
             for col in colList:
-                if self.PeakTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
+                if G2frame.PeakTable.GetTypeName(0,col) == wg.GRID_VALUE_BOOL:
                     if key == 89: #'Y'
-                        for row in range(self.PeakTable.GetNumberRows()): data[row][col]=True
+                        for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=True
                     elif key == 78:  #'N'
-                        for row in range(self.PeakTable.GetNumberRows()): data[row][col]=False
+                        for row in range(G2frame.PeakTable.GetNumberRows()): data[row][col]=False
         elif selectList:
-            self.dataDisplay.ClearSelection()
+            G2frame.dataDisplay.ClearSelection()
             key = event.GetKeyCode()
             for row,col in selectList:
-                if self.PeakTable.GetTypeName(row,col) == wg.GRID_VALUE_BOOL:
+                if G2frame.PeakTable.GetTypeName(row,col) == wg.GRID_VALUE_BOOL:
                     if key == 89: #'Y'
                         data[row][col]=True
                     elif key == 78:  #'N'
                         data[row][col]=False
-        G2plt.PlotPatterns(self)
+        G2plt.PlotPatterns(G2frame)
             
-    self.dataFrame.SetMenuBar(self.dataFrame.PeakMenu)
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
-    self.Bind(wx.EVT_MENU, OnUnDo, id=G2gd.wxID_UNDO)
-    self.Bind(wx.EVT_MENU, OnLSQPeakFit, id=G2gd.wxID_LSQPEAKFIT)
-    self.Bind(wx.EVT_MENU, OnOneCycle, id=G2gd.wxID_LSQONECYCLE)
-    self.Bind(wx.EVT_MENU, OnClearPeaks, id=G2gd.wxID_CLEARPEAKS)
-    self.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
-    self.dataFrame.PeakFit.Enable(False)
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.PeakMenu)
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
+    G2frame.Bind(wx.EVT_MENU, OnUnDo, id=G2gd.wxID_UNDO)
+    G2frame.Bind(wx.EVT_MENU, OnLSQPeakFit, id=G2gd.wxID_LSQPEAKFIT)
+    G2frame.Bind(wx.EVT_MENU, OnOneCycle, id=G2gd.wxID_LSQONECYCLE)
+    G2frame.Bind(wx.EVT_MENU, OnClearPeaks, id=G2gd.wxID_CLEARPEAKS)
+    G2frame.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
+    G2frame.dataFrame.PeakFit.Enable(False)
     if data:
-        self.dataFrame.PeakFit.Enable(True)
-        self.dataFrame.PFOneCycle.Enable(True)
-    self.PickTable = []
+        G2frame.dataFrame.PeakFit.Enable(True)
+        G2frame.dataFrame.PFOneCycle.Enable(True)
+    G2frame.PickTable = []
     rowLabels = []
     for i in range(len(data)): rowLabels.append(str(i+1))
@@ -244 +246 @@
     for key in T: X.append(D[key])
     data = X        
-    self.PatternTree.SetItemPyData(self.PickId,data)
-    self.PeakTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-    self.dataFrame.SetLabel('Peak List')
-    self.dataDisplay = G2gd.GSGrid(parent=self.dataFrame)
-    self.dataDisplay.SetTable(self.PeakTable, True)
+    G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
+    G2frame.PeakTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+    G2frame.dataFrame.SetLabel('Peak List')
+    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
+    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
     setBackgroundColors()                         
-    self.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
-    self.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
-    self.dataDisplay.SetMargins(0,0)
-    self.dataDisplay.AutoSizeColumns(False)
-    self.dataFrame.setSizePosLeft([535,350])
-        
-def UpdateBackground(self,data):
+    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
+    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
+    G2frame.dataDisplay.SetMargins(0,0)
+    G2frame.dataDisplay.AutoSizeColumns(False)
+    G2frame.dataFrame.setSizePosLeft([535,350])
+        
+def UpdateBackground(G2frame,data):
     if len(data) < 2:       #add Debye diffuse & peaks scattering here
         data.append({'nDebye':0,'debyeTerms':[],'nPeaks':0,'peaksList':[]})
@@ -264 +266 @@
             
     def OnBackCopy(event):
-        histList = ['All',]+G2gd.GetPatternTreeDataNames(self,['PWDR',])
+        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
         copyList = []
-        dlg = wx.MultiChoiceDialog(self, 
+        dlg = wx.MultiChoiceDialog(G2frame, 
             'Copy parameters to which histograms?', 'Copy parameters', 
             histList, wx.CHOICEDLG_STYLE)
@@ -277 +279 @@
                     copyList = histList[1:]
             for item in copyList:
-                Id = G2gd.GetPatternTreeItemId(self,self.root,item)
-                self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Background'),
+                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
+                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Background'),
                     copy.copy(data))
         finally:
@@ -302 +304 @@
                 for i in range(N,M):
                     del(item[-1])
-            self.PatternTree.SetItemPyData(BackId,data)
-            UpdateBackground(self,data)
+            G2frame.PatternTree.SetItemPyData(BackId,data)
+            UpdateBackground(G2frame,data)
             
         def OnBakVal(event):
@@ -317 +319 @@
         backSizer = wx.BoxSizer(wx.VERTICAL)
         topSizer = wx.BoxSizer(wx.HORIZONTAL)
-        topSizer.Add(wx.StaticText(self.dataDisplay,-1,' Background function: '),0,wx.ALIGN_CENTER_VERTICAL)
-        bakType = wx.ComboBox(self.dataDisplay,value=data[0][0],
+        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background function: '),0,wx.ALIGN_CENTER_VERTICAL)
+        bakType = wx.ComboBox(G2frame.dataDisplay,value=data[0][0],
                 choices=Choices,style=wx.CB_READONLY|wx.CB_DROPDOWN)
         bakType.Bind(wx.EVT_COMBOBOX, OnNewType)
         topSizer.Add(bakType)
         topSizer.Add((5,0),0)
-        bakRef = wx.CheckBox(self.dataDisplay,label=' Refine?')
+        bakRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
         bakRef.SetValue(bool(data[0][1]))
         bakRef.Bind(wx.EVT_CHECKBOX, OnBakRef)
         topSizer.Add(bakRef,0,wx.ALIGN_CENTER_VERTICAL)
-        topSizer.Add(wx.StaticText(self.dataDisplay,-1,' No. coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
-        bakTerms = wx.ComboBox(self.dataDisplay,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
+        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
+        bakTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         bakTerms.Bind(wx.EVT_COMBOBOX,OnBakTerms)
@@ -334 +336 @@
         topSizer.Add((5,0),0)
         backSizer.Add(topSizer)
-        backSizer.Add(wx.StaticText(self.dataDisplay,-1,' Background coefficients:'),0,wx.ALIGN_CENTER_VERTICAL)
+        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background coefficients:'),0,wx.ALIGN_CENTER_VERTICAL)
         bakSizer = wx.FlexGridSizer(1,5,5,5)
         for i,value in enumerate(data[0][3:]):
-            bakVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,'%10.4f'%(value),style=wx.TE_PROCESS_ENTER)
+            bakVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.4f'%(value),style=wx.TE_PROCESS_ENTER)
             bakSizer.Add(bakVal,0,wx.ALIGN_CENTER_VERTICAL)
             ValObj[bakVal.GetId()] = [i+3]
@@ -357 +359 @@
                 for i in range(N,M):
                     del(data[1]['debyeTerms'][-1])
-            UpdateBackground(self,data)
+            UpdateBackground(G2frame,data)
 
         def KeyEditPeakGrid(event):
@@ -380 +382 @@
         debSizer = wx.BoxSizer(wx.VERTICAL)
         topSizer = wx.BoxSizer(wx.HORIZONTAL)
-        topSizer.Add(wx.StaticText(self.dataDisplay,-1,' Debye scattering: '),0,wx.ALIGN_CENTER_VERTICAL)
-        topSizer.Add(wx.StaticText(self.dataDisplay,-1,' No. coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
-        debTerms = wx.ComboBox(self.dataDisplay,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
+        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye scattering: '),0,wx.ALIGN_CENTER_VERTICAL)
+        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
+        debTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         debTerms.Bind(wx.EVT_COMBOBOX,OnDebTerms)
@@ -389 +391 @@
         debSizer.Add(topSizer)
         if data[1]['nDebye']:
-            debSizer.Add(wx.StaticText(self.dataDisplay,-1,' Debye diffuse terms:'),0,wx.ALIGN_CENTER_VERTICAL)       
+            debSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye diffuse terms:'),0,wx.ALIGN_CENTER_VERTICAL)       
             rowLabels = []
             for i in range(len(data[1]['debyeTerms'])): rowLabels.append(str(i))
@@ -397 +399 @@
             wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
             debyeTable = G2gd.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            debyeGrid = G2gd.GSGrid(parent=self.dataDisplay)
+            debyeGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
             debyeGrid.SetTable(debyeTable, True)
             debyeGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
@@ -416 +418 @@
                 for i in range(N,M):
                     del(data[1]['peaksList'][-1])
-            UpdateBackground(self,data)
+            UpdateBackground(G2frame,data)
 
         def KeyEditPeakGrid(event):
@@ -438 +440 @@
         peaksSizer = wx.BoxSizer(wx.VERTICAL)
         topSizer = wx.BoxSizer(wx.HORIZONTAL)
-        topSizer.Add(wx.StaticText(self.dataDisplay,-1,' Peaks in background: '),0,wx.ALIGN_CENTER_VERTICAL)
-        topSizer.Add(wx.StaticText(self.dataDisplay,-1,' No. peaks: '),0,wx.ALIGN_CENTER_VERTICAL)
-        peaks = wx.ComboBox(self.dataDisplay,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(12)],
+        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peaks in background: '),0,wx.ALIGN_CENTER_VERTICAL)
+        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. peaks: '),0,wx.ALIGN_CENTER_VERTICAL)
+        peaks = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(12)],
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         peaks.Bind(wx.EVT_COMBOBOX,OnPeaks)
@@ -447 +449 @@
         peaksSizer.Add(topSizer)
         if data[1]['nPeaks']:
-            peaksSizer.Add(wx.StaticText(self.dataDisplay,-1,' Peak list:'),0,wx.ALIGN_CENTER_VERTICAL)       
+            peaksSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peak list:'),0,wx.ALIGN_CENTER_VERTICAL)       
             rowLabels = []
             for i in range(len(data[1]['peaksList'])): rowLabels.append(str(i))
@@ -456 +458 @@
             wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
             peaksTable = G2gd.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            peaksGrid = G2gd.GSGrid(parent=self.dataDisplay)
+            peaksGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
             peaksGrid.SetTable(peaksTable, True)
             peaksGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
@@ -463 +465 @@
         return peaksSizer
                 
-    if self.dataDisplay:
-        self.dataFrame.Clear()
-    self.dataDisplay = wx.Panel(self.dataFrame)
-    self.dataFrame.SetMenuBar(self.dataFrame.BackMenu)
-    self.dataFrame.SetLabel('Background')
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
-    self.Bind(wx.EVT_MENU,OnBackCopy,id=G2gd.wxID_BACKCOPY)
-    BackId = G2gd.GetPatternTreeItemId(self,self.PatternId, 'Background')
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BackMenu)
+    G2frame.dataFrame.SetLabel('Background')
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
+    G2frame.Bind(wx.EVT_MENU,OnBackCopy,id=G2gd.wxID_BACKCOPY)
+    BackId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Background')
     Choices = ['chebyschev','cosine','lin interpolate','inv interpolate','log interpolate']
     mainSizer = wx.BoxSizer(wx.VERTICAL)
@@ -480 +482 @@
     mainSizer.Add(PeaksSizer())
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    self.dataFrame.setSizePosLeft(mainSizer.Fit(self.dataFrame))
-        
-def UpdateLimitsGrid(self, data):
-    if self.dataDisplay:
-        self.dataFrame.Clear()
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
+        
+def UpdateLimitsGrid(G2frame, data):
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
         
     def RefreshLimitsGrid(event):
         event.StopPropagation()
-        data = self.LimitsTable.GetData()
+        data = G2frame.LimitsTable.GetData()
         old = data[0]
         new = data[1]
@@ -495 +497 @@
         new[1] = max(new[0],min(old[1],new[1]))
         data = [old,new]
-        G2plt.PlotPatterns(self)
+        G2plt.PlotPatterns(G2frame)
         
     def OnLimitCopy(event):
-        histList = ['All',]+G2gd.GetPatternTreeDataNames(self,['PWDR',])
+        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
         copyList = []
-        dlg = wx.MultiChoiceDialog(self, 
+        dlg = wx.MultiChoiceDialog(G2frame, 
             'Copy limits to which histograms?', 'Copy limits', 
             histList, wx.CHOICEDLG_STYLE)
@@ -511 +513 @@
                     copyList = histList[1:]
             for item in copyList:
-                Id = G2gd.GetPatternTreeItemId(self,self.root,item)
-                self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Limits'),
+                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
+                G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Limits'),
                     copy.copy(data))
         finally:
             dlg.Destroy()
         
-    self.LimitsTable = []
+    G2frame.LimitsTable = []
     colLabels = ['Tmin','Tmax']
     rowLabels = ['original','changed']
     Types = 2*[wg.GRID_VALUE_FLOAT+':10,3',]
-    self.LimitsTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-    self.dataFrame.SetLabel('Limits')
-    self.dataFrame.SetMenuBar(self.dataFrame.LimitMenu)
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
-    self.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
-    self.dataDisplay = G2gd.GSGrid(parent=self.dataFrame)
-    self.dataDisplay.SetTable(self.LimitsTable, True)
-    self.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshLimitsGrid)                
-    self.dataDisplay.SetMargins(0,0)
-    self.dataDisplay.AutoSizeColumns(False)
-    self.dataFrame.setSizePosLeft([230,160])
+    G2frame.LimitsTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+    G2frame.dataFrame.SetLabel('Limits')
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.LimitMenu)
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
+    G2frame.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
+    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
+    G2frame.dataDisplay.SetTable(G2frame.LimitsTable, True)
+    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshLimitsGrid)                
+    G2frame.dataDisplay.SetMargins(0,0)
+    G2frame.dataDisplay.AutoSizeColumns(False)
+    G2frame.dataFrame.setSizePosLeft([230,160])
     
-def UpdateInstrumentGrid(self,data):
+def UpdateInstrumentGrid(G2frame,data):
     if len(data) > 3:                   #powder data
         insVal = dict(zip(data[3],data[1]))
@@ -568 +570 @@
         
     def updateData(inst,ref):
-        return inst2data(inst,ref,self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,
-            self.PatternId,'Instrument Parameters')))        
+        return inst2data(inst,ref,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,
+            G2frame.PatternId,'Instrument Parameters')))        
     
     def RefreshInstrumentGrid(event,doAnyway=False):
         if doAnyway or event.GetRow() == 1:
-            peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Peak List'))
+            peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
             if 'P' in insVal['Type']:                                       #update powder peak parameters
                 for peak in peaks:
@@ -583 +585 @@
         data = updateData(insVal,insRef)
         RefreshInstrumentGrid(event,doAnyway=True)          #to get peaks updated
-        UpdateInstrumentGrid(self,data)
+        UpdateInstrumentGrid(G2frame,data)
         
     def OnInstCopy(event):
-        histList = ['All',]+G2gd.GetPatternTreeDataNames(self,['PWDR',])
+        histList = ['All',]+G2gd.GetPatternTreeDataNames(G2frame,['PWDR',])
         copyList = []
-        dlg = wx.MultiChoiceDialog(self, 
+        dlg = wx.MultiChoiceDialog(G2frame, 
             'Copy parameters to which histograms?', 'Copy parameters', 
             histList, wx.CHOICEDLG_STYLE)
@@ -599 +601 @@
                     copyList = histList[1:]
             for item in copyList:
-                Id = G2gd.GetPatternTreeItemId(self,self.root,item)
-                instData = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Instrument Parameters'))
+                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
+                instData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))
                 if len(data) == len(instData):                          #don't mix lam & lam1/lam2 parms!
                     for i,item in enumerate(data[1:]):                  #skip default values in tuple
@@ -620 +622 @@
             data[2] = data[2][:2]+data[2][4:]
             data[3] = data[3][:1]+['Lam',]+data[3][4:]            
-        UpdateInstrumentGrid(self,data)
+        UpdateInstrumentGrid(G2frame,data)
                 
     def OnNewType(event):
         insVal['Type'] = typePick.GetValue()
         data = updateData(insVal,insRef)
-        UpdateInstrumentGrid(self,data)
+        UpdateInstrumentGrid(G2frame,data)
         
     def OnLamPick(event):
@@ -632 +634 @@
         insVal['Lam2'] = waves[lamType][1]
         data = updateData(insVal,insRef)
-        UpdateInstrumentGrid(self,data)
+        UpdateInstrumentGrid(G2frame,data)
                  
     def OnRatValue(event):
@@ -681 +683 @@
         data = updateData(insVal,insRef)
                 
-    if self.dataDisplay:
-        self.dataFrame.Clear()
-    histoName = self.PatternTree.GetItemPyData(self.PatternId)[-1]
-    ifHisto = IsHistogramInAnyPhase(self,histoName)
-    self.dataFrame.SetMenuBar(self.dataFrame.BlankMenu)
-    self.dataFrame.SetLabel('Instrument Parameters')
-    self.dataDisplay = wx.Panel(self.dataFrame)
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
+    histoName = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[-1]
+    ifHisto = IsHistogramInAnyPhase(G2frame,histoName)
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
+    G2frame.dataFrame.SetLabel('Instrument Parameters')
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     instSizer = wx.FlexGridSizer(2,6,5,5)
-    instSizer.Add(wx.StaticText(self.dataDisplay,-1,' Histogram Type:'),0,wx.ALIGN_CENTER_VERTICAL)
+    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Histogram Type:'),0,wx.ALIGN_CENTER_VERTICAL)
     if 'P' in insVal['Type']:                   #powder data
-        self.dataFrame.SetMenuBar(self.dataFrame.InstMenu)
-        if not self.dataFrame.GetStatusBar():
-            Status = self.dataFrame.CreateStatusBar()
-        self.Bind(wx.EVT_MENU,OnReset,id=G2gd.wxID_INSTPRMRESET)
-        self.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
-        self.Bind(wx.EVT_MENU,OnWaveChange,id=G2gd.wxID_CHANGEWAVETYPE)        
-        typePick = wx.ComboBox(self.dataDisplay,value=insVal['Type'],
+        G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.InstMenu)
+        if not G2frame.dataFrame.GetStatusBar():
+            Status = G2frame.dataFrame.CreateStatusBar()
+        G2frame.Bind(wx.EVT_MENU,OnReset,id=G2gd.wxID_INSTPRMRESET)
+        G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
+        G2frame.Bind(wx.EVT_MENU,OnWaveChange,id=G2gd.wxID_CHANGEWAVETYPE)        
+        typePick = wx.ComboBox(G2frame.dataDisplay,value=insVal['Type'],
             choices=['PXC','PNC','PNT'],style=wx.CB_READONLY|wx.CB_DROPDOWN)
         typePick.Bind(wx.EVT_COMBOBOX, OnNewType)
@@ -708 +710 @@
                 insRef['Azimuth'] = False
             #end of patch
-            instSizer.Add(wx.StaticText(self.dataDisplay,-1,' Azimuth: %7.2f'%(insVal['Azimuth'])),0,wx.ALIGN_CENTER_VERTICAL)
+            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: %7.2f'%(insVal['Azimuth'])),0,wx.ALIGN_CENTER_VERTICAL)
             if 'Lam1' in insVal:
                 instSizer.Add((5,5),0)
                 instSizer.Add((5,5),0)
                 instSizer.Add((5,5),0)
-                instSizer.Add(wx.StaticText(self.dataDisplay,-1,' Ka1/Ka2:'),
+                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Ka1/Ka2:'),
                         0,wx.ALIGN_CENTER_VERTICAL)
-                instSizer.Add(wx.StaticText(self.dataDisplay,-1,'%8.6f/%8.6f'%(insVal['Lam1'],insVal['Lam2'])),
+                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'%8.6f/%8.6f'%(insVal['Lam1'],insVal['Lam2'])),
                         0,wx.ALIGN_CENTER_VERTICAL)
                 waveSizer = wx.BoxSizer(wx.HORIZONTAL)
-                waveSizer.Add(wx.StaticText(self.dataDisplay,-1,'Select:'),0,wx.ALIGN_CENTER_VERTICAL)
+                waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'Select:'),0,wx.ALIGN_CENTER_VERTICAL)
                 choice = ['TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
-                lamPick = wx.ComboBox(self.dataDisplay,value=' ',choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
+                lamPick = wx.ComboBox(G2frame.dataDisplay,value=' ',choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
                 lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
                 waveSizer.Add(lamPick,0)
                 instSizer.Add(waveSizer,0)
-                instSizer.Add(wx.StaticText(self.dataDisplay,-1,' I(L2)/I(L1): (%10.4f)'%(insDef['I(L2)/I(L1)'])),
+                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' I(L2)/I(L1): (%10.4f)'%(insDef['I(L2)/I(L1)'])),
                         0,wx.ALIGN_CENTER_VERTICAL)
-                ratVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,'%10.4f'%(insVal['I(L2)/I(L1)']),style=wx.TE_PROCESS_ENTER)
+                ratVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.4f'%(insVal['I(L2)/I(L1)']),style=wx.TE_PROCESS_ENTER)
                 ratVal.Bind(wx.EVT_TEXT_ENTER,OnRatValue)
                 ratVal.Bind(wx.EVT_KILL_FOCUS,OnRatValue)
                 instSizer.Add(ratVal,0)
-                ratRef = wx.CheckBox(self.dataDisplay,label=' Refine?')
+                ratRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
                 ratRef.SetValue(bool(insRef['I(L2)/I(L1)']))
                 ratRef.Bind(wx.EVT_CHECKBOX, OnRatRef)
@@ -736 +738 @@
                 
             else:
-                instSizer.Add(wx.StaticText(self.dataDisplay,-1,' Lam: (%10.6f)'%(insDef['Lam'])),
+                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Lam: (%10.6f)'%(insDef['Lam'])),
                     0,wx.ALIGN_CENTER_VERTICAL)
-                waveVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
+                waveVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,'%10.6f'%(insVal['Lam']),style=wx.TE_PROCESS_ENTER)
                 waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveValue)
                 waveVal.Bind(wx.EVT_KILL_FOCUS,OnWaveValue)
                 instSizer.Add(waveVal,0,wx.ALIGN_CENTER_VERTICAL)
                 if ifHisto:
-                    waveRef = wx.CheckBox(self.dataDisplay,label=' Refine?')
+                    waveRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
                     waveRef.SetValue(bool(insRef['Lam']))
                     waveRef.Bind(wx.EVT_CHECKBOX, OnWaveRef)
@@ -753 +755 @@
                 Fmt = ' %s: ('+fmt+')'
                 if item in insDef:
-                    instSizer.Add(wx.StaticText(self.dataDisplay,-1,Fmt%(item,insDef[item])),
+                    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
                             0,wx.ALIGN_CENTER_VERTICAL)
-                    itemVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
+                    itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
                     ValObj[itemVal.GetId()] = [item,fmt]
                     itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
@@ -761 +763 @@
                     instSizer.Add(itemVal,0,wx.ALIGN_CENTER_VERTICAL)
                     if ifHisto:
-                        itemRef = wx.CheckBox(self.dataDisplay,wx.ID_ANY,label=' Refine?')
+                        itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
                         itemRef.SetValue(bool(insRef[item]))
                         RefObj[itemRef.GetId()] = item
@@ -777 +779 @@
                     fmt = '%10.5f'
                 Fmt = ' %s: ('+fmt+')'
-                instSizer.Add(wx.StaticText(self.dataDisplay,-1,Fmt%(item,insDef[item])),
+                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,Fmt%(item,insDef[item])),
                         0,wx.ALIGN_CENTER_VERTICAL)
-                itemVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
+                itemVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,fmt%(insVal[item]),style=wx.TE_PROCESS_ENTER)
                 ValObj[itemVal.GetId()] = [item,fmt]
                 itemVal.Bind(wx.EVT_TEXT_ENTER,OnItemValue)
                 itemVal.Bind(wx.EVT_KILL_FOCUS,OnItemValue)
                 instSizer.Add(itemVal,0,wx.ALIGN_CENTER_VERTICAL)
-                itemRef = wx.CheckBox(self.dataDisplay,wx.ID_ANY,label=' Refine?')
+                itemRef = wx.CheckBox(G2frame.dataDisplay,wx.ID_ANY,label=' Refine?')
                 itemRef.SetValue(bool(insRef[item]))
                 RefObj[itemRef.GetId()] = item
@@ -795 +797 @@
 
     else:                       #single crystal data
-        typePick = wx.ComboBox(self.dataDisplay,value=insVal['Type'],
+        typePick = wx.ComboBox(G2frame.dataDisplay,value=insVal['Type'],
             choices=['SXC','SNC','SNT'],style=wx.CB_READONLY|wx.CB_DROPDOWN)
         typePick.Bind(wx.EVT_COMBOBOX, OnNewType)
         instSizer.Add(typePick,0,wx.ALIGN_CENTER_VERTICAL)
         if 'C' in insVal['Type']:               #constant wavelength
-            instSizer.Add(wx.StaticText(self.dataDisplay,-1,' Lam: %10.6f'%(insDef['Lam'])),
+            instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Lam: %10.6f'%(insDef['Lam'])),
                     0,wx.ALIGN_CENTER_VERTICAL)
         else:                                   #time of flight (neutrons)
@@ -808 +810 @@
     mainSizer.Add(instSizer,0)
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    self.dataFrame.setSizePosLeft(mainSizer.Fit(self.dataFrame))
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
     
-def UpdateSampleGrid(self,data):
+def UpdateSampleGrid(G2frame,data):
     
     def OnSampleCopy(event):
-        histName = self.PatternTree.GetItemText(self.PatternId)
+        histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
         copyNames = ['Scale',]
         dataType = data['Type']
@@ -829 +831 @@
             copyDict[parm] = data[parm]
         histList = ['All '+histType,]
-        item, cookie = self.PatternTree.GetFirstChild(self.root)
+        item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
         while item:
-            name = self.PatternTree.GetItemText(item)
+            name = G2frame.PatternTree.GetItemText(item)
             if histType in name and name != histName:
                 histList.append(name)
-            item, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+            item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
         if len(histList) == 1:      #nothing to copy to!
             return
         copyList = []
-        dlg = wx.MultiChoiceDialog(self,'Copy parameters from\n'+histName,
+        dlg = wx.MultiChoiceDialog(G2frame,'Copy parameters from\n'+histName,
             'Copy parameters to which histograms?',histList,wx.CHOICEDLG_STYLE)
         try:
@@ -848 +850 @@
                     copyList = histList[1:]
             for item in copyList:
-                Id = G2gd.GetPatternTreeItemId(self,self.root,item)
-                sampleData = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,Id,'Sample Parameters'))
+                Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
+                sampleData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
                 sampleData.update(copy.deepcopy(copyDict))
         finally:
             dlg.Destroy()
 
-    if self.dataDisplay:
-        self.dataFrame.Clear()
-    self.dataFrame.SetMenuBar(self.dataFrame.SampleMenu)
-    self.dataFrame.SetLabel('Sample Parameters')
-    self.Bind(wx.EVT_MENU, OnSampleCopy, id=G2gd.wxID_SAMPLECOPY)
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()    
-    self.dataDisplay = wx.Panel(self.dataFrame)
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.SampleMenu)
+    G2frame.dataFrame.SetLabel('Sample Parameters')
+    G2frame.Bind(wx.EVT_MENU, OnSampleCopy, id=G2gd.wxID_SAMPLECOPY)
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()    
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
 
 #patch
@@ -908 +910 @@
             data['Shift'] = [0.0,False]
             data['Transparency'] = [0.0,False]
-        self.dataDisplay.Destroy()
-        UpdateSampleGrid(self,data)
+        G2frame.dataDisplay.Destroy()
+        UpdateSampleGrid(G2frame,data)
         
     def OnParmRef(event):
@@ -932 +934 @@
                 
     mainSizer = wx.BoxSizer(wx.VERTICAL)
-    mainSizer.Add(wx.StaticText(self.dataDisplay,label=' Sample parameters: '),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample parameters: '),0,wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)
     parmSizer = wx.FlexGridSizer(9,2,5,0)
-    scaleRef = wx.CheckBox(self.dataDisplay,label=' Histogram scale factor: ')
+    scaleRef = wx.CheckBox(G2frame.dataDisplay,label=' Histogram scale factor: ')
     scaleRef.SetValue(data['Scale'][1])
     scaleRef.Bind(wx.EVT_CHECKBOX, OnScaleRef)
     parmSizer.Add(scaleRef,0,wx.ALIGN_CENTER_VERTICAL)
-    scaleVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,
+    scaleVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,
         '%.4f'%(data['Scale'][0]),style=wx.TE_PROCESS_ENTER)
     scaleVal.Bind(wx.EVT_TEXT_ENTER,OnScaleVal)
@@ -946 +948 @@
     typeSizer = wx.BoxSizer(wx.HORIZONTAL)
     choices = ['Debye-Scherrer','Bragg-Brentano',]
-    histoType = wx.ComboBox(self.dataDisplay,wx.ID_ANY,value=data['Type'],choices=choices,
+    histoType = wx.ComboBox(G2frame.dataDisplay,wx.ID_ANY,value=data['Type'],choices=choices,
         style=wx.CB_READONLY|wx.CB_DROPDOWN)
     histoType.Bind(wx.EVT_COMBOBOX, OnHistoType)
@@ -954 +956 @@
     for parm in parms:
         if 'list' in str(type(data[parm[0]])):
-            parmRef = wx.CheckBox(self.dataDisplay,label=parm[1])
+            parmRef = wx.CheckBox(G2frame.dataDisplay,label=parm[1])
             objList[parmRef.GetId()] = parm[0]
             parmRef.SetValue(data[parm[0]][1])
             parmRef.Bind(wx.EVT_CHECKBOX, OnParmRef)
             parmSizer.Add(parmRef,0,wx.ALIGN_CENTER_VERTICAL)
-            parmVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,
+            parmVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,
                 parm[2]%(data[parm[0]][0]),style=wx.TE_PROCESS_ENTER)
         else:
-            parmSizer.Add(wx.StaticText(self.dataDisplay,label=parm[1]),
+            parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=parm[1]),
                 0,wx.ALIGN_CENTER_VERTICAL)
-            parmVal = wx.TextCtrl(self.dataDisplay,wx.ID_ANY,
+            parmVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,
                 parm[2]%(data[parm[0]]),style=wx.TE_PROCESS_ENTER)        
         objList[parmVal.GetId()] = parm
@@ -974 +976 @@
     
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    Size = mainSizer.Fit(self.dataFrame)
-    self.dataDisplay.SetSize(Size)
-    self.dataFrame.setSizePosLeft(Size)
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    Size = mainSizer.Fit(G2frame.dataFrame)
+    G2frame.dataDisplay.SetSize(Size)
+    G2frame.dataFrame.setSizePosLeft(Size)
                 
-def UpdateIndexPeaksGrid(self, data):
-    IndexId = G2gd.GetPatternTreeItemId(self,self.PatternId, 'Index Peak List')
-    inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Instrument Parameters'))
+def UpdateIndexPeaksGrid(G2frame, data):
+    IndexId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List')
+    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
     Inst = dict(zip(inst[3],inst[1]))
     try:
@@ -990 +992 @@
     def RefreshIndexPeaksGrid(event):
         r,c =  event.GetRow(),event.GetCol()
-        data = self.IndexPeaksTable.GetData()
+        data = G2frame.IndexPeaksTable.GetData()
         if c == 2:
             if data[r][c]:
@@ -996 +998 @@
             else:
                 data[r][c] = True
-            self.IndexPeaksTable.SetData(data)
-            self.PatternTree.SetItemPyData(IndexId,data)
-            self.dataDisplay.ForceRefresh()
+            G2frame.IndexPeaksTable.SetData(data)
+            G2frame.PatternTree.SetItemPyData(IndexId,data)
+            G2frame.dataDisplay.ForceRefresh()
             
     def OnReload(event):
         data = []
-        peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Peak List'))
+        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Peak List'))
         for peak in peaks:
             dsp = wave/(2.0*sind((peak[0]-Inst['Zero'])/2.0))
             data.append([peak[0],peak[2],True,False,0,0,0,dsp,0.0])
-        self.PatternTree.SetItemPyData(IndexId,data)
-        UpdateIndexPeaksGrid(self,data)
+        G2frame.PatternTree.SetItemPyData(IndexId,data)
+        UpdateIndexPeaksGrid(G2frame,data)
         
     def KeyEditPickGrid(event):
-        colList = self.dataDisplay.GetSelectedCols()
-        rowList = self.dataDisplay.GetSelectedRows()
-        data = self.PatternTree.GetItemPyData(IndexId)
+        colList = G2frame.dataDisplay.GetSelectedCols()
+        rowList = G2frame.dataDisplay.GetSelectedRows()
+        data = G2frame.PatternTree.GetItemPyData(IndexId)
         if event.GetKeyCode() == wx.WXK_RETURN:
             event.Skip(True)
@@ -1020 +1022 @@
             event.Skip(True)
         elif colList:
-            self.dataDisplay.ClearSelection()
+            G2frame.dataDisplay.ClearSelection()
             key = event.GetKeyCode()
             for col in colList:
-                if self.IndexPeaksTable.GetColLabelValue(col) in ['use','refine']:
+                if G2frame.IndexPeaksTable.GetColLabelValue(col) in ['use','refine']:
                     if key == 89: #'Y'
-                        for row in range(self.IndexPeaksTable.GetNumberRows()): data[row][col]=True
+                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=True
                     elif key == 78:  #'N'
-                        for row in range(self.IndexPeaksTable.GetNumberRows()): data[row][col]=False
+                        for row in range(G2frame.IndexPeaksTable.GetNumberRows()): data[row][col]=False
             
-    if self.dataDisplay:
-        self.dataFrame.Clear()
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
-    if 'PWD' in self.PatternTree.GetItemText(self.PatternId):
-        self.dataFrame.SetMenuBar(self.dataFrame.IndPeaksMenu)
-        self.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
-    self.dataFrame.IndexPeaks.Enable(False)
-    self.IndexPeaksTable = []
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
+    if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
+        G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.IndPeaksMenu)
+        G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
+    G2frame.dataFrame.IndexPeaks.Enable(False)
+    G2frame.IndexPeaksTable = []
     if data:
-        self.dataFrame.IndexPeaks.Enable(True)
-        cells = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Unit Cells List'))
+        G2frame.dataFrame.IndexPeaks.Enable(True)
+        cells = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
         if cells:
             cellist = cells[2]
             dmin = cells[3]
-            self.HKL = []
+            G2frame.HKL = []
             for i,cell in enumerate(cellist):
                 if cell[-1]:
                     ibrav = cell[2]
                     A = G2lat.cell2A(cell[3:9])
-                    self.HKL = G2lat.GenHBravais(dmin,ibrav,A)
-                    G2indx.IndexPeaks(data,self.HKL)
-                    for hkl in self.HKL:
+                    G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
+                    G2indx.IndexPeaks(data,G2frame.HKL)
+                    for hkl in G2frame.HKL:
                         hkl.append(2.0*asind(wave/(2.*hkl[3]))+Inst['Zero'])             
     rowLabels = []
@@ -1059 +1061 @@
         wg.GRID_VALUE_BOOL,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,wg.GRID_VALUE_LONG,
         wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_FLOAT+':10,5']
-    self.PatternTree.SetItemPyData(IndexId,data)
-    self.IndexPeaksTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-    self.dataFrame.SetLabel('Index Peak List')
-    self.dataDisplay = G2gd.GSGrid(parent=self.dataFrame)                
-    self.dataDisplay.SetTable(self.IndexPeaksTable, True)
-    for r in range(self.dataDisplay.GetNumberRows()):
-        for c in range(self.dataDisplay.GetNumberCols()):
+    G2frame.PatternTree.SetItemPyData(IndexId,data)
+    G2frame.IndexPeaksTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+    G2frame.dataFrame.SetLabel('Index Peak List')
+    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)                
+    G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
+    for r in range(G2frame.dataDisplay.GetNumberRows()):
+        for c in range(G2frame.dataDisplay.GetNumberCols()):
             if c == 2:
-                self.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
+                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
             else:
-                self.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
-    self.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
-    self.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
-    self.dataDisplay.SetMargins(0,0)
-    self.dataDisplay.AutoSizeColumns(False)
-    self.dataFrame.setSizePosLeft([490,300])
+                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
+    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
+    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
+    G2frame.dataDisplay.SetMargins(0,0)
+    G2frame.dataDisplay.AutoSizeColumns(False)
+    G2frame.dataFrame.setSizePosLeft([490,300])
   
-def UpdateUnitCellsGrid(self, data):
-    UnitCellsId = G2gd.GetPatternTreeItemId(self,self.PatternId, 'Unit Cells List')
+def UpdateUnitCellsGrid(G2frame, data):
+    UnitCellsId = G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List')
     bravaisSymb = ['Fm3m','Im3m','Pm3m','R3-H','P6/mmm','I4/mmm',
         'P4/mmm','Fmmm','Immm','Cmmm','Pmmm','C2/m','P2/m','P1']
     spaceGroups = ['F m 3 m','I m 3 m','P m 3 m','R -3 H','P 6/m m m','I 4/m m m',
         'P 4/m m m','F m m m','I m m m','C m m m','P m m m','C 2/m','P 2/m','P -1']
-    inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Instrument Parameters'))
+    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))
     Inst = dict(zip(inst[3],inst[1]))
     if 'Lam' in Inst:
@@ -1137 +1139 @@
     def OnBravSel(event):
         controls[5] = bravSel.GetString(bravSel.GetSelection())       
-        UpdateUnitCellsGrid(self,data)
+        UpdateUnitCellsGrid(G2frame,data)
         
     def OnCellChange(event):
@@ -1186 +1188 @@
         
     def OnHklShow(event):
-        PatternId = self.PatternId
-        PickId = self.PickId    
-        limits = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Limits'))[1]
-        controls,bravais,cells,dmin = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Unit Cells List'))
+        PatternId = G2frame.PatternId
+        PickId = G2frame.PickId    
+        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
+        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
         cell = controls[6:12]
         A = G2lat.cell2A(cell)
         ibrav = bravaisSymb.index(controls[5])
         dmin = wave/(2.0*sind(limits[1]/2.0))
-        self.HKL = G2lat.GenHBravais(dmin,ibrav,A)
-        for hkl in self.HKL:
+        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
+        for hkl in G2frame.HKL:
             hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
-        if 'PKS' in self.PatternTree.GetItemText(self.PatternId):
-            G2plt.PlotPowderLines(self)
+        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
+            G2plt.PlotPowderLines(G2frame)
         else:
-            G2plt.PlotPatterns(self)
+            G2plt.PlotPatterns(G2frame)
             
     def OnSortCells(event):
-        controls,bravais,cells,dmin = self.PatternTree.GetItemPyData(UnitCellsId)
+        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
         c =  event.GetCol()
         if colLabels[c] == 'M20':
@@ -1212 +1214 @@
             return
         data = [controls,bravais,cells,dmin]
-        self.PatternTree.SetItemPyData(UnitCellsId,data)
-        UpdateUnitCellsGrid(self,data)
+        G2frame.PatternTree.SetItemPyData(UnitCellsId,data)
+        UpdateUnitCellsGrid(G2frame,data)
         
     def CopyUnitCell(event):
-        controls,bravais,cells,dmin = self.PatternTree.GetItemPyData(UnitCellsId)
+        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)
         for Cell in cells:
             if Cell[-1]:
@@ -1225 +1227 @@
         controls[6:12] = cell[1:8]
         controls[12] = G2lat.calc_V(G2lat.cell2A(controls[6:12]))
-        self.PatternTree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin])
-        UpdateUnitCellsGrid(self,data)
-        
-        self.dataFrame.RefineCell.Enable(True)
+        G2frame.PatternTree.SetItemPyData(UnitCellsId,[controls,bravais,cells,dmin])
+        UpdateUnitCellsGrid(G2frame,data)
+        
+        G2frame.dataFrame.RefineCell.Enable(True)
                 
     def RefineCell(event):
@@ -1246 +1248 @@
                 print "%s%8.3f %s%8.3f %s%8.3f %s%12.3f" % ('alpha =',cell[3],'beta =',cell[4],'gamma =',cell[5],' volume =',Vol)
              
-        PatternId = self.PatternId
-        PickId = self.PickId    
-        peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Index Peak List'))
+        PatternId = G2frame.PatternId
+        PickId = G2frame.PickId    
+        peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Index Peak List'))
         if not peaks:
-            self.ErrorDialog('No peaks!', 'Nothing to refine!')
+            G2frame.ErrorDialog('No peaks!', 'Nothing to refine!')
             return        
         print 'Refine cell'
-        controls,bravais,cells,dmin = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Unit Cells List'))
+        controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
         cell = controls[6:12]
         A = G2lat.cell2A(cell)
         ibrav = bravaisSymb.index(controls[5])
         dmin = G2indx.getDmin(peaks)-0.005
-        self.HKL = G2lat.GenHBravais(dmin,ibrav,A)
-        G2indx.IndexPeaks(peaks,self.HKL)
+        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
+        G2indx.IndexPeaks(peaks,G2frame.HKL)
         Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksZ(peaks,wave,ibrav,A,controls[1],controls[0])            
         controls[1] = Zero
@@ -1265 +1267 @@
         controls[12] = G2lat.calc_V(Aref)
         data = [controls,bravais,cells,dmin]
-        cells = self.PatternTree.GetItemPyData(UnitCellsId)[2]
+        cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
         for cell in cells:
             cell[-1] = False
         cells.insert(0,[M20,X20,ibrav]+controls[6:13]+[True,])
-        self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Unit Cells List'),data)
-        self.HKL = G2lat.GenHBravais(dmin,ibrav,Aref)
-        UpdateUnitCellsGrid(self,data)
+        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
+        G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,Aref)
+        UpdateUnitCellsGrid(G2frame,data)
         print "%s%10.3f" % ('refinement M20 = ',M20)
         print 'unindexed lines = ',X20
         cellPrint(ibrav,Aref)
-        for hkl in self.HKL:
+        for hkl in G2frame.HKL:
             hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
-        if 'PKS' in self.PatternTree.GetItemText(self.PatternId):
-            G2plt.PlotPowderLines(self)
+        if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
+            G2plt.PlotPowderLines(G2frame)
         else:
-            G2plt.PlotPatterns(self)
+            G2plt.PlotPatterns(G2frame)
         
     def IndexPeaks(event):
-        PatternId = self.PatternId    
+        PatternId = G2frame.PatternId    
         print 'Peak Indexing'
         try:
-            controls,bravais,cells,dmin = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Unit Cells List'))
+            controls,bravais,cells,dmin = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'))
             cells = []
         except ValueError:
-            self.ErrorDialog('Error','Need to set controls in Unit Cell List first')
+            G2frame.ErrorDialog('Error','Need to set controls in Unit Cell List first')
             return
         if True not in bravais:
-            self.ErrorDialog('Error','No Bravais lattices selected')
+            G2frame.ErrorDialog('Error','No Bravais lattices selected')
             return
-        self.dataFrame.CopyCell.Enable(False)
-        self.dataFrame.RefineCell.Enable(False)
+        G2frame.dataFrame.CopyCell.Enable(False)
+        G2frame.dataFrame.RefineCell.Enable(False)
         OK,dmin,cells = G2indx.DoIndexPeaks(peaks,inst[1],controls,bravais)
         if OK:
             data = [controls,bravais,cells,dmin]
-            self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,PatternId, 'Unit Cells List'),data)
-            UpdateUnitCellsGrid(self,data)
+            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
+            UpdateUnitCellsGrid(G2frame,data)
             bestCell = cells[0]
             if bestCell[0] > 10.:
-                self.HKL = G2lat.GenHBravais(dmin,bestCell[2],G2lat.cell2A(bestCell[3:9]))
-                for hkl in self.HKL:
+                G2frame.HKL = G2lat.GenHBravais(dmin,bestCell[2],G2lat.cell2A(bestCell[3:9]))
+                for hkl in G2frame.HKL:
                     hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
-                if 'PKS' in self.PatternTree.GetItemText(self.PatternId):
-                    G2plt.PlotPowderLines(self)
+                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
+                    G2plt.PlotPowderLines(G2frame)
                 else:
-                    G2plt.PlotPatterns(self)
-            self.dataFrame.CopyCell.Enable(True)
-            self.dataFrame.IndexPeaks.Enable(True)
-            self.dataFrame.MakeNewPhase.Enable(True)
-            UpdateUnitCellsGrid(self,data)
+                    G2plt.PlotPatterns(G2frame)
+            G2frame.dataFrame.CopyCell.Enable(True)
+            G2frame.dataFrame.IndexPeaks.Enable(True)
+            G2frame.dataFrame.MakeNewPhase.Enable(True)
+            UpdateUnitCellsGrid(G2frame,data)
                 
     def RefreshUnitCellsGrid(event):
-        cells,dmin = self.PatternTree.GetItemPyData(UnitCellsId)[2:]
+        cells,dmin = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2:]
         r,c =  event.GetRow(),event.GetCol()
         if cells:
@@ -1328 +1330 @@
                 ibrav = cells[r][2]
                 A = G2lat.cell2A(cells[r][3:9])
-                self.HKL = G2lat.GenHBravais(dmin,ibrav,A)
-                for hkl in self.HKL:
+                G2frame.HKL = G2lat.GenHBravais(dmin,ibrav,A)
+                for hkl in G2frame.HKL:
                     hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
-                if 'PKS' in self.PatternTree.GetItemText(self.PatternId):
-                    G2plt.PlotPowderLines(self)
+                if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
+                    G2plt.PlotPowderLines(G2frame)
                 else:
-                    G2plt.PlotPatterns(self)
+                    G2plt.PlotPatterns(G2frame)
         
     def MakeNewPhase(event):
-        if not G2gd.GetPatternTreeItemId(self,self.root,'Phases'):
-            sub = self.PatternTree.AppendItem(parent=self.root,text='Phases')
+        if not G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'):
+            sub = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Phases')
         else:
-            sub = G2gd.GetPatternTreeItemId(self,self.root,'Phases')
+            sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases')
         PhaseName = ''
         dlg = wx.TextEntryDialog(None,'Enter a name for this phase','Phase Name Entry','New phase',
@@ -1347 +1349 @@
             if dlg.ShowModal() == wx.ID_OK:
                 PhaseName = dlg.GetValue()
-                cells = self.PatternTree.GetItemPyData(UnitCellsId)[2]
+                cells = G2frame.PatternTree.GetItemPyData(UnitCellsId)[2]
                 for Cell in cells:
                     if Cell[-1]:
                         break
                 cell = Cell[2:10]        
-                sub = self.PatternTree.AppendItem(parent=sub,text=PhaseName)
+                sub = G2frame.PatternTree.AppendItem(parent=sub,text=PhaseName)
                 E,SGData = G2spc.SpcGroup(spaceGroups[cell[0]])
-                self.PatternTree.SetItemPyData(sub, \
+                G2frame.PatternTree.SetItemPyData(sub, \
                     {'General':{'Name':PhaseName,'Type':'nuclear','SGData':SGData,
                     'Cell':[False,]+cell[1:],
@@ -1362 +1364 @@
             dlg.Destroy()
             
-    if self.dataDisplay:
-        self.dataFrame.Clear()
-    self.dataFrame.SetMenuBar(self.dataFrame.IndexMenu)
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()
-    self.Bind(wx.EVT_MENU, IndexPeaks, id=G2gd.wxID_INDEXPEAKS)
-    self.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
-    self.Bind(wx.EVT_MENU, RefineCell, id=G2gd.wxID_REFINECELL)
-    self.Bind(wx.EVT_MENU, MakeNewPhase, id=G2gd.wxID_MAKENEWPHASE)
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.IndexMenu)
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()
+    G2frame.Bind(wx.EVT_MENU, IndexPeaks, id=G2gd.wxID_INDEXPEAKS)
+    G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
+    G2frame.Bind(wx.EVT_MENU, RefineCell, id=G2gd.wxID_REFINECELL)
+    G2frame.Bind(wx.EVT_MENU, MakeNewPhase, id=G2gd.wxID_MAKENEWPHASE)
     
     controls,bravais,cells,dmin = data
     if len(controls) < 13:              #add cell volume if missing
         controls.append(G2lat.calc_V(G2lat.cell2A(controls[6:12])))
-    self.PatternTree.SetItemPyData(UnitCellsId,data)            #update with volume
+    G2frame.PatternTree.SetItemPyData(UnitCellsId,data)            #update with volume
     bravaisNames = ['Cubic-F','Cubic-I','Cubic-P','Trigonal-R','Trigonal/Hexagonal-P',
         'Tetragonal-I','Tetragonal-P','Orthorhombic-F','Orthorhombic-I','Orthorhombic-C',
@@ -1389 +1391 @@
         [True,True,True,False,True,True,True],[0,1,2,0,3,4,5])]]
     
-    self.dataFrame.SetLabel('Unit Cells List')
-    self.sp = wx.SplitterWindow(self.dataFrame)
-    self.dataDisplay = wx.Panel(self.sp, style=wx.SUNKEN_BORDER)
-    self.dataFrame.IndexPeaks.Enable(False)
-    peaks = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.PatternId, 'Index Peak List'))
+    G2frame.dataFrame.SetLabel('Unit Cells List')
+    G2frame.sp = wx.SplitterWindow(G2frame.dataFrame)
+    G2frame.dataDisplay = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
+    G2frame.dataFrame.IndexPeaks.Enable(False)
+    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
     if peaks:
-        self.dataFrame.IndexPeaks.Enable(True)
-    self.dataFrame.RefineCell.Enable(False)
+        G2frame.dataFrame.IndexPeaks.Enable(True)
+    G2frame.dataFrame.RefineCell.Enable(False)
     if controls[12] > 1.0:                               #if a "real" volume (i.e. not default)
-        self.dataFrame.RefineCell.Enable(True)    
-    self.dataFrame.CopyCell.Enable(False)
-    self.dataFrame.MakeNewPhase.Enable(False)        
+        G2frame.dataFrame.RefineCell.Enable(True)    
+    G2frame.dataFrame.CopyCell.Enable(False)
+    G2frame.dataFrame.MakeNewPhase.Enable(False)        
     if cells:
-        self.bottom = wx.Panel(self.sp, style=wx.SUNKEN_BORDER)
-        self.sp.SplitHorizontally(self.dataDisplay,self.bottom,0)
-        self.dataFrame.CopyCell.Enable(True)
-        self.dataFrame.MakeNewPhase.Enable(True)        
+        G2frame.bottom = wx.Panel(G2frame.sp, style=wx.SUNKEN_BORDER)
+        G2frame.sp.SplitHorizontally(G2frame.dataDisplay,G2frame.bottom,0)
+        G2frame.dataFrame.CopyCell.Enable(True)
+        G2frame.dataFrame.MakeNewPhase.Enable(True)        
     mainSizer = wx.BoxSizer(wx.VERTICAL)
-    mainSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Indexing controls: '),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Indexing controls: '),0,wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)
     littleSizer = wx.FlexGridSizer(2,5,5,5)
-    littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Max Nc/Nobs '),0,wx.ALIGN_CENTER_VERTICAL)
-    NcNo = wx.SpinCtrl(self.dataDisplay)
+    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max Nc/Nobs '),0,wx.ALIGN_CENTER_VERTICAL)
+    NcNo = wx.SpinCtrl(G2frame.dataDisplay)
     NcNo.SetRange(1,6)
     NcNo.SetValue(controls[2])
     NcNo.Bind(wx.EVT_SPINCTRL,OnNcNo)
     littleSizer.Add(NcNo,0,wx.ALIGN_CENTER_VERTICAL)
-    littleSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Start Volume '),0,wx.ALIGN_CENTER_VERTICAL)
-    startVol = wx.TextCtrl(self.dataDisplay,value=str('%d'%(controls[3])),style=wx.TE_PROCESS_ENTER)
+    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start Volume '),0,wx.ALIGN_CENTER_VERTICAL)
+    startVol = wx.TextCtrl(G2frame.dataDisplay,value=str('%d'%(controls[3])),style=wx.TE_PROCESS_ENTER)
     startVol.Bind(wx.EVT_TEXT_ENTER,OnStartVol)
     startVol.Bind(wx.EVT_KILL_FOCUS,OnStartVol)
@@ -1423 +1425 @@
     mainSizer.Add(littleSizer,0)
     mainSizer.Add((5,5),0)
-    mainSizer.Add(wx.StaticText(self.dataDisplay,label=' Select Bravais Lattices for indexing: '),
+    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Select Bravais Lattices for indexing: '),
         0,wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)
@@ -1430 +1432 @@
     bravs = zip(bravais,bravaisNames)
     for brav,bravName in bravs:
-        bravCk = wx.CheckBox(self.dataDisplay,label=bravName)
+        bravCk = wx.CheckBox(G2frame.dataDisplay,label=bravName)
         bravList.append(bravCk.GetId())
         bravCk.SetValue(brav)
@@ -1438 +1440 @@
     mainSizer.Add((5,5),0)
     
-    mainSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' Cell Refinement: '),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Cell Refinement: '),0,wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)
     littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-    littleSizer.Add(wx.StaticText(self.dataDisplay,label=" Bravais lattice "),0,wx.ALIGN_CENTER_VERTICAL)
-    bravSel = wx.Choice(self.dataDisplay,choices=bravaisSymb)
+    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Bravais lattice "),0,wx.ALIGN_CENTER_VERTICAL)
+    bravSel = wx.Choice(G2frame.dataDisplay,choices=bravaisSymb)
     bravSel.SetSelection(bravaisSymb.index(controls[5]))
     bravSel.Bind(wx.EVT_CHOICE,OnBravSel)
     littleSizer.Add(bravSel,0,wx.ALIGN_CENTER_VERTICAL)
-    littleSizer.Add(wx.StaticText(self.dataDisplay,label=" Zero offset"),0,wx.ALIGN_CENTER_VERTICAL)
-    zero = wx.TextCtrl(self.dataDisplay,value="%.4f"%(controls[1]),style=wx.TE_PROCESS_ENTER)
+    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Zero offset"),0,wx.ALIGN_CENTER_VERTICAL)
+    zero = wx.TextCtrl(G2frame.dataDisplay,value="%.4f"%(controls[1]),style=wx.TE_PROCESS_ENTER)
     zero.Bind(wx.EVT_TEXT_ENTER,OnZero)
     zero.Bind(wx.EVT_KILL_FOCUS,OnZero)
     littleSizer.Add(zero,0,wx.ALIGN_CENTER_VERTICAL)
-    zeroVar = wx.CheckBox(self.dataDisplay,label="Refine?")
+    zeroVar = wx.CheckBox(G2frame.dataDisplay,label="Refine?")
     zeroVar.SetValue(controls[0])
     zeroVar.Bind(wx.EVT_CHECKBOX,OnZeroVar)
     littleSizer.Add(zeroVar,0,wx.ALIGN_CENTER_VERTICAL)
-    hklShow = wx.Button(self.dataDisplay,label="Show refined hkl positions + Zero offset")
+    hklShow = wx.Button(G2frame.dataDisplay,label="Show refined hkl positions + Zero offset")
     hklShow.Bind(wx.EVT_BUTTON,OnHklShow)
     littleSizer.Add(hklShow,0,wx.ALIGN_CENTER_VERTICAL)
@@ -1468 +1470 @@
     littleSizer = wx.FlexGridSizer(2,useGUI[1],5,5)
     for txt,fmt,ifEdit,Id in useGUI[2]:
-        littleSizer.Add(wx.StaticText(self.dataDisplay,label=txt),0,wx.ALIGN_CENTER_VERTICAL)
+        littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=txt),0,wx.ALIGN_CENTER_VERTICAL)
         if ifEdit:          #a,b,c,etc.
-            cellVal = wx.TextCtrl(self.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
+            cellVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
             cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)        
             cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
@@ -1476 +1478 @@
             cellList.append(cellVal.GetId())
         else:               #volume
-            volVal = wx.TextCtrl(self.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
+            volVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
             volVal.SetBackgroundColour(VERY_LIGHT_GREY)
             littleSizer.Add(volVal,0,wx.ALIGN_CENTER_VERTICAL)
@@ -1482 +1484 @@
         
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    topSize = mainSizer.Fit(self.dataFrame)
-    self.dataDisplay.SetSize(topSize)
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    topSize = mainSizer.Fit(G2frame.dataFrame)
+    G2frame.dataDisplay.SetSize(topSize)
     if cells:
         if ibrav == 13:
@@ -1490 +1492 @@
         else:
             topSize[1] += 200
-    self.dataFrame.setSizePosLeft(topSize)    
+    G2frame.dataFrame.setSizePosLeft(topSize)    
     
     if cells:
-        bottomSize = self.bottom.GetSize()
+        bottomSize = G2frame.bottom.GetSize()
         if ibrav == 13:
             bottomSize[1] -= 240
         else:
             bottomSize[1] -= 210
-        wx.StaticText(parent=self.bottom,label=' Indexing Result ')
+        wx.StaticText(parent=G2frame.bottom,label=' Indexing Result ')
         rowLabels = []
         colLabels = ['M20','X20','use','Bravais','a','b','c','alpha','beta','gamma','Volume']
@@ -1511 +1513 @@
             if cell[-1]:
                 A = G2lat.cell2A(cell[3:9])
-                self.HKL = G2lat.GenHBravais(dmin,cell[2],A)
-                for hkl in self.HKL:
+                G2frame.HKL = G2lat.GenHBravais(dmin,cell[2],A)
+                for hkl in G2frame.HKL:
                     hkl.append(2.0*asind(wave/(2.*hkl[3]))+controls[1]+Inst['Zero'])             
             table.append(row)
         UnitCellsTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-        gridDisplay = G2gd.GSGrid(self.bottom)
+        gridDisplay = G2gd.GSGrid(G2frame.bottom)
         gridDisplay.SetPosition(wx.Point(0,20))                
         gridDisplay.SetTable(UnitCellsTable, True)
-        self.dataFrame.CopyCell.Enable(True)
+        G2frame.dataFrame.CopyCell.Enable(True)
         gridDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK,RefreshUnitCellsGrid)
         gridDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK,OnSortCells)
@@ -1533 +1535 @@
         gridDisplay.SetSize(bottomSize)
 
-def UpdateReflectionGrid(self,data):
+def UpdateReflectionGrid(G2frame,data):
     if not data:
         print 'No phases, no reflections'
@@ -1540 +1542 @@
     
     def OnSelectPhase(event):
-        dlg = wx.SingleChoiceDialog(self,'Select','Phase',phases)
+        dlg = wx.SingleChoiceDialog(G2frame,'Select','Phase',phases)
         try:
             if dlg.ShowModal() == wx.ID_OK:
                 sel = dlg.GetSelection()
-                self.RefList = phases[sel]
-                UpdateReflectionGrid(self,data)
+                G2frame.RefList = phases[sel]
+                UpdateReflectionGrid(G2frame,data)
         finally:
             dlg.Destroy()
-        G2plt.PlotPatterns(self)
-        
-        
-    if self.dataDisplay:
-        self.dataFrame.Clear()
-    self.dataFrame.SetMenuBar(self.dataFrame.ReflMenu)
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()    
-    self.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
-    self.dataFrame.SelectPhase.Enable(False)
+        G2plt.PlotPatterns(G2frame)
+        
+        
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.ReflMenu)
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()    
+    G2frame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
+    G2frame.dataFrame.SelectPhase.Enable(False)
     if len(data) > 1:
-        self.dataFrame.SelectPhase.Enable(True)
+        G2frame.dataFrame.SelectPhase.Enable(True)
     rowLabels = []
-    refList = [refl[:11] for refl in data[self.RefList]]
+    refList = [refl[:11] for refl in data[G2frame.RefList]]
     for i in range(len(refList)): rowLabels.append(str(i))
     colLabels = ['H','K','L','mul','d','pos','sig','gam','Fosq','Fcsq','phase',]
     Types = 4*[wg.GRID_VALUE_LONG,]+4*[wg.GRID_VALUE_FLOAT+':10,4',]+2*[wg.GRID_VALUE_FLOAT+':10,2',]+[wg.GRID_VALUE_FLOAT+':10,3',]
-    self.PeakTable = G2gd.Table(refList,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-    self.dataFrame.SetLabel('Reflection List for '+self.RefList)
-    self.dataDisplay = G2gd.GSGrid(parent=self.dataFrame)
-    self.dataDisplay.SetTable(self.PeakTable, True)
-    self.dataDisplay.EnableEditing(False)
-    self.dataDisplay.SetMargins(0,0)
-    self.dataDisplay.AutoSizeColumns(False)
-    self.dataFrame.setSizePosLeft([555,350])
+    G2frame.PeakTable = G2gd.Table(refList,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+    G2frame.dataFrame.SetLabel('Reflection List for '+G2frame.RefList)
+    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
+    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
+    G2frame.dataDisplay.EnableEditing(False)
+    G2frame.dataDisplay.SetMargins(0,0)
+    G2frame.dataDisplay.AutoSizeColumns(False)
+    G2frame.dataFrame.setSizePosLeft([555,350])
 
-def UpdatePDFGrid(self,data):
+def UpdatePDFGrid(G2frame,data):
     global inst
     tth2q = lambda t,w:4.0*math.pi*sind(t/2.0)/w
-    dataFile = self.PatternTree.GetItemText(self.PatternId)
+    dataFile = G2frame.PatternTree.GetItemText(G2frame.PatternId)
     powName = 'PWDR'+dataFile[4:]
-    powId = G2gd.GetPatternTreeItemId(self,self.root, powName)
-    fullLimits,limits = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,powId, 'Limits'))
-    inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,powId, 'Instrument Parameters'))
+    powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, powName)
+    fullLimits,limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Limits'))
+    inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId, 'Instrument Parameters'))
     inst = dict(zip(inst[3],inst[1]))
     if 'Lam' in inst:
@@ -1608 +1610 @@
             Obj.SetValue(fmt%(value))
             data[fileKey][itemKey] = value
-            UpdatePDFGrid(self,data)
+            UpdatePDFGrid(G2frame,data)
         
         def OnValueChange(event):
@@ -1620 +1622 @@
             data[fileKey][itemKey] = value
             auxPlot = ComputePDF(data)
-            G2plt.PlotISFG(self,newPlot=True)
+            G2plt.PlotISFG(G2frame,newPlot=True)
                         
         item = data[key]
         fileList = np.array(GetFileList('PWDR')).T[1]
-        fileSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' '+key+' file:'),0,wx.ALIGN_CENTER_VERTICAL)
-        fileName = wx.ComboBox(self.dataDisplay,value=item['Name'],choices=fileList,
+        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+key+' file:'),0,wx.ALIGN_CENTER_VERTICAL)
+        fileName = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=fileList,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         itemDict[fileName.GetId()] = [key,'Name','%s']
         fileName.Bind(wx.EVT_COMBOBOX,OnSelectFile)        
         fileSizer.Add(fileName,0,)
-        fileSizer.Add(wx.StaticText(parent=self.dataDisplay,label='Multiplier:'),0,wx.ALIGN_CENTER_VERTICAL)
-        mult = wx.TextCtrl(self.dataDisplay,value='%.3f'%(item['Mult']),style=wx.TE_PROCESS_ENTER)
+        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Multiplier:'),0,wx.ALIGN_CENTER_VERTICAL)
+        mult = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(item['Mult']),style=wx.TE_PROCESS_ENTER)
         itemDict[mult.GetId()] = [key,'Mult','%.3f']
         mult.Bind(wx.EVT_TEXT_ENTER,OnValueChange)        
         mult.Bind(wx.EVT_KILL_FOCUS,OnValueChange)
         fileSizer.Add(mult,0,)
-        fileSizer.Add(wx.StaticText(parent=self.dataDisplay,label='Add:'),0,wx.ALIGN_CENTER_VERTICAL)
-        add = wx.TextCtrl(self.dataDisplay,value='%.0f'%(item['Add']),style=wx.TE_PROCESS_ENTER)
+        fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Add:'),0,wx.ALIGN_CENTER_VERTICAL)
+        add = wx.TextCtrl(G2frame.dataDisplay,value='%.0f'%(item['Add']),style=wx.TE_PROCESS_ENTER)
         itemDict[add.GetId()] = [key,'Add','%.0f']
         add.Bind(wx.EVT_TEXT_ENTER,OnValueChange)        
@@ -1651 +1653 @@
         return sumVol
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=True)        
+        G2plt.PlotISFG(G2frame,newPlot=True)        
         
     def FillElemSizer(elemSizer,ElData):
@@ -1664 +1666 @@
             data['Form Vol'] = max(10.0,SumElementVolumes())
             formVol.SetValue('%.2f'%(data['Form Vol']))
-            UpdatePDFGrid(self,data)
+            UpdatePDFGrid(G2frame,data)
             auxPlot = ComputePDF(data)
-            G2plt.PlotISFG(self,newPlot=True)        
-        
-        elemSizer.Add(wx.StaticText(parent=self.dataDisplay,
+            G2plt.PlotISFG(G2frame,newPlot=True)        
+        
+        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
             label=' Element: '+'%2s'%(ElData['Symbol'])+' * '),0,wx.ALIGN_CENTER_VERTICAL)
-        num = wx.TextCtrl(self.dataDisplay,value='%.3f'%(ElData['FormulaNo']),style=wx.TE_PROCESS_ENTER)
+        num = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(ElData['FormulaNo']),style=wx.TE_PROCESS_ENTER)
         num.Bind(wx.EVT_TEXT_ENTER,OnFractionChange)        
         num.Bind(wx.EVT_KILL_FOCUS,OnFractionChange)
         elemSizer.Add(num,0,wx.ALIGN_CENTER_VERTICAL)
-        elemSizer.Add(wx.StaticText(parent=self.dataDisplay,
+        elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
             label="f': %.3f"%(ElData['fp'])+' f": %.3f'%(ElData['fpp'])+' mu: %.2f barns'%(ElData['mu']) ),
             0,wx.ALIGN_CENTER_VERTICAL)
@@ -1680 +1682 @@
     def OnGeometry(event):
         data['Geometry'] = geometry.GetValue()
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=True)        
+        G2plt.PlotISFG(G2frame,newPlot=True)        
         
     def OnDetType(event):
         data['DetType'] = detType.GetValue()
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=True)        
+        G2plt.PlotISFG(G2frame,newPlot=True)        
         
     def OnFormVol(event):
@@ -1698 +1700 @@
             value = data['Form Vol']
         data['Form Vol'] = value
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)        
+        G2plt.PlotISFG(G2frame,newPlot=False)        
         
     def OnDiameter(event):
@@ -1710 +1712 @@
             value = data['Diam']
         data['Diam'] = value
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)
+        G2plt.PlotISFG(G2frame,newPlot=False)
         
     def OnPolaVal(event):
@@ -1723 +1725 @@
         inst['Polariz.'] = value
         polaVal.SetValue('%.2f'%(inst['Polariz.']))
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)
+        G2plt.PlotISFG(G2frame,newPlot=False)
                 
     def OnAzimVal(event):
@@ -1736 +1738 @@
         inst['Azimuth'] = value
         azimVal.SetValue('%.1f'%(inst['Azimuth']))
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)
+        G2plt.PlotISFG(G2frame,newPlot=False)
                         
     def OnObliqCoeff(event):
@@ -1752 +1754 @@
         obliqCoeff.SetValue('%.3f'%(value))
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)
+        G2plt.PlotISFG(G2frame,newPlot=False)
         
     def OnRulandWdt(event):
@@ -1766 +1768 @@
         rulandWdt.SetValue('%.3f'%(value))
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)
+        G2plt.PlotISFG(G2frame,newPlot=False)
         
     def OnRulSlider(event):
@@ -1773 +1775 @@
         rulandWdt.SetValue('%.3f'%(data['Ruland']))
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)
+        G2plt.PlotISFG(G2frame,newPlot=False)
         
     def OnLorch(event):
         data['Lorch'] = lorch.GetValue()
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)        
+        G2plt.PlotISFG(G2frame,newPlot=False)        
                         
     def OnPacking(event):
@@ -1788 +1790 @@
             value = data['Pack']
         data['Pack'] = value
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=False)        
+        G2plt.PlotISFG(G2frame,newPlot=False)        
                 
     def OnSQmin(event):
@@ -1802 +1804 @@
         SQmin.SetValue('%.1f'%(value))
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=True)        
+        G2plt.PlotISFG(G2frame,newPlot=True)        
         
     def OnSQmax(event):
@@ -1817 +1819 @@
         SQmax.SetValue('%.1f'%(value))
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=True)
+        G2plt.PlotISFG(G2frame,newPlot=True)
         
     def OnResetQ(event):
@@ -1826 +1828 @@
         SQmin.SetValue('%.1f'%(data['QScaleLim'][0]))
         auxPlot = ComputePDF(data)
-        G2plt.PlotISFG(self,newPlot=True)        
+        G2plt.PlotISFG(G2frame,newPlot=True)        
 
     def GetFileList(fileType,skip=None):
         fileList = [[False,'',0]]
         Source = ''
-        id, cookie = self.PatternTree.GetFirstChild(self.root)
+        id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
         while id:
-            name = self.PatternTree.GetItemText(id)
+            name = G2frame.PatternTree.GetItemText(id)
             if fileType in name:
                 if id == skip:
@@ -1839 +1841 @@
                 else:
                     fileList.append([False,name,id])
-            id, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+            id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
         if skip:
             return fileList,Source
@@ -1847 +1849 @@
     def OnCopyPDFControls(event):
         import copy
-        TextList,Source = GetFileList('PDF',skip=self.PatternId)
+        TextList,Source = GetFileList('PDF',skip=G2frame.PatternId)
         TextList[0] = [False,'All PDF',0]
         if len(TextList) == 1:
-            self.ErrorDialog('Nothing to copy controls to','There must be more than one "PDF" pattern')
+            G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "PDF" pattern')
             return
-        dlg = self.CopyDialog(self,'Copy PDF controls','Copy controls from '+Source+' to:',TextList)
+        dlg = G2frame.CopyDialog(G2frame,'Copy PDF controls','Copy controls from '+Source+' to:',TextList)
         try:
             if dlg.ShowModal() == wx.ID_OK:
@@ -1862 +1864 @@
                     ifcopy,name,id = item
                     if ifcopy:
-                        olddata = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'PDF Controls'))
+                        olddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'))
                         sample = olddata['Sample']
                         olddata.update(copy.deepcopy(data))
                         olddata['Sample'] = sample
-                        self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,id, 'PDF Controls'),olddata)
+                        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'),olddata)
                 Status.SetStatusText('PDF controls copied')
         finally:
@@ -1879 +1881 @@
     def OnAddElement(event):
         ElList = data['ElList']
-        PE = G2elem.PickElement(self,oneOnly=True)
+        PE = G2elem.PickElement(G2frame,oneOnly=True)
         if PE.ShowModal() == wx.ID_OK:
             El = PE.Elem
@@ -1893 +1895 @@
             data['Form Vol'] = max(10.0,SumElementVolumes())
         PE.Destroy()
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
         
     def OnDeleteElement(event):
         ElList = data['ElList']
         choice = ElList.keys()
-        dlg = G2elem.DeleteElement(self,choice=choice)
+        dlg = G2elem.DeleteElement(G2frame,choice=choice)
         if dlg.ShowModal() == wx.ID_OK:
             del ElList[dlg.GetDeleteElement()]
         dlg.Destroy()
-        UpdatePDFGrid(self,data)
+        UpdatePDFGrid(G2frame,data)
                 
     def ComputePDF(Data):
@@ -1909 +1911 @@
             name = Data[key]['Name']
             if name:
-                xydata[key] = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,self.root,name))
+                xydata[key] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name))
                 PDFname = name
         powName = xydata['Sample'][2]
-        powId = G2gd.GetPatternTreeItemId(self,self.root,powName)
-        inst = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,powId,'Instrument Parameters'))
+        powId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,powName)
+        inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,powId,'Instrument Parameters'))
         inst = dict(zip(inst[3],inst[1]))
         auxPlot = G2pwd.CalcPDF(Data,inst,xydata)
-        PDFId = G2gd.GetPatternTreeItemId(self,self.root,'PDF '+powName[4:])
-        self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,PDFId,'I(Q)'+powName[4:]),xydata['IofQ'])
-        self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,PDFId,'S(Q)'+powName[4:]),xydata['SofQ'])
-        self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,PDFId,'F(Q)'+powName[4:]),xydata['FofQ'])
-        self.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(self,PDFId,'G(R)'+powName[4:]),xydata['GofR'])
+        PDFId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'PDF '+powName[4:])
+        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'I(Q)'+powName[4:]),xydata['IofQ'])
+        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'S(Q)'+powName[4:]),xydata['SofQ'])
+        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'F(Q)'+powName[4:]),xydata['FofQ'])
+        G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PDFId,'G(R)'+powName[4:]),xydata['GofR'])
         return auxPlot
         
@@ -1929 +1931 @@
         Status.SetStatusText('PDF computed')
         for plot in auxPlot:
-            G2plt.PlotXY(self,plot[:2],type=plot[2])
-        
-        G2plt.PlotISFG(self,newPlot=True,type='I(Q)')
-        G2plt.PlotISFG(self,newPlot=True,type='S(Q)')
-        G2plt.PlotISFG(self,newPlot=True,type='F(Q)')
-        G2plt.PlotISFG(self,newPlot=True,type='G(R)')
+            G2plt.PlotXY(G2frame,plot[:2],type=plot[2])
+        
+        G2plt.PlotISFG(G2frame,newPlot=True,type='I(Q)')
+        G2plt.PlotISFG(G2frame,newPlot=True,type='S(Q)')
+        G2plt.PlotISFG(G2frame,newPlot=True,type='F(Q)')
+        G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
         
     def OnComputeAllPDF(event):
         print 'Calculating PDFs:'
-        if self.PatternTree.GetCount():
-            id, cookie = self.PatternTree.GetFirstChild(self.root)
+        if G2frame.PatternTree.GetCount():
+            id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
             while id:
-                Name = self.PatternTree.GetItemText(id)
+                Name = G2frame.PatternTree.GetItemText(id)
                 if 'PDF' in Name:
-                    Data = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,id,'PDF Controls'))
+                    Data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'PDF Controls'))
                     auxPlot = ComputePDF(Data)                    
-                id, cookie = self.PatternTree.GetNextChild(self.root, cookie)
+                id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
             Status.SetStatusText('All PDFs computed')
-            G2plt.PlotISFG(self,newPlot=True,type='G(R)')
+            G2plt.PlotISFG(G2frame,newPlot=True,type='G(R)')
             print ' Done calculating PDFs:'
         
-    def OnShowTip(self,tip):
+    def OnShowTip(G2frame,tip):
         print tip    
                 
-    if self.dataDisplay:
-        self.dataFrame.Clear()
-    self.dataFrame.SetMenuBar(self.dataFrame.PDFMenu)
-    if not self.dataFrame.GetStatusBar():
-        Status = self.dataFrame.CreateStatusBar()    
-    self.dataDisplay = wx.Panel(self.dataFrame)
-    self.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFControls, id=G2gd.wxID_PDFCOPYCONTROLS)
-    self.dataFrame.Bind(wx.EVT_MENU, OnSavePDFControls, id=G2gd.wxID_PDFSAVECONTROLS)
-    self.dataFrame.Bind(wx.EVT_MENU, OnLoadPDFControls, id=G2gd.wxID_PDFLOADCONTROLS)
-    self.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_PDFADDELEMENT)
-    self.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_PDFDELELEMENT)
-    self.dataFrame.Bind(wx.EVT_MENU, OnComputePDF, id=G2gd.wxID_PDFCOMPUTE)
-    self.dataFrame.Bind(wx.EVT_MENU, OnComputeAllPDF, id=G2gd.wxID_PDFCOMPUTEALL)
+    if G2frame.dataDisplay:
+        G2frame.dataFrame.Clear()
+    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.PDFMenu)
+    if not G2frame.dataFrame.GetStatusBar():
+        Status = G2frame.dataFrame.CreateStatusBar()    
+    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFControls, id=G2gd.wxID_PDFCOPYCONTROLS)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSavePDFControls, id=G2gd.wxID_PDFSAVECONTROLS)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadPDFControls, id=G2gd.wxID_PDFLOADCONTROLS)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddElement, id=G2gd.wxID_PDFADDELEMENT)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnDeleteElement, id=G2gd.wxID_PDFDELELEMENT)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputePDF, id=G2gd.wxID_PDFCOMPUTE)
+    G2frame.dataFrame.Bind(wx.EVT_MENU, OnComputeAllPDF, id=G2gd.wxID_PDFCOMPUTEALL)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
-    mainSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' PDF data files: '),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' PDF data files: '),0,wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)
     str = ' Sample file: PWDR %s   Wavelength, A: %.5f  Energy, keV: %.3f  Polariz.: %.2f '%(dataFile[3:],wave,keV,polariz)
-    mainSizer.Add(wx.StaticText(parent=self.dataDisplay,label=str),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=str),0,wx.ALIGN_CENTER_VERTICAL)
 #    dataSizer = wx.BoxSizer(wx.HORIZONTAL)
-#    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label='Azimuth'),0,wx.ALIGN_CENTER_VERTICAL)
-#    azimVal = wx.TextCtrl(self.dataDisplay,value='%.2f'%(inst['Azimuth']))
+#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Azimuth'),0,wx.ALIGN_CENTER_VERTICAL)
+#    azimVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Azimuth']))
 #    azimVal.Bind(wx.EVT_TEXT_ENTER,OnAzimVal)        
 #    azimVal.Bind(wx.EVT_KILL_FOCUS,OnAzimVal)
 #    dataSizer.Add(azimVal,0)    
-#    dataSizer.Add(wx.StaticText(parent=self.dataDisplay,label='Polarization'),0,wx.ALIGN_CENTER_VERTICAL)
-#    polaVal = wx.TextCtrl(self.dataDisplay,value='%.2f'%(inst['Polariz.']))
+#    dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Polarization'),0,wx.ALIGN_CENTER_VERTICAL)
+#    polaVal = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(inst['Polariz.']))
 #    polaVal.Bind(wx.EVT_TEXT_ENTER,OnPolaVal)        
 #    polaVal.Bind(wx.EVT_KILL_FOCUS,OnPolaVal)
@@ -1992 +1994 @@
     mainSizer.Add(fileSizer,0)
     mainSizer.Add((5,5),0)
-    mainSizer.Add(wx.StaticText(self.dataDisplay,label=' Sample information: '),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: '),0,wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)    
 
@@ -2004 +2006 @@
     mainSizer.Add((5,5),0)    
     midSizer = wx.BoxSizer(wx.HORIZONTAL)
-    midSizer.Add(wx.StaticText(self.dataDisplay,label=' Formula volume: '),0,wx.ALIGN_CENTER_VERTICAL)
-    formVol = wx.TextCtrl(self.dataDisplay,value='%.2f'%(data['Form Vol']))
+    midSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Formula volume: '),0,wx.ALIGN_CENTER_VERTICAL)
+    formVol = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Form Vol']))
     formVol.Bind(wx.EVT_TEXT_ENTER,OnFormVol)        
     formVol.Bind(wx.EVT_KILL_FOCUS,OnFormVol)
     midSizer.Add(formVol,0)
-    midSizer.Add(wx.StaticText(self.dataDisplay,
+    midSizer.Add(wx.StaticText(G2frame.dataDisplay,
         label=' Theoretical absorption: %.4f cm-1 Sample absorption: %.4f cm-1'%(Abs,Abs*data['Pack'])),
         0,wx.ALIGN_CENTER_VERTICAL)
@@ -2016 +2018 @@
 
     geoBox = wx.BoxSizer(wx.HORIZONTAL)
-    geoBox.Add(wx.StaticText(self.dataDisplay,label=' Sample geometry: '),0,wx.ALIGN_CENTER_VERTICAL)
+    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample geometry: '),0,wx.ALIGN_CENTER_VERTICAL)
     choice = ['Cylinder','Bragg-Brentano','Tilting flat plate in transmission','Fixed flat plate']
-    geometry = wx.ComboBox(self.dataDisplay,value=data['Geometry'],choices=choice,
+    geometry = wx.ComboBox(G2frame.dataDisplay,value=data['Geometry'],choices=choice,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
     geometry.Bind(wx.EVT_COMBOBOX, OnGeometry)
     geoBox.Add(geometry,0)
-    geoBox.Add(wx.StaticText(self.dataDisplay,label=' Sample diameter/thickness, mm: '),0,wx.ALIGN_CENTER_VERTICAL)
-    diam = wx.TextCtrl(self.dataDisplay,value='%.3f'%(data['Diam']))
+    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample diameter/thickness, mm: '),0,wx.ALIGN_CENTER_VERTICAL)
+    diam = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Diam']))
     diam.Bind(wx.EVT_TEXT_ENTER,OnDiameter)        
     diam.Bind(wx.EVT_KILL_FOCUS,OnDiameter)
-#    diam.Bind(wx.EVT_SET_FOCUS,OnShowTip(self,'tip')) #this doesn't work - what would????
+#    diam.Bind(wx.EVT_SET_FOCUS,OnShowTip(G2frame,'tip')) #this doesn't work - what would????
     geoBox.Add(diam,0)
     mainSizer.Add(geoBox,0)
     mainSizer.Add((5,5),0)    
     geoBox = wx.BoxSizer(wx.HORIZONTAL)
-    geoBox.Add(wx.StaticText(self.dataDisplay,label=' Packing: '),0,wx.ALIGN_CENTER_VERTICAL)
-    pack = wx.TextCtrl(self.dataDisplay,value='%.2f'%(data['Pack']))
+    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Packing: '),0,wx.ALIGN_CENTER_VERTICAL)
+    pack = wx.TextCtrl(G2frame.dataDisplay,value='%.2f'%(data['Pack']))
     pack.Bind(wx.EVT_TEXT_ENTER,OnPacking)        
     pack.Bind(wx.EVT_KILL_FOCUS,OnPacking)
     geoBox.Add(pack,0)
-    geoBox.Add(wx.StaticText(self.dataDisplay,label=' Sample transmission: %.3f %%'%(Trans)),0,wx.ALIGN_CENTER_VERTICAL)    
+    geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample transmission: %.3f %%'%(Trans)),0,wx.ALIGN_CENTER_VERTICAL)    
     mainSizer.Add(geoBox,0)
     mainSizer.Add((5,5),0)    
         
-    mainSizer.Add(wx.StaticText(parent=self.dataDisplay,label=' S(Q)->F(Q)->G(R) controls: '),0,wx.ALIGN_CENTER_VERTICAL)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' S(Q)->F(Q)->G(R) controls: '),0,wx.ALIGN_CENTER_VERTICAL)
     mainSizer.Add((5,5),0)
     sqBox = wx.BoxSizer(wx.HORIZONTAL)
-    sqBox.Add(wx.StaticText(self.dataDisplay,label=' Detector type: '),0,wx.ALIGN_CENTER_VERTICAL)
+    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Detector type: '),0,wx.ALIGN_CENTER_VERTICAL)
     choice = ['Image plate','Point detector']
-    detType = wx.ComboBox(self.dataDisplay,value=data['DetType'],choices=choice,
+    detType = wx.ComboBox(G2frame.dataDisplay,value=data['DetType'],choices=choice,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
     detType.Bind(wx.EVT_COMBOBOX, OnDetType)
     sqBox.Add(detType,0)
     if data['DetType'] == 'Image plate':
-        sqBox.Add(wx.StaticText(self.dataDisplay,label=' IP transmission coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
-        obliqCoeff = wx.TextCtrl(self.dataDisplay,value='%.3f'%(data['ObliqCoeff']))
+        sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' IP transmission coeff.: '),0,wx.ALIGN_CENTER_VERTICAL)
+        obliqCoeff = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['ObliqCoeff']))
         obliqCoeff.Bind(wx.EVT_TEXT_ENTER,OnObliqCoeff)        
         obliqCoeff.Bind(wx.EVT_KILL_FOCUS,OnObliqCoeff)
@@ -2058 +2060 @@
         
     sqBox = wx.BoxSizer(wx.HORIZONTAL)
-    sqBox.Add(wx.StaticText(self.dataDisplay,label=' Ruland width: '),0,wx.ALIGN_CENTER_VERTICAL)    
-    rulandSldr = wx.Slider(parent=self.dataDisplay,style=wx.SL_HORIZONTAL,
+    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Ruland width: '),0,wx.ALIGN_CENTER_VERTICAL)    
+    rulandSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
         value=int(1000*data['Ruland']))
     sqBox.Add(rulandSldr,1,wx.EXPAND)
     rulandSldr.Bind(wx.EVT_SLIDER, OnRulSlider)
-    rulandWdt = wx.TextCtrl(self.dataDisplay,value='%.3f'%(data['Ruland']))
+    rulandWdt = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(data['Ruland']))
     rulandWdt.Bind(wx.EVT_TEXT_ENTER,OnRulandWdt)        
     rulandWdt.Bind(wx.EVT_KILL_FOCUS,OnRulandWdt)
@@ -2070 +2072 @@
     
     sqBox = wx.BoxSizer(wx.HORIZONTAL)
-    lorch = wx.CheckBox(parent=self.dataDisplay,label='Lorch damping?')
+    lorch = wx.CheckBox(parent=G2frame.dataDisplay,label='Lorch damping?')
     lorch.SetValue(data['Lorch'])
     lorch.Bind(wx.EVT_CHECKBOX, OnLorch)
     sqBox.Add(lorch,0,wx.ALIGN_CENTER_VERTICAL)
-    sqBox.Add(wx.StaticText(self.dataDisplay,label=' Scaling q-range: '),0,wx.ALIGN_CENTER_VERTICAL)
-    SQmin = wx.TextCtrl(self.dataDisplay,value='%.1f'%(data['QScaleLim'][0]))
+    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Scaling q-range: '),0,wx.ALIGN_CENTER_VERTICAL)
+    SQmin = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][0]))
     SQmin.Bind(wx.EVT_TEXT_ENTER,OnSQmin)        
     SQmin.Bind(wx.EVT_KILL_FOCUS,OnSQmin)    
     sqBox.Add(SQmin,0)
-    sqBox.Add(wx.StaticText(self.dataDisplay,label=' to '),0,wx.ALIGN_CENTER_VERTICAL)
-    SQmax = wx.TextCtrl(self.dataDisplay,value='%.1f'%(data['QScaleLim'][1]))
+    sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' to '),0,wx.ALIGN_CENTER_VERTICAL)
+    SQmax = wx.TextCtrl(G2frame.dataDisplay,value='%.1f'%(data['QScaleLim'][1]))
     SQmax.Bind(wx.EVT_TEXT_ENTER,OnSQmax)        
     SQmax.Bind(wx.EVT_KILL_FOCUS,OnSQmax)
     sqBox.Add(SQmax,0)
-    resetQ = wx.CheckBox(parent=self.dataDisplay,label='Reset?')
+    resetQ = wx.CheckBox(parent=G2frame.dataDisplay,label='Reset?')
     sqBox.Add(resetQ,0)
     resetQ.Bind(wx.EVT_CHECKBOX, OnResetQ)
@@ -2091 +2093 @@
 
     mainSizer.Layout()    
-    self.dataDisplay.SetSizer(mainSizer)
-    Size = mainSizer.Fit(self.dataFrame)
-    self.dataDisplay.SetSize(Size)
-    self.dataFrame.setSizePosLeft(Size)
+    G2frame.dataDisplay.SetSizer(mainSizer)
+    Size = mainSizer.Fit(G2frame.dataFrame)
+    G2frame.dataDisplay.SetSize(Size)
+    G2frame.dataFrame.setSizePosLeft(Size)