Changeset 2888 for branch

Timestamp:

Jul 1, 2017 6:22:10 AM (6 years ago)

Author:

vondreele

Message:

 

Location:

branch/2frame

Files:

• . (copied) (copied from trunk)
• GSASII.py (modified) (14 diffs)
• GSASIIconstrGUI.py (modified) (12 diffs)
• GSASIIctrls.py (modified) (4 diffs)
• GSASIIddataGUI.py (modified) (3 diffs)
• GSASIIgrid.py (modified) (38 diffs)
• GSASIIimgGUI.py (modified) (44 diffs)
• GSASIIphsGUI.py (modified) (73 diffs)
• GSASIIplot.py (modified) (7 diffs)
• GSASIIpwdGUI.py (modified) (158 diffs)
• GSASIIrestrGUI.py (modified) (25 diffs)
• gltext.py (modified) (1 diff)

branch/2frame/GSASII.py

@@ -90 +90 @@
 #                GSASIIpath.IPyBreak()
 
-__version__ = '0.2.0'
+__version__ = '0.3.0'
 
 # PATCH: for Mavericks (OS X 10.9.x), wx produces an annoying warning about LucidaGrandeUI.
@@ -121 +121 @@
             'HStrain':[NDij*[0.0,],NDij*[False,]],                          
             'Extinction':[0.0,False],'Babinet':{'BabA':[0.0,False],'BabU':[0.0,False]}}
+
+class GSASIIsplit(wx.SplitterWindow):
+    def __init__(self,parent,ID):
+        wx.SplitterWindow.__init__(self, parent, ID,style = wx.SP_BORDER|wx.SP_LIVE_UPDATE)
+        self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED, self.OnSashChanged)
+        self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGING, self.OnSashChanging)
+
+    def OnSashChanged(self, evt):
+        evt.Skip()
+#        print "sash changed to %s\n" % str(evt.GetSashPosition())
+
+    def OnSashChanging(self, evt):
+        evt.Skip()
+#        print "sash changing to %s\n" % str(evt.GetSashPosition())
 
 class GSASII(wx.Frame):
@@ -1489 +1503 @@
             if UseList: haveData = True
         if haveData:
-            self.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,True)
+            self.dataWindow.DataMenu.Enable(G2gd.wxID_DATADELETE,True)
             for item in self.Refine: item.Enable(True)
         else:
-            self.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,False)
+            self.dataWindow.DataMenu.Enable(G2gd.wxID_DATADELETE,False)
             for item in self.Refine: item.Enable(False)
 
@@ -2446 +2460 @@
         item.Enable(False)
         self.Bind(wx.EVT_MENU, self.OnExportPDF, id=item.GetId())
-
+            
     def FillMainMenu(self,menubar,addhelp=True):
         '''Define contents of the main GSAS-II menu for the (main) data tree window.
@@ -2521 +2535 @@
     def _init_ctrls(self, parent):
         wx.Frame.__init__(self, name='GSASII', parent=parent,
-            size=wx.Size(400, 250),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
+            size=wx.Size(700, 450),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
         clientSize = wx.ClientDisplayRect()
         Size = self.GetSize()
@@ -2546 +2560 @@
         self.Bind(wx.EVT_SIZE, self.OnSize)
         self.Status = self.CreateStatusBar()
-        self.mainPanel = wx.Panel(self,-1)
+#TODO - split window tree on left, data on right
+        self.mainPanel = GSASIIsplit(self,-1)
+        self.treePanel = wx.Panel(self.mainPanel, wx.ID_ANY,
+                style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER)
+        self.treePanel.SetAutoLayout(True)
+        self.dataPanel = wx.Panel(self.mainPanel, wx.ID_ANY,
+                style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER)
+        self.dataPanel.SetAutoLayout(True)
+        self.dataWindow = G2gd.DataWindow(self.dataPanel)
+        self.dataWindow.SetupScrolling()
+        self.mainPanel.SetMinimumPaneSize(100)
+        self.mainPanel.SplitVertically(self.treePanel, self.dataPanel, 200)
+        self.dataFrame = self.dataWindow        #kluge!!
         
         wxID_PATTERNTREE = wx.NewId()
-        #self.PatternTree = wx.TreeCtrl(id=wxID_PATTERNTREE, # replaced for logging
+        treeSizer = wx.BoxSizer()
         self.PatternTree = G2G.G2TreeCtrl(id=wxID_PATTERNTREE,
-            parent=self.mainPanel, pos=wx.Point(0, 0),style=wx.TR_DEFAULT_STYLE )
+            parent=self.treePanel, size=self.treePanel.GetSize(),style=wx.TR_DEFAULT_STYLE )
+        treeSizer.Add(self.PatternTree,1,wx.EXPAND)
+        self.treePanel.SetSizer(treeSizer)
         self.PatternTree.Bind(wx.EVT_TREE_SEL_CHANGED,self.OnDataTreeSelChanged)
         self.PatternTree.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK,self.OnDataTreeSelChanged)
@@ -2566 +2594 @@
         self.PatternTree.Bind(wx.EVT_TREE_END_DRAG,
             self.OnPatternTreeEndDrag, id=wxID_PATTERNTREE)        
-        #self.root = self.PatternTree.AddRoot('Loaded Data: ')
-        self.root = self.PatternTree.root
+        self.root = self.PatternTree.root        
+        
         plotFrame = wx.Frame(None,-1,'GSASII Plots',size=wx.Size(700,600), \
             style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX)
         self.G2plotNB = G2plt.G2PlotNoteBook(plotFrame,G2frame=self)
         plotFrame.Show()
-        
-        self.dataDisplay = None
+        self.SetDataSize()
         
     def __init__(self, parent):
@@ -2609 +2636 @@
         self.Lines = []
         self.itemPicked = None
-        self.dataFrame = None
         self.Interpolate = 'nearest'
         self.ContourColor = GSASIIpath.GetConfigValue('Contour_color','Paired')
@@ -2687 +2713 @@
         self.mainPanel.SetSize(wx.Size(w,h))
         self.PatternTree.SetSize(wx.Size(w,h))
-                        
+        
+    def SetDataSize(self):
+        Size = self.GetSize()
+        self.SetSize(Size)
+        Size[1] += 1        #kluge to ensure scrollbar settings & window properly displayed
+        self.SetSize(Size)
+                                
     def OnDataTreeSelChanged(self, event):
         '''Called when a data tree item is selected'''
@@ -3428 +3460 @@
         if self.PatternTree.GetChildrenCount(self.root,False):
             if self.dataFrame:
-                self.dataFrame.Clear() 
+                self.dataFrame.ClearData() 
             dlg = wx.MessageDialog(
                 self,
@@ -3447 +3479 @@
 
         if not filename:
-            if self.dataDisplay: self.dataDisplay.Destroy()
             if self.LastGPXdir:
                 pth = self.LastGPXdir
@@ -3515 +3546 @@
         the project.
         '''
-        if self.dataFrame:
-            self.dataFrame.Clear()
-            self.dataFrame.SetLabel('GSAS-II data display') 
-        dlg = wx.MessageDialog(self, 'Save current project?', ' ', wx.YES | wx.NO | wx.CANCEL)
+#        dlg = wx.MessageDialog(self, 'Save current project?', ' ', wx.YES | wx.NO | wx.CANCEL)
         try:
             result = dlg.ShowModal()
@@ -3625 +3653 @@
             self.G2plotNB.Destroy()
         if self.dataFrame:
-            self.dataFrame.Clear() 
             self.dataFrame.Destroy()
         if self.undofile:
@@ -3636 +3663 @@
             self.G2plotNB.Destroy()
         if self.dataFrame:
-            self.dataFrame.Clear() 
             self.dataFrame.Destroy()
         self.Close()

branch/2frame/GSASIIconstrGUI.py

@@ -662 +662 @@
         #varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
         legend = "Select variables to hold (Will not be varied, even if vary flag is set)"
-        dlg = G2G.G2MultiChoiceDialog(
-            G2frame.dataFrame,
+        dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,
             legend,title1,varListlbl,toggle=False,size=(625,400),monoFont=True)
         dlg.CenterOnParent()
@@ -1062 +1061 @@
         notebook tab. Called in :func:`OnPageChanged`
         '''
-        if panel.GetSizer(): panel.GetSizer().Clear(True) # N.B. don't use panel.DestroyChildren()
+#        if panel.GetSizer(): panel.GetSizer().Clear(True) # N.B. don't use panel.DestroyChildren()
         # because it deletes scrollbars on Mac
         Siz = wx.BoxSizer(wx.VERTICAL)
         Siz.Add((5,5),0)
-        Siz.Add(MakeConstraintsSizer(typ,panel))
+        Siz.Add(MakeConstraintsSizer(typ,panel),1,wx.EXPAND)
         panel.SetSizer(Siz,True)
         Size = Siz.GetMinSize()
@@ -1073 +1072 @@
         panel.SetSize(Size)
         panel.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
-        Size[1] = min(500,Size[1])
-        G2frame.dataFrame.setSizePosLeft(Size)
+        panel.Show()
 
     def OnPageChanged(event):
@@ -1083 +1081 @@
             page = event.GetSelection()
         else: # called directly, get current page
-            page = G2frame.dataDisplay.GetSelection()
-        G2frame.dataDisplay.ChangeSelection(page)
-        text = G2frame.dataDisplay.GetPageText(page)
+            page = G2frame.constr.GetSelection()
+        G2frame.constr.ChangeSelection(page)
+        text = G2frame.constr.GetPageText(page)
         G2frame.dataFrame.ConstraintEdit.Enable(G2gd.wxID_EQUIVALANCEATOMS,False)
 #        G2frame.dataFrame.ConstraintEdit.Enable(G2gd.wxID_ADDRIDING,False)
@@ -1114 +1112 @@
                  G2gd.wxID_CONSHIST,
                  G2gd.wxID_CONSGLOBAL).index(event.GetId())
-            G2frame.dataDisplay.SetSelection(i)
+            G2frame.constr.SetSelection(i)
             wx.CallAfter(OnPageChanged,None)
         except ValueError:
@@ -1120 +1118 @@
 
     def SetStatusLine(text):
-        Status.SetStatusText(text)                                      
-        
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ConstraintMenu)
-    G2frame.dataFrame.SetLabel('Constraints')
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()
+        G2frame.GetStatusBar().SetStatusText(text)                                      
+        
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ConstraintMenu)
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Constraints')
     SetStatusLine('')
     
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ConstraintMenu)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddConstraint, id=G2gd.wxID_CONSTRAINTADD)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddFunction, id=G2gd.wxID_FUNCTADD)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddEquivalence, id=G2gd.wxID_EQUIVADD)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddHold, id=G2gd.wxID_HOLDADD)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddAtomEquiv, id=G2gd.wxID_EQUIVALANCEATOMS)
+    G2frame.Bind(wx.EVT_MENU, OnAddConstraint, id=G2gd.wxID_CONSTRAINTADD)
+    G2frame.Bind(wx.EVT_MENU, OnAddFunction, id=G2gd.wxID_FUNCTADD)
+    G2frame.Bind(wx.EVT_MENU, OnAddEquivalence, id=G2gd.wxID_EQUIVADD)
+    G2frame.Bind(wx.EVT_MENU, OnAddHold, id=G2gd.wxID_HOLDADD)
+    G2frame.Bind(wx.EVT_MENU, OnAddAtomEquiv, id=G2gd.wxID_EQUIVALANCEATOMS)
 #    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddRiding, id=G2gd.wxID_ADDRIDING)
     # tab commands
@@ -1144 +1137 @@
         G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=id)
 
-    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame)
+    G2frame.dataWindow.ClearData()
+    G2frame.constr = G2G.GSNoteBook(parent=G2frame.dataWindow)
     # note that order of pages is hard-coded in RaisePage
-    PhaseConstr = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(PhaseConstr,'Phase')
-    HAPConstr = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(HAPConstr,'Histogram/Phase')
-    HistConstr = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(HistConstr,'Histogram')
-    GlobalConstr = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(GlobalConstr,'Global')
+    PhaseConstr = wx.ScrolledWindow(G2frame.constr)
+    G2frame.constr.AddPage(PhaseConstr,'Phase')
+    HAPConstr = wx.ScrolledWindow(G2frame.constr)
+    G2frame.constr.AddPage(HAPConstr,'Histogram/Phase')
+    HistConstr = wx.ScrolledWindow(G2frame.constr)
+    G2frame.constr.AddPage(HistConstr,'Histogram')
+    GlobalConstr = wx.ScrolledWindow(G2frame.constr)
+    G2frame.constr.AddPage(GlobalConstr,'Global')
     wx.CallAfter(OnPageChanged,None)
-    G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
+    G2frame.constr.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     # validate all the constrants -- should not see any errors here normally
     allcons = []
@@ -1321 +1315 @@
             page = event.GetSelection()
         else:
-            page = G2frame.dataDisplay.GetSelection()
-        G2frame.dataDisplay.ChangeSelection(page)
-        text = G2frame.dataDisplay.GetPageText(page)
+            page = G2frame.rbBook.GetSelection()
+        G2frame.rbBook.ChangeSelection(page)
+        text = G2frame.rbBook.GetPageText(page)
         if text == 'Vector rigid bodies':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.VectorBodyMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.VectorBodyMenu)
             G2frame.dataFrame.Bind(wx.EVT_MENU, AddVectorRB, id=G2gd.wxID_VECTORBODYADD)
             G2frame.Page = [page,'vrb']
             UpdateVectorRB()
         elif text == 'Residue rigid bodies':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodyMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodyMenu)
             G2frame.dataFrame.Bind(wx.EVT_MENU, AddResidueRB, id=G2gd.wxID_RIGIDBODYADD)
             G2frame.dataFrame.Bind(wx.EVT_MENU, OnImportRigidBody, id=G2gd.wxID_RIGIDBODYIMPORT)
@@ -1595 +1589 @@
         AtInfo = data['Vector']['AtInfo']
         refChoice = {}
-        if 'DELETED' in str(Status):   #seems to be no other way to do this (wx bug)
+        if 'DELETED' in str(G2frame.GetStatusBar()):   #seems to be no other way to do this (wx bug)
             if GSASIIpath.GetConfigValue('debug'):
                 print 'wx error: Rigid Body/Status not cleanly deleted after Refine'
@@ -1804 +1798 @@
         VectorRB.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
         VectorRB.Scroll(0,Scroll)
-        Size[1] = min(Size[1],500)
-        G2frame.dataFrame.setSizePosLeft(Size)
         
     def UpdateResidueRB():
@@ -2058 +2050 @@
                 refChoice[rbId][i].sort()     
             
-        #ResidueRB.DestroyChildren() # bad, deletes scrollbars on Mac!
-        if ResidueRB.GetSizer():
-#            ResidueRB.DestroyChildren()
-            ResidueRB.GetSizer().Clear(True)
-            
         ResidueRBDisplay = wx.Panel(ResidueRB)
         ResidueRBSizer = wx.BoxSizer(wx.VERTICAL)
@@ -2091 +2078 @@
         ResidueRBDisplay.SetSize(Size)
         ResidueRB.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
-        Size[1] = min(500,Size[1])
-        G2frame.dataFrame.setSizePosLeft(Size)
         
     def SetStatusLine(text):
-        Status.SetStatusText(text)                                      
-
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodyMenu)
-    G2frame.dataFrame.SetLabel('Rigid bodies')
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()
+        G2frame.GetStatusBar().SetStatusText(text)                                      
+
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodyMenu)
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Rigid bodies')
     SetStatusLine('')
-
-    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
-
-    VectorRB = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(VectorRB,'Vector rigid bodies')
-    ResidueRB = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(ResidueRB,'Residue rigid bodies')
+    G2frame.dataWindow.ClearData()
+    G2frame.rbBook = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
+
+    VectorRB = wx.ScrolledWindow(G2frame.rbBook)
+    G2frame.rbBook.AddPage(VectorRB,'Vector rigid bodies')
+    ResidueRB = wx.ScrolledWindow(G2frame.rbBook)
+    G2frame.rbBook.AddPage(ResidueRB,'Residue rigid bodies')
     UpdateVectorRB()
-    G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
+    G2frame.rbBook.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     wx.CallAfter(OnPageChanged,None)

branch/2frame/GSASIIctrls.py

@@ -57 +57 @@
     def __init__(self,parent=None,*args,**kwargs):
         super(self.__class__,self).__init__(parent=parent,*args,**kwargs)
-        self.G2frame = parent.GetParent()
+        self.G2frame = parent.GetParent().GetParent()
         self.root = self.AddRoot('Loaded Data: ')
         self.SelectionChanged = None
@@ -79 +79 @@
         '''Log each press on a tree item here. 
         '''
-        if not self.G2frame.dataFrame:
+        if not self.G2frame.treePanel:
             return
-        self.G2frame.dataFrame.userReSize = False
         if self.SelectionChanged:
             textlist = self._getTreeItemsList(event.GetItem())
@@ -93 +92 @@
             self.textlist = textlist
             self.SelectionChanged(event)
-        self.G2frame.dataFrame.userReSize = True
 
     def Bind(self,eventtype,handler,*args,**kwargs):
@@ -3039 +3037 @@
         
     def PageChangeEvent(self,event):
-        G2frame = self.parent.G2frame
+#        G2frame = self.parent.G2frame
         page = event.GetSelection()
-        if self.PageChangeHandler:
-            if log.LogInfo['Logging']:
-                log.MakeTabLog(
-                    G2frame.dataFrame.GetTitle(),
-                    G2frame.dataDisplay.GetPageText(page)
-                    )
-            self.PageChangeHandler(event)
+#        if self.PageChangeHandler:
+#            if log.LogInfo['Logging']:
+#                log.MakeTabLog(
+#                    G2frame.dataFrame.GetTitle(),
+#                    G2frame.dataDisplay.GetPageText(page)
+#                    )
+#            self.PageChangeHandler(event)
             
-    def Bind(self,eventtype,handler,*args,**kwargs):
-        '''Override the Bind() function so that page change events can be trapped
-        '''
-        if eventtype == wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED:
-            self.PageChangeHandler = handler
-            wx.aui.AuiNotebook.Bind(self,eventtype,self.PageChangeEvent)
-            return
-        wx.aui.AuiNotebook.Bind(self,eventtype,handler,*args,**kwargs)
+#    def Bind(self,eventtype,handler,*args,**kwargs):
+#        '''Override the Bind() function so that page change events can be trapped
+#        '''
+#        if eventtype == wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED:
+#            self.PageChangeHandler = handler
+#            wx.aui.AuiNotebook.Bind(self,eventtype,self.PageChangeEvent)
+#            return
+#        wx.aui.AuiNotebook.Bind(self,eventtype,handler,*args,**kwargs)
                                                       
     def Clear(self):        

branch/2frame/GSASIIddataGUI.py

@@ -855 +855 @@
             useBox.Add(lebail,0,WACV)
             if UseList[G2frame.hist]['LeBail']:
-                G2frame.dataFrame.SetStatusText('To reset LeBail, cycle LeBail check box.')
+                G2frame.SetStatusText('To reset LeBail, cycle LeBail check box.')
         bottomSizer.Add(useBox,0,WACV|wx.TOP|wx.BOTTOM|wx.LEFT,5)
         
@@ -961 +961 @@
     # Beginning of UpdateDData execution here
     ######################################################################
-    G2frame.dataFrame.SetStatusText('')
+    G2frame.SetStatusText('')
     keyList = G2frame.GetHistogramNames(['PWDR','HKLF'])
     UseList = data['Histograms']
@@ -985 +985 @@
     if DData.GetSizer():
         DData.GetSizer().Clear(True)
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add(wx.StaticText(DData,wx.ID_ANY,' Histogram data for '+PhaseName+':'),0,WACV|wx.LEFT,5)

branch/2frame/GSASIIgrid.py

@@ -53 +53 @@
 # Define a short name for convenience
 WACV = wx.ALIGN_CENTER_VERTICAL
-
 [ wxID_FOURCALC, wxID_FOURSEARCH, wxID_FOURCLEAR, wxID_PEAKSMOVE, wxID_PEAKSCLEAR, 
     wxID_CHARGEFLIP, wxID_PEAKSUNIQUE, wxID_PEAKSDELETE, wxID_PEAKSDA,
@@ -158 +157 @@
 [ wxID_MCRON,wxID_MCRLIST,wxID_MCRSAVE,wxID_MCRPLAY,
 ] = [wx.NewId() for item in range(4)]
+
+
 
 VERY_LIGHT_GREY = wx.Colour(235,235,235)
@@ -1587 +1588 @@
  
 ################################################################################
-class DataFrame(wx.Frame):
-    '''Create the data item window and all the entries in menus used in
-    that window. For Linux and windows, the menu entries are created for the
-    current data item window, but in the Mac the menu is accessed from all
+class DataWindow(wxscroll.ScrolledPanel):
+    '''Create the data item window entries in menus used in
+    that window. The menu entries are created for all
+    data item windows, but in the Mac the menu is accessed from all
     windows. This means that a different menu is posted depending on which
     data item is posted. On the Mac, all the menus contain the data tree menu
@@ -1599 +1600 @@
     where the functions to be called are defined.
     '''
-    def Bind(self,eventtype,handler,*args,**kwargs):
-        '''Override the Bind() function: on the Mac the binding is to
-        the main window, so that menus operate with any window on top.
-        For other platforms, either wrap calls that will be logged
-        or call the default wx.Frame Bind() to bind to the menu item directly.
-
-        Note that bindings can be made to objects by Id or by direct reference to the
-        object. As a convention, when bindings are to objects, they are not logged
-        but when bindings are by Id, they are logged.
-        '''
-        if sys.platform == "darwin": # mac
-            self.G2frame.Bind(eventtype,handler,*args,**kwargs)
-            return
-        if eventtype == wx.EVT_MENU and 'id' in kwargs:
-            menulabels = log.SaveMenuCommand(kwargs['id'],self.G2frame,handler)
-            if menulabels:
-                #print 'intercepting bind for',handler,menulabels,kwargs['id']
-                wx.Frame.Bind(self,eventtype,self.G2frame.MenuBinding,*args,**kwargs)
-                return
-            wx.Frame.Bind(self,eventtype,handler,*args,**kwargs)      
+#    def Bind(self,eventtype,handler,*args,**kwargs):
+#        '''Override the Bind() function: on the Mac the binding is to
+#        the main window, so that menus operate with any window on top.
+#        For other platforms, either wrap calls that will be logged
+#        or call the default wx.Frame Bind() to bind to the menu item directly.
+#
+#        Note that bindings can be made to objects by Id or by direct reference to the
+#        object. As a convention, when bindings are to objects, they are not logged
+#        but when bindings are by Id, they are logged.
+#        '''
+#        if sys.platform == "darwin": # mac
+#            self.Bind(eventtype,handler,*args,**kwargs)
+#            return
+#        if eventtype == wx.EVT_MENU and 'id' in kwargs:
+##            menulabels = log.SaveMenuCommand(kwargs['id'],self,handler)
+##            if menulabels:
+##                #print 'intercepting bind for',handler,menulabels,kwargs['id']
+##                wx.Window.Bind(self,eventtype,self.MenuBinding,*args,**kwargs)
+##                return
+#            self.Bind(self,eventtype,handler,*args,**kwargs)      
         
     def PrefillDataMenu(self,menu,empty=False):
-        '''Create the "standard" part of data frame menus. Note that on Linux and
-        Windows nothing happens here. On Mac, this menu duplicates the
+        '''Create the "standard" part of data frame menus & add the data menu.  
+        On Mac, this menu duplicates the
         tree menu, but adds an extra help command for the data item and a separator. 
         '''
         self.datamenu = menu
-        self.G2frame.dataMenuBars.append(menu)
-        if sys.platform == "darwin": # mac                         
-            self.G2frame.FillMainMenu(menu,addhelp=False) # add the data tree menu items
-            if not empty:
-                menu.Append(wx.Menu(title=''),title='|') # add a separator
+        self.GetGrandParent().GetParent().FillMainMenu(menu,addhelp=False) # add the data tree menu items to the main menu
+        if not empty:
+            menu.Append(wx.Menu(title=''),title='|') # add a separator
         
     def PostfillDataMenu(self,empty=False):
@@ -1649 +1648 @@
             menu.Append(menu=G2G.MyHelp(self),title='&Help')
 
-    def _init_menus(self):
-        'define all GSAS-II data frame menus'
+
+    def _initMenus_(self):
+        'define all GSAS-II data window menus'
 
         # for use where no menu or data frame help is provided
@@ -1826 +1826 @@
                         ):
             objlist = []
-            for obj in self.G2frame.exporterlist:
+            for obj in self.parent.GetParent().GetParent().exporterlist:
                 if lbl.lower() in obj.exporttype:
                     try:
@@ -2376 +2376 @@
         # setup a cascade menu for the formats that have been defined
         self.ReImportMenuId = {}  # points to readers for each menu entry
-        for reader in self.G2frame.ImportPhaseReaderlist:
+        for reader in self.parent.GetParent().GetParent().ImportPhaseReaderlist:
             item = submenu.Append(
                 wx.ID_ANY,help=reader.longFormatName,
@@ -2587 +2587 @@
         self.PostfillDataMenu()
     # end of GSAS-II menu definitions
-        
-    def _init_ctrls(self, parent,name=None,size=None,pos=None):
-        wx.Frame.__init__(
-            self,parent=parent,
-            #style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX | wx.FRAME_FLOAT_ON_PARENT ,
-            style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX,
-            size=size,pos=pos,title='GSAS-II data display')
-        self._init_menus()
-        if name:
-            self.SetLabel(name)
-        self.Show()
-        
-    def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
-        self.G2frame = frame
-        self._init_ctrls(parent,name,size,pos)
-        self.data = data
-        clientSize = wx.ClientDisplayRect()
-        Size = self.GetSize()
-        xPos = clientSize[2]-Size[0]
-        self.SetPosition(wx.Point(xPos,clientSize[1]+250))
-        self.AtomGrid = []
-        self.selectedRow = 0
-        self.lastSize = Size        
-        self.manualPhaseSize = None
-        self.userReSize = False
-        wx.Frame.Bind(self,wx.EVT_SIZE,self.OnReSize)
-            
-    def OnReSize(self,event):
-        '''Keep track of size changes for Phase windows
-        '''
-        id = self.G2frame.PatternTree.GetSelection()
-        try:
-            parent = self.G2frame.PatternTree.GetItemParent(id)
-        except:         #avoid bad tree item on start via gpx file selection 
-            parent = 0
-        if self.userReSize and parent and self.G2frame.PatternTree.GetItemText(parent) == "Phases":
-            newSize = event.EventObject.GetSize()
-            if newSize[1] < 200: return             #avois spurious small window after Refine
-            if self.lastSize == newSize:
-#                if GSASIIpath.GetConfigValue('debug'):
-#                    print 'no save size=',self.lastSize
-                return
-            self.manualPhaseSize = newSize
-            self.lastSize = event.EventObject.GetSize()
-#            if GSASIIpath.GetConfigValue('debug'):
-#                print 'Saving Phase size=',self.manualPhaseSize
-                #HowDidIgetHere()
-        event.Skip()
-
-    def SendSizeEvent(self):
-        '''Prevent SendSizeEvent from overriding the saved size
-        '''
-        self.userReSize = False
-        wx.Frame.SendSizeEvent(self)
-        self.userReSize = True
-        
-    def setSizePosLeft(self,Size):
-        '''Place the dataFrame window so that the upper left-hand corner remains in the same place;
-        The size is dictated by parameter Width, unless overridden by a previous Phase window resize
-        '''
-        self.userReSize = False
-#        if GSASIIpath.GetConfigValue('debug'):
-#            print 'setSizePosLeft size',Size,self.lastSize
-        Size = list(Size)
-        id = self.G2frame.PatternTree.GetSelection()
-        try:            #avoid bad tree item on start via gpx file selection 
-            pid = self.G2frame.PatternTree.GetItemParent(id)
-        except:
-            pid = 0
-        if pid:
-            parent = self.G2frame.PatternTree.GetItemText(pid)
-            # is this a phase window and has a previous window has been resized?
-            if self.manualPhaseSize and parent == "Phases":
-                Size = list(self.manualPhaseSize)
-        Pos = self.GetPosition()
-        clientSize = wx.ClientDisplayRect()     #display window size (e.g. 1304x768)
-        Size[1] = min(Size[1],clientSize[2]-300)
-        Size[0] = max(Size[0],300)
-#        print 'current position/width:',Pos,Width
-        self.SetSize(Size)
-        Size[1] += 1        #kluge to ensure scrollbar settings & window properly displayed
-        self.SetSize(Size)
-        Pos[0] += self.lastSize[0]-Size[0]
-        offSet = 0
-        if Pos[0] < clientSize[2]:
-            offSet = Pos[0]+Size[0]-clientSize[2]
-        if offSet > 0:
-            Pos[0] -= offSet
-        self.SetPosition(wx.Point(Pos[0],Pos[1]))
-        self.lastSize = Size
-        self.userReSize = True
-        
-    def Clear(self):
-        self.ClearBackground()
+    
+    def __init__(self,parent):
+        wxscroll.ScrolledPanel.__init__(self,parent,wx.ID_ANY,size=parent.GetSize())
+        self.parent = parent
+        self._initMenus_()
+        self.currentGrids = []
+        
+    def ClearData(self):
+#        if self.GetSizer():
+#            self.GetSizer().Destroy()
+        self.SetBackgroundColour(wx.WHITE)
         self.DestroyChildren()
+#        self.SetSize(self.GetParent().GetSize())
+        
+#TODO - remove         
+#    def _init_ctrls(self, parent,name=None,size=None,pos=None):
+#        wx.Frame.__init__(
+#            self,parent=parent,
+#            #style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX | wx.FRAME_FLOAT_ON_PARENT ,
+#            style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX,
+#            size=size,pos=pos,title='GSAS-II data display')
+#        self._init_menus()
+#        if name:
+#            self.SetLabel(name)
+#        self.Show()
+#
+#    def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
+#        self.G2frame = frame
+#        self._init_ctrls(parent,name,size,pos)
+#        self.data = data
+#        clientSize = wx.ClientDisplayRect()
+#        Size = self.GetSize()
+#        xPos = clientSize[2]-Size[0]
+#        self.SetPosition(wx.Point(xPos,clientSize[1]+250))
+#        self.AtomGrid = []
+#        self.selectedRow = 0
+#        self.lastSize = Size        
+#        self.manualPhaseSize = None
+#        self.userReSize = False
+#        wx.Frame.Bind(self,wx.EVT_SIZE,self.OnReSize)
+#            
+#    def OnReSize(self,event):
+#        '''Keep track of size changes for Phase windows
+#        '''
+#        id = self.G2frame.PatternTree.GetSelection()
+#        try:
+#            parent = self.G2frame.PatternTree.GetItemParent(id)
+#        except:         #avoid bad tree item on start via gpx file selection 
+#            parent = 0
+#        if self.userReSize and parent and self.G2frame.PatternTree.GetItemText(parent) == "Phases":
+#            newSize = event.EventObject.GetSize()
+#            if newSize[1] < 200: return             #avois spurious small window after Refine
+#            if self.lastSize == newSize:
+##                if GSASIIpath.GetConfigValue('debug'):
+##                    print 'no save size=',self.lastSize
+#                return
+#            self.manualPhaseSize = newSize
+#            self.lastSize = event.EventObject.GetSize()
+##            if GSASIIpath.GetConfigValue('debug'):
+##                print 'Saving Phase size=',self.manualPhaseSize
+#                #HowDidIgetHere()
+#        event.Skip()
+#
+#    def SendSizeEvent(self):
+#        '''Prevent SendSizeEvent from overriding the saved size
+#        '''
+#        self.userReSize = False
+#        wx.Frame.SendSizeEvent(self)
+#        self.userReSize = True
+#                
+#    def Clear(self):
+#        self.ClearBackground()
+#        self.DestroyChildren()
                    
-
 ################################################################################
 #####  Notebook Tree Item editor
@@ -2693 +2670 @@
     def OnNoteBook(event):
         event.Skip()
-        data = G2frame.dataDisplay.GetValue().split('\n')
+        data = text.GetValue().split('\n')
         G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Notebook'),data)
         if 'nt' not in os.name:
-            G2frame.dataDisplay.AppendText('\n')
+            text.AppendText('\n')
                     
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
-    G2frame.dataFrame.SetLabel('Notebook')
-    G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Notebook')
+    G2frame.dataWindow.ClearData()
+    G2frame.dataWindow.SetupScrolling()
+    mainSizer = wx.BoxSizer()
+    text = wx.TextCtrl(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetSize(),
         style=wx.TE_MULTILINE|wx.TE_PROCESS_ENTER | wx.TE_DONTWRAP)
-    G2frame.dataDisplay.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
-    G2frame.dataDisplay.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
+    text.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
+    text.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
     for line in data:
-        G2frame.dataDisplay.AppendText(line+"\n")
-    G2frame.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
-    G2frame.dataFrame.setSizePosLeft([400,250])
+        text.AppendText(line+"\n")
+    text.AppendText('Notebook entry @ '+time.ctime()+"\n")
+    mainSizer.Add(text,1,wx.EXPAND)
+    G2frame.dataWindow.SetSizer(mainSizer)
+    G2frame.SetDataSize()
+            
+################################################################################
+#####  Comments
+################################################################################           
+       
+def UpdateComments(G2frame,data):                   
+
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Comments')
+    G2frame.dataWindow.ClearData()
+    G2frame.dataWindow.SetupScrolling()
+    text = wx.TextCtrl(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetSize(),
+        style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP)
+    for line in data:
+        if '\n' not in line:
+            text.AppendText(line+'\n')
+        else:
+            text.AppendText(line)
+    mainSizer = wx.BoxSizer()
+    mainSizer.Add(text,1,wx.EXPAND)
+    G2frame.dataWindow.SetSizer(mainSizer)
+    G2frame.SetDataSize()
             
 ################################################################################
@@ -2785 +2786 @@
         seqSizer = wx.BoxSizer(wx.VERTICAL)
         dataSizer = wx.BoxSizer(wx.HORIZONTAL)
-        dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sequential Refinement: '),0,WACV)
-        selSeqData = wx.Button(G2frame.dataDisplay,-1,label=' Select data')
+        dataSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Sequential Refinement: '),0,WACV)
+        selSeqData = wx.Button(G2frame.dataWindow,-1,label=' Select data')
         selSeqData.Bind(wx.EVT_BUTTON,OnSelectData)
         dataSizer.Add(selSeqData,0,WACV)
@@ -2795 +2796 @@
             lbl = ' ('+str(len(SeqData))+' dataset(s) selected)'
 
-        dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=lbl),0,WACV)
+        dataSizer.Add(wx.StaticText(G2frame.dataWindow,label=lbl),0,WACV)
         seqSizer.Add(dataSizer,0)
         if SeqData:
             selSizer = wx.BoxSizer(wx.HORIZONTAL)
-            reverseSel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Reverse order?')
+            reverseSel = wx.CheckBox(G2frame.dataWindow,-1,label=' Reverse order?')
             reverseSel.Bind(wx.EVT_CHECKBOX,OnReverse)
             reverseSel.SetValue(data['Reverse Seq'])
             selSizer.Add(reverseSel,0,WACV)
-            copySel =  wx.CheckBox(G2frame.dataDisplay,-1,label=' Copy results to next histogram?')
+            copySel =  wx.CheckBox(G2frame.dataWindow,-1,label=' Copy results to next histogram?')
             copySel.Bind(wx.EVT_CHECKBOX,OnCopySel)
             copySel.SetValue(data['Copy2Next'])
@@ -2838 +2839 @@
             
         LSSizer = wx.FlexGridSizer(cols=4,vgap=5,hgap=5)
-        LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement derivatives: '),0,WACV)
+        LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Refinement derivatives: '),0,WACV)
         Choice=['analytic Jacobian','numeric','analytic Hessian','Hessian SVD']   #TODO +'SVD refine' - what flags will it need?
-        derivSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['deriv type'],choices=Choice,
+        derivSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['deriv type'],choices=Choice,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         derivSel.SetValue(data['deriv type'])
@@ -2846 +2847 @@
             
         LSSizer.Add(derivSel,0,WACV)
-        LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min delta-M/M: '),0,WACV)
-        LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'min dM/M',nDig=(10,2,'g'),min=1.e-9,max=1.),0,WACV)
+        LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Min delta-M/M: '),0,WACV)
+        LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'min dM/M',nDig=(10,2,'g'),min=1.e-9,max=1.),0,WACV)
         if 'Hessian' in data['deriv type']:
-            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max cycles: '),0,WACV)
+            LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Max cycles: '),0,WACV)
             Choice = ['0','1','2','3','5','10','15','20']
-            maxCyc = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['max cyc']),choices=Choice,
+            maxCyc = wx.ComboBox(parent=G2frame.dataWindow,value=str(data['max cyc']),choices=Choice,
                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
             maxCyc.Bind(wx.EVT_COMBOBOX, OnMaxCycles)
             LSSizer.Add(maxCyc,0,WACV)
             if 'SVD' not in data['deriv type']:
-                LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial lambda = 10**'),0,WACV)
+                LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Initial lambda = 10**'),0,WACV)
                 MarqChoice = ['-3','-2','-1','0','1','2','3','4']
-                marqLam = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['Marquardt']),choices=MarqChoice,
+                marqLam = wx.ComboBox(parent=G2frame.dataWindow,value=str(data['Marquardt']),choices=MarqChoice,
                     style=wx.CB_READONLY|wx.CB_DROPDOWN)
                 marqLam.Bind(wx.EVT_COMBOBOX,OnMarqLam)
                 LSSizer.Add(marqLam,0,WACV)
-            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' SVD zero tolerance:'),0,WACV)
-            LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'SVDtol',nDig=(10,1,'g'),min=1.e-9,max=.01),0,WACV)
+            LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' SVD zero tolerance:'),0,WACV)
+            LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'SVDtol',nDig=(10,1,'g'),min=1.e-9,max=.01),0,WACV)
         else:       #TODO what for SVD refine?
-            LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial shift factor: '),0,WACV)
-            Factr = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'shift factor',nDig=(10,5),min=1.e-5,max=100.)
+            LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Initial shift factor: '),0,WACV)
+            Factr = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'shift factor',nDig=(10,5),min=1.e-5,max=100.)
             LSSizer.Add(Factr,0,WACV)
         if G2frame.Sngl:
@@ -2874 +2875 @@
                 'MinD':[' Min d-spacing (0.1-2.0): ',[0.1,2.0],]}
 
-            fsqRef = wx.CheckBox(G2frame.dataDisplay,-1,label='Refine HKLF as F^2? ')
+            fsqRef = wx.CheckBox(G2frame.dataWindow,-1,label='Refine HKLF as F^2? ')
             fsqRef.SetValue(data['F**2'])
             fsqRef.Bind(wx.EVT_CHECKBOX,OnFsqRef)
@@ -2880 +2881 @@
             LSSizer.Add((1,0),)
             for item in usrRej:
-                LSSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=usrRej[item][0]),0,WACV)
-                usrrej = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,userReject,item,nDig=(10,2),
+                LSSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=usrRej[item][0]),0,WACV)
+                usrrej = G2G.ValidatedTxtCtrl(G2frame.dataWindow,userReject,item,nDig=(10,2),
                     min=usrRej[item][1][0],max=usrRej[item][1][1])
                 LSSizer.Add(usrrej,0,WACV)
@@ -2894 +2895 @@
         Author = data['Author']
         authSizer = wx.BoxSizer(wx.HORIZONTAL)
-        authSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' CIF Author (last, first):'),0,WACV)
-        auth = wx.TextCtrl(G2frame.dataDisplay,-1,value=Author,style=wx.TE_PROCESS_ENTER)
+        authSizer.Add(wx.StaticText(G2frame.dataWindow,label=' CIF Author (last, first):'),0,WACV)
+        auth = wx.TextCtrl(G2frame.dataWindow,-1,value=Author,style=wx.TE_PROCESS_ENTER)
         auth.Bind(wx.EVT_TEXT_ENTER,OnAuthor)
         auth.Bind(wx.EVT_KILL_FOCUS,OnAuthor)
@@ -2901 +2902 @@
         return authSizer
         
-        
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()
+    if 'SVD' in data['deriv type']:
+        G2frame.GetStatusBar().SetStatusText('Hessian SVD not recommended for initial refinements; use analytic Hessian or Jacobian')
     else:
-        Status = G2frame.dataFrame.GetStatusBar()
-    if 'SVD' in data['deriv type']:
-        Status.SetStatusText('Hessian SVD not recommended for initial refinements; use analytic Hessian or Jacobian')
-    else:
-        Status.SetStatusText('')
-    G2frame.dataFrame.SetLabel('Controls')
-    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
-    SetDataMenuBar(G2frame,G2frame.dataFrame.ControlsMenu)
+        G2frame.GetStatusBar().SetStatusText('')
+    G2frame.dataWindow.ClearData()
+    G2frame.dataWindow.SetupScrolling()
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Controls')
+    SetDataMenuBar(G2frame,G2frame.dataWindow.ControlsMenu)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,5),0)
-    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement Controls:'),0,WACV)    
+    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Refinement Controls:'),0,WACV)    
     mainSizer.Add(LSSizer())
     mainSizer.Add((5,5),0)
@@ -2925 +2920 @@
     mainSizer.Add((5,5),0)
         
-    mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
+    mainSizer.Layout()
+    mainSizer.FitInside(G2frame.dataWindow)    
+    G2frame.dataWindow.SetSizer(mainSizer)
+    G2frame.dataWindow.SetAutoLayout(1)
+    G2frame.SetDataSize()
      
-################################################################################
-#####  Comments
-################################################################################           
-       
-def UpdateComments(G2frame,data):                   
-
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
-    G2frame.dataFrame.SetLabel('Comments')
-    G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
-        style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP)
-    for line in data:
-        if '\n' not in line:
-            G2frame.dataDisplay.AppendText(line+'\n')
-        else:
-            G2frame.dataDisplay.AppendText(line)
-    G2frame.dataFrame.setSizePosLeft([400,250])
-            
 ################################################################################
 #####  Display of Sequential Results
@@ -3234 +3213 @@
         else:
             val = False
-        G2frame.dataFrame.SequentialPvars.Enable(wxDELSEQVAR,val)
-        G2frame.dataFrame.SequentialPvars.Enable(wxEDITSEQVAR,val)
+        G2frame.dataWindow.SequentialPvars.Enable(wxDELSEQVAR,val)
+        G2frame.dataWindow.SequentialPvars.Enable(wxEDITSEQVAR,val)
 
     def DelPseudoVar(event):
@@ -3752 +3731 @@
     if G2frame.dataDisplay:
         G2frame.dataDisplay.Destroy()
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()
-        Status.SetStatusText("Select column to export; Double click on column to plot data; on row for Covariance")
+    G2frame.GetStatusBar().SetStatusText("Select column to export; Double click on column to plot data; on row for Covariance")
     sampleParms = GetSampleParms()
 
@@ -3809 +3786 @@
             initialCell[str(pId)+'::A'+str(i)] =  RecpCellTerms[pId][i]
 
-    SetDataMenuBar(G2frame,G2frame.dataFrame.SequentialMenu)
-    G2frame.dataFrame.SetLabel('Sequential refinement results')
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()
-        Status.SetStatusText('')
+    SetDataMenuBar(G2frame,G2frame.dataWindow.SequentialMenu)
+    G2frame.dataFrame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Sequential refinement results')
+    G2frame.GetStatusBar().SetStatusText('')
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnRenameSelSeq, id=wxID_RENAMESEQSEL)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeq, id=wxID_SAVESEQSEL)
@@ -4147 +4122 @@
             del G2frame.colSigs[l]
 
+    G2frame.dataWindow.ClearData()
     G2frame.dataFrame.currentGrids = []
-    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
+    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataWindow)
+    G2frame.dataDisplay.SetSize(G2frame.dataWindow.GetSize())
     G2frame.SeqTable = G2G.Table([list(cl) for cl in zip(*G2frame.colList)],     # convert from columns to rows
         colLabels=colLabels,rowLabels=histNames,types=Types)
@@ -4162 +4139 @@
     G2frame.dataDisplay.SetMargins(0,0)
     G2frame.dataDisplay.AutoSizeColumns(False)
-    if prevSize:
-        G2frame.dataFrame.setSizePosLeft(prevSize)
-    else:
-        G2frame.dataFrame.setSizePosLeft([700,350])
     # highlight unconverged shifts 
     if histNames[0][:4] not in ['SASD','IMG ','REFD',]:
@@ -4378 +4351 @@
            
     data = G2frame.PatternTree.GetItemPyData(item)
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+G2frame.PatternTree.GetItemText(item))
 #patches
     if not data:
@@ -4394 +4368 @@
         G2frame.PatternTree.SetItemPyData(item,data)
 #end patches
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
     if kind in ['PWDR','SASD','REFD']:
-        SetDataMenuBar(G2frame,G2frame.dataFrame.PWDRMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, onCopyPlotCtrls, id=wxID_PLOTCTRLCOPY)
+        SetDataMenuBar(G2frame,G2frame.dataWindow.PWDRMenu)
+        G2frame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
+        G2frame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
+        G2frame.Bind(wx.EVT_MENU, onCopyPlotCtrls, id=wxID_PLOTCTRLCOPY)
     elif kind in ['HKLF',]:
-        SetDataMenuBar(G2frame,G2frame.dataFrame.HKLFMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnMergeHKL, id=wxID_MERGEHKL)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=wxID_PWD3DHKLPLOT)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotAll3DHKL, id=wxID_3DALLHKLPLOT)
-#        G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
-    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
+        SetDataMenuBar(G2frame,G2frame.dataWindow.HKLFMenu)
+        G2frame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
+        G2frame.Bind(wx.EVT_MENU, OnMergeHKL, id=wxID_MERGEHKL)
+        G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=wxID_PWD3DHKLPLOT)
+        G2frame.Bind(wx.EVT_MENU, OnPlotAll3DHKL, id=wxID_3DALLHKLPLOT)
     
+    G2frame.dataWindow.ClearData()
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,5),)
     wtSizer = wx.BoxSizer(wx.HORIZONTAL)
-    wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Weight factor: '),0,WACV)
-    wtval = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[0],'wtFactor',nDig=(10,3),min=1.e-9)
+    wtSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Weight factor: '),0,WACV)
+    wtval = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[0],'wtFactor',nDig=(10,3),min=1.e-9)
     wtSizer.Add(wtval,0,WACV)
 #    if kind == 'PWDR':         #possible future compression feature; NB above patch as well
-#        wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Compression factor: '),0,WACV)
+#        wtSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Compression factor: '),0,WACV)
 #        choice = ['1','2','3','4','5','6']
-#        comp = wx.ComboBox(parent=G2frame.dataDisplay,choices=choice,
+#        comp = wx.ComboBox(parent=G2frame.dataWindow,choices=choice,
 #            style=wx.CB_READONLY|wx.CB_DROPDOWN)
 #        comp.SetValue(str(data[0]['Compression']))
@@ -4435 +4406 @@
         lbl += u'\n(Edit range resets observed intensities).'
         lbl = lbl.format(Tmin,Tmax,t,step,num)
-        simSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,lbl),
+        simSizer.Add(wx.StaticText(G2frame.dataWindow,wx.ID_ANY,lbl),
                     0,WACV)
-        but = wx.Button(G2frame.dataDisplay,wx.ID_ANY,"Edit range")
+        but = wx.Button(G2frame.dataWindow,wx.ID_ANY,"Edit range")
         but.Bind(wx.EVT_BUTTON,onEditSimRange)
         simSizer.Add(but,0,WACV)
         mainSizer.Add(simSizer)
     if 'Nobs' in data[0]:
-        mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
+        mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
             ' Data residual wR: %.3f%% on %d observations'%(data[0]['wR'],data[0]['Nobs'])))
         if kind == 'PWDR':
-            mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
+            mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
                 ' Durbin-Watson statistic: %.3f'%(data[0].get('Durbin-Watson',0.))))
         for value in data[0]:
@@ -4453 +4424 @@
                 if 'SS' in value:
                     mainSizer.Add((5,5),)
-                    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For incommensurate phase '+name+':'))
+                    mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' For incommensurate phase '+name+':'))
                     for m,(Rf2,Rf,Nobs) in enumerate(zip(data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])):
-                        mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
+                        mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
                             u' m = +/- %d: RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections  '% \
                             (m,Rf2,Rf,Nobs)))
                 else:
                     mainSizer.Add((5,5),)
-                    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For phase '+name+':'))
-                    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
+                    mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' For phase '+name+':'))
+                    mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
                         u' Unweighted phase residuals RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections  '% \
                         (data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])))
@@ -4467 +4438 @@
     mainSizer.Add((5,5),)
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    Size = mainSizer.Fit(G2frame.dataFrame)
-    Size[1] += 10
-    G2frame.dataFrame.setSizePosLeft(Size)
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataWindow)
+    G2frame.SetDataSize()
+    
     G2frame.PatternTree.SetItemPyData(item,data)
     G2frame.PatternId = item
@@ -4583 +4554 @@
             if G2frame.dataDisplay: 
                 oldPage = G2frame.dataDisplay.GetSelection()
-        G2frame.dataFrame.Clear()
-        G2frame.dataFrame.SetLabel('')
-    else:
-        #create the frame for the data item window
-        G2frame.dataFrame = DataFrame(parent=G2frame.mainPanel,frame=G2frame)
-        G2frame.dataFrame.PhaseUserSize = None
+        G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'')
         
     SetDataMenuBar(G2frame)
-    G2frame.dataFrame.currentGrids = [] # this will contain pointers to a grid placed in the frame
     G2frame.PickId = item
     G2frame.PickIdText = None
     parentID = G2frame.root
-    #for i in G2frame.ExportPattern: i.Enable(False)
-    defWid = [250,150]
     if item == G2frame.root:
-        G2frame.dataFrame.helpKey = "Data tree"
-        G2frame.dataFrame.setSizePosLeft(defWid)
-        wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
+        G2frame.helpKey = "Data tree"
+        wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.GetClientSize(),
                     value='Select an item from the tree to see/edit parameters')        
-        G2frame.dataFrame.Raise()            
         return
     else:
-        parentID = G2frame.PatternTree.GetItemParent(item)
-        # save name of calling tree item for help. N.B. may want to override this later
-        prfx = G2frame.PatternTree.GetItemText(item).split()[0]
-        prfx1 = G2frame.PatternTree.GetItemText(parentID).split()[0]
-        if prfx in ('IMG','PKS','PWDR','SASD','HKLF','PDF','refd',):
-            G2frame.dataFrame.helpKey = prfx
-        elif prfx1 in ('IMG','PKS','PWDR','SASD','HKLF','PDF','REFD',):
-            suffix = G2frame.PatternTree.GetItemText(item)
-            suffix1 = suffix.split()[0]
-            if '(Q)' in suffix1 or '(R)' in suffix1: suffix = suffix1
-            G2frame.dataFrame.helpKey = prfx1 + '_' + suffix
-        else:
-            G2frame.dataFrame.helpKey = G2frame.PatternTree.GetItemText(item) # save name of calling tree item for help
+        try:    #don't know why here when opening new project  from inside phase data!
+            parentID = G2frame.PatternTree.GetItemParent(item)
+            # save name of calling tree item for help. N.B. may want to override this later
+            prfx = G2frame.PatternTree.GetItemText(item).split()[0]
+            prfx1 = G2frame.PatternTree.GetItemText(parentID).split()[0]
+            if prfx in ('IMG','PKS','PWDR','SASD','HKLF','PDF','refd',):
+                G2frame.dataFrame.helpKey = prfx
+            elif prfx1 in ('IMG','PKS','PWDR','SASD','HKLF','PDF','REFD',):
+                suffix = G2frame.PatternTree.GetItemText(item)
+                suffix1 = suffix.split()[0]
+                if '(Q)' in suffix1 or '(R)' in suffix1: suffix = suffix1
+                G2frame.dataFrame.helpKey = prfx1 + '_' + suffix
+            else:
+                G2frame.dataFrame.helpKey = G2frame.PatternTree.GetItemText(item) # save name of calling tree item for help
+        except IndexError:
+            print 'bug: why here?'
+            return
     if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
         G2frame.PatternId = 0
         if G2frame.PatternTree.GetItemText(item) == 'Notebook':
-            SetDataMenuBar(G2frame,G2frame.dataFrame.DataNotebookMenu)
-            #for i in G2frame.ExportPattern: i.Enable(False)
+            SetDataMenuBar(G2frame,G2frame.dataWindow.DataNotebookMenu)
             data = G2frame.PatternTree.GetItemPyData(item)
             UpdateNotebook(G2frame,data)
         elif G2frame.PatternTree.GetItemText(item) == 'Controls':
-            #for i in G2frame.ExportPattern: i.Enable(False)
             data = G2frame.PatternTree.GetItemPyData(item)
             if not data:           #fill in defaults
@@ -4640 +4603 @@
         elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
             data = G2frame.PatternTree.GetItemPyData(item)
-            G2frame.dataFrame.setSizePosLeft(defWid)
             text = ''
             if 'Rvals' in data:
@@ -4650 +4612 @@
                 if 'lamMax' in Rvals:
                     text += '\nlog10 MaxLambda = %.1f'%(np.log10(Rvals['lamMax']))
-            wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
+            G2frame.dataWindow.ClearData()
+            wx.TextCtrl(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetSize(),
                 value='See plot window for covariance display'+text,style=wx.TE_MULTILINE)
             G2plt.PlotCovariance(G2frame,data)
@@ -4665 +4628 @@
             if Phases:
                 phaseName = Phases.keys()[0]
-            G2frame.dataFrame.setSizePosLeft(defWid)
             G2restG.UpdateRestraints(G2frame,data,Phases,phaseName)
         elif G2frame.PatternTree.GetItemText(item).startswith('IMG '):
             G2frame.Image = item
-            G2frame.dataFrame.SetTitle('Image Data')
+            G2frame.SetTitle('Image Data')
             data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(
                 G2frame,item,'Image Controls'))
@@ -4702 +4664 @@
                 G2plt.PlotISFG(G2frame,data,plotType='G(R)')
         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')            
@@ -4727 +4688 @@
         G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
     elif G2frame.PatternTree.GetItemText(item) == 'Comments':
-        SetDataMenuBar(G2frame,G2frame.dataFrame.DataCommentsMenu)
+        SetDataMenuBar(G2frame,G2frame.dataWindow.DataCommentsMenu)
         G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
         data = G2frame.PatternTree.GetItemPyData(item)
         UpdateComments(G2frame,data)
     elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
-        G2frame.dataFrame.SetTitle('Image Controls')
+        G2frame.SetTitle('Image Controls')
         G2frame.Image = G2frame.PatternTree.GetItemParent(item)
         masks = G2frame.PatternTree.GetItemPyData(
@@ -4741 +4702 @@
         G2plt.PlotImage(G2frame,newPlot=False)
     elif G2frame.PatternTree.GetItemText(item) == 'Masks':
-        G2frame.dataFrame.SetTitle('Masks')
+        G2frame.SetTitle('Masks')
         G2frame.Image = G2frame.PatternTree.GetItemParent(item)
         masks = G2frame.PatternTree.GetItemPyData(item)
@@ -4750 +4711 @@
         G2plt.PlotImage(G2frame,newPlot=False)
     elif G2frame.PatternTree.GetItemText(item) == 'Stress/Strain':
-        G2frame.dataFrame.SetTitle('Stress/Strain')
+        G2frame.SetTitle('Stress/Strain')
         G2frame.Image = G2frame.PatternTree.GetItemParent(item)
         data = G2frame.PatternTree.GetItemPyData(
@@ -4865 +4826 @@
     if G2frame.PickId:
         G2frame.PickIdText = G2frame.GetTreeItemsList(G2frame.PickId)
-    G2frame.dataFrame.Raise()
+    G2frame.Raise()
     if oldFocus:
         oldFocus.GetTopLevelParent().Raise()
@@ -4871 +4832 @@
         
 def SetDataMenuBar(G2frame,menu=None):
-    '''Set the menu for the data frame. On the Mac put this
-    menu for the data tree window instead.
+    '''Set the menu for the data frame.
 
     Note that data frame items do not have menus, for these (menu=None)
-    display a blank menu or on the Mac display the standard menu for
-    the data tree window.
+    display the standard main menu for the data tree window.
     '''
-    if sys.platform == "darwin":
-        if menu is None:
-            G2frame.SetMenuBar(G2frame.GSASIIMenu)
-        else:
-            G2frame.SetMenuBar(menu)
+    if menu is None:
+        G2frame.SetMenuBar(G2frame.GSASIIMenu)
     else:
-        if menu is None:
-            G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
-        else:
-            G2frame.dataFrame.SetMenuBar(menu)
+        G2frame.SetMenuBar(menu)
 
 def HowDidIgetHere():

branch/2frame/GSASIIimgGUI.py

@@ -22 +22 @@
 import sys
 import wx
-import wx.lib.scrolledpanel as wxscroll
 import wx.lib.mixins.listctrl  as  listmix
 import matplotlib as mpl
@@ -106 +105 @@
         G2plt.PlotExposedImage(G2frame,newPlot=True,event=tc.event)
         
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()
-    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
+#    G2frame.dataWindow = wx.Panel(G2frame.dataFrame)
     G2frame.ImageZ = GetImageZ(G2frame,data)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
-    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,
+    mainSizer.Add(wx.StaticText(G2frame.dataWindow,
         label='Do not change anything here unless you are absolutely sure!'),0,WACV)
-    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Image size: %d by %d'%(data['size'][0],data['size'][1])),0,WACV)
+    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Image size: %d by %d'%(data['size'][0],data['size'][1])),0,WACV)
     pixSize = wx.FlexGridSizer(0,4,5,5)
     pixLabels = [u' Pixel X-dimension (\xb5m)',u' Pixel Y-dimension (\xb5m)']
     for i,[pixLabel,pix] in enumerate(zip(pixLabels,data['pixelSize'])):
-        pixSize.Add(wx.StaticText(G2frame.dataDisplay,label=pixLabel),0,WACV)
-        pixVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['pixelSize'],i,nDig=(10,3),
+        pixSize.Add(wx.StaticText(G2frame.dataWindow,label=pixLabel),0,WACV)
+        pixVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['pixelSize'],i,nDig=(10,3),
             typeHint=float,OnLeave=OnPixVal)
         pixSize.Add(pixVal,0,WACV)
     mainSizer.Add(pixSize,0)
     distSizer = wx.BoxSizer(wx.HORIZONTAL)
-    distSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Set detector distance: '),0,WACV)
+    distSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Set detector distance: '),0,WACV)
     if 'setdist' not in data:
         data['setdist'] = data['distance']
-    distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'setdist',nDig=(10,4),
+    distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'setdist',nDig=(10,4),
             typeHint=float),0,WACV)
-    distSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Polarization: '),0,WACV)
+    distSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Polarization: '),0,WACV)
     if 'PolaVal' not in data:       #patch
         data['PolaVal'] = [0.99,False]
-    distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['PolaVal'],0,nDig=(10,4),
+    distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['PolaVal'],0,nDig=(10,4),
         min=0.,max=1.,typeHint=float),0,WACV)
     mainSizer.Add(distSizer,0)
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    fitSize = mainSizer.Fit(G2frame.dataFrame)
-    G2frame.dataFrame.setSizePosLeft(fitSize)
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataFrame)
+    G2frame.SetDataSize()
 
 ################################################################################
@@ -583 +578 @@
         
         comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Type of image data: '),0,WACV)
-        typeSel = wx.ComboBox(parent=G2frame.dataDisplay,value=typeDict[data['type']],choices=typeList,
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Type of image data: '),0,WACV)
+        typeSel = wx.ComboBox(parent=G2frame.dataWindow,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,WACV)
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Color bar '),0,WACV)
-        colSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['color'],choices=colorList,
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Color bar '),0,WACV)
+        colSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['color'],choices=colorList,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         colSel.Bind(wx.EVT_COMBOBOX, OnNewColorBar)
         comboSizer.Add(colSel,0,WACV)
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Azimuth offset '),0,WACV)
-        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Azimuth offset '),0,WACV)
+        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'azmthOff',nDig=(10,2),
             typeHint=float,OnLeave=OnAzmthOff)
         comboSizer.Add(azmthOff,0,WACV)
@@ -712 +707 @@
         maxSizer = wx.GridBagSizer(0,0)
         r = c = 0
-        maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max intensity'),(r,c))
+        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Max intensity'),(r,c))
         c += 1
         # maxSel is a slider with 101 steps scaled from Imin+1 to Imax0 with sqrt scaling
@@ -720 +715 @@
         sqrtDeltOne  = math.sqrt(max(1.0,Range[1][1]-max(0.0,Range[1][0])-1)) # sqrt(Imax-Imin-1)
         sv1 = min(100,max(0,int(0.5+100.*sqrtDeltOne/sqrtDeltZero)))
-        maxSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
+        maxSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
         maxSizer.Add(maxSel,(r,c),flag=wx.EXPAND)
         maxSizer.AddGrowableCol(c)
         c += 1
         maxSel.Bind(wx.EVT_SLIDER, OnMaxSlider)
-        maxVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],1,min=Range[0][0]+1,
+        maxVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],1,min=Range[0][0]+1,
             max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
         maxSizer.Add(maxVal,(r,c))
         c += 1
         scaleChoices = ("100%","99%","95%","90%","80%","?")
-        scaleSel = wx.Choice(G2frame.dataDisplay,choices=scaleChoices,size=(-1,-1))
+        scaleSel = wx.Choice(G2frame.dataWindow,choices=scaleChoices,size=(-1,-1))
         if (Range[1][0] == Range[0][0] and
             Range[1][1] == Range[0][1]):
@@ -740 +735 @@
         c = 0
         r = 1
-        maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min intensity'),(r,c))
+        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min intensity'),(r,c))
         c += 1
         # minSel is a slider with 101 steps scaled from Imin0 to Imax-1 with linear scaling
@@ -747 +742 @@
         DeltOne  = max(1.0,Range[1][1]-max(0.0,Range[0][0])-1) # Imax-Imin0-1
         sv0 = min(100,max(0,int(0.5+100.*(Range[1][0]-Range[0][0])/DeltOne)))
-        minSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
+        minSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
         maxSizer.Add(minSel,(r,c),flag=wx.EXPAND|wx.ALL)
         c += 1
         minSel.Bind(wx.EVT_SLIDER, OnMinSlider)
-        minVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],0,
+        minVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],0,
             max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
         maxSizer.Add(minVal,(r,c))
@@ -765 +760 @@
         calibSizer = wx.FlexGridSizer(0,2,5,5)
         calibSizer.SetFlexibleDirection(wx.HORIZONTAL)
-        calibSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration coefficients'),0,WACV)    
+        calibSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calibration coefficients'),0,WACV)    
         calibSizer.Add((5,0),0)
         Names = ['det-X','det-Y','wave','dist','tilt','phi']
@@ -775 +770 @@
             'wave':['Wavelength',(10,6),data,'wavelength']}
         for name in Names:
-            calSel = wx.CheckBox(parent=G2frame.dataDisplay,label=Parms[name][0])
+            calSel = wx.CheckBox(parent=G2frame.dataWindow,label=Parms[name][0])
             calibSizer.Add(calSel,0,WACV)
             calSel.Bind(wx.EVT_CHECKBOX, OnCalRef)
@@ -781 +776 @@
             Indx[calSel] = name
             if name == 'wave':
-                calVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Parms[name][2],
+                calVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Parms[name][2],
                     Parms[name][3],min=0.01,max=10.,nDig=Parms[name][1],typeHint=float)
             elif name == 'dep':
-                calVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Parms[name][2],
+                calVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Parms[name][2],
                     Parms[name][3],min=0.0,max=0.2,nDig=Parms[name][1],typeHint=float)
             else:
-                calVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Parms[name][2],
+                calVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Parms[name][2],
                     Parms[name][3],nDig=Parms[name][1],typeHint=float)
             calibSizer.Add(calVal,0,WACV)
@@ -871 +866 @@
                 
         dataSizer = wx.FlexGridSizer(0,2,5,3)
-        dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Integration coefficients'),0,WACV)    
+        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Integration coefficients'),0,WACV)    
         dataSizer.Add((5,0),0)
         if 'PWDR' in data['type']:
@@ -877 +872 @@
         elif 'SASD' in data['type']:
             binChoice = ['2-theta','Q','log(q)']
-        dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Bin style: Constant step bins in'),0,WACV)            
-        binSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['binType'],choices=binChoice,
+        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Bin style: Constant step bins in'),0,WACV)            
+        binSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['binType'],choices=binChoice,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         binSel.Bind(wx.EVT_COMBOBOX, OnNewBinType)
@@ -885 +880 @@
         if 'q' in data['binType'].lower():
             binType = 'Q'
-        dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Inner/Outer '+binType),0,WACV)            
+        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Inner/Outer '+binType),0,WACV)            
         IOtth = data['IOtth'][:]
         if 'q' in data['binType'].lower():
@@ -891 +886 @@
             IOtth = [4.*math.pi*sind(IOtth[0]/2.)/wave,4.*math.pi*sind(IOtth[1]/2.)/wave]
         littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-        G2frame.InnerTth = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,IOtth,0,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
+        G2frame.InnerTth = G2G.ValidatedTxtCtrl(G2frame.dataWindow,IOtth,0,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
         littleSizer.Add(G2frame.InnerTth,0,WACV)
-        G2frame.OuterTth = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,IOtth,1,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
+        G2frame.OuterTth = G2G.ValidatedTxtCtrl(G2frame.dataWindow,IOtth,1,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
         littleSizer.Add(G2frame.OuterTth,0,WACV)
         dataSizer.Add(littleSizer,0,)
-        dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start/End azimuth'),0,WACV)
+        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Start/End azimuth'),0,WACV)
         LRazim = data['LRazimuth']
         littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-        G2frame.Lazim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,LRazim,0,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
+        G2frame.Lazim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,LRazim,0,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
         littleSizer.Add(G2frame.Lazim,0,WACV)
-        G2frame.Razim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,LRazim,1,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
+        G2frame.Razim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,LRazim,1,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
         if data['fullIntegrate']:
             G2frame.Razim.Enable(False)
@@ -908 +903 @@
         littleSizer.Add(G2frame.Razim,0,WACV)
         dataSizer.Add(littleSizer,0,)
-        dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' No. 2-theta/azimuth bins'),0,WACV)
+        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' No. 2-theta/azimuth bins'),0,WACV)
         littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-        outChan = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'outChannels',typeHint=int,min=10)
+        outChan = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'outChannels',typeHint=int,min=10)
         littleSizer.Add(outChan,0,WACV)
-        outAzim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'outAzimuths',nDig=(10,4),min=1,typeHint=int,OnLeave=OnNumOutAzms)
+        outAzim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'outAzimuths',nDig=(10,4),min=1,typeHint=int,OnLeave=OnNumOutAzms)
         littleSizer.Add(outAzim,0,WACV)
         dataSizer.Add(littleSizer,0,)
         samplechoice = ['Cylinder','Fixed flat plate',]
-        dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Select sample shape'),0,WACV)
-        samShape = wx.ComboBox(G2frame.dataDisplay,value=data['SampleShape'],choices=samplechoice,
+        dataSizer.Add(wx.StaticText(G2frame.dataWindow,label='Select sample shape'),0,WACV)
+        samShape = wx.ComboBox(G2frame.dataWindow,value=data['SampleShape'],choices=samplechoice,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         samShape.Bind(wx.EVT_COMBOBOX,OnSampleShape)
@@ -923 +918 @@
         #SampleShape - cylinder or flat plate choice?
         littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-        samabs = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply sample absorption?')
+        samabs = wx.CheckBox(parent=G2frame.dataWindow,label='Apply sample absorption?')
         dataSizer.Add(samabs,0,WACV)
         samabs.Bind(wx.EVT_CHECKBOX, OnSamAbs)
@@ -929 +924 @@
         minmax = [0.,2.]
         if 'Cylind' in data['SampleShape']: #cylinder mu*R; flat plate transmission
-            littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='mu*R (0.00-2.0) '),0,WACV)
+            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='mu*R (0.00-2.0) '),0,WACV)
         elif 'Fixed' in data['SampleShape']:
-            littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='transmission '),0,WACV) #for flat plate
+            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='transmission '),0,WACV) #for flat plate
             minmax = [.05,1.0]
-        samabsVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['SampleAbs'],0,nDig=(10,3),
+        samabsVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['SampleAbs'],0,nDig=(10,3),
             typeHint=float,min=minmax[0],max=minmax[1])
         littleSizer.Add(samabsVal,0,WACV)
@@ -939 +934 @@
         if 'PWDR' in data['type']:
             littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-            oblique = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply detector absorption?')
+            oblique = wx.CheckBox(parent=G2frame.dataWindow,label='Apply detector absorption?')
             dataSizer.Add(oblique,0,WACV)
             oblique.Bind(wx.EVT_CHECKBOX, OnOblique)
             oblique.SetValue(data['Oblique'][1])
-            littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Value (0.01-0.99)  '),0,WACV)
-            obliqVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Oblique'],0,nDig=(10,3),typeHint=float,min=0.01,max=0.99)
+            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='Value (0.01-0.99)  '),0,WACV)
+            obliqVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Oblique'],0,nDig=(10,3),typeHint=float,min=0.01,max=0.99)
             littleSizer.Add(obliqVal,0,WACV)
             dataSizer.Add(littleSizer,0,)
         if 'SASD' in data['type']:
             littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-            setPolariz = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply polarization?')
+            setPolariz = wx.CheckBox(parent=G2frame.dataWindow,label='Apply polarization?')
             dataSizer.Add(setPolariz,0,WACV)
             setPolariz.Bind(wx.EVT_CHECKBOX, OnApplyPola)
             setPolariz.SetValue(data['PolaVal'][1])
-            littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Value (0.001-0.999)  '),0,WACV)
-            polaVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['PolaVal'],0,nDig=(10,3),typeHint=float,min=0.001,max=0.999)
+            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='Value (0.001-0.999)  '),0,WACV)
+            polaVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['PolaVal'],0,nDig=(10,3),typeHint=float,min=0.001,max=0.999)
             littleSizer.Add(polaVal,0,WACV)
             dataSizer.Add(littleSizer,0,)
         
-        showLines = wx.CheckBox(parent=G2frame.dataDisplay,label='Show integration limits?')
+        showLines = wx.CheckBox(parent=G2frame.dataWindow,label='Show integration limits?')
         dataSizer.Add(showLines,0,WACV)
         showLines.Bind(wx.EVT_CHECKBOX, OnShowLines)
         showLines.SetValue(data['showLines'])
-        fullIntegrate = wx.CheckBox(parent=G2frame.dataDisplay,label='Do full integration?')
+        fullIntegrate = wx.CheckBox(parent=G2frame.dataWindow,label='Do full integration?')
         dataSizer.Add(fullIntegrate,0,WACV)
         fullIntegrate.Bind(wx.EVT_CHECKBOX, OnFullIntegrate)
         fullIntegrate.SetValue(data['fullIntegrate'])
-        setDefault = wx.CheckBox(parent=G2frame.dataDisplay,label='Use for all new images?')
+        setDefault = wx.CheckBox(parent=G2frame.dataWindow,label='Use for all new images?')
         dataSizer.Add(setDefault,0,WACV)
         setDefault.Bind(wx.EVT_CHECKBOX, OnSetDefault)
         setDefault.SetValue(data['setDefault'])
-        centerAzm = wx.CheckBox(parent=G2frame.dataDisplay,label='Azimuth at bin center?')
+        centerAzm = wx.CheckBox(parent=G2frame.dataWindow,label='Azimuth at bin center?')
         dataSizer.Add(centerAzm,0,WACV)
         centerAzm.Bind(wx.EVT_CHECKBOX, OnCenterAzm)
@@ -1006 +1001 @@
         oldFlat = data.get('Flat Bkg',0.)
 
-        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Dark image'),0,WACV)
+        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Dark image'),0,WACV)
         Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
         Source = G2frame.PatternTree.GetItemText(G2frame.Image)
         Choices.pop(Choices.index(Source))
-        darkImage = wx.ComboBox(parent=G2frame.dataDisplay,value=data['dark image'][0],choices=Choices,
+        darkImage = wx.ComboBox(parent=G2frame.dataWindow,value=data['dark image'][0],choices=Choices,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         darkImage.Bind(wx.EVT_COMBOBOX,OnDarkImage)
         backSizer.Add(darkImage)
-        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' multiplier'),0,WACV)
-        darkMult = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['dark image'],1,nDig=(10,3),
+        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' multiplier'),0,WACV)
+        darkMult = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['dark image'],1,nDig=(10,3),
             typeHint=float,OnLeave=OnMult)
         backSizer.Add(darkMult,0,WACV)
-        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Flat Bkg: '),0,WACV)
-        flatbkg = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Flat Bkg',nDig=(10,0),
+        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Flat Bkg: '),0,WACV)
+        flatbkg = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Flat Bkg',nDig=(10,0),
             typeHint=float,OnLeave=OnFlatBkg)
         backSizer.Add(flatbkg,0,WACV)
 
-        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background image'),0,WACV)
-        backImage = wx.ComboBox(parent=G2frame.dataDisplay,value=data['background image'][0],choices=Choices,
+        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background image'),0,WACV)
+        backImage = wx.ComboBox(parent=G2frame.dataWindow,value=data['background image'][0],choices=Choices,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         backImage.Bind(wx.EVT_COMBOBOX,OnBackImage)
         backSizer.Add(backImage)
-        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' multiplier'),0,WACV)
-        backMult = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['background image'],1,nDig=(10,3),
+        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' multiplier'),0,WACV)
+        backMult = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['background image'],1,nDig=(10,3),
             typeHint=float,OnLeave=OnMult)
         backSizer.Add(backMult,0,WACV)
@@ -1066 +1061 @@
         calibSizer = wx.FlexGridSizer(0,3,5,5)
         comboSizer = wx.BoxSizer(wx.HORIZONTAL)    
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibrant '),0,WACV)
-        calSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['calibrant'],choices=calList,
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calibrant '),0,WACV)
+        calSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['calibrant'],choices=calList,
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         calSel.Bind(wx.EVT_COMBOBOX, OnNewCalibrant)
@@ -1074 +1069 @@
         
         comboSizer = wx.BoxSizer(wx.HORIZONTAL)    
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calib lines to skip   '),0,WACV)
-        calibSkip  = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['calibskip']),choices=[str(i) for i in range(25)],
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calib lines to skip   '),0,WACV)
+        calibSkip  = wx.ComboBox(parent=G2frame.dataWindow,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)
@@ -1082 +1077 @@
         
         comboSizer = wx.BoxSizer(wx.HORIZONTAL)        
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min calib d-spacing '),0,WACV)
-        G2frame.calibDmin = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'calibdmin',nDig=(10,2),typeHint=float,min=0.25)
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min calib d-spacing '),0,WACV)
+        G2frame.calibDmin = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'calibdmin',nDig=(10,2),typeHint=float,min=0.25)
         comboSizer.Add(G2frame.calibDmin,0,WACV)
         calibSizer.Add(comboSizer,0)
         
         comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min ring I/Ib '),0,WACV)
-        cutOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'cutoff',nDig=(10,2),min=0.1)
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min ring I/Ib '),0,WACV)
+        cutOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'cutoff',nDig=(10,2),min=0.1)
         comboSizer.Add(cutOff,0,WACV)
         calibSizer.Add(comboSizer,0)
         
         comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-        comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Pixel search range '),0,WACV)
-        pixLimit = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['pixLimit']),choices=['1','2','5','10','15','20'],
+        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Pixel search range '),0,WACV)
+        pixLimit = wx.ComboBox(parent=G2frame.dataWindow,value=str(data['pixLimit']),choices=['1','2','5','10','15','20'],
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         pixLimit.Bind(wx.EVT_COMBOBOX, OnPixLimit)
@@ -1102 +1097 @@
         
         comboSizer = wx.BoxSizer(wx.HORIZONTAL)
-        setRings = wx.CheckBox(parent=G2frame.dataDisplay,label='Show ring picks?')
+        setRings = wx.CheckBox(parent=G2frame.dataWindow,label='Show ring picks?')
         comboSizer.Add(setRings,0)
         setRings.Bind(wx.EVT_CHECKBOX, OnSetRings)
@@ -1144 +1139 @@
         gonioSizer = wx.BoxSizer(wx.HORIZONTAL)
         names = ['Omega','Chi','Phi']
-        gonioSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'Sample goniometer angles: '),0,WACV)
+        gonioSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'Sample goniometer angles: '),0,WACV)
         for i,name in enumerate(names):
-            gonioSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,name),0,WACV)
-            angle = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['GonioAngles'],i,nDig=(8,2),typeHint=float)
+            gonioSizer.Add(wx.StaticText(G2frame.dataWindow,-1,name),0,WACV)
+            angle = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['GonioAngles'],i,nDig=(8,2),typeHint=float)
             gonioSizer.Add(angle,0,WACV)
-        globEdit = wx.Button(G2frame.dataDisplay,-1,'Global edit')
+        globEdit = wx.Button(G2frame.dataWindow,-1,'Global edit')
         globEdit.Bind(wx.EVT_BUTTON,OnGlobalEdit)
         gonioSizer.Add(globEdit,0,WACV)
@@ -1181 +1176 @@
         data['type'] = 'PWDR'
     typeDict = {'PWDR':typeList[0],'SASD':typeList[1],}
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
-    G2gd.SetDataMenuBar(G2frame,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, OnRecalibAll, id=G2gd.wxID_IMRECALIBALL)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnClearCalib, id=G2gd.wxID_IMCLEARCALIB)
+    G2frame.dataWindow.ClearData()
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ImageMenu)
+    G2frame.Bind(wx.EVT_MENU, OnCalibrate, id=G2gd.wxID_IMCALIBRATE)
+    G2frame.Bind(wx.EVT_MENU, OnRecalibrate, id=G2gd.wxID_IMRECALIBRATE)
+    G2frame.Bind(wx.EVT_MENU, OnRecalibAll, id=G2gd.wxID_IMRECALIBALL)
+    G2frame.Bind(wx.EVT_MENU, OnClearCalib, id=G2gd.wxID_IMCLEARCALIB)
     if data.get('calibrant'):
         mode = True
     else:
         mode = False
-    G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=mode)
-    G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMCALIBRATE,enable=mode)
-    G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBALL,enable=mode)
-    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, OnCopySelected, id=G2gd.wxID_IMCOPYSELECTED)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveControls, id=G2gd.wxID_IMSAVECONTROLS)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveMultiControls, id=G2gd.wxID_SAVESELECTEDCONTROLS)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadControls, id=G2gd.wxID_IMLOADCONTROLS)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnTransferAngles, id=G2gd.wxID_IMXFERCONTROLS)
-    G2frame.dataFrame.Bind(wx.EVT_MENU, OnResetDist, id=G2gd.wxID_IMRESETDIST)
+#    G2frame.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=mode)
+#    G2frame.Enable(id=G2gd.wxID_IMCALIBRATE,enable=mode)
+#    G2frame.Enable(id=G2gd.wxID_IMRECALIBALL,enable=mode)
+    G2frame.Bind(wx.EVT_MENU, OnIntegrate, id=G2gd.wxID_IMINTEGRATE)
+    G2frame.Bind(wx.EVT_MENU, OnIntegrateAll, id=G2gd.wxID_INTEGRATEALL)
+    G2frame.Bind(wx.EVT_MENU, OnCopyControls, id=G2gd.wxID_IMCOPYCONTROLS)
+    G2frame.Bind(wx.EVT_MENU, OnCopySelected, id=G2gd.wxID_IMCOPYSELECTED)
+    G2frame.Bind(wx.EVT_MENU, OnSaveControls, id=G2gd.wxID_IMSAVECONTROLS)
+    G2frame.Bind(wx.EVT_MENU, OnSaveMultiControls, id=G2gd.wxID_SAVESELECTEDCONTROLS)
+    G2frame.Bind(wx.EVT_MENU, OnLoadControls, id=G2gd.wxID_IMLOADCONTROLS)
+    G2frame.Bind(wx.EVT_MENU, OnTransferAngles, id=G2gd.wxID_IMXFERCONTROLS)
+    G2frame.Bind(wx.EVT_MENU, OnResetDist, id=G2gd.wxID_IMRESETDIST)
     def OnDestroy(event):
         G2frame.autoIntFrame = None
@@ -1216 +1208 @@
         G2frame.autoIntFrame.Bind(wx.EVT_WINDOW_DESTROY,OnDestroy) # clean up name on window close 
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAutoInt, id=G2gd.wxID_IMAUTOINTEG)
-    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
 
     mainSizer = wx.BoxSizer(wx.VERTICAL)
@@ -1233 +1224 @@
     mainSizer.Add((5,5),0)            
     mainSizer.Add(BackSizer(),0)
-    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration controls:'),0,WACV)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calibration controls:'),0,WACV)
     mainSizer.Add((5,5),0)
     mainSizer.Add(CalibSizer(),0,WACV)
@@ -1240 +1231 @@
         
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    fitSize = mainSizer.Fit(G2frame.dataFrame)
-    G2frame.dataFrame.setSizePosLeft(fitSize)
-    G2frame.dataFrame.SendSizeEvent()
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataFrame)
+    G2frame.SetDataSize()
     
 ################################################################################
@@ -1370 +1360 @@
     def OnAutoSpotMask(event):
         'Do auto search for spot masks'
-        if wx.MessageDialog(G2frame.dataDisplay,'NB: This will clear any old spot masks',
+        if wx.MessageDialog(G2frame.dataWindow,'NB: This will clear any old spot masks',
             'Auto Spot Masks', wx.OK|wx.CANCEL).ShowModal() == wx.ID_OK:
             Controls = copy.deepcopy(G2frame.PatternTree.GetItemPyData( 
@@ -1520 +1510 @@
         maxSizer = wx.GridBagSizer(0,0)
         r = c = 0
-        maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max intensity'),(r,c))
+        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Max intensity'),(r,c))
         c += 1
         # maxSel is a slider with 101 steps scaled from Imin+1 to Imax0 with sqrt scaling
@@ -1528 +1518 @@
         sqrtDeltOne  = math.sqrt(max(1.0,Range[1][1]-max(0.0,Range[1][0])-1)) # sqrt(Imax-Imin-1)
         sv1 = min(100,max(0,int(0.5+100.*sqrtDeltOne/sqrtDeltZero)))
-        maxSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
+        maxSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
         maxSizer.Add(maxSel,(r,c),flag=wx.EXPAND)
         maxSizer.AddGrowableCol(c)
         c += 1
         maxSel.Bind(wx.EVT_SLIDER, OnMaxSlider)
-        maxVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],1,min=Range[0][0]+1,
+        maxVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],1,min=Range[0][0]+1,
             max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
         maxSizer.Add(maxVal,(r,c))
         c += 1
         scaleChoices = ("100%","99%","95%","90%","80%","?")
-        scaleSel = wx.Choice(G2frame.dataDisplay,choices=scaleChoices,size=(-1,-1))
+        scaleSel = wx.Choice(G2frame.dataWindow,choices=scaleChoices,size=(-1,-1))
         if (Range[1][0] == Range[0][0] and
             Range[1][1] == Range[0][1]):
@@ -1548 +1538 @@
         c = 0
         r = 1
-        maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min intensity'),(r,c))
+        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min intensity'),(r,c))
         c += 1
         # minSel is a slider with 101 steps scaled from Imin0 to Imax-1 with linear scaling
@@ -1555 +1545 @@
         DeltOne  = max(1.0,Range[1][1]-max(0.0,Range[0][0])-1) # Imax-Imin0-1
         sv0 = min(100,max(0,int(0.5+100.*(Range[1][0]-Range[0][0])/DeltOne)))
-        minSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
+        minSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
         maxSizer.Add(minSel,(r,c),flag=wx.EXPAND|wx.ALL)
         c += 1
         minSel.Bind(wx.EVT_SLIDER, OnMinSlider)
-        minVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],0,
+        minVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],0,
             max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
         maxSizer.Add(minVal,(r,c))
         return maxSizer
 
+    G2frame.dataWindow.ClearData()
     startScroll = None
-    if G2frame.dataDisplay:
-        startScroll = G2frame.dataDisplay.GetScrollPos(wx.VERTICAL) # save scroll position
-        G2frame.dataDisplay.Destroy()
+    if G2frame.dataWindow:
+        startScroll = G2frame.dataWindow.GetScrollPos(wx.VERTICAL) # save scroll position
     else:
         CleanupMasks(data) # posting page for 1st time; clean out anything unfinished
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MaskMenu)
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MaskMenu)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyMask, id=G2gd.wxID_MASKCOPY)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadMask, id=G2gd.wxID_MASKLOAD)
@@ -1582 +1572 @@
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewPolyMask, id=G2gd.wxID_NEWMASKPOLY)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewFrameMask, id=G2gd.wxID_NEWMASKFRAME)
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()
     if G2frame.MaskKey == 'f':
-        G2frame.dataFrame.GetStatusBar().SetStatusText('Frame mask active - LB pick next point, RB close polygon')
+        G2frame.GetStatusBar().SetStatusText('Frame mask active - LB pick next point, RB close polygon')
     elif G2frame.MaskKey == 'p':
-        G2frame.dataFrame.GetStatusBar().SetStatusText('Polygon mask active - LB pick next point, RB close polygon')
+        G2frame.GetStatusBar().SetStatusText('Polygon mask active - LB pick next point, RB close polygon')
     elif G2frame.MaskKey == 'a':
-        G2frame.dataFrame.GetStatusBar().SetStatusText('Arc mask active - LB pick arc location')
+        G2frame.GetStatusBar().SetStatusText('Arc mask active - LB pick arc location')
     elif G2frame.MaskKey == 'r':
-        G2frame.dataFrame.GetStatusBar().SetStatusText('Ring mask active - LB pick ring location')
+        G2frame.GetStatusBar().SetStatusText('Ring mask active - LB pick ring location')
     else:
-        G2frame.dataFrame.GetStatusBar().SetStatusText("To add mask: press a,r,s,p or f on 2D image for arc/ring/spot/polygon/frame")
-    G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
+        G2frame.GetStatusBar().SetStatusText("To add mask: press a,r,s,p or f on 2D image for arc/ring/spot/polygon/frame")
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,10),0)
@@ -1615 +1602 @@
 
     littleSizer = wx.FlexGridSizer(0,3,0,5)
-    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper limits '),0,WACV)
-    Text = wx.TextCtrl(G2frame.dataDisplay,value=str(thresh[0][0]),style=wx.TE_READONLY)
+    littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Lower/Upper limits '),0,WACV)
+    Text = wx.TextCtrl(G2frame.dataWindow,value=str(thresh[0][0]),style=wx.TE_READONLY)
     littleSizer.Add(Text,0,WACV)
     Text.SetBackgroundColour(VERY_LIGHT_GREY)
-    Text = wx.TextCtrl(G2frame.dataDisplay,value=str(thresh[0][1]),style=wx.TE_READONLY)
+    Text = wx.TextCtrl(G2frame.dataWindow,value=str(thresh[0][1]),style=wx.TE_READONLY)
     littleSizer.Add(Text,0,WACV)
     Text.SetBackgroundColour(VERY_LIGHT_GREY)
-    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper thresholds '),0,WACV)
-    lowerThreshold = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=thresh[1],key=0,
+    littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Lower/Upper thresholds '),0,WACV)
+    lowerThreshold = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=thresh[1],key=0,
         min=thresh[0][0],OnLeave=newReplot,typeHint=int)
     littleSizer.Add(lowerThreshold,0,WACV)
-    upperThreshold = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=thresh[1],key=1,
+    upperThreshold = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=thresh[1],key=1,
         max=thresh[0][1],OnLeave=newReplot,typeHint=int)
     littleSizer.Add(upperThreshold,0,WACV)
     mainSizer.Add(littleSizer,0,)
     if len(Spots):
-        lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Spot masks')
+        lbl = wx.StaticText(parent=G2frame.dataWindow,label=' Spot masks')
         lbl.SetBackgroundColour(wx.Colour(200,200,210))
         mainSizer.Add(lbl,0,wx.EXPAND|wx.ALIGN_CENTER,0)
         littleSizer = wx.FlexGridSizer(0,3,0,5)
-        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' position, mm'),0,WACV)
-        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' diameter, mm'),0,WACV)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' position, mm'),0,WACV)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' diameter, mm'),0,WACV)
         littleSizer.Add((5,0),0)
         for i in range(len(Spots)):
             if len(Spots[i]):
                 x,y,d = Spots[i]
-                spotText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f,%.2f" % (x,y)),
+                spotText = wx.TextCtrl(parent=G2frame.dataWindow,value=("%.2f,%.2f" % (x,y)),
                     style=wx.TE_READONLY)
                 spotText.SetBackgroundColour(VERY_LIGHT_GREY)
                 littleSizer.Add(spotText,0,WACV)
                 spotText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
-                spotDiameter = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Spots[i],key=2,
+                spotDiameter = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=Spots[i],key=2,
                     max=100.,OnLeave=Replot,nDig=[8,2])
                 littleSizer.Add(spotDiameter,0,WACV)
-                spotDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                spotDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
                     locationcode='Delete+Points+'+str(i),handler=onDeleteMask)
                 littleSizer.Add(spotDelete,0,WACV)
         mainSizer.Add(littleSizer,0,)
     if Rings:
-        lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Ring masks')
+        lbl = wx.StaticText(parent=G2frame.dataWindow,label=' Ring masks')
         lbl.SetBackgroundColour(wx.Colour(200,200,210))
         mainSizer.Add(lbl,0,wx.EXPAND|wx.ALIGN_CENTER,0)
         littleSizer = wx.FlexGridSizer(0,3,0,5)
-        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,WACV)
-        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,WACV)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' 2-theta,deg'),0,WACV)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' thickness, deg'),0,WACV)
         littleSizer.Add((5,0),0)
         for i in range(len(Rings)):
             if Rings[i]:
-                ringText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (Rings[i][0])),
+                ringText = wx.TextCtrl(parent=G2frame.dataWindow,value=("%.3f" % (Rings[i][0])),
                     style=wx.TE_READONLY)
                 ringText.SetBackgroundColour(VERY_LIGHT_GREY)
                 ringText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
                 littleSizer.Add(ringText,0,WACV)
-                ringThick = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Rings[i],key=1,
+                ringThick = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=Rings[i],key=1,
                     min=0.001,max=1.,OnLeave=Replot,nDig=[8,3])
                 littleSizer.Add(ringThick,0,WACV)
-                ringDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                ringDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
                     locationcode='Delete+Rings+'+str(i),handler=onDeleteMask)
                 littleSizer.Add(ringDelete,0,WACV)
         mainSizer.Add(littleSizer,0,)
     if Arcs:
-        lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Arc masks')
+        lbl = wx.StaticText(parent=G2frame.dataWindow,label=' Arc masks')
         lbl.SetBackgroundColour(wx.Colour(200,200,210))
         mainSizer.Add(lbl,0,wx.EXPAND|wx.ALIGN_CENTER,0)
         littleSizer = wx.FlexGridSizer(0,4,0,5)
-        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,WACV)
-        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' azimuth, deg'),0,WACV)
-        littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,WACV)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' 2-theta,deg'),0,WACV)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' azimuth, deg'),0,WACV)
+        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' thickness, deg'),0,WACV)
         littleSizer.Add((5,0),0)
         for i in range(len(Arcs)):
             if Arcs[i]:
                 tth,azimuth,thick = Arcs[i]
-                arcText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (tth)),
+                arcText = wx.TextCtrl(parent=G2frame.dataWindow,value=("%.3f" % (tth)),
                     style=wx.TE_READONLY)
                 arcText.SetBackgroundColour(VERY_LIGHT_GREY)
                 arcText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
                 littleSizer.Add(arcText,0,WACV)
-                azmText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%d,%d" % (azimuth[0],azimuth[1])),
+                azmText = wx.TextCtrl(parent=G2frame.dataWindow,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,WACV)
-                arcThick = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Arcs[i],key=2,
+                arcThick = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=Arcs[i],key=2,
                     min=0.001,max=20.,OnLeave=Replot,nDig=[8,3])
                 littleSizer.Add(arcThick,0,WACV)
-                arcDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                arcDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
                     locationcode='Delete+Arcs+'+str(i),handler=onDeleteMask)
                 littleSizer.Add(arcDelete,0,WACV)
         mainSizer.Add(littleSizer,0,)
     if Polygons:
-        lbl = wx.StaticText(parent=G2frame.dataDisplay,
+        lbl = wx.StaticText(parent=G2frame.dataWindow,
             label=' Polygon masks (on plot RB vertex drag to move, LB vertex drag to insert)')
         lbl.SetBackgroundColour(wx.Colour(200,200,210))
@@ -1715 +1702 @@
                 for x,y in Polygons[i]:
                     polyList.append("%.2f, %.2f"%(x,y))
-                polyText = wx.ComboBox(G2frame.dataDisplay,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
+                polyText = wx.ComboBox(G2frame.dataWindow,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
                 littleSizer.Add(polyText,0,WACV)
-                polyDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                polyDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
                     locationcode='Delete+Polygons+'+str(i),handler=onDeleteMask)
                 littleSizer.Add(polyDelete,0,WACV)
         mainSizer.Add(littleSizer,0,)
     if frame:
-        lbl = wx.StaticText(parent=G2frame.dataDisplay,
+        lbl = wx.StaticText(parent=G2frame.dataWindow,
             label=' Frame mask (on plot RB vertex drag to move, LB vertex drag to insert)')
         lbl.SetBackgroundColour(wx.Colour(200,200,210))
@@ -1730 +1717 @@
         for x,y in frame:
             frameList.append("%.2f, %.2f"%(x,y))
-        frameText = wx.ComboBox(G2frame.dataDisplay,value=frameList[0],choices=frameList,style=wx.CB_READONLY)
+        frameText = wx.ComboBox(G2frame.dataWindow,value=frameList[0],choices=frameList,style=wx.CB_READONLY)
         littleSizer.Add(frameText,0,WACV)
-        frameDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+        frameDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
             locationcode='Delete+Frame',handler=onDeleteFrame)
         littleSizer.Add(frameDelete,0,WACV)
         mainSizer.Add(littleSizer,0,)
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    G2frame.dataDisplay.SetupScrolling()
-    Size = mainSizer.Fit(G2frame.dataFrame)
-    Size[0] += 50 # room for scrollbar & status msg
-    Size[1] = min(Size[1],500)
-    G2frame.dataFrame.setSizePosLeft(Size)    
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataFrame)
+    G2frame.SetDataSize()
     if startScroll: # reset scroll to saved position
-        G2frame.dataDisplay.Scroll(0,startScroll) # set to saved scroll position
+        G2frame.dataWindow.Scroll(0,startScroll) # set to saved scroll position
         wx.Yield()
 
@@ -2051 +2035 @@
         
         samSizer = wx.BoxSizer(wx.HORIZONTAL)
-        samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Strain type: '),0,WACV)
-        strType = wx.ComboBox(G2frame.dataDisplay,value=data['Type'],choices=['True','Conventional'],
+        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Strain type: '),0,WACV)
+        strType = wx.ComboBox(G2frame.dataWindow,value=data['Type'],choices=['True','Conventional'],
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         strType.SetValue(data['Type'])
@@ -2058 +2042 @@
         samSizer.Add(strType,0,WACV)
         
-        samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample phi: '),0,WACV)
-        samPhi = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Sample phi',nDig=(10,3),typeHint=float,min=-360.,max=360.)
+        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Sample phi: '),0,WACV)
+        samPhi = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Sample phi',nDig=(10,3),typeHint=float,min=-360.,max=360.)
         samSizer.Add(samPhi,0,WACV)
-        samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample delta-z(mm): '),0,WACV)
-        samZ = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Sample z',nDig=(10,3),typeHint=float)
+        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Sample delta-z(mm): '),0,WACV)
+        samZ = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Sample z',nDig=(10,3),typeHint=float)
         samSizer.Add(samZ,0,WACV)
-        samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample load(MPa): '),0,WACV)
-        samLoad = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Sample load',
+        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Sample load(MPa): '),0,WACV)
+        samLoad = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Sample load',
                 nDig=[8,3],typeHint=float,)
         samSizer.Add(samLoad,0,WACV)
@@ -2112 +2096 @@
         dzeroSizer = wx.FlexGridSizer(0,8,5,5)
         for id,dzero in enumerate(data['d-zero']):
-            dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' d-zero #%d: '%(id))),0,WACV)
-            dZero = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['d-zero'][id],'Dset',
+            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=(' d-zero #%d: '%(id))),0,WACV)
+            dZero = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['d-zero'][id],'Dset',
                 min=0.25,max=20.,nDig=(10,5),typeHint=float,OnLeave=OnDzero)
             dzeroSizer.Add(dZero,0,WACV)
             Indx[dZero.GetId()] = id
-            dfix = wx.CheckBox(G2frame.dataDisplay,label='Use Poisson mean?')
+            dfix = wx.CheckBox(G2frame.dataWindow,label='Use Poisson mean?')
             dfix.SetValue(dzero.get('fixDset',False))
             dfix.Bind(wx.EVT_CHECKBOX,OnFixDset)
             Indx[dfix.GetId()] = id
             dzeroSizer.Add(dfix,0,WACV)
-            dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' d-zero ave: %.5f'%(dzero['Dcalc']))),0,WACV)
+            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=(' d-zero ave: %.5f'%(dzero['Dcalc']))),0,WACV)
                 
-            dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min ring I/Ib '),0,WACV)
-            cutOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['d-zero'][id],'cutoff',
+            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Min ring I/Ib '),0,WACV)
+            cutOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['d-zero'][id],'cutoff',
                     min=0.5,max=20.,nDig=(10,1),typeHint=float,OnLeave=OnCutOff)
             Indx[cutOff.GetId()] = id
             dzeroSizer.Add(cutOff,0,WACV)
         
-            dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Pixel search range '),0,WACV)
-            pixLimit = wx.ComboBox(parent=G2frame.dataDisplay,value=str(dzero['pixLimit']),choices=['1','2','5','10','15','20'],
+            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Pixel search range '),0,WACV)
+            pixLimit = wx.ComboBox(parent=G2frame.dataWindow,value=str(dzero['pixLimit']),choices=['1','2','5','10','15','20'],
                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
             pixLimit.Bind(wx.EVT_COMBOBOX, OnPixLimit)
@@ -2137 +2121 @@
             dzeroSizer.Add(pixLimit,0,WACV)                
                 
-            dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' Strain tensor:')),WACV)
+            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=(' Strain tensor:')),WACV)
             names = ['e11','e12','e22']
             for i in range(3):
-                dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=names[i]),0,WACV)
-                tensorElem = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2f'%(dzero['Emat'][i]),style=wx.TE_READONLY)
+                dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=names[i]),0,WACV)
+                tensorElem = wx.TextCtrl(G2frame.dataWindow,-1,value='%.2f'%(dzero['Emat'][i]),style=wx.TE_READONLY)
                 tensorElem.SetBackgroundColour(VERY_LIGHT_GREY)
                 dzeroSizer.Add(tensorElem,0,WACV)
-            dzeroDelete = wx.CheckBox(parent=G2frame.dataDisplay,label='delete?')
+            dzeroDelete = wx.CheckBox(parent=G2frame.dataWindow,label='delete?')
             dzeroDelete.Bind(wx.EVT_CHECKBOX,OnDeleteDzero)
             delIndx.append(dzeroDelete)
@@ -2156 +2140 @@
 # end patches
     
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
+    G2frame.dataWindow.ClearData()
     Controls = G2frame.PatternTree.GetItemPyData(
         G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))        
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.StrStaMenu)
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.StrStaMenu)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAppendDzero, id=G2gd.wxID_APPENDDZERO)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnUpdateDzero, id=G2gd.wxID_UPDATEDZERO)
@@ -2171 +2154 @@
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveStrSta, id=G2gd.wxID_STRSTASAVE)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnStrStaSample, id=G2gd.wxID_STRSTSAMPLE)        
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()
     if G2frame.StrainKey == 'a':    #probably doesn't happen
-        G2frame.dataFrame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value')
+        G2frame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value')
     else:
-        G2frame.dataFrame.GetStatusBar().SetStatusText("To add strain data: On 2D Powder Image, key a:add ring")
-        
-    G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
+        G2frame.GetStatusBar().SetStatusText("To add strain data: On 2D Powder Image, key a:add ring")
+        
     mainSizer = wx.BoxSizer(wx.VERTICAL)
     mainSizer.Add((5,10),0)
@@ -2186 +2166 @@
     
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    G2frame.dataDisplay.SetAutoLayout(1)
-    G2frame.dataDisplay.SetupScrolling()
-    Size = mainSizer.Fit(G2frame.dataFrame)
-    Size[0] += 25
-    G2frame.dataFrame.setSizePosLeft(Size)    
+    G2frame.dataWindow.SetSizer(mainSizer)
+    G2frame.dataWindow.SetAutoLayout(1)
+    mainSizer.Fit(G2frame.dataFrame)
+    G2frame.SetDataSize()
 
 ###########################################################################

branch/2frame/GSASIIphsGUI.py

@@ -76 +76 @@
     phasePage.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
     phasePage.Scroll(0,Scroll)
-    if size is None:
-        Size[1] = min(Size[1]+ 150,500) 
-#        Size[1] = min(500,Size[1])
-        mainFrame.setSizePosLeft(Size)
-    else:
-        size[1] = min(500,size[1])
-        mainFrame.setSizePosLeft(size)
     
 def FindBondsDraw(data):    
@@ -371 +364 @@
                     generalData['Name'] = newName
                     G2frame.G2plotNB.Rename(oldName,generalData['Name'])
-                    G2frame.dataFrame.SetLabel('Phase Data for '+generalData['Name'])
+                    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+generalData['Name'])
                     G2frame.PatternTree.SetItemText(Item,generalData['Name'])
                     # change phase name key in Reflection Lists for each histogram
@@ -390 +383 @@
                 if not len(generalData['AtomTypes']):             #can change only if no atoms!
                     generalData['Type'] = TypeTxt.GetValue()
-                    pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
+                    pages = [G2frame.phaseDisplay.GetPageText(PageNum) for PageNum in range(G2frame.phaseDisplay.GetPageCount())]
                     if generalData['Type'] == 'faulted':
                         G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
@@ -398 +391 @@
                         if 'Wave Data' in pages:
                             pass
-#                            G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
+#                            G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
                         if 'MC/SA' in pages:
                             pass
-#                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))
+#                            G2frame.phaseDisplay.DeletePage(pages.index('MC/SA'))
                         if 'RB Models' in pages:
                             pass
-#                            G2frame.dataDisplay.DeletePage(pages.index('RB Models'))
+#                            G2frame.phaseDisplay.DeletePage(pages.index('RB Models'))
                         if 'Layers' not in pages:
                             if 'Layers' not in data:
@@ -410 +403 @@
                                     'Width':[[1.,1.],[False,False]],'Toler':0.01,'AtInfo':{},
                                     'Layers':[],'Stacking':[],'Transitions':[]}
-                            G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
-                            G2frame.dataDisplay.InsertPage(3,G2frame.layerData,'Layers')
+                            G2frame.layerData = wx.ScrolledWindow(G2frame.phaseDisplay)
+                            G2frame.phaseDisplay.InsertPage(3,G2frame.layerData,'Layers')
                             Id = wx.NewId()
                             TabSelectionIdDict[Id] = 'Layers'
@@ -423 +416 @@
                     else:
                         if 'Wave Data' in pages:
-                            G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
+                            G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
                         if 'MC/SA' not in pages:
-                            G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
-                            G2frame.dataDisplay.InsertPage(7,G2frame.MCSA,'MC/SA')
+                            G2frame.MCSA = wx.ScrolledWindow(G2frame.phaseDisplay)
+                            G2frame.phaseDisplay.InsertPage(7,G2frame.MCSA,'MC/SA')
                             Id = wx.NewId()
                             TabSelectionIdDict[Id] = 'MC/SA'
@@ -513 +506 @@
             def OnModulated(event):
                 if not len(generalData['AtomTypes']):             #can change only if no atoms!
-                    pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
+                    pages = [G2frame.phaseDisplay.GetPageText(PageNum) for PageNum in range(G2frame.phaseDisplay.GetPageCount())]
                     if generalData['Type'] in ['nuclear','magnetic']:
                         generalData['Modulated'] = modulated.GetValue()
@@ -529 +522 @@
                             if 'MC/SA' in pages:
                                 pass
-    #                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
+    #                            G2frame.phaseDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
                             if 'Layers' in pages:
                                 pass
-    #                            G2frame.dataDisplay.DeletePage(pages.index('Layers'))
+    #                            G2frame.phaseDisplay.DeletePage(pages.index('Layers'))
                             if 'Wave Data' not in pages:
-                                G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
-                                G2frame.dataDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
+                                G2frame.waveData = wx.ScrolledWindow(G2frame.phaseDisplay)
+                                G2frame.phaseDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
                                 Id = wx.NewId()
                                 TabSelectionIdDict[Id] = 'Wave Data'
                         else:
                             if 'Wave Data' in pages:
-                                G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
+                                G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
                         wx.CallAfter(UpdateGeneral)
                 else:
@@ -685 +678 @@
                 cellSizer.Add(wx.StaticText(General,label=txt),0,WACV)
                 if ifEdit:          #a,b,c,etc.
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                     cellVal = wx.TextCtrl(General,value=(fmt%(cell[Id+1])),
                         style=wx.TE_PROCESS_ENTER)
@@ -848 +841 @@
             dminSizer = wx.BoxSizer(wx.HORIZONTAL)
             dminSizer.Add(wx.StaticText(General,label=' Magnetic reflection d-min: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             dminVal = wx.TextCtrl(General,value='%.4f'%(generalData['MagDmin']),style=wx.TE_PROCESS_ENTER)
             dminVal.Bind(wx.EVT_TEXT_ENTER,OnDminVal)        
@@ -947 +940 @@
             for i,[val,show] in enumerate(zip(generalData['SuperVec'][0],ifShow)):
                 if show:
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                     modVal = wx.TextCtrl(General,value=('%.4f'%(val)),
                         size=wx.Size(50,20),style=wx.TE_PROCESS_ENTER)
@@ -1037 +1030 @@
             line2Sizer = wx.BoxSizer(wx.HORIZONTAL)
             line2Sizer.Add(wx.StaticText(General,label=' Resolution: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             mapRes =  wx.TextCtrl(General,value='%.2f'%(Map['Resolution']),style=wx.TE_PROCESS_ENTER)
             mapRes.Bind(wx.EVT_TEXT_ENTER,OnResVal)        
@@ -1043 +1036 @@
             line2Sizer.Add(mapRes,0,WACV)
             line2Sizer.Add(wx.StaticText(General,label=' Peak cutoff %: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             cutOff =  wx.TextCtrl(General,value='%.1f'%(Map['cutOff']),style=wx.TE_PROCESS_ENTER)
             cutOff.Bind(wx.EVT_TEXT_ENTER,OnCutOff)        
@@ -1138 +1131 @@
             line2Sizer = wx.BoxSizer(wx.HORIZONTAL)
             line2Sizer.Add(wx.StaticText(General,label=' Resolution: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             flipRes =  wx.TextCtrl(General,value='%.2f'%(Flip['Resolution']),style=wx.TE_PROCESS_ENTER)
             flipRes.Bind(wx.EVT_TEXT_ENTER,OnResVal)        
@@ -1144 +1137 @@
             line2Sizer.Add(flipRes,0,WACV)
             line2Sizer.Add(wx.StaticText(General,label=' k-Factor (0.1-1.2): '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             kFactor =  wx.TextCtrl(General,value='%.3f'%(Flip['k-factor']),style=wx.TE_PROCESS_ENTER)
             kFactor.Bind(wx.EVT_TEXT_ENTER,OnkFactor)        
@@ -1150 +1143 @@
             line2Sizer.Add(kFactor,0,WACV)
             line2Sizer.Add(wx.StaticText(General,label=' k-Max (>=10.0): '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             kMax = wx.TextCtrl(General,value='%.1f'%(Flip['k-Max']),style=wx.TE_PROCESS_ENTER)
             kMax.Bind(wx.EVT_TEXT_ENTER,OnkMax)        
@@ -1266 +1259 @@
             lineSizer.Add(refList,0,WACV)
             lineSizer.Add(wx.StaticText(General,label=' d-min: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             dmin = wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata['dmin']),style=wx.TE_PROCESS_ENTER)
             dmin.Bind(wx.EVT_TEXT_ENTER,OnDmin)        
@@ -1285 +1278 @@
             ranStart.SetValue(MCSAdata.get('ranStart',False))
             line2Sizer.Add(ranStart,0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             ranRange = wx.TextCtrl(General,-1,value='%.1f'%(MCSAdata.get('ranRange',0.10)*100),style=wx.TE_PROCESS_ENTER)
             ranRange.Bind(wx.EVT_TEXT_ENTER,OnRanRange)        
@@ -1315 +1308 @@
                 for i,name in enumerate(Names):
                     line3Sizer.Add(wx.StaticText(General,label=name),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                     Ajump =  wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata[parms][i]),style=wx.TE_PROCESS_ENTER)
                     Ajump.Bind(wx.EVT_TEXT_ENTER,OnAjump)        
@@ -1323 +1316 @@
             elif 'log' in MCSAdata['Algorithm']:
                 line3Sizer.Add(wx.StaticText(General,label=' slope: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 slope =  wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata['log slope']),style=wx.TE_PROCESS_ENTER)
                 slope.Bind(wx.EVT_TEXT_ENTER,OnSlope)        
@@ -1395 +1388 @@
             G2G.HorizontalLine(mainSizer,General)
             mainSizer.Add(MCSASizer())
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         SetPhaseWindow(G2frame.dataFrame,General,mainSizer,Scroll=Scroll)
         
@@ -1695 +1688 @@
             if not (event.AltDown() or (event.ShiftDown() and event.ControlDown())):
                 Atoms.frm = -1
-                G2frame.dataFrame.SetStatusText('')                    
+                G2frame.GetStatusBar().SetStatusText('')                    
             if r < 0 and c < 0:
                 if Atoms.IsSelection():
@@ -1724 +1717 @@
                             Atoms.SelectRow(r,True)
                             n = colLabels.index('Name')
-                            G2frame.dataFrame.SetStatusText('Atom '+atomData[r][n]+' is to be moved')
+                            G2frame.GetStatusBar().SetStatusText('Atom '+atomData[r][n]+' is to be moved')
                         else:                       #move it
                             item = atomData.pop(Atoms.frm)
                             atomData.insert(r,item)
                             Atoms.frm = -1
-                            G2frame.dataFrame.SetStatusText('')
+                            G2frame.GetStatusBar().SetStatusText('')
                             wx.CallAfter(Paint)
                 else:
@@ -1891 +1884 @@
             Types = Types[:7]+3*[wg.GRID_VALUE_FLOAT+':10,4',]+Types[7:]
         SGData = data['General']['SGData']
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         if SGData['SGPolax']:
-            G2frame.dataFrame.SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'])
+            G2frame.GetStatusBar().SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'])
         Atoms.Bind(wg.EVT_GRID_CELL_CHANGE, ChangeAtomCell)
         Atoms.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, AtomTypeSelect)
@@ -2204 +2197 @@
             atom = atomData[ind]
             if atom[ci+8] in rbAtmDict:
-                G2frame.dataFrame.SetStatusText('**** ERROR - atom is in a rigid body and can not be deleted ****')
+                G2frame.GetStatusBar().SetStatusText('**** ERROR - atom is in a rigid body and can not be deleted ****')
             else:
                 if atom[ci+8] in HydIds:    #remove Hs from Hatom update dict
@@ -2931 +2924 @@
             for txt,fmt,ifEdit,Id in useGUI[2]:
                 cellSizer.Add(wx.StaticText(layerData,label=txt),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 cellVal = wx.TextCtrl(layerData,value=(fmt%(cell[Id+1])),
                     style=wx.TE_PROCESS_ENTER)
@@ -2964 +2957 @@
             for i in range(2):
                 widthSizer.Add(wx.StaticText(layerData,label=u' layer width(%s) (<= 1\xb5m): '%(Labels[i])),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 widthVal = wx.TextCtrl(layerData,value='%.3f'%(widths[i]),style=wx.TE_PROCESS_ENTER)
                 widthVal.Bind(wx.EVT_TEXT_ENTER,OnWidthChange)        
@@ -3350 +3343 @@
             if Layers['Stacking'][0] == 'recursive':
                 topLine.Add(wx.StaticText(layerData,label=' number of layers (<1022 or "infinite"): '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 numLayers = wx.TextCtrl(layerData,value=data['Layers']['Stacking'][1],style=wx.TE_PROCESS_ENTER)
                 numLayers.Bind(wx.EVT_TEXT_ENTER,OnNumLayers)        
@@ -3390 +3383 @@
         if len(Layers['Layers']):
             layerNames = [layer['Name'] for layer in Layers['Layers']]
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         layerData = G2frame.layerData
         if layerData.GetSizer():
@@ -3416 +3409 @@
         if Layers['Laue'] == 'unknown':
             laueSizer.Add(wx.StaticText(layerData,label=' Diffraction symmetry tolerance: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             toler = wx.TextCtrl(layerData,value='%.3f'%(Layers['Toler']),style=wx.TE_PROCESS_ENTER)
             toler.Bind(wx.EVT_TEXT_ENTER,OnToler)        
@@ -3693 +3686 @@
         Indx = {}
         waveData = G2frame.waveData
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         generalData = data['General']
         SGData = generalData['SGData']
@@ -3838 +3831 @@
                         for ival,val in enumerate(wave[0]):
                             if np.any(CSI[Stype][0][ival]):
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                                 waveVal = wx.TextCtrl(waveData,value='%.5f'%(val),style=wx.TE_PROCESS_ENTER)
                                 waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveVal)
@@ -4059 +4052 @@
             'atNames':atNames,'rbRef':[0,1,2,False],'rbSeq':[],'SelSeq':[0,0],'useCount':0}
         RBData['RBIds']['Residue'].append(rbId)
-        G2frame.dataFrame.SetStatusText('New rigid body UNKRB added to set of Residue rigid bodies')
+        G2frame.GetStatusBar().SetStatusText('New rigid body UNKRB added to set of Residue rigid bodies')
 
 ################################################################################
@@ -4198 +4191 @@
 
         # UpdateDrawAtoms executable code starts here
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         generalData = data['General']
         SetupDrawingData()
@@ -4309 +4302 @@
         if indx:
             if len(indx) > 1:
-                G2frame.dataFrame.SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK')
+                G2frame.GetStatusBar().SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK')
             else:
-                G2frame.dataFrame.SetStatusText('Change color, Add to Custom Colors, then OK')
+                G2frame.GetStatusBar().SetStatusText('Change color, Add to Custom Colors, then OK')
             atomData = data['Drawing']['Atoms']
             cx,ct,cs,ci = data['Drawing']['atomPtrs']
@@ -4338 +4331 @@
             drawAtoms.ClearSelection()
             dlg.Destroy()
-            G2frame.dataFrame.SetStatusText('')
+            G2frame.GetStatusBar().SetStatusText('')
             G2plt.PlotStructure(G2frame,data)
             
@@ -4847 +4840 @@
             cameraPosTxt = wx.StaticText(drawOptions,-1,
                 ' Camera Distance: '+'%.2f'%(drawingData['cameraPos']),name='cameraPos')
-            G2frame.dataDisplay.cameraPosTxt = cameraPosTxt
+            G2frame.phaseDisplay.cameraPosTxt = cameraPosTxt
             slideSizer.Add(cameraPosTxt,0,WACV)
             cameraPos = wx.Slider(drawOptions,style=wx.SL_HORIZONTAL,value=drawingData['cameraPos'],name='cameraSlider')
             cameraPos.SetRange(10,500)
             cameraPos.Bind(wx.EVT_SLIDER, OnCameraPos)
-            G2frame.dataDisplay.cameraSlider = cameraPos
+            G2frame.phaseDisplay.cameraSlider = cameraPos
             slideSizer.Add(cameraPos,1,wx.EXPAND|wx.RIGHT)
             
@@ -4864 +4857 @@
             ZstepSizer = wx.BoxSizer(wx.HORIZONTAL)
             ZstepSizer.Add(wx.StaticText(drawOptions,-1,' Z step:'),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             Zstep = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['Zstep']),
                 style=wx.TE_PROCESS_ENTER)
@@ -4996 +4989 @@
             viewDir.Bind(wx.EVT_TEXT_ENTER,OnViewDir)
             viewDir.Bind(wx.EVT_KILL_FOCUS,OnViewDir)
-            G2frame.dataDisplay.viewDir = viewDir
+            G2frame.phaseDisplay.viewDir = viewDir
             lineSizer.Add(viewDir,0,WACV)
             showSizer.Add(lineSizer)
@@ -5010 +5003 @@
             viewPoint = wx.TextCtrl(drawOptions,value='%.3f %.3f %.3f'%(VP[0],VP[1],VP[2]),
                 style=wx.TE_PROCESS_ENTER,size=wx.Size(140,20),name='viewPoint')
-            G2frame.dataDisplay.viewPoint = viewPoint
+            G2frame.phaseDisplay.viewPoint = viewPoint
             viewPoint.Bind(wx.EVT_TEXT_ENTER,OnViewPoint)
             viewPoint.Bind(wx.EVT_KILL_FOCUS,OnViewPoint)
@@ -5062 +5055 @@
             radSizer = wx.BoxSizer(wx.HORIZONTAL)
             radSizer.Add(wx.StaticText(drawOptions,-1,' Hydrogen radius, A:  '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             sizeH = wx.TextCtrl(drawOptions,-1,value='%.2f'%(drawingData['sizeH']),size=wx.Size(60,20),style=wx.TE_PROCESS_ENTER)
             sizeH.Bind(wx.EVT_TEXT_ENTER,OnSizeHatoms)
@@ -5069 +5062 @@
     
             radSizer.Add(wx.StaticText(drawOptions,-1,' Bond search factor:  '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             radFactor = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['radiusFactor']),size=wx.Size(60,20),style=wx.TE_PROCESS_ENTER)
             radFactor.Bind(wx.EVT_TEXT_ENTER,OnRadFactor)
@@ -5132 +5125 @@
             planeSizer2 = wx.BoxSizer(wx.HORIZONTAL)
             planeSizer2.Add(wx.StaticText(drawOptions,label=' Phase shift (deg): '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             phase = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['Plane'][3]),
                 style=wx.TE_PROCESS_ENTER)
@@ -5153 +5146 @@
         drawingData = data['Drawing']
 
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         if drawOptions.GetSizer():
             drawOptions.GetSizer().Clear(True)
@@ -5411 +5404 @@
             shPenalty.Add(hklList,0,WACV)
             shPenalty.Add(wx.StaticText(Texture,wx.ID_ANY,' Zero MRD tolerance: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             shToler = wx.TextCtrl(Texture,wx.ID_ANY,'%.2f'%(Penalty[1]),style=wx.TE_PROCESS_ENTER)
             shToler.Bind(wx.EVT_TEXT_ENTER,OnshToler)
@@ -5422 +5415 @@
         if Texture.GetSizer():
             Texture.GetSizer().Clear(True)
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         generalData = data['General']        
         SGData = generalData['SGData']
@@ -5492 +5485 @@
             PTSizer.Add(wx.StaticText(Texture,-1,' Inverse pole figure XYZ: '),0,WACV)
             PX = textureData['PFxyz']
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             pfVal = wx.TextCtrl(Texture,-1,'%3.1f %3.1f %3.1f'%(PX[0],PX[1],PX[2]),style=wx.TE_PROCESS_ENTER)
         pfVal.Bind(wx.EVT_TEXT_ENTER,OnPFValue)
@@ -5520 +5513 @@
             for item in ODFkeys:
                 ODFSizer.Add(wx.StaticText(Texture,-1,item),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 ODFval = wx.TextCtrl(Texture,wx.ID_ANY,'%8.3f'%(textureData['SH Coeff'][1][item]),style=wx.TE_PROCESS_ENTER)
                 ODFIndx[ODFval.GetId()] = item
@@ -5540 +5533 @@
             angRef.Bind(wx.EVT_CHECKBOX, OnAngRef)
             angSizer.Add(angRef,0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             angVal = wx.TextCtrl(Texture,wx.ID_ANY,'%8.2f'%(textureData[item][1]),style=wx.TE_PROCESS_ENTER)
             valIndx[angVal.GetId()] = item
@@ -5930 +5923 @@
             for i,name in enumerate(names):
                 thermSizer.Add(wx.StaticText(RigidBodies,-1,name+': '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 thermVal = wx.TextCtrl(RigidBodies,-1,value='%8.4f'%(model[1][i]),
                     style=wx.TE_PROCESS_ENTER)
@@ -6003 +5996 @@
             topSizer.Add(wx.StaticText(RigidBodies,-1,'Origin x,y,z:'),0,WACV)
             for ix,x in enumerate(Orig):
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 origX = wx.TextCtrl(RigidBodies,-1,value='%8.5f'%(x),style=wx.TE_PROCESS_ENTER)
                 origX.Bind(wx.EVT_TEXT_ENTER,OnOrigX)
@@ -6016 +6009 @@
             topSizer.Add(wx.StaticText(RigidBodies,-1,'Rotation angle, vector:'),0,WACV)
             for ix,x in enumerate(Orien):
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 orien = wx.TextCtrl(RigidBodies,-1,value='%8.4f'%(x),style=wx.TE_PROCESS_ENTER)
                 orien.Bind(wx.EVT_TEXT_ENTER,OnOrien)
@@ -6081 +6074 @@
             for itors,tors in enumerate(RBObj['Torsions']):
                 torSizer.Add(wx.StaticText(RigidBodies,-1,'Torsion '+'%d'%(itors)),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 torsTxt = wx.TextCtrl(RigidBodies,-1,value='%.3f'%(tors[0]),style=wx.TE_PROCESS_ENTER)
                 torsTxt.Bind(wx.EVT_TEXT_ENTER,OnTorsion)
@@ -6108 +6101 @@
             
         def VecrbSizer(RBObj):
-            G2frame.dataFrame.SetStatusText('NB: Rotation vector is in crystallographic space')
+            G2frame.GetStatusBar().SetStatusText('NB: Rotation vector is in crystallographic space')
                    
             def OnDelVecRB(event):
@@ -6186 +6179 @@
         if 'macro' in general['Type']:
             atomStyle = 'sticks'
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         mainSizer = wx.BoxSizer(wx.VERTICAL)
         if not data['RBModels']:
@@ -6211 +6204 @@
             G2frame.bottomSizer.Add(ResrbSizer(rbObj))
             mainSizer.Add(G2frame.bottomSizer)
-            G2frame.dataFrame.SetStatusText('NB: Rotation vector is in crystallographic space')
+            G2frame.GetStatusBar().SetStatusText('NB: Rotation vector is in crystallographic space')
             G2plt.PlotStructure(G2frame,data)
         if 'Vector' in data['RBModels'] and len(data['RBModels']['Vector']):
@@ -6254 +6247 @@
     def OnRBAssign(event):
         
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         RBData = G2frame.PatternTree.GetItemPyData(   
             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
@@ -6788 +6781 @@
                 Indx[posRef.GetId()] = [model,'Pos',ix]
                 atomsizer.Add(posRef,0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 posVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(model['Pos'][0][ix]),style=wx.TE_PROCESS_ENTER)
                 posVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
@@ -6862 +6855 @@
                 Indx[posRef.GetId()] = [model,'Pos',ix]
                 rbsizer1.Add(posRef,0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                 posVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(model['Pos'][0][ix]),style=wx.TE_PROCESS_ENTER)
                 posVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
@@ -6885 +6878 @@
             Ori = model['Ori'][0]
             rbsizer2.Add(wx.StaticText(G2frame.MCSA,-1,'Oa: '),0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             angVal = wx.TextCtrl(G2frame.MCSA,-1,'%.5f'%(Ori[0]),style=wx.TE_PROCESS_ENTER)
             angVal.Bind(wx.EVT_TEXT_ENTER,OnOriVal)
@@ -6933 +6926 @@
                     Indx[torRef.GetId()] = [model,'Tor',it]
                     rbsizer3.Add(torRef,0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
                     torVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(tor),style=wx.TE_PROCESS_ENTER)
                     torVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
@@ -6997 +6990 @@
             poRef.Bind(wx.EVT_CHECKBOX,OnPORef)
             poSizer.Add(poRef,0,WACV)
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
             poVal = wx.TextCtrl(G2frame.MCSA,-1,'%.3f'%(POData['Coef'][0]),style=wx.TE_PROCESS_ENTER)
             poVal.Bind(wx.EVT_TEXT_ENTER,OnPOVal)
@@ -7082 +7075 @@
 #        if 'macro' in general['Type']:
 #            atomStyle = 'sticks'
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         mainSizer = wx.BoxSizer(wx.VERTICAL)
         if not data['MCSA']['Models']:
@@ -7217 +7210 @@
         MCSAdata['Results'][0][0] = True
         SetSolution(MCSAdata['Results'][0],data['MCSA']['Models'])
-        G2frame.dataDisplay.SetFocus()
-        Page = G2frame.dataDisplay.FindPage('MC/SA')
-        G2frame.dataDisplay.SetSelection(Page)
+        G2frame.phaseDisplay.SetFocus()
+        Page = G2frame.phaseDisplay.FindPage('MC/SA')
+        G2frame.phaseDisplay.SetSelection(Page)
         G2plt.PlotStructure(G2frame,data)
         wx.CallAfter(UpdateMCSA)
@@ -7323 +7316 @@
             
         # FillPawleyReflectionsGrid executable starts here
-        G2frame.dataFrame.SetStatusText('To delete a Pawley reflection: select row & press Delete')                        
+        G2frame.GetStatusBar().SetStatusText('To delete a Pawley reflection: select row & press Delete')                        
         generalData = data['General']
         if 'Pawley ref' in data:
@@ -7635 +7628 @@
             G2plt.PlotStructure(G2frame,data)                    
             
-        G2frame.dataFrame.SetStatusText('')
+        G2frame.GetStatusBar().SetStatusText('')
         if 'Map Peaks' in data:
-            G2frame.dataFrame.SetStatusText('Double click any column heading to sort')
+            G2frame.GetStatusBar().SetStatusText('Double click any column heading to sort')
             mapPeaks = data['Map Peaks']                        
             rowLabels = []
@@ -7867 +7860 @@
             print ' Map search finished, time = %.2fs'%(time.time()-time0)
             print ' No.peaks found:',len(peaks)    
-            Page = G2frame.dataDisplay.FindPage('Map peaks')
-            G2frame.dataDisplay.SetSelection(Page)
+            Page = G2frame.phaseDisplay.FindPage('Map peaks')
+            G2frame.phaseDisplay.SetSelection(Page)
             wx.CallAfter(FillMapPeaksGrid)
             UpdateDrawAtoms()
@@ -8012 +8005 @@
                 return                
             # find the matching tab
-            for PageNum in range(G2frame.dataDisplay.GetPageCount()):
-                if tabname == G2frame.dataDisplay.GetPageText(PageNum):
-                    G2frame.dataDisplay.SetSelection(PageNum)
+            for PageNum in range(G2frame.phaseDisplay.GetPageCount()):
+                if tabname == G2frame.phaseDisplay.GetPageText(PageNum):
+                    G2frame.phaseDisplay.SetSelection(PageNum)
                     return
             else:
@@ -8031 +8024 @@
         on a Phase data item window
         '''
-        for page in G2frame.dataDisplay.gridList: # clear out all grids, forcing edits in progress to complete
+        for page in G2frame.phaseDisplay.gridList: # clear out all grids, forcing edits in progress to complete
             page.ClearGrid()
         page = event.GetSelection()
@@ -8037 +8030 @@
         
     def ChangePage(page):
-        text = G2frame.dataDisplay.GetPageText(page)
-        G2frame.dataDisplayPhaseText = text
+        text = G2frame.phaseDisplay.GetPageText(page)
+        G2frame.phaseDisplayPhaseText = text
         G2frame.dataFrame.helpKey = text # use name of Phase tab for help lookup
         if text == 'General':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataGeneral)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataGeneral)
             UpdateGeneral()
         elif text == 'Data':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataMenu)
             G2ddG.UpdateDData(G2frame,DData,data)
             wx.CallAfter(G2plt.PlotSizeStrainPO,G2frame,data,hist='',Start=True)            
         elif text == 'Atoms':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.AtomsMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.AtomsMenu)
             FillAtomsGrid(Atoms)
         elif text == 'Layers':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LayerData)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.LayerData)
             UpdateLayerData()
         elif text == 'Wave Data' and data['General']['Modulated']:
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.WavesData)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.WavesData)
             UpdateWavesData()
             wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
         elif text == 'Draw Options':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataDrawOptions)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataDrawOptions)
             UpdateDrawOptions()
             wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
         elif text == 'Draw Atoms':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DrawAtomsMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DrawAtomsMenu)
             UpdateDrawAtoms()
             wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
         elif text == 'RB Models':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodiesMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodiesMenu)
             FillRigidBodyGrid()
         elif text == 'Map peaks':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MapPeaksMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MapPeaksMenu)
             FillMapPeaksGrid()
             wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
         elif text == 'MC/SA':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MCSAMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MCSAMenu)
             UpdateMCSA()                        
             wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
         elif text == 'Texture':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.TextureMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.TextureMenu)
             UpdateTexture()                        
             wx.CallAfter(G2plt.PlotTexture,G2frame,data,Start=True)            
         elif text == 'Pawley reflections':
-            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PawleyMenu)
+            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.PawleyMenu)
             FillPawleyReflectionsGrid()
         else:
@@ -8090 +8083 @@
         '''
         # General
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataGeneral)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnFourierMaps, id=G2gd.wxID_FOURCALC)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnSearchMaps, id=G2gd.wxID_FOURSEARCH)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnChargeFlip, id=G2gd.wxID_CHARGEFLIP)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, On4DChargeFlip, id=G2gd.wxID_4DCHARGEFLIP)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnFourClear, id=G2gd.wxID_FOURCLEAR)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRunSingleMCSA, id=G2gd.wxID_SINGLEMCSA)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRunMultiMCSA, id=G2gd.wxID_MULTIMCSA)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnTransform, id=G2gd.wxID_TRANSFORMSTRUCTURE)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataGeneral)
+        G2frame.Bind(wx.EVT_MENU, OnFourierMaps, id=G2gd.wxID_FOURCALC)
+        G2frame.Bind(wx.EVT_MENU, OnSearchMaps, id=G2gd.wxID_FOURSEARCH)
+        G2frame.Bind(wx.EVT_MENU, OnChargeFlip, id=G2gd.wxID_CHARGEFLIP)
+        G2frame.Bind(wx.EVT_MENU, On4DChargeFlip, id=G2gd.wxID_4DCHARGEFLIP)
+        G2frame.Bind(wx.EVT_MENU, OnFourClear, id=G2gd.wxID_FOURCLEAR)
+        G2frame.Bind(wx.EVT_MENU, OnRunSingleMCSA, id=G2gd.wxID_SINGLEMCSA)
+        G2frame.Bind(wx.EVT_MENU, OnRunMultiMCSA, id=G2gd.wxID_MULTIMCSA)
+        G2frame.Bind(wx.EVT_MENU, OnTransform, id=G2gd.wxID_TRANSFORMSTRUCTURE)
         # Data
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataUse, id=G2gd.wxID_DATAUSE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataCopy, id=G2gd.wxID_DATACOPY)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataCopyFlags, id=G2gd.wxID_DATACOPYFLAGS)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnSelDataCopy, id=G2gd.wxID_DATASELCOPY)
-        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)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataMenu)
+        G2frame.Bind(wx.EVT_MENU, OnDataUse, id=G2gd.wxID_DATAUSE)
+        G2frame.Bind(wx.EVT_MENU, OnDataCopy, id=G2gd.wxID_DATACOPY)
+        G2frame.Bind(wx.EVT_MENU, OnDataCopyFlags, id=G2gd.wxID_DATACOPYFLAGS)
+        G2frame.Bind(wx.EVT_MENU, OnSelDataCopy, id=G2gd.wxID_DATASELCOPY)
+        G2frame.Bind(wx.EVT_MENU, OnPwdrAdd, id=G2gd.wxID_PWDRADD)
+        G2frame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2gd.wxID_HKLFADD)
+        G2frame.Bind(wx.EVT_MENU, OnDataDelete, id=G2gd.wxID_DATADELETE)
         # Atoms
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.AtomsMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnSetAll, id=G2gd.wxID_ATOMSSETALL)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, AtomRefine, id=G2gd.wxID_ATOMSSETSEL)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, AtomModify, id=G2gd.wxID_ATOMSMODIFY)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnHydAtomAdd, id=G2gd.wxID_ADDHATOM)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, AtomTransform, id=G2gd.wxID_ATOMSTRANSFORM)
-#        G2frame.dataFrame.Bind(wx.EVT_MENU, AtomRotate, id=G2gd.wxID_ATOMSROTATE)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.AtomsMenu)
+        G2frame.Bind(wx.EVT_MENU, OnSetAll, id=G2gd.wxID_ATOMSSETALL)
+        G2frame.Bind(wx.EVT_MENU, AtomRefine, id=G2gd.wxID_ATOMSSETSEL)
+        G2frame.Bind(wx.EVT_MENU, AtomModify, id=G2gd.wxID_ATOMSMODIFY)
+        G2frame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
+        G2frame.Bind(wx.EVT_MENU, OnHydAtomAdd, id=G2gd.wxID_ADDHATOM)
+        G2frame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
+        G2frame.Bind(wx.EVT_MENU, AtomTransform, id=G2gd.wxID_ATOMSTRANSFORM)
+#        G2frame.Bind(wx.EVT_MENU, AtomRotate, id=G2gd.wxID_ATOMSROTATE)
         
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewAdd, id=G2gd.wxID_ATOMSVIEWADD)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewInsert, id=G2gd.wxID_ATOMVIEWINSERT)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnHydAtomUpdate, id=G2gd.wxID_UPDATEHATOM)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomMove, id=G2gd.wxID_ATOMMOVE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, MakeMolecule, id=G2gd.wxID_MAKEMOLECULE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAnglePrt, id=G2gd.wxID_ATOMSPDISAGL)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDensity, id=G2gd.wxID_ATOMSDENSITY)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnValidProtein, id=G2gd.wxID_VALIDPROTEIN)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnIsoDistortCalc, id=G2gd.wxID_ISODISP)
+        G2frame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
+        G2frame.Bind(wx.EVT_MENU, OnAtomViewAdd, id=G2gd.wxID_ATOMSVIEWADD)
+        G2frame.Bind(wx.EVT_MENU, OnAtomViewInsert, id=G2gd.wxID_ATOMVIEWINSERT)
+        G2frame.Bind(wx.EVT_MENU, OnHydAtomUpdate, id=G2gd.wxID_UPDATEHATOM)
+        G2frame.Bind(wx.EVT_MENU, OnAtomMove, id=G2gd.wxID_ATOMMOVE)
+        G2frame.Bind(wx.EVT_MENU, MakeMolecule, id=G2gd.wxID_MAKEMOLECULE)
+        G2frame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
+        G2frame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
+        G2frame.Bind(wx.EVT_MENU, OnDistAnglePrt, id=G2gd.wxID_ATOMSPDISAGL)
+        G2frame.Bind(wx.EVT_MENU, OnDensity, id=G2gd.wxID_ATOMSDENSITY)
+        G2frame.Bind(wx.EVT_MENU, OnValidProtein, id=G2gd.wxID_VALIDPROTEIN)
+        G2frame.Bind(wx.EVT_MENU, OnIsoDistortCalc, id=G2gd.wxID_ISODISP)
         if 'HydIds' in data['General']:
             G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,True)
@@ -8136 +8129 @@
             G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,False)
         for id in G2frame.dataFrame.ReImportMenuId:     #loop over submenu items
-            G2frame.dataFrame.Bind(wx.EVT_MENU, OnReImport, id=id)
+            G2frame.Bind(wx.EVT_MENU, OnReImport, id=id)
         # Wave Data
         if data['General']['Modulated']:
-            FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.WavesData)
-            G2frame.dataFrame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)
+            FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.WavesData)
+            G2frame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)
         # Stacking faults 
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.LayerData)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPhase, id=G2gd.wxID_COPYPHASE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnSimulate, id=G2gd.wxID_LAYERSIMULATE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitLayers, id=G2gd.wxID_LAYERSFIT)                        
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2gd.wxID_SEQUENCESIMULATE)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.LayerData)
+        G2frame.Bind(wx.EVT_MENU, OnCopyPhase, id=G2gd.wxID_COPYPHASE)
+        G2frame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
+        G2frame.Bind(wx.EVT_MENU, OnSimulate, id=G2gd.wxID_LAYERSIMULATE)
+        G2frame.Bind(wx.EVT_MENU, OnFitLayers, id=G2gd.wxID_LAYERSFIT)                        
+        G2frame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2gd.wxID_SEQUENCESIMULATE)
         # Draw Options
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataDrawOptions)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataDrawOptions)
         # Draw Atoms
-        FillSelectPageMenu(TabSelectionIdDict, 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, OnEditAtomRadii, id=G2gd.wxID_DRWAEDITRADII)   
-        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, AddSphere, id=G2gd.wxID_DRAWADDSPHERE)
-        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, OnDrawDistVP, id=G2gd.wxID_DRAWDISTVP)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawDAT, id=G2gd.wxID_DRAWDISAGLTOR)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2gd.wxID_DRAWPLANE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRBOND)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRANGLE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRPLANE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRCHIRAL)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnDefineRB, id=G2gd.wxID_DRAWDEFINERB)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DrawAtomsMenu)
+        G2frame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2gd.wxID_DRAWATOMSTYLE)
+        G2frame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2gd.wxID_DRAWATOMLABEL)
+        G2frame.Bind(wx.EVT_MENU, DrawAtomColor, id=G2gd.wxID_DRAWATOMCOLOR)
+        G2frame.Bind(wx.EVT_MENU, ResetAtomColors, id=G2gd.wxID_DRAWATOMRESETCOLOR)
+        G2frame.Bind(wx.EVT_MENU, OnEditAtomRadii, id=G2gd.wxID_DRWAEDITRADII)   
+        G2frame.Bind(wx.EVT_MENU, SetViewPoint, id=G2gd.wxID_DRAWVIEWPOINT)
+        G2frame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2gd.wxID_DRAWADDEQUIV)
+        G2frame.Bind(wx.EVT_MENU, AddSphere, id=G2gd.wxID_DRAWADDSPHERE)
+        G2frame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2gd.wxID_DRAWTRANSFORM)
+        G2frame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2gd.wxID_DRAWFILLCOORD)            
+        G2frame.Bind(wx.EVT_MENU, FillUnitCell, id=G2gd.wxID_DRAWFILLCELL)
+        G2frame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2gd.wxID_DRAWDELETE)
+        G2frame.Bind(wx.EVT_MENU, OnDrawDistVP, id=G2gd.wxID_DRAWDISTVP)
+        G2frame.Bind(wx.EVT_MENU, OnDrawDAT, id=G2gd.wxID_DRAWDISAGLTOR)
+        G2frame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2gd.wxID_DRAWPLANE)
+        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRBOND)
+        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRANGLE)
+        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRPLANE)
+        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRCHIRAL)
+        G2frame.Bind(wx.EVT_MENU, OnDefineRB, id=G2gd.wxID_DRAWDEFINERB)
         # RB Models
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.RigidBodiesMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnAutoFindResRB, id=G2gd.wxID_AUTOFINDRESRB)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBAssign, id=G2gd.wxID_ASSIGNATMS2RB)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBCopyParms, id=G2gd.wxID_COPYRBPARMS)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnGlobalResRBTherm, id=G2gd.wxID_GLOBALTHERM)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnGlobalResRBRef, id=G2gd.wxID_GLOBALRESREFINE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBRemoveAll, id=G2gd.wxID_RBREMOVEALL)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.RigidBodiesMenu)
+        G2frame.Bind(wx.EVT_MENU, OnAutoFindResRB, id=G2gd.wxID_AUTOFINDRESRB)
+        G2frame.Bind(wx.EVT_MENU, OnRBAssign, id=G2gd.wxID_ASSIGNATMS2RB)
+        G2frame.Bind(wx.EVT_MENU, OnRBCopyParms, id=G2gd.wxID_COPYRBPARMS)
+        G2frame.Bind(wx.EVT_MENU, OnGlobalResRBTherm, id=G2gd.wxID_GLOBALTHERM)
+        G2frame.Bind(wx.EVT_MENU, OnGlobalResRBRef, id=G2gd.wxID_GLOBALRESREFINE)
+        G2frame.Bind(wx.EVT_MENU, OnRBRemoveAll, id=G2gd.wxID_RBREMOVEALL)
         # Map peaks
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.MapPeaksMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksMove, id=G2gd.wxID_PEAKSMOVE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksViewPoint, id=G2gd.wxID_PEAKSVIEWPT)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDistVP, id=G2gd.wxID_PEAKSDISTVP)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDA, id=G2gd.wxID_PEAKSDA)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnShowBonds, id=G2gd.wxID_SHOWBONDS)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksEquiv, id=G2gd.wxID_FINDEQVPEAKS)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksUnique, id=G2gd.wxID_PEAKSUNIQUE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDelete, id=G2gd.wxID_PEAKSDELETE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksClear, id=G2gd.wxID_PEAKSCLEAR)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.MapPeaksMenu)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksMove, id=G2gd.wxID_PEAKSMOVE)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksViewPoint, id=G2gd.wxID_PEAKSVIEWPT)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksDistVP, id=G2gd.wxID_PEAKSDISTVP)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksDA, id=G2gd.wxID_PEAKSDA)
+        G2frame.Bind(wx.EVT_MENU, OnShowBonds, id=G2gd.wxID_SHOWBONDS)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksEquiv, id=G2gd.wxID_FINDEQVPEAKS)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksUnique, id=G2gd.wxID_PEAKSUNIQUE)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksDelete, id=G2gd.wxID_PEAKSDELETE)
+        G2frame.Bind(wx.EVT_MENU, OnPeaksClear, id=G2gd.wxID_PEAKSCLEAR)
         # MC/SA
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.MCSAMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAaddAtom, id=G2gd.wxID_ADDMCSAATOM)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAaddRB, id=G2gd.wxID_ADDMCSARB)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAclear, id=G2gd.wxID_CLEARMCSARB)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAmove, id=G2gd.wxID_MOVEMCSA)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnClearResults, id=G2gd.wxID_MCSACLEARRESULTS)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.MCSAMenu)
+        G2frame.Bind(wx.EVT_MENU, OnMCSAaddAtom, id=G2gd.wxID_ADDMCSAATOM)
+        G2frame.Bind(wx.EVT_MENU, OnMCSAaddRB, id=G2gd.wxID_ADDMCSARB)
+        G2frame.Bind(wx.EVT_MENU, OnMCSAclear, id=G2gd.wxID_CLEARMCSARB)
+        G2frame.Bind(wx.EVT_MENU, OnMCSAmove, id=G2gd.wxID_MOVEMCSA)
+        G2frame.Bind(wx.EVT_MENU, OnClearResults, id=G2gd.wxID_MCSACLEARRESULTS)
         # Texture
-        FillSelectPageMenu(TabSelectionIdDict, 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)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.TextureMenu)
+        G2frame.Bind(wx.EVT_MENU, OnTextureRefine, id=G2gd.wxID_REFINETEXTURE)
+#        G2frame.Bind(wx.EVT_MENU, OnTextureClear, id=G2gd.wxID_CLEARTEXTURE)
         # Pawley reflections
-        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.PawleyMenu)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySet, id=G2gd.wxID_PAWLEYSET)
-        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, OnPawleyUpdate, id=G2gd.wxID_PAWLEYUPDATE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySelAll, id=G2gd.wxID_PAWLEYSELALL)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySelNone, id=G2gd.wxID_PAWLEYSELNONE)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyToggle, id=G2gd.wxID_PAWLEYSELTOGGLE)
+        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.PawleyMenu)
+        G2frame.Bind(wx.EVT_MENU, OnPawleySet, id=G2gd.wxID_PAWLEYSET)
+        G2frame.Bind(wx.EVT_MENU, OnPawleyLoad, id=G2gd.wxID_PAWLEYLOAD)
+        G2frame.Bind(wx.EVT_MENU, OnPawleyEstimate, id=G2gd.wxID_PAWLEYESTIMATE)
+        G2frame.Bind(wx.EVT_MENU, OnPawleyUpdate, id=G2gd.wxID_PAWLEYUPDATE)
+        G2frame.Bind(wx.EVT_MENU, OnPawleySelAll, id=G2gd.wxID_PAWLEYSELALL)
+        G2frame.Bind(wx.EVT_MENU, OnPawleySelNone, id=G2gd.wxID_PAWLEYSELNONE)
+        G2frame.Bind(wx.EVT_MENU, OnPawleyToggle, id=G2gd.wxID_PAWLEYSELTOGGLE)
         
     # UpdatePhaseData execution starts here
@@ -8230 +8223 @@
     global rbAtmDict   
     rbAtmDict = {}
-    if G2frame.dataDisplay:
-        G2frame.dataDisplay.Destroy()
     PhaseName = G2frame.PatternTree.GetItemText(Item)
     G2gd.SetDataMenuBar(G2frame)
-    G2frame.dataFrame.SetLabel('Phase Data for '+PhaseName)
-    G2frame.dataFrame.CreateStatusBar()
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+PhaseName)
+    G2frame.dataWindow.ClearData()
     if GSASIIpath.GetConfigValue('debug'):
-        G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
-            style=wx.aui.AUI_NB_DEFAULT_STYLE ^ wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB)
+        G2frame.phaseDisplay = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize(),
+            style=wx.aui.AUI_NB_TOP | wx.aui.AUI_NB_TAB_SPLIT | wx.aui.AUI_NB_TAB_MOVE)
     else:
-        G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
-    G2frame.dataDisplay.gridList = [] # list of all grids in notebook
+        G2frame.phaseDisplay = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize())
+    G2frame.phaseDisplay.gridList = [] # list of all grids in notebook
     Pages = []    
-    G2frame.dataDisplay.gridList = []
-    General = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(General,'General')
+    G2frame.phaseDisplay.gridList = []
+    General = wx.ScrolledWindow(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.AddPage(General,'General')
     Pages.append('General')
-    DData = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(DData,'Data')
+    DData = wx.ScrolledWindow(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.AddPage(DData,'Data')
     Pages.append('Data')
-    Atoms = G2G.GSGrid(G2frame.dataDisplay)
-    G2frame.dataDisplay.gridList.append(Atoms)
-    G2frame.dataDisplay.AddPage(Atoms,'Atoms')
+    Atoms = G2G.GSGrid(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.gridList.append(Atoms)
+    G2frame.phaseDisplay.AddPage(Atoms,'Atoms')
     Pages.append('Atoms')
     if data['General']['Modulated']:
-        G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
-        G2frame.dataDisplay.AddPage(G2frame.waveData,'Wave Data')
+        G2frame.waveData = wx.ScrolledWindow(G2frame.phaseDisplay)
+        G2frame.phaseDisplay.AddPage(G2frame.waveData,'Wave Data')
         Pages.append('Wave Data') 
     if data['General']['Type'] == 'faulted':
-        G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
-        G2frame.dataDisplay.AddPage(G2frame.layerData,'Layers')
+        G2frame.layerData = wx.ScrolledWindow(G2frame.phaseDisplay)
+        G2frame.phaseDisplay.AddPage(G2frame.layerData,'Layers')
         Pages.append('Layers')               
-    drawOptions = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(drawOptions,'Draw Options')
+    drawOptions = wx.ScrolledWindow(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.AddPage(drawOptions,'Draw Options')
     Pages.append('Draw Options')
-    drawAtoms = G2G.GSGrid(G2frame.dataDisplay)
-    G2frame.dataDisplay.gridList.append(drawAtoms)
-    G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
+    drawAtoms = G2G.GSGrid(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.gridList.append(drawAtoms)
+    G2frame.phaseDisplay.AddPage(drawAtoms,'Draw Atoms')
     Pages.append('Draw Atoms')
     if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
-        RigidBodies = wx.ScrolledWindow(G2frame.dataDisplay)
-        G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
+        RigidBodies = wx.ScrolledWindow(G2frame.phaseDisplay)
+        G2frame.phaseDisplay.AddPage(RigidBodies,'RB Models')
         Pages.append('RB Models')
-    MapPeaks = G2G.GSGrid(G2frame.dataDisplay)
-    G2frame.dataDisplay.gridList.append(MapPeaks)    
-    G2frame.dataDisplay.AddPage(MapPeaks,'Map peaks')
+    MapPeaks = G2G.GSGrid(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.gridList.append(MapPeaks)    
+    G2frame.phaseDisplay.AddPage(MapPeaks,'Map peaks')
     Pages.append('Map peaks')
     if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
-        G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
-        G2frame.dataDisplay.AddPage(G2frame.MCSA,'MC/SA')
+        G2frame.MCSA = wx.ScrolledWindow(G2frame.phaseDisplay)
+        G2frame.phaseDisplay.AddPage(G2frame.MCSA,'MC/SA')
         Pages.append('MC/SA')
-    Texture = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(Texture,'Texture')
+    Texture = wx.ScrolledWindow(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.AddPage(Texture,'Texture')
     Pages.append('Texture')
-    G2frame.PawleyRefl = G2G.GSGrid(G2frame.dataDisplay)
-    G2frame.dataDisplay.gridList.append(G2frame.PawleyRefl)
-    G2frame.dataDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
+    G2frame.PawleyRefl = G2G.GSGrid(G2frame.phaseDisplay)
+    G2frame.phaseDisplay.gridList.append(G2frame.PawleyRefl)
+    G2frame.phaseDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
     Pages.append('Pawley reflections')
     G2frame.dataFrame.AtomCompute.Enable(G2gd.wxID_ISODISP,'ISODISTORT' in data)
     G2frame.dataFrame.AtomCompute.Enable(G2gd.wxID_VALIDPROTEIN,'macro' in data['General']['Type'])
-    G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
+    G2frame.phaseDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     FillMenus()
     if oldPage is None or oldPage == 0:
         ChangePage(0)
-        wx.CallAfter(G2frame.dataDisplay.SendSizeEvent)
+        wx.CallAfter(G2frame.phaseDisplay.SendSizeEvent)
     elif oldPage:
         SetupGeneral()    # not sure why one might need this when moving from phase to phase; but does not hurt
-        G2frame.dataDisplay.SetSelection(oldPage)
+        G2frame.phaseDisplay.SetSelection(oldPage)

branch/2frame/GSASIIplot.py

@@ -1826 +1826 @@
         Phases = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Reflection Lists'))
         Page.phaseList = sorted(Phases.keys()) # define an order for phases (once!)
-        G2frame.dataFrame.Bind(wx.EVT_MENU, onMoveDiffCurve, id=G2frame.dataFrame.moveDiffCurve.GetId())
-        G2frame.dataFrame.Bind(wx.EVT_MENU, onMoveTopTick, id=G2frame.dataFrame.moveTickLoc.GetId())
-        G2frame.dataFrame.Bind(wx.EVT_MENU, onMoveTickSpace, id=G2frame.dataFrame.moveTickSpc.GetId())
-        G2frame.dataFrame.moveDiffCurve.Enable(False)
-        G2frame.dataFrame.moveTickLoc.Enable(False)
-        G2frame.dataFrame.moveTickSpc.Enable(False)
+        G2frame.dataWindow.Bind(wx.EVT_MENU, onMoveDiffCurve, id=G2frame.dataWindow.moveDiffCurve.GetId())
+        G2frame.dataWindow.Bind(wx.EVT_MENU, onMoveTopTick, id=G2frame.dataWindow.moveTickLoc.GetId())
+        G2frame.dataWindow.Bind(wx.EVT_MENU, onMoveTickSpace, id=G2frame.dataWindow.moveTickSpc.GetId())
+        G2frame.dataWindow.moveDiffCurve.Enable(False)
+        G2frame.dataWindow.moveTickLoc.Enable(False)
+        G2frame.dataWindow.moveTickSpc.Enable(False)
     elif G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Peak List':
-        G2frame.dataFrame.Bind(wx.EVT_MENU, onMovePeak, id=G2frame.dataFrame.movePeak.GetId())
+        G2frame.dataFrame.Bind(wx.EVT_MENU, onMovePeak, id=G2frame.dataWindow.movePeak.GetId())
     # save information needed to reload from tree and redraw
     kwargs={'PatternName':G2frame.PatternTree.GetItemText(G2frame.PatternId)}
@@ -2154 +2154 @@
                         data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
                         selectedPeaks = list(set(
-                            [row for row,col in G2frame.dataDisplay.GetSelectedCells()] +
-                            G2frame.dataDisplay.GetSelectedRows()))
-                        G2frame.dataFrame.movePeak.Enable(len(selectedPeaks) == 1) # allow peak move from table when one peak is selected
+                            [row for row,col in G2frame.reflGrid.GetSelectedCells()] +
+                            G2frame.reflGrid.GetSelectedRows()))
+                        G2frame.dataWindow.movePeak.Enable(len(selectedPeaks) == 1) # allow peak move from table when one peak is selected
                         for i,item in enumerate(data['peaks']):
                             if i in selectedPeaks:
@@ -2292 +2292 @@
     if 'PWDR' in G2frame.PatternTree.GetItemText(G2frame.PickId):
         if len(Page.tickDict.keys()) == 1:
-            G2frame.dataFrame.moveTickLoc.Enable(True)
+            G2frame.dataWindow.moveTickLoc.Enable(True)
         elif len(Page.tickDict.keys()) > 1:
-            G2frame.dataFrame.moveTickLoc.Enable(True)
-            G2frame.dataFrame.moveTickSpc.Enable(True)
+            G2frame.dataWindow.moveTickLoc.Enable(True)
+            G2frame.dataWindow.moveTickSpc.Enable(True)
         if DifLine[0]:
-            G2frame.dataFrame.moveDiffCurve.Enable(True)
+            G2frame.dataWindow.moveDiffCurve.Enable(True)
     
 ################################################################################
@@ -4375 +4375 @@
       triggers the addition of a d-zero.    
     '''
-    G2frame.dataFrame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value',0)
+    G2frame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value',0)
     G2frame.PickId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Stress/Strain')
     data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
@@ -4856 +4856 @@
                         Data['ring'].append([xpos,ypos])
                 elif event.button == 3:
-                    G2frame.dataFrame.GetStatusBar().SetStatusText('Calibrating...',0)
+                    G2frame.GetStatusBar().SetStatusText('Calibrating...',0)
                     if G2img.ImageCalibrate(G2frame,Data):
-                        G2frame.dataFrame.GetStatusBar().SetStatusText('Calibration successful - Show ring picks to check',0)
+                        G2frame.GetStatusBar().SetStatusText('Calibration successful - Show ring picks to check',0)
                         print 'Calibration successful'
                     else:
-                        G2frame.dataFrame.GetStatusBar().SetStatusText('Calibration failed - Show ring picks to diagnose',0)
+                        G2frame.GetStatusBar().SetStatusText('Calibration failed - Show ring picks to diagnose',0)
                         print 'Calibration failed'
                     G2frame.ifGetRing = False
@@ -6247 +6247 @@
         GL.glMultMatrixf(B4mat.T)
         GL.glDisable(GL.GL_LIGHTING)
-        GL.glRasterPos3f(0,0,0)
+        GL.glWindowPos3f(0,0,0)
         GL.glMultMatrixf(matRot)
         GL.glRotate(180,1,0,0)             #fix to flip about x-axis
@@ -6254 +6254 @@
         GL.glEnable(GL.GL_LIGHTING)
         GL.glPopMatrix()
-        
+         
     def RenderMap(rho,rhoXYZ,indx,Rok):
         GL.glShadeModel(GL.GL_FLAT)

branch/2frame/GSASIIpwdGUI.py

@@ -20 +20 @@
 import wx
 import wx.grid as wg
-import wx.lib.scrolledpanel as wxscroll
 import numpy as np
 import numpy.ma as ma
@@ -424 +423 @@
     '''respond to selection of PWDR powder peaks data tree item.
     '''
-    if G2frame.dataDisplay:
-        G2frame.dataFrame.Clear()
-        
     def OnAutoSearch(event):
         PatternId = G2frame.PatternId
@@ -495 +491 @@
         for item in ['Background','Instrument Parameters','Peak List']:
             G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item),cPickle.load(file))
-            if G2frame.dataDisplay.GetName() == item:
+            if G2frame.dataWindow.GetName() == item:
                 if item == 'Background':
                     UpdateBackground(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
@@ -515 +511 @@
         
     def OnLSQPeakFit(event):
-        if G2frame.dataDisplay.IsCellEditControlEnabled(): # complete any grid edits in progress
-            G2frame.dataDisplay.HideCellEditControl()
-            G2frame.dataDisplay.DisableCellEditControl()
+        if reflGrid.IsCellEditControlEnabled(): # complete any grid edits in progress
+            reflGrid.HideCellEditControl()
+            reflGrid.DisableCellEditControl()
         if not G2frame.GSASprojectfile:            #force a save of the gpx file so SaveState can write in the same directory
             G2frame.OnFileSaveas(event)
@@ -523 +519 @@
         
     def OnOneCycle(event):
-        if G2frame.dataDisplay.IsCellEditControlEnabled(): # complete any grid edits in progress
-            G2frame.dataDisplay.HideCellEditControl()
-            G2frame.dataDisplay.DisableCellEditControl()
+        if reflGrid.IsCellEditControlEnabled(): # complete any grid edits in progress
+            reflGrid.HideCellEditControl()
+            reflGrid.DisableCellEditControl()
         wx.CallAfter(OnPeakFit,'LSQ',oneCycle=True)
         
@@ -672 +668 @@
         
     def setBackgroundColors():
-       for r in range(G2frame.dataDisplay.GetNumberRows()):
-           for c in range(G2frame.dataDisplay.GetNumberCols()):
-               if G2frame.dataDisplay.GetColLabelValue(c) in ['position','intensity','alpha','beta','sigma','gamma']:
-                   if float(G2frame.dataDisplay.GetCellValue(r,c)) < 0.:
-                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.RED)
+       for r in range(reflGrid.GetNumberRows()):
+           for c in range(reflGrid.GetNumberCols()):
+               if reflGrid.GetColLabelValue(c) in ['position','intensity','alpha','beta','sigma','gamma']:
+                   if float(reflGrid.GetCellValue(r,c)) < 0.:
+                       reflGrid.SetCellBackgroundColour(r,c,wx.RED)
                    else:
-                       G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.WHITE)
+                       reflGrid.SetCellBackgroundColour(r,c,wx.WHITE)
                                                   
     def KeyEditPeakGrid(event):
@@ -684 +680 @@
         in the Peak List table
         '''
-        rowList = G2frame.dataDisplay.GetSelectedRows()
-        colList = G2frame.dataDisplay.GetSelectedCols()
-        selectList = G2frame.dataDisplay.GetSelectedCells()
+        rowList = reflGrid.GetSelectedRows()
+        colList = reflGrid.GetSelectedCols()
+        selectList = reflGrid.GetSelectedCells()
         data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
         if event.GetKeyCode() == wx.WXK_RETURN:
@@ -696 +692 @@
         elif rowList and (event.GetKeyCode() == wx.WXK_DELETE or event.GetKeyCode() == 8):
             # pressing the delete key or backspace deletes selected peak(s)
-            G2frame.dataDisplay.ClearSelection()
-            G2frame.dataDisplay.ClearGrid()
+            reflGrid.ClearSelection()
+            reflGrid.ClearGrid()
             rowList.sort()
             rowList.reverse()
@@ -707 +703 @@
                 msg = wg.GridTableMessage(G2frame.PeakTable, 
                     wg.GRIDTABLE_NOTIFY_ROWS_DELETED,0,nDel)
-                G2frame.dataDisplay.ProcessTableMessage(msg)
+                reflGrid.ProcessTableMessage(msg)
             data['peaks'] = G2frame.PeakTable.GetData()[:-nDel]
             G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
-            wx.CallAfter(G2frame.dataDisplay.ForceRefresh)
+            wx.CallAfter(reflGrid.ForceRefresh)
             setBackgroundColors()
         elif colList and (event.GetKeyCode() == 89 or event.GetKeyCode() == 78):
-            G2frame.dataDisplay.ClearSelection()
+            reflGrid.ClearSelection()
             key = event.GetKeyCode()
             for col in colList:
@@ -722 +718 @@
                         for row in range(G2frame.PeakTable.GetNumberRows()): data['peaks'][row][col]=False
         elif selectList and (event.GetKeyCode() == 89 or event.GetKeyCode() == 78):
-            G2frame.dataDisplay.ClearSelection()
+            reflGrid.ClearSelection()
             key = event.GetKeyCode()
             for row,col in selectList:
@@ -734 +730 @@
             return
         G2plt.PlotPatterns(G2frame,plotType='PWDR')
-        #wx.CallAfter(G2frame.dataDisplay.ForceRefresh) # did not always work
+        #wx.CallAfter(G2frame.dataWindow.ForceRefresh) # did not always work
         wx.CallAfter(UpdatePeakGrid,G2frame,data)
             
@@ -740 +736 @@
         '''Set or clear peak refinement variables for peaks listed in rows
         '''
-        refOpts = {G2frame.dataDisplay.GetColLabelValue(i):i+1 for i in range(G2frame.dataDisplay.GetNumberCols()) if G2frame.dataDisplay.GetColLabelValue(i) != "refine"}
+        refOpts = {reflGrid.GetColLabelValue(i):i+1 for i in range(reflGrid.GetNumberCols()) if reflGrid.GetColLabelValue(i) != "refine"}
         dlg = G2G.G2MultiChoiceDialog(
             G2frame.dataFrame, 
@@ -762 +758 @@
         '''set refinement flags for the selected peaks
         '''
-        rows = list(set([row for row,col in G2frame.dataDisplay.GetSelectedCells()] +
-                        G2frame.dataDisplay.GetSelectedRows()))
+        rows = list(set([row for row,col in reflGrid.GetSelectedCells()] +
+                        reflGrid.GetSelectedRows()))
         if not rows:
             wx.MessageBox('No selected rows. You must select rows or cells before using this command',
@@ -773 +769 @@
         '''set refinement flags for all peaks
         '''
-        SelectVars(range(G2frame.dataDisplay.GetNumberRows()))
+        SelectVars(range(reflGrid.GetNumberRows()))
 
     def onCellListSClick(event):
@@ -786 +782 @@
         '''Called after a double-click on a cell label'''
         r,c =  event.GetRow(),event.GetCol()
-        grid = G2frame.dataDisplay
         if r < 0 and c < 0:
-            for row in range(grid.GetNumberRows()):
-                grid.SelectRow(row,True)                    
-            for col in range(grid.GetNumberCols()):
-                grid.SelectCol(col,True)                    
+            for row in range(reflGrid.GetNumberRows()):
+                reflGrid.SelectRow(row,True)                    
+            for col in range(reflGrid.GetNumberCols()):
+                reflGrid.SelectCol(col,True)                    
         elif r > 0:     #row label: select it and replot!
-            grid.ClearSelection()
-            grid.SelectRow(r,True)
-            wx.CallAfter(G2frame.dataDisplay.ForceRefresh)
+            reflGrid.ClearSelection()
+            reflGrid.SelectRow(r,True)
+            wx.CallAfter(G2frame.dataWindow.ForceRefresh)
             wx.CallAfter(G2plt.PlotPatterns,G2frame,plotType='PWDR')
         elif c > 0:     #column label: just select it (& redisplay)
-            grid.ClearSelection()
-            grid.SelectCol(c,True)
-            if grid.GetColLabelValue(c) != 'refine': return
+            reflGrid.ClearSelection()
+            reflGrid.SelectCol(c,True)
+            if reflGrid.GetColLabelValue(c) != 'refine': return
             choice = ['Y - vary all','N - vary none',]
             dlg = wx.SingleChoiceDialog(G2frame.dataFrame,
-                                        'Select refinement option for '+grid.GetColLabelValue(c-1),
+                                        'Select refinement option for '+reflGrid.GetColLabelValue(c-1),
                                         'Refinement controls',choice)
             dlg.CenterOnParent()
@@ -809 +804 @@
                 sel = dlg.GetSelection()
                 if sel == 0:
-                    for row in range(grid.GetNumberRows()): data['peaks'][row][c]=True
+                    for row in range(reflGrid.GetNumberRows()): data['peaks'][row][c]=True
                 else:
-                    for row in range(grid.GetNumberRows()): data['peaks'][row][c]=False
+                    for row in range(reflGrid.GetNumberRows()): data['peaks'][row][c]=False
             wx.CallAfter(UpdatePeakGrid,G2frame,data)
                  
@@ -817 +812 @@
     # beginning of UpdatePeakGrid init
     #======================================================================
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PeakMenu)
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()
-    Status.SetStatusText('Global refine: select refine column & press Y or N')
+    G2frame.dataWindow.ClearData()
+    G2frame.GetStatusBar().SetStatusText('Global refine: select refine column & press Y or N')
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.PeakMenu)
     G2frame.Bind(wx.EVT_MENU, OnAutoSearch, id=G2gd.wxID_AUTOSEARCH)
     G2frame.Bind(wx.EVT_MENU, OnCopyPeaks, id=G2gd.wxID_PEAKSCOPY)
@@ -832 +826 @@
     G2frame.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
     if data['peaks']:
-        G2frame.dataFrame.AutoSearch.Enable(False)
-        G2frame.dataFrame.PeakCopy.Enable(True)
-        G2frame.dataFrame.PeakFit.Enable(True)
-        G2frame.dataFrame.PFOneCycle.Enable(True)
-        G2frame.dataFrame.SeqPeakFit.Enable(True)
+        G2frame.dataWindow.AutoSearch.Enable(False)
+        G2frame.dataWindow.PeakCopy.Enable(True)
+        G2frame.dataWindow.PeakFit.Enable(True)
+        G2frame.dataWindow.PFOneCycle.Enable(True)
+        G2frame.dataWindow.SeqPeakFit.Enable(True)
     else:
-        G2frame.dataFrame.PeakFit.Enable(False)
-        G2frame.dataFrame.PeakCopy.Enable(False)
-        G2frame.dataFrame.PFOneCycle.Enable(False)
-        G2frame.dataFrame.AutoSearch.Enable(True)
-        G2frame.dataFrame.SeqPeakFit.Enable(False)
+        G2frame.dataWindow.PeakFit.Enable(False)
+        G2frame.dataWindow.PeakCopy.Enable(False)
+        G2frame.dataWindow.PFOneCycle.Enable(False)
+        G2frame.dataWindow.AutoSearch.Enable(True)
+        G2frame.dataWindow.SeqPeakFit.Enable(False)
     G2frame.PickTable = []
     rowLabels = []
@@ -875 +869 @@
     G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
     G2frame.PeakTable = G2G.Table(data['peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-    G2frame.dataFrame.SetLabel('Peak List')
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Peak List')
     G2frame.dataFrame.currentGrids = []
-    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
-    G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
+    reflGrid = G2G.GSGrid(parent=G2frame.dataWindow)
+    reflGrid.SetTable(G2frame.PeakTable, True)
     setBackgroundColors()                         
-    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
-    G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
-    G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, onCellListSClick)
-#    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, onCellListSClick)
-    G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, onCellListDClick)
-#    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, onCellListDClick)
-    G2frame.dataDisplay.SetMargins(0,0)
-    G2frame.dataDisplay.AutoSizeColumns(False)
-    G2frame.dataFrame.setSizePosLeft([535,350])
-    #G2frame.dataFrame.SendSizeEvent()
+    reflGrid.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
+    reflGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
+    reflGrid.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, onCellListSClick)
+#    G2frame.dataWindow.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, onCellListSClick)
+    reflGrid.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, onCellListDClick)
+#    G2frame.dataWindow.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, onCellListDClick)
+    reflGrid.SetMargins(0,0)
+    reflGrid.AutoSizeColumns(False)
+    G2frame.reflGrid = reflGrid
+    mainSizer = wx.BoxSizer(wx.VERTICAL)
+    mainSizer.Add(reflGrid)
+    mainSizer.Layout()    
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataWindow)
+    G2frame.SetDataSize()    
 
 ################################################################################
@@ -1108 +1107 @@
         backSizer = wx.BoxSizer(wx.VERTICAL)
         topSizer = wx.BoxSizer(wx.HORIZONTAL)
-        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background function: '),0,WACV)
-        bakType = wx.ComboBox(G2frame.dataDisplay,value=data[0][0],
+        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background function: '),0,WACV)
+        bakType = wx.ComboBox(G2frame.dataWindow,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(G2frame.dataDisplay,label=' Refine?')
+        bakRef = wx.CheckBox(G2frame.dataWindow,label=' Refine?')
         bakRef.SetValue(bool(data[0][1]))
         bakRef.Bind(wx.EVT_CHECKBOX, OnBakRef)
         topSizer.Add(bakRef,0,WACV)
-        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
-        bakTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
+        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' No. coeff.: '),0,WACV)
+        bakTerms = wx.ComboBox(G2frame.dataWindow,-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)
@@ -1125 +1124 @@
         topSizer.Add((5,0),0)
         backSizer.Add(topSizer)
-        backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background coefficients:'),0,WACV)
+        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background coefficients:'),0,WACV)
         bakSizer = wx.FlexGridSizer(0,5,5,5)
         for i,value in enumerate(data[0][3:]):
-            bakVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[0],i+3,nDig=(10,4),typeHint=float)
+            bakVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[0],i+3,nDig=(10,4),typeHint=float)
             bakSizer.Add(bakVal,0,WACV)
         backSizer.Add(bakSizer)
@@ -1169 +1168 @@
         debSizer = wx.BoxSizer(wx.VERTICAL)
         topSizer = wx.BoxSizer(wx.HORIZONTAL)
-        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye scattering: '),0,WACV)
-        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
-        debTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
+        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Debye scattering: '),0,WACV)
+        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' No. coeff.: '),0,WACV)
+        debTerms = wx.ComboBox(G2frame.dataWindow,-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)
@@ -1178 +1177 @@
         debSizer.Add(topSizer)
         if data[1]['nDebye']:
-            debSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye diffuse terms:'),0,WACV)       
+            debSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Debye diffuse terms:'),0,WACV)       
             rowLabels = []
             for i in range(len(data[1]['debyeTerms'])): rowLabels.append(str(i))
@@ -1186 +1185 @@
             wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
             debyeTable = G2G.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            debyeGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
+            debyeGrid = G2G.GSGrid(parent=G2frame.dataWindow)
             debyeGrid.SetTable(debyeTable, True)
             debyeGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
@@ -1228 +1227 @@
         peaksSizer = wx.BoxSizer(wx.VERTICAL)
         topSizer = wx.BoxSizer(wx.HORIZONTAL)
-        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peaks in background: '),0,WACV)
-        topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. peaks: '),0,WACV)
-        peaks = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(30)],
+        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Peaks in background: '),0,WACV)
+        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' No. peaks: '),0,WACV)
+        peaks = wx.ComboBox(G2frame.dataWindow,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(30)],
             style=wx.CB_READONLY|wx.CB_DROPDOWN)
         peaks.Bind(wx.EVT_COMBOBOX,OnPeaks)
@@ -1238 +1237 @@
         G2frame.dataFrame.currentGrids = []
         if data[1]['nPeaks']:
-            peaksSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peak list:'),0,WACV)       
+            peaksSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Peak list:'),0,WACV)       
             rowLabels = []
             for i in range(len(data[1]['peaksList'])): rowLabels.append(str(i))
@@ -1247 +1246 @@
             wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
             peaksTable = G2G.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            peaksGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
+            peaksGrid = G2G.GSGrid(parent=G2frame.dataWindow)
             peaksGrid.SetTable(peaksTable, True)
             peaksGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
@@ -1254 +1253 @@
         return peaksSizer
                 
-    if G2frame.dataDisplay:
-        G2frame.dataFrame.DestroyChildren()
-    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.BackMenu)
-    G2frame.dataFrame.SetLabel('Background')
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.BackMenu)
+    G2frame.dataWindow.ClearData()
     G2frame.Bind(wx.EVT_MENU,OnBackCopy,id=G2gd.wxID_BACKCOPY)
     G2frame.Bind(wx.EVT_MENU,OnBackFlagCopy,id=G2gd.wxID_BACKFLAGCOPY)
@@ -1276 +1270 @@
     mainSizer.Add(PeaksSizer())
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    Size = mainSizer.Fit(G2frame.dataFrame)
-    G2frame.dataFrame.setSizePosLeft(Size)
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataFrame)
+    G2frame.SetDataSize()
         
 ################################################################################
@@ -1297 +1291 @@
         labels = ['Tmin','Tmax']
         for i in [0,1]:
-            limits.Add(wx.StaticText(G2frame.dataDisplay,label=' Original %s: %.4f'%(labels[0],data[0][i])),0,WACV)
-            limits.Add(wx.StaticText(G2frame.dataDisplay,label=' New: '),0,WACV)
-            limits.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[1],i,  \
+            limits.Add(wx.StaticText(G2frame.dataWindow,label=' Original %s: %.4f'%(labels[0],data[0][i])),0,WACV)
+            limits.Add(wx.StaticText(G2frame.dataWindow,label=' New: '),0,WACV)
+            limits.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[1],i,  \
                 min=data[0][0],max=data[0][1],nDig=(10,4),typeHint=float,OnLeave=AfterChange))
         return limits
@@ -1314 +1308 @@
         Indx = {}
         excl = wx.FlexGridSizer(0,3,0,5)
-        excl.Add(wx.StaticText(G2frame.dataDisplay,label=' From: '),0,WACV)
-        excl.Add(wx.StaticText(G2frame.dataDisplay,label=' To: '),0,WACV)
-        excl.Add(wx.StaticText(G2frame.dataDisplay,label=' Delete?: '),0,WACV)
+        excl.Add(wx.StaticText(G2frame.dataWindow,label=' From: '),0,WACV)
+        excl.Add(wx.StaticText(G2frame.dataWindow,label=' To: '),0,WACV)
+        excl.Add(wx.StaticText(G2frame.dataWindow,label=' Delete?: '),0,WACV)
         for id,item in enumerate(data[2:]):
             for i in [0,1]:
-                excl.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,i,  \
+                excl.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,item,i,  \
                     min=data[0][0],max=data[0][1],nDig=(10,4),typeHint=float,OnLeave=AfterChange))
-            delExcl = wx.CheckBox(G2frame.dataDisplay,label='')
+            delExcl = wx.CheckBox(G2frame.dataWindow,label='')
             Indx[delExcl.GetId()] = id
             delExcl.Bind(wx.EVT_CHECKBOX,OnDelExcl)
@@ -1356 +1350 @@
         if len(data)>2:
 #            mainSizer.Add((0,5),0)
-            mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Excluded regions:'),0,WACV)
+            mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Excluded regions:'),0,WACV)
             mainSizer.Add(ExclSizer())
         mainSizer.Layout()    
-        G2frame.dataDisplay.SetSizer(mainSizer)
-        Size = mainSizer.Fit(G2frame.dataFrame)
-        G2frame.dataFrame.setSizePosLeft(Size)
-        
-    if G2frame.dataDisplay:
+        G2frame.dataWindow.SetSizer(mainSizer)
+        mainSizer.Fit(G2frame.dataFrame)
+        G2frame.SetDataSize()
+        
+    if G2frame.dataWindow:
         G2frame.dataFrame.DestroyChildren()
     G2frame.ifGetExclude = False
-    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LimitMenu)
-    G2frame.dataFrame.SetLabel('Limits')
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.LimitMenu)
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Limits')
     G2frame.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
     G2frame.Bind(wx.EVT_MENU,OnAddExcl,id=G2gd.wxID_ADDEXCLREGION)
@@ -1683 +1674 @@
     def RefineBox(item):
         'Define a refine checkbox with binding'
-        wid = wx.CheckBox(G2frame.dataDisplay,label=' Refine?  ')
+        wid = wx.CheckBox(G2frame.dataWindow,label=' Refine?  ')
         wid.SetValue(bool(insRef[item]))
         RefObj[wid.GetId()] = item
@@ -1706 +1697 @@
 
     def MakeParameterWindow():
-        'Displays the Instrument parameters in the datadisplay frame'
-        if G2frame.dataDisplay:
-            G2frame.dataFrame.Clear()
-        G2frame.dataFrame.SetLabel('Instrument Parameters')
-        G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
+        'Displays the Instrument parameters in the dataWindow frame'
+        G2frame.dataFrame.ClearData()
+        G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Instrument Parameters')
         mainSizer = wx.BoxSizer(wx.VERTICAL)
         instSizer = wx.FlexGridSizer(0,6,5,5)
@@ -1717 +1706 @@
             insVal['Bank'] = 1
         text = ' Histogram Type: %s  Bank: %d'%(insVal['Type'],insVal['Bank'])
-        subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,text),0,WACV)
+        subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,text),0,WACV)
         mainSizer.Add(subSizer)
         labelLst[:],elemKeysLst[:],dspLst[:],refFlgElem[:] = [],[],[],[]
@@ -1728 +1717 @@
                 if 'Lam1' in insVal:
                     subSizer = wx.BoxSizer(wx.HORIZONTAL)
-                    subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: '),0,WACV)
+                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Azimuth: '),0,WACV)
                     txt = '%7.2f'%(insVal['Azimuth'])
-                    subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
-                    subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'   Ka1/Ka2: '),0,WACV)
+                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
+                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'   Ka1/Ka2: '),0,WACV)
                     txt = u'  %8.6f/%8.6f\xc5'%(insVal['Lam1'],insVal['Lam2'])
-                    subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
+                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
                     waveSizer = wx.BoxSizer(wx.HORIZONTAL)
-                    waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Source type: '),0,WACV)
+                    waveSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  Source type: '),0,WACV)
                     # PATCH?: for now at least, Source is not saved anywhere before here
                     if 'Source' not in data: data['Source'] = ['CuKa','?']
                     choice = ['TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
-                    lamPick = wx.ComboBox(G2frame.dataDisplay,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
+                    lamPick = wx.ComboBox(G2frame.dataWindow,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
                     lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
                     waveSizer.Add(lamPick,0)
@@ -1745 +1734 @@
                     mainSizer.Add(subSizer)
                     instSizer.Add(wx.StaticText(
-                        G2frame.dataDisplay,-1,
+                        G2frame.dataWindow,-1,
                         lblWdef('I(L2)/I(L1)',4,insDef['I(L2)/I(L1)'])),
                         0,WACV)
@@ -1753 +1742 @@
                     dspLst.append([10,4])
                     refFlgElem.append([key,2])                   
-                    ratVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
+                    ratVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,key,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
                     instSizer.Add(ratVal,0)
                     instSizer.Add(RefineBox(key),0,WACV)
@@ -1760 +1749 @@
                     instSizer.Add((5,5),0)                
                 else: # single wavelength
-                    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: '),0,WACV)
+                    instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Azimuth: '),0,WACV)
                     txt = '%7.2f'%(insVal['Azimuth'])
-                    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
+                    instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
                     instSizer.Add((5,5),0)
                     key = 'Lam'
-                    instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
+                    instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
                         0,WACV)
-                    waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
+                    waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
                     labelLst.append(u'Lam (\xc5)')
                     elemKeysLst.append([key,1])
@@ -1786 +1775 @@
                         dspLst.append([10,4])
                         instSizer.Add(
-                            wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,4,insDef[item])),
+                            wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,4,insDef[item])),
                             0,WACV)
-                        itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
+                        itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
                         instSizer.Add(itemVal,0,WACV)
                         refFlgElem.append([item,2])
@@ -1816 +1805 @@
                     refFlgElem.append([item,2])
                     instSizer.Add(
-                        wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,nDig[1],insDef[item])),
+                        wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,nDig[1],insDef[item])),
                         0,WACV)
-                    itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
+                    itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
                     instSizer.Add(itemVal,0,WACV)
                     instSizer.Add(RefineBox(item),0,WACV)
             elif 'T' in insVal['Type']:                                   #time of flight (neutrons)
                 subSizer = wx.BoxSizer(wx.HORIZONTAL)
-                subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Fligth path: '),0,WACV)
+                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Fligth path: '),0,WACV)
                 txt = '%8.3f'%(insVal['fltPath'])
-                subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
+                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
                 labelLst.append('flight path')
                 elemKeysLst.append(['fltPath',1])
                 dspLst.append([10,2])
                 refFlgElem.append(None)                   
-                subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  2-theta: '),0,WACV)
+                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  2-theta: '),0,WACV)
                 txt = '%7.2f'%(insVal['2-theta'])
-                subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
+                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
                 labelLst.append('2-theta')
                 elemKeysLst.append(['2-theta',1])
@@ -1839 +1828 @@
                 if 'Pdabc' in Inst2:
                     Items = ['sig-0','sig-1','sig-2','sig-q','X','Y']
-                    subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  difC: '),0,WACV)
+                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  difC: '),0,WACV)
                     txt = '%8.2f'%(insVal['difC'])
-                    subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
+                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
                     labelLst.append('difC')
                     elemKeysLst.append(['difC',1])
                     dspLst.append([10,2])
                     refFlgElem.append(None)
-                    subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  alpha, beta: fixed by table'),0,WACV)
+                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  alpha, beta: fixed by table'),0,WACV)
                 else:
                     Items = ['difC','difA','difB','Zero','alpha','beta-0','beta-1','beta-q','sig-0','sig-1','sig-2','sig-q','X','Y']
@@ -1862 +1851 @@
                         nDig = (12,6)
                     instSizer.Add(
-                            wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,nDig[1],insDef[item])),
+                            wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,nDig[1],insDef[item])),
                             0,WACV)
-                    itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
+                    itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
                     instSizer.Add(itemVal,0,WACV)
                     labelLst.append(item)
@@ -1873 +1862 @@
             elif 'PKS' in insVal['Type']:   #peak positions only
                 key = 'Lam'
-                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
+                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
                     0,WACV)
-                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
+                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
                 labelLst.append(u'Lam (\xc5)')
                 elemKeysLst.append([key,1])
@@ -1888 +1877 @@
                         dspLst.append([10,4])
                         instSizer.Add(
-                            wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,4,insDef[item])),
+                            wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,4,insDef[item])),
                             0,WACV)
-                        itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
+                        itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
                         instSizer.Add(itemVal,0,WACV)
                         refFlgElem.append([item,2])
@@ -1898 +1887 @@
         elif 'S' in insVal['Type']:                       #single crystal data
             if 'C' in insVal['Type']:               #constant wavelength
-                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
+                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
                     0,WACV)
-                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
+                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
                 instSizer.Add(waveVal,0,WACV)
                 labelLst.append(u'Lam (\xc5)')
                 waveSizer = wx.BoxSizer(wx.HORIZONTAL)
-                waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Source type: '),0,WACV)
+                waveSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  Source type: '),0,WACV)
                 # PATCH?: for now at least, Source is not saved anywhere before here
                 if 'Source' not in data: data['Source'] = ['CuKa','?']
                 choice = ['synchrotron','TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
-                lamPick = wx.ComboBox(G2frame.dataDisplay,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
+                lamPick = wx.ComboBox(G2frame.dataWindow,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
                 lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
                 waveSizer.Add(lamPick,0,WACV)
@@ -1919 +1908 @@
         elif insVal['Type'][0] in ['L','R',]:
             if 'C' in insVal['Type']:        
-                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
+                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
                     0,WACV)
-                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
+                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
                 instSizer.Add(waveVal,0,WACV)
                 labelLst.append(u'Lam (\xc5)')
@@ -1927 +1916 @@
                 dspLst.append([10,6])
                 refFlgElem.append(None)
-                instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
+                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
                 labelLst.append('Azimuth angle')
                 elemKeysLst.append(['Azimuth',1])
@@ -1937 +1926 @@
         mainSizer.Add(instSizer,0)
         mainSizer.Layout()    
-        G2frame.dataDisplay.SetSizer(mainSizer)
-        G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
-        G2frame.dataFrame.SendSizeEvent()  # this causes a frame repaint, even if the size does not change!
+        G2frame.dataWindow.SetSizer(mainSizer)
+        mainSizer.Fit(G2frame.dataWindow)
+        G2frame.SetDataSize()    
         # end of MakeParameterWindow
                 
@@ -1996 +1985 @@
     #end of patch
     if 'P' in insVal['Type']:                   #powder data menu commands
-        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.InstMenu)
-        if not G2frame.dataFrame.GetStatusBar():
-            Status = G2frame.dataFrame.CreateStatusBar()            
-            Status.SetStatusText('NB: Azimuth is used for polarization only')
+        G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.InstMenu)
+        G2frame.dataWindow.ClearData()
+        G2frame.GetStatusBar().SetStatusText('NB: Azimuth is used for polarization only')
         G2frame.Bind(wx.EVT_MENU,OnCalibrate,id=G2gd.wxID_INSTCALIB)
         G2frame.Bind(wx.EVT_MENU,OnLoad,id=G2gd.wxID_INSTLOAD)
@@ -2010 +1998 @@
         G2frame.Bind(wx.EVT_MENU,OnCopy1Val,id=G2gd.wxID_INST1VAL)
     elif 'L' in insVal['Type'] or 'R' in insVal['Type']:                   #SASD data menu commands
-        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SASDInstMenu)
-        if not G2frame.dataFrame.GetStatusBar():
-            Status = G2frame.dataFrame.CreateStatusBar()
+        G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.SASDInstMenu)
         G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
     MakeParameterWindow()
@@ -2381 +2367 @@
             G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
-    if G2frame.dataDisplay:
-        G2frame.dataFrame.Clear()
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SampleMenu)
-    G2frame.dataFrame.SetLabel('Sample Parameters')
+    G2frame.dataWindow.ClearData()
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.SampleMenu)
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Sample Parameters')
     G2frame.Bind(wx.EVT_MENU, OnSetScale, id=G2gd.wxID_SETSCALE)
     G2frame.Bind(wx.EVT_MENU, OnSampleCopy, id=G2gd.wxID_SAMPLECOPY)
@@ -2396 +2381 @@
     if histName[:4] in ['SASD','REFD','PWDR']:
         G2frame.dataFrame.SetScale.Enable(True)
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()    
-    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     Controls = G2frame.PatternTree.GetItemPyData(
         G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
@@ -2444 +2426 @@
     topSizer = wx.BoxSizer(wx.HORIZONTAL)
     topSizer.Add((-1,-1),1,wx.EXPAND,1)
-    topSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Sample and Experimental Parameters'))
+    topSizer.Add(wx.StaticText(G2frame.dataWindow,label='Sample and Experimental Parameters'))
     topSizer.Add((-1,-1),1,wx.EXPAND,1)
     mainSizer.Add(topSizer,0,wx.EXPAND,1)
     nameSizer = wx.BoxSizer(wx.HORIZONTAL)
-    nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Instrument Name'),
+    nameSizer.Add(wx.StaticText(G2frame.dataWindow,wx.ID_ANY,' Instrument Name'),
                 0,WACV)
     nameSizer.Add((-1,-1),1,wx.EXPAND,1)
-    instNameVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,data['InstrName'],
+    instNameVal = wx.TextCtrl(G2frame.dataWindow,wx.ID_ANY,data['InstrName'],
                               size=(200,-1),style=wx.TE_PROCESS_ENTER)        
     nameSizer.Add(instNameVal)
@@ -2464 +2446 @@
     if 'PWDR' in histName:
         nameSizer = wx.BoxSizer(wx.HORIZONTAL)
-        nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Diffractometer type: '),
+        nameSizer.Add(wx.StaticText(G2frame.dataWindow,wx.ID_ANY,' Diffractometer type: '),
                     0,WACV)
         if 'T' in Inst['Type'][0]:
@@ -2470 +2452 @@
         else:
             choices = ['Debye-Scherrer','Bragg-Brentano',]
-        histoType = G2G.G2ChoiceButton(G2frame.dataDisplay,choices,
+        histoType = G2G.G2ChoiceButton(G2frame.dataWindow,choices,
                     strLoc=data,strKey='Type',
                     onChoice=OnHistoChange)
@@ -2482 +2464 @@
         dspLst.append(nDig)
         if 'list' in str(type(data[key])):
-            parmRef = G2G.G2CheckBox(G2frame.dataDisplay,' '+lbl,data[key],1)
+            parmRef = G2G.G2CheckBox(G2frame.dataWindow,' '+lbl,data[key],1)
             parmSizer.Add(parmRef,0,WACV|wx.EXPAND)
-            parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[key],0,
+            parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[key],0,
                 nDig=nDig,typeHint=float,OnLeave=AfterChange)
             elemKeysLst.append([key,0])
             refFlgElem.append([key,1])
         else:
-            parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' '+lbl),
+            parmSizer.Add(wx.StaticText(G2frame.dataWindow,label=' '+lbl),
                 0,WACV|wx.EXPAND)
-            parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,
+            parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,key,
                 typeHint=float,OnLeave=AfterChange)
             elemKeysLst.append([key])
@@ -2499 +2481 @@
         
     for key in ('FreePrm1','FreePrm2','FreePrm3'):
-        parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Controls,key,typeHint=str,
+        parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Controls,key,typeHint=str,
                                         notBlank=False)
         parmSizer.Add(parmVal,1,wx.EXPAND)
-        parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,typeHint=float)
+        parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,key,typeHint=float)
         parmSizer.Add(parmVal,1,wx.EXPAND)
         labelLst.append(Controls[key])
@@ -2519 +2501 @@
             G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
         for id,item in enumerate(data['Materials']):
-            subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Material: '),0,WACV)
-            matsel = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=Substances['Substances'].keys(),
+            subSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Material: '),0,WACV)
+            matsel = wx.ComboBox(G2frame.dataWindow,value=item['Name'],choices=Substances['Substances'].keys(),
                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
             Info[matsel.GetId()] = id
             matsel.Bind(wx.EVT_COMBOBOX,OnMaterial)        
             subSizer.Add(matsel,0,WACV)
-            subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Volume fraction: '),0,WACV)
-            volfrac = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,'VolFrac',
+            subSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Volume fraction: '),0,WACV)
+            volfrac = G2G.ValidatedTxtCtrl(G2frame.dataWindow,item,'VolFrac',
                 min=0.,max=1.,nDig=(10,3),typeHint=float,OnLeave=OnVolFrac)
             subSizer.Add(volfrac,0,WACV)
@@ -2536 +2518 @@
         mainSizer.Add(subSizer,0)
         conSizer = wx.BoxSizer(wx.HORIZONTAL)
-        conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Contrast: %10.2f '%(data['Contrast'][0])),0,WACV)
-        conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Anom. Contrast: %10.2f '%(data['Contrast'][1])),0,WACV)
+        conSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Contrast: %10.2f '%(data['Contrast'][0])),0,WACV)
+        conSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Anom. Contrast: %10.2f '%(data['Contrast'][1])),0,WACV)
         mut =  mu*data['Thick']
-        conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Transmission (calc): %10.3f  '%(np.exp(-mut))),0,WACV)
+        conSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Transmission (calc): %10.3f  '%(np.exp(-mut))),0,WACV)
         mainSizer.Add(conSizer,0)
     
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    Size = mainSizer.Fit(G2frame.dataFrame)
-    G2frame.dataFrame.setSizePosLeft(Size)
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataWindow)
+    G2frame.SetDataSize()    
                 
 ################################################################################
@@ -2571 +2553 @@
             G2frame.IndexPeaksTable.SetData(peaks)
             G2frame.PatternTree.SetItemPyData(IndexId,[peaks,data[1]])
-            G2frame.dataDisplay.ForceRefresh()
+#            G2frame.dataWindow.ForceRefresh()
             if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
                 G2plt.PlotPowderLines(G2frame)
@@ -2594 +2576 @@
         
     def KeyEditPickGrid(event):
-        colList = G2frame.dataDisplay.GetSelectedCols()
+        colList = G2frame.indxPeaks.GetSelectedCols()
         data = G2frame.PatternTree.GetItemPyData(IndexId)
         if event.GetKeyCode() == wx.WXK_RETURN:
@@ -2603 +2585 @@
             event.Skip(True)
         elif colList:
-            G2frame.dataDisplay.ClearSelection()
+            G2frame.dataWindow.ClearSelection()
             key = event.GetKeyCode()
             for col in colList:
@@ -2615 +2597 @@
                         
             
-    if G2frame.dataDisplay:
-        G2frame.dataFrame.Clear()
-    if not G2frame.dataFrame.GetStatusBar():
-        G2frame.dataFrame.CreateStatusBar()
+    G2frame.dataWindow.ClearData()
     if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
-        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndPeaksMenu)
+        G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.IndPeaksMenu)
         G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
-    G2frame.dataFrame.IndexPeaks.Enable(False)
+    G2frame.dataWindow.IndexPeaks.Enable(False)
     G2frame.IndexPeaksTable = []
     if len(data[0]):
-        G2frame.dataFrame.IndexPeaks.Enable(True)
+        G2frame.dataWindow.IndexPeaks.Enable(True)
         Unit = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
         if Unit:
@@ -2670 +2649 @@
     G2frame.PatternTree.SetItemPyData(IndexId,data)
     G2frame.IndexPeaksTable = G2G.Table(data[0],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-    G2frame.dataFrame.SetLabel('Index Peak List')
-    G2frame.dataFrame.currentGrids = []
-    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)                
-    G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Index Peak List')
+    G2frame.dataWindow.ClearData()
+    G2frame.dataWindow.currentGrids = []
+    G2frame.indxPeaks = G2G.GSGrid(parent=G2frame.dataWindow)                
+    G2frame.indxPeaks.SetTable(G2frame.IndexPeaksTable, True)
     XY = []
     Sigs = []
-    for r in range(G2frame.dataDisplay.GetNumberRows()):
-        for c in range(G2frame.dataDisplay.GetNumberCols()):
+    for r in range(G2frame.indxPeaks.GetNumberRows()):
+        for c in range(G2frame.indxPeaks.GetNumberCols()):
             if c == 2:
-                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
+                G2frame.indxPeaks.SetReadOnly(r,c,isReadOnly=False)
             else:
-                G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
+                G2frame.indxPeaks.SetReadOnly(r,c,isReadOnly=True)
         if data[0][r][2] and data[0][r][3]:
             XY.append([data[0][r][-1],data[0][r][0]])
@@ -2689 +2669 @@
                 sig = 0.
             Sigs.append(sig)
-    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])
+    G2frame.indxPeaks.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
+    G2frame.indxPeaks.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
+    G2frame.indxPeaks.SetMargins(0,0)
+    G2frame.indxPeaks.AutoSizeColumns(False)
     if len(XY):
         XY = np.array(XY)
         G2plt.PlotCalib(G2frame,Inst,XY,Sigs,newPlot=True)
-    G2frame.dataFrame.SendSizeEvent()
+    mainSizer = wx.BoxSizer(wx.VERTICAL)
+    mainSizer.Add(G2frame.indxPeaks)
+    mainSizer.Layout()    
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataWindow)
+    G2frame.SetDataSize()    
       
 ################################################################################
@@ -3160 +3144 @@
                 G2frame.PatternTree.SetItemPyData(sub, \
                     G2obj.SetNewPhase(Name=PhaseName,SGData=SGData,cell=cell[1:],Super=ssopt))
-                Status.SetStatusText('Change space group from '+str(controls[13])+' if needed')
+                G2frame.GetStatusBar().SetStatusText('Change space group from '+str(controls[13])+' if needed')
         finally:
             dlg.Destroy()
             
-    if G2frame.dataDisplay:
-        G2frame.dataFrame.DestroyChildren()
-    G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
-    G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndexMenu)
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()
+    G2frame.dataWindow.ClearData()
+    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Unit cells')
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.IndexMenu)
     G2frame.Bind(wx.EVT_MENU, OnIndexPeaks, id=G2gd.wxID_INDEXPEAKS)
     G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
@@ -3195 +3176 @@
         [True,True,True,False,True,True,True],[0,1,2,0,3,4,5])]]
     
-    G2frame.dataFrame.SetLabel('Unit Cells List')
     G2frame.dataFrame.IndexPeaks.Enable(False)
     peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
@@ -3211 +3191 @@
         G2frame.dataFrame.ExportCells.Enable(True)
     mainSizer = wx.BoxSizer(wx.VERTICAL)
-    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Indexing controls: '),0,WACV)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Indexing controls: '),0,WACV)
     mainSizer.Add((5,5),0)
     littleSizer = wx.FlexGridSizer(0,5,5,5)
-    littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max Nc/Nobs '),0,WACV)
-    NcNo = wx.SpinCtrl(G2frame.dataDisplay)
+    littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Max Nc/Nobs '),0,WACV)
+    NcNo = wx.SpinCtrl(G2frame.dataWindow)
     NcNo.SetRange(2,8)
     NcNo.SetValue(controls[2])
     NcNo.Bind(wx.EVT_SPINCTRL,OnNcNo)
     littleSizer.Add(NcNo,0,WACV)
-    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Start Volume '),0,WACV)
-    startVol = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,controls,3,typeHint=int,min=25)
+    littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Start Volume '),0,WACV)
+    startVol = G2G.ValidatedTxtCtrl(G2frame.dataWindow,controls,3,typeHint=int,min=25)
     littleSizer.Add(startVol,0,WACV)
-    x20 = wx.CheckBox(G2frame.dataDisplay,label='Use M20/(X20+1)?')
+    x20 = wx.CheckBox(G2frame.dataWindow,label='Use M20/(X20+1)?')
     x20.SetValue(G2frame.ifX20)
     x20.Bind(wx.EVT_CHECKBOX,OnIfX20)
@@ -3229 +3209 @@
     mainSizer.Add(littleSizer,0)
     mainSizer.Add((5,5),0)
-    mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Select Bravais Lattices for indexing: '),
+    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Select Bravais Lattices for indexing: '),
         0,WACV)
     mainSizer.Add((5,5),0)
@@ -3236 +3216 @@
     bravs = zip(bravais,bravaisNames)
     for brav,bravName in bravs:
-        bravCk = wx.CheckBox(G2frame.dataDisplay,label=bravName)
+        bravCk = wx.CheckBox(G2frame.dataWindow,label=bravName)
         bravList.append(bravCk.GetId())
         bravCk.SetValue(brav)
@@ -3244 +3224 @@
     mainSizer.Add((5,5),0)
     
-    mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Cell Test & Refinement: '),0,WACV)
+    mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Cell Test & Refinement: '),0,WACV)
     mainSizer.Add((5,5),0)
     littleSizer = wx.BoxSizer(wx.HORIZONTAL)
-    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Bravais lattice "),0,WACV)
-    bravSel = wx.Choice(G2frame.dataDisplay,choices=bravaisSymb)
+    littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=" Bravais lattice "),0,WACV)
+    bravSel = wx.Choice(G2frame.dataWindow,choices=bravaisSymb)
     bravSel.SetSelection(bravaisSymb.index(controls[5]))
     bravSel.Bind(wx.EVT_CHOICE,OnBravSel)
     littleSizer.Add(bravSel,0,WACV)
-    littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Space group "),0,WACV)
-    spcSel = wx.Choice(G2frame.dataDisplay,choices=SPGlist[controls[5]])
+    littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=" Space group "),0,WACV)
+    spcSel = wx.Choice(G2frame.dataWindow,choices=SPGlist[controls[5]])
     spcSel.SetSelection(SPGlist[controls[5]].index(controls[13]))
     spcSel.Bind(wx.EVT_CHOICE,OnSpcSel)
@@ -3260 +3240 @@
         controls[0] = False
     else:
-        littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Zero offset"),0,WACV)
-        zero = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,controls,1,nDig=(10,4),typeHint=float,min=-5.,max=5.)
+        littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=" Zero offset"),0,WACV)
+        zero = G2G.ValidatedTxtCtrl(G2frame.dataWindow,controls,1,nDig=(10,4),typeHint=float,min=-5.,max=5.)
         littleSizer.Add(zero,0,WACV)
-        zeroVar = wx.CheckBox(G2frame.dataDisplay,label="Refine?")
+        zeroVar = wx.CheckBox(G2frame.dataWindow,label="Refine?")
         zeroVar.SetValue(controls[0])
         zeroVar.Bind(wx.EVT_CHECKBOX,OnZeroVar)
         littleSizer.Add(zeroVar,0,WACV)
-    SSopt = wx.CheckBox(G2frame.dataDisplay,label="Super lattice?")
+    SSopt = wx.CheckBox(G2frame.dataWindow,label="Super lattice?")
     SSopt.SetValue(ssopt.get('Use',False))
     SSopt.Bind(wx.EVT_CHECKBOX,OnSSopt)
     littleSizer.Add(SSopt,0,WACV)
-    hklShow = wx.Button(G2frame.dataDisplay,label="Show hkl positions")
+    hklShow = wx.Button(G2frame.dataWindow,label="Show hkl positions")
     hklShow.Bind(wx.EVT_BUTTON,OnHklShow)
     littleSizer.Add(hklShow,0,WACV)
@@ -3285 +3265 @@
     littleSizer = wx.FlexGridSizer(0,useGUI[1],5,5)
     for txt,fmt,ifEdit,Id in useGUI[2]:
-        littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=txt),0,WACV)
+        littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=txt),0,WACV)
         if ifEdit:          #a,b,c,etc.
-#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
-            cellVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
+#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
+            cellVal = wx.TextCtrl(G2frame.dataWindow,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
             cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)        
             cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
             valSizer = wx.BoxSizer(wx.HORIZONTAL)
             valSizer.Add(cellVal,0,WACV)
-            cellSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,20))
+            cellSpin = wx.SpinButton(G2frame.dataWindow,style=wx.SP_VERTICAL,size=wx.Size(20,20))
             cellSpin.SetValue(0)
             cellSpin.SetRange(-1,1)
@@ -3303 +3283 @@
             valDict[cellSpin.GetId()] = cellVal
         else:               #volume
-            volVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
+            volVal = wx.TextCtrl(G2frame.dataWindow,value=(fmt%(controls[12])),style=wx.TE_READONLY)
             volVal.SetBackgroundColour(VERY_LIGHT_GREY)
             littleSizer.Add(volVal,0,WACV)
@@ -3314 +3294 @@
             ssopt['ssSymb'] = ssChoice[0]
         ssSizer = wx.BoxSizer(wx.HORIZONTAL)
-        ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Supersymmetry space group: '+SpSg+' '),0,WACV)
-        selMG = wx.ComboBox(G2frame.dataDisplay,value=ssopt['ssSymb'],
+        ssSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Supersymmetry space group: '+SpSg+' '),0,WACV)
+        selMG = wx.ComboBox(G2frame.dataWindow,value=ssopt['ssSymb'],
                 choices=ssChoice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
         selMG.Bind(wx.EVT_COMBOBOX, OnSelMG)
         ssSizer.Add(selMG,0,WACV)
-        ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Mod. vector: '),0,WACV)
+        ssSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Mod. vector: '),0,WACV)
         modS = G2spc.splitSSsym(ssopt['ssSymb'])[0]
         ssopt['ModVec'],ifShow = G2spc.SSGModCheck(ssopt['ModVec'],modS)
@@ -3326 +3306 @@
             if show:
                 valSizer = wx.BoxSizer(wx.HORIZONTAL)
-                modVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,ssopt['ModVec'],i,
+                modVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,ssopt['ModVec'],i,
                     min=-.98,max=.98,nDig=(10,4),typeHint=float,OnLeave=OnModVal)
                 valSizer.Add(modVal,0,WACV)
-                modSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,20))
+                modSpin = wx.SpinButton(G2frame.dataWindow,style=wx.SP_VERTICAL,size=wx.Size(20,20))
                 modSpin.SetValue(0)
                 modSpin.SetRange(-1,1)
@@ -3338 +3318 @@
                 Indx[modSpin.GetId()] = [i,modVal]
             else:
-                modVal = wx.TextCtrl(G2frame.dataDisplay,value=('%.3f'%(val)),
+                modVal = wx.TextCtrl(G2frame.dataWindow,value=('%.3f'%(val)),
                     size=wx.Size(50,20),style=wx.TE_READONLY)
                 modVal.SetBackgroundColour(VERY_LIGHT_GREY)
                 ssSizer.Add(modVal,0,WACV)
-        ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max. M: '),0,WACV)
-        maxMH = wx.ComboBox(G2frame.dataDisplay,value=str(ssopt['maxH']),
+        ssSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Max. M: '),0,WACV)
+        maxMH = wx.ComboBox(G2frame.dataWindow,value=str(ssopt['maxH']),
             choices=indChoice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
         maxMH.Bind(wx.EVT_COMBOBOX, OnMaxMH)
         ssSizer.Add(maxMH,0,WACV)
-        findMV = wx.Button(G2frame.dataDisplay,label="Find mod. vec.?")
+        findMV = wx.Button(G2frame.dataWindow,label="Find mod. vec.?")
         findMV.Bind(wx.EVT_BUTTON,OnFindMV)
         ssSizer.Add(findMV,0,WACV)
@@ -3354 +3334 @@
     G2frame.dataFrame.currentGrids = []
     if cells:
-        mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='\n Indexing Result:'),0,WACV)
+        mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label='\n Indexing Result:'),0,WACV)
         rowLabels = []
         colLabels = ['M20','X20','use','Bravais','a','b','c','alpha','beta','gamma','Volume','Keep']
@@ -3372 +3352 @@
             table.append(row)
         UnitCellsTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-        gridDisplay = G2G.GSGrid(G2frame.dataDisplay)
+        gridDisplay = G2G.GSGrid(G2frame.dataWindow)
         gridDisplay.SetTable(UnitCellsTable, True)
         G2frame.dataFrame.CopyCell.Enable(True)
@@ -3388 +3368 @@
         mainSizer.Add(gridDisplay,0,WACV)
     mainSizer.Layout()    
-    G2frame.dataDisplay.SetSizer(mainSizer)
-    G2frame.dataDisplay.SetAutoLayout(1)
-    G2frame.dataDisplay.SetupScrolling()
-    Size = mainSizer.Fit(G2frame.dataFrame)
-    Size[0] += 25
-    Size[1] = min(600,Size[1])
-    G2frame.dataFrame.setSizePosLeft(Size)    
+    G2frame.dataWindow.SetSizer(mainSizer)
+    mainSizer.Fit(G2frame.dataFrame)
+    G2frame.SetDataSize()
     
 ################################################################################
@@ -3555 +3531 @@
             return          #deleted phase?
         G2frame.RefList = phaseName
-        G2frame.dataFrame.SetLabel('Reflection List for '+phaseName)
+        G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Reflection List for '+phaseName)
         if HKLF:
-            Status.SetStatusText('abs(DF)/sig > 10 red; > 3 yellow; twin < 0 (user rejected) red; twin=0 (sp. gp. absent) red')
+            G2frame.GetStatusBar().SetStatusText('abs(DF)/sig > 10 red; > 3 yellow; twin < 0 (user rejected) red; twin=0 (sp. gp. absent) red')
         else:
-            Status.SetStatusText('Prfo < 0. in red; if excluded Fosq in red & mul < 0')
+            G2frame.GetStatusBar().SetStatusText('Prfo < 0. in red; if excluded Fosq in red & mul < 0')
         itof = 0
         if HKLF:
@@ -3581 +3557 @@
         G2frame.HKL = np.vstack((refList.T)).T    #build for plots
         # raise the tab (needed for 1st use and from OnSelectPhase)
-        for PageNum in range(G2frame.dataDisplay.GetPageCount()):
-            if phaseName == G2frame.dataDisplay.GetPageText(PageNum):
-                G2frame.dataDisplay.SetSelection(PageNum)
+        for PageNum in range(G2frame.refBook.GetPageCount()):
+            if phaseName == G2frame.refBook.GetPageText(PageNum):
+                G2frame.refBook.SetSelection(PageNum)
                 break
         else:
@@ -3595 +3571 @@
         '''
         page = event.GetSelection()
-        phaseName = G2frame.dataDisplay.GetPageText(page)
+        phaseName = G2frame.refBook.GetPageText(page)
         ShowReflTable(phaseName)
 
@@ -3622 +3598 @@
         phaseName = G2frame.RefList
         phases = data.keys()
-    if G2frame.dataDisplay:
-        G2frame.dataFrame.Clear()
+    G2frame.dataFrame.ClearData()
     Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
-    if not G2frame.dataFrame.GetStatusBar():
-        Status = G2frame.dataFrame.CreateStatusBar()    
+    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ReflMenu)
     if HKLF:
-        G2gd.SetDataMenuBar(G2frame)
-        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
         G2frame.Bind(wx.EVT_MENU, OnPlotHKL, id=G2gd.wxID_PWDHKLPLOT)
         G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=G2gd.wxID_PWD3DHKLPLOT)
-        G2frame.dataFrame.SelectPhase.Enable(False)
+        G2frame.dataWindow.SelectPhase.Enable(False)
     else:
-        G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
         G2frame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
         G2frame.Bind(wx.EVT_MENU, OnPlotHKL, id=G2gd.wxID_PWDHKLPLOT)
         G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=G2gd.wxID_PWD3DHKLPLOT)
-        G2frame.dataFrame.SelectPhase.Enable(False)
+        G2frame.dataWindow.SelectPhase.Enable(False)
             
-    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
+    G2frame.dataWindow.ClearData()
+    G2frame.refBook = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize())
     G2frame.refTable = {}
-    G2frame.dataFrame.currentGrids = []
+    G2frame.dataWindow.currentGrids = []
     for tabnum,phase in enumerate(phases):
         if isinstance(data,list):           #single crystal HKLF
-            G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.dataDisplay)
-            G2frame.dataDisplay.AddPage(G2frame.refTable[phase],phase)
+            G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.refBook)
+            G2frame.refBook.AddPage(G2frame.refTable[phase],phase)
         elif len(data[phase]):              #else dict for PWDR
-            G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.dataDisplay)
-            G2frame.dataDisplay.AddPage(G2frame.refTable[phase],phase)
+            G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.refBook)
+            G2frame.refBook.AddPage(G2frame.refTable[phase],phase)
         else:       #cleanup deleted phase reflection lists
             del data[phase]
@@ -3660 +3632 @@
     if phaseName:
         ShowReflTable(phaseName)
-    G2frame.dataFrame.setSizePosLeft([550,350])
-    G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
+    G2frame.refBook.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     
 ################################################################################
@@ -3938 +3909 @@
         Indx = {}
         substSizer = wx.BoxSizer(wx.VERTICAL)
-        substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Substance list: wavelength: %.5fA'%(wave)),
+        substSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Substance list: wavelength: %.5fA'%(wave)),
             0,WACV)
         for name in data['Substances']:
-            G2G.HorizontalLine(substSizer,G2frame.dataDisplay)    
-            substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Data for '+name+':'),
+            G2G.HorizontalLine(substSizer,G2frame.dataWindow)    
+            substSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Data for '+name+':'),
                 0,WACV)
             if name == 'vacuum':
-                substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='        Not applicable'),
+                substSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label='        Not applicable'),
                     0,WACV)
             elif name == 'unit scatter':
-                substSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Scattering density,f: %.3f *10%scm%s'%(data['Substances'][name]['Scatt density'],Pwr10,Pwrm2)),0,WACV)
+                substSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Scattering density,f: %.3f *10%scm%s'%(data['Substances'][name]['Scatt density'],Pwr10,Pwrm2)),0,WACV)
             else:    
                 elSizer = wx.FlexGridSizer(0,8,5,5)
@@ -3954 +3925 @@
                 Elems = Substance['Elements']
                 for El in Elems:    #do elements as pull downs for isotopes for neutrons
-                    elSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+El+': '),
+                    elSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' '+El+': '),
                         0,WACV)
-                    num = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Substances'][name]['Elements'][El],'Num',
+                    num = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Substances'][name]['Elements'][El],'Num',
                         nDig=(10,2,'f'),typeHint=float,OnLeave=OnNum)
                     Indx[num.GetId()] = [name,El,'Num']
                     elSizer.Add(num,0,WACV)
                     if 'N' in Inst['Type'][0]:
-                        elSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Isotope: '),0,WACV)
+                        elSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Isotope: '),0,WACV)
                         isotopes = Elems[El]['Isotopes'].keys()
-                        isotope = wx.ComboBox(G2frame.dataDisplay,choices=isotopes,value=Elems[El].get('Isotope','Nat. Abund.'),
+                        isotope = wx.ComboBox(G2frame.dataWindow,choices=isotopes,value=Elems[El].get('Isotope','Nat. Abund.'),
                             style=wx.CB_READONLY|wx.CB_DROPDOWN)
                         Indx[isotope.GetId()] = [El,name]
@@ -3970 +3941 @@
                 substSizer.Add(elSizer,0)
                 vdsSizer = wx.FlexGridSizer(0,4,5,5)
-                vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Volume: '),
+                vdsSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Volume: '),
                     0,WACV)
-                vol = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Substances'][name],'Volume',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
+                vol = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Substances'][name],'Volume',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
                 Indx[vol.GetId()] = [name,'Volume']
                 vdsSizer.Add(vol,0,WACV)                
-                vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Density: '),
+                vdsSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Density: '),
                     0,WACV)
-                den = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Substances'][name],'Density',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
+                den = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Substances'][name],'Density',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
                 Indx[den.GetId()] = [name,'Density']
                 vdsSizer.Add(den,0,WACV)
                 substSizer.Add(vdsSizer,0)
                 denSizer = wx.FlexGridSizer(0,2,0,0)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Scattering density,f'),0,WACV)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3f *10%scm%s'%(Substance['Scatt density'],Pwr10,Pwrm2)),0,WACV)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Real density,f+f'"),0,WACV)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3f *10%scm%s'%(Substance['XAnom density'],Pwr10,Pwrm2)),0,WACV)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Imaginary density,f"'),0,WACV)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3g *10%scm%s'%(Substance['XImag density'],Pwr10,Pwrm2)),0,WACV)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Absorption'),0,WACV)
-                denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3g cm%s'%(Substance['XAbsorption'],Pwrm1)),0,WACV)