Changeset 2888


Ignore:
Timestamp:
Jul 1, 2017 6:22:10 AM (8 years ago)
Author:
vondreele
Message:
 
Location:
branch/2frame
Files:
11 edited
1 copied

Legend:

Unmodified
Added
Removed
  • TabularUnified branch/2frame/GSASII.py

    r2871 r2888  
    9090#                GSASIIpath.IPyBreak()
    9191
    92 __version__ = '0.2.0'
     92__version__ = '0.3.0'
    9393
    9494# PATCH: for Mavericks (OS X 10.9.x), wx produces an annoying warning about LucidaGrandeUI.
     
    121121            'HStrain':[NDij*[0.0,],NDij*[False,]],                         
    122122            'Extinction':[0.0,False],'Babinet':{'BabA':[0.0,False],'BabU':[0.0,False]}}
     123
     124class GSASIIsplit(wx.SplitterWindow):
     125    def __init__(self,parent,ID):
     126        wx.SplitterWindow.__init__(self, parent, ID,style = wx.SP_BORDER|wx.SP_LIVE_UPDATE)
     127        self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED, self.OnSashChanged)
     128        self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGING, self.OnSashChanging)
     129
     130    def OnSashChanged(self, evt):
     131        evt.Skip()
     132#        print "sash changed to %s\n" % str(evt.GetSashPosition())
     133
     134    def OnSashChanging(self, evt):
     135        evt.Skip()
     136#        print "sash changing to %s\n" % str(evt.GetSashPosition())
    123137
    124138class GSASII(wx.Frame):
     
    14891503            if UseList: haveData = True
    14901504        if haveData:
    1491             self.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,True)
     1505            self.dataWindow.DataMenu.Enable(G2gd.wxID_DATADELETE,True)
    14921506            for item in self.Refine: item.Enable(True)
    14931507        else:
    1494             self.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,False)
     1508            self.dataWindow.DataMenu.Enable(G2gd.wxID_DATADELETE,False)
    14951509            for item in self.Refine: item.Enable(False)
    14961510
     
    24462460        item.Enable(False)
    24472461        self.Bind(wx.EVT_MENU, self.OnExportPDF, id=item.GetId())
    2448 
     2462           
    24492463    def FillMainMenu(self,menubar,addhelp=True):
    24502464        '''Define contents of the main GSAS-II menu for the (main) data tree window.
     
    25212535    def _init_ctrls(self, parent):
    25222536        wx.Frame.__init__(self, name='GSASII', parent=parent,
    2523             size=wx.Size(400, 250),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
     2537            size=wx.Size(700, 450),style=wx.DEFAULT_FRAME_STYLE, title='GSAS-II data tree')
    25242538        clientSize = wx.ClientDisplayRect()
    25252539        Size = self.GetSize()
     
    25462560        self.Bind(wx.EVT_SIZE, self.OnSize)
    25472561        self.Status = self.CreateStatusBar()
    2548         self.mainPanel = wx.Panel(self,-1)
     2562#TODO - split window tree on left, data on right
     2563        self.mainPanel = GSASIIsplit(self,-1)
     2564        self.treePanel = wx.Panel(self.mainPanel, wx.ID_ANY,
     2565                style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER)
     2566        self.treePanel.SetAutoLayout(True)
     2567        self.dataPanel = wx.Panel(self.mainPanel, wx.ID_ANY,
     2568                style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER)
     2569        self.dataPanel.SetAutoLayout(True)
     2570        self.dataWindow = G2gd.DataWindow(self.dataPanel)
     2571        self.dataWindow.SetupScrolling()
     2572        self.mainPanel.SetMinimumPaneSize(100)
     2573        self.mainPanel.SplitVertically(self.treePanel, self.dataPanel, 200)
     2574        self.dataFrame = self.dataWindow        #kluge!!
    25492575       
    25502576        wxID_PATTERNTREE = wx.NewId()
    2551         #self.PatternTree = wx.TreeCtrl(id=wxID_PATTERNTREE, # replaced for logging
     2577        treeSizer = wx.BoxSizer()
    25522578        self.PatternTree = G2G.G2TreeCtrl(id=wxID_PATTERNTREE,
    2553             parent=self.mainPanel, pos=wx.Point(0, 0),style=wx.TR_DEFAULT_STYLE )
     2579            parent=self.treePanel, size=self.treePanel.GetSize(),style=wx.TR_DEFAULT_STYLE )
     2580        treeSizer.Add(self.PatternTree,1,wx.EXPAND)
     2581        self.treePanel.SetSizer(treeSizer)
    25542582        self.PatternTree.Bind(wx.EVT_TREE_SEL_CHANGED,self.OnDataTreeSelChanged)
    25552583        self.PatternTree.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK,self.OnDataTreeSelChanged)
     
    25662594        self.PatternTree.Bind(wx.EVT_TREE_END_DRAG,
    25672595            self.OnPatternTreeEndDrag, id=wxID_PATTERNTREE)       
    2568         #self.root = self.PatternTree.AddRoot('Loaded Data: ')
    2569         self.root = self.PatternTree.root
     2596        self.root = self.PatternTree.root       
     2597       
    25702598        plotFrame = wx.Frame(None,-1,'GSASII Plots',size=wx.Size(700,600), \
    25712599            style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX)
    25722600        self.G2plotNB = G2plt.G2PlotNoteBook(plotFrame,G2frame=self)
    25732601        plotFrame.Show()
    2574        
    2575         self.dataDisplay = None
     2602        self.SetDataSize()
    25762603       
    25772604    def __init__(self, parent):
     
    26092636        self.Lines = []
    26102637        self.itemPicked = None
    2611         self.dataFrame = None
    26122638        self.Interpolate = 'nearest'
    26132639        self.ContourColor = GSASIIpath.GetConfigValue('Contour_color','Paired')
     
    26872713        self.mainPanel.SetSize(wx.Size(w,h))
    26882714        self.PatternTree.SetSize(wx.Size(w,h))
    2689                        
     2715       
     2716    def SetDataSize(self):
     2717        Size = self.GetSize()
     2718        self.SetSize(Size)
     2719        Size[1] += 1        #kluge to ensure scrollbar settings & window properly displayed
     2720        self.SetSize(Size)
     2721                               
    26902722    def OnDataTreeSelChanged(self, event):
    26912723        '''Called when a data tree item is selected'''
     
    34283460        if self.PatternTree.GetChildrenCount(self.root,False):
    34293461            if self.dataFrame:
    3430                 self.dataFrame.Clear()
     3462                self.dataFrame.ClearData()
    34313463            dlg = wx.MessageDialog(
    34323464                self,
     
    34473479
    34483480        if not filename:
    3449             if self.dataDisplay: self.dataDisplay.Destroy()
    34503481            if self.LastGPXdir:
    34513482                pth = self.LastGPXdir
     
    35153546        the project.
    35163547        '''
    3517         if self.dataFrame:
    3518             self.dataFrame.Clear()
    3519             self.dataFrame.SetLabel('GSAS-II data display')
    3520         dlg = wx.MessageDialog(self, 'Save current project?', ' ', wx.YES | wx.NO | wx.CANCEL)
     3548#        dlg = wx.MessageDialog(self, 'Save current project?', ' ', wx.YES | wx.NO | wx.CANCEL)
    35213549        try:
    35223550            result = dlg.ShowModal()
     
    36253653            self.G2plotNB.Destroy()
    36263654        if self.dataFrame:
    3627             self.dataFrame.Clear()
    36283655            self.dataFrame.Destroy()
    36293656        if self.undofile:
     
    36363663            self.G2plotNB.Destroy()
    36373664        if self.dataFrame:
    3638             self.dataFrame.Clear()
    36393665            self.dataFrame.Destroy()
    36403666        self.Close()
  • TabularUnified branch/2frame/GSASIIconstrGUI.py

    r2753 r2888  
    662662        #varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
    663663        legend = "Select variables to hold (Will not be varied, even if vary flag is set)"
    664         dlg = G2G.G2MultiChoiceDialog(
    665             G2frame.dataFrame,
     664        dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,
    666665            legend,title1,varListlbl,toggle=False,size=(625,400),monoFont=True)
    667666        dlg.CenterOnParent()
     
    10621061        notebook tab. Called in :func:`OnPageChanged`
    10631062        '''
    1064         if panel.GetSizer(): panel.GetSizer().Clear(True) # N.B. don't use panel.DestroyChildren()
     1063#        if panel.GetSizer(): panel.GetSizer().Clear(True) # N.B. don't use panel.DestroyChildren()
    10651064        # because it deletes scrollbars on Mac
    10661065        Siz = wx.BoxSizer(wx.VERTICAL)
    10671066        Siz.Add((5,5),0)
    1068         Siz.Add(MakeConstraintsSizer(typ,panel))
     1067        Siz.Add(MakeConstraintsSizer(typ,panel),1,wx.EXPAND)
    10691068        panel.SetSizer(Siz,True)
    10701069        Size = Siz.GetMinSize()
     
    10731072        panel.SetSize(Size)
    10741073        panel.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1075         Size[1] = min(500,Size[1])
    1076         G2frame.dataFrame.setSizePosLeft(Size)
     1074        panel.Show()
    10771075
    10781076    def OnPageChanged(event):
     
    10831081            page = event.GetSelection()
    10841082        else: # called directly, get current page
    1085             page = G2frame.dataDisplay.GetSelection()
    1086         G2frame.dataDisplay.ChangeSelection(page)
    1087         text = G2frame.dataDisplay.GetPageText(page)
     1083            page = G2frame.constr.GetSelection()
     1084        G2frame.constr.ChangeSelection(page)
     1085        text = G2frame.constr.GetPageText(page)
    10881086        G2frame.dataFrame.ConstraintEdit.Enable(G2gd.wxID_EQUIVALANCEATOMS,False)
    10891087#        G2frame.dataFrame.ConstraintEdit.Enable(G2gd.wxID_ADDRIDING,False)
     
    11141112                 G2gd.wxID_CONSHIST,
    11151113                 G2gd.wxID_CONSGLOBAL).index(event.GetId())
    1116             G2frame.dataDisplay.SetSelection(i)
     1114            G2frame.constr.SetSelection(i)
    11171115            wx.CallAfter(OnPageChanged,None)
    11181116        except ValueError:
     
    11201118
    11211119    def SetStatusLine(text):
    1122         Status.SetStatusText(text)                                     
    1123        
    1124     if G2frame.dataDisplay:
    1125         G2frame.dataDisplay.Destroy()
    1126     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ConstraintMenu)
    1127     G2frame.dataFrame.SetLabel('Constraints')
    1128     if not G2frame.dataFrame.GetStatusBar():
    1129         Status = G2frame.dataFrame.CreateStatusBar()
     1120        G2frame.GetStatusBar().SetStatusText(text)                                     
     1121       
     1122    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ConstraintMenu)
     1123    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Constraints')
    11301124    SetStatusLine('')
    11311125   
    1132     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ConstraintMenu)
    1133     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddConstraint, id=G2gd.wxID_CONSTRAINTADD)
    1134     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddFunction, id=G2gd.wxID_FUNCTADD)
    1135     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddEquivalence, id=G2gd.wxID_EQUIVADD)
    1136     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddHold, id=G2gd.wxID_HOLDADD)
    1137     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddAtomEquiv, id=G2gd.wxID_EQUIVALANCEATOMS)
     1126    G2frame.Bind(wx.EVT_MENU, OnAddConstraint, id=G2gd.wxID_CONSTRAINTADD)
     1127    G2frame.Bind(wx.EVT_MENU, OnAddFunction, id=G2gd.wxID_FUNCTADD)
     1128    G2frame.Bind(wx.EVT_MENU, OnAddEquivalence, id=G2gd.wxID_EQUIVADD)
     1129    G2frame.Bind(wx.EVT_MENU, OnAddHold, id=G2gd.wxID_HOLDADD)
     1130    G2frame.Bind(wx.EVT_MENU, OnAddAtomEquiv, id=G2gd.wxID_EQUIVALANCEATOMS)
    11381131#    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddRiding, id=G2gd.wxID_ADDRIDING)
    11391132    # tab commands
     
    11441137        G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=id)
    11451138
    1146     G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame)
     1139    G2frame.dataWindow.ClearData()
     1140    G2frame.constr = G2G.GSNoteBook(parent=G2frame.dataWindow)
    11471141    # note that order of pages is hard-coded in RaisePage
    1148     PhaseConstr = wx.ScrolledWindow(G2frame.dataDisplay)
    1149     G2frame.dataDisplay.AddPage(PhaseConstr,'Phase')
    1150     HAPConstr = wx.ScrolledWindow(G2frame.dataDisplay)
    1151     G2frame.dataDisplay.AddPage(HAPConstr,'Histogram/Phase')
    1152     HistConstr = wx.ScrolledWindow(G2frame.dataDisplay)
    1153     G2frame.dataDisplay.AddPage(HistConstr,'Histogram')
    1154     GlobalConstr = wx.ScrolledWindow(G2frame.dataDisplay)
    1155     G2frame.dataDisplay.AddPage(GlobalConstr,'Global')
     1142    PhaseConstr = wx.ScrolledWindow(G2frame.constr)
     1143    G2frame.constr.AddPage(PhaseConstr,'Phase')
     1144    HAPConstr = wx.ScrolledWindow(G2frame.constr)
     1145    G2frame.constr.AddPage(HAPConstr,'Histogram/Phase')
     1146    HistConstr = wx.ScrolledWindow(G2frame.constr)
     1147    G2frame.constr.AddPage(HistConstr,'Histogram')
     1148    GlobalConstr = wx.ScrolledWindow(G2frame.constr)
     1149    G2frame.constr.AddPage(GlobalConstr,'Global')
    11561150    wx.CallAfter(OnPageChanged,None)
    1157     G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     1151    G2frame.constr.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
    11581152    # validate all the constrants -- should not see any errors here normally
    11591153    allcons = []
     
    13211315            page = event.GetSelection()
    13221316        else:
    1323             page = G2frame.dataDisplay.GetSelection()
    1324         G2frame.dataDisplay.ChangeSelection(page)
    1325         text = G2frame.dataDisplay.GetPageText(page)
     1317            page = G2frame.rbBook.GetSelection()
     1318        G2frame.rbBook.ChangeSelection(page)
     1319        text = G2frame.rbBook.GetPageText(page)
    13261320        if text == 'Vector rigid bodies':
    1327             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.VectorBodyMenu)
     1321            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.VectorBodyMenu)
    13281322            G2frame.dataFrame.Bind(wx.EVT_MENU, AddVectorRB, id=G2gd.wxID_VECTORBODYADD)
    13291323            G2frame.Page = [page,'vrb']
    13301324            UpdateVectorRB()
    13311325        elif text == 'Residue rigid bodies':
    1332             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodyMenu)
     1326            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodyMenu)
    13331327            G2frame.dataFrame.Bind(wx.EVT_MENU, AddResidueRB, id=G2gd.wxID_RIGIDBODYADD)
    13341328            G2frame.dataFrame.Bind(wx.EVT_MENU, OnImportRigidBody, id=G2gd.wxID_RIGIDBODYIMPORT)
     
    15951589        AtInfo = data['Vector']['AtInfo']
    15961590        refChoice = {}
    1597         if 'DELETED' in str(Status):   #seems to be no other way to do this (wx bug)
     1591        if 'DELETED' in str(G2frame.GetStatusBar()):   #seems to be no other way to do this (wx bug)
    15981592            if GSASIIpath.GetConfigValue('debug'):
    15991593                print 'wx error: Rigid Body/Status not cleanly deleted after Refine'
     
    18041798        VectorRB.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    18051799        VectorRB.Scroll(0,Scroll)
    1806         Size[1] = min(Size[1],500)
    1807         G2frame.dataFrame.setSizePosLeft(Size)
    18081800       
    18091801    def UpdateResidueRB():
     
    20582050                refChoice[rbId][i].sort()     
    20592051           
    2060         #ResidueRB.DestroyChildren() # bad, deletes scrollbars on Mac!
    2061         if ResidueRB.GetSizer():
    2062 #            ResidueRB.DestroyChildren()
    2063             ResidueRB.GetSizer().Clear(True)
    2064            
    20652052        ResidueRBDisplay = wx.Panel(ResidueRB)
    20662053        ResidueRBSizer = wx.BoxSizer(wx.VERTICAL)
     
    20912078        ResidueRBDisplay.SetSize(Size)
    20922079        ResidueRB.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    2093         Size[1] = min(500,Size[1])
    2094         G2frame.dataFrame.setSizePosLeft(Size)
    20952080       
    20962081    def SetStatusLine(text):
    2097         Status.SetStatusText(text)                                     
    2098 
    2099     if G2frame.dataDisplay:
    2100         G2frame.dataDisplay.Destroy()
    2101     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodyMenu)
    2102     G2frame.dataFrame.SetLabel('Rigid bodies')
    2103     if not G2frame.dataFrame.GetStatusBar():
    2104         Status = G2frame.dataFrame.CreateStatusBar()
     2082        G2frame.GetStatusBar().SetStatusText(text)                                     
     2083
     2084    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodyMenu)
     2085    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Rigid bodies')
    21052086    SetStatusLine('')
    2106 
    2107     G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
    2108 
    2109     VectorRB = wx.ScrolledWindow(G2frame.dataDisplay)
    2110     G2frame.dataDisplay.AddPage(VectorRB,'Vector rigid bodies')
    2111     ResidueRB = wx.ScrolledWindow(G2frame.dataDisplay)
    2112     G2frame.dataDisplay.AddPage(ResidueRB,'Residue rigid bodies')
     2087    G2frame.dataWindow.ClearData()
     2088    G2frame.rbBook = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     2089
     2090    VectorRB = wx.ScrolledWindow(G2frame.rbBook)
     2091    G2frame.rbBook.AddPage(VectorRB,'Vector rigid bodies')
     2092    ResidueRB = wx.ScrolledWindow(G2frame.rbBook)
     2093    G2frame.rbBook.AddPage(ResidueRB,'Residue rigid bodies')
    21132094    UpdateVectorRB()
    2114     G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     2095    G2frame.rbBook.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
    21152096    wx.CallAfter(OnPageChanged,None)
  • TabularUnified branch/2frame/GSASIIctrls.py

    r2872 r2888  
    5757    def __init__(self,parent=None,*args,**kwargs):
    5858        super(self.__class__,self).__init__(parent=parent,*args,**kwargs)
    59         self.G2frame = parent.GetParent()
     59        self.G2frame = parent.GetParent().GetParent()
    6060        self.root = self.AddRoot('Loaded Data: ')
    6161        self.SelectionChanged = None
     
    7979        '''Log each press on a tree item here.
    8080        '''
    81         if not self.G2frame.dataFrame:
     81        if not self.G2frame.treePanel:
    8282            return
    83         self.G2frame.dataFrame.userReSize = False
    8483        if self.SelectionChanged:
    8584            textlist = self._getTreeItemsList(event.GetItem())
     
    9392            self.textlist = textlist
    9493            self.SelectionChanged(event)
    95         self.G2frame.dataFrame.userReSize = True
    9694
    9795    def Bind(self,eventtype,handler,*args,**kwargs):
     
    30393037       
    30403038    def PageChangeEvent(self,event):
    3041         G2frame = self.parent.G2frame
     3039#        G2frame = self.parent.G2frame
    30423040        page = event.GetSelection()
    3043         if self.PageChangeHandler:
    3044             if log.LogInfo['Logging']:
    3045                 log.MakeTabLog(
    3046                     G2frame.dataFrame.GetTitle(),
    3047                     G2frame.dataDisplay.GetPageText(page)
    3048                     )
    3049             self.PageChangeHandler(event)
     3041#        if self.PageChangeHandler:
     3042#            if log.LogInfo['Logging']:
     3043#                log.MakeTabLog(
     3044#                    G2frame.dataFrame.GetTitle(),
     3045#                    G2frame.dataDisplay.GetPageText(page)
     3046#                    )
     3047#            self.PageChangeHandler(event)
    30503048           
    3051     def Bind(self,eventtype,handler,*args,**kwargs):
    3052         '''Override the Bind() function so that page change events can be trapped
    3053         '''
    3054         if eventtype == wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED:
    3055             self.PageChangeHandler = handler
    3056             wx.aui.AuiNotebook.Bind(self,eventtype,self.PageChangeEvent)
    3057             return
    3058         wx.aui.AuiNotebook.Bind(self,eventtype,handler,*args,**kwargs)
     3049#    def Bind(self,eventtype,handler,*args,**kwargs):
     3050#        '''Override the Bind() function so that page change events can be trapped
     3051#        '''
     3052#        if eventtype == wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED:
     3053#            self.PageChangeHandler = handler
     3054#            wx.aui.AuiNotebook.Bind(self,eventtype,self.PageChangeEvent)
     3055#            return
     3056#        wx.aui.AuiNotebook.Bind(self,eventtype,handler,*args,**kwargs)
    30593057                                                     
    30603058    def Clear(self):       
  • TabularUnified branch/2frame/GSASIIddataGUI.py

    r2873 r2888  
    855855            useBox.Add(lebail,0,WACV)
    856856            if UseList[G2frame.hist]['LeBail']:
    857                 G2frame.dataFrame.SetStatusText('To reset LeBail, cycle LeBail check box.')
     857                G2frame.SetStatusText('To reset LeBail, cycle LeBail check box.')
    858858        bottomSizer.Add(useBox,0,WACV|wx.TOP|wx.BOTTOM|wx.LEFT,5)
    859859       
     
    961961    # Beginning of UpdateDData execution here
    962962    ######################################################################
    963     G2frame.dataFrame.SetStatusText('')
     963    G2frame.SetStatusText('')
    964964    keyList = G2frame.GetHistogramNames(['PWDR','HKLF'])
    965965    UseList = data['Histograms']
     
    985985    if DData.GetSizer():
    986986        DData.GetSizer().Clear(True)
    987     if not G2frame.dataFrame.GetStatusBar():
    988         G2frame.dataFrame.CreateStatusBar()
    989987    mainSizer = wx.BoxSizer(wx.VERTICAL)
    990988    mainSizer.Add(wx.StaticText(DData,wx.ID_ANY,' Histogram data for '+PhaseName+':'),0,WACV|wx.LEFT,5)
  • TabularUnified branch/2frame/GSASIIgrid.py

    r2870 r2888  
    5353# Define a short name for convenience
    5454WACV = wx.ALIGN_CENTER_VERTICAL
    55 
    5655[ wxID_FOURCALC, wxID_FOURSEARCH, wxID_FOURCLEAR, wxID_PEAKSMOVE, wxID_PEAKSCLEAR,
    5756    wxID_CHARGEFLIP, wxID_PEAKSUNIQUE, wxID_PEAKSDELETE, wxID_PEAKSDA,
     
    158157[ wxID_MCRON,wxID_MCRLIST,wxID_MCRSAVE,wxID_MCRPLAY,
    159158] = [wx.NewId() for item in range(4)]
     159
     160
    160161
    161162VERY_LIGHT_GREY = wx.Colour(235,235,235)
     
    15871588 
    15881589################################################################################
    1589 class DataFrame(wx.Frame):
    1590     '''Create the data item window and all the entries in menus used in
    1591     that window. For Linux and windows, the menu entries are created for the
    1592     current data item window, but in the Mac the menu is accessed from all
     1590class DataWindow(wxscroll.ScrolledPanel):
     1591    '''Create the data item window entries in menus used in
     1592    that window. The menu entries are created for all
     1593    data item windows, but in the Mac the menu is accessed from all
    15931594    windows. This means that a different menu is posted depending on which
    15941595    data item is posted. On the Mac, all the menus contain the data tree menu
     
    15991600    where the functions to be called are defined.
    16001601    '''
    1601     def Bind(self,eventtype,handler,*args,**kwargs):
    1602         '''Override the Bind() function: on the Mac the binding is to
    1603         the main window, so that menus operate with any window on top.
    1604         For other platforms, either wrap calls that will be logged
    1605         or call the default wx.Frame Bind() to bind to the menu item directly.
    1606 
    1607         Note that bindings can be made to objects by Id or by direct reference to the
    1608         object. As a convention, when bindings are to objects, they are not logged
    1609         but when bindings are by Id, they are logged.
    1610         '''
    1611         if sys.platform == "darwin": # mac
    1612             self.G2frame.Bind(eventtype,handler,*args,**kwargs)
    1613             return
    1614         if eventtype == wx.EVT_MENU and 'id' in kwargs:
    1615             menulabels = log.SaveMenuCommand(kwargs['id'],self.G2frame,handler)
    1616             if menulabels:
    1617                 #print 'intercepting bind for',handler,menulabels,kwargs['id']
    1618                 wx.Frame.Bind(self,eventtype,self.G2frame.MenuBinding,*args,**kwargs)
    1619                 return
    1620             wx.Frame.Bind(self,eventtype,handler,*args,**kwargs)     
     1602#    def Bind(self,eventtype,handler,*args,**kwargs):
     1603#        '''Override the Bind() function: on the Mac the binding is to
     1604#        the main window, so that menus operate with any window on top.
     1605#        For other platforms, either wrap calls that will be logged
     1606#        or call the default wx.Frame Bind() to bind to the menu item directly.
     1607#
     1608#        Note that bindings can be made to objects by Id or by direct reference to the
     1609#        object. As a convention, when bindings are to objects, they are not logged
     1610#        but when bindings are by Id, they are logged.
     1611#        '''
     1612#        if sys.platform == "darwin": # mac
     1613#            self.Bind(eventtype,handler,*args,**kwargs)
     1614#            return
     1615#        if eventtype == wx.EVT_MENU and 'id' in kwargs:
     1616##            menulabels = log.SaveMenuCommand(kwargs['id'],self,handler)
     1617##            if menulabels:
     1618##                #print 'intercepting bind for',handler,menulabels,kwargs['id']
     1619##                wx.Window.Bind(self,eventtype,self.MenuBinding,*args,**kwargs)
     1620##                return
     1621#            self.Bind(self,eventtype,handler,*args,**kwargs)     
    16211622       
    16221623    def PrefillDataMenu(self,menu,empty=False):
    1623         '''Create the "standard" part of data frame menus. Note that on Linux and
    1624         Windows nothing happens here. On Mac, this menu duplicates the
     1624        '''Create the "standard" part of data frame menus & add the data menu. 
     1625        On Mac, this menu duplicates the
    16251626        tree menu, but adds an extra help command for the data item and a separator.
    16261627        '''
    16271628        self.datamenu = menu
    1628         self.G2frame.dataMenuBars.append(menu)
    1629         if sys.platform == "darwin": # mac                         
    1630             self.G2frame.FillMainMenu(menu,addhelp=False) # add the data tree menu items
    1631             if not empty:
    1632                 menu.Append(wx.Menu(title=''),title='|') # add a separator
     1629        self.GetGrandParent().GetParent().FillMainMenu(menu,addhelp=False) # add the data tree menu items to the main menu
     1630        if not empty:
     1631            menu.Append(wx.Menu(title=''),title='|') # add a separator
    16331632       
    16341633    def PostfillDataMenu(self,empty=False):
     
    16491648            menu.Append(menu=G2G.MyHelp(self),title='&Help')
    16501649
    1651     def _init_menus(self):
    1652         'define all GSAS-II data frame menus'
     1650
     1651    def _initMenus_(self):
     1652        'define all GSAS-II data window menus'
    16531653
    16541654        # for use where no menu or data frame help is provided
     
    18261826                        ):
    18271827            objlist = []
    1828             for obj in self.G2frame.exporterlist:
     1828            for obj in self.parent.GetParent().GetParent().exporterlist:
    18291829                if lbl.lower() in obj.exporttype:
    18301830                    try:
     
    23762376        # setup a cascade menu for the formats that have been defined
    23772377        self.ReImportMenuId = {}  # points to readers for each menu entry
    2378         for reader in self.G2frame.ImportPhaseReaderlist:
     2378        for reader in self.parent.GetParent().GetParent().ImportPhaseReaderlist:
    23792379            item = submenu.Append(
    23802380                wx.ID_ANY,help=reader.longFormatName,
     
    25872587        self.PostfillDataMenu()
    25882588    # end of GSAS-II menu definitions
    2589        
    2590     def _init_ctrls(self, parent,name=None,size=None,pos=None):
    2591         wx.Frame.__init__(
    2592             self,parent=parent,
    2593             #style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX | wx.FRAME_FLOAT_ON_PARENT ,
    2594             style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX,
    2595             size=size,pos=pos,title='GSAS-II data display')
    2596         self._init_menus()
    2597         if name:
    2598             self.SetLabel(name)
    2599         self.Show()
    2600        
    2601     def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
    2602         self.G2frame = frame
    2603         self._init_ctrls(parent,name,size,pos)
    2604         self.data = data
    2605         clientSize = wx.ClientDisplayRect()
    2606         Size = self.GetSize()
    2607         xPos = clientSize[2]-Size[0]
    2608         self.SetPosition(wx.Point(xPos,clientSize[1]+250))
    2609         self.AtomGrid = []
    2610         self.selectedRow = 0
    2611         self.lastSize = Size       
    2612         self.manualPhaseSize = None
    2613         self.userReSize = False
    2614         wx.Frame.Bind(self,wx.EVT_SIZE,self.OnReSize)
    2615            
    2616     def OnReSize(self,event):
    2617         '''Keep track of size changes for Phase windows
    2618         '''
    2619         id = self.G2frame.PatternTree.GetSelection()
    2620         try:
    2621             parent = self.G2frame.PatternTree.GetItemParent(id)
    2622         except:         #avoid bad tree item on start via gpx file selection
    2623             parent = 0
    2624         if self.userReSize and parent and self.G2frame.PatternTree.GetItemText(parent) == "Phases":
    2625             newSize = event.EventObject.GetSize()
    2626             if newSize[1] < 200: return             #avois spurious small window after Refine
    2627             if self.lastSize == newSize:
    2628 #                if GSASIIpath.GetConfigValue('debug'):
    2629 #                    print 'no save size=',self.lastSize
    2630                 return
    2631             self.manualPhaseSize = newSize
    2632             self.lastSize = event.EventObject.GetSize()
    2633 #            if GSASIIpath.GetConfigValue('debug'):
    2634 #                print 'Saving Phase size=',self.manualPhaseSize
    2635                 #HowDidIgetHere()
    2636         event.Skip()
    2637 
    2638     def SendSizeEvent(self):
    2639         '''Prevent SendSizeEvent from overriding the saved size
    2640         '''
    2641         self.userReSize = False
    2642         wx.Frame.SendSizeEvent(self)
    2643         self.userReSize = True
    2644        
    2645     def setSizePosLeft(self,Size):
    2646         '''Place the dataFrame window so that the upper left-hand corner remains in the same place;
    2647         The size is dictated by parameter Width, unless overridden by a previous Phase window resize
    2648         '''
    2649         self.userReSize = False
    2650 #        if GSASIIpath.GetConfigValue('debug'):
    2651 #            print 'setSizePosLeft size',Size,self.lastSize
    2652         Size = list(Size)
    2653         id = self.G2frame.PatternTree.GetSelection()
    2654         try:            #avoid bad tree item on start via gpx file selection
    2655             pid = self.G2frame.PatternTree.GetItemParent(id)
    2656         except:
    2657             pid = 0
    2658         if pid:
    2659             parent = self.G2frame.PatternTree.GetItemText(pid)
    2660             # is this a phase window and has a previous window has been resized?
    2661             if self.manualPhaseSize and parent == "Phases":
    2662                 Size = list(self.manualPhaseSize)
    2663         Pos = self.GetPosition()
    2664         clientSize = wx.ClientDisplayRect()     #display window size (e.g. 1304x768)
    2665         Size[1] = min(Size[1],clientSize[2]-300)
    2666         Size[0] = max(Size[0],300)
    2667 #        print 'current position/width:',Pos,Width
    2668         self.SetSize(Size)
    2669         Size[1] += 1        #kluge to ensure scrollbar settings & window properly displayed
    2670         self.SetSize(Size)
    2671         Pos[0] += self.lastSize[0]-Size[0]
    2672         offSet = 0
    2673         if Pos[0] < clientSize[2]:
    2674             offSet = Pos[0]+Size[0]-clientSize[2]
    2675         if offSet > 0:
    2676             Pos[0] -= offSet
    2677         self.SetPosition(wx.Point(Pos[0],Pos[1]))
    2678         self.lastSize = Size
    2679         self.userReSize = True
    2680        
    2681     def Clear(self):
    2682         self.ClearBackground()
     2589   
     2590    def __init__(self,parent):
     2591        wxscroll.ScrolledPanel.__init__(self,parent,wx.ID_ANY,size=parent.GetSize())
     2592        self.parent = parent
     2593        self._initMenus_()
     2594        self.currentGrids = []
     2595       
     2596    def ClearData(self):
     2597#        if self.GetSizer():
     2598#            self.GetSizer().Destroy()
     2599        self.SetBackgroundColour(wx.WHITE)
    26832600        self.DestroyChildren()
     2601#        self.SetSize(self.GetParent().GetSize())
     2602       
     2603#TODO - remove         
     2604#    def _init_ctrls(self, parent,name=None,size=None,pos=None):
     2605#        wx.Frame.__init__(
     2606#            self,parent=parent,
     2607#            #style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX | wx.FRAME_FLOAT_ON_PARENT ,
     2608#            style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX,
     2609#            size=size,pos=pos,title='GSAS-II data display')
     2610#        self._init_menus()
     2611#        if name:
     2612#            self.SetLabel(name)
     2613#        self.Show()
     2614#
     2615#    def __init__(self,parent,frame,data=None,name=None, size=None,pos=None):
     2616#        self.G2frame = frame
     2617#        self._init_ctrls(parent,name,size,pos)
     2618#        self.data = data
     2619#        clientSize = wx.ClientDisplayRect()
     2620#        Size = self.GetSize()
     2621#        xPos = clientSize[2]-Size[0]
     2622#        self.SetPosition(wx.Point(xPos,clientSize[1]+250))
     2623#        self.AtomGrid = []
     2624#        self.selectedRow = 0
     2625#        self.lastSize = Size       
     2626#        self.manualPhaseSize = None
     2627#        self.userReSize = False
     2628#        wx.Frame.Bind(self,wx.EVT_SIZE,self.OnReSize)
     2629#           
     2630#    def OnReSize(self,event):
     2631#        '''Keep track of size changes for Phase windows
     2632#        '''
     2633#        id = self.G2frame.PatternTree.GetSelection()
     2634#        try:
     2635#            parent = self.G2frame.PatternTree.GetItemParent(id)
     2636#        except:         #avoid bad tree item on start via gpx file selection
     2637#            parent = 0
     2638#        if self.userReSize and parent and self.G2frame.PatternTree.GetItemText(parent) == "Phases":
     2639#            newSize = event.EventObject.GetSize()
     2640#            if newSize[1] < 200: return             #avois spurious small window after Refine
     2641#            if self.lastSize == newSize:
     2642##                if GSASIIpath.GetConfigValue('debug'):
     2643##                    print 'no save size=',self.lastSize
     2644#                return
     2645#            self.manualPhaseSize = newSize
     2646#            self.lastSize = event.EventObject.GetSize()
     2647##            if GSASIIpath.GetConfigValue('debug'):
     2648##                print 'Saving Phase size=',self.manualPhaseSize
     2649#                #HowDidIgetHere()
     2650#        event.Skip()
     2651#
     2652#    def SendSizeEvent(self):
     2653#        '''Prevent SendSizeEvent from overriding the saved size
     2654#        '''
     2655#        self.userReSize = False
     2656#        wx.Frame.SendSizeEvent(self)
     2657#        self.userReSize = True
     2658#               
     2659#    def Clear(self):
     2660#        self.ClearBackground()
     2661#        self.DestroyChildren()
    26842662                   
    2685 
    26862663################################################################################
    26872664#####  Notebook Tree Item editor
     
    26932670    def OnNoteBook(event):
    26942671        event.Skip()
    2695         data = G2frame.dataDisplay.GetValue().split('\n')
     2672        data = text.GetValue().split('\n')
    26962673        G2frame.PatternTree.SetItemPyData(GetPatternTreeItemId(G2frame,G2frame.root,'Notebook'),data)
    26972674        if 'nt' not in os.name:
    2698             G2frame.dataDisplay.AppendText('\n')
     2675            text.AppendText('\n')
    26992676                   
    2700     if G2frame.dataDisplay:
    2701         G2frame.dataDisplay.Destroy()
    2702     G2frame.dataFrame.SetLabel('Notebook')
    2703     G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
     2677    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Notebook')
     2678    G2frame.dataWindow.ClearData()
     2679    G2frame.dataWindow.SetupScrolling()
     2680    mainSizer = wx.BoxSizer()
     2681    text = wx.TextCtrl(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetSize(),
    27042682        style=wx.TE_MULTILINE|wx.TE_PROCESS_ENTER | wx.TE_DONTWRAP)
    2705     G2frame.dataDisplay.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
    2706     G2frame.dataDisplay.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
     2683    text.Bind(wx.EVT_TEXT_ENTER,OnNoteBook)
     2684    text.Bind(wx.EVT_KILL_FOCUS,OnNoteBook)
    27072685    for line in data:
    2708         G2frame.dataDisplay.AppendText(line+"\n")
    2709     G2frame.dataDisplay.AppendText('Notebook entry @ '+time.ctime()+"\n")
    2710     G2frame.dataFrame.setSizePosLeft([400,250])
     2686        text.AppendText(line+"\n")
     2687    text.AppendText('Notebook entry @ '+time.ctime()+"\n")
     2688    mainSizer.Add(text,1,wx.EXPAND)
     2689    G2frame.dataWindow.SetSizer(mainSizer)
     2690    G2frame.SetDataSize()
     2691           
     2692################################################################################
     2693#####  Comments
     2694################################################################################           
     2695       
     2696def UpdateComments(G2frame,data):                   
     2697
     2698    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Comments')
     2699    G2frame.dataWindow.ClearData()
     2700    G2frame.dataWindow.SetupScrolling()
     2701    text = wx.TextCtrl(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetSize(),
     2702        style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP)
     2703    for line in data:
     2704        if '\n' not in line:
     2705            text.AppendText(line+'\n')
     2706        else:
     2707            text.AppendText(line)
     2708    mainSizer = wx.BoxSizer()
     2709    mainSizer.Add(text,1,wx.EXPAND)
     2710    G2frame.dataWindow.SetSizer(mainSizer)
     2711    G2frame.SetDataSize()
    27112712           
    27122713################################################################################
     
    27852786        seqSizer = wx.BoxSizer(wx.VERTICAL)
    27862787        dataSizer = wx.BoxSizer(wx.HORIZONTAL)
    2787         dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sequential Refinement: '),0,WACV)
    2788         selSeqData = wx.Button(G2frame.dataDisplay,-1,label=' Select data')
     2788        dataSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Sequential Refinement: '),0,WACV)
     2789        selSeqData = wx.Button(G2frame.dataWindow,-1,label=' Select data')
    27892790        selSeqData.Bind(wx.EVT_BUTTON,OnSelectData)
    27902791        dataSizer.Add(selSeqData,0,WACV)
     
    27952796            lbl = ' ('+str(len(SeqData))+' dataset(s) selected)'
    27962797
    2797         dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label=lbl),0,WACV)
     2798        dataSizer.Add(wx.StaticText(G2frame.dataWindow,label=lbl),0,WACV)
    27982799        seqSizer.Add(dataSizer,0)
    27992800        if SeqData:
    28002801            selSizer = wx.BoxSizer(wx.HORIZONTAL)
    2801             reverseSel = wx.CheckBox(G2frame.dataDisplay,-1,label=' Reverse order?')
     2802            reverseSel = wx.CheckBox(G2frame.dataWindow,-1,label=' Reverse order?')
    28022803            reverseSel.Bind(wx.EVT_CHECKBOX,OnReverse)
    28032804            reverseSel.SetValue(data['Reverse Seq'])
    28042805            selSizer.Add(reverseSel,0,WACV)
    2805             copySel =  wx.CheckBox(G2frame.dataDisplay,-1,label=' Copy results to next histogram?')
     2806            copySel =  wx.CheckBox(G2frame.dataWindow,-1,label=' Copy results to next histogram?')
    28062807            copySel.Bind(wx.EVT_CHECKBOX,OnCopySel)
    28072808            copySel.SetValue(data['Copy2Next'])
     
    28382839           
    28392840        LSSizer = wx.FlexGridSizer(cols=4,vgap=5,hgap=5)
    2840         LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement derivatives: '),0,WACV)
     2841        LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Refinement derivatives: '),0,WACV)
    28412842        Choice=['analytic Jacobian','numeric','analytic Hessian','Hessian SVD']   #TODO +'SVD refine' - what flags will it need?
    2842         derivSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['deriv type'],choices=Choice,
     2843        derivSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['deriv type'],choices=Choice,
    28432844            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    28442845        derivSel.SetValue(data['deriv type'])
     
    28462847           
    28472848        LSSizer.Add(derivSel,0,WACV)
    2848         LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min delta-M/M: '),0,WACV)
    2849         LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'min dM/M',nDig=(10,2,'g'),min=1.e-9,max=1.),0,WACV)
     2849        LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Min delta-M/M: '),0,WACV)
     2850        LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'min dM/M',nDig=(10,2,'g'),min=1.e-9,max=1.),0,WACV)
    28502851        if 'Hessian' in data['deriv type']:
    2851             LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max cycles: '),0,WACV)
     2852            LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Max cycles: '),0,WACV)
    28522853            Choice = ['0','1','2','3','5','10','15','20']
    2853             maxCyc = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['max cyc']),choices=Choice,
     2854            maxCyc = wx.ComboBox(parent=G2frame.dataWindow,value=str(data['max cyc']),choices=Choice,
    28542855                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    28552856            maxCyc.Bind(wx.EVT_COMBOBOX, OnMaxCycles)
    28562857            LSSizer.Add(maxCyc,0,WACV)
    28572858            if 'SVD' not in data['deriv type']:
    2858                 LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial lambda = 10**'),0,WACV)
     2859                LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Initial lambda = 10**'),0,WACV)
    28592860                MarqChoice = ['-3','-2','-1','0','1','2','3','4']
    2860                 marqLam = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['Marquardt']),choices=MarqChoice,
     2861                marqLam = wx.ComboBox(parent=G2frame.dataWindow,value=str(data['Marquardt']),choices=MarqChoice,
    28612862                    style=wx.CB_READONLY|wx.CB_DROPDOWN)
    28622863                marqLam.Bind(wx.EVT_COMBOBOX,OnMarqLam)
    28632864                LSSizer.Add(marqLam,0,WACV)
    2864             LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' SVD zero tolerance:'),0,WACV)
    2865             LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'SVDtol',nDig=(10,1,'g'),min=1.e-9,max=.01),0,WACV)
     2865            LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' SVD zero tolerance:'),0,WACV)
     2866            LSSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'SVDtol',nDig=(10,1,'g'),min=1.e-9,max=.01),0,WACV)
    28662867        else:       #TODO what for SVD refine?
    2867             LSSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Initial shift factor: '),0,WACV)
    2868             Factr = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'shift factor',nDig=(10,5),min=1.e-5,max=100.)
     2868            LSSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Initial shift factor: '),0,WACV)
     2869            Factr = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'shift factor',nDig=(10,5),min=1.e-5,max=100.)
    28692870            LSSizer.Add(Factr,0,WACV)
    28702871        if G2frame.Sngl:
     
    28742875                'MinD':[' Min d-spacing (0.1-2.0): ',[0.1,2.0],]}
    28752876
    2876             fsqRef = wx.CheckBox(G2frame.dataDisplay,-1,label='Refine HKLF as F^2? ')
     2877            fsqRef = wx.CheckBox(G2frame.dataWindow,-1,label='Refine HKLF as F^2? ')
    28772878            fsqRef.SetValue(data['F**2'])
    28782879            fsqRef.Bind(wx.EVT_CHECKBOX,OnFsqRef)
     
    28802881            LSSizer.Add((1,0),)
    28812882            for item in usrRej:
    2882                 LSSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=usrRej[item][0]),0,WACV)
    2883                 usrrej = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,userReject,item,nDig=(10,2),
     2883                LSSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=usrRej[item][0]),0,WACV)
     2884                usrrej = G2G.ValidatedTxtCtrl(G2frame.dataWindow,userReject,item,nDig=(10,2),
    28842885                    min=usrRej[item][1][0],max=usrRej[item][1][1])
    28852886                LSSizer.Add(usrrej,0,WACV)
     
    28942895        Author = data['Author']
    28952896        authSizer = wx.BoxSizer(wx.HORIZONTAL)
    2896         authSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' CIF Author (last, first):'),0,WACV)
    2897         auth = wx.TextCtrl(G2frame.dataDisplay,-1,value=Author,style=wx.TE_PROCESS_ENTER)
     2897        authSizer.Add(wx.StaticText(G2frame.dataWindow,label=' CIF Author (last, first):'),0,WACV)
     2898        auth = wx.TextCtrl(G2frame.dataWindow,-1,value=Author,style=wx.TE_PROCESS_ENTER)
    28982899        auth.Bind(wx.EVT_TEXT_ENTER,OnAuthor)
    28992900        auth.Bind(wx.EVT_KILL_FOCUS,OnAuthor)
     
    29012902        return authSizer
    29022903       
    2903        
    2904     if G2frame.dataDisplay:
    2905         G2frame.dataDisplay.Destroy()
    2906     if not G2frame.dataFrame.GetStatusBar():
    2907         Status = G2frame.dataFrame.CreateStatusBar()
     2904    if 'SVD' in data['deriv type']:
     2905        G2frame.GetStatusBar().SetStatusText('Hessian SVD not recommended for initial refinements; use analytic Hessian or Jacobian')
    29082906    else:
    2909         Status = G2frame.dataFrame.GetStatusBar()
    2910     if 'SVD' in data['deriv type']:
    2911         Status.SetStatusText('Hessian SVD not recommended for initial refinements; use analytic Hessian or Jacobian')
    2912     else:
    2913         Status.SetStatusText('')
    2914     G2frame.dataFrame.SetLabel('Controls')
    2915     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
    2916     SetDataMenuBar(G2frame,G2frame.dataFrame.ControlsMenu)
     2907        G2frame.GetStatusBar().SetStatusText('')
     2908    G2frame.dataWindow.ClearData()
     2909    G2frame.dataWindow.SetupScrolling()
     2910    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Controls')
     2911    SetDataMenuBar(G2frame,G2frame.dataWindow.ControlsMenu)
    29172912    mainSizer = wx.BoxSizer(wx.VERTICAL)
    29182913    mainSizer.Add((5,5),0)
    2919     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Refinement Controls:'),0,WACV)   
     2914    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Refinement Controls:'),0,WACV)   
    29202915    mainSizer.Add(LSSizer())
    29212916    mainSizer.Add((5,5),0)
     
    29252920    mainSizer.Add((5,5),0)
    29262921       
    2927     mainSizer.Layout()   
    2928     G2frame.dataDisplay.SetSizer(mainSizer)
    2929     G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
     2922    mainSizer.Layout()
     2923    mainSizer.FitInside(G2frame.dataWindow)   
     2924    G2frame.dataWindow.SetSizer(mainSizer)
     2925    G2frame.dataWindow.SetAutoLayout(1)
     2926    G2frame.SetDataSize()
    29302927     
    2931 ################################################################################
    2932 #####  Comments
    2933 ################################################################################           
    2934        
    2935 def UpdateComments(G2frame,data):                   
    2936 
    2937     if G2frame.dataDisplay:
    2938         G2frame.dataDisplay.Destroy()
    2939     G2frame.dataFrame.SetLabel('Comments')
    2940     G2frame.dataDisplay = wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
    2941         style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP)
    2942     for line in data:
    2943         if '\n' not in line:
    2944             G2frame.dataDisplay.AppendText(line+'\n')
    2945         else:
    2946             G2frame.dataDisplay.AppendText(line)
    2947     G2frame.dataFrame.setSizePosLeft([400,250])
    2948            
    29492928################################################################################
    29502929#####  Display of Sequential Results
     
    32343213        else:
    32353214            val = False
    3236         G2frame.dataFrame.SequentialPvars.Enable(wxDELSEQVAR,val)
    3237         G2frame.dataFrame.SequentialPvars.Enable(wxEDITSEQVAR,val)
     3215        G2frame.dataWindow.SequentialPvars.Enable(wxDELSEQVAR,val)
     3216        G2frame.dataWindow.SequentialPvars.Enable(wxEDITSEQVAR,val)
    32383217
    32393218    def DelPseudoVar(event):
     
    37523731    if G2frame.dataDisplay:
    37533732        G2frame.dataDisplay.Destroy()
    3754     if not G2frame.dataFrame.GetStatusBar():
    3755         Status = G2frame.dataFrame.CreateStatusBar()
    3756         Status.SetStatusText("Select column to export; Double click on column to plot data; on row for Covariance")
     3733    G2frame.GetStatusBar().SetStatusText("Select column to export; Double click on column to plot data; on row for Covariance")
    37573734    sampleParms = GetSampleParms()
    37583735
     
    38093786            initialCell[str(pId)+'::A'+str(i)] =  RecpCellTerms[pId][i]
    38103787
    3811     SetDataMenuBar(G2frame,G2frame.dataFrame.SequentialMenu)
    3812     G2frame.dataFrame.SetLabel('Sequential refinement results')
    3813     if not G2frame.dataFrame.GetStatusBar():
    3814         Status = G2frame.dataFrame.CreateStatusBar()
    3815         Status.SetStatusText('')
     3788    SetDataMenuBar(G2frame,G2frame.dataWindow.SequentialMenu)
     3789    G2frame.dataFrame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Sequential refinement results')
     3790    G2frame.GetStatusBar().SetStatusText('')
    38163791    G2frame.dataFrame.Bind(wx.EVT_MENU, OnRenameSelSeq, id=wxID_RENAMESEQSEL)
    38173792    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveSelSeq, id=wxID_SAVESEQSEL)
     
    41474122            del G2frame.colSigs[l]
    41484123
     4124    G2frame.dataWindow.ClearData()
    41494125    G2frame.dataFrame.currentGrids = []
    4150     G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
     4126    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataWindow)
     4127    G2frame.dataDisplay.SetSize(G2frame.dataWindow.GetSize())
    41514128    G2frame.SeqTable = G2G.Table([list(cl) for cl in zip(*G2frame.colList)],     # convert from columns to rows
    41524129        colLabels=colLabels,rowLabels=histNames,types=Types)
     
    41624139    G2frame.dataDisplay.SetMargins(0,0)
    41634140    G2frame.dataDisplay.AutoSizeColumns(False)
    4164     if prevSize:
    4165         G2frame.dataFrame.setSizePosLeft(prevSize)
    4166     else:
    4167         G2frame.dataFrame.setSizePosLeft([700,350])
    41684141    # highlight unconverged shifts
    41694142    if histNames[0][:4] not in ['SASD','IMG ','REFD',]:
     
    43784351           
    43794352    data = G2frame.PatternTree.GetItemPyData(item)
     4353    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+G2frame.PatternTree.GetItemText(item))
    43804354#patches
    43814355    if not data:
     
    43944368        G2frame.PatternTree.SetItemPyData(item,data)
    43954369#end patches
    4396     if G2frame.dataDisplay:
    4397         G2frame.dataDisplay.Destroy()
    43984370    if kind in ['PWDR','SASD','REFD']:
    4399         SetDataMenuBar(G2frame,G2frame.dataFrame.PWDRMenu)
    4400         G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
    4401         G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
    4402         G2frame.dataFrame.Bind(wx.EVT_MENU, onCopyPlotCtrls, id=wxID_PLOTCTRLCOPY)
     4371        SetDataMenuBar(G2frame,G2frame.dataWindow.PWDRMenu)
     4372        G2frame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
     4373        G2frame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
     4374        G2frame.Bind(wx.EVT_MENU, onCopyPlotCtrls, id=wxID_PLOTCTRLCOPY)
    44034375    elif kind in ['HKLF',]:
    4404         SetDataMenuBar(G2frame,G2frame.dataFrame.HKLFMenu)
    4405         G2frame.dataFrame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
    4406         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMergeHKL, id=wxID_MERGEHKL)
    4407         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=wxID_PWD3DHKLPLOT)
    4408         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotAll3DHKL, id=wxID_3DALLHKLPLOT)
    4409 #        G2frame.dataFrame.Bind(wx.EVT_MENU, onCopySelectedItems, id=wxID_PWDCOPY)
    4410     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     4376        SetDataMenuBar(G2frame,G2frame.dataWindow.HKLFMenu)
     4377        G2frame.Bind(wx.EVT_MENU, OnErrorAnalysis, id=wxID_PWDANALYSIS)
     4378        G2frame.Bind(wx.EVT_MENU, OnMergeHKL, id=wxID_MERGEHKL)
     4379        G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=wxID_PWD3DHKLPLOT)
     4380        G2frame.Bind(wx.EVT_MENU, OnPlotAll3DHKL, id=wxID_3DALLHKLPLOT)
    44114381   
     4382    G2frame.dataWindow.ClearData()
    44124383    mainSizer = wx.BoxSizer(wx.VERTICAL)
    44134384    mainSizer.Add((5,5),)
    44144385    wtSizer = wx.BoxSizer(wx.HORIZONTAL)
    4415     wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Weight factor: '),0,WACV)
    4416     wtval = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[0],'wtFactor',nDig=(10,3),min=1.e-9)
     4386    wtSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Weight factor: '),0,WACV)
     4387    wtval = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[0],'wtFactor',nDig=(10,3),min=1.e-9)
    44174388    wtSizer.Add(wtval,0,WACV)
    44184389#    if kind == 'PWDR':         #possible future compression feature; NB above patch as well
    4419 #        wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Compression factor: '),0,WACV)
     4390#        wtSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Compression factor: '),0,WACV)
    44204391#        choice = ['1','2','3','4','5','6']
    4421 #        comp = wx.ComboBox(parent=G2frame.dataDisplay,choices=choice,
     4392#        comp = wx.ComboBox(parent=G2frame.dataWindow,choices=choice,
    44224393#            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    44234394#        comp.SetValue(str(data[0]['Compression']))
     
    44354406        lbl += u'\n(Edit range resets observed intensities).'
    44364407        lbl = lbl.format(Tmin,Tmax,t,step,num)
    4437         simSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,lbl),
     4408        simSizer.Add(wx.StaticText(G2frame.dataWindow,wx.ID_ANY,lbl),
    44384409                    0,WACV)
    4439         but = wx.Button(G2frame.dataDisplay,wx.ID_ANY,"Edit range")
     4410        but = wx.Button(G2frame.dataWindow,wx.ID_ANY,"Edit range")
    44404411        but.Bind(wx.EVT_BUTTON,onEditSimRange)
    44414412        simSizer.Add(but,0,WACV)
    44424413        mainSizer.Add(simSizer)
    44434414    if 'Nobs' in data[0]:
    4444         mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
     4415        mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
    44454416            ' Data residual wR: %.3f%% on %d observations'%(data[0]['wR'],data[0]['Nobs'])))
    44464417        if kind == 'PWDR':
    4447             mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
     4418            mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
    44484419                ' Durbin-Watson statistic: %.3f'%(data[0].get('Durbin-Watson',0.))))
    44494420        for value in data[0]:
     
    44534424                if 'SS' in value:
    44544425                    mainSizer.Add((5,5),)
    4455                     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For incommensurate phase '+name+':'))
     4426                    mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' For incommensurate phase '+name+':'))
    44564427                    for m,(Rf2,Rf,Nobs) in enumerate(zip(data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])):
    4457                         mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
     4428                        mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
    44584429                            u' m = +/- %d: RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections  '% \
    44594430                            (m,Rf2,Rf,Nobs)))
    44604431                else:
    44614432                    mainSizer.Add((5,5),)
    4462                     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' For phase '+name+':'))
    4463                     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,
     4433                    mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' For phase '+name+':'))
     4434                    mainSizer.Add(wx.StaticText(G2frame.dataWindow,-1,
    44644435                        u' Unweighted phase residuals RF\u00b2: %.3f%%, RF: %.3f%% on %d reflections  '% \
    44654436                        (data[0][pfx+'Rf^2'],data[0][pfx+'Rf'],data[0][value])))
     
    44674438    mainSizer.Add((5,5),)
    44684439    mainSizer.Layout()   
    4469     G2frame.dataDisplay.SetSizer(mainSizer)
    4470     Size = mainSizer.Fit(G2frame.dataFrame)
    4471     Size[1] += 10
    4472     G2frame.dataFrame.setSizePosLeft(Size)
     4440    G2frame.dataWindow.SetSizer(mainSizer)
     4441    mainSizer.Fit(G2frame.dataWindow)
     4442    G2frame.SetDataSize()
     4443   
    44734444    G2frame.PatternTree.SetItemPyData(item,data)
    44744445    G2frame.PatternId = item
     
    45834554            if G2frame.dataDisplay:
    45844555                oldPage = G2frame.dataDisplay.GetSelection()
    4585         G2frame.dataFrame.Clear()
    4586         G2frame.dataFrame.SetLabel('')
    4587     else:
    4588         #create the frame for the data item window
    4589         G2frame.dataFrame = DataFrame(parent=G2frame.mainPanel,frame=G2frame)
    4590         G2frame.dataFrame.PhaseUserSize = None
     4556        G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'')
    45914557       
    45924558    SetDataMenuBar(G2frame)
    4593     G2frame.dataFrame.currentGrids = [] # this will contain pointers to a grid placed in the frame
    45944559    G2frame.PickId = item
    45954560    G2frame.PickIdText = None
    45964561    parentID = G2frame.root
    4597     #for i in G2frame.ExportPattern: i.Enable(False)
    4598     defWid = [250,150]
    45994562    if item == G2frame.root:
    4600         G2frame.dataFrame.helpKey = "Data tree"
    4601         G2frame.dataFrame.setSizePosLeft(defWid)
    4602         wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
     4563        G2frame.helpKey = "Data tree"
     4564        wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.GetClientSize(),
    46034565                    value='Select an item from the tree to see/edit parameters')       
    4604         G2frame.dataFrame.Raise()           
    46054566        return
    46064567    else:
    4607         parentID = G2frame.PatternTree.GetItemParent(item)
    4608         # save name of calling tree item for help. N.B. may want to override this later
    4609         prfx = G2frame.PatternTree.GetItemText(item).split()[0]
    4610         prfx1 = G2frame.PatternTree.GetItemText(parentID).split()[0]
    4611         if prfx in ('IMG','PKS','PWDR','SASD','HKLF','PDF','refd',):
    4612             G2frame.dataFrame.helpKey = prfx
    4613         elif prfx1 in ('IMG','PKS','PWDR','SASD','HKLF','PDF','REFD',):
    4614             suffix = G2frame.PatternTree.GetItemText(item)
    4615             suffix1 = suffix.split()[0]
    4616             if '(Q)' in suffix1 or '(R)' in suffix1: suffix = suffix1
    4617             G2frame.dataFrame.helpKey = prfx1 + '_' + suffix
    4618         else:
    4619             G2frame.dataFrame.helpKey = G2frame.PatternTree.GetItemText(item) # save name of calling tree item for help
     4568        try:    #don't know why here when opening new project  from inside phase data!
     4569            parentID = G2frame.PatternTree.GetItemParent(item)
     4570            # save name of calling tree item for help. N.B. may want to override this later
     4571            prfx = G2frame.PatternTree.GetItemText(item).split()[0]
     4572            prfx1 = G2frame.PatternTree.GetItemText(parentID).split()[0]
     4573            if prfx in ('IMG','PKS','PWDR','SASD','HKLF','PDF','refd',):
     4574                G2frame.dataFrame.helpKey = prfx
     4575            elif prfx1 in ('IMG','PKS','PWDR','SASD','HKLF','PDF','REFD',):
     4576                suffix = G2frame.PatternTree.GetItemText(item)
     4577                suffix1 = suffix.split()[0]
     4578                if '(Q)' in suffix1 or '(R)' in suffix1: suffix = suffix1
     4579                G2frame.dataFrame.helpKey = prfx1 + '_' + suffix
     4580            else:
     4581                G2frame.dataFrame.helpKey = G2frame.PatternTree.GetItemText(item) # save name of calling tree item for help
     4582        except IndexError:
     4583            print 'bug: why here?'
     4584            return
    46204585    if G2frame.PatternTree.GetItemParent(item) == G2frame.root:
    46214586        G2frame.PatternId = 0
    46224587        if G2frame.PatternTree.GetItemText(item) == 'Notebook':
    4623             SetDataMenuBar(G2frame,G2frame.dataFrame.DataNotebookMenu)
    4624             #for i in G2frame.ExportPattern: i.Enable(False)
     4588            SetDataMenuBar(G2frame,G2frame.dataWindow.DataNotebookMenu)
    46254589            data = G2frame.PatternTree.GetItemPyData(item)
    46264590            UpdateNotebook(G2frame,data)
    46274591        elif G2frame.PatternTree.GetItemText(item) == 'Controls':
    4628             #for i in G2frame.ExportPattern: i.Enable(False)
    46294592            data = G2frame.PatternTree.GetItemPyData(item)
    46304593            if not data:           #fill in defaults
     
    46404603        elif G2frame.PatternTree.GetItemText(item) == 'Covariance':
    46414604            data = G2frame.PatternTree.GetItemPyData(item)
    4642             G2frame.dataFrame.setSizePosLeft(defWid)
    46434605            text = ''
    46444606            if 'Rvals' in data:
     
    46504612                if 'lamMax' in Rvals:
    46514613                    text += '\nlog10 MaxLambda = %.1f'%(np.log10(Rvals['lamMax']))
    4652             wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
     4614            G2frame.dataWindow.ClearData()
     4615            wx.TextCtrl(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetSize(),
    46534616                value='See plot window for covariance display'+text,style=wx.TE_MULTILINE)
    46544617            G2plt.PlotCovariance(G2frame,data)
     
    46654628            if Phases:
    46664629                phaseName = Phases.keys()[0]
    4667             G2frame.dataFrame.setSizePosLeft(defWid)
    46684630            G2restG.UpdateRestraints(G2frame,data,Phases,phaseName)
    46694631        elif G2frame.PatternTree.GetItemText(item).startswith('IMG '):
    46704632            G2frame.Image = item
    4671             G2frame.dataFrame.SetTitle('Image Data')
     4633            G2frame.SetTitle('Image Data')
    46724634            data = G2frame.PatternTree.GetItemPyData(GetPatternTreeItemId(
    46734635                G2frame,item,'Image Controls'))
     
    47024664                G2plt.PlotISFG(G2frame,data,plotType='G(R)')
    47034665        elif G2frame.PatternTree.GetItemText(item) == 'Phases':
    4704             G2frame.dataFrame.setSizePosLeft(defWid)
    47054666            wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
    47064667                value='Select one phase to see its parameters')           
     
    47274688        G2phG.UpdatePhaseData(G2frame,item,data,oldPage)
    47284689    elif G2frame.PatternTree.GetItemText(item) == 'Comments':
    4729         SetDataMenuBar(G2frame,G2frame.dataFrame.DataCommentsMenu)
     4690        SetDataMenuBar(G2frame,G2frame.dataWindow.DataCommentsMenu)
    47304691        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
    47314692        data = G2frame.PatternTree.GetItemPyData(item)
    47324693        UpdateComments(G2frame,data)
    47334694    elif G2frame.PatternTree.GetItemText(item) == 'Image Controls':
    4734         G2frame.dataFrame.SetTitle('Image Controls')
     4695        G2frame.SetTitle('Image Controls')
    47354696        G2frame.Image = G2frame.PatternTree.GetItemParent(item)
    47364697        masks = G2frame.PatternTree.GetItemPyData(
     
    47414702        G2plt.PlotImage(G2frame,newPlot=False)
    47424703    elif G2frame.PatternTree.GetItemText(item) == 'Masks':
    4743         G2frame.dataFrame.SetTitle('Masks')
     4704        G2frame.SetTitle('Masks')
    47444705        G2frame.Image = G2frame.PatternTree.GetItemParent(item)
    47454706        masks = G2frame.PatternTree.GetItemPyData(item)
     
    47504711        G2plt.PlotImage(G2frame,newPlot=False)
    47514712    elif G2frame.PatternTree.GetItemText(item) == 'Stress/Strain':
    4752         G2frame.dataFrame.SetTitle('Stress/Strain')
     4713        G2frame.SetTitle('Stress/Strain')
    47534714        G2frame.Image = G2frame.PatternTree.GetItemParent(item)
    47544715        data = G2frame.PatternTree.GetItemPyData(
     
    48654826    if G2frame.PickId:
    48664827        G2frame.PickIdText = G2frame.GetTreeItemsList(G2frame.PickId)
    4867     G2frame.dataFrame.Raise()
     4828    G2frame.Raise()
    48684829    if oldFocus:
    48694830        oldFocus.GetTopLevelParent().Raise()
     
    48714832       
    48724833def SetDataMenuBar(G2frame,menu=None):
    4873     '''Set the menu for the data frame. On the Mac put this
    4874     menu for the data tree window instead.
     4834    '''Set the menu for the data frame.
    48754835
    48764836    Note that data frame items do not have menus, for these (menu=None)
    4877     display a blank menu or on the Mac display the standard menu for
    4878     the data tree window.
     4837    display the standard main menu for the data tree window.
    48794838    '''
    4880     if sys.platform == "darwin":
    4881         if menu is None:
    4882             G2frame.SetMenuBar(G2frame.GSASIIMenu)
    4883         else:
    4884             G2frame.SetMenuBar(menu)
     4839    if menu is None:
     4840        G2frame.SetMenuBar(G2frame.GSASIIMenu)
    48854841    else:
    4886         if menu is None:
    4887             G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.BlankMenu)
    4888         else:
    4889             G2frame.dataFrame.SetMenuBar(menu)
     4842        G2frame.SetMenuBar(menu)
    48904843
    48914844def HowDidIgetHere():
  • TabularUnified branch/2frame/GSASIIimgGUI.py

    r2863 r2888  
    2222import sys
    2323import wx
    24 import wx.lib.scrolledpanel as wxscroll
    2524import wx.lib.mixins.listctrl  as  listmix
    2625import matplotlib as mpl
     
    106105        G2plt.PlotExposedImage(G2frame,newPlot=True,event=tc.event)
    107106       
    108     if G2frame.dataDisplay:
    109         G2frame.dataDisplay.Destroy()
    110     if not G2frame.dataFrame.GetStatusBar():
    111         G2frame.dataFrame.CreateStatusBar()
    112     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     107#    G2frame.dataWindow = wx.Panel(G2frame.dataFrame)
    113108    G2frame.ImageZ = GetImageZ(G2frame,data)
    114109    mainSizer = wx.BoxSizer(wx.VERTICAL)
    115     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,
     110    mainSizer.Add(wx.StaticText(G2frame.dataWindow,
    116111        label='Do not change anything here unless you are absolutely sure!'),0,WACV)
    117     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Image size: %d by %d'%(data['size'][0],data['size'][1])),0,WACV)
     112    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Image size: %d by %d'%(data['size'][0],data['size'][1])),0,WACV)
    118113    pixSize = wx.FlexGridSizer(0,4,5,5)
    119114    pixLabels = [u' Pixel X-dimension (\xb5m)',u' Pixel Y-dimension (\xb5m)']
    120115    for i,[pixLabel,pix] in enumerate(zip(pixLabels,data['pixelSize'])):
    121         pixSize.Add(wx.StaticText(G2frame.dataDisplay,label=pixLabel),0,WACV)
    122         pixVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['pixelSize'],i,nDig=(10,3),
     116        pixSize.Add(wx.StaticText(G2frame.dataWindow,label=pixLabel),0,WACV)
     117        pixVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['pixelSize'],i,nDig=(10,3),
    123118            typeHint=float,OnLeave=OnPixVal)
    124119        pixSize.Add(pixVal,0,WACV)
    125120    mainSizer.Add(pixSize,0)
    126121    distSizer = wx.BoxSizer(wx.HORIZONTAL)
    127     distSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Set detector distance: '),0,WACV)
     122    distSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Set detector distance: '),0,WACV)
    128123    if 'setdist' not in data:
    129124        data['setdist'] = data['distance']
    130     distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'setdist',nDig=(10,4),
     125    distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'setdist',nDig=(10,4),
    131126            typeHint=float),0,WACV)
    132     distSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Polarization: '),0,WACV)
     127    distSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Polarization: '),0,WACV)
    133128    if 'PolaVal' not in data:       #patch
    134129        data['PolaVal'] = [0.99,False]
    135     distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['PolaVal'],0,nDig=(10,4),
     130    distSizer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['PolaVal'],0,nDig=(10,4),
    136131        min=0.,max=1.,typeHint=float),0,WACV)
    137132    mainSizer.Add(distSizer,0)
    138133    mainSizer.Layout()   
    139     G2frame.dataDisplay.SetSizer(mainSizer)
    140     fitSize = mainSizer.Fit(G2frame.dataFrame)
    141     G2frame.dataFrame.setSizePosLeft(fitSize)
     134    G2frame.dataWindow.SetSizer(mainSizer)
     135    mainSizer.Fit(G2frame.dataFrame)
     136    G2frame.SetDataSize()
    142137
    143138################################################################################
     
    583578       
    584579        comboSizer = wx.BoxSizer(wx.HORIZONTAL)
    585         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Type of image data: '),0,WACV)
    586         typeSel = wx.ComboBox(parent=G2frame.dataDisplay,value=typeDict[data['type']],choices=typeList,
     580        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Type of image data: '),0,WACV)
     581        typeSel = wx.ComboBox(parent=G2frame.dataWindow,value=typeDict[data['type']],choices=typeList,
    587582            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    588583        typeSel.SetValue(data['type'])
    589584        typeSel.Bind(wx.EVT_COMBOBOX, OnDataType)
    590585        comboSizer.Add(typeSel,0,WACV)
    591         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Color bar '),0,WACV)
    592         colSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['color'],choices=colorList,
     586        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Color bar '),0,WACV)
     587        colSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['color'],choices=colorList,
    593588            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    594589        colSel.Bind(wx.EVT_COMBOBOX, OnNewColorBar)
    595590        comboSizer.Add(colSel,0,WACV)
    596         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Azimuth offset '),0,WACV)
    597         azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),
     591        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Azimuth offset '),0,WACV)
     592        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'azmthOff',nDig=(10,2),
    598593            typeHint=float,OnLeave=OnAzmthOff)
    599594        comboSizer.Add(azmthOff,0,WACV)
     
    712707        maxSizer = wx.GridBagSizer(0,0)
    713708        r = c = 0
    714         maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max intensity'),(r,c))
     709        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Max intensity'),(r,c))
    715710        c += 1
    716711        # maxSel is a slider with 101 steps scaled from Imin+1 to Imax0 with sqrt scaling
     
    720715        sqrtDeltOne  = math.sqrt(max(1.0,Range[1][1]-max(0.0,Range[1][0])-1)) # sqrt(Imax-Imin-1)
    721716        sv1 = min(100,max(0,int(0.5+100.*sqrtDeltOne/sqrtDeltZero)))
    722         maxSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
     717        maxSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
    723718        maxSizer.Add(maxSel,(r,c),flag=wx.EXPAND)
    724719        maxSizer.AddGrowableCol(c)
    725720        c += 1
    726721        maxSel.Bind(wx.EVT_SLIDER, OnMaxSlider)
    727         maxVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],1,min=Range[0][0]+1,
     722        maxVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],1,min=Range[0][0]+1,
    728723            max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
    729724        maxSizer.Add(maxVal,(r,c))
    730725        c += 1
    731726        scaleChoices = ("100%","99%","95%","90%","80%","?")
    732         scaleSel = wx.Choice(G2frame.dataDisplay,choices=scaleChoices,size=(-1,-1))
     727        scaleSel = wx.Choice(G2frame.dataWindow,choices=scaleChoices,size=(-1,-1))
    733728        if (Range[1][0] == Range[0][0] and
    734729            Range[1][1] == Range[0][1]):
     
    740735        c = 0
    741736        r = 1
    742         maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min intensity'),(r,c))
     737        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min intensity'),(r,c))
    743738        c += 1
    744739        # minSel is a slider with 101 steps scaled from Imin0 to Imax-1 with linear scaling
     
    747742        DeltOne  = max(1.0,Range[1][1]-max(0.0,Range[0][0])-1) # Imax-Imin0-1
    748743        sv0 = min(100,max(0,int(0.5+100.*(Range[1][0]-Range[0][0])/DeltOne)))
    749         minSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
     744        minSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
    750745        maxSizer.Add(minSel,(r,c),flag=wx.EXPAND|wx.ALL)
    751746        c += 1
    752747        minSel.Bind(wx.EVT_SLIDER, OnMinSlider)
    753         minVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],0,
     748        minVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],0,
    754749            max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
    755750        maxSizer.Add(minVal,(r,c))
     
    765760        calibSizer = wx.FlexGridSizer(0,2,5,5)
    766761        calibSizer.SetFlexibleDirection(wx.HORIZONTAL)
    767         calibSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration coefficients'),0,WACV)   
     762        calibSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calibration coefficients'),0,WACV)   
    768763        calibSizer.Add((5,0),0)
    769764        Names = ['det-X','det-Y','wave','dist','tilt','phi']
     
    775770            'wave':['Wavelength',(10,6),data,'wavelength']}
    776771        for name in Names:
    777             calSel = wx.CheckBox(parent=G2frame.dataDisplay,label=Parms[name][0])
     772            calSel = wx.CheckBox(parent=G2frame.dataWindow,label=Parms[name][0])
    778773            calibSizer.Add(calSel,0,WACV)
    779774            calSel.Bind(wx.EVT_CHECKBOX, OnCalRef)
     
    781776            Indx[calSel] = name
    782777            if name == 'wave':
    783                 calVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Parms[name][2],
     778                calVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Parms[name][2],
    784779                    Parms[name][3],min=0.01,max=10.,nDig=Parms[name][1],typeHint=float)
    785780            elif name == 'dep':
    786                 calVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Parms[name][2],
     781                calVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Parms[name][2],
    787782                    Parms[name][3],min=0.0,max=0.2,nDig=Parms[name][1],typeHint=float)
    788783            else:
    789                 calVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Parms[name][2],
     784                calVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Parms[name][2],
    790785                    Parms[name][3],nDig=Parms[name][1],typeHint=float)
    791786            calibSizer.Add(calVal,0,WACV)
     
    871866               
    872867        dataSizer = wx.FlexGridSizer(0,2,5,3)
    873         dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Integration coefficients'),0,WACV)   
     868        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Integration coefficients'),0,WACV)   
    874869        dataSizer.Add((5,0),0)
    875870        if 'PWDR' in data['type']:
     
    877872        elif 'SASD' in data['type']:
    878873            binChoice = ['2-theta','Q','log(q)']
    879         dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Bin style: Constant step bins in'),0,WACV)           
    880         binSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['binType'],choices=binChoice,
     874        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Bin style: Constant step bins in'),0,WACV)           
     875        binSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['binType'],choices=binChoice,
    881876            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    882877        binSel.Bind(wx.EVT_COMBOBOX, OnNewBinType)
     
    885880        if 'q' in data['binType'].lower():
    886881            binType = 'Q'
    887         dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Inner/Outer '+binType),0,WACV)           
     882        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Inner/Outer '+binType),0,WACV)           
    888883        IOtth = data['IOtth'][:]
    889884        if 'q' in data['binType'].lower():
     
    891886            IOtth = [4.*math.pi*sind(IOtth[0]/2.)/wave,4.*math.pi*sind(IOtth[1]/2.)/wave]
    892887        littleSizer = wx.BoxSizer(wx.HORIZONTAL)
    893         G2frame.InnerTth = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,IOtth,0,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
     888        G2frame.InnerTth = G2G.ValidatedTxtCtrl(G2frame.dataWindow,IOtth,0,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
    894889        littleSizer.Add(G2frame.InnerTth,0,WACV)
    895         G2frame.OuterTth = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,IOtth,1,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
     890        G2frame.OuterTth = G2G.ValidatedTxtCtrl(G2frame.dataWindow,IOtth,1,nDig=(8,3,'f'),min=0.001,typeHint=float,OnLeave=OnIOtth)
    896891        littleSizer.Add(G2frame.OuterTth,0,WACV)
    897892        dataSizer.Add(littleSizer,0,)
    898         dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start/End azimuth'),0,WACV)
     893        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Start/End azimuth'),0,WACV)
    899894        LRazim = data['LRazimuth']
    900895        littleSizer = wx.BoxSizer(wx.HORIZONTAL)
    901         G2frame.Lazim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,LRazim,0,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
     896        G2frame.Lazim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,LRazim,0,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
    902897        littleSizer.Add(G2frame.Lazim,0,WACV)
    903         G2frame.Razim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,LRazim,1,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
     898        G2frame.Razim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,LRazim,1,nDig=(6,1,'f'),typeHint=float,OnLeave=OnLRazim)
    904899        if data['fullIntegrate']:
    905900            G2frame.Razim.Enable(False)
     
    908903        littleSizer.Add(G2frame.Razim,0,WACV)
    909904        dataSizer.Add(littleSizer,0,)
    910         dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' No. 2-theta/azimuth bins'),0,WACV)
     905        dataSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' No. 2-theta/azimuth bins'),0,WACV)
    911906        littleSizer = wx.BoxSizer(wx.HORIZONTAL)
    912         outChan = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'outChannels',typeHint=int,min=10)
     907        outChan = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'outChannels',typeHint=int,min=10)
    913908        littleSizer.Add(outChan,0,WACV)
    914         outAzim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'outAzimuths',nDig=(10,4),min=1,typeHint=int,OnLeave=OnNumOutAzms)
     909        outAzim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'outAzimuths',nDig=(10,4),min=1,typeHint=int,OnLeave=OnNumOutAzms)
    915910        littleSizer.Add(outAzim,0,WACV)
    916911        dataSizer.Add(littleSizer,0,)
    917912        samplechoice = ['Cylinder','Fixed flat plate',]
    918         dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Select sample shape'),0,WACV)
    919         samShape = wx.ComboBox(G2frame.dataDisplay,value=data['SampleShape'],choices=samplechoice,
     913        dataSizer.Add(wx.StaticText(G2frame.dataWindow,label='Select sample shape'),0,WACV)
     914        samShape = wx.ComboBox(G2frame.dataWindow,value=data['SampleShape'],choices=samplechoice,
    920915            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    921916        samShape.Bind(wx.EVT_COMBOBOX,OnSampleShape)
     
    923918        #SampleShape - cylinder or flat plate choice?
    924919        littleSizer = wx.BoxSizer(wx.HORIZONTAL)
    925         samabs = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply sample absorption?')
     920        samabs = wx.CheckBox(parent=G2frame.dataWindow,label='Apply sample absorption?')
    926921        dataSizer.Add(samabs,0,WACV)
    927922        samabs.Bind(wx.EVT_CHECKBOX, OnSamAbs)
     
    929924        minmax = [0.,2.]
    930925        if 'Cylind' in data['SampleShape']: #cylinder mu*R; flat plate transmission
    931             littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='mu*R (0.00-2.0) '),0,WACV)
     926            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='mu*R (0.00-2.0) '),0,WACV)
    932927        elif 'Fixed' in data['SampleShape']:
    933             littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='transmission '),0,WACV) #for flat plate
     928            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='transmission '),0,WACV) #for flat plate
    934929            minmax = [.05,1.0]
    935         samabsVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['SampleAbs'],0,nDig=(10,3),
     930        samabsVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['SampleAbs'],0,nDig=(10,3),
    936931            typeHint=float,min=minmax[0],max=minmax[1])
    937932        littleSizer.Add(samabsVal,0,WACV)
     
    939934        if 'PWDR' in data['type']:
    940935            littleSizer = wx.BoxSizer(wx.HORIZONTAL)
    941             oblique = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply detector absorption?')
     936            oblique = wx.CheckBox(parent=G2frame.dataWindow,label='Apply detector absorption?')
    942937            dataSizer.Add(oblique,0,WACV)
    943938            oblique.Bind(wx.EVT_CHECKBOX, OnOblique)
    944939            oblique.SetValue(data['Oblique'][1])
    945             littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Value (0.01-0.99)  '),0,WACV)
    946             obliqVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Oblique'],0,nDig=(10,3),typeHint=float,min=0.01,max=0.99)
     940            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='Value (0.01-0.99)  '),0,WACV)
     941            obliqVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Oblique'],0,nDig=(10,3),typeHint=float,min=0.01,max=0.99)
    947942            littleSizer.Add(obliqVal,0,WACV)
    948943            dataSizer.Add(littleSizer,0,)
    949944        if 'SASD' in data['type']:
    950945            littleSizer = wx.BoxSizer(wx.HORIZONTAL)
    951             setPolariz = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply polarization?')
     946            setPolariz = wx.CheckBox(parent=G2frame.dataWindow,label='Apply polarization?')
    952947            dataSizer.Add(setPolariz,0,WACV)
    953948            setPolariz.Bind(wx.EVT_CHECKBOX, OnApplyPola)
    954949            setPolariz.SetValue(data['PolaVal'][1])
    955             littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Value (0.001-0.999)  '),0,WACV)
    956             polaVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['PolaVal'],0,nDig=(10,3),typeHint=float,min=0.001,max=0.999)
     950            littleSizer.Add(wx.StaticText(G2frame.dataWindow,label='Value (0.001-0.999)  '),0,WACV)
     951            polaVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['PolaVal'],0,nDig=(10,3),typeHint=float,min=0.001,max=0.999)
    957952            littleSizer.Add(polaVal,0,WACV)
    958953            dataSizer.Add(littleSizer,0,)
    959954       
    960         showLines = wx.CheckBox(parent=G2frame.dataDisplay,label='Show integration limits?')
     955        showLines = wx.CheckBox(parent=G2frame.dataWindow,label='Show integration limits?')
    961956        dataSizer.Add(showLines,0,WACV)
    962957        showLines.Bind(wx.EVT_CHECKBOX, OnShowLines)
    963958        showLines.SetValue(data['showLines'])
    964         fullIntegrate = wx.CheckBox(parent=G2frame.dataDisplay,label='Do full integration?')
     959        fullIntegrate = wx.CheckBox(parent=G2frame.dataWindow,label='Do full integration?')
    965960        dataSizer.Add(fullIntegrate,0,WACV)
    966961        fullIntegrate.Bind(wx.EVT_CHECKBOX, OnFullIntegrate)
    967962        fullIntegrate.SetValue(data['fullIntegrate'])
    968         setDefault = wx.CheckBox(parent=G2frame.dataDisplay,label='Use for all new images?')
     963        setDefault = wx.CheckBox(parent=G2frame.dataWindow,label='Use for all new images?')
    969964        dataSizer.Add(setDefault,0,WACV)
    970965        setDefault.Bind(wx.EVT_CHECKBOX, OnSetDefault)
    971966        setDefault.SetValue(data['setDefault'])
    972         centerAzm = wx.CheckBox(parent=G2frame.dataDisplay,label='Azimuth at bin center?')
     967        centerAzm = wx.CheckBox(parent=G2frame.dataWindow,label='Azimuth at bin center?')
    973968        dataSizer.Add(centerAzm,0,WACV)
    974969        centerAzm.Bind(wx.EVT_CHECKBOX, OnCenterAzm)
     
    10061001        oldFlat = data.get('Flat Bkg',0.)
    10071002
    1008         backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Dark image'),0,WACV)
     1003        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Dark image'),0,WACV)
    10091004        Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
    10101005        Source = G2frame.PatternTree.GetItemText(G2frame.Image)
    10111006        Choices.pop(Choices.index(Source))
    1012         darkImage = wx.ComboBox(parent=G2frame.dataDisplay,value=data['dark image'][0],choices=Choices,
     1007        darkImage = wx.ComboBox(parent=G2frame.dataWindow,value=data['dark image'][0],choices=Choices,
    10131008            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    10141009        darkImage.Bind(wx.EVT_COMBOBOX,OnDarkImage)
    10151010        backSizer.Add(darkImage)
    1016         backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' multiplier'),0,WACV)
    1017         darkMult = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['dark image'],1,nDig=(10,3),
     1011        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' multiplier'),0,WACV)
     1012        darkMult = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['dark image'],1,nDig=(10,3),
    10181013            typeHint=float,OnLeave=OnMult)
    10191014        backSizer.Add(darkMult,0,WACV)
    1020         backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Flat Bkg: '),0,WACV)
    1021         flatbkg = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Flat Bkg',nDig=(10,0),
     1015        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Flat Bkg: '),0,WACV)
     1016        flatbkg = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Flat Bkg',nDig=(10,0),
    10221017            typeHint=float,OnLeave=OnFlatBkg)
    10231018        backSizer.Add(flatbkg,0,WACV)
    10241019
    1025         backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background image'),0,WACV)
    1026         backImage = wx.ComboBox(parent=G2frame.dataDisplay,value=data['background image'][0],choices=Choices,
     1020        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background image'),0,WACV)
     1021        backImage = wx.ComboBox(parent=G2frame.dataWindow,value=data['background image'][0],choices=Choices,
    10271022            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    10281023        backImage.Bind(wx.EVT_COMBOBOX,OnBackImage)
    10291024        backSizer.Add(backImage)
    1030         backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' multiplier'),0,WACV)
    1031         backMult = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['background image'],1,nDig=(10,3),
     1025        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' multiplier'),0,WACV)
     1026        backMult = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['background image'],1,nDig=(10,3),
    10321027            typeHint=float,OnLeave=OnMult)
    10331028        backSizer.Add(backMult,0,WACV)
     
    10661061        calibSizer = wx.FlexGridSizer(0,3,5,5)
    10671062        comboSizer = wx.BoxSizer(wx.HORIZONTAL)   
    1068         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibrant '),0,WACV)
    1069         calSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['calibrant'],choices=calList,
     1063        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calibrant '),0,WACV)
     1064        calSel = wx.ComboBox(parent=G2frame.dataWindow,value=data['calibrant'],choices=calList,
    10701065            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    10711066        calSel.Bind(wx.EVT_COMBOBOX, OnNewCalibrant)
     
    10741069       
    10751070        comboSizer = wx.BoxSizer(wx.HORIZONTAL)   
    1076         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calib lines to skip   '),0,WACV)
    1077         calibSkip  = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['calibskip']),choices=[str(i) for i in range(25)],
     1071        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calib lines to skip   '),0,WACV)
     1072        calibSkip  = wx.ComboBox(parent=G2frame.dataWindow,value=str(data['calibskip']),choices=[str(i) for i in range(25)],
    10781073            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    10791074        calibSkip.Bind(wx.EVT_COMBOBOX, OnCalibSkip)
     
    10821077       
    10831078        comboSizer = wx.BoxSizer(wx.HORIZONTAL)       
    1084         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min calib d-spacing '),0,WACV)
    1085         G2frame.calibDmin = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'calibdmin',nDig=(10,2),typeHint=float,min=0.25)
     1079        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min calib d-spacing '),0,WACV)
     1080        G2frame.calibDmin = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'calibdmin',nDig=(10,2),typeHint=float,min=0.25)
    10861081        comboSizer.Add(G2frame.calibDmin,0,WACV)
    10871082        calibSizer.Add(comboSizer,0)
    10881083       
    10891084        comboSizer = wx.BoxSizer(wx.HORIZONTAL)
    1090         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min ring I/Ib '),0,WACV)
    1091         cutOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'cutoff',nDig=(10,2),min=0.1)
     1085        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min ring I/Ib '),0,WACV)
     1086        cutOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'cutoff',nDig=(10,2),min=0.1)
    10921087        comboSizer.Add(cutOff,0,WACV)
    10931088        calibSizer.Add(comboSizer,0)
    10941089       
    10951090        comboSizer = wx.BoxSizer(wx.HORIZONTAL)
    1096         comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Pixel search range '),0,WACV)
    1097         pixLimit = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['pixLimit']),choices=['1','2','5','10','15','20'],
     1091        comboSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Pixel search range '),0,WACV)
     1092        pixLimit = wx.ComboBox(parent=G2frame.dataWindow,value=str(data['pixLimit']),choices=['1','2','5','10','15','20'],
    10981093            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    10991094        pixLimit.Bind(wx.EVT_COMBOBOX, OnPixLimit)
     
    11021097       
    11031098        comboSizer = wx.BoxSizer(wx.HORIZONTAL)
    1104         setRings = wx.CheckBox(parent=G2frame.dataDisplay,label='Show ring picks?')
     1099        setRings = wx.CheckBox(parent=G2frame.dataWindow,label='Show ring picks?')
    11051100        comboSizer.Add(setRings,0)
    11061101        setRings.Bind(wx.EVT_CHECKBOX, OnSetRings)
     
    11441139        gonioSizer = wx.BoxSizer(wx.HORIZONTAL)
    11451140        names = ['Omega','Chi','Phi']
    1146         gonioSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'Sample goniometer angles: '),0,WACV)
     1141        gonioSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'Sample goniometer angles: '),0,WACV)
    11471142        for i,name in enumerate(names):
    1148             gonioSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,name),0,WACV)
    1149             angle = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['GonioAngles'],i,nDig=(8,2),typeHint=float)
     1143            gonioSizer.Add(wx.StaticText(G2frame.dataWindow,-1,name),0,WACV)
     1144            angle = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['GonioAngles'],i,nDig=(8,2),typeHint=float)
    11501145            gonioSizer.Add(angle,0,WACV)
    1151         globEdit = wx.Button(G2frame.dataDisplay,-1,'Global edit')
     1146        globEdit = wx.Button(G2frame.dataWindow,-1,'Global edit')
    11521147        globEdit.Bind(wx.EVT_BUTTON,OnGlobalEdit)
    11531148        gonioSizer.Add(globEdit,0,WACV)
     
    11811176        data['type'] = 'PWDR'
    11821177    typeDict = {'PWDR':typeList[0],'SASD':typeList[1],}
    1183     if G2frame.dataDisplay:
    1184         G2frame.dataDisplay.Destroy()
    1185     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ImageMenu)
    1186     if not G2frame.dataFrame.GetStatusBar():
    1187         G2frame.dataFrame.CreateStatusBar()
    1188     G2frame.dataFrame.Bind(wx.EVT_MENU, OnCalibrate, id=G2gd.wxID_IMCALIBRATE)
    1189     G2frame.dataFrame.Bind(wx.EVT_MENU, OnRecalibrate, id=G2gd.wxID_IMRECALIBRATE)
    1190     G2frame.dataFrame.Bind(wx.EVT_MENU, OnRecalibAll, id=G2gd.wxID_IMRECALIBALL)
    1191     G2frame.dataFrame.Bind(wx.EVT_MENU, OnClearCalib, id=G2gd.wxID_IMCLEARCALIB)
     1178    G2frame.dataWindow.ClearData()
     1179    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ImageMenu)
     1180    G2frame.Bind(wx.EVT_MENU, OnCalibrate, id=G2gd.wxID_IMCALIBRATE)
     1181    G2frame.Bind(wx.EVT_MENU, OnRecalibrate, id=G2gd.wxID_IMRECALIBRATE)
     1182    G2frame.Bind(wx.EVT_MENU, OnRecalibAll, id=G2gd.wxID_IMRECALIBALL)
     1183    G2frame.Bind(wx.EVT_MENU, OnClearCalib, id=G2gd.wxID_IMCLEARCALIB)
    11921184    if data.get('calibrant'):
    11931185        mode = True
    11941186    else:
    11951187        mode = False
    1196     G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=mode)
    1197     G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMCALIBRATE,enable=mode)
    1198     G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBALL,enable=mode)
    1199     G2frame.dataFrame.Bind(wx.EVT_MENU, OnIntegrate, id=G2gd.wxID_IMINTEGRATE)
    1200     G2frame.dataFrame.Bind(wx.EVT_MENU, OnIntegrateAll, id=G2gd.wxID_INTEGRATEALL)
    1201     G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyControls, id=G2gd.wxID_IMCOPYCONTROLS)
    1202     G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopySelected, id=G2gd.wxID_IMCOPYSELECTED)
    1203     G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveControls, id=G2gd.wxID_IMSAVECONTROLS)
    1204     G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveMultiControls, id=G2gd.wxID_SAVESELECTEDCONTROLS)
    1205     G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadControls, id=G2gd.wxID_IMLOADCONTROLS)
    1206     G2frame.dataFrame.Bind(wx.EVT_MENU, OnTransferAngles, id=G2gd.wxID_IMXFERCONTROLS)
    1207     G2frame.dataFrame.Bind(wx.EVT_MENU, OnResetDist, id=G2gd.wxID_IMRESETDIST)
     1188#    G2frame.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=mode)
     1189#    G2frame.Enable(id=G2gd.wxID_IMCALIBRATE,enable=mode)
     1190#    G2frame.Enable(id=G2gd.wxID_IMRECALIBALL,enable=mode)
     1191    G2frame.Bind(wx.EVT_MENU, OnIntegrate, id=G2gd.wxID_IMINTEGRATE)
     1192    G2frame.Bind(wx.EVT_MENU, OnIntegrateAll, id=G2gd.wxID_INTEGRATEALL)
     1193    G2frame.Bind(wx.EVT_MENU, OnCopyControls, id=G2gd.wxID_IMCOPYCONTROLS)
     1194    G2frame.Bind(wx.EVT_MENU, OnCopySelected, id=G2gd.wxID_IMCOPYSELECTED)
     1195    G2frame.Bind(wx.EVT_MENU, OnSaveControls, id=G2gd.wxID_IMSAVECONTROLS)
     1196    G2frame.Bind(wx.EVT_MENU, OnSaveMultiControls, id=G2gd.wxID_SAVESELECTEDCONTROLS)
     1197    G2frame.Bind(wx.EVT_MENU, OnLoadControls, id=G2gd.wxID_IMLOADCONTROLS)
     1198    G2frame.Bind(wx.EVT_MENU, OnTransferAngles, id=G2gd.wxID_IMXFERCONTROLS)
     1199    G2frame.Bind(wx.EVT_MENU, OnResetDist, id=G2gd.wxID_IMRESETDIST)
    12081200    def OnDestroy(event):
    12091201        G2frame.autoIntFrame = None
     
    12161208        G2frame.autoIntFrame.Bind(wx.EVT_WINDOW_DESTROY,OnDestroy) # clean up name on window close
    12171209    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAutoInt, id=G2gd.wxID_IMAUTOINTEG)
    1218     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
    12191210
    12201211    mainSizer = wx.BoxSizer(wx.VERTICAL)
     
    12331224    mainSizer.Add((5,5),0)           
    12341225    mainSizer.Add(BackSizer(),0)
    1235     mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration controls:'),0,WACV)
     1226    mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Calibration controls:'),0,WACV)
    12361227    mainSizer.Add((5,5),0)
    12371228    mainSizer.Add(CalibSizer(),0,WACV)
     
    12401231       
    12411232    mainSizer.Layout()   
    1242     G2frame.dataDisplay.SetSizer(mainSizer)
    1243     fitSize = mainSizer.Fit(G2frame.dataFrame)
    1244     G2frame.dataFrame.setSizePosLeft(fitSize)
    1245     G2frame.dataFrame.SendSizeEvent()
     1233    G2frame.dataWindow.SetSizer(mainSizer)
     1234    mainSizer.Fit(G2frame.dataFrame)
     1235    G2frame.SetDataSize()
    12461236   
    12471237################################################################################
     
    13701360    def OnAutoSpotMask(event):
    13711361        'Do auto search for spot masks'
    1372         if wx.MessageDialog(G2frame.dataDisplay,'NB: This will clear any old spot masks',
     1362        if wx.MessageDialog(G2frame.dataWindow,'NB: This will clear any old spot masks',
    13731363            'Auto Spot Masks', wx.OK|wx.CANCEL).ShowModal() == wx.ID_OK:
    13741364            Controls = copy.deepcopy(G2frame.PatternTree.GetItemPyData(
     
    15201510        maxSizer = wx.GridBagSizer(0,0)
    15211511        r = c = 0
    1522         maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max intensity'),(r,c))
     1512        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Max intensity'),(r,c))
    15231513        c += 1
    15241514        # maxSel is a slider with 101 steps scaled from Imin+1 to Imax0 with sqrt scaling
     
    15281518        sqrtDeltOne  = math.sqrt(max(1.0,Range[1][1]-max(0.0,Range[1][0])-1)) # sqrt(Imax-Imin-1)
    15291519        sv1 = min(100,max(0,int(0.5+100.*sqrtDeltOne/sqrtDeltZero)))
    1530         maxSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
     1520        maxSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv1,size=(300,-1))
    15311521        maxSizer.Add(maxSel,(r,c),flag=wx.EXPAND)
    15321522        maxSizer.AddGrowableCol(c)
    15331523        c += 1
    15341524        maxSel.Bind(wx.EVT_SLIDER, OnMaxSlider)
    1535         maxVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],1,min=Range[0][0]+1,
     1525        maxVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],1,min=Range[0][0]+1,
    15361526            max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
    15371527        maxSizer.Add(maxVal,(r,c))
    15381528        c += 1
    15391529        scaleChoices = ("100%","99%","95%","90%","80%","?")
    1540         scaleSel = wx.Choice(G2frame.dataDisplay,choices=scaleChoices,size=(-1,-1))
     1530        scaleSel = wx.Choice(G2frame.dataWindow,choices=scaleChoices,size=(-1,-1))
    15411531        if (Range[1][0] == Range[0][0] and
    15421532            Range[1][1] == Range[0][1]):
     
    15481538        c = 0
    15491539        r = 1
    1550         maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min intensity'),(r,c))
     1540        maxSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Min intensity'),(r,c))
    15511541        c += 1
    15521542        # minSel is a slider with 101 steps scaled from Imin0 to Imax-1 with linear scaling
     
    15551545        DeltOne  = max(1.0,Range[1][1]-max(0.0,Range[0][0])-1) # Imax-Imin0-1
    15561546        sv0 = min(100,max(0,int(0.5+100.*(Range[1][0]-Range[0][0])/DeltOne)))
    1557         minSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
     1547        minSel = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,value=sv0,size=(300,-1))
    15581548        maxSizer.Add(minSel,(r,c),flag=wx.EXPAND|wx.ALL)
    15591549        c += 1
    15601550        minSel.Bind(wx.EVT_SLIDER, OnMinSlider)
    1561         minVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Range[1],0,
     1551        minVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Range[1],0,
    15621552            max=Range[0][1],typeHint=int,OnLeave=OnNewVal)
    15631553        maxSizer.Add(minVal,(r,c))
    15641554        return maxSizer
    15651555
     1556    G2frame.dataWindow.ClearData()
    15661557    startScroll = None
    1567     if G2frame.dataDisplay:
    1568         startScroll = G2frame.dataDisplay.GetScrollPos(wx.VERTICAL) # save scroll position
    1569         G2frame.dataDisplay.Destroy()
     1558    if G2frame.dataWindow:
     1559        startScroll = G2frame.dataWindow.GetScrollPos(wx.VERTICAL) # save scroll position
    15701560    else:
    15711561        CleanupMasks(data) # posting page for 1st time; clean out anything unfinished
    1572     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MaskMenu)
     1562    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MaskMenu)
    15731563    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyMask, id=G2gd.wxID_MASKCOPY)
    15741564    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadMask, id=G2gd.wxID_MASKLOAD)
     
    15821572    G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewPolyMask, id=G2gd.wxID_NEWMASKPOLY)
    15831573    G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewFrameMask, id=G2gd.wxID_NEWMASKFRAME)
    1584     if not G2frame.dataFrame.GetStatusBar():
    1585         G2frame.dataFrame.CreateStatusBar()
    15861574    if G2frame.MaskKey == 'f':
    1587         G2frame.dataFrame.GetStatusBar().SetStatusText('Frame mask active - LB pick next point, RB close polygon')
     1575        G2frame.GetStatusBar().SetStatusText('Frame mask active - LB pick next point, RB close polygon')
    15881576    elif G2frame.MaskKey == 'p':
    1589         G2frame.dataFrame.GetStatusBar().SetStatusText('Polygon mask active - LB pick next point, RB close polygon')
     1577        G2frame.GetStatusBar().SetStatusText('Polygon mask active - LB pick next point, RB close polygon')
    15901578    elif G2frame.MaskKey == 'a':
    1591         G2frame.dataFrame.GetStatusBar().SetStatusText('Arc mask active - LB pick arc location')
     1579        G2frame.GetStatusBar().SetStatusText('Arc mask active - LB pick arc location')
    15921580    elif G2frame.MaskKey == 'r':
    1593         G2frame.dataFrame.GetStatusBar().SetStatusText('Ring mask active - LB pick ring location')
     1581        G2frame.GetStatusBar().SetStatusText('Ring mask active - LB pick ring location')
    15941582    else:
    1595         G2frame.dataFrame.GetStatusBar().SetStatusText("To add mask: press a,r,s,p or f on 2D image for arc/ring/spot/polygon/frame")
    1596     G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
     1583        G2frame.GetStatusBar().SetStatusText("To add mask: press a,r,s,p or f on 2D image for arc/ring/spot/polygon/frame")
    15971584    mainSizer = wx.BoxSizer(wx.VERTICAL)
    15981585    mainSizer.Add((5,10),0)
     
    16151602
    16161603    littleSizer = wx.FlexGridSizer(0,3,0,5)
    1617     littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper limits '),0,WACV)
    1618     Text = wx.TextCtrl(G2frame.dataDisplay,value=str(thresh[0][0]),style=wx.TE_READONLY)
     1604    littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Lower/Upper limits '),0,WACV)
     1605    Text = wx.TextCtrl(G2frame.dataWindow,value=str(thresh[0][0]),style=wx.TE_READONLY)
    16191606    littleSizer.Add(Text,0,WACV)
    16201607    Text.SetBackgroundColour(VERY_LIGHT_GREY)
    1621     Text = wx.TextCtrl(G2frame.dataDisplay,value=str(thresh[0][1]),style=wx.TE_READONLY)
     1608    Text = wx.TextCtrl(G2frame.dataWindow,value=str(thresh[0][1]),style=wx.TE_READONLY)
    16221609    littleSizer.Add(Text,0,WACV)
    16231610    Text.SetBackgroundColour(VERY_LIGHT_GREY)
    1624     littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper thresholds '),0,WACV)
    1625     lowerThreshold = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=thresh[1],key=0,
     1611    littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Lower/Upper thresholds '),0,WACV)
     1612    lowerThreshold = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=thresh[1],key=0,
    16261613        min=thresh[0][0],OnLeave=newReplot,typeHint=int)
    16271614    littleSizer.Add(lowerThreshold,0,WACV)
    1628     upperThreshold = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=thresh[1],key=1,
     1615    upperThreshold = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=thresh[1],key=1,
    16291616        max=thresh[0][1],OnLeave=newReplot,typeHint=int)
    16301617    littleSizer.Add(upperThreshold,0,WACV)
    16311618    mainSizer.Add(littleSizer,0,)
    16321619    if len(Spots):
    1633         lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Spot masks')
     1620        lbl = wx.StaticText(parent=G2frame.dataWindow,label=' Spot masks')
    16341621        lbl.SetBackgroundColour(wx.Colour(200,200,210))
    16351622        mainSizer.Add(lbl,0,wx.EXPAND|wx.ALIGN_CENTER,0)
    16361623        littleSizer = wx.FlexGridSizer(0,3,0,5)
    1637         littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' position, mm'),0,WACV)
    1638         littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' diameter, mm'),0,WACV)
     1624        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' position, mm'),0,WACV)
     1625        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' diameter, mm'),0,WACV)
    16391626        littleSizer.Add((5,0),0)
    16401627        for i in range(len(Spots)):
    16411628            if len(Spots[i]):
    16421629                x,y,d = Spots[i]
    1643                 spotText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f,%.2f" % (x,y)),
     1630                spotText = wx.TextCtrl(parent=G2frame.dataWindow,value=("%.2f,%.2f" % (x,y)),
    16441631                    style=wx.TE_READONLY)
    16451632                spotText.SetBackgroundColour(VERY_LIGHT_GREY)
    16461633                littleSizer.Add(spotText,0,WACV)
    16471634                spotText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
    1648                 spotDiameter = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Spots[i],key=2,
     1635                spotDiameter = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=Spots[i],key=2,
    16491636                    max=100.,OnLeave=Replot,nDig=[8,2])
    16501637                littleSizer.Add(spotDiameter,0,WACV)
    1651                 spotDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
     1638                spotDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
    16521639                    locationcode='Delete+Points+'+str(i),handler=onDeleteMask)
    16531640                littleSizer.Add(spotDelete,0,WACV)
    16541641        mainSizer.Add(littleSizer,0,)
    16551642    if Rings:
    1656         lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Ring masks')
     1643        lbl = wx.StaticText(parent=G2frame.dataWindow,label=' Ring masks')
    16571644        lbl.SetBackgroundColour(wx.Colour(200,200,210))
    16581645        mainSizer.Add(lbl,0,wx.EXPAND|wx.ALIGN_CENTER,0)
    16591646        littleSizer = wx.FlexGridSizer(0,3,0,5)
    1660         littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,WACV)
    1661         littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,WACV)
     1647        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' 2-theta,deg'),0,WACV)
     1648        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' thickness, deg'),0,WACV)
    16621649        littleSizer.Add((5,0),0)
    16631650        for i in range(len(Rings)):
    16641651            if Rings[i]:
    1665                 ringText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (Rings[i][0])),
     1652                ringText = wx.TextCtrl(parent=G2frame.dataWindow,value=("%.3f" % (Rings[i][0])),
    16661653                    style=wx.TE_READONLY)
    16671654                ringText.SetBackgroundColour(VERY_LIGHT_GREY)
    16681655                ringText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
    16691656                littleSizer.Add(ringText,0,WACV)
    1670                 ringThick = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Rings[i],key=1,
     1657                ringThick = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=Rings[i],key=1,
    16711658                    min=0.001,max=1.,OnLeave=Replot,nDig=[8,3])
    16721659                littleSizer.Add(ringThick,0,WACV)
    1673                 ringDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
     1660                ringDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
    16741661                    locationcode='Delete+Rings+'+str(i),handler=onDeleteMask)
    16751662                littleSizer.Add(ringDelete,0,WACV)
    16761663        mainSizer.Add(littleSizer,0,)
    16771664    if Arcs:
    1678         lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Arc masks')
     1665        lbl = wx.StaticText(parent=G2frame.dataWindow,label=' Arc masks')
    16791666        lbl.SetBackgroundColour(wx.Colour(200,200,210))
    16801667        mainSizer.Add(lbl,0,wx.EXPAND|wx.ALIGN_CENTER,0)
    16811668        littleSizer = wx.FlexGridSizer(0,4,0,5)
    1682         littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,WACV)
    1683         littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' azimuth, deg'),0,WACV)
    1684         littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,WACV)
     1669        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' 2-theta,deg'),0,WACV)
     1670        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' azimuth, deg'),0,WACV)
     1671        littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' thickness, deg'),0,WACV)
    16851672        littleSizer.Add((5,0),0)
    16861673        for i in range(len(Arcs)):
    16871674            if Arcs[i]:
    16881675                tth,azimuth,thick = Arcs[i]
    1689                 arcText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (tth)),
     1676                arcText = wx.TextCtrl(parent=G2frame.dataWindow,value=("%.3f" % (tth)),
    16901677                    style=wx.TE_READONLY)
    16911678                arcText.SetBackgroundColour(VERY_LIGHT_GREY)
    16921679                arcText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
    16931680                littleSizer.Add(arcText,0,WACV)
    1694                 azmText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%d,%d" % (azimuth[0],azimuth[1])),
     1681                azmText = wx.TextCtrl(parent=G2frame.dataWindow,value=("%d,%d" % (azimuth[0],azimuth[1])),
    16951682                    style=wx.TE_READONLY)
    16961683                azmText.SetBackgroundColour(VERY_LIGHT_GREY)
    16971684                azmText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
    16981685                littleSizer.Add(azmText,0,WACV)
    1699                 arcThick = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Arcs[i],key=2,
     1686                arcThick = G2G.ValidatedTxtCtrl(G2frame.dataWindow,loc=Arcs[i],key=2,
    17001687                    min=0.001,max=20.,OnLeave=Replot,nDig=[8,3])
    17011688                littleSizer.Add(arcThick,0,WACV)
    1702                 arcDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
     1689                arcDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
    17031690                    locationcode='Delete+Arcs+'+str(i),handler=onDeleteMask)
    17041691                littleSizer.Add(arcDelete,0,WACV)
    17051692        mainSizer.Add(littleSizer,0,)
    17061693    if Polygons:
    1707         lbl = wx.StaticText(parent=G2frame.dataDisplay,
     1694        lbl = wx.StaticText(parent=G2frame.dataWindow,
    17081695            label=' Polygon masks (on plot RB vertex drag to move, LB vertex drag to insert)')
    17091696        lbl.SetBackgroundColour(wx.Colour(200,200,210))
     
    17151702                for x,y in Polygons[i]:
    17161703                    polyList.append("%.2f, %.2f"%(x,y))
    1717                 polyText = wx.ComboBox(G2frame.dataDisplay,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
     1704                polyText = wx.ComboBox(G2frame.dataWindow,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
    17181705                littleSizer.Add(polyText,0,WACV)
    1719                 polyDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
     1706                polyDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
    17201707                    locationcode='Delete+Polygons+'+str(i),handler=onDeleteMask)
    17211708                littleSizer.Add(polyDelete,0,WACV)
    17221709        mainSizer.Add(littleSizer,0,)
    17231710    if frame:
    1724         lbl = wx.StaticText(parent=G2frame.dataDisplay,
     1711        lbl = wx.StaticText(parent=G2frame.dataWindow,
    17251712            label=' Frame mask (on plot RB vertex drag to move, LB vertex drag to insert)')
    17261713        lbl.SetBackgroundColour(wx.Colour(200,200,210))
     
    17301717        for x,y in frame:
    17311718            frameList.append("%.2f, %.2f"%(x,y))
    1732         frameText = wx.ComboBox(G2frame.dataDisplay,value=frameList[0],choices=frameList,style=wx.CB_READONLY)
     1719        frameText = wx.ComboBox(G2frame.dataWindow,value=frameList[0],choices=frameList,style=wx.CB_READONLY)
    17331720        littleSizer.Add(frameText,0,WACV)
    1734         frameDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
     1721        frameDelete = G2G.G2LoggedButton(G2frame.dataWindow,label='delete?',
    17351722            locationcode='Delete+Frame',handler=onDeleteFrame)
    17361723        littleSizer.Add(frameDelete,0,WACV)
    17371724        mainSizer.Add(littleSizer,0,)
    17381725    mainSizer.Layout()   
    1739     G2frame.dataDisplay.SetSizer(mainSizer)
    1740     G2frame.dataDisplay.SetupScrolling()
    1741     Size = mainSizer.Fit(G2frame.dataFrame)
    1742     Size[0] += 50 # room for scrollbar & status msg
    1743     Size[1] = min(Size[1],500)
    1744     G2frame.dataFrame.setSizePosLeft(Size)   
     1726    G2frame.dataWindow.SetSizer(mainSizer)
     1727    mainSizer.Fit(G2frame.dataFrame)
     1728    G2frame.SetDataSize()
    17451729    if startScroll: # reset scroll to saved position
    1746         G2frame.dataDisplay.Scroll(0,startScroll) # set to saved scroll position
     1730        G2frame.dataWindow.Scroll(0,startScroll) # set to saved scroll position
    17471731        wx.Yield()
    17481732
     
    20512035       
    20522036        samSizer = wx.BoxSizer(wx.HORIZONTAL)
    2053         samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Strain type: '),0,WACV)
    2054         strType = wx.ComboBox(G2frame.dataDisplay,value=data['Type'],choices=['True','Conventional'],
     2037        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Strain type: '),0,WACV)
     2038        strType = wx.ComboBox(G2frame.dataWindow,value=data['Type'],choices=['True','Conventional'],
    20552039            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    20562040        strType.SetValue(data['Type'])
     
    20582042        samSizer.Add(strType,0,WACV)
    20592043       
    2060         samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample phi: '),0,WACV)
    2061         samPhi = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Sample phi',nDig=(10,3),typeHint=float,min=-360.,max=360.)
     2044        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Sample phi: '),0,WACV)
     2045        samPhi = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Sample phi',nDig=(10,3),typeHint=float,min=-360.,max=360.)
    20622046        samSizer.Add(samPhi,0,WACV)
    2063         samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample delta-z(mm): '),0,WACV)
    2064         samZ = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Sample z',nDig=(10,3),typeHint=float)
     2047        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Sample delta-z(mm): '),0,WACV)
     2048        samZ = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Sample z',nDig=(10,3),typeHint=float)
    20652049        samSizer.Add(samZ,0,WACV)
    2066         samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample load(MPa): '),0,WACV)
    2067         samLoad = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Sample load',
     2050        samSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=' Sample load(MPa): '),0,WACV)
     2051        samLoad = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Sample load',
    20682052                nDig=[8,3],typeHint=float,)
    20692053        samSizer.Add(samLoad,0,WACV)
     
    21122096        dzeroSizer = wx.FlexGridSizer(0,8,5,5)
    21132097        for id,dzero in enumerate(data['d-zero']):
    2114             dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' d-zero #%d: '%(id))),0,WACV)
    2115             dZero = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['d-zero'][id],'Dset',
     2098            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=(' d-zero #%d: '%(id))),0,WACV)
     2099            dZero = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['d-zero'][id],'Dset',
    21162100                min=0.25,max=20.,nDig=(10,5),typeHint=float,OnLeave=OnDzero)
    21172101            dzeroSizer.Add(dZero,0,WACV)
    21182102            Indx[dZero.GetId()] = id
    2119             dfix = wx.CheckBox(G2frame.dataDisplay,label='Use Poisson mean?')
     2103            dfix = wx.CheckBox(G2frame.dataWindow,label='Use Poisson mean?')
    21202104            dfix.SetValue(dzero.get('fixDset',False))
    21212105            dfix.Bind(wx.EVT_CHECKBOX,OnFixDset)
    21222106            Indx[dfix.GetId()] = id
    21232107            dzeroSizer.Add(dfix,0,WACV)
    2124             dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' d-zero ave: %.5f'%(dzero['Dcalc']))),0,WACV)
     2108            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=(' d-zero ave: %.5f'%(dzero['Dcalc']))),0,WACV)
    21252109               
    2126             dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min ring I/Ib '),0,WACV)
    2127             cutOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['d-zero'][id],'cutoff',
     2110            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Min ring I/Ib '),0,WACV)
     2111            cutOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['d-zero'][id],'cutoff',
    21282112                    min=0.5,max=20.,nDig=(10,1),typeHint=float,OnLeave=OnCutOff)
    21292113            Indx[cutOff.GetId()] = id
    21302114            dzeroSizer.Add(cutOff,0,WACV)
    21312115       
    2132             dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Pixel search range '),0,WACV)
    2133             pixLimit = wx.ComboBox(parent=G2frame.dataDisplay,value=str(dzero['pixLimit']),choices=['1','2','5','10','15','20'],
     2116            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Pixel search range '),0,WACV)
     2117            pixLimit = wx.ComboBox(parent=G2frame.dataWindow,value=str(dzero['pixLimit']),choices=['1','2','5','10','15','20'],
    21342118                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    21352119            pixLimit.Bind(wx.EVT_COMBOBOX, OnPixLimit)
     
    21372121            dzeroSizer.Add(pixLimit,0,WACV)               
    21382122               
    2139             dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' Strain tensor:')),WACV)
     2123            dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=(' Strain tensor:')),WACV)
    21402124            names = ['e11','e12','e22']
    21412125            for i in range(3):
    2142                 dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=names[i]),0,WACV)
    2143                 tensorElem = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2f'%(dzero['Emat'][i]),style=wx.TE_READONLY)
     2126                dzeroSizer.Add(wx.StaticText(G2frame.dataWindow,-1,label=names[i]),0,WACV)
     2127                tensorElem = wx.TextCtrl(G2frame.dataWindow,-1,value='%.2f'%(dzero['Emat'][i]),style=wx.TE_READONLY)
    21442128                tensorElem.SetBackgroundColour(VERY_LIGHT_GREY)
    21452129                dzeroSizer.Add(tensorElem,0,WACV)
    2146             dzeroDelete = wx.CheckBox(parent=G2frame.dataDisplay,label='delete?')
     2130            dzeroDelete = wx.CheckBox(parent=G2frame.dataWindow,label='delete?')
    21472131            dzeroDelete.Bind(wx.EVT_CHECKBOX,OnDeleteDzero)
    21482132            delIndx.append(dzeroDelete)
     
    21562140# end patches
    21572141   
    2158     if G2frame.dataDisplay:
    2159         G2frame.dataDisplay.Destroy()
     2142    G2frame.dataWindow.ClearData()
    21602143    Controls = G2frame.PatternTree.GetItemPyData(
    21612144        G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))       
    2162     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.StrStaMenu)
     2145    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.StrStaMenu)
    21632146    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAppendDzero, id=G2gd.wxID_APPENDDZERO)
    21642147    G2frame.dataFrame.Bind(wx.EVT_MENU, OnUpdateDzero, id=G2gd.wxID_UPDATEDZERO)
     
    21712154    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveStrSta, id=G2gd.wxID_STRSTASAVE)
    21722155    G2frame.dataFrame.Bind(wx.EVT_MENU, OnStrStaSample, id=G2gd.wxID_STRSTSAMPLE)       
    2173     if not G2frame.dataFrame.GetStatusBar():
    2174         G2frame.dataFrame.CreateStatusBar()
    21752156    if G2frame.StrainKey == 'a':    #probably doesn't happen
    2176         G2frame.dataFrame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value')
     2157        G2frame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value')
    21772158    else:
    2178         G2frame.dataFrame.GetStatusBar().SetStatusText("To add strain data: On 2D Powder Image, key a:add ring")
    2179        
    2180     G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
     2159        G2frame.GetStatusBar().SetStatusText("To add strain data: On 2D Powder Image, key a:add ring")
     2160       
    21812161    mainSizer = wx.BoxSizer(wx.VERTICAL)
    21822162    mainSizer.Add((5,10),0)
     
    21862166   
    21872167    mainSizer.Layout()   
    2188     G2frame.dataDisplay.SetSizer(mainSizer)
    2189     G2frame.dataDisplay.SetAutoLayout(1)
    2190     G2frame.dataDisplay.SetupScrolling()
    2191     Size = mainSizer.Fit(G2frame.dataFrame)
    2192     Size[0] += 25
    2193     G2frame.dataFrame.setSizePosLeft(Size)   
     2168    G2frame.dataWindow.SetSizer(mainSizer)
     2169    G2frame.dataWindow.SetAutoLayout(1)
     2170    mainSizer.Fit(G2frame.dataFrame)
     2171    G2frame.SetDataSize()
    21942172
    21952173###########################################################################
  • TabularUnified branch/2frame/GSASIIphsGUI.py

    r2873 r2888  
    7676    phasePage.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    7777    phasePage.Scroll(0,Scroll)
    78     if size is None:
    79         Size[1] = min(Size[1]+ 150,500)
    80 #        Size[1] = min(500,Size[1])
    81         mainFrame.setSizePosLeft(Size)
    82     else:
    83         size[1] = min(500,size[1])
    84         mainFrame.setSizePosLeft(size)
    8578   
    8679def FindBondsDraw(data):   
     
    371364                    generalData['Name'] = newName
    372365                    G2frame.G2plotNB.Rename(oldName,generalData['Name'])
    373                     G2frame.dataFrame.SetLabel('Phase Data for '+generalData['Name'])
     366                    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+generalData['Name'])
    374367                    G2frame.PatternTree.SetItemText(Item,generalData['Name'])
    375368                    # change phase name key in Reflection Lists for each histogram
     
    390383                if not len(generalData['AtomTypes']):             #can change only if no atoms!
    391384                    generalData['Type'] = TypeTxt.GetValue()
    392                     pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
     385                    pages = [G2frame.phaseDisplay.GetPageText(PageNum) for PageNum in range(G2frame.phaseDisplay.GetPageCount())]
    393386                    if generalData['Type'] == 'faulted':
    394387                        G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
     
    398391                        if 'Wave Data' in pages:
    399392                            pass
    400 #                            G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     393#                            G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
    401394                        if 'MC/SA' in pages:
    402395                            pass
    403 #                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))
     396#                            G2frame.phaseDisplay.DeletePage(pages.index('MC/SA'))
    404397                        if 'RB Models' in pages:
    405398                            pass
    406 #                            G2frame.dataDisplay.DeletePage(pages.index('RB Models'))
     399#                            G2frame.phaseDisplay.DeletePage(pages.index('RB Models'))
    407400                        if 'Layers' not in pages:
    408401                            if 'Layers' not in data:
     
    410403                                    'Width':[[1.,1.],[False,False]],'Toler':0.01,'AtInfo':{},
    411404                                    'Layers':[],'Stacking':[],'Transitions':[]}
    412                             G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
    413                             G2frame.dataDisplay.InsertPage(3,G2frame.layerData,'Layers')
     405                            G2frame.layerData = wx.ScrolledWindow(G2frame.phaseDisplay)
     406                            G2frame.phaseDisplay.InsertPage(3,G2frame.layerData,'Layers')
    414407                            Id = wx.NewId()
    415408                            TabSelectionIdDict[Id] = 'Layers'
     
    423416                    else:
    424417                        if 'Wave Data' in pages:
    425                             G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     418                            G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
    426419                        if 'MC/SA' not in pages:
    427                             G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
    428                             G2frame.dataDisplay.InsertPage(7,G2frame.MCSA,'MC/SA')
     420                            G2frame.MCSA = wx.ScrolledWindow(G2frame.phaseDisplay)
     421                            G2frame.phaseDisplay.InsertPage(7,G2frame.MCSA,'MC/SA')
    429422                            Id = wx.NewId()
    430423                            TabSelectionIdDict[Id] = 'MC/SA'
     
    513506            def OnModulated(event):
    514507                if not len(generalData['AtomTypes']):             #can change only if no atoms!
    515                     pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
     508                    pages = [G2frame.phaseDisplay.GetPageText(PageNum) for PageNum in range(G2frame.phaseDisplay.GetPageCount())]
    516509                    if generalData['Type'] in ['nuclear','magnetic']:
    517510                        generalData['Modulated'] = modulated.GetValue()
     
    529522                            if 'MC/SA' in pages:
    530523                                pass
    531     #                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
     524    #                            G2frame.phaseDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
    532525                            if 'Layers' in pages:
    533526                                pass
    534     #                            G2frame.dataDisplay.DeletePage(pages.index('Layers'))
     527    #                            G2frame.phaseDisplay.DeletePage(pages.index('Layers'))
    535528                            if 'Wave Data' not in pages:
    536                                 G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
    537                                 G2frame.dataDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
     529                                G2frame.waveData = wx.ScrolledWindow(G2frame.phaseDisplay)
     530                                G2frame.phaseDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
    538531                                Id = wx.NewId()
    539532                                TabSelectionIdDict[Id] = 'Wave Data'
    540533                        else:
    541534                            if 'Wave Data' in pages:
    542                                 G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     535                                G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
    543536                        wx.CallAfter(UpdateGeneral)
    544537                else:
     
    685678                cellSizer.Add(wx.StaticText(General,label=txt),0,WACV)
    686679                if ifEdit:          #a,b,c,etc.
    687 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     680#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    688681                    cellVal = wx.TextCtrl(General,value=(fmt%(cell[Id+1])),
    689682                        style=wx.TE_PROCESS_ENTER)
     
    848841            dminSizer = wx.BoxSizer(wx.HORIZONTAL)
    849842            dminSizer.Add(wx.StaticText(General,label=' Magnetic reflection d-min: '),0,WACV)
    850 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     843#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    851844            dminVal = wx.TextCtrl(General,value='%.4f'%(generalData['MagDmin']),style=wx.TE_PROCESS_ENTER)
    852845            dminVal.Bind(wx.EVT_TEXT_ENTER,OnDminVal)       
     
    947940            for i,[val,show] in enumerate(zip(generalData['SuperVec'][0],ifShow)):
    948941                if show:
    949 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     942#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    950943                    modVal = wx.TextCtrl(General,value=('%.4f'%(val)),
    951944                        size=wx.Size(50,20),style=wx.TE_PROCESS_ENTER)
     
    10371030            line2Sizer = wx.BoxSizer(wx.HORIZONTAL)
    10381031            line2Sizer.Add(wx.StaticText(General,label=' Resolution: '),0,WACV)
    1039 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1032#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    10401033            mapRes =  wx.TextCtrl(General,value='%.2f'%(Map['Resolution']),style=wx.TE_PROCESS_ENTER)
    10411034            mapRes.Bind(wx.EVT_TEXT_ENTER,OnResVal)       
     
    10431036            line2Sizer.Add(mapRes,0,WACV)
    10441037            line2Sizer.Add(wx.StaticText(General,label=' Peak cutoff %: '),0,WACV)
    1045 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1038#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    10461039            cutOff =  wx.TextCtrl(General,value='%.1f'%(Map['cutOff']),style=wx.TE_PROCESS_ENTER)
    10471040            cutOff.Bind(wx.EVT_TEXT_ENTER,OnCutOff)       
     
    11381131            line2Sizer = wx.BoxSizer(wx.HORIZONTAL)
    11391132            line2Sizer.Add(wx.StaticText(General,label=' Resolution: '),0,WACV)
    1140 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1133#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    11411134            flipRes =  wx.TextCtrl(General,value='%.2f'%(Flip['Resolution']),style=wx.TE_PROCESS_ENTER)
    11421135            flipRes.Bind(wx.EVT_TEXT_ENTER,OnResVal)       
     
    11441137            line2Sizer.Add(flipRes,0,WACV)
    11451138            line2Sizer.Add(wx.StaticText(General,label=' k-Factor (0.1-1.2): '),0,WACV)
    1146 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1139#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    11471140            kFactor =  wx.TextCtrl(General,value='%.3f'%(Flip['k-factor']),style=wx.TE_PROCESS_ENTER)
    11481141            kFactor.Bind(wx.EVT_TEXT_ENTER,OnkFactor)       
     
    11501143            line2Sizer.Add(kFactor,0,WACV)
    11511144            line2Sizer.Add(wx.StaticText(General,label=' k-Max (>=10.0): '),0,WACV)
    1152 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1145#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    11531146            kMax = wx.TextCtrl(General,value='%.1f'%(Flip['k-Max']),style=wx.TE_PROCESS_ENTER)
    11541147            kMax.Bind(wx.EVT_TEXT_ENTER,OnkMax)       
     
    12661259            lineSizer.Add(refList,0,WACV)
    12671260            lineSizer.Add(wx.StaticText(General,label=' d-min: '),0,WACV)
    1268 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1261#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    12691262            dmin = wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata['dmin']),style=wx.TE_PROCESS_ENTER)
    12701263            dmin.Bind(wx.EVT_TEXT_ENTER,OnDmin)       
     
    12851278            ranStart.SetValue(MCSAdata.get('ranStart',False))
    12861279            line2Sizer.Add(ranStart,0,WACV)
    1287 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1280#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    12881281            ranRange = wx.TextCtrl(General,-1,value='%.1f'%(MCSAdata.get('ranRange',0.10)*100),style=wx.TE_PROCESS_ENTER)
    12891282            ranRange.Bind(wx.EVT_TEXT_ENTER,OnRanRange)       
     
    13151308                for i,name in enumerate(Names):
    13161309                    line3Sizer.Add(wx.StaticText(General,label=name),0,WACV)
    1317 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1310#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    13181311                    Ajump =  wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata[parms][i]),style=wx.TE_PROCESS_ENTER)
    13191312                    Ajump.Bind(wx.EVT_TEXT_ENTER,OnAjump)       
     
    13231316            elif 'log' in MCSAdata['Algorithm']:
    13241317                line3Sizer.Add(wx.StaticText(General,label=' slope: '),0,WACV)
    1325 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     1318#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    13261319                slope =  wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata['log slope']),style=wx.TE_PROCESS_ENTER)
    13271320                slope.Bind(wx.EVT_TEXT_ENTER,OnSlope)       
     
    13951388            G2G.HorizontalLine(mainSizer,General)
    13961389            mainSizer.Add(MCSASizer())
    1397         G2frame.dataFrame.SetStatusText('')
     1390        G2frame.GetStatusBar().SetStatusText('')
    13981391        SetPhaseWindow(G2frame.dataFrame,General,mainSizer,Scroll=Scroll)
    13991392       
     
    16951688            if not (event.AltDown() or (event.ShiftDown() and event.ControlDown())):
    16961689                Atoms.frm = -1
    1697                 G2frame.dataFrame.SetStatusText('')                   
     1690                G2frame.GetStatusBar().SetStatusText('')                   
    16981691            if r < 0 and c < 0:
    16991692                if Atoms.IsSelection():
     
    17241717                            Atoms.SelectRow(r,True)
    17251718                            n = colLabels.index('Name')
    1726                             G2frame.dataFrame.SetStatusText('Atom '+atomData[r][n]+' is to be moved')
     1719                            G2frame.GetStatusBar().SetStatusText('Atom '+atomData[r][n]+' is to be moved')
    17271720                        else:                       #move it
    17281721                            item = atomData.pop(Atoms.frm)
    17291722                            atomData.insert(r,item)
    17301723                            Atoms.frm = -1
    1731                             G2frame.dataFrame.SetStatusText('')
     1724                            G2frame.GetStatusBar().SetStatusText('')
    17321725                            wx.CallAfter(Paint)
    17331726                else:
     
    18911884            Types = Types[:7]+3*[wg.GRID_VALUE_FLOAT+':10,4',]+Types[7:]
    18921885        SGData = data['General']['SGData']
    1893         G2frame.dataFrame.SetStatusText('')
     1886        G2frame.GetStatusBar().SetStatusText('')
    18941887        if SGData['SGPolax']:
    1895             G2frame.dataFrame.SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'])
     1888            G2frame.GetStatusBar().SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'])
    18961889        Atoms.Bind(wg.EVT_GRID_CELL_CHANGE, ChangeAtomCell)
    18971890        Atoms.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, AtomTypeSelect)
     
    22042197            atom = atomData[ind]
    22052198            if atom[ci+8] in rbAtmDict:
    2206                 G2frame.dataFrame.SetStatusText('**** ERROR - atom is in a rigid body and can not be deleted ****')
     2199                G2frame.GetStatusBar().SetStatusText('**** ERROR - atom is in a rigid body and can not be deleted ****')
    22072200            else:
    22082201                if atom[ci+8] in HydIds:    #remove Hs from Hatom update dict
     
    29312924            for txt,fmt,ifEdit,Id in useGUI[2]:
    29322925                cellSizer.Add(wx.StaticText(layerData,label=txt),0,WACV)
    2933 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     2926#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    29342927                cellVal = wx.TextCtrl(layerData,value=(fmt%(cell[Id+1])),
    29352928                    style=wx.TE_PROCESS_ENTER)
     
    29642957            for i in range(2):
    29652958                widthSizer.Add(wx.StaticText(layerData,label=u' layer width(%s) (<= 1\xb5m): '%(Labels[i])),0,WACV)
    2966 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     2959#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    29672960                widthVal = wx.TextCtrl(layerData,value='%.3f'%(widths[i]),style=wx.TE_PROCESS_ENTER)
    29682961                widthVal.Bind(wx.EVT_TEXT_ENTER,OnWidthChange)       
     
    33503343            if Layers['Stacking'][0] == 'recursive':
    33513344                topLine.Add(wx.StaticText(layerData,label=' number of layers (<1022 or "infinite"): '),0,WACV)
    3352 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     3345#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    33533346                numLayers = wx.TextCtrl(layerData,value=data['Layers']['Stacking'][1],style=wx.TE_PROCESS_ENTER)
    33543347                numLayers.Bind(wx.EVT_TEXT_ENTER,OnNumLayers)       
     
    33903383        if len(Layers['Layers']):
    33913384            layerNames = [layer['Name'] for layer in Layers['Layers']]
    3392         G2frame.dataFrame.SetStatusText('')
     3385        G2frame.GetStatusBar().SetStatusText('')
    33933386        layerData = G2frame.layerData
    33943387        if layerData.GetSizer():
     
    34163409        if Layers['Laue'] == 'unknown':
    34173410            laueSizer.Add(wx.StaticText(layerData,label=' Diffraction symmetry tolerance: '),0,WACV)
    3418 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     3411#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    34193412            toler = wx.TextCtrl(layerData,value='%.3f'%(Layers['Toler']),style=wx.TE_PROCESS_ENTER)
    34203413            toler.Bind(wx.EVT_TEXT_ENTER,OnToler)       
     
    36933686        Indx = {}
    36943687        waveData = G2frame.waveData
    3695         G2frame.dataFrame.SetStatusText('')
     3688        G2frame.GetStatusBar().SetStatusText('')
    36963689        generalData = data['General']
    36973690        SGData = generalData['SGData']
     
    38383831                        for ival,val in enumerate(wave[0]):
    38393832                            if np.any(CSI[Stype][0][ival]):
    3840 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     3833#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    38413834                                waveVal = wx.TextCtrl(waveData,value='%.5f'%(val),style=wx.TE_PROCESS_ENTER)
    38423835                                waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveVal)
     
    40594052            'atNames':atNames,'rbRef':[0,1,2,False],'rbSeq':[],'SelSeq':[0,0],'useCount':0}
    40604053        RBData['RBIds']['Residue'].append(rbId)
    4061         G2frame.dataFrame.SetStatusText('New rigid body UNKRB added to set of Residue rigid bodies')
     4054        G2frame.GetStatusBar().SetStatusText('New rigid body UNKRB added to set of Residue rigid bodies')
    40624055
    40634056################################################################################
     
    41984191
    41994192        # UpdateDrawAtoms executable code starts here
    4200         G2frame.dataFrame.SetStatusText('')
     4193        G2frame.GetStatusBar().SetStatusText('')
    42014194        generalData = data['General']
    42024195        SetupDrawingData()
     
    43094302        if indx:
    43104303            if len(indx) > 1:
    4311                 G2frame.dataFrame.SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK')
     4304                G2frame.GetStatusBar().SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK')
    43124305            else:
    4313                 G2frame.dataFrame.SetStatusText('Change color, Add to Custom Colors, then OK')
     4306                G2frame.GetStatusBar().SetStatusText('Change color, Add to Custom Colors, then OK')
    43144307            atomData = data['Drawing']['Atoms']
    43154308            cx,ct,cs,ci = data['Drawing']['atomPtrs']
     
    43384331            drawAtoms.ClearSelection()
    43394332            dlg.Destroy()
    4340             G2frame.dataFrame.SetStatusText('')
     4333            G2frame.GetStatusBar().SetStatusText('')
    43414334            G2plt.PlotStructure(G2frame,data)
    43424335           
     
    48474840            cameraPosTxt = wx.StaticText(drawOptions,-1,
    48484841                ' Camera Distance: '+'%.2f'%(drawingData['cameraPos']),name='cameraPos')
    4849             G2frame.dataDisplay.cameraPosTxt = cameraPosTxt
     4842            G2frame.phaseDisplay.cameraPosTxt = cameraPosTxt
    48504843            slideSizer.Add(cameraPosTxt,0,WACV)
    48514844            cameraPos = wx.Slider(drawOptions,style=wx.SL_HORIZONTAL,value=drawingData['cameraPos'],name='cameraSlider')
    48524845            cameraPos.SetRange(10,500)
    48534846            cameraPos.Bind(wx.EVT_SLIDER, OnCameraPos)
    4854             G2frame.dataDisplay.cameraSlider = cameraPos
     4847            G2frame.phaseDisplay.cameraSlider = cameraPos
    48554848            slideSizer.Add(cameraPos,1,wx.EXPAND|wx.RIGHT)
    48564849           
     
    48644857            ZstepSizer = wx.BoxSizer(wx.HORIZONTAL)
    48654858            ZstepSizer.Add(wx.StaticText(drawOptions,-1,' Z step:'),0,WACV)
    4866 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     4859#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    48674860            Zstep = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['Zstep']),
    48684861                style=wx.TE_PROCESS_ENTER)
     
    49964989            viewDir.Bind(wx.EVT_TEXT_ENTER,OnViewDir)
    49974990            viewDir.Bind(wx.EVT_KILL_FOCUS,OnViewDir)
    4998             G2frame.dataDisplay.viewDir = viewDir
     4991            G2frame.phaseDisplay.viewDir = viewDir
    49994992            lineSizer.Add(viewDir,0,WACV)
    50004993            showSizer.Add(lineSizer)
     
    50105003            viewPoint = wx.TextCtrl(drawOptions,value='%.3f %.3f %.3f'%(VP[0],VP[1],VP[2]),
    50115004                style=wx.TE_PROCESS_ENTER,size=wx.Size(140,20),name='viewPoint')
    5012             G2frame.dataDisplay.viewPoint = viewPoint
     5005            G2frame.phaseDisplay.viewPoint = viewPoint
    50135006            viewPoint.Bind(wx.EVT_TEXT_ENTER,OnViewPoint)
    50145007            viewPoint.Bind(wx.EVT_KILL_FOCUS,OnViewPoint)
     
    50625055            radSizer = wx.BoxSizer(wx.HORIZONTAL)
    50635056            radSizer.Add(wx.StaticText(drawOptions,-1,' Hydrogen radius, A:  '),0,WACV)
    5064 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5057#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    50655058            sizeH = wx.TextCtrl(drawOptions,-1,value='%.2f'%(drawingData['sizeH']),size=wx.Size(60,20),style=wx.TE_PROCESS_ENTER)
    50665059            sizeH.Bind(wx.EVT_TEXT_ENTER,OnSizeHatoms)
     
    50695062   
    50705063            radSizer.Add(wx.StaticText(drawOptions,-1,' Bond search factor:  '),0,WACV)
    5071 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5064#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    50725065            radFactor = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['radiusFactor']),size=wx.Size(60,20),style=wx.TE_PROCESS_ENTER)
    50735066            radFactor.Bind(wx.EVT_TEXT_ENTER,OnRadFactor)
     
    51325125            planeSizer2 = wx.BoxSizer(wx.HORIZONTAL)
    51335126            planeSizer2.Add(wx.StaticText(drawOptions,label=' Phase shift (deg): '),0,WACV)
    5134 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5127#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    51355128            phase = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['Plane'][3]),
    51365129                style=wx.TE_PROCESS_ENTER)
     
    51535146        drawingData = data['Drawing']
    51545147
    5155         G2frame.dataFrame.SetStatusText('')
     5148        G2frame.GetStatusBar().SetStatusText('')
    51565149        if drawOptions.GetSizer():
    51575150            drawOptions.GetSizer().Clear(True)
     
    54115404            shPenalty.Add(hklList,0,WACV)
    54125405            shPenalty.Add(wx.StaticText(Texture,wx.ID_ANY,' Zero MRD tolerance: '),0,WACV)
    5413 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5406#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    54145407            shToler = wx.TextCtrl(Texture,wx.ID_ANY,'%.2f'%(Penalty[1]),style=wx.TE_PROCESS_ENTER)
    54155408            shToler.Bind(wx.EVT_TEXT_ENTER,OnshToler)
     
    54225415        if Texture.GetSizer():
    54235416            Texture.GetSizer().Clear(True)
    5424         G2frame.dataFrame.SetStatusText('')
     5417        G2frame.GetStatusBar().SetStatusText('')
    54255418        generalData = data['General']       
    54265419        SGData = generalData['SGData']
     
    54925485            PTSizer.Add(wx.StaticText(Texture,-1,' Inverse pole figure XYZ: '),0,WACV)
    54935486            PX = textureData['PFxyz']
    5494 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5487#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    54955488            pfVal = wx.TextCtrl(Texture,-1,'%3.1f %3.1f %3.1f'%(PX[0],PX[1],PX[2]),style=wx.TE_PROCESS_ENTER)
    54965489        pfVal.Bind(wx.EVT_TEXT_ENTER,OnPFValue)
     
    55205513            for item in ODFkeys:
    55215514                ODFSizer.Add(wx.StaticText(Texture,-1,item),0,WACV)
    5522 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5515#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    55235516                ODFval = wx.TextCtrl(Texture,wx.ID_ANY,'%8.3f'%(textureData['SH Coeff'][1][item]),style=wx.TE_PROCESS_ENTER)
    55245517                ODFIndx[ODFval.GetId()] = item
     
    55405533            angRef.Bind(wx.EVT_CHECKBOX, OnAngRef)
    55415534            angSizer.Add(angRef,0,WACV)
    5542 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5535#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    55435536            angVal = wx.TextCtrl(Texture,wx.ID_ANY,'%8.2f'%(textureData[item][1]),style=wx.TE_PROCESS_ENTER)
    55445537            valIndx[angVal.GetId()] = item
     
    59305923            for i,name in enumerate(names):
    59315924                thermSizer.Add(wx.StaticText(RigidBodies,-1,name+': '),0,WACV)
    5932 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5925#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    59335926                thermVal = wx.TextCtrl(RigidBodies,-1,value='%8.4f'%(model[1][i]),
    59345927                    style=wx.TE_PROCESS_ENTER)
     
    60035996            topSizer.Add(wx.StaticText(RigidBodies,-1,'Origin x,y,z:'),0,WACV)
    60045997            for ix,x in enumerate(Orig):
    6005 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     5998#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    60065999                origX = wx.TextCtrl(RigidBodies,-1,value='%8.5f'%(x),style=wx.TE_PROCESS_ENTER)
    60076000                origX.Bind(wx.EVT_TEXT_ENTER,OnOrigX)
     
    60166009            topSizer.Add(wx.StaticText(RigidBodies,-1,'Rotation angle, vector:'),0,WACV)
    60176010            for ix,x in enumerate(Orien):
    6018 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     6011#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    60196012                orien = wx.TextCtrl(RigidBodies,-1,value='%8.4f'%(x),style=wx.TE_PROCESS_ENTER)
    60206013                orien.Bind(wx.EVT_TEXT_ENTER,OnOrien)
     
    60816074            for itors,tors in enumerate(RBObj['Torsions']):
    60826075                torSizer.Add(wx.StaticText(RigidBodies,-1,'Torsion '+'%d'%(itors)),0,WACV)
    6083 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     6076#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    60846077                torsTxt = wx.TextCtrl(RigidBodies,-1,value='%.3f'%(tors[0]),style=wx.TE_PROCESS_ENTER)
    60856078                torsTxt.Bind(wx.EVT_TEXT_ENTER,OnTorsion)
     
    61086101           
    61096102        def VecrbSizer(RBObj):
    6110             G2frame.dataFrame.SetStatusText('NB: Rotation vector is in crystallographic space')
     6103            G2frame.GetStatusBar().SetStatusText('NB: Rotation vector is in crystallographic space')
    61116104                   
    61126105            def OnDelVecRB(event):
     
    61866179        if 'macro' in general['Type']:
    61876180            atomStyle = 'sticks'
    6188         G2frame.dataFrame.SetStatusText('')
     6181        G2frame.GetStatusBar().SetStatusText('')
    61896182        mainSizer = wx.BoxSizer(wx.VERTICAL)
    61906183        if not data['RBModels']:
     
    62116204            G2frame.bottomSizer.Add(ResrbSizer(rbObj))
    62126205            mainSizer.Add(G2frame.bottomSizer)
    6213             G2frame.dataFrame.SetStatusText('NB: Rotation vector is in crystallographic space')
     6206            G2frame.GetStatusBar().SetStatusText('NB: Rotation vector is in crystallographic space')
    62146207            G2plt.PlotStructure(G2frame,data)
    62156208        if 'Vector' in data['RBModels'] and len(data['RBModels']['Vector']):
     
    62546247    def OnRBAssign(event):
    62556248       
    6256         G2frame.dataFrame.SetStatusText('')
     6249        G2frame.GetStatusBar().SetStatusText('')
    62576250        RBData = G2frame.PatternTree.GetItemPyData(   
    62586251            G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     
    67886781                Indx[posRef.GetId()] = [model,'Pos',ix]
    67896782                atomsizer.Add(posRef,0,WACV)
    6790 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     6783#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    67916784                posVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(model['Pos'][0][ix]),style=wx.TE_PROCESS_ENTER)
    67926785                posVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
     
    68626855                Indx[posRef.GetId()] = [model,'Pos',ix]
    68636856                rbsizer1.Add(posRef,0,WACV)
    6864 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     6857#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    68656858                posVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(model['Pos'][0][ix]),style=wx.TE_PROCESS_ENTER)
    68666859                posVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
     
    68856878            Ori = model['Ori'][0]
    68866879            rbsizer2.Add(wx.StaticText(G2frame.MCSA,-1,'Oa: '),0,WACV)
    6887 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     6880#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    68886881            angVal = wx.TextCtrl(G2frame.MCSA,-1,'%.5f'%(Ori[0]),style=wx.TE_PROCESS_ENTER)
    68896882            angVal.Bind(wx.EVT_TEXT_ENTER,OnOriVal)
     
    69336926                    Indx[torRef.GetId()] = [model,'Tor',it]
    69346927                    rbsizer3.Add(torRef,0,WACV)
    6935 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     6928#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    69366929                    torVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(tor),style=wx.TE_PROCESS_ENTER)
    69376930                    torVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
     
    69976990            poRef.Bind(wx.EVT_CHECKBOX,OnPORef)
    69986991            poSizer.Add(poRef,0,WACV)
    6999 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     6992#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.phaseDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    70006993            poVal = wx.TextCtrl(G2frame.MCSA,-1,'%.3f'%(POData['Coef'][0]),style=wx.TE_PROCESS_ENTER)
    70016994            poVal.Bind(wx.EVT_TEXT_ENTER,OnPOVal)
     
    70827075#        if 'macro' in general['Type']:
    70837076#            atomStyle = 'sticks'
    7084         G2frame.dataFrame.SetStatusText('')
     7077        G2frame.GetStatusBar().SetStatusText('')
    70857078        mainSizer = wx.BoxSizer(wx.VERTICAL)
    70867079        if not data['MCSA']['Models']:
     
    72177210        MCSAdata['Results'][0][0] = True
    72187211        SetSolution(MCSAdata['Results'][0],data['MCSA']['Models'])
    7219         G2frame.dataDisplay.SetFocus()
    7220         Page = G2frame.dataDisplay.FindPage('MC/SA')
    7221         G2frame.dataDisplay.SetSelection(Page)
     7212        G2frame.phaseDisplay.SetFocus()
     7213        Page = G2frame.phaseDisplay.FindPage('MC/SA')
     7214        G2frame.phaseDisplay.SetSelection(Page)
    72227215        G2plt.PlotStructure(G2frame,data)
    72237216        wx.CallAfter(UpdateMCSA)
     
    73237316           
    73247317        # FillPawleyReflectionsGrid executable starts here
    7325         G2frame.dataFrame.SetStatusText('To delete a Pawley reflection: select row & press Delete')                       
     7318        G2frame.GetStatusBar().SetStatusText('To delete a Pawley reflection: select row & press Delete')                       
    73267319        generalData = data['General']
    73277320        if 'Pawley ref' in data:
     
    76357628            G2plt.PlotStructure(G2frame,data)                   
    76367629           
    7637         G2frame.dataFrame.SetStatusText('')
     7630        G2frame.GetStatusBar().SetStatusText('')
    76387631        if 'Map Peaks' in data:
    7639             G2frame.dataFrame.SetStatusText('Double click any column heading to sort')
     7632            G2frame.GetStatusBar().SetStatusText('Double click any column heading to sort')
    76407633            mapPeaks = data['Map Peaks']                       
    76417634            rowLabels = []
     
    78677860            print ' Map search finished, time = %.2fs'%(time.time()-time0)
    78687861            print ' No.peaks found:',len(peaks)   
    7869             Page = G2frame.dataDisplay.FindPage('Map peaks')
    7870             G2frame.dataDisplay.SetSelection(Page)
     7862            Page = G2frame.phaseDisplay.FindPage('Map peaks')
     7863            G2frame.phaseDisplay.SetSelection(Page)
    78717864            wx.CallAfter(FillMapPeaksGrid)
    78727865            UpdateDrawAtoms()
     
    80128005                return               
    80138006            # find the matching tab
    8014             for PageNum in range(G2frame.dataDisplay.GetPageCount()):
    8015                 if tabname == G2frame.dataDisplay.GetPageText(PageNum):
    8016                     G2frame.dataDisplay.SetSelection(PageNum)
     8007            for PageNum in range(G2frame.phaseDisplay.GetPageCount()):
     8008                if tabname == G2frame.phaseDisplay.GetPageText(PageNum):
     8009                    G2frame.phaseDisplay.SetSelection(PageNum)
    80178010                    return
    80188011            else:
     
    80318024        on a Phase data item window
    80328025        '''
    8033         for page in G2frame.dataDisplay.gridList: # clear out all grids, forcing edits in progress to complete
     8026        for page in G2frame.phaseDisplay.gridList: # clear out all grids, forcing edits in progress to complete
    80348027            page.ClearGrid()
    80358028        page = event.GetSelection()
     
    80378030       
    80388031    def ChangePage(page):
    8039         text = G2frame.dataDisplay.GetPageText(page)
    8040         G2frame.dataDisplayPhaseText = text
     8032        text = G2frame.phaseDisplay.GetPageText(page)
     8033        G2frame.phaseDisplayPhaseText = text
    80418034        G2frame.dataFrame.helpKey = text # use name of Phase tab for help lookup
    80428035        if text == 'General':
    8043             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataGeneral)
     8036            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataGeneral)
    80448037            UpdateGeneral()
    80458038        elif text == 'Data':
    8046             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataMenu)
     8039            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataMenu)
    80478040            G2ddG.UpdateDData(G2frame,DData,data)
    80488041            wx.CallAfter(G2plt.PlotSizeStrainPO,G2frame,data,hist='',Start=True)           
    80498042        elif text == 'Atoms':
    8050             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.AtomsMenu)
     8043            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.AtomsMenu)
    80518044            FillAtomsGrid(Atoms)
    80528045        elif text == 'Layers':
    8053             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LayerData)
     8046            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.LayerData)
    80548047            UpdateLayerData()
    80558048        elif text == 'Wave Data' and data['General']['Modulated']:
    8056             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.WavesData)
     8049            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.WavesData)
    80578050            UpdateWavesData()
    80588051            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80598052        elif text == 'Draw Options':
    8060             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataDrawOptions)
     8053            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataDrawOptions)
    80618054            UpdateDrawOptions()
    80628055            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80638056        elif text == 'Draw Atoms':
    8064             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DrawAtomsMenu)
     8057            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DrawAtomsMenu)
    80658058            UpdateDrawAtoms()
    80668059            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80678060        elif text == 'RB Models':
    8068             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodiesMenu)
     8061            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodiesMenu)
    80698062            FillRigidBodyGrid()
    80708063        elif text == 'Map peaks':
    8071             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MapPeaksMenu)
     8064            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MapPeaksMenu)
    80728065            FillMapPeaksGrid()
    80738066            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80748067        elif text == 'MC/SA':
    8075             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MCSAMenu)
     8068            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MCSAMenu)
    80768069            UpdateMCSA()                       
    80778070            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80788071        elif text == 'Texture':
    8079             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.TextureMenu)
     8072            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.TextureMenu)
    80808073            UpdateTexture()                       
    80818074            wx.CallAfter(G2plt.PlotTexture,G2frame,data,Start=True)           
    80828075        elif text == 'Pawley reflections':
    8083             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PawleyMenu)
     8076            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.PawleyMenu)
    80848077            FillPawleyReflectionsGrid()
    80858078        else:
     
    80908083        '''
    80918084        # General
    8092         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataGeneral)
    8093         G2frame.dataFrame.Bind(wx.EVT_MENU, OnFourierMaps, id=G2gd.wxID_FOURCALC)
    8094         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSearchMaps, id=G2gd.wxID_FOURSEARCH)
    8095         G2frame.dataFrame.Bind(wx.EVT_MENU, OnChargeFlip, id=G2gd.wxID_CHARGEFLIP)
    8096         G2frame.dataFrame.Bind(wx.EVT_MENU, On4DChargeFlip, id=G2gd.wxID_4DCHARGEFLIP)
    8097         G2frame.dataFrame.Bind(wx.EVT_MENU, OnFourClear, id=G2gd.wxID_FOURCLEAR)
    8098         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRunSingleMCSA, id=G2gd.wxID_SINGLEMCSA)
    8099         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRunMultiMCSA, id=G2gd.wxID_MULTIMCSA)
    8100         G2frame.dataFrame.Bind(wx.EVT_MENU, OnTransform, id=G2gd.wxID_TRANSFORMSTRUCTURE)
     8085        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataGeneral)
     8086        G2frame.Bind(wx.EVT_MENU, OnFourierMaps, id=G2gd.wxID_FOURCALC)
     8087        G2frame.Bind(wx.EVT_MENU, OnSearchMaps, id=G2gd.wxID_FOURSEARCH)
     8088        G2frame.Bind(wx.EVT_MENU, OnChargeFlip, id=G2gd.wxID_CHARGEFLIP)
     8089        G2frame.Bind(wx.EVT_MENU, On4DChargeFlip, id=G2gd.wxID_4DCHARGEFLIP)
     8090        G2frame.Bind(wx.EVT_MENU, OnFourClear, id=G2gd.wxID_FOURCLEAR)
     8091        G2frame.Bind(wx.EVT_MENU, OnRunSingleMCSA, id=G2gd.wxID_SINGLEMCSA)
     8092        G2frame.Bind(wx.EVT_MENU, OnRunMultiMCSA, id=G2gd.wxID_MULTIMCSA)
     8093        G2frame.Bind(wx.EVT_MENU, OnTransform, id=G2gd.wxID_TRANSFORMSTRUCTURE)
    81018094        # Data
    8102         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataMenu)
    8103         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataUse, id=G2gd.wxID_DATAUSE)
    8104         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataCopy, id=G2gd.wxID_DATACOPY)
    8105         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataCopyFlags, id=G2gd.wxID_DATACOPYFLAGS)
    8106         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSelDataCopy, id=G2gd.wxID_DATASELCOPY)
    8107         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPwdrAdd, id=G2gd.wxID_PWDRADD)
    8108         G2frame.dataFrame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2gd.wxID_HKLFADD)
    8109         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataDelete, id=G2gd.wxID_DATADELETE)
     8095        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataMenu)
     8096        G2frame.Bind(wx.EVT_MENU, OnDataUse, id=G2gd.wxID_DATAUSE)
     8097        G2frame.Bind(wx.EVT_MENU, OnDataCopy, id=G2gd.wxID_DATACOPY)
     8098        G2frame.Bind(wx.EVT_MENU, OnDataCopyFlags, id=G2gd.wxID_DATACOPYFLAGS)
     8099        G2frame.Bind(wx.EVT_MENU, OnSelDataCopy, id=G2gd.wxID_DATASELCOPY)
     8100        G2frame.Bind(wx.EVT_MENU, OnPwdrAdd, id=G2gd.wxID_PWDRADD)
     8101        G2frame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2gd.wxID_HKLFADD)
     8102        G2frame.Bind(wx.EVT_MENU, OnDataDelete, id=G2gd.wxID_DATADELETE)
    81108103        # Atoms
    8111         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.AtomsMenu)
    8112         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSetAll, id=G2gd.wxID_ATOMSSETALL)
    8113         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomRefine, id=G2gd.wxID_ATOMSSETSEL)
    8114         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomModify, id=G2gd.wxID_ATOMSMODIFY)
    8115         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
    8116         G2frame.dataFrame.Bind(wx.EVT_MENU, OnHydAtomAdd, id=G2gd.wxID_ADDHATOM)
    8117         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
    8118         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomTransform, id=G2gd.wxID_ATOMSTRANSFORM)
    8119 #        G2frame.dataFrame.Bind(wx.EVT_MENU, AtomRotate, id=G2gd.wxID_ATOMSROTATE)
     8104        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.AtomsMenu)
     8105        G2frame.Bind(wx.EVT_MENU, OnSetAll, id=G2gd.wxID_ATOMSSETALL)
     8106        G2frame.Bind(wx.EVT_MENU, AtomRefine, id=G2gd.wxID_ATOMSSETSEL)
     8107        G2frame.Bind(wx.EVT_MENU, AtomModify, id=G2gd.wxID_ATOMSMODIFY)
     8108        G2frame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
     8109        G2frame.Bind(wx.EVT_MENU, OnHydAtomAdd, id=G2gd.wxID_ADDHATOM)
     8110        G2frame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
     8111        G2frame.Bind(wx.EVT_MENU, AtomTransform, id=G2gd.wxID_ATOMSTRANSFORM)
     8112#        G2frame.Bind(wx.EVT_MENU, AtomRotate, id=G2gd.wxID_ATOMSROTATE)
    81208113       
    8121         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
    8122         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewAdd, id=G2gd.wxID_ATOMSVIEWADD)
    8123         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewInsert, id=G2gd.wxID_ATOMVIEWINSERT)
    8124         G2frame.dataFrame.Bind(wx.EVT_MENU, OnHydAtomUpdate, id=G2gd.wxID_UPDATEHATOM)
    8125         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomMove, id=G2gd.wxID_ATOMMOVE)
    8126         G2frame.dataFrame.Bind(wx.EVT_MENU, MakeMolecule, id=G2gd.wxID_MAKEMOLECULE)
    8127         G2frame.dataFrame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
    8128         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
    8129         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAnglePrt, id=G2gd.wxID_ATOMSPDISAGL)
    8130         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDensity, id=G2gd.wxID_ATOMSDENSITY)
    8131         G2frame.dataFrame.Bind(wx.EVT_MENU, OnValidProtein, id=G2gd.wxID_VALIDPROTEIN)
    8132         G2frame.dataFrame.Bind(wx.EVT_MENU, OnIsoDistortCalc, id=G2gd.wxID_ISODISP)
     8114        G2frame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
     8115        G2frame.Bind(wx.EVT_MENU, OnAtomViewAdd, id=G2gd.wxID_ATOMSVIEWADD)
     8116        G2frame.Bind(wx.EVT_MENU, OnAtomViewInsert, id=G2gd.wxID_ATOMVIEWINSERT)
     8117        G2frame.Bind(wx.EVT_MENU, OnHydAtomUpdate, id=G2gd.wxID_UPDATEHATOM)
     8118        G2frame.Bind(wx.EVT_MENU, OnAtomMove, id=G2gd.wxID_ATOMMOVE)
     8119        G2frame.Bind(wx.EVT_MENU, MakeMolecule, id=G2gd.wxID_MAKEMOLECULE)
     8120        G2frame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
     8121        G2frame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
     8122        G2frame.Bind(wx.EVT_MENU, OnDistAnglePrt, id=G2gd.wxID_ATOMSPDISAGL)
     8123        G2frame.Bind(wx.EVT_MENU, OnDensity, id=G2gd.wxID_ATOMSDENSITY)
     8124        G2frame.Bind(wx.EVT_MENU, OnValidProtein, id=G2gd.wxID_VALIDPROTEIN)
     8125        G2frame.Bind(wx.EVT_MENU, OnIsoDistortCalc, id=G2gd.wxID_ISODISP)
    81338126        if 'HydIds' in data['General']:
    81348127            G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,True)
     
    81368129            G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,False)
    81378130        for id in G2frame.dataFrame.ReImportMenuId:     #loop over submenu items
    8138             G2frame.dataFrame.Bind(wx.EVT_MENU, OnReImport, id=id)
     8131            G2frame.Bind(wx.EVT_MENU, OnReImport, id=id)
    81398132        # Wave Data
    81408133        if data['General']['Modulated']:
    8141             FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.WavesData)
    8142             G2frame.dataFrame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)
     8134            FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.WavesData)
     8135            G2frame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)
    81438136        # Stacking faults
    8144         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.LayerData)
    8145         G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPhase, id=G2gd.wxID_COPYPHASE)
    8146         G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
    8147         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSimulate, id=G2gd.wxID_LAYERSIMULATE)
    8148         G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitLayers, id=G2gd.wxID_LAYERSFIT)                       
    8149         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2gd.wxID_SEQUENCESIMULATE)
     8137        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.LayerData)
     8138        G2frame.Bind(wx.EVT_MENU, OnCopyPhase, id=G2gd.wxID_COPYPHASE)
     8139        G2frame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
     8140        G2frame.Bind(wx.EVT_MENU, OnSimulate, id=G2gd.wxID_LAYERSIMULATE)
     8141        G2frame.Bind(wx.EVT_MENU, OnFitLayers, id=G2gd.wxID_LAYERSFIT)                       
     8142        G2frame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2gd.wxID_SEQUENCESIMULATE)
    81508143        # Draw Options
    8151         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataDrawOptions)
     8144        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataDrawOptions)
    81528145        # Draw Atoms
    8153         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DrawAtomsMenu)
    8154         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2gd.wxID_DRAWATOMSTYLE)
    8155         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2gd.wxID_DRAWATOMLABEL)
    8156         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomColor, id=G2gd.wxID_DRAWATOMCOLOR)
    8157         G2frame.dataFrame.Bind(wx.EVT_MENU, ResetAtomColors, id=G2gd.wxID_DRAWATOMRESETCOLOR)
    8158         G2frame.dataFrame.Bind(wx.EVT_MENU, OnEditAtomRadii, id=G2gd.wxID_DRWAEDITRADII)   
    8159         G2frame.dataFrame.Bind(wx.EVT_MENU, SetViewPoint, id=G2gd.wxID_DRAWVIEWPOINT)
    8160         G2frame.dataFrame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2gd.wxID_DRAWADDEQUIV)
    8161         G2frame.dataFrame.Bind(wx.EVT_MENU, AddSphere, id=G2gd.wxID_DRAWADDSPHERE)
    8162         G2frame.dataFrame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2gd.wxID_DRAWTRANSFORM)
    8163         G2frame.dataFrame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2gd.wxID_DRAWFILLCOORD)           
    8164         G2frame.dataFrame.Bind(wx.EVT_MENU, FillUnitCell, id=G2gd.wxID_DRAWFILLCELL)
    8165         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2gd.wxID_DRAWDELETE)
    8166         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawDistVP, id=G2gd.wxID_DRAWDISTVP)
    8167         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawDAT, id=G2gd.wxID_DRAWDISAGLTOR)
    8168         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2gd.wxID_DRAWPLANE)
    8169         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRBOND)
    8170         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRANGLE)
    8171         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRPLANE)
    8172         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRCHIRAL)
    8173         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDefineRB, id=G2gd.wxID_DRAWDEFINERB)
     8146        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DrawAtomsMenu)
     8147        G2frame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2gd.wxID_DRAWATOMSTYLE)
     8148        G2frame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2gd.wxID_DRAWATOMLABEL)
     8149        G2frame.Bind(wx.EVT_MENU, DrawAtomColor, id=G2gd.wxID_DRAWATOMCOLOR)
     8150        G2frame.Bind(wx.EVT_MENU, ResetAtomColors, id=G2gd.wxID_DRAWATOMRESETCOLOR)
     8151        G2frame.Bind(wx.EVT_MENU, OnEditAtomRadii, id=G2gd.wxID_DRWAEDITRADII)   
     8152        G2frame.Bind(wx.EVT_MENU, SetViewPoint, id=G2gd.wxID_DRAWVIEWPOINT)
     8153        G2frame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2gd.wxID_DRAWADDEQUIV)
     8154        G2frame.Bind(wx.EVT_MENU, AddSphere, id=G2gd.wxID_DRAWADDSPHERE)
     8155        G2frame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2gd.wxID_DRAWTRANSFORM)
     8156        G2frame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2gd.wxID_DRAWFILLCOORD)           
     8157        G2frame.Bind(wx.EVT_MENU, FillUnitCell, id=G2gd.wxID_DRAWFILLCELL)
     8158        G2frame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2gd.wxID_DRAWDELETE)
     8159        G2frame.Bind(wx.EVT_MENU, OnDrawDistVP, id=G2gd.wxID_DRAWDISTVP)
     8160        G2frame.Bind(wx.EVT_MENU, OnDrawDAT, id=G2gd.wxID_DRAWDISAGLTOR)
     8161        G2frame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2gd.wxID_DRAWPLANE)
     8162        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRBOND)
     8163        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRANGLE)
     8164        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRPLANE)
     8165        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRCHIRAL)
     8166        G2frame.Bind(wx.EVT_MENU, OnDefineRB, id=G2gd.wxID_DRAWDEFINERB)
    81748167        # RB Models
    8175         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.RigidBodiesMenu)
    8176         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAutoFindResRB, id=G2gd.wxID_AUTOFINDRESRB)
    8177         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBAssign, id=G2gd.wxID_ASSIGNATMS2RB)
    8178         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBCopyParms, id=G2gd.wxID_COPYRBPARMS)
    8179         G2frame.dataFrame.Bind(wx.EVT_MENU, OnGlobalResRBTherm, id=G2gd.wxID_GLOBALTHERM)
    8180         G2frame.dataFrame.Bind(wx.EVT_MENU, OnGlobalResRBRef, id=G2gd.wxID_GLOBALRESREFINE)
    8181         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBRemoveAll, id=G2gd.wxID_RBREMOVEALL)
     8168        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.RigidBodiesMenu)
     8169        G2frame.Bind(wx.EVT_MENU, OnAutoFindResRB, id=G2gd.wxID_AUTOFINDRESRB)
     8170        G2frame.Bind(wx.EVT_MENU, OnRBAssign, id=G2gd.wxID_ASSIGNATMS2RB)
     8171        G2frame.Bind(wx.EVT_MENU, OnRBCopyParms, id=G2gd.wxID_COPYRBPARMS)
     8172        G2frame.Bind(wx.EVT_MENU, OnGlobalResRBTherm, id=G2gd.wxID_GLOBALTHERM)
     8173        G2frame.Bind(wx.EVT_MENU, OnGlobalResRBRef, id=G2gd.wxID_GLOBALRESREFINE)
     8174        G2frame.Bind(wx.EVT_MENU, OnRBRemoveAll, id=G2gd.wxID_RBREMOVEALL)
    81828175        # Map peaks
    8183         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.MapPeaksMenu)
    8184         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksMove, id=G2gd.wxID_PEAKSMOVE)
    8185         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksViewPoint, id=G2gd.wxID_PEAKSVIEWPT)
    8186         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDistVP, id=G2gd.wxID_PEAKSDISTVP)
    8187         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDA, id=G2gd.wxID_PEAKSDA)
    8188         G2frame.dataFrame.Bind(wx.EVT_MENU, OnShowBonds, id=G2gd.wxID_SHOWBONDS)
    8189         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksEquiv, id=G2gd.wxID_FINDEQVPEAKS)
    8190         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksUnique, id=G2gd.wxID_PEAKSUNIQUE)
    8191         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDelete, id=G2gd.wxID_PEAKSDELETE)
    8192         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksClear, id=G2gd.wxID_PEAKSCLEAR)
     8176        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.MapPeaksMenu)
     8177        G2frame.Bind(wx.EVT_MENU, OnPeaksMove, id=G2gd.wxID_PEAKSMOVE)
     8178        G2frame.Bind(wx.EVT_MENU, OnPeaksViewPoint, id=G2gd.wxID_PEAKSVIEWPT)
     8179        G2frame.Bind(wx.EVT_MENU, OnPeaksDistVP, id=G2gd.wxID_PEAKSDISTVP)
     8180        G2frame.Bind(wx.EVT_MENU, OnPeaksDA, id=G2gd.wxID_PEAKSDA)
     8181        G2frame.Bind(wx.EVT_MENU, OnShowBonds, id=G2gd.wxID_SHOWBONDS)
     8182        G2frame.Bind(wx.EVT_MENU, OnPeaksEquiv, id=G2gd.wxID_FINDEQVPEAKS)
     8183        G2frame.Bind(wx.EVT_MENU, OnPeaksUnique, id=G2gd.wxID_PEAKSUNIQUE)
     8184        G2frame.Bind(wx.EVT_MENU, OnPeaksDelete, id=G2gd.wxID_PEAKSDELETE)
     8185        G2frame.Bind(wx.EVT_MENU, OnPeaksClear, id=G2gd.wxID_PEAKSCLEAR)
    81938186        # MC/SA
    8194         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.MCSAMenu)
    8195         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAaddAtom, id=G2gd.wxID_ADDMCSAATOM)
    8196         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAaddRB, id=G2gd.wxID_ADDMCSARB)
    8197         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAclear, id=G2gd.wxID_CLEARMCSARB)
    8198         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAmove, id=G2gd.wxID_MOVEMCSA)
    8199         G2frame.dataFrame.Bind(wx.EVT_MENU, OnClearResults, id=G2gd.wxID_MCSACLEARRESULTS)
     8187        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.MCSAMenu)
     8188        G2frame.Bind(wx.EVT_MENU, OnMCSAaddAtom, id=G2gd.wxID_ADDMCSAATOM)
     8189        G2frame.Bind(wx.EVT_MENU, OnMCSAaddRB, id=G2gd.wxID_ADDMCSARB)
     8190        G2frame.Bind(wx.EVT_MENU, OnMCSAclear, id=G2gd.wxID_CLEARMCSARB)
     8191        G2frame.Bind(wx.EVT_MENU, OnMCSAmove, id=G2gd.wxID_MOVEMCSA)
     8192        G2frame.Bind(wx.EVT_MENU, OnClearResults, id=G2gd.wxID_MCSACLEARRESULTS)
    82008193        # Texture
    8201         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.TextureMenu)
    8202         G2frame.dataFrame.Bind(wx.EVT_MENU, OnTextureRefine, id=G2gd.wxID_REFINETEXTURE)
    8203 #        G2frame.dataFrame.Bind(wx.EVT_MENU, OnTextureClear, id=G2gd.wxID_CLEARTEXTURE)
     8194        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.TextureMenu)
     8195        G2frame.Bind(wx.EVT_MENU, OnTextureRefine, id=G2gd.wxID_REFINETEXTURE)
     8196#        G2frame.Bind(wx.EVT_MENU, OnTextureClear, id=G2gd.wxID_CLEARTEXTURE)
    82048197        # Pawley reflections
    8205         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.PawleyMenu)
    8206         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySet, id=G2gd.wxID_PAWLEYSET)
    8207         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyLoad, id=G2gd.wxID_PAWLEYLOAD)
    8208         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyEstimate, id=G2gd.wxID_PAWLEYESTIMATE)
    8209         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyUpdate, id=G2gd.wxID_PAWLEYUPDATE)
    8210         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySelAll, id=G2gd.wxID_PAWLEYSELALL)
    8211         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySelNone, id=G2gd.wxID_PAWLEYSELNONE)
    8212         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyToggle, id=G2gd.wxID_PAWLEYSELTOGGLE)
     8198        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.PawleyMenu)
     8199        G2frame.Bind(wx.EVT_MENU, OnPawleySet, id=G2gd.wxID_PAWLEYSET)
     8200        G2frame.Bind(wx.EVT_MENU, OnPawleyLoad, id=G2gd.wxID_PAWLEYLOAD)
     8201        G2frame.Bind(wx.EVT_MENU, OnPawleyEstimate, id=G2gd.wxID_PAWLEYESTIMATE)
     8202        G2frame.Bind(wx.EVT_MENU, OnPawleyUpdate, id=G2gd.wxID_PAWLEYUPDATE)
     8203        G2frame.Bind(wx.EVT_MENU, OnPawleySelAll, id=G2gd.wxID_PAWLEYSELALL)
     8204        G2frame.Bind(wx.EVT_MENU, OnPawleySelNone, id=G2gd.wxID_PAWLEYSELNONE)
     8205        G2frame.Bind(wx.EVT_MENU, OnPawleyToggle, id=G2gd.wxID_PAWLEYSELTOGGLE)
    82138206       
    82148207    # UpdatePhaseData execution starts here
     
    82308223    global rbAtmDict   
    82318224    rbAtmDict = {}
    8232     if G2frame.dataDisplay:
    8233         G2frame.dataDisplay.Destroy()
    82348225    PhaseName = G2frame.PatternTree.GetItemText(Item)
    82358226    G2gd.SetDataMenuBar(G2frame)
    8236     G2frame.dataFrame.SetLabel('Phase Data for '+PhaseName)
    8237     G2frame.dataFrame.CreateStatusBar()
     8227    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+PhaseName)
     8228    G2frame.dataWindow.ClearData()
    82388229    if GSASIIpath.GetConfigValue('debug'):
    8239         G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
    8240             style=wx.aui.AUI_NB_DEFAULT_STYLE ^ wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB)
     8230        G2frame.phaseDisplay = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize(),
     8231            style=wx.aui.AUI_NB_TOP | wx.aui.AUI_NB_TAB_SPLIT | wx.aui.AUI_NB_TAB_MOVE)
    82418232    else:
    8242         G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
    8243     G2frame.dataDisplay.gridList = [] # list of all grids in notebook
     8233        G2frame.phaseDisplay = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize())
     8234    G2frame.phaseDisplay.gridList = [] # list of all grids in notebook
    82448235    Pages = []   
    8245     G2frame.dataDisplay.gridList = []
    8246     General = wx.ScrolledWindow(G2frame.dataDisplay)
    8247     G2frame.dataDisplay.AddPage(General,'General')
     8236    G2frame.phaseDisplay.gridList = []
     8237    General = wx.ScrolledWindow(G2frame.phaseDisplay)
     8238    G2frame.phaseDisplay.AddPage(General,'General')
    82488239    Pages.append('General')
    8249     DData = wx.ScrolledWindow(G2frame.dataDisplay)
    8250     G2frame.dataDisplay.AddPage(DData,'Data')
     8240    DData = wx.ScrolledWindow(G2frame.phaseDisplay)
     8241    G2frame.phaseDisplay.AddPage(DData,'Data')
    82518242    Pages.append('Data')
    8252     Atoms = G2G.GSGrid(G2frame.dataDisplay)
    8253     G2frame.dataDisplay.gridList.append(Atoms)
    8254     G2frame.dataDisplay.AddPage(Atoms,'Atoms')
     8243    Atoms = G2G.GSGrid(G2frame.phaseDisplay)
     8244    G2frame.phaseDisplay.gridList.append(Atoms)
     8245    G2frame.phaseDisplay.AddPage(Atoms,'Atoms')
    82558246    Pages.append('Atoms')
    82568247    if data['General']['Modulated']:
    8257         G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
    8258         G2frame.dataDisplay.AddPage(G2frame.waveData,'Wave Data')
     8248        G2frame.waveData = wx.ScrolledWindow(G2frame.phaseDisplay)
     8249        G2frame.phaseDisplay.AddPage(G2frame.waveData,'Wave Data')
    82598250        Pages.append('Wave Data')
    82608251    if data['General']['Type'] == 'faulted':
    8261         G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
    8262         G2frame.dataDisplay.AddPage(G2frame.layerData,'Layers')
     8252        G2frame.layerData = wx.ScrolledWindow(G2frame.phaseDisplay)
     8253        G2frame.phaseDisplay.AddPage(G2frame.layerData,'Layers')
    82638254        Pages.append('Layers')               
    8264     drawOptions = wx.ScrolledWindow(G2frame.dataDisplay)
    8265     G2frame.dataDisplay.AddPage(drawOptions,'Draw Options')
     8255    drawOptions = wx.ScrolledWindow(G2frame.phaseDisplay)
     8256    G2frame.phaseDisplay.AddPage(drawOptions,'Draw Options')
    82668257    Pages.append('Draw Options')
    8267     drawAtoms = G2G.GSGrid(G2frame.dataDisplay)
    8268     G2frame.dataDisplay.gridList.append(drawAtoms)
    8269     G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
     8258    drawAtoms = G2G.GSGrid(G2frame.phaseDisplay)
     8259    G2frame.phaseDisplay.gridList.append(drawAtoms)
     8260    G2frame.phaseDisplay.AddPage(drawAtoms,'Draw Atoms')
    82708261    Pages.append('Draw Atoms')
    82718262    if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
    8272         RigidBodies = wx.ScrolledWindow(G2frame.dataDisplay)
    8273         G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
     8263        RigidBodies = wx.ScrolledWindow(G2frame.phaseDisplay)
     8264        G2frame.phaseDisplay.AddPage(RigidBodies,'RB Models')
    82748265        Pages.append('RB Models')
    8275     MapPeaks = G2G.GSGrid(G2frame.dataDisplay)
    8276     G2frame.dataDisplay.gridList.append(MapPeaks)   
    8277     G2frame.dataDisplay.AddPage(MapPeaks,'Map peaks')
     8266    MapPeaks = G2G.GSGrid(G2frame.phaseDisplay)
     8267    G2frame.phaseDisplay.gridList.append(MapPeaks)   
     8268    G2frame.phaseDisplay.AddPage(MapPeaks,'Map peaks')
    82788269    Pages.append('Map peaks')
    82798270    if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
    8280         G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
    8281         G2frame.dataDisplay.AddPage(G2frame.MCSA,'MC/SA')
     8271        G2frame.MCSA = wx.ScrolledWindow(G2frame.phaseDisplay)
     8272        G2frame.phaseDisplay.AddPage(G2frame.MCSA,'MC/SA')
    82828273        Pages.append('MC/SA')
    8283     Texture = wx.ScrolledWindow(G2frame.dataDisplay)
    8284     G2frame.dataDisplay.AddPage(Texture,'Texture')
     8274    Texture = wx.ScrolledWindow(G2frame.phaseDisplay)
     8275    G2frame.phaseDisplay.AddPage(Texture,'Texture')
    82858276    Pages.append('Texture')
    8286     G2frame.PawleyRefl = G2G.GSGrid(G2frame.dataDisplay)
    8287     G2frame.dataDisplay.gridList.append(G2frame.PawleyRefl)
    8288     G2frame.dataDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
     8277    G2frame.PawleyRefl = G2G.GSGrid(G2frame.phaseDisplay)
     8278    G2frame.phaseDisplay.gridList.append(G2frame.PawleyRefl)
     8279    G2frame.phaseDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
    82898280    Pages.append('Pawley reflections')
    82908281    G2frame.dataFrame.AtomCompute.Enable(G2gd.wxID_ISODISP,'ISODISTORT' in data)
    82918282    G2frame.dataFrame.AtomCompute.Enable(G2gd.wxID_VALIDPROTEIN,'macro' in data['General']['Type'])
    8292     G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     8283    G2frame.phaseDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
    82938284    FillMenus()
    82948285    if oldPage is None or oldPage == 0:
    82958286        ChangePage(0)
    8296         wx.CallAfter(G2frame.dataDisplay.SendSizeEvent)
     8287        wx.CallAfter(G2frame.phaseDisplay.SendSizeEvent)
    82978288    elif oldPage:
    82988289        SetupGeneral()    # not sure why one might need this when moving from phase to phase; but does not hurt
    8299         G2frame.dataDisplay.SetSelection(oldPage)
     8290        G2frame.phaseDisplay.SetSelection(oldPage)
  • TabularUnified branch/2frame/GSASIIplot.py

    r2871 r2888  
    18261826        Phases = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId,'Reflection Lists'))
    18271827        Page.phaseList = sorted(Phases.keys()) # define an order for phases (once!)
    1828         G2frame.dataFrame.Bind(wx.EVT_MENU, onMoveDiffCurve, id=G2frame.dataFrame.moveDiffCurve.GetId())
    1829         G2frame.dataFrame.Bind(wx.EVT_MENU, onMoveTopTick, id=G2frame.dataFrame.moveTickLoc.GetId())
    1830         G2frame.dataFrame.Bind(wx.EVT_MENU, onMoveTickSpace, id=G2frame.dataFrame.moveTickSpc.GetId())
    1831         G2frame.dataFrame.moveDiffCurve.Enable(False)
    1832         G2frame.dataFrame.moveTickLoc.Enable(False)
    1833         G2frame.dataFrame.moveTickSpc.Enable(False)
     1828        G2frame.dataWindow.Bind(wx.EVT_MENU, onMoveDiffCurve, id=G2frame.dataWindow.moveDiffCurve.GetId())
     1829        G2frame.dataWindow.Bind(wx.EVT_MENU, onMoveTopTick, id=G2frame.dataWindow.moveTickLoc.GetId())
     1830        G2frame.dataWindow.Bind(wx.EVT_MENU, onMoveTickSpace, id=G2frame.dataWindow.moveTickSpc.GetId())
     1831        G2frame.dataWindow.moveDiffCurve.Enable(False)
     1832        G2frame.dataWindow.moveTickLoc.Enable(False)
     1833        G2frame.dataWindow.moveTickSpc.Enable(False)
    18341834    elif G2frame.PatternTree.GetItemText(G2frame.PickId) == 'Peak List':
    1835         G2frame.dataFrame.Bind(wx.EVT_MENU, onMovePeak, id=G2frame.dataFrame.movePeak.GetId())
     1835        G2frame.dataFrame.Bind(wx.EVT_MENU, onMovePeak, id=G2frame.dataWindow.movePeak.GetId())
    18361836    # save information needed to reload from tree and redraw
    18371837    kwargs={'PatternName':G2frame.PatternTree.GetItemText(G2frame.PatternId)}
     
    21542154                        data = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Peak List'))
    21552155                        selectedPeaks = list(set(
    2156                             [row for row,col in G2frame.dataDisplay.GetSelectedCells()] +
    2157                             G2frame.dataDisplay.GetSelectedRows()))
    2158                         G2frame.dataFrame.movePeak.Enable(len(selectedPeaks) == 1) # allow peak move from table when one peak is selected
     2156                            [row for row,col in G2frame.reflGrid.GetSelectedCells()] +
     2157                            G2frame.reflGrid.GetSelectedRows()))
     2158                        G2frame.dataWindow.movePeak.Enable(len(selectedPeaks) == 1) # allow peak move from table when one peak is selected
    21592159                        for i,item in enumerate(data['peaks']):
    21602160                            if i in selectedPeaks:
     
    22922292    if 'PWDR' in G2frame.PatternTree.GetItemText(G2frame.PickId):
    22932293        if len(Page.tickDict.keys()) == 1:
    2294             G2frame.dataFrame.moveTickLoc.Enable(True)
     2294            G2frame.dataWindow.moveTickLoc.Enable(True)
    22952295        elif len(Page.tickDict.keys()) > 1:
    2296             G2frame.dataFrame.moveTickLoc.Enable(True)
    2297             G2frame.dataFrame.moveTickSpc.Enable(True)
     2296            G2frame.dataWindow.moveTickLoc.Enable(True)
     2297            G2frame.dataWindow.moveTickSpc.Enable(True)
    22982298        if DifLine[0]:
    2299             G2frame.dataFrame.moveDiffCurve.Enable(True)
     2299            G2frame.dataWindow.moveDiffCurve.Enable(True)
    23002300   
    23012301################################################################################
     
    43754375      triggers the addition of a d-zero.   
    43764376    '''
    4377     G2frame.dataFrame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value',0)
     4377    G2frame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value',0)
    43784378    G2frame.PickId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Stress/Strain')
    43794379    data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
     
    48564856                        Data['ring'].append([xpos,ypos])
    48574857                elif event.button == 3:
    4858                     G2frame.dataFrame.GetStatusBar().SetStatusText('Calibrating...',0)
     4858                    G2frame.GetStatusBar().SetStatusText('Calibrating...',0)
    48594859                    if G2img.ImageCalibrate(G2frame,Data):
    4860                         G2frame.dataFrame.GetStatusBar().SetStatusText('Calibration successful - Show ring picks to check',0)
     4860                        G2frame.GetStatusBar().SetStatusText('Calibration successful - Show ring picks to check',0)
    48614861                        print 'Calibration successful'
    48624862                    else:
    4863                         G2frame.dataFrame.GetStatusBar().SetStatusText('Calibration failed - Show ring picks to diagnose',0)
     4863                        G2frame.GetStatusBar().SetStatusText('Calibration failed - Show ring picks to diagnose',0)
    48644864                        print 'Calibration failed'
    48654865                    G2frame.ifGetRing = False
     
    62476247        GL.glMultMatrixf(B4mat.T)
    62486248        GL.glDisable(GL.GL_LIGHTING)
    6249         GL.glRasterPos3f(0,0,0)
     6249        GL.glWindowPos3f(0,0,0)
    62506250        GL.glMultMatrixf(matRot)
    62516251        GL.glRotate(180,1,0,0)             #fix to flip about x-axis
     
    62546254        GL.glEnable(GL.GL_LIGHTING)
    62556255        GL.glPopMatrix()
    6256        
     6256         
    62576257    def RenderMap(rho,rhoXYZ,indx,Rok):
    62586258        GL.glShadeModel(GL.GL_FLAT)
  • TabularUnified branch/2frame/GSASIIpwdGUI.py

    r2846 r2888  
    2020import wx
    2121import wx.grid as wg
    22 import wx.lib.scrolledpanel as wxscroll
    2322import numpy as np
    2423import numpy.ma as ma
     
    424423    '''respond to selection of PWDR powder peaks data tree item.
    425424    '''
    426     if G2frame.dataDisplay:
    427         G2frame.dataFrame.Clear()
    428        
    429425    def OnAutoSearch(event):
    430426        PatternId = G2frame.PatternId
     
    495491        for item in ['Background','Instrument Parameters','Peak List']:
    496492            G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item),cPickle.load(file))
    497             if G2frame.dataDisplay.GetName() == item:
     493            if G2frame.dataWindow.GetName() == item:
    498494                if item == 'Background':
    499495                    UpdateBackground(G2frame,G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, item)))
     
    515511       
    516512    def OnLSQPeakFit(event):
    517         if G2frame.dataDisplay.IsCellEditControlEnabled(): # complete any grid edits in progress
    518             G2frame.dataDisplay.HideCellEditControl()
    519             G2frame.dataDisplay.DisableCellEditControl()
     513        if reflGrid.IsCellEditControlEnabled(): # complete any grid edits in progress
     514            reflGrid.HideCellEditControl()
     515            reflGrid.DisableCellEditControl()
    520516        if not G2frame.GSASprojectfile:            #force a save of the gpx file so SaveState can write in the same directory
    521517            G2frame.OnFileSaveas(event)
     
    523519       
    524520    def OnOneCycle(event):
    525         if G2frame.dataDisplay.IsCellEditControlEnabled(): # complete any grid edits in progress
    526             G2frame.dataDisplay.HideCellEditControl()
    527             G2frame.dataDisplay.DisableCellEditControl()
     521        if reflGrid.IsCellEditControlEnabled(): # complete any grid edits in progress
     522            reflGrid.HideCellEditControl()
     523            reflGrid.DisableCellEditControl()
    528524        wx.CallAfter(OnPeakFit,'LSQ',oneCycle=True)
    529525       
     
    672668       
    673669    def setBackgroundColors():
    674        for r in range(G2frame.dataDisplay.GetNumberRows()):
    675            for c in range(G2frame.dataDisplay.GetNumberCols()):
    676                if G2frame.dataDisplay.GetColLabelValue(c) in ['position','intensity','alpha','beta','sigma','gamma']:
    677                    if float(G2frame.dataDisplay.GetCellValue(r,c)) < 0.:
    678                        G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.RED)
     670       for r in range(reflGrid.GetNumberRows()):
     671           for c in range(reflGrid.GetNumberCols()):
     672               if reflGrid.GetColLabelValue(c) in ['position','intensity','alpha','beta','sigma','gamma']:
     673                   if float(reflGrid.GetCellValue(r,c)) < 0.:
     674                       reflGrid.SetCellBackgroundColour(r,c,wx.RED)
    679675                   else:
    680                        G2frame.dataDisplay.SetCellBackgroundColour(r,c,wx.WHITE)
     676                       reflGrid.SetCellBackgroundColour(r,c,wx.WHITE)
    681677                                                 
    682678    def KeyEditPeakGrid(event):
     
    684680        in the Peak List table
    685681        '''
    686         rowList = G2frame.dataDisplay.GetSelectedRows()
    687         colList = G2frame.dataDisplay.GetSelectedCols()
    688         selectList = G2frame.dataDisplay.GetSelectedCells()
     682        rowList = reflGrid.GetSelectedRows()
     683        colList = reflGrid.GetSelectedCols()
     684        selectList = reflGrid.GetSelectedCells()
    689685        data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
    690686        if event.GetKeyCode() == wx.WXK_RETURN:
     
    696692        elif rowList and (event.GetKeyCode() == wx.WXK_DELETE or event.GetKeyCode() == 8):
    697693            # pressing the delete key or backspace deletes selected peak(s)
    698             G2frame.dataDisplay.ClearSelection()
    699             G2frame.dataDisplay.ClearGrid()
     694            reflGrid.ClearSelection()
     695            reflGrid.ClearGrid()
    700696            rowList.sort()
    701697            rowList.reverse()
     
    707703                msg = wg.GridTableMessage(G2frame.PeakTable,
    708704                    wg.GRIDTABLE_NOTIFY_ROWS_DELETED,0,nDel)
    709                 G2frame.dataDisplay.ProcessTableMessage(msg)
     705                reflGrid.ProcessTableMessage(msg)
    710706            data['peaks'] = G2frame.PeakTable.GetData()[:-nDel]
    711707            G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
    712             wx.CallAfter(G2frame.dataDisplay.ForceRefresh)
     708            wx.CallAfter(reflGrid.ForceRefresh)
    713709            setBackgroundColors()
    714710        elif colList and (event.GetKeyCode() == 89 or event.GetKeyCode() == 78):
    715             G2frame.dataDisplay.ClearSelection()
     711            reflGrid.ClearSelection()
    716712            key = event.GetKeyCode()
    717713            for col in colList:
     
    722718                        for row in range(G2frame.PeakTable.GetNumberRows()): data['peaks'][row][col]=False
    723719        elif selectList and (event.GetKeyCode() == 89 or event.GetKeyCode() == 78):
    724             G2frame.dataDisplay.ClearSelection()
     720            reflGrid.ClearSelection()
    725721            key = event.GetKeyCode()
    726722            for row,col in selectList:
     
    734730            return
    735731        G2plt.PlotPatterns(G2frame,plotType='PWDR')
    736         #wx.CallAfter(G2frame.dataDisplay.ForceRefresh) # did not always work
     732        #wx.CallAfter(G2frame.dataWindow.ForceRefresh) # did not always work
    737733        wx.CallAfter(UpdatePeakGrid,G2frame,data)
    738734           
     
    740736        '''Set or clear peak refinement variables for peaks listed in rows
    741737        '''
    742         refOpts = {G2frame.dataDisplay.GetColLabelValue(i):i+1 for i in range(G2frame.dataDisplay.GetNumberCols()) if G2frame.dataDisplay.GetColLabelValue(i) != "refine"}
     738        refOpts = {reflGrid.GetColLabelValue(i):i+1 for i in range(reflGrid.GetNumberCols()) if reflGrid.GetColLabelValue(i) != "refine"}
    743739        dlg = G2G.G2MultiChoiceDialog(
    744740            G2frame.dataFrame,
     
    762758        '''set refinement flags for the selected peaks
    763759        '''
    764         rows = list(set([row for row,col in G2frame.dataDisplay.GetSelectedCells()] +
    765                         G2frame.dataDisplay.GetSelectedRows()))
     760        rows = list(set([row for row,col in reflGrid.GetSelectedCells()] +
     761                        reflGrid.GetSelectedRows()))
    766762        if not rows:
    767763            wx.MessageBox('No selected rows. You must select rows or cells before using this command',
     
    773769        '''set refinement flags for all peaks
    774770        '''
    775         SelectVars(range(G2frame.dataDisplay.GetNumberRows()))
     771        SelectVars(range(reflGrid.GetNumberRows()))
    776772
    777773    def onCellListSClick(event):
     
    786782        '''Called after a double-click on a cell label'''
    787783        r,c =  event.GetRow(),event.GetCol()
    788         grid = G2frame.dataDisplay
    789784        if r < 0 and c < 0:
    790             for row in range(grid.GetNumberRows()):
    791                 grid.SelectRow(row,True)                   
    792             for col in range(grid.GetNumberCols()):
    793                 grid.SelectCol(col,True)                   
     785            for row in range(reflGrid.GetNumberRows()):
     786                reflGrid.SelectRow(row,True)                   
     787            for col in range(reflGrid.GetNumberCols()):
     788                reflGrid.SelectCol(col,True)                   
    794789        elif r > 0:     #row label: select it and replot!
    795             grid.ClearSelection()
    796             grid.SelectRow(r,True)
    797             wx.CallAfter(G2frame.dataDisplay.ForceRefresh)
     790            reflGrid.ClearSelection()
     791            reflGrid.SelectRow(r,True)
     792            wx.CallAfter(G2frame.dataWindow.ForceRefresh)
    798793            wx.CallAfter(G2plt.PlotPatterns,G2frame,plotType='PWDR')
    799794        elif c > 0:     #column label: just select it (& redisplay)
    800             grid.ClearSelection()
    801             grid.SelectCol(c,True)
    802             if grid.GetColLabelValue(c) != 'refine': return
     795            reflGrid.ClearSelection()
     796            reflGrid.SelectCol(c,True)
     797            if reflGrid.GetColLabelValue(c) != 'refine': return
    803798            choice = ['Y - vary all','N - vary none',]
    804799            dlg = wx.SingleChoiceDialog(G2frame.dataFrame,
    805                                         'Select refinement option for '+grid.GetColLabelValue(c-1),
     800                                        'Select refinement option for '+reflGrid.GetColLabelValue(c-1),
    806801                                        'Refinement controls',choice)
    807802            dlg.CenterOnParent()
     
    809804                sel = dlg.GetSelection()
    810805                if sel == 0:
    811                     for row in range(grid.GetNumberRows()): data['peaks'][row][c]=True
     806                    for row in range(reflGrid.GetNumberRows()): data['peaks'][row][c]=True
    812807                else:
    813                     for row in range(grid.GetNumberRows()): data['peaks'][row][c]=False
     808                    for row in range(reflGrid.GetNumberRows()): data['peaks'][row][c]=False
    814809            wx.CallAfter(UpdatePeakGrid,G2frame,data)
    815810                 
     
    817812    # beginning of UpdatePeakGrid init
    818813    #======================================================================
    819     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PeakMenu)
    820     if not G2frame.dataFrame.GetStatusBar():
    821         Status = G2frame.dataFrame.CreateStatusBar()
    822     Status.SetStatusText('Global refine: select refine column & press Y or N')
     814    G2frame.dataWindow.ClearData()
     815    G2frame.GetStatusBar().SetStatusText('Global refine: select refine column & press Y or N')
     816    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.PeakMenu)
    823817    G2frame.Bind(wx.EVT_MENU, OnAutoSearch, id=G2gd.wxID_AUTOSEARCH)
    824818    G2frame.Bind(wx.EVT_MENU, OnCopyPeaks, id=G2gd.wxID_PEAKSCOPY)
     
    832826    G2frame.Bind(wx.EVT_MENU, OnResetSigGam, id=G2gd.wxID_RESETSIGGAM)
    833827    if data['peaks']:
    834         G2frame.dataFrame.AutoSearch.Enable(False)
    835         G2frame.dataFrame.PeakCopy.Enable(True)
    836         G2frame.dataFrame.PeakFit.Enable(True)
    837         G2frame.dataFrame.PFOneCycle.Enable(True)
    838         G2frame.dataFrame.SeqPeakFit.Enable(True)
     828        G2frame.dataWindow.AutoSearch.Enable(False)
     829        G2frame.dataWindow.PeakCopy.Enable(True)
     830        G2frame.dataWindow.PeakFit.Enable(True)
     831        G2frame.dataWindow.PFOneCycle.Enable(True)
     832        G2frame.dataWindow.SeqPeakFit.Enable(True)
    839833    else:
    840         G2frame.dataFrame.PeakFit.Enable(False)
    841         G2frame.dataFrame.PeakCopy.Enable(False)
    842         G2frame.dataFrame.PFOneCycle.Enable(False)
    843         G2frame.dataFrame.AutoSearch.Enable(True)
    844         G2frame.dataFrame.SeqPeakFit.Enable(False)
     834        G2frame.dataWindow.PeakFit.Enable(False)
     835        G2frame.dataWindow.PeakCopy.Enable(False)
     836        G2frame.dataWindow.PFOneCycle.Enable(False)
     837        G2frame.dataWindow.AutoSearch.Enable(True)
     838        G2frame.dataWindow.SeqPeakFit.Enable(False)
    845839    G2frame.PickTable = []
    846840    rowLabels = []
     
    875869    G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
    876870    G2frame.PeakTable = G2G.Table(data['peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    877     G2frame.dataFrame.SetLabel('Peak List')
     871    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Peak List')
    878872    G2frame.dataFrame.currentGrids = []
    879     G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
    880     G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
     873    reflGrid = G2G.GSGrid(parent=G2frame.dataWindow)
     874    reflGrid.SetTable(G2frame.PeakTable, True)
    881875    setBackgroundColors()                         
    882     G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
    883     G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
    884     G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, onCellListSClick)
    885 #    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, onCellListSClick)
    886     G2frame.dataDisplay.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, onCellListDClick)
    887 #    G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, onCellListDClick)
    888     G2frame.dataDisplay.SetMargins(0,0)
    889     G2frame.dataDisplay.AutoSizeColumns(False)
    890     G2frame.dataFrame.setSizePosLeft([535,350])
    891     #G2frame.dataFrame.SendSizeEvent()
     876    reflGrid.Bind(wg.EVT_GRID_CELL_CHANGE, RefreshPeakGrid)
     877    reflGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
     878    reflGrid.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, onCellListSClick)
     879#    G2frame.dataWindow.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, onCellListSClick)
     880    reflGrid.Bind(wg.EVT_GRID_LABEL_LEFT_DCLICK, onCellListDClick)
     881#    G2frame.dataWindow.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, onCellListDClick)
     882    reflGrid.SetMargins(0,0)
     883    reflGrid.AutoSizeColumns(False)
     884    G2frame.reflGrid = reflGrid
     885    mainSizer = wx.BoxSizer(wx.VERTICAL)
     886    mainSizer.Add(reflGrid)
     887    mainSizer.Layout()   
     888    G2frame.dataWindow.SetSizer(mainSizer)
     889    mainSizer.Fit(G2frame.dataWindow)
     890    G2frame.SetDataSize()   
    892891
    893892################################################################################
     
    11081107        backSizer = wx.BoxSizer(wx.VERTICAL)
    11091108        topSizer = wx.BoxSizer(wx.HORIZONTAL)
    1110         topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background function: '),0,WACV)
    1111         bakType = wx.ComboBox(G2frame.dataDisplay,value=data[0][0],
     1109        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background function: '),0,WACV)
     1110        bakType = wx.ComboBox(G2frame.dataWindow,value=data[0][0],
    11121111                choices=Choices,style=wx.CB_READONLY|wx.CB_DROPDOWN)
    11131112        bakType.Bind(wx.EVT_COMBOBOX, OnNewType)
    11141113        topSizer.Add(bakType)
    11151114        topSizer.Add((5,0),0)
    1116         bakRef = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
     1115        bakRef = wx.CheckBox(G2frame.dataWindow,label=' Refine?')
    11171116        bakRef.SetValue(bool(data[0][1]))
    11181117        bakRef.Bind(wx.EVT_CHECKBOX, OnBakRef)
    11191118        topSizer.Add(bakRef,0,WACV)
    1120         topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
    1121         bakTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
     1119        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' No. coeff.: '),0,WACV)
     1120        bakTerms = wx.ComboBox(G2frame.dataWindow,-1,value=str(data[0][2]),choices=[str(i+1) for i in range(36)],
    11221121            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    11231122        bakTerms.Bind(wx.EVT_COMBOBOX,OnBakTerms)
     
    11251124        topSizer.Add((5,0),0)
    11261125        backSizer.Add(topSizer)
    1127         backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background coefficients:'),0,WACV)
     1126        backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background coefficients:'),0,WACV)
    11281127        bakSizer = wx.FlexGridSizer(0,5,5,5)
    11291128        for i,value in enumerate(data[0][3:]):
    1130             bakVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[0],i+3,nDig=(10,4),typeHint=float)
     1129            bakVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[0],i+3,nDig=(10,4),typeHint=float)
    11311130            bakSizer.Add(bakVal,0,WACV)
    11321131        backSizer.Add(bakSizer)
     
    11691168        debSizer = wx.BoxSizer(wx.VERTICAL)
    11701169        topSizer = wx.BoxSizer(wx.HORIZONTAL)
    1171         topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye scattering: '),0,WACV)
    1172         topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. coeff.: '),0,WACV)
    1173         debTerms = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
     1170        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Debye scattering: '),0,WACV)
     1171        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' No. coeff.: '),0,WACV)
     1172        debTerms = wx.ComboBox(G2frame.dataWindow,-1,value=str(data[1]['nDebye']),choices=[str(i) for i in range(12)],
    11741173            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    11751174        debTerms.Bind(wx.EVT_COMBOBOX,OnDebTerms)
     
    11781177        debSizer.Add(topSizer)
    11791178        if data[1]['nDebye']:
    1180             debSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Debye diffuse terms:'),0,WACV)       
     1179            debSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Debye diffuse terms:'),0,WACV)       
    11811180            rowLabels = []
    11821181            for i in range(len(data[1]['debyeTerms'])): rowLabels.append(str(i))
     
    11861185            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
    11871186            debyeTable = G2G.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    1188             debyeGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
     1187            debyeGrid = G2G.GSGrid(parent=G2frame.dataWindow)
    11891188            debyeGrid.SetTable(debyeTable, True)
    11901189            debyeGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
     
    12281227        peaksSizer = wx.BoxSizer(wx.VERTICAL)
    12291228        topSizer = wx.BoxSizer(wx.HORIZONTAL)
    1230         topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peaks in background: '),0,WACV)
    1231         topSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' No. peaks: '),0,WACV)
    1232         peaks = wx.ComboBox(G2frame.dataDisplay,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(30)],
     1229        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Peaks in background: '),0,WACV)
     1230        topSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' No. peaks: '),0,WACV)
     1231        peaks = wx.ComboBox(G2frame.dataWindow,-1,value=str(data[1]['nPeaks']),choices=[str(i) for i in range(30)],
    12331232            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    12341233        peaks.Bind(wx.EVT_COMBOBOX,OnPeaks)
     
    12381237        G2frame.dataFrame.currentGrids = []
    12391238        if data[1]['nPeaks']:
    1240             peaksSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Peak list:'),0,WACV)       
     1239            peaksSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Peak list:'),0,WACV)       
    12411240            rowLabels = []
    12421241            for i in range(len(data[1]['peaksList'])): rowLabels.append(str(i))
     
    12471246            wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
    12481247            peaksTable = G2G.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    1249             peaksGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
     1248            peaksGrid = G2G.GSGrid(parent=G2frame.dataWindow)
    12501249            peaksGrid.SetTable(peaksTable, True)
    12511250            peaksGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
     
    12541253        return peaksSizer
    12551254               
    1256     if G2frame.dataDisplay:
    1257         G2frame.dataFrame.DestroyChildren()
    1258     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
    1259     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.BackMenu)
    1260     G2frame.dataFrame.SetLabel('Background')
    1261     if not G2frame.dataFrame.GetStatusBar():
    1262         G2frame.dataFrame.CreateStatusBar()
     1255    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.BackMenu)
     1256    G2frame.dataWindow.ClearData()
    12631257    G2frame.Bind(wx.EVT_MENU,OnBackCopy,id=G2gd.wxID_BACKCOPY)
    12641258    G2frame.Bind(wx.EVT_MENU,OnBackFlagCopy,id=G2gd.wxID_BACKFLAGCOPY)
     
    12761270    mainSizer.Add(PeaksSizer())
    12771271    mainSizer.Layout()   
    1278     G2frame.dataDisplay.SetSizer(mainSizer)
    1279     Size = mainSizer.Fit(G2frame.dataFrame)
    1280     G2frame.dataFrame.setSizePosLeft(Size)
     1272    G2frame.dataWindow.SetSizer(mainSizer)
     1273    mainSizer.Fit(G2frame.dataFrame)
     1274    G2frame.SetDataSize()
    12811275       
    12821276################################################################################
     
    12971291        labels = ['Tmin','Tmax']
    12981292        for i in [0,1]:
    1299             limits.Add(wx.StaticText(G2frame.dataDisplay,label=' Original %s: %.4f'%(labels[0],data[0][i])),0,WACV)
    1300             limits.Add(wx.StaticText(G2frame.dataDisplay,label=' New: '),0,WACV)
    1301             limits.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[1],i,  \
     1293            limits.Add(wx.StaticText(G2frame.dataWindow,label=' Original %s: %.4f'%(labels[0],data[0][i])),0,WACV)
     1294            limits.Add(wx.StaticText(G2frame.dataWindow,label=' New: '),0,WACV)
     1295            limits.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[1],i,  \
    13021296                min=data[0][0],max=data[0][1],nDig=(10,4),typeHint=float,OnLeave=AfterChange))
    13031297        return limits
     
    13141308        Indx = {}
    13151309        excl = wx.FlexGridSizer(0,3,0,5)
    1316         excl.Add(wx.StaticText(G2frame.dataDisplay,label=' From: '),0,WACV)
    1317         excl.Add(wx.StaticText(G2frame.dataDisplay,label=' To: '),0,WACV)
    1318         excl.Add(wx.StaticText(G2frame.dataDisplay,label=' Delete?: '),0,WACV)
     1310        excl.Add(wx.StaticText(G2frame.dataWindow,label=' From: '),0,WACV)
     1311        excl.Add(wx.StaticText(G2frame.dataWindow,label=' To: '),0,WACV)
     1312        excl.Add(wx.StaticText(G2frame.dataWindow,label=' Delete?: '),0,WACV)
    13191313        for id,item in enumerate(data[2:]):
    13201314            for i in [0,1]:
    1321                 excl.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,i,  \
     1315                excl.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,item,i,  \
    13221316                    min=data[0][0],max=data[0][1],nDig=(10,4),typeHint=float,OnLeave=AfterChange))
    1323             delExcl = wx.CheckBox(G2frame.dataDisplay,label='')
     1317            delExcl = wx.CheckBox(G2frame.dataWindow,label='')
    13241318            Indx[delExcl.GetId()] = id
    13251319            delExcl.Bind(wx.EVT_CHECKBOX,OnDelExcl)
     
    13561350        if len(data)>2:
    13571351#            mainSizer.Add((0,5),0)
    1358             mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Excluded regions:'),0,WACV)
     1352            mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Excluded regions:'),0,WACV)
    13591353            mainSizer.Add(ExclSizer())
    13601354        mainSizer.Layout()   
    1361         G2frame.dataDisplay.SetSizer(mainSizer)
    1362         Size = mainSizer.Fit(G2frame.dataFrame)
    1363         G2frame.dataFrame.setSizePosLeft(Size)
    1364        
    1365     if G2frame.dataDisplay:
     1355        G2frame.dataWindow.SetSizer(mainSizer)
     1356        mainSizer.Fit(G2frame.dataFrame)
     1357        G2frame.SetDataSize()
     1358       
     1359    if G2frame.dataWindow:
    13661360        G2frame.dataFrame.DestroyChildren()
    13671361    G2frame.ifGetExclude = False
    1368     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
    1369     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LimitMenu)
    1370     G2frame.dataFrame.SetLabel('Limits')
    1371     if not G2frame.dataFrame.GetStatusBar():
    1372         G2frame.dataFrame.CreateStatusBar()
     1362    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.LimitMenu)
     1363    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Limits')
    13731364    G2frame.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
    13741365    G2frame.Bind(wx.EVT_MENU,OnAddExcl,id=G2gd.wxID_ADDEXCLREGION)
     
    16831674    def RefineBox(item):
    16841675        'Define a refine checkbox with binding'
    1685         wid = wx.CheckBox(G2frame.dataDisplay,label=' Refine?  ')
     1676        wid = wx.CheckBox(G2frame.dataWindow,label=' Refine?  ')
    16861677        wid.SetValue(bool(insRef[item]))
    16871678        RefObj[wid.GetId()] = item
     
    17061697
    17071698    def MakeParameterWindow():
    1708         'Displays the Instrument parameters in the datadisplay frame'
    1709         if G2frame.dataDisplay:
    1710             G2frame.dataFrame.Clear()
    1711         G2frame.dataFrame.SetLabel('Instrument Parameters')
    1712         G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     1699        'Displays the Instrument parameters in the dataWindow frame'
     1700        G2frame.dataFrame.ClearData()
     1701        G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Instrument Parameters')
    17131702        mainSizer = wx.BoxSizer(wx.VERTICAL)
    17141703        instSizer = wx.FlexGridSizer(0,6,5,5)
     
    17171706            insVal['Bank'] = 1
    17181707        text = ' Histogram Type: %s  Bank: %d'%(insVal['Type'],insVal['Bank'])
    1719         subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,text),0,WACV)
     1708        subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,text),0,WACV)
    17201709        mainSizer.Add(subSizer)
    17211710        labelLst[:],elemKeysLst[:],dspLst[:],refFlgElem[:] = [],[],[],[]
     
    17281717                if 'Lam1' in insVal:
    17291718                    subSizer = wx.BoxSizer(wx.HORIZONTAL)
    1730                     subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: '),0,WACV)
     1719                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Azimuth: '),0,WACV)
    17311720                    txt = '%7.2f'%(insVal['Azimuth'])
    1732                     subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
    1733                     subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'   Ka1/Ka2: '),0,WACV)
     1721                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
     1722                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'   Ka1/Ka2: '),0,WACV)
    17341723                    txt = u'  %8.6f/%8.6f\xc5'%(insVal['Lam1'],insVal['Lam2'])
    1735                     subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
     1724                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
    17361725                    waveSizer = wx.BoxSizer(wx.HORIZONTAL)
    1737                     waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Source type: '),0,WACV)
     1726                    waveSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  Source type: '),0,WACV)
    17381727                    # PATCH?: for now at least, Source is not saved anywhere before here
    17391728                    if 'Source' not in data: data['Source'] = ['CuKa','?']
    17401729                    choice = ['TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
    1741                     lamPick = wx.ComboBox(G2frame.dataDisplay,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
     1730                    lamPick = wx.ComboBox(G2frame.dataWindow,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
    17421731                    lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
    17431732                    waveSizer.Add(lamPick,0)
     
    17451734                    mainSizer.Add(subSizer)
    17461735                    instSizer.Add(wx.StaticText(
    1747                         G2frame.dataDisplay,-1,
     1736                        G2frame.dataWindow,-1,
    17481737                        lblWdef('I(L2)/I(L1)',4,insDef['I(L2)/I(L1)'])),
    17491738                        0,WACV)
     
    17531742                    dspLst.append([10,4])
    17541743                    refFlgElem.append([key,2])                   
    1755                     ratVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
     1744                    ratVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,key,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
    17561745                    instSizer.Add(ratVal,0)
    17571746                    instSizer.Add(RefineBox(key),0,WACV)
     
    17601749                    instSizer.Add((5,5),0)               
    17611750                else: # single wavelength
    1762                     instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Azimuth: '),0,WACV)
     1751                    instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Azimuth: '),0,WACV)
    17631752                    txt = '%7.2f'%(insVal['Azimuth'])
    1764                     instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
     1753                    instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
    17651754                    instSizer.Add((5,5),0)
    17661755                    key = 'Lam'
    1767                     instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
     1756                    instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
    17681757                        0,WACV)
    1769                     waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
     1758                    waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
    17701759                    labelLst.append(u'Lam (\xc5)')
    17711760                    elemKeysLst.append([key,1])
     
    17861775                        dspLst.append([10,4])
    17871776                        instSizer.Add(
    1788                             wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,4,insDef[item])),
     1777                            wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,4,insDef[item])),
    17891778                            0,WACV)
    1790                         itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
     1779                        itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
    17911780                        instSizer.Add(itemVal,0,WACV)
    17921781                        refFlgElem.append([item,2])
     
    18161805                    refFlgElem.append([item,2])
    18171806                    instSizer.Add(
    1818                         wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,nDig[1],insDef[item])),
     1807                        wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,nDig[1],insDef[item])),
    18191808                        0,WACV)
    1820                     itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
     1809                    itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
    18211810                    instSizer.Add(itemVal,0,WACV)
    18221811                    instSizer.Add(RefineBox(item),0,WACV)
    18231812            elif 'T' in insVal['Type']:                                   #time of flight (neutrons)
    18241813                subSizer = wx.BoxSizer(wx.HORIZONTAL)
    1825                 subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Fligth path: '),0,WACV)
     1814                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Fligth path: '),0,WACV)
    18261815                txt = '%8.3f'%(insVal['fltPath'])
    1827                 subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
     1816                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
    18281817                labelLst.append('flight path')
    18291818                elemKeysLst.append(['fltPath',1])
    18301819                dspLst.append([10,2])
    18311820                refFlgElem.append(None)                   
    1832                 subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  2-theta: '),0,WACV)
     1821                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  2-theta: '),0,WACV)
    18331822                txt = '%7.2f'%(insVal['2-theta'])
    1834                 subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
     1823                subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
    18351824                labelLst.append('2-theta')
    18361825                elemKeysLst.append(['2-theta',1])
     
    18391828                if 'Pdabc' in Inst2:
    18401829                    Items = ['sig-0','sig-1','sig-2','sig-q','X','Y']
    1841                     subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  difC: '),0,WACV)
     1830                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  difC: '),0,WACV)
    18421831                    txt = '%8.2f'%(insVal['difC'])
    1843                     subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,txt.strip()),0,WACV)
     1832                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,txt.strip()),0,WACV)
    18441833                    labelLst.append('difC')
    18451834                    elemKeysLst.append(['difC',1])
    18461835                    dspLst.append([10,2])
    18471836                    refFlgElem.append(None)
    1848                     subSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  alpha, beta: fixed by table'),0,WACV)
     1837                    subSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  alpha, beta: fixed by table'),0,WACV)
    18491838                else:
    18501839                    Items = ['difC','difA','difB','Zero','alpha','beta-0','beta-1','beta-q','sig-0','sig-1','sig-2','sig-q','X','Y']
     
    18621851                        nDig = (12,6)
    18631852                    instSizer.Add(
    1864                             wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,nDig[1],insDef[item])),
     1853                            wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,nDig[1],insDef[item])),
    18651854                            0,WACV)
    1866                     itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
     1855                    itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=nDig,typeHint=float,OnLeave=AfterChange)
    18671856                    instSizer.Add(itemVal,0,WACV)
    18681857                    labelLst.append(item)
     
    18731862            elif 'PKS' in insVal['Type']:   #peak positions only
    18741863                key = 'Lam'
    1875                 instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
     1864                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef[key])),
    18761865                    0,WACV)
    1877                 waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
     1866                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,key,nDig=(10,6),typeHint=float,OnLeave=AfterChange)
    18781867                labelLst.append(u'Lam (\xc5)')
    18791868                elemKeysLst.append([key,1])
     
    18881877                        dspLst.append([10,4])
    18891878                        instSizer.Add(
    1890                             wx.StaticText(G2frame.dataDisplay,-1,lblWdef(item,4,insDef[item])),
     1879                            wx.StaticText(G2frame.dataWindow,-1,lblWdef(item,4,insDef[item])),
    18911880                            0,WACV)
    1892                         itemVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
     1881                        itemVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,item,nDig=(10,4),typeHint=float,OnLeave=AfterChange)
    18931882                        instSizer.Add(itemVal,0,WACV)
    18941883                        refFlgElem.append([item,2])
     
    18981887        elif 'S' in insVal['Type']:                       #single crystal data
    18991888            if 'C' in insVal['Type']:               #constant wavelength
    1900                 instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
     1889                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
    19011890                    0,WACV)
    1902                 waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
     1891                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
    19031892                instSizer.Add(waveVal,0,WACV)
    19041893                labelLst.append(u'Lam (\xc5)')
    19051894                waveSizer = wx.BoxSizer(wx.HORIZONTAL)
    1906                 waveSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Source type: '),0,WACV)
     1895                waveSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  Source type: '),0,WACV)
    19071896                # PATCH?: for now at least, Source is not saved anywhere before here
    19081897                if 'Source' not in data: data['Source'] = ['CuKa','?']
    19091898                choice = ['synchrotron','TiKa','CrKa','FeKa','CoKa','CuKa','MoKa','AgKa']
    1910                 lamPick = wx.ComboBox(G2frame.dataDisplay,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
     1899                lamPick = wx.ComboBox(G2frame.dataWindow,value=data['Source'][1],choices=choice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
    19111900                lamPick.Bind(wx.EVT_COMBOBOX, OnLamPick)
    19121901                waveSizer.Add(lamPick,0,WACV)
     
    19191908        elif insVal['Type'][0] in ['L','R',]:
    19201909            if 'C' in insVal['Type']:       
    1921                 instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
     1910                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,u' Lam (\xc5): (%10.6f)'%(insDef['Lam'])),
    19221911                    0,WACV)
    1923                 waveVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
     1912                waveVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,insVal,'Lam',nDig=(10,6),typeHint=float,OnLeave=AfterChange)
    19241913                instSizer.Add(waveVal,0,WACV)
    19251914                labelLst.append(u'Lam (\xc5)')
     
    19271916                dspLst.append([10,6])
    19281917                refFlgElem.append(None)
    1929                 instSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'  Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
     1918                instSizer.Add(wx.StaticText(G2frame.dataWindow,-1,'  Azimuth: %7.2f'%(insVal['Azimuth'])),0,WACV)
    19301919                labelLst.append('Azimuth angle')
    19311920                elemKeysLst.append(['Azimuth',1])
     
    19371926        mainSizer.Add(instSizer,0)
    19381927        mainSizer.Layout()   
    1939         G2frame.dataDisplay.SetSizer(mainSizer)
    1940         G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
    1941         G2frame.dataFrame.SendSizeEvent()  # this causes a frame repaint, even if the size does not change!
     1928        G2frame.dataWindow.SetSizer(mainSizer)
     1929        mainSizer.Fit(G2frame.dataWindow)
     1930        G2frame.SetDataSize()   
    19421931        # end of MakeParameterWindow
    19431932               
     
    19961985    #end of patch
    19971986    if 'P' in insVal['Type']:                   #powder data menu commands
    1998         G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.InstMenu)
    1999         if not G2frame.dataFrame.GetStatusBar():
    2000             Status = G2frame.dataFrame.CreateStatusBar()           
    2001             Status.SetStatusText('NB: Azimuth is used for polarization only')
     1987        G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.InstMenu)
     1988        G2frame.dataWindow.ClearData()
     1989        G2frame.GetStatusBar().SetStatusText('NB: Azimuth is used for polarization only')
    20021990        G2frame.Bind(wx.EVT_MENU,OnCalibrate,id=G2gd.wxID_INSTCALIB)
    20031991        G2frame.Bind(wx.EVT_MENU,OnLoad,id=G2gd.wxID_INSTLOAD)
     
    20101998        G2frame.Bind(wx.EVT_MENU,OnCopy1Val,id=G2gd.wxID_INST1VAL)
    20111999    elif 'L' in insVal['Type'] or 'R' in insVal['Type']:                   #SASD data menu commands
    2012         G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SASDInstMenu)
    2013         if not G2frame.dataFrame.GetStatusBar():
    2014             Status = G2frame.dataFrame.CreateStatusBar()
     2000        G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.SASDInstMenu)
    20152001        G2frame.Bind(wx.EVT_MENU,OnInstCopy,id=G2gd.wxID_INSTCOPY)
    20162002    MakeParameterWindow()
     
    23812367            G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    23822368    histName = G2frame.PatternTree.GetItemText(G2frame.PatternId)
    2383     if G2frame.dataDisplay:
    2384         G2frame.dataFrame.Clear()
    2385     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SampleMenu)
    2386     G2frame.dataFrame.SetLabel('Sample Parameters')
     2369    G2frame.dataWindow.ClearData()
     2370    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.SampleMenu)
     2371    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Sample Parameters')
    23872372    G2frame.Bind(wx.EVT_MENU, OnSetScale, id=G2gd.wxID_SETSCALE)
    23882373    G2frame.Bind(wx.EVT_MENU, OnSampleCopy, id=G2gd.wxID_SAMPLECOPY)
     
    23962381    if histName[:4] in ['SASD','REFD','PWDR']:
    23972382        G2frame.dataFrame.SetScale.Enable(True)
    2398     if not G2frame.dataFrame.GetStatusBar():
    2399         G2frame.dataFrame.CreateStatusBar()   
    2400     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
    24012383    Controls = G2frame.PatternTree.GetItemPyData(
    24022384        G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Controls'))
     
    24442426    topSizer = wx.BoxSizer(wx.HORIZONTAL)
    24452427    topSizer.Add((-1,-1),1,wx.EXPAND,1)
    2446     topSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Sample and Experimental Parameters'))
     2428    topSizer.Add(wx.StaticText(G2frame.dataWindow,label='Sample and Experimental Parameters'))
    24472429    topSizer.Add((-1,-1),1,wx.EXPAND,1)
    24482430    mainSizer.Add(topSizer,0,wx.EXPAND,1)
    24492431    nameSizer = wx.BoxSizer(wx.HORIZONTAL)
    2450     nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Instrument Name'),
     2432    nameSizer.Add(wx.StaticText(G2frame.dataWindow,wx.ID_ANY,' Instrument Name'),
    24512433                0,WACV)
    24522434    nameSizer.Add((-1,-1),1,wx.EXPAND,1)
    2453     instNameVal = wx.TextCtrl(G2frame.dataDisplay,wx.ID_ANY,data['InstrName'],
     2435    instNameVal = wx.TextCtrl(G2frame.dataWindow,wx.ID_ANY,data['InstrName'],
    24542436                              size=(200,-1),style=wx.TE_PROCESS_ENTER)       
    24552437    nameSizer.Add(instNameVal)
     
    24642446    if 'PWDR' in histName:
    24652447        nameSizer = wx.BoxSizer(wx.HORIZONTAL)
    2466         nameSizer.Add(wx.StaticText(G2frame.dataDisplay,wx.ID_ANY,' Diffractometer type: '),
     2448        nameSizer.Add(wx.StaticText(G2frame.dataWindow,wx.ID_ANY,' Diffractometer type: '),
    24672449                    0,WACV)
    24682450        if 'T' in Inst['Type'][0]:
     
    24702452        else:
    24712453            choices = ['Debye-Scherrer','Bragg-Brentano',]
    2472         histoType = G2G.G2ChoiceButton(G2frame.dataDisplay,choices,
     2454        histoType = G2G.G2ChoiceButton(G2frame.dataWindow,choices,
    24732455                    strLoc=data,strKey='Type',
    24742456                    onChoice=OnHistoChange)
     
    24822464        dspLst.append(nDig)
    24832465        if 'list' in str(type(data[key])):
    2484             parmRef = G2G.G2CheckBox(G2frame.dataDisplay,' '+lbl,data[key],1)
     2466            parmRef = G2G.G2CheckBox(G2frame.dataWindow,' '+lbl,data[key],1)
    24852467            parmSizer.Add(parmRef,0,WACV|wx.EXPAND)
    2486             parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data[key],0,
     2468            parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data[key],0,
    24872469                nDig=nDig,typeHint=float,OnLeave=AfterChange)
    24882470            elemKeysLst.append([key,0])
    24892471            refFlgElem.append([key,1])
    24902472        else:
    2491             parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' '+lbl),
     2473            parmSizer.Add(wx.StaticText(G2frame.dataWindow,label=' '+lbl),
    24922474                0,WACV|wx.EXPAND)
    2493             parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,
     2475            parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,key,
    24942476                typeHint=float,OnLeave=AfterChange)
    24952477            elemKeysLst.append([key])
     
    24992481       
    25002482    for key in ('FreePrm1','FreePrm2','FreePrm3'):
    2501         parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,Controls,key,typeHint=str,
     2483        parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,Controls,key,typeHint=str,
    25022484                                        notBlank=False)
    25032485        parmSizer.Add(parmVal,1,wx.EXPAND)
    2504         parmVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,key,typeHint=float)
     2486        parmVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,key,typeHint=float)
    25052487        parmSizer.Add(parmVal,1,wx.EXPAND)
    25062488        labelLst.append(Controls[key])
     
    25192501            G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Substances'))
    25202502        for id,item in enumerate(data['Materials']):
    2521             subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Material: '),0,WACV)
    2522             matsel = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=Substances['Substances'].keys(),
     2503            subSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Material: '),0,WACV)
     2504            matsel = wx.ComboBox(G2frame.dataWindow,value=item['Name'],choices=Substances['Substances'].keys(),
    25232505                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    25242506            Info[matsel.GetId()] = id
    25252507            matsel.Bind(wx.EVT_COMBOBOX,OnMaterial)       
    25262508            subSizer.Add(matsel,0,WACV)
    2527             subSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Volume fraction: '),0,WACV)
    2528             volfrac = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,'VolFrac',
     2509            subSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Volume fraction: '),0,WACV)
     2510            volfrac = G2G.ValidatedTxtCtrl(G2frame.dataWindow,item,'VolFrac',
    25292511                min=0.,max=1.,nDig=(10,3),typeHint=float,OnLeave=OnVolFrac)
    25302512            subSizer.Add(volfrac,0,WACV)
     
    25362518        mainSizer.Add(subSizer,0)
    25372519        conSizer = wx.BoxSizer(wx.HORIZONTAL)
    2538         conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Contrast: %10.2f '%(data['Contrast'][0])),0,WACV)
    2539         conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Anom. Contrast: %10.2f '%(data['Contrast'][1])),0,WACV)
     2520        conSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Contrast: %10.2f '%(data['Contrast'][0])),0,WACV)
     2521        conSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Anom. Contrast: %10.2f '%(data['Contrast'][1])),0,WACV)
    25402522        mut =  mu*data['Thick']
    2541         conSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Transmission (calc): %10.3f  '%(np.exp(-mut))),0,WACV)
     2523        conSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Transmission (calc): %10.3f  '%(np.exp(-mut))),0,WACV)
    25422524        mainSizer.Add(conSizer,0)
    25432525   
    25442526    mainSizer.Layout()   
    2545     G2frame.dataDisplay.SetSizer(mainSizer)
    2546     Size = mainSizer.Fit(G2frame.dataFrame)
    2547     G2frame.dataFrame.setSizePosLeft(Size)
     2527    G2frame.dataWindow.SetSizer(mainSizer)
     2528    mainSizer.Fit(G2frame.dataWindow)
     2529    G2frame.SetDataSize()   
    25482530               
    25492531################################################################################
     
    25712553            G2frame.IndexPeaksTable.SetData(peaks)
    25722554            G2frame.PatternTree.SetItemPyData(IndexId,[peaks,data[1]])
    2573             G2frame.dataDisplay.ForceRefresh()
     2555#            G2frame.dataWindow.ForceRefresh()
    25742556            if 'PKS' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
    25752557                G2plt.PlotPowderLines(G2frame)
     
    25942576       
    25952577    def KeyEditPickGrid(event):
    2596         colList = G2frame.dataDisplay.GetSelectedCols()
     2578        colList = G2frame.indxPeaks.GetSelectedCols()
    25972579        data = G2frame.PatternTree.GetItemPyData(IndexId)
    25982580        if event.GetKeyCode() == wx.WXK_RETURN:
     
    26032585            event.Skip(True)
    26042586        elif colList:
    2605             G2frame.dataDisplay.ClearSelection()
     2587            G2frame.dataWindow.ClearSelection()
    26062588            key = event.GetKeyCode()
    26072589            for col in colList:
     
    26152597                       
    26162598           
    2617     if G2frame.dataDisplay:
    2618         G2frame.dataFrame.Clear()
    2619     if not G2frame.dataFrame.GetStatusBar():
    2620         G2frame.dataFrame.CreateStatusBar()
     2599    G2frame.dataWindow.ClearData()
    26212600    if 'PWD' in G2frame.PatternTree.GetItemText(G2frame.PatternId):
    2622         G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndPeaksMenu)
     2601        G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.IndPeaksMenu)
    26232602        G2frame.Bind(wx.EVT_MENU, OnReload, id=G2gd.wxID_INDXRELOAD)
    2624     G2frame.dataFrame.IndexPeaks.Enable(False)
     2603    G2frame.dataWindow.IndexPeaks.Enable(False)
    26252604    G2frame.IndexPeaksTable = []
    26262605    if len(data[0]):
    2627         G2frame.dataFrame.IndexPeaks.Enable(True)
     2606        G2frame.dataWindow.IndexPeaks.Enable(True)
    26282607        Unit = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
    26292608        if Unit:
     
    26702649    G2frame.PatternTree.SetItemPyData(IndexId,data)
    26712650    G2frame.IndexPeaksTable = G2G.Table(data[0],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    2672     G2frame.dataFrame.SetLabel('Index Peak List')
    2673     G2frame.dataFrame.currentGrids = []
    2674     G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)               
    2675     G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
     2651    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Index Peak List')
     2652    G2frame.dataWindow.ClearData()
     2653    G2frame.dataWindow.currentGrids = []
     2654    G2frame.indxPeaks = G2G.GSGrid(parent=G2frame.dataWindow)               
     2655    G2frame.indxPeaks.SetTable(G2frame.IndexPeaksTable, True)
    26762656    XY = []
    26772657    Sigs = []
    2678     for r in range(G2frame.dataDisplay.GetNumberRows()):
    2679         for c in range(G2frame.dataDisplay.GetNumberCols()):
     2658    for r in range(G2frame.indxPeaks.GetNumberRows()):
     2659        for c in range(G2frame.indxPeaks.GetNumberCols()):
    26802660            if c == 2:
    2681                 G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=False)
     2661                G2frame.indxPeaks.SetReadOnly(r,c,isReadOnly=False)
    26822662            else:
    2683                 G2frame.dataDisplay.SetReadOnly(r,c,isReadOnly=True)
     2663                G2frame.indxPeaks.SetReadOnly(r,c,isReadOnly=True)
    26842664        if data[0][r][2] and data[0][r][3]:
    26852665            XY.append([data[0][r][-1],data[0][r][0]])
     
    26892669                sig = 0.
    26902670            Sigs.append(sig)
    2691     G2frame.dataDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
    2692     G2frame.dataDisplay.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
    2693     G2frame.dataDisplay.SetMargins(0,0)
    2694     G2frame.dataDisplay.AutoSizeColumns(False)
    2695     G2frame.dataFrame.setSizePosLeft([490,300])
     2671    G2frame.indxPeaks.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, RefreshIndexPeaksGrid)
     2672    G2frame.indxPeaks.Bind(wx.EVT_KEY_DOWN, KeyEditPickGrid)                 
     2673    G2frame.indxPeaks.SetMargins(0,0)
     2674    G2frame.indxPeaks.AutoSizeColumns(False)
    26962675    if len(XY):
    26972676        XY = np.array(XY)
    26982677        G2plt.PlotCalib(G2frame,Inst,XY,Sigs,newPlot=True)
    2699     G2frame.dataFrame.SendSizeEvent()
     2678    mainSizer = wx.BoxSizer(wx.VERTICAL)
     2679    mainSizer.Add(G2frame.indxPeaks)
     2680    mainSizer.Layout()   
     2681    G2frame.dataWindow.SetSizer(mainSizer)
     2682    mainSizer.Fit(G2frame.dataWindow)
     2683    G2frame.SetDataSize()   
    27002684     
    27012685################################################################################
     
    31603144                G2frame.PatternTree.SetItemPyData(sub, \
    31613145                    G2obj.SetNewPhase(Name=PhaseName,SGData=SGData,cell=cell[1:],Super=ssopt))
    3162                 Status.SetStatusText('Change space group from '+str(controls[13])+' if needed')
     3146                G2frame.GetStatusBar().SetStatusText('Change space group from '+str(controls[13])+' if needed')
    31633147        finally:
    31643148            dlg.Destroy()
    31653149           
    3166     if G2frame.dataDisplay:
    3167         G2frame.dataFrame.DestroyChildren()
    3168     G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
    3169     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.IndexMenu)
    3170     if not G2frame.dataFrame.GetStatusBar():
    3171         Status = G2frame.dataFrame.CreateStatusBar()
     3150    G2frame.dataWindow.ClearData()
     3151    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Unit cells')
     3152    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.IndexMenu)
    31723153    G2frame.Bind(wx.EVT_MENU, OnIndexPeaks, id=G2gd.wxID_INDEXPEAKS)
    31733154    G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2gd.wxID_COPYCELL)
     
    31953176        [True,True,True,False,True,True,True],[0,1,2,0,3,4,5])]]
    31963177   
    3197     G2frame.dataFrame.SetLabel('Unit Cells List')
    31983178    G2frame.dataFrame.IndexPeaks.Enable(False)
    31993179    peaks = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Index Peak List'))
     
    32113191        G2frame.dataFrame.ExportCells.Enable(True)
    32123192    mainSizer = wx.BoxSizer(wx.VERTICAL)
    3213     mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Indexing controls: '),0,WACV)
     3193    mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Indexing controls: '),0,WACV)
    32143194    mainSizer.Add((5,5),0)
    32153195    littleSizer = wx.FlexGridSizer(0,5,5,5)
    3216     littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max Nc/Nobs '),0,WACV)
    3217     NcNo = wx.SpinCtrl(G2frame.dataDisplay)
     3196    littleSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Max Nc/Nobs '),0,WACV)
     3197    NcNo = wx.SpinCtrl(G2frame.dataWindow)
    32183198    NcNo.SetRange(2,8)
    32193199    NcNo.SetValue(controls[2])
    32203200    NcNo.Bind(wx.EVT_SPINCTRL,OnNcNo)
    32213201    littleSizer.Add(NcNo,0,WACV)
    3222     littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Start Volume '),0,WACV)
    3223     startVol = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,controls,3,typeHint=int,min=25)
     3202    littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Start Volume '),0,WACV)
     3203    startVol = G2G.ValidatedTxtCtrl(G2frame.dataWindow,controls,3,typeHint=int,min=25)
    32243204    littleSizer.Add(startVol,0,WACV)
    3225     x20 = wx.CheckBox(G2frame.dataDisplay,label='Use M20/(X20+1)?')
     3205    x20 = wx.CheckBox(G2frame.dataWindow,label='Use M20/(X20+1)?')
    32263206    x20.SetValue(G2frame.ifX20)
    32273207    x20.Bind(wx.EVT_CHECKBOX,OnIfX20)
     
    32293209    mainSizer.Add(littleSizer,0)
    32303210    mainSizer.Add((5,5),0)
    3231     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Select Bravais Lattices for indexing: '),
     3211    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Select Bravais Lattices for indexing: '),
    32323212        0,WACV)
    32333213    mainSizer.Add((5,5),0)
     
    32363216    bravs = zip(bravais,bravaisNames)
    32373217    for brav,bravName in bravs:
    3238         bravCk = wx.CheckBox(G2frame.dataDisplay,label=bravName)
     3218        bravCk = wx.CheckBox(G2frame.dataWindow,label=bravName)
    32393219        bravList.append(bravCk.GetId())
    32403220        bravCk.SetValue(brav)
     
    32443224    mainSizer.Add((5,5),0)
    32453225   
    3246     mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Cell Test & Refinement: '),0,WACV)
     3226    mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Cell Test & Refinement: '),0,WACV)
    32473227    mainSizer.Add((5,5),0)
    32483228    littleSizer = wx.BoxSizer(wx.HORIZONTAL)
    3249     littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Bravais lattice "),0,WACV)
    3250     bravSel = wx.Choice(G2frame.dataDisplay,choices=bravaisSymb)
     3229    littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=" Bravais lattice "),0,WACV)
     3230    bravSel = wx.Choice(G2frame.dataWindow,choices=bravaisSymb)
    32513231    bravSel.SetSelection(bravaisSymb.index(controls[5]))
    32523232    bravSel.Bind(wx.EVT_CHOICE,OnBravSel)
    32533233    littleSizer.Add(bravSel,0,WACV)
    3254     littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Space group "),0,WACV)
    3255     spcSel = wx.Choice(G2frame.dataDisplay,choices=SPGlist[controls[5]])
     3234    littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=" Space group "),0,WACV)
     3235    spcSel = wx.Choice(G2frame.dataWindow,choices=SPGlist[controls[5]])
    32563236    spcSel.SetSelection(SPGlist[controls[5]].index(controls[13]))
    32573237    spcSel.Bind(wx.EVT_CHOICE,OnSpcSel)
     
    32603240        controls[0] = False
    32613241    else:
    3262         littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Zero offset"),0,WACV)
    3263         zero = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,controls,1,nDig=(10,4),typeHint=float,min=-5.,max=5.)
     3242        littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=" Zero offset"),0,WACV)
     3243        zero = G2G.ValidatedTxtCtrl(G2frame.dataWindow,controls,1,nDig=(10,4),typeHint=float,min=-5.,max=5.)
    32643244        littleSizer.Add(zero,0,WACV)
    3265         zeroVar = wx.CheckBox(G2frame.dataDisplay,label="Refine?")
     3245        zeroVar = wx.CheckBox(G2frame.dataWindow,label="Refine?")
    32663246        zeroVar.SetValue(controls[0])
    32673247        zeroVar.Bind(wx.EVT_CHECKBOX,OnZeroVar)
    32683248        littleSizer.Add(zeroVar,0,WACV)
    3269     SSopt = wx.CheckBox(G2frame.dataDisplay,label="Super lattice?")
     3249    SSopt = wx.CheckBox(G2frame.dataWindow,label="Super lattice?")
    32703250    SSopt.SetValue(ssopt.get('Use',False))
    32713251    SSopt.Bind(wx.EVT_CHECKBOX,OnSSopt)
    32723252    littleSizer.Add(SSopt,0,WACV)
    3273     hklShow = wx.Button(G2frame.dataDisplay,label="Show hkl positions")
     3253    hklShow = wx.Button(G2frame.dataWindow,label="Show hkl positions")
    32743254    hklShow.Bind(wx.EVT_BUTTON,OnHklShow)
    32753255    littleSizer.Add(hklShow,0,WACV)
     
    32853265    littleSizer = wx.FlexGridSizer(0,useGUI[1],5,5)
    32863266    for txt,fmt,ifEdit,Id in useGUI[2]:
    3287         littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=txt),0,WACV)
     3267        littleSizer.Add(wx.StaticText(G2frame.dataWindow,label=txt),0,WACV)
    32883268        if ifEdit:          #a,b,c,etc.
    3289 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    3290             cellVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
     3269#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     3270            cellVal = wx.TextCtrl(G2frame.dataWindow,value=(fmt%(controls[6+Id])),style=wx.TE_PROCESS_ENTER)
    32913271            cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)       
    32923272            cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
    32933273            valSizer = wx.BoxSizer(wx.HORIZONTAL)
    32943274            valSizer.Add(cellVal,0,WACV)
    3295             cellSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,20))
     3275            cellSpin = wx.SpinButton(G2frame.dataWindow,style=wx.SP_VERTICAL,size=wx.Size(20,20))
    32963276            cellSpin.SetValue(0)
    32973277            cellSpin.SetRange(-1,1)
     
    33033283            valDict[cellSpin.GetId()] = cellVal
    33043284        else:               #volume
    3305             volVal = wx.TextCtrl(G2frame.dataDisplay,value=(fmt%(controls[12])),style=wx.TE_READONLY)
     3285            volVal = wx.TextCtrl(G2frame.dataWindow,value=(fmt%(controls[12])),style=wx.TE_READONLY)
    33063286            volVal.SetBackgroundColour(VERY_LIGHT_GREY)
    33073287            littleSizer.Add(volVal,0,WACV)
     
    33143294            ssopt['ssSymb'] = ssChoice[0]
    33153295        ssSizer = wx.BoxSizer(wx.HORIZONTAL)
    3316         ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Supersymmetry space group: '+SpSg+' '),0,WACV)
    3317         selMG = wx.ComboBox(G2frame.dataDisplay,value=ssopt['ssSymb'],
     3296        ssSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Supersymmetry space group: '+SpSg+' '),0,WACV)
     3297        selMG = wx.ComboBox(G2frame.dataWindow,value=ssopt['ssSymb'],
    33183298                choices=ssChoice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
    33193299        selMG.Bind(wx.EVT_COMBOBOX, OnSelMG)
    33203300        ssSizer.Add(selMG,0,WACV)
    3321         ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Mod. vector: '),0,WACV)
     3301        ssSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Mod. vector: '),0,WACV)
    33223302        modS = G2spc.splitSSsym(ssopt['ssSymb'])[0]
    33233303        ssopt['ModVec'],ifShow = G2spc.SSGModCheck(ssopt['ModVec'],modS)
     
    33263306            if show:
    33273307                valSizer = wx.BoxSizer(wx.HORIZONTAL)
    3328                 modVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,ssopt['ModVec'],i,
     3308                modVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,ssopt['ModVec'],i,
    33293309                    min=-.98,max=.98,nDig=(10,4),typeHint=float,OnLeave=OnModVal)
    33303310                valSizer.Add(modVal,0,WACV)
    3331                 modSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,20))
     3311                modSpin = wx.SpinButton(G2frame.dataWindow,style=wx.SP_VERTICAL,size=wx.Size(20,20))
    33323312                modSpin.SetValue(0)
    33333313                modSpin.SetRange(-1,1)
     
    33383318                Indx[modSpin.GetId()] = [i,modVal]
    33393319            else:
    3340                 modVal = wx.TextCtrl(G2frame.dataDisplay,value=('%.3f'%(val)),
     3320                modVal = wx.TextCtrl(G2frame.dataWindow,value=('%.3f'%(val)),
    33413321                    size=wx.Size(50,20),style=wx.TE_READONLY)
    33423322                modVal.SetBackgroundColour(VERY_LIGHT_GREY)
    33433323                ssSizer.Add(modVal,0,WACV)
    3344         ssSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max. M: '),0,WACV)
    3345         maxMH = wx.ComboBox(G2frame.dataDisplay,value=str(ssopt['maxH']),
     3324        ssSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Max. M: '),0,WACV)
     3325        maxMH = wx.ComboBox(G2frame.dataWindow,value=str(ssopt['maxH']),
    33463326            choices=indChoice,style=wx.CB_READONLY|wx.CB_DROPDOWN)
    33473327        maxMH.Bind(wx.EVT_COMBOBOX, OnMaxMH)
    33483328        ssSizer.Add(maxMH,0,WACV)
    3349         findMV = wx.Button(G2frame.dataDisplay,label="Find mod. vec.?")
     3329        findMV = wx.Button(G2frame.dataWindow,label="Find mod. vec.?")
    33503330        findMV.Bind(wx.EVT_BUTTON,OnFindMV)
    33513331        ssSizer.Add(findMV,0,WACV)
     
    33543334    G2frame.dataFrame.currentGrids = []
    33553335    if cells:
    3356         mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='\n Indexing Result:'),0,WACV)
     3336        mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label='\n Indexing Result:'),0,WACV)
    33573337        rowLabels = []
    33583338        colLabels = ['M20','X20','use','Bravais','a','b','c','alpha','beta','gamma','Volume','Keep']
     
    33723352            table.append(row)
    33733353        UnitCellsTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
    3374         gridDisplay = G2G.GSGrid(G2frame.dataDisplay)
     3354        gridDisplay = G2G.GSGrid(G2frame.dataWindow)
    33753355        gridDisplay.SetTable(UnitCellsTable, True)
    33763356        G2frame.dataFrame.CopyCell.Enable(True)
     
    33883368        mainSizer.Add(gridDisplay,0,WACV)
    33893369    mainSizer.Layout()   
    3390     G2frame.dataDisplay.SetSizer(mainSizer)
    3391     G2frame.dataDisplay.SetAutoLayout(1)
    3392     G2frame.dataDisplay.SetupScrolling()
    3393     Size = mainSizer.Fit(G2frame.dataFrame)
    3394     Size[0] += 25
    3395     Size[1] = min(600,Size[1])
    3396     G2frame.dataFrame.setSizePosLeft(Size)   
     3370    G2frame.dataWindow.SetSizer(mainSizer)
     3371    mainSizer.Fit(G2frame.dataFrame)
     3372    G2frame.SetDataSize()
    33973373   
    33983374################################################################################
     
    35553531            return          #deleted phase?
    35563532        G2frame.RefList = phaseName
    3557         G2frame.dataFrame.SetLabel('Reflection List for '+phaseName)
     3533        G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Reflection List for '+phaseName)
    35583534        if HKLF:
    3559             Status.SetStatusText('abs(DF)/sig > 10 red; > 3 yellow; twin < 0 (user rejected) red; twin=0 (sp. gp. absent) red')
     3535            G2frame.GetStatusBar().SetStatusText('abs(DF)/sig > 10 red; > 3 yellow; twin < 0 (user rejected) red; twin=0 (sp. gp. absent) red')
    35603536        else:
    3561             Status.SetStatusText('Prfo < 0. in red; if excluded Fosq in red & mul < 0')
     3537            G2frame.GetStatusBar().SetStatusText('Prfo < 0. in red; if excluded Fosq in red & mul < 0')
    35623538        itof = 0
    35633539        if HKLF:
     
    35813557        G2frame.HKL = np.vstack((refList.T)).T    #build for plots
    35823558        # raise the tab (needed for 1st use and from OnSelectPhase)
    3583         for PageNum in range(G2frame.dataDisplay.GetPageCount()):
    3584             if phaseName == G2frame.dataDisplay.GetPageText(PageNum):
    3585                 G2frame.dataDisplay.SetSelection(PageNum)
     3559        for PageNum in range(G2frame.refBook.GetPageCount()):
     3560            if phaseName == G2frame.refBook.GetPageText(PageNum):
     3561                G2frame.refBook.SetSelection(PageNum)
    35863562                break
    35873563        else:
     
    35953571        '''
    35963572        page = event.GetSelection()
    3597         phaseName = G2frame.dataDisplay.GetPageText(page)
     3573        phaseName = G2frame.refBook.GetPageText(page)
    35983574        ShowReflTable(phaseName)
    35993575
     
    36223598        phaseName = G2frame.RefList
    36233599        phases = data.keys()
    3624     if G2frame.dataDisplay:
    3625         G2frame.dataFrame.Clear()
     3600    G2frame.dataFrame.ClearData()
    36263601    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    3627     if not G2frame.dataFrame.GetStatusBar():
    3628         Status = G2frame.dataFrame.CreateStatusBar()   
     3602    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ReflMenu)
    36293603    if HKLF:
    3630         G2gd.SetDataMenuBar(G2frame)
    3631         G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
    36323604        G2frame.Bind(wx.EVT_MENU, OnPlotHKL, id=G2gd.wxID_PWDHKLPLOT)
    36333605        G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=G2gd.wxID_PWD3DHKLPLOT)
    3634         G2frame.dataFrame.SelectPhase.Enable(False)
     3606        G2frame.dataWindow.SelectPhase.Enable(False)
    36353607    else:
    3636         G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ReflMenu)
    36373608        G2frame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_SELECTPHASE)
    36383609        G2frame.Bind(wx.EVT_MENU, OnPlotHKL, id=G2gd.wxID_PWDHKLPLOT)
    36393610        G2frame.Bind(wx.EVT_MENU, OnPlot3DHKL, id=G2gd.wxID_PWD3DHKLPLOT)
    3640         G2frame.dataFrame.SelectPhase.Enable(False)
     3611        G2frame.dataWindow.SelectPhase.Enable(False)
    36413612           
    3642     G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     3613    G2frame.dataWindow.ClearData()
     3614    G2frame.refBook = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize())
    36433615    G2frame.refTable = {}
    3644     G2frame.dataFrame.currentGrids = []
     3616    G2frame.dataWindow.currentGrids = []
    36453617    for tabnum,phase in enumerate(phases):
    36463618        if isinstance(data,list):           #single crystal HKLF
    3647             G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.dataDisplay)
    3648             G2frame.dataDisplay.AddPage(G2frame.refTable[phase],phase)
     3619            G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.refBook)
     3620            G2frame.refBook.AddPage(G2frame.refTable[phase],phase)
    36493621        elif len(data[phase]):              #else dict for PWDR
    3650             G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.dataDisplay)
    3651             G2frame.dataDisplay.AddPage(G2frame.refTable[phase],phase)
     3622            G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.refBook)
     3623            G2frame.refBook.AddPage(G2frame.refTable[phase],phase)
    36523624        else:       #cleanup deleted phase reflection lists
    36533625            del data[phase]
     
    36603632    if phaseName:
    36613633        ShowReflTable(phaseName)
    3662     G2frame.dataFrame.setSizePosLeft([550,350])
    3663     G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     3634    G2frame.refBook.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
    36643635   
    36653636################################################################################
     
    39383909        Indx = {}
    39393910        substSizer = wx.BoxSizer(wx.VERTICAL)
    3940         substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Substance list: wavelength: %.5fA'%(wave)),
     3911        substSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Substance list: wavelength: %.5fA'%(wave)),
    39413912            0,WACV)
    39423913        for name in data['Substances']:
    3943             G2G.HorizontalLine(substSizer,G2frame.dataDisplay)   
    3944             substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Data for '+name+':'),
     3914            G2G.HorizontalLine(substSizer,G2frame.dataWindow)   
     3915            substSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Data for '+name+':'),
    39453916                0,WACV)
    39463917            if name == 'vacuum':
    3947                 substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='        Not applicable'),
     3918                substSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label='        Not applicable'),
    39483919                    0,WACV)
    39493920            elif name == 'unit scatter':
    3950                 substSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Scattering density,f: %.3f *10%scm%s'%(data['Substances'][name]['Scatt density'],Pwr10,Pwrm2)),0,WACV)
     3921                substSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Scattering density,f: %.3f *10%scm%s'%(data['Substances'][name]['Scatt density'],Pwr10,Pwrm2)),0,WACV)
    39513922            else:   
    39523923                elSizer = wx.FlexGridSizer(0,8,5,5)
     
    39543925                Elems = Substance['Elements']
    39553926                for El in Elems:    #do elements as pull downs for isotopes for neutrons
    3956                     elSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+El+': '),
     3927                    elSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' '+El+': '),
    39573928                        0,WACV)
    3958                     num = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Substances'][name]['Elements'][El],'Num',
     3929                    num = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Substances'][name]['Elements'][El],'Num',
    39593930                        nDig=(10,2,'f'),typeHint=float,OnLeave=OnNum)
    39603931                    Indx[num.GetId()] = [name,El,'Num']
    39613932                    elSizer.Add(num,0,WACV)
    39623933                    if 'N' in Inst['Type'][0]:
    3963                         elSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Isotope: '),0,WACV)
     3934                        elSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Isotope: '),0,WACV)
    39643935                        isotopes = Elems[El]['Isotopes'].keys()
    3965                         isotope = wx.ComboBox(G2frame.dataDisplay,choices=isotopes,value=Elems[El].get('Isotope','Nat. Abund.'),
     3936                        isotope = wx.ComboBox(G2frame.dataWindow,choices=isotopes,value=Elems[El].get('Isotope','Nat. Abund.'),
    39663937                            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    39673938                        Indx[isotope.GetId()] = [El,name]
     
    39703941                substSizer.Add(elSizer,0)
    39713942                vdsSizer = wx.FlexGridSizer(0,4,5,5)
    3972                 vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Volume: '),
     3943                vdsSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Volume: '),
    39733944                    0,WACV)
    3974                 vol = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Substances'][name],'Volume',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
     3945                vol = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Substances'][name],'Volume',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
    39753946                Indx[vol.GetId()] = [name,'Volume']
    39763947                vdsSizer.Add(vol,0,WACV)               
    3977                 vdsSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Density: '),
     3948                vdsSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' Density: '),
    39783949                    0,WACV)
    3979                 den = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Substances'][name],'Density',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
     3950                den = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Substances'][name],'Density',nDig=(10,2),typeHint=float,OnLeave=OnVolDen)
    39803951                Indx[den.GetId()] = [name,'Density']
    39813952                vdsSizer.Add(den,0,WACV)
    39823953                substSizer.Add(vdsSizer,0)
    39833954                denSizer = wx.FlexGridSizer(0,2,0,0)
    3984                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Scattering density,f'),0,WACV)
    3985                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3f *10%scm%s'%(Substance['Scatt density'],Pwr10,Pwrm2)),0,WACV)
    3986                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=" Real density,f+f'"),0,WACV)
    3987                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3f *10%scm%s'%(Substance['XAnom density'],Pwr10,Pwrm2)),0,WACV)
    3988                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Imaginary density,f"'),0,WACV)
    3989                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3g *10%scm%s'%(Substance['XImag density'],Pwr10,Pwrm2)),0,WACV)
    3990                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Absorption'),0,WACV)
    3991                 denSizer.Add(wx.StaticText(G2frame.dataDisplay,label=': %.3g cm%s'%(Substance['XAbsorption'],Pwrm1)),0,WACV)
     3955                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Scattering density,f'),0,WACV)
     3956                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=': %.3f *10%scm%s'%(Substance['Scatt density'],Pwr10,Pwrm2)),0,WACV)
     3957                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=" Real density,f+f'"),0,WACV)
     3958                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=': %.3f *10%scm%s'%(Substance['XAnom density'],Pwr10,Pwrm2)),0,WACV)
     3959                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Imaginary density,f"'),0,WACV)
     3960                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=': %.3g *10%scm%s'%(Substance['XImag density'],Pwr10,Pwrm2)),0,WACV)
     3961                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Absorption'),0,WACV)
     3962                denSizer.Add(wx.StaticText(G2frame.dataWindow,label=': %.3g cm%s'%(Substance['XAbsorption'],Pwrm1)),0,WACV)
    39923963                substSizer.Add(denSizer)
    39933964        return substSizer
     
    39953966    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    39963967    wave = G2mth.getWave(Inst)
    3997     if G2frame.dataDisplay:
    3998         G2frame.dataFrame.DestroyChildren()  # is this a ScrolledWindow? If so, bad!
    3999     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.SubstanceMenu)
    4000     if not G2frame.dataFrame.GetStatusBar():
    4001         G2frame.dataFrame.CreateStatusBar()
    4002     G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
    4003     G2frame.dataFrame.SetLabel('Substances')
     3968    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.SubstanceMenu)
     3969    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Substances')
     3970    G2frame.dataWindow.ClearData()
    40043971    G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadSubstance, id=G2gd.wxID_LOADSUBSTANCE)   
    40053972    G2frame.dataFrame.Bind(wx.EVT_MENU, OnReloadSubstances, id=G2gd.wxID_RELOADSUBSTANCES)   
     
    40133980
    40143981    mainSizer.Layout()   
    4015     G2frame.dataDisplay.SetSizer(mainSizer)
    4016     G2frame.dataDisplay.SetAutoLayout(1)
    4017     G2frame.dataDisplay.SetupScrolling()
    4018     Size = mainSizer.Fit(G2frame.dataFrame)
    4019     Size[0] += 25
    4020     G2frame.dataFrame.setSizePosLeft(Size)   
     3982    G2frame.dataWindow.SetSizer(mainSizer)
     3983    G2frame.dataWindow.SetAutoLayout(1)
     3984    mainSizer.Fit(G2frame.dataFrame)
     3985    G2frame.SetDataSize()
    40213986       
    40223987################################################################################
     
    42994264           
    43004265        sizeSizer = wx.BoxSizer(wx.VERTICAL)
    4301         sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Size distribution parameters: '),0,WACV)
     4266        sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Size distribution parameters: '),0,WACV)
    43024267        binSizer = wx.FlexGridSizer(0,7,5,5)
    4303         binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' No. size bins: '),0,WACV)
     4268        binSizer.Add(wx.StaticText(G2frame.dataWindow,label=' No. size bins: '),0,WACV)
    43044269        bins = ['50','100','150','200']
    4305         nbins = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['Nbins']),choices=bins,
     4270        nbins = wx.ComboBox(G2frame.dataWindow,value=str(data['Size']['Nbins']),choices=bins,
    43064271            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    43074272        Indx[nbins.GetId()] = [data['Size'],'Nbins',0]
    43084273        nbins.Bind(wx.EVT_COMBOBOX,OnIntVal)       
    43094274        binSizer.Add(nbins,0,WACV)
    4310         binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min diam.: '),0,WACV)
     4275        binSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Min diam.: '),0,WACV)
    43114276        minDias = ['10','25','50','100','150','200']
    4312         mindiam = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MinDiam']),choices=minDias,
     4277        mindiam = wx.ComboBox(G2frame.dataWindow,value=str(data['Size']['MinDiam']),choices=minDias,
    43134278            style=wx.CB_DROPDOWN)
    43144279        mindiam.Bind(wx.EVT_LEAVE_WINDOW,OnIntVal)
     
    43174282        Indx[mindiam.GetId()] = [data['Size'],'MinDiam',0]
    43184283        binSizer.Add(mindiam,0,WACV)
    4319         binSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Max diam.: '),0,WACV)
     4284        binSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Max diam.: '),0,WACV)
    43204285        maxDias = [str(1000*(i+1)) for i in range(10)]
    4321         maxdiam = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MaxDiam']),choices=maxDias,
     4286        maxdiam = wx.ComboBox(G2frame.dataWindow,value=str(data['Size']['MaxDiam']),choices=maxDias,
    43224287            style=wx.CB_DROPDOWN)
    43234288        maxdiam.Bind(wx.EVT_LEAVE_WINDOW,OnIntVal)
     
    43264291        Indx[maxdiam.GetId()] = [data['Size'],'MaxDiam',0]
    43274292        binSizer.Add(maxdiam,0,WACV)
    4328         logbins = wx.CheckBox(G2frame.dataDisplay,label='Log bins?')
     4293        logbins = wx.CheckBox(G2frame.dataWindow,label='Log bins?')
    43294294        Indx[logbins.GetId()] = [data['Size'],'logBins']
    43304295        logbins.SetValue(data['Size']['logBins'])
     
    43344299        sizeSizer.Add((5,5),0)
    43354300        partSizer = wx.BoxSizer(wx.HORIZONTAL)
    4336         partSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Particle description: '),0,WACV)
     4301        partSizer.Add(wx.StaticText(G2frame.dataWindow,label='Particle description: '),0,WACV)
    43374302        shapes = {'Spheroid':' Aspect ratio: ','Cylinder':' Diameter ','Cylinder AR':' Aspect ratio: ',
    43384303            'Unified sphere':'','Unified rod':' Diameter: ','Unified rod AR':' Aspect ratio: ',
    43394304            'Unified disk':' Thickness: ', 'Spherical shell': ' Shell thickness'}
    4340         partsh = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['Shape'][0]),choices=shapes.keys(),
     4305        partsh = wx.ComboBox(G2frame.dataWindow,value=str(data['Size']['Shape'][0]),choices=shapes.keys(),
    43414306            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    43424307        partsh.Bind(wx.EVT_COMBOBOX,OnShape)       
    43434308        partSizer.Add(partsh,0,WACV)
    43444309        if data['Size']['Shape'][0] not in ['Unified sphere',]:
    4345             partSizer.Add(wx.StaticText(G2frame.dataDisplay,label=shapes[data['Size']['Shape'][0]]),0,WACV)
    4346             partprm = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Size']['Shape'],1,
     4310            partSizer.Add(wx.StaticText(G2frame.dataWindow,label=shapes[data['Size']['Shape'][0]]),0,WACV)
     4311            partprm = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Size']['Shape'],1,
    43474312                nDig=(10,3),typeHint=float,min=0.)
    43484313            partSizer.Add(partprm,0,WACV)
     
    43514316        fitSizer = wx.BoxSizer(wx.HORIZONTAL)
    43524317        methods = ['MaxEnt','IPG',]
    4353         fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Fitting method: '),0,WACV)
    4354         method = wx.ComboBox(G2frame.dataDisplay,value=data['Size']['Method'],choices=methods,
     4318        fitSizer.Add(wx.StaticText(G2frame.dataWindow,label='Fitting method: '),0,WACV)
     4319        method = wx.ComboBox(G2frame.dataWindow,value=data['Size']['Method'],choices=methods,
    43554320            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    43564321        method.Bind(wx.EVT_COMBOBOX,OnMethod)
    43574322        fitSizer.Add(method,0,WACV)
    43584323        iters = ['10','25','50','100','150','200']       
    4359         fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' No. iterations: '),0,WACV)
     4324        fitSizer.Add(wx.StaticText(G2frame.dataWindow,label=' No. iterations: '),0,WACV)
    43604325        Method = data['Size']['Method']
    4361         iter = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size'][Method]['Niter']),choices=iters,
     4326        iter = wx.ComboBox(G2frame.dataWindow,value=str(data['Size'][Method]['Niter']),choices=iters,
    43624327            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    43634328        Indx[iter.GetId()] = [data['Size'][Method],'Niter',0]
     
    43654330        fitSizer.Add(iter,0,WACV)
    43664331        if 'MaxEnt' in data['Size']['Method']:
    4367             fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Log floor factor: '),0,WACV)
     4332            fitSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Log floor factor: '),0,WACV)
    43684333            floors = [str(-i) for i in range(9)]
    4369             floor = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['MaxEnt']['Sky']),choices=floors,
     4334            floor = wx.ComboBox(G2frame.dataWindow,value=str(data['Size']['MaxEnt']['Sky']),choices=floors,
    43704335                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    43714336            Indx[floor.GetId()] = [data['Size']['MaxEnt'],'Sky',-10]
     
    43734338            fitSizer.Add(floor,0,WACV)
    43744339        elif 'IPG' in data['Size']['Method']:
    4375             fitSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Q power weight (-1 for sigma): '),0,WACV)
     4340            fitSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Q power weight (-1 for sigma): '),0,WACV)
    43764341            choices = ['-1','0','1','2','3','4']
    4377             power = wx.ComboBox(G2frame.dataDisplay,value=str(data['Size']['IPG']['Power']),choices=choices,
     4342            power = wx.ComboBox(G2frame.dataWindow,value=str(data['Size']['IPG']['Power']),choices=choices,
    43784343                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    43794344            Indx[power.GetId()] = [data['Size']['IPG'],'Power',-2]
     
    44674432        def SizeSizer():
    44684433            sizeSizer = wx.FlexGridSizer(0,4,5,5)
    4469             sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Distribution: '),0,WACV)
     4434            sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Distribution: '),0,WACV)
    44704435            Distchoice = ['LogNormal','Gaussian','LSW','Schulz-Zimm','Bragg','Unified','Porod','Monodisperse',]
    4471             distChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['DistType'],choices=Distchoice,
     4436            distChoice = wx.ComboBox(G2frame.dataWindow,value=level['Controls']['DistType'],choices=Distchoice,
    44724437                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    44734438            Indx[distChoice.GetId()] = [level['Controls'],'DistType']
     
    44754440            sizeSizer.Add(distChoice,0,WACV)    #put structure factor choices here
    44764441            if level['Controls']['DistType'] not in ['Bragg','Unified','Porod',]:
    4477                 sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Form Factor: '),0,WACV)
     4442                sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Form Factor: '),0,WACV)
    44784443                if 'Mono' in level['Controls']['DistType']:
    4479                     ffChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['FormFact'],choices=ffMonoChoices,
     4444                    ffChoice = wx.ComboBox(G2frame.dataWindow,value=level['Controls']['FormFact'],choices=ffMonoChoices,
    44804445                        style=wx.CB_READONLY|wx.CB_DROPDOWN)
    44814446                else:
    4482                     ffChoice = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['FormFact'],choices=ffDistChoices,
     4447                    ffChoice = wx.ComboBox(G2frame.dataWindow,value=level['Controls']['FormFact'],choices=ffDistChoices,
    44834448                        style=wx.CB_READONLY|wx.CB_DROPDOWN)
    44844449                Indx[ffChoice.GetId()] = [level['Controls'],'FormFact']
     
    44864451                sizeSizer.Add(ffChoice,0,WACV)
    44874452               
    4488                 sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Material: '),0,WACV)
    4489                 matSel = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['Material'],
     4453                sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Material: '),0,WACV)
     4454                matSel = wx.ComboBox(G2frame.dataWindow,value=level['Controls']['Material'],
    44904455                    choices=Substances['Substances'].keys(),style=wx.CB_READONLY|wx.CB_DROPDOWN)
    44914456                Indx[matSel.GetId()] = [level['Controls'],'Material']
     
    44944459                rho = Substances['Substances'][level['Controls']['Material']].get('XAnom density',0.0)
    44954460                level['Controls']['Contrast'] = contrast = (rho-rhoMat)**2                 
    4496                 sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Resonant X-ray contrast: '),0,WACV)
    4497                 sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label='  %.2f 10%scm%s'%(contrast,Pwr20,Pwrm4)),0,WACV)
     4461                sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Resonant X-ray contrast: '),0,WACV)
     4462                sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label='  %.2f 10%scm%s'%(contrast,Pwr20,Pwrm4)),0,WACV)
    44984463                if 'Mono' not in level['Controls']['DistType']:
    4499                     sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Num. radii: '),0,WACV)
     4464                    sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Num. radii: '),0,WACV)
    45004465                    radii = ['25','50','75','100','200']
    4501                     nRadii = wx.ComboBox(G2frame.dataDisplay,value=str(level['Controls']['NumPoints']),choices=radii,
     4466                    nRadii = wx.ComboBox(G2frame.dataWindow,value=str(level['Controls']['NumPoints']),choices=radii,
    45024467                        style=wx.CB_READONLY|wx.CB_DROPDOWN)
    45034468                    Indx[nRadii.GetId()] = [level['Controls'],'NumPoints']
    45044469                    nRadii.Bind(wx.EVT_COMBOBOX,OnSelect)
    45054470                    sizeSizer.Add(nRadii,0,WACV)
    4506                     sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' R dist. cutoff: '),0,WACV)
    4507                     rCutoff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,level['Controls'],'Cutoff',
     4471                    sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' R dist. cutoff: '),0,WACV)
     4472                    rCutoff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,level['Controls'],'Cutoff',
    45084473                        min=0.001,max=0.1,typeHint=float)
    45094474                    sizeSizer.Add(rCutoff,0,WACV)
     
    45114476                Parms = level['Unified']
    45124477                Best = G2sasd.Bestimate(Parms['G'][0],Parms['Rg'][0],Parms['P'][0])
    4513                 sizeSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Estimated Dist B: %12.4g'%(Best)),0,WACV)
     4478                sizeSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Estimated Dist B: %12.4g'%(Best)),0,WACV)
    45144479            return sizeSizer
    45154480           
     
    45264491                if parm in Parms:
    45274492                    if parm == 'MinSize':
    4528                         parmSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Dist '+parm),0,wx.ALIGN_CENTER)
     4493                        parmSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Dist '+parm),0,wx.ALIGN_CENTER)
    45294494                    else:
    4530                         parmVar = wx.CheckBox(G2frame.dataDisplay,label='Refine? Dist '+parm)
     4495                        parmVar = wx.CheckBox(G2frame.dataWindow,label='Refine? Dist '+parm)
    45314496                        parmVar.SetValue(Parms[parm][1])
    45324497                        parmVar.Bind(wx.EVT_CHECKBOX, OnSelect)
    45334498                        parmSizer.Add(parmVar,0,WACV)
    45344499                        Indx[parmVar.GetId()] = [Parms[parm],1]
    4535 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    4536                     parmValue = wx.TextCtrl(G2frame.dataDisplay,value='%.3g'%(Parms[parm][0]),
     4500#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     4501                    parmValue = wx.TextCtrl(G2frame.dataWindow,value='%.3g'%(Parms[parm][0]),
    45374502                        style=wx.TE_PROCESS_ENTER)
    45384503                    parmValue.Bind(wx.EVT_TEXT_ENTER,OnValue)       
     
    45454510                        value = np.log10(Parms[parm][0])
    45464511                        valMinMax = [value-1,value+1]
    4547                     parmSldr = wx.Slider(G2frame.dataDisplay,minValue=slMult*valMinMax[0],
     4512                    parmSldr = wx.Slider(G2frame.dataWindow,minValue=slMult*valMinMax[0],
    45484513                        maxValue=slMult*valMinMax[1],value=slMult*value)
    45494514                    Indx[parmValue.GetId()] = [Parms,parm,parmSldr]
     
    45574522                    for parm in parmOrder:
    45584523                        if parm in Args:
    4559                             parmVar = wx.CheckBox(G2frame.dataDisplay,label='Refine? '+fTypes[iarg]+parm)
     4524                            parmVar = wx.CheckBox(G2frame.dataWindow,label='Refine? '+fTypes[iarg]+parm)
    45604525                            parmVar.SetValue(Args[parm][1])
    45614526                            Indx[parmVar.GetId()] = [Args[parm],1]
    45624527                            parmVar.Bind(wx.EVT_CHECKBOX, OnSelect)
    45634528                            parmSizer.Add(parmVar,0,WACV)
    4564 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    4565                             parmValue = wx.TextCtrl(G2frame.dataDisplay,value='%.3g'%(Args[parm][0]),
     4529#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     4530                            parmValue = wx.TextCtrl(G2frame.dataWindow,value='%.3g'%(Args[parm][0]),
    45664531                                style=wx.TE_PROCESS_ENTER)
    45674532                            parmValue.Bind(wx.EVT_TEXT_ENTER,OnValue)       
     
    45824547                                value = np.log10(Args[parm][0])
    45834548                                valMinMax = [value-1,value+1]
    4584                             parmSldr = wx.Slider(G2frame.dataDisplay,minValue=slMult*valMinMax[0],
     4549                            parmSldr = wx.Slider(G2frame.dataWindow,minValue=slMult*valMinMax[0],
    45854550                                maxValue=slMult*valMinMax[1],value=slMult*value)
    45864551                            Indx[parmVar.GetId()] = [Args[parm],1]
     
    45944559        partSizer = wx.BoxSizer(wx.VERTICAL)
    45954560        topSizer = wx.BoxSizer(wx.HORIZONTAL)
    4596         topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Particle fit parameters: '),0,WACV)
    4597         topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Matrix: '),0,WACV)
    4598         matsel = wx.ComboBox(G2frame.dataDisplay,value=data['Particle']['Matrix']['Name'],
     4561        topSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Particle fit parameters: '),0,WACV)
     4562        topSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Matrix: '),0,WACV)
     4563        matsel = wx.ComboBox(G2frame.dataWindow,value=data['Particle']['Matrix']['Name'],
    45994564            choices=Substances['Substances'].keys(),style=wx.CB_READONLY|wx.CB_DROPDOWN)
    46004565        Indx[matsel.GetId()] = [data['Particle']['Matrix'],'Name']
     
    46024567        rhoMat = Substances['Substances'][data['Particle']['Matrix']['Name']].get('XAnom density',0.0)       
    46034568        topSizer.Add(matsel,0,WACV)
    4604         topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Volume fraction: '),0,WACV)
    4605         volfrac = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Particle']['Matrix']['VolFrac'],0,
     4569        topSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Volume fraction: '),0,WACV)
     4570        volfrac = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Particle']['Matrix']['VolFrac'],0,
    46064571                typeHint=float)
    46074572        topSizer.Add(volfrac,0,WACV)
    4608         volVar = wx.CheckBox(G2frame.dataDisplay,label=' Refine?')
     4573        volVar = wx.CheckBox(G2frame.dataWindow,label=' Refine?')
    46094574        volVar.SetValue(data['Particle']['Matrix']['VolFrac'][1])
    46104575        Indx[volVar.GetId()] = [data['Particle']['Matrix']['VolFrac'],1]
     
    46134578        partSizer.Add(topSizer,0,)
    46144579        for ilev,level in enumerate(data['Particle']['Levels']):
    4615             G2G.HorizontalLine(partSizer,G2frame.dataDisplay)
     4580            G2G.HorizontalLine(partSizer,G2frame.dataWindow)
    46164581            topLevel = wx.BoxSizer(wx.HORIZONTAL)
    4617             topLevel.Add(wx.StaticText(G2frame.dataDisplay,label=' Model component %d: '%(ilev)),0,WACV)
    4618             delBtn = wx.Button(G2frame.dataDisplay,label=' Delete?')
     4582            topLevel.Add(wx.StaticText(G2frame.dataWindow,label=' Model component %d: '%(ilev)),0,WACV)
     4583            delBtn = wx.Button(G2frame.dataWindow,label=' Delete?')
    46194584            Indx[delBtn.GetId()] = ilev
    46204585            delBtn.Bind(wx.EVT_BUTTON,OnDelLevel)
     
    46234588            partSizer.Add(SizeSizer())
    46244589            if level['Controls']['DistType'] not in ['Bragg','Unified','Porod',]:
    4625                 topLevel.Add(wx.StaticText(G2frame.dataDisplay,label=' Structure factor: '),0,WACV)
    4626                 strfctr = wx.ComboBox(G2frame.dataDisplay,value=level['Controls']['StrFact'],
     4590                topLevel.Add(wx.StaticText(G2frame.dataWindow,label=' Structure factor: '),0,WACV)
     4591                strfctr = wx.ComboBox(G2frame.dataWindow,value=level['Controls']['StrFact'],
    46274592                    choices=sfChoices,style=wx.CB_READONLY|wx.CB_DROPDOWN)
    46284593                Indx[strfctr.GetId()] = [level['Controls'],'StrFact']
     
    46664631        BackSample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,BackId, 'Sample Parameters'))
    46674632        Profile[5] = BackSample['Scale'][0]*G2frame.PatternTree.GetItemPyData(BackId)[1][1]
    4668     if G2frame.dataDisplay:
    4669         G2frame.dataFrame.DestroyChildren()   # is this a ScrolledWindow? If so, bad!
    4670     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ModelMenu)
    4671     if not G2frame.dataFrame.GetStatusBar():
    4672         Status = G2frame.dataFrame.CreateStatusBar()
    4673     G2frame.dataFrame.SetLabel('Modelling')
    4674     G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
     4633    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ModelMenu)
     4634    G2frame.dataWindow.ClearData()
     4635    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Modelling')
    46754636    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyModel, id=G2gd.wxID_MODELCOPY)
    46764637    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyFlags, id=G2gd.wxID_MODELCOPYFLAGS)
     
    46834644    topSizer = wx.BoxSizer(wx.HORIZONTAL)
    46844645    models = ['Size dist.','Particle fit']
    4685     topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Modeling by: '),0,WACV)
    4686     fitSel = wx.ComboBox(G2frame.dataDisplay,value=data['Current'],choices=models,
     4646    topSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Modeling by: '),0,WACV)
     4647    fitSel = wx.ComboBox(G2frame.dataWindow,value=data['Current'],choices=models,
    46874648        style=wx.CB_READONLY|wx.CB_DROPDOWN)
    46884649    fitSel.Bind(wx.EVT_COMBOBOX,OnSelectFit)       
    46894650    topSizer.Add(fitSel,0,WACV)
    4690     topSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Error multiplier: '),0,WACV)
    4691 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    4692     esdScale = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(1./np.sqrt(ProfDict['wtFactor'])),style=wx.TE_PROCESS_ENTER)
     4651    topSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Error multiplier: '),0,WACV)
     4652#        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
     4653    esdScale = wx.TextCtrl(G2frame.dataWindow,value='%.3f'%(1./np.sqrt(ProfDict['wtFactor'])),style=wx.TE_PROCESS_ENTER)
    46934654    esdScale.Bind(wx.EVT_TEXT_ENTER,OnEsdScale)       
    46944655    esdScale.Bind(wx.EVT_KILL_FOCUS,OnEsdScale)
    46954656    topSizer.Add(esdScale,0,WACV)
    46964657    mainSizer.Add(topSizer)
    4697     G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
     4658    G2G.HorizontalLine(mainSizer,G2frame.dataWindow)
    46984659    if 'Size' in data['Current']:
    46994660        if 'MaxEnt' in data['Size']['Method']:
    4700             Status.SetStatusText('Size distribution by Maximum entropy')
     4661            G2frame.GetStatusBar().SetStatusText('Size distribution by Maximum entropy')
    47014662        elif 'IPG' in data['Size']['Method']:
    4702             Status.SetStatusText('Size distribution by Interior-Point Gradient')
     4663            G2frame.GetStatusBar().SetStatusText('Size distribution by Interior-Point Gradient')
    47034664        mainSizer.Add(SizeSizer())       
    47044665    elif 'Particle' in data['Current']:
    47054666        mainSizer.Add(PartSizer(),1,wx.ALIGN_LEFT|wx.EXPAND)
    4706     G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)   
     4667    G2G.HorizontalLine(mainSizer,G2frame.dataWindow)   
    47074668    backSizer = wx.BoxSizer(wx.HORIZONTAL)
    4708     backSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Background:'),0,WACV)
    4709     backVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Back'],0,
     4669    backSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Background:'),0,WACV)
     4670    backVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Back'],0,
    47104671        nDig=(10,3),typeHint=float,OnLeave=OnBackChange)
    47114672    backSizer.Add(backVal,0,WACV)
    4712     backVar = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
     4673    backVar = wx.CheckBox(G2frame.dataWindow,label='Refine?')
    47134674    Indx[backVar.GetId()] = [data['Back'],1]
    47144675    backVar.SetValue(data['Back'][1])
     
    47164677    backSizer.Add(backVar,0,WACV)
    47174678    #multiple background files?
    4718     backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background file: '),0,WACV)
     4679    backSizer.Add(wx.StaticText(G2frame.dataWindow,-1,' Background file: '),0,WACV)
    47194680    Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['SASD',])
    4720     backFile = wx.ComboBox(parent=G2frame.dataDisplay,value=data['BackFile'],choices=Choices,
     4681    backFile = wx.ComboBox(parent=G2frame.dataWindow,value=data['BackFile'],choices=Choices,
    47214682        style=wx.CB_READONLY|wx.CB_DROPDOWN)
    47224683    backFile.Bind(wx.EVT_COMBOBOX,OnBackFile)
     
    47254686
    47264687    mainSizer.Layout()   
    4727     G2frame.dataDisplay.SetSizer(mainSizer)
    4728     G2frame.dataDisplay.SetAutoLayout(1)
    4729     G2frame.dataDisplay.SetupScrolling()
    4730     Size = mainSizer.Fit(G2frame.dataFrame)
    4731     Size[0] += 25
    4732     G2frame.dataFrame.setSizePosLeft(Size)   
     4688    G2frame.dataWindow.SetSizer(mainSizer)
     4689    G2frame.dataWindow.SetAutoLayout(1)
     4690    mainSizer.Fit(G2frame.dataFrame)
     4691    G2frame.SetDataSize()
    47334692   
    47344693################################################################################
     
    49724931        if ProfDict['ifDQ']:
    49734932            choice += [GkDelta+'Q/Q in data']
    4974         dQSel = wx.RadioBox(G2frame.dataDisplay,wx.ID_ANY,'Instrument resolution type:',choices=choice,
     4933        dQSel = wx.RadioBox(G2frame.dataWindow,wx.ID_ANY,'Instrument resolution type:',choices=choice,
    49754934            majorDimension=0,style=wx.RA_SPECIFY_COLS)
    49764935        dQSel.SetStringSelection(data['dQ type'])
    49774936        dQSel.Bind(wx.EVT_RADIOBOX,OndQSel)
    49784937        resol.Add(dQSel,0,WACV)
    4979         resol.Add(wx.StaticText(G2frame.dataDisplay,label=' (FWHM %): '),0,WACV)
    4980         resol.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Resolution'],0,nDig=(10,3),min=0.,max=5.,OnLeave=NewRes),0,WACV)
     4938        resol.Add(wx.StaticText(G2frame.dataWindow,label=' (FWHM %): '),0,WACV)
     4939        resol.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Resolution'],0,nDig=(10,3),min=0.,max=5.,OnLeave=NewRes),0,WACV)
    49814940        controlSizer.Add(resol,0,WACV)
    49824941        minimiz = wx.BoxSizer(wx.HORIZONTAL)
    4983         minimiz.Add(wx.StaticText(G2frame.dataDisplay,label=' Minimizer: '),0,WACV)
     4942        minimiz.Add(wx.StaticText(G2frame.dataWindow,label=' Minimizer: '),0,WACV)
    49844943        minlist = ['LMLS','Basin Hopping','MC/SA Anneal','L-BFGS-B',]
    4985         minSel = wx.ComboBox(G2frame.dataDisplay,value=data['Minimizer'],choices=minlist,
     4944        minSel = wx.ComboBox(G2frame.dataWindow,value=data['Minimizer'],choices=minlist,
    49864945            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    49874946        minSel.Bind(wx.EVT_COMBOBOX, OnMinSel)
    49884947        minimiz.Add(minSel,0,WACV)
    4989         minimiz.Add(wx.StaticText(G2frame.dataDisplay,label=' Bounds factor: '),0,WACV)
    4990         minimiz.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Toler',nDig=(10,2),max=0.99,min=0.1),0,WACV)
    4991         weight = wx.CheckBox(G2frame.dataDisplay,label='Use 2% sig. weights')
     4948        minimiz.Add(wx.StaticText(G2frame.dataWindow,label=' Bounds factor: '),0,WACV)
     4949        minimiz.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Toler',nDig=(10,2),max=0.99,min=0.1),0,WACV)
     4950        weight = wx.CheckBox(G2frame.dataWindow,label='Use 2% sig. weights')
    49924951        weight.SetValue(data.get('2% weight',False))
    49934952        weight.Bind(wx.EVT_CHECKBOX, OnWeight)
     
    49954954        controlSizer.Add(minimiz,0,WACV)
    49964955        plotSizer = wx.BoxSizer(wx.HORIZONTAL)
    4997         plotSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Plot controls: '),0,WACV)
    4998         sld = wx.CheckBox(G2frame.dataDisplay,label='Plot SLD?')
     4956        plotSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Plot controls: '),0,WACV)
     4957        sld = wx.CheckBox(G2frame.dataWindow,label='Plot SLD?')
    49994958        sld.Bind(wx.EVT_CHECKBOX, OnSLDplot)
    50004959        plotSizer.Add(sld,0,WACV)
    5001         plotSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Zero position location: '),0,WACV)
     4960        plotSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Zero position location: '),0,WACV)
    50024961        poslist = ['Top','Bottom']
    5003         refpos = wx.ComboBox(G2frame.dataDisplay,value=data['Zero'],choices=poslist,
     4962        refpos = wx.ComboBox(G2frame.dataWindow,value=data['Zero'],choices=poslist,
    50044963            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    50054964        refpos.Bind(wx.EVT_COMBOBOX, OnRefPos)
    50064965        plotSizer.Add(refpos,0,WACV)
    5007 #        q4fft = wx.CheckBox(G2frame.dataDisplay,label='Plot fft?')
     4966#        q4fft = wx.CheckBox(G2frame.dataWindow,label='Plot fft?')
    50084967#        q4fft.Bind(wx.EVT_CHECKBOX, OnQ4fftplot)
    50094968#        plotSizer.Add(q4fft,0,WACV)
     
    50304989
    50314990        overall = wx.BoxSizer(wx.HORIZONTAL)
    5032         overall.Add(wx.StaticText(G2frame.dataDisplay,label=' Scale: '),0,WACV)
    5033         overall.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Scale'],0,
     4991        overall.Add(wx.StaticText(G2frame.dataWindow,label=' Scale: '),0,WACV)
     4992        overall.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Scale'],0,
    50344993            nDig=(10,2),typeHint=float,OnLeave=Recalculate),0,WACV)
    5035         scaleref = wx.CheckBox(G2frame.dataDisplay,label=' Refine?  ')
     4994        scaleref = wx.CheckBox(G2frame.dataWindow,label=' Refine?  ')
    50364995        scaleref.SetValue(data['Scale'][1])
    50374996        scaleref.Bind(wx.EVT_CHECKBOX, OnScaleRef)
    50384997        overall.Add(scaleref,0,WACV)
    5039         overall.Add(wx.StaticText(G2frame.dataDisplay,label=' Flat bkg.: '),0,WACV)
    5040         overall.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['FltBack'],0,
     4998        overall.Add(wx.StaticText(G2frame.dataWindow,label=' Flat bkg.: '),0,WACV)
     4999        overall.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['FltBack'],0,
    50415000            nDig=(10,2,'g'),typeHint=float,OnLeave=Recalculate),0,WACV)
    5042         backref = wx.CheckBox(G2frame.dataDisplay,label=' Refine?  ')
     5001        backref = wx.CheckBox(G2frame.dataWindow,label=' Refine?  ')
    50435002        backref.SetValue(data['FltBack'][1])
    50445003        backref.Bind(wx.EVT_CHECKBOX, OnBackRef)
     
    51035062        for ilay,layer in enumerate(data['Layers']):
    51045063            if not ilay:
    5105                 layerSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Top layer (superphase):'),0,WACV)
     5064                layerSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Top layer (superphase):'),0,WACV)
    51065065            elif ilay < len(data['Layers'])-1:
    5107                 layerSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Layer no. %d'%(ilay)),0,WACV)
     5066                layerSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Layer no. %d'%(ilay)),0,WACV)
    51085067            else:
    5109                 layerSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Bottom layer (substrate):'),0,WACV)
     5068                layerSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Bottom layer (substrate):'),0,WACV)
    51105069            midlayer = wx.BoxSizer(wx.HORIZONTAL)
    5111             midlayer.Add(wx.StaticText(G2frame.dataDisplay,label=' Substance: '),0,WACV)
     5070            midlayer.Add(wx.StaticText(G2frame.dataWindow,label=' Substance: '),0,WACV)
    51125071            midName = data['Layers'][ilay]['Name']
    5113             midSel = wx.ComboBox(G2frame.dataDisplay,value=midName,
     5072            midSel = wx.ComboBox(G2frame.dataWindow,value=midName,
    51145073                choices=Substances.keys(),style=wx.CB_READONLY|wx.CB_DROPDOWN)
    51155074            Indx[midSel.GetId()] = ilay
     
    51185077            if midName != 'vacuum':
    51195078                if midName != 'unit scatter':
    5120                     midlayer.Add(wx.StaticText(G2frame.dataDisplay,label=' Den. Mult.: '),0,WACV)
    5121                     midlayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Layers'][ilay]['DenMul'],0,
     5079                    midlayer.Add(wx.StaticText(G2frame.dataWindow,label=' Den. Mult.: '),0,WACV)
     5080                    midlayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Layers'][ilay]['DenMul'],0,
    51225081                        nDig=(10,4),OnLeave=Recalculate),0,WACV)
    5123                     varBox = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
     5082                    varBox = wx.CheckBox(G2frame.dataWindow,label='Refine?')
    51245083                    Indx[varBox.GetId()] = [ilay,'DenMul']
    51255084                    varBox.SetValue(data['Layers'][ilay]['DenMul'][1])
     
    51275086                    midlayer.Add(varBox,0,WACV)
    51285087                    realScatt = data['Layers'][ilay]['DenMul'][0]*Substances[midName]['Scatt density']
    5129                     midlayer.Add(wx.StaticText(G2frame.dataDisplay,
     5088                    midlayer.Add(wx.StaticText(G2frame.dataWindow,
    51305089                        label=' Real scat. den.: %.4g'%(realScatt)),0,WACV)
    51315090                    imagScatt = data['Layers'][ilay]['DenMul'][0]*Substances[midName]['XImag density']
    5132                     midlayer.Add(wx.StaticText(G2frame.dataDisplay,
     5091                    midlayer.Add(wx.StaticText(G2frame.dataWindow,
    51335092                        label=' Imag scat. den.: %.4g'%(imagScatt)),0,WACV)
    51345093                else:
    51355094                    realScatt = data['Layers'][ilay]['DenMul'][0]
    5136                     midlayer.Add(wx.StaticText(G2frame.dataDisplay,
     5095                    midlayer.Add(wx.StaticText(G2frame.dataWindow,
    51375096                        label=' Real scat. den.: %.4g'%(realScatt)),0,WACV)
    51385097                    imagScatt = data['Layers'][ilay]['iDenMul'][0]
    5139                     midlayer.Add(wx.StaticText(G2frame.dataDisplay,
     5098                    midlayer.Add(wx.StaticText(G2frame.dataWindow,
    51405099                        label=' Imag scat. den.: %.4g'%(imagScatt)),0,WACV)                   
    51415100            else:
    5142                 midlayer.Add(wx.StaticText(G2frame.dataDisplay,label=', air or gas'),0,WACV)
     5101                midlayer.Add(wx.StaticText(G2frame.dataWindow,label=', air or gas'),0,WACV)
    51435102            layerSizer.Add(midlayer)
    51445103            if midName == 'unit scatter':
    51455104                nxtlayer = wx.BoxSizer(wx.HORIZONTAL)
    5146                 nxtlayer.Add(wx.StaticText(G2frame.dataDisplay,label=' Real Den. : '),0,WACV)               
    5147                 nxtlayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Layers'][ilay]['DenMul'],0,
     5105                nxtlayer.Add(wx.StaticText(G2frame.dataWindow,label=' Real Den. : '),0,WACV)               
     5106                nxtlayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Layers'][ilay]['DenMul'],0,
    51485107                    nDig=(10,4),OnLeave=Recalculate),0,WACV)
    5149                 varBox = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
     5108                varBox = wx.CheckBox(G2frame.dataWindow,label='Refine?')
    51505109                Indx[varBox.GetId()] = [ilay,'DenMul']
    51515110                varBox.SetValue(data['Layers'][ilay]['DenMul'][1])
    51525111                varBox.Bind(wx.EVT_CHECKBOX, OnCheckBox)
    51535112                nxtlayer.Add(varBox,0,WACV)
    5154                 nxtlayer.Add(wx.StaticText(G2frame.dataDisplay,label=' Imag Den. : '),0,WACV)               
    5155                 nxtlayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Layers'][ilay]['iDenMul'],0,
     5113                nxtlayer.Add(wx.StaticText(G2frame.dataWindow,label=' Imag Den. : '),0,WACV)               
     5114                nxtlayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Layers'][ilay]['iDenMul'],0,
    51565115                    nDig=(10,4),OnLeave=Recalculate),0,WACV)
    5157                 varBox = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
     5116                varBox = wx.CheckBox(G2frame.dataWindow,label='Refine?')
    51585117                Indx[varBox.GetId()] = [ilay,'iDenMul']
    51595118                varBox.SetValue(data['Layers'][ilay]['iDenMul'][1])
     
    51645123                if 'N' in Inst['Type'][0] and midName not in ['vacuum','unit scatter']:
    51655124                    magLayer = wx.BoxSizer(wx.HORIZONTAL)
    5166                     magLayer.Add(wx.StaticText(G2frame.dataDisplay,label=' Magnetic SLD: '),0,WACV)
    5167                     magLayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Layers'][ilay]['Mag SLD'],0,
     5125                    magLayer.Add(wx.StaticText(G2frame.dataWindow,label=' Magnetic SLD: '),0,WACV)
     5126                    magLayer.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Layers'][ilay]['Mag SLD'],0,
    51685127                        nDig=(10,4),OnLeave=Recalculate),0,WACV)
    5169                     varBox = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
     5128                    varBox = wx.CheckBox(G2frame.dataWindow,label='Refine?')
    51705129                    Indx[varBox.GetId()] = [ilay,'Mag SLD']
    51715130                    varBox.SetValue(data['Layers'][ilay]['Mag SLD'][1])
    51725131                    varBox.Bind(wx.EVT_CHECKBOX, OnCheckBox)
    51735132                    magLayer.Add(varBox,0,WACV)
    5174                     magLayer.Add(wx.StaticText(G2frame.dataDisplay,
     5133                    magLayer.Add(wx.StaticText(G2frame.dataWindow,
    51755134                        label=' Real+mag scat. den.: %.4g'%(realScatt+data['Layers'][ilay]['Mag SLD'][0])),0,WACV)
    51765135                    layerSizer.Add(magLayer)
     
    51825141                        parms = ['Rough',]
    51835142                    for parm in parms:
    5184                         parmsline.Add(wx.StaticText(G2frame.dataDisplay,label=' %s: '%(names[parm])),0,WACV)
    5185                         parmsline.Add(G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['Layers'][ilay][parm],0,
     5143                        parmsline.Add(wx.StaticText(G2frame.dataWindow,label=' %s: '%(names[parm])),0,WACV)
     5144                        parmsline.Add(G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['Layers'][ilay][parm],0,
    51865145                            nDig=(10,2),OnLeave=Recalculate),0,WACV)
    5187                         varBox = wx.CheckBox(G2frame.dataDisplay,label='Refine?')
     5146                        varBox = wx.CheckBox(G2frame.dataWindow,label='Refine?')
    51885147                        Indx[varBox.GetId()] = [ilay,parm]
    51895148                        varBox.SetValue(data['Layers'][ilay][parm][1])
     
    51935152            if ilay < len(data['Layers'])-1:
    51945153                newlayer = wx.BoxSizer(wx.HORIZONTAL)
    5195                 insert = wx.Button(G2frame.dataDisplay,label='Insert')
     5154                insert = wx.Button(G2frame.dataWindow,label='Insert')
    51965155                Indx[insert.GetId()] = ilay
    51975156                insert.Bind(wx.EVT_BUTTON,OnInsertLayer)
    51985157                newlayer.Add(insert)
    5199                 delet = wx.Button(G2frame.dataDisplay,label='Delete')
     5158                delet = wx.Button(G2frame.dataWindow,label='Delete')
    52005159                Indx[delet.GetId()] = ilay
    52015160                delet.Bind(wx.EVT_BUTTON,OnDeleteLayer)
    52025161                newlayer.Add(delet)
    52035162                layerSizer.Add(newlayer)
    5204                 G2G.HorizontalLine(layerSizer,G2frame.dataDisplay)   
     5163                G2G.HorizontalLine(layerSizer,G2frame.dataWindow)   
    52055164       
    52065165        return layerSizer
     
    52625221    Limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Limits'))
    52635222    Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    5264     if G2frame.dataDisplay:
    5265         G2frame.dataFrame.DestroyChildren()   # is this a ScrolledWindow? If so, bad!
    5266     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.REFDModelMenu)
    5267     if not G2frame.dataFrame.GetStatusBar():
    5268         G2frame.dataFrame.CreateStatusBar()
    5269     G2frame.dataFrame.SetLabel('Modelling')
    5270     G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
     5223    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.REFDModelMenu)
     5224    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Modelling')
     5225    G2frame.dataWindow.ClearData()
    52715226    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyModel, id=G2gd.wxID_MODELCOPY)
    52725227    G2frame.dataFrame.Bind(wx.EVT_MENU, OnModelPlot, id=G2gd.wxID_MODELPLOT)
     
    52765231    mainSizer = wx.BoxSizer(wx.VERTICAL)
    52775232   
    5278     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Reflectometry fitting for: '+Name),0,WACV)
    5279     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Controls:'),0,WACV)
     5233    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Reflectometry fitting for: '+Name),0,WACV)
     5234    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Controls:'),0,WACV)
    52805235    mainSizer.Add(ControlSizer())
    5281     G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)   
    5282     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Global parameters:'),0,WACV)
     5236    G2G.HorizontalLine(mainSizer,G2frame.dataWindow)   
     5237    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Global parameters:'),0,WACV)
    52835238    mainSizer.Add(OverallSizer())
    5284     G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
     5239    G2G.HorizontalLine(mainSizer,G2frame.dataWindow)
    52855240    Nlayers = len(data['Layers'])
    52865241    if Nlayers > 2:
     
    52885243            data['Layer Seq'] = ' '.join([str(i+1) for i in range(Nlayers-2)])
    52895244        lineSizer = wx.BoxSizer(wx.HORIZONTAL)
    5290         lineSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Layer sequence: '),0,WACV)
    5291         repseq = wx.TextCtrl(G2frame.dataDisplay,value = data['Layer Seq'],style=wx.TE_PROCESS_ENTER,size=(500,25))
     5245        lineSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Layer sequence: '),0,WACV)
     5246        repseq = wx.TextCtrl(G2frame.dataWindow,value = data['Layer Seq'],style=wx.TE_PROCESS_ENTER,size=(500,25))
    52925247        repseq.Bind(wx.EVT_TEXT_ENTER,OnRepSeq)       
    52935248        repseq.Bind(wx.EVT_KILL_FOCUS,OnRepSeq)
     
    52975252        for ilay,layer in enumerate(data['Layers'][1:-1]):
    52985253            Str += ' %d: %s'%(ilay+1,layer['Name'])
    5299         mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=Str),0,WACV)
    5300         mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' NB: Repeat sequence by e.g. 6*(1 2) '),0,WACV)
    5301     G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)   
    5302     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Layers: scatt. densities are 10%scm%s = 10%s%s%s'%(Pwr10,Pwrm2,Pwrm6,Angstr,Pwrm2)),0,WACV)
     5254        mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=Str),0,WACV)
     5255        mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' NB: Repeat sequence by e.g. 6*(1 2) '),0,WACV)
     5256    G2G.HorizontalLine(mainSizer,G2frame.dataWindow)   
     5257    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Layers: scatt. densities are 10%scm%s = 10%s%s%s'%(Pwr10,Pwrm2,Pwrm6,Angstr,Pwrm2)),0,WACV)
    53035258    mainSizer.Add(LayerSizer())
    53045259    mainSizer.Layout()   
    5305     G2frame.dataDisplay.SetSizer(mainSizer)
    5306     G2frame.dataDisplay.SetAutoLayout(1)
    5307     G2frame.dataDisplay.SetupScrolling()
    5308     Size = mainSizer.Fit(G2frame.dataFrame)
    5309     Size[0] += 25
    5310     Size[1] = min(700,Size[1])
    5311     G2frame.dataFrame.setSizePosLeft(Size)
    5312 #    x,xr,y = G2pwd.makeSLDprofile(data,Substances)
    5313 #    ModelPlot(data,x,xr,y)
    5314    
     5260    G2frame.dataWindow.SetSizer(mainSizer)
     5261    G2frame.dataWindow.SetAutoLayout(1)
     5262    mainSizer.FitInside(G2frame.dataFrame)
     5263    G2frame.SetDataSize()   
    53155264   
    53165265################################################################################
     
    54775426                item['Refine'] = refMult.GetValue()
    54785427                if item['Refine']:
    5479                     Status.SetStatusText('Be sure Mult is close to anticipated value. '+   \
     5428                    G2frame.GetStatusBar().SetStatusText('Be sure Mult is close to anticipated value. '+   \
    54805429                        'Suggest setting Flat Bkg. to 0 before Optimize Mult')
    54815430           
     
    55075456            item = data[key]
    55085457            fileList = [''] + GetFileList(G2frame,'PWDR')
    5509             fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' '+key+' file:'),0,WACV)
    5510             fileName = wx.ComboBox(G2frame.dataDisplay,value=item['Name'],choices=fileList,
     5458            fileSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' '+key+' file:'),0,WACV)
     5459            fileName = wx.ComboBox(G2frame.dataWindow,value=item['Name'],choices=fileList,
    55115460                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    55125461            itemDict[fileName.GetId()] = [key,'Name','%s']
    55135462            fileName.Bind(wx.EVT_COMBOBOX,OnSelectFile)       
    55145463            fileSizer.Add(fileName,0,)
    5515             fileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label='Multiplier:'),0,WACV)
     5464            fileSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label='Multiplier:'),0,WACV)
    55165465            mulBox = wx.BoxSizer(wx.HORIZONTAL)
    5517             mult = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,item,'Mult',nDig=(10,3),
     5466            mult = G2G.ValidatedTxtCtrl(G2frame.dataWindow,item,'Mult',nDig=(10,3),
    55185467                typeHint=float,OnLeave=OnMult)
    55195468            mulBox.Add(mult,0,)
    5520             multSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,25))
     5469            multSpin = wx.SpinButton(G2frame.dataWindow,style=wx.SP_VERTICAL,size=wx.Size(20,25))
    55215470            multSpin.SetRange(-1,1)
    55225471            multSpin.SetValue(0)
     
    55255474            fileSizer.Add(mulBox,0,WACV)
    55265475            if 'Refine' in item and item['Name']:
    5527                 refMult = wx.CheckBox(parent=G2frame.dataDisplay,label='Refine?')
     5476                refMult = wx.CheckBox(parent=G2frame.dataWindow,label='Refine?')
    55285477                refMult.SetValue(item['Refine'])
    55295478                refMult.Bind(wx.EVT_CHECKBOX, OnRefMult)
     
    55525501                           
    55535502        PDFfileSizer = wx.BoxSizer(wx.VERTICAL)
    5554         PDFfileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' PDF data files: '),0,WACV)
     5503        PDFfileSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=' PDF data files: '),0,WACV)
    55555504        PDFfileSizer.Add((5,5),0)   
    55565505        if 'C' in inst['Type'][0]:
    55575506            str = ' Sample file: PWDR%s   Wavelength, A: %.5f  Energy, keV: %.3f  Polariz.: %.2f '%(dataFile[4:],wave,keV,polariz)
    5558             PDFfileSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=str),0,WACV)
     5507            PDFfileSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label=str),0,WACV)
    55595508        PDFfileSizer.Add((5,5),0)
    55605509        fileSizer = wx.FlexGridSizer(0,5,5,1)
     
    55775526                wx.CallAfter(OnComputePDF,None)
    55785527                   
    5579             elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
     5528            elemSizer.Add(wx.StaticText(parent=G2frame.dataWindow,
    55805529                label=' Element: '+'%2s'%(ElData['Symbol'])+' * '),0,WACV)
    5581             num = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,ElData,'FormulaNo',nDig=(10,3),min=0.0,
     5530            num = G2G.ValidatedTxtCtrl(G2frame.dataWindow,ElData,'FormulaNo',nDig=(10,3),min=0.0,
    55825531                typeHint=float,OnLeave=AfterChange)
    55835532            elemSizer.Add(num,0,WACV)
    5584             elemSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,
     5533            elemSizer.Add(wx.StaticText(parent=G2frame.dataWindow,
    55855534                label="f': %.3f"%(ElData['fp'])+' f": %.3f'%(ElData['fpp'])+' mu: %.2f barns'%(ElData['mu']) ),
    55865535                0,WACV)
     
    55995548        sampleSizer = wx.BoxSizer(wx.VERTICAL)
    56005549        if not ElList:
    5601             sampleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: fill in this 1st'),0,WACV)
     5550            sampleSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Sample information: fill in this 1st'),0,WACV)
    56025551        else:
    5603             sampleSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample information: '),0,WACV)
     5552            sampleSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Sample information: '),0,WACV)
    56045553        sampleSizer.Add((5,5),0)   
    56055554        Abs = G2lat.CellAbsorption(ElList,data['Form Vol'])
     
    56115560        sampleSizer.Add((5,5),0)   
    56125561        midSizer = wx.BoxSizer(wx.HORIZONTAL)
    5613         midSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Formula volume: '),0,WACV)
    5614         formVol = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Form Vol',nDig=(10,3),min=10.0,
     5562        midSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Formula volume: '),0,WACV)
     5563        formVol = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Form Vol',nDig=(10,3),min=10.0,
    56155564            typeHint=float,OnLeave=AfterChange)
    56165565        midSizer.Add(formVol,0)
    5617         midSizer.Add(wx.StaticText(G2frame.dataDisplay,
     5566        midSizer.Add(wx.StaticText(G2frame.dataWindow,
    56185567            label=' Theoretical absorption: %.4f cm-1 Sample absorption: %.4f cm-1'%(Abs,Abs*data['Pack'])),
    56195568            0,WACV)
     
    56215570        sampleSizer.Add((5,5),0)
    56225571        geoBox = wx.BoxSizer(wx.HORIZONTAL)
    5623         geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample geometry: '),0,WACV)
     5572        geoBox.Add(wx.StaticText(G2frame.dataWindow,label=' Sample geometry: '),0,WACV)
    56245573        choice = ['Cylinder','Bragg-Brentano','Tilting flat plate in transmission','Fixed flat plate']
    5625         geometry = wx.ComboBox(G2frame.dataDisplay,value=data['Geometry'],choices=choice,
     5574        geometry = wx.ComboBox(G2frame.dataWindow,value=data['Geometry'],choices=choice,
    56265575                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    56275576        geometry.Bind(wx.EVT_COMBOBOX, OnGeometry)
    56285577        geoBox.Add(geometry,0)
    5629         geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample diameter/thickness, mm: '),0,WACV)
    5630         diam = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Diam',nDig=(10,3),min=0.01,
     5578        geoBox.Add(wx.StaticText(G2frame.dataWindow,label=' Sample diameter/thickness, mm: '),0,WACV)
     5579        diam = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Diam',nDig=(10,3),min=0.01,
    56315580            typeHint=float,OnLeave=AfterChange)
    56325581        geoBox.Add(diam,0)
     
    56345583        sampleSizer.Add((5,5),0)   
    56355584        geoBox = wx.BoxSizer(wx.HORIZONTAL)
    5636         geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Packing: '),0,WACV)
    5637         pack = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Pack',nDig=(10,2),min=0.01,
     5585        geoBox.Add(wx.StaticText(G2frame.dataWindow,label=' Packing: '),0,WACV)
     5586        pack = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Pack',nDig=(10,2),min=0.01,
    56385587            typeHint=float,OnLeave=AfterChange)
    56395588        geoBox.Add(pack,0)
    5640         geoBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Sample transmission: %.3f %%'%(Trans)),0,WACV)   
     5589        geoBox.Add(wx.StaticText(G2frame.dataWindow,label=' Sample transmission: %.3f %%'%(Trans)),0,WACV)   
    56415590        sampleSizer.Add(geoBox,0)
    56425591        return sampleSizer
     
    56525601                G2frame.ErrorDialog('PDF error','Chemical formula not defined')
    56535602                return
    5654             Status.SetStatusText('')
     5603            G2frame.GetStatusBar().SetStatusText('')
    56555604            wx.BeginBusyCursor()
    56565605            try:
     
    57115660        sfgSizer = wx.BoxSizer(wx.VERTICAL)         
    57125661        sqBox = wx.BoxSizer(wx.HORIZONTAL)
    5713         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' S(Q)->F(Q)->G(r) controls: '),0,WACV)
     5662        sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' S(Q)->F(Q)->G(r) controls: '),0,WACV)
    57145663        sqBox.Add((1,1),1,wx.EXPAND,1)
    5715         optB = wx.Button(G2frame.dataDisplay,label='Optimize PDF',style=wx.BU_EXACTFIT)
     5664        optB = wx.Button(G2frame.dataWindow,label='Optimize PDF',style=wx.BU_EXACTFIT)
    57165665        optB.Bind(wx.EVT_BUTTON, OnOptimizePDF)
    57175666        sqBox.Add(optB,0,WACV|wx.ALIGN_RIGHT)
     
    57205669        sfgSizer.Add((5,5),0)
    57215670        sqBox = wx.BoxSizer(wx.HORIZONTAL)
    5722         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Detector type: '),0,WACV)
     5671        sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' Detector type: '),0,WACV)
    57235672        choice = ['Area detector','Point detector']
    5724         detType = wx.ComboBox(G2frame.dataDisplay,value=data['DetType'],choices=choice,
     5673        detType = wx.ComboBox(G2frame.dataWindow,value=data['DetType'],choices=choice,
    57255674                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    57265675        detType.Bind(wx.EVT_COMBOBOX, OnDetType)
    57275676        sqBox.Add(detType,0)
    57285677        if data['DetType'] == 'Area detector':
    5729             sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' IP transmission coeff.: '),0,WACV)
    5730             obliqCoeff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'ObliqCoeff',nDig=(10,3),min=0.0,max=1.0,
     5678            sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' IP transmission coeff.: '),0,WACV)
     5679            obliqCoeff = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'ObliqCoeff',nDig=(10,3),min=0.0,max=1.0,
    57315680                typeHint=float,OnLeave=AfterChangeNoRefresh)
    57325681            sqBox.Add(obliqCoeff,0)
    5733         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Flat Bkg.: '),0,WACV)
    5734         flatBkg = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Flat Bkg',nDig=(10,0),min=0,
     5682        sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' Flat Bkg.: '),0,WACV)
     5683        flatBkg = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Flat Bkg',nDig=(10,0),min=0,
    57355684                typeHint=float,OnLeave=AfterChangeNoRefresh)
    57365685        sqBox.Add(flatBkg,0)
    5737         flatSpin = wx.SpinButton(G2frame.dataDisplay,style=wx.SP_VERTICAL,size=wx.Size(20,25))
     5686        flatSpin = wx.SpinButton(G2frame.dataWindow,style=wx.SP_VERTICAL,size=wx.Size(20,25))
    57385687        flatSpin.SetRange(-1,1)
    57395688        flatSpin.SetValue(0)
     
    57415690        sqBox.Add(flatSpin,0,WACV)
    57425691        sqBox.Add((1,1),1,wx.EXPAND,1)
    5743         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label='Rmin: '),0,WACV|wx.ALIGN_RIGHT)
    5744         rmin = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Rmin',nDig=(5,1),
     5692        sqBox.Add(wx.StaticText(G2frame.dataWindow,label='Rmin: '),0,WACV|wx.ALIGN_RIGHT)
     5693        rmin = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Rmin',nDig=(5,1),
    57455694                typeHint=float,size=wx.Size(50,20))
    57465695        sqBox.Add(rmin,0,WACV|wx.ALIGN_RIGHT)
     
    57485697           
    57495698        bkBox = wx.BoxSizer(wx.HORIZONTAL)
    5750         bkBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Background ratio: '),0,WACV)   
    5751         backSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
     5699        bkBox.Add(wx.StaticText(G2frame.dataWindow,label=' Background ratio: '),0,WACV)   
     5700        backSldr = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,
    57525701            value=int(100*data['BackRatio']))
    57535702        bkBox.Add(backSldr,1,wx.EXPAND)
    57545703        backSldr.Bind(wx.EVT_SLIDER, OnBackSlider)
    5755         backVal = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'BackRatio',nDig=(10,3),min=0.0,max=1.0,
     5704        backVal = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'BackRatio',nDig=(10,3),min=0.0,max=1.0,
    57565705            typeHint=float,OnLeave=AfterChangeNoRefresh)
    57575706        bkBox.Add(backVal,0,WACV)   
     
    57595708   
    57605709        sqBox = wx.BoxSizer(wx.HORIZONTAL)
    5761         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Ruland width: '),0,WACV)   
    5762         rulandSldr = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
     5710        sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' Ruland width: '),0,WACV)   
     5711        rulandSldr = wx.Slider(parent=G2frame.dataWindow,style=wx.SL_HORIZONTAL,
    57635712            value=int(1000*data['Ruland']))
    57645713        sqBox.Add(rulandSldr,1,wx.EXPAND)
    57655714        rulandSldr.Bind(wx.EVT_SLIDER, OnRulSlider)
    5766         rulandWdt = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Ruland',nDig=(10,3),min=0.001,max=1.0,
     5715        rulandWdt = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Ruland',nDig=(10,3),min=0.001,max=1.0,
    57675716            typeHint=float,OnLeave=AfterChangeNoRefresh)
    57685717        sqBox.Add(rulandWdt,0,WACV)   
     
    57705719       
    57715720        sqBox = wx.BoxSizer(wx.HORIZONTAL)
    5772         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Scaling Q-range: '),0,WACV)
    5773         SQmin = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['QScaleLim'],0,nDig=(10,3),
     5721        sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' Scaling Q-range: '),0,WACV)
     5722        SQmin = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['QScaleLim'],0,nDig=(10,3),
    57745723            min=qLimits[0],max=.95*data['QScaleLim'][1],
    57755724            typeHint=float,OnLeave=AfterChangeNoRefresh)
    57765725        sqBox.Add(SQmin,0,WACV)
    5777         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' to Qmax '),0,WACV)
    5778         SQmax = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data['QScaleLim'],1,nDig=(10,3),
     5726        sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' to Qmax '),0,WACV)
     5727        SQmax = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data['QScaleLim'],1,nDig=(10,3),
    57795728            min=qLimits[0],max=qLimits[1],typeHint=float,OnLeave=NewQmax)
    57805729        sqBox.Add(SQmax,0,WACV)
    5781         resetQ = wx.Button(G2frame.dataDisplay,label='Reset?',style=wx.BU_EXACTFIT)
     5730        resetQ = wx.Button(G2frame.dataWindow,label='Reset?',style=wx.BU_EXACTFIT)
    57825731        sqBox.Add(resetQ,0,WACV)
    57835732        resetQ.Bind(wx.EVT_BUTTON, OnResetQ)
    5784         sqBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Rmax: '),0,WACV)
    5785         rmax = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Rmax',nDig=(10,1),min=10.,max=200.,
     5733        sqBox.Add(wx.StaticText(G2frame.dataWindow,label=' Rmax: '),0,WACV)
     5734        rmax = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'Rmax',nDig=(10,1),min=10.,max=200.,
    57865735            typeHint=float,OnLeave=AfterChangeNoRefresh,size=wx.Size(50,20))
    57875736        sqBox.Add(rmax,0,WACV)
    5788         lorch = wx.CheckBox(parent=G2frame.dataDisplay,label='Lorch damping?')
     5737        lorch = wx.CheckBox(parent=G2frame.dataWindow,label='Lorch damping?')
    57895738        lorch.SetValue(data['Lorch'])
    57905739        lorch.Bind(wx.EVT_CHECKBOX, OnLorch)
    57915740        sqBox.Add(lorch,0,WACV)
    5792         noRing = wx.CheckBox(parent=G2frame.dataDisplay,label='Suppress G(0) ringing?')
     5741        noRing = wx.CheckBox(parent=G2frame.dataWindow,label='Suppress G(0) ringing?')
    57935742        noRing.SetValue(data['noRing'])
    57945743        noRing.Bind(wx.EVT_CHECKBOX, OnNoRing)
     
    58265775        diffSizer = wx.BoxSizer(wx.HORIZONTAL)
    58275776        fileList = [''] + GetFileList(G2frame,'PDF')
    5828         diffSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Subtract G(R) for: '),0,WACV)
    5829         grName = wx.ComboBox(G2frame.dataDisplay,value=data['diffGRname'],choices=fileList,
     5777        diffSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Subtract G(R) for: '),0,WACV)
     5778        grName = wx.ComboBox(G2frame.dataWindow,value=data['diffGRname'],choices=fileList,
    58305779            style=wx.CB_READONLY|wx.CB_DROPDOWN)
    58315780        grName.Bind(wx.EVT_COMBOBOX,OnSelectGR)       
    58325781        diffSizer.Add(grName,0,WACV)
    58335782        if data['diffGRname']:
    5834             diffSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Mult: '),0,WACV)
    5835             mult = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'diffMult',nDig=(10,3),
     5783            diffSizer.Add(wx.StaticText(G2frame.dataWindow,label=' Mult: '),0,WACV)
     5784            mult = G2G.ValidatedTxtCtrl(G2frame.dataWindow,data,'diffMult',nDig=(10,3),
    58365785                    typeHint=float,OnLeave=OnMult)
    58375786            diffSizer.Add(mult,0,WACV)
     
    58705819                        olddata['Sample'] = sample
    58715820                    G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Controls'),olddata)
    5872                 Status.SetStatusText('PDF controls copied')
     5821                G2frame.GetStatusBar().SetStatusText('PDF controls copied')
    58735822        finally:
    58745823            dlg.Destroy()
     
    59545903            return
    59555904        auxPlot = computePDF(G2frame,data)
    5956         if not G2frame.dataFrame.GetStatusBar():
    5957             Status = G2frame.dataFrame.CreateStatusBar()
    5958             Status.SetStatusText('PDF computed')
     5905        G2frame.GetStatusBar().SetStatusText('PDF computed')
    59595906        for plot in auxPlot:
    59605907            XY = np.array(plot[:2])
     
    60285975        else:
    60295976            msg = '{}/{} PDFs computed'.format(N,len(Names))
    6030         G2frame.dataFrame.GetStatusBar().SetStatusText(msg)
     5977        G2frame.GetStatusBar().SetStatusText(msg)
    60315978        print(msg)
    60325979        # what item is being plotted? -- might be better to select from tree
     
    60816028        if 'diffMult' not in data:
    60826029            data['diffMult'] = 1.0
    6083     if G2frame.dataDisplay:
    6084         G2frame.dataFrame.Clear()
    6085     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PDFMenu)
    6086     if not G2frame.dataFrame.GetStatusBar():
    6087         Status = G2frame.dataFrame.CreateStatusBar()
     6030    G2frame.dataFrame.ClearData()
     6031    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.PDFMenu)
    60886032    if powId:
    60896033        G2frame.dataFrame.PDFMenu.EnableTop(0,enable=True)
    60906034    else:
    60916035        G2frame.dataFrame.PDFMenu.EnableTop(0,enable=False)
    6092     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
    60936036    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFControls, id=G2gd.wxID_PDFCOPYCONTROLS)
    60946037    G2frame.dataFrame.Bind(wx.EVT_MENU, OnSavePDFControls, id=G2gd.wxID_PDFSAVECONTROLS)
     
    61036046        ElList = data['ElList']
    61046047        mainSizer.Add(PDFFileSizer(),0,WACV)
    6105         G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
     6048        G2G.HorizontalLine(mainSizer,G2frame.dataWindow)
    61066049        mainSizer.Add(SampleSizer(),0,WACV)
    6107         G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
     6050        G2G.HorizontalLine(mainSizer,G2frame.dataWindow)
    61086051        mainSizer.Add(SFGctrlSizer(),0,WACV)
    6109         G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
     6052        G2G.HorizontalLine(mainSizer,G2frame.dataWindow)
    61106053    mainSizer.Add(DiffSizer(),0,WACV)
    61116054    mainSizer.Layout()   
    6112     G2frame.dataDisplay.SetSizer(mainSizer)
    6113     Size = mainSizer.Fit(G2frame.dataFrame)
    6114     G2frame.dataFrame.setSizePosLeft(Size)
     6055    G2frame.dataWindow.SetSizer(mainSizer)
     6056    mainSizer.Fit(G2frame.dataFrame)
     6057    G2frame.SetDataSize()
     6058
    61156059###############################################################################################################
    61166060#UpdatePDFPeaks: peaks in G(r)
     
    61266070                       
    61276071        limitBox = wx.BoxSizer(wx.HORIZONTAL)
    6128         limitBox.Add(wx.StaticText(G2frame.dataDisplay,label=' PDF Limits: '),0,WACV)
    6129         lowLim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,peaks['Limits'],0,nDig=(10,3),
     6072        limitBox.Add(wx.StaticText(G2frame.dataWindow,label=' PDF Limits: '),0,WACV)
     6073        lowLim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,peaks['Limits'],0,nDig=(10,3),
    61306074            min=0.,max=10.,typeHint=float,OnLeave=NewLim)
    61316075        limitBox.Add(lowLim,0,WACV)
    6132         highLim = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,peaks['Limits'],1,nDig=(10,3),
     6076        highLim = G2G.ValidatedTxtCtrl(G2frame.dataWindow,peaks['Limits'],1,nDig=(10,3),
    61336077            min=peaks['Limits'][0],max=10.,typeHint=float,OnLeave=NewLim)
    61346078        limitBox.Add(highLim,0,WACV)
     
    61466090       
    61476091        backBox = wx.wx.BoxSizer(wx.HORIZONTAL)
    6148         backBox.Add(wx.StaticText(G2frame.dataDisplay,label=' Background slope: '),0,WACV)
    6149         slope = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,peaks['Background'][1],1,nDig=(10,3),
     6092        backBox.Add(wx.StaticText(G2frame.dataWindow,label=' Background slope: '),0,WACV)
     6093        slope = G2G.ValidatedTxtCtrl(G2frame.dataWindow,peaks['Background'][1],1,nDig=(10,3),
    61506094            min=-4.*np.pi,max=0.,typeHint=float,OnLeave=NewBack)
    61516095        backBox.Add(slope,0,WACV)
    6152         refbk = wx.CheckBox(parent=G2frame.dataDisplay,label=' Refine?')
     6096        refbk = wx.CheckBox(parent=G2frame.dataWindow,label=' Refine?')
    61536097        refbk.SetValue(peaks['Background'][2])
    61546098        refbk.Bind(wx.EVT_CHECKBOX, OnRefBack)
     
    61886132        rowLabels = range(len(peaks['Peaks']))
    61896133        peakTable = G2G.Table(peaks['Peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
    6190         PDFPeaks = G2G.GSGrid(G2frame.dataDisplay)
     6134        PDFPeaks = G2G.GSGrid(G2frame.dataWindow)
    61916135        PDFPeaks.SetTable(peakTable,False)
    61926136        PDFPeaks.SetMargins(0,0)
     
    61976141
    61986142        peakBox = wx.BoxSizer(wx.VERTICAL)
    6199         peakBox.Add(wx.StaticText(G2frame.dataDisplay,label=' PDF Peaks:'),0,WACV)
     6143        peakBox.Add(wx.StaticText(G2frame.dataWindow,label=' PDF Peaks:'),0,WACV)
    62006144        peakBox.Add(PDFPeaks,0,WACV)
    62016145       
     
    62186162                    olddata.update(copy.deepcopy(peaks))
    62196163                    G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'PDF Peaks'),olddata)
    6220                 Status.SetStatusText('PDF peaks copied')
     6164                G2frame.GetStatusBar().SetStatusText('PDF peaks copied')
    62216165        finally:
    62226166            dlg.Destroy()
     
    62766220        wx.CallAfter(UpdatePDFPeaks,G2frame,peaks,data)
    62776221
    6278     if G2frame.dataDisplay:
    6279         G2frame.dataFrame.Clear()
    6280     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PDFPksMenu)
    6281     if not G2frame.dataFrame.GetStatusBar():
    6282         Status = G2frame.dataFrame.CreateStatusBar()   
    6283     G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     6222    G2frame.dataFrame.ClearData()
     6223    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.PDFPksMenu)
    62846224    G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPDFPeaks, id=G2gd.wxID_PDFCOPYPEAKS)
    62856225    G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitPDFpeaks, id=G2gd.wxID_PDFPKSFIT)
     
    62886228    mainSizer = wx.BoxSizer(wx.VERTICAL)
    62896229    mainSizer.Add((5,5),0)
    6290     mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' PDF peak fit controls:'),0,WACV)
     6230    mainSizer.Add(wx.StaticText(G2frame.dataWindow,label=' PDF peak fit controls:'),0,WACV)
    62916231    mainSizer.Add((5,5),0)
    62926232    mainSizer.Add(limitSizer(),0,WACV)
     
    62976237        mainSizer.Add(peakSizer())
    62986238    mainSizer.Layout()   
    6299     G2frame.dataDisplay.SetSizer(mainSizer)
    6300     Size = mainSizer.Fit(G2frame.dataFrame)
    6301     G2frame.dataFrame.setSizePosLeft(Size)
     6239    G2frame.dataWindow.SetSizer(mainSizer)
     6240    mainSizer.Fit(G2frame.dataFrame)
     6241    G2frame.SetDataSize()
    63026242   
  • TabularUnified branch/2frame/GSASIIrestrGUI.py

    r2840 r2888  
    6060        return
    6161    phasedata = Phases[phaseName]
    62     tabIndex = {}
    6362    if phaseName not in data:
    6463        data[phaseName] = {}
     
    190189           
    191190    def OnAddRestraint(event):
    192         page = G2frame.dataDisplay.GetSelection()
    193         if 'Bond' in G2frame.dataDisplay.GetPageText(page):
     191        page = G2frame.restrBook.GetSelection()
     192        if 'Bond' in G2frame.restrBook.GetPageText(page):
    194193            AddBondRestraint(restrData['Bond'])
    195         elif 'Angle' in G2frame.dataDisplay.GetPageText(page):
     194        elif 'Angle' in G2frame.restrBook.GetPageText(page):
    196195            AddAngleRestraint(restrData['Angle'])
    197         elif 'Plane' in G2frame.dataDisplay.GetPageText(page):
     196        elif 'Plane' in G2frame.restrBook.GetPageText(page):
    198197            AddPlaneRestraint(restrData['Plane'])
    199         elif 'Chem' in G2frame.dataDisplay.GetPageText(page):
     198        elif 'Chem' in G2frame.restrBook.GetPageText(page):
    200199            AddChemCompRestraint(restrData['ChemComp'])
    201         elif 'Texture' in G2frame.dataDisplay.GetPageText(page):
     200        elif 'Texture' in G2frame.restrBook.GetPageText(page):
    202201            AddTextureRestraint(restrData['Texture'])
    203202           
    204203    def OnAddAARestraint(event):
    205         page = G2frame.dataDisplay.GetSelection()
    206         if 'Bond' in G2frame.dataDisplay.GetPageText(page):
     204        page = G2frame.restrBook.GetSelection()
     205        if 'Bond' in G2frame.restrBook.GetPageText(page):
    207206            AddAABondRestraint(restrData['Bond'])
    208         elif 'Angle' in G2frame.dataDisplay.GetPageText(page):
     207        elif 'Angle' in G2frame.restrBook.GetPageText(page):
    209208            AddAAAngleRestraint(restrData['Angle'])
    210         elif 'Plane' in G2frame.dataDisplay.GetPageText(page):
     209        elif 'Plane' in G2frame.restrBook.GetPageText(page):
    211210            AddAAPlaneRestraint(restrData['Plane'])
    212         elif 'Chiral' in G2frame.dataDisplay.GetPageText(page):
     211        elif 'Chiral' in G2frame.restrBook.GetPageText(page):
    213212            AddAAChiralRestraint(restrData['Chiral'])
    214         elif 'Torsion' in G2frame.dataDisplay.GetPageText(page):
     213        elif 'Torsion' in G2frame.restrBook.GetPageText(page):
    215214            AddAATorsionRestraint(restrData['Torsion'])
    216         elif 'Rama' in G2frame.dataDisplay.GetPageText(page):
     215        elif 'Rama' in G2frame.restrBook.GetPageText(page):
    217216            AddAARamaRestraint(restrData['Rama'])
    218217           
     
    858857            UpdateBondRestr(bondRestData)               
    859858           
    860         #BondRestr.DestroyChildren()
    861         if BondRestr.GetSizer():
    862             BondRestr.GetSizer().Clear(True)
     859        BondRestr.DestroyChildren()
     860#        if BondRestr.GetSizer():
     861#            BondRestr.GetSizer().Clear(True)
    863862        mainSizer = wx.BoxSizer(wx.VERTICAL)
    864863        mainSizer.Add((5,5),0)
     
    937936        BondRestr.SetSize(Size)
    938937        BondRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    939         G2frame.dataFrame.setSizePosLeft(Size)
    940938       
    941939    def UpdateAngleRestr(angleRestData):
     
    990988            UpdateAngleRestr(angleRestData)               
    991989           
    992         #AngleRestr.DestroyChildren()
    993         if AngleRestr.GetSizer():
    994             AngleRestr.GetSizer().Clear(True)
     990        AngleRestr.DestroyChildren()
     991#        if AngleRestr.GetSizer():
     992#            AngleRestr.GetSizer().Clear(True)
    995993        mainSizer = wx.BoxSizer(wx.VERTICAL)
    996994        mainSizer.Add((5,5),0)
     
    10691067        AngleRestr.SetSize(Size)
    10701068        AngleRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1071         G2frame.dataFrame.setSizePosLeft(Size)
    10721069   
    10731070    def UpdatePlaneRestr(planeRestData):
     
    11131110            UpdatePlaneRestr(planeRestData)               
    11141111           
    1115         #PlaneRestr.DestroyChildren()
    1116         if PlaneRestr.GetSizer():
    1117             PlaneRestr.GetSizer().Clear(True)
     1112        PlaneRestr.DestroyChildren()
     1113#        if PlaneRestr.GetSizer():
     1114#            PlaneRestr.GetSizer().Clear(True)
    11181115        mainSizer = wx.BoxSizer(wx.VERTICAL)
    11191116        mainSizer.Add((5,5),0)
     
    11971194        PlaneRestr.SetSize(Size)
    11981195        PlaneRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1199         G2frame.dataFrame.setSizePosLeft(Size)
    12001196   
    12011197    def UpdateChiralRestr(chiralRestData):
     
    12501246            UpdateChiralRestr(chiralRestData)               
    12511247                                           
    1252         #ChiralRestr.DestroyChildren()
    1253         if ChiralRestr.GetSizer():
    1254             ChiralRestr.GetSizer().Clear(True)
     1248        ChiralRestr.DestroyChildren()
     1249#        if ChiralRestr.GetSizer():
     1250#            ChiralRestr.GetSizer().Clear(True)
    12551251        mainSizer = wx.BoxSizer(wx.VERTICAL)
    12561252        mainSizer.Add((5,5),0)
     
    13291325        ChiralRestr.SetSize(Size)
    13301326        ChiralRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1331         G2frame.dataFrame.setSizePosLeft(Size)
    13321327   
    13331328    def UpdateTorsionRestr(torsionRestData):
     
    13681363            wx.CallAfter(UpdateTorsionRestr,torsionRestData)               
    13691364                                           
    1370         #TorsionRestr.DestroyChildren()
    1371         if TorsionRestr.GetSizer():
    1372             TorsionRestr.GetSizer().Clear(True)
     1365        TorsionRestr.DestroyChildren()
     1366#        if TorsionRestr.GetSizer():
     1367#            TorsionRestr.GetSizer().Clear(True)
    13731368        mainSizer = wx.BoxSizer(wx.VERTICAL)
    13741369        mainSizer.Add((5,5),0)
     
    14511446        TorsionRestr.SetSize(Size)
    14521447        TorsionRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1453         G2frame.dataFrame.setSizePosLeft(Size)
    14541448
    14551449    def UpdateRamaRestr(ramaRestData):
     
    14901484            UpdateRamaRestr(ramaRestData)               
    14911485                                           
    1492         #RamaRestr.DestroyChildren()
    1493         if RamaRestr.GetSizer():
    1494             RamaRestr.GetSizer().Clear(True)
     1486        RamaRestr.DestroyChildren()
     1487#        if RamaRestr.GetSizer():
     1488#            RamaRestr.GetSizer().Clear(True)
    14951489        mainSizer = wx.BoxSizer(wx.VERTICAL)
    14961490        mainSizer.Add((5,5),0)
     
    15751569        RamaRestr.SetSize(Size)
    15761570        RamaRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1577         G2frame.dataFrame.setSizePosLeft(Size)
    15781571
    15791572    def UpdateChemcompRestr(chemcompRestData):
     
    16301623            UpdateChemcompRestr(chemcompRestData)               
    16311624
    1632         #ChemCompRestr.DestroyChildren()
    1633         if ChemCompRestr.GetSizer():
    1634             ChemCompRestr.GetSizer().Clear(True)
     1625        ChemCompRestr.DestroyChildren()
     1626#        if ChemCompRestr.GetSizer():
     1627#            ChemCompRestr.GetSizer().Clear(True)
    16351628        mainSizer = wx.BoxSizer(wx.VERTICAL)
    16361629        mainSizer.Add((5,5),0)
     
    17091702        ChemCompRestr.SetSize(Size)
    17101703        ChemCompRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1711         G2frame.dataFrame.setSizePosLeft(Size)
    1712    
    1713        
     1704           
    17141705    def UpdateTextureRestr(textureRestData):
    17151706           
     
    17421733            wx.CallAfter(UpdateTextureRestr,textureRestData)               
    17431734
    1744         #TextureRestr.DestroyChildren()
    1745         if TextureRestr.GetSizer():
    1746             TextureRestr.GetSizer().Clear(True)
     1735        TextureRestr.DestroyChildren()
    17471736        mainSizer = wx.BoxSizer(wx.VERTICAL)
    17481737        mainSizer.Add((5,5),0)
     
    17861775        TextureRestr.SetSize(Size)
    17871776        TextureRestr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    1788         G2frame.dataFrame.setSizePosLeft(Size)
    17891777           
    17901778    def OnPageChanged(event):
    17911779        #print 'OnPageChanged'
    17921780        page = event.GetSelection()
    1793         text = G2frame.dataDisplay.GetPageText(page)
     1781        text = G2frame.restrBook.GetPageText(page)
    17941782        G2frame.dataFrame.RestraintEdit.SetLabel(G2gd.wxID_RESRCHANGEVAL,'Change value')
    17951783        if text == 'Bond':
    1796             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1784            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    17971785            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,True)
    17981786            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESRCHANGEVAL,True)
     
    18001788            UpdateBondRestr(bondRestData)
    18011789        elif text == 'Angle':
    1802             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1790            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    18031791            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,True)
    18041792            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESRCHANGEVAL,True)
     
    18061794            UpdateAngleRestr(angleRestData)
    18071795        elif text == 'Plane':
    1808             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1796            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    18091797            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,True)
    18101798            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESRCHANGEVAL,False)
     
    18121800            UpdatePlaneRestr(planeRestData)
    18131801        elif text == 'Chiral':
    1814             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1802            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    18151803            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,False)
    18161804            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESRCHANGEVAL,True)
     
    18181806            UpdateChiralRestr(chiralRestData)
    18191807        elif text == 'Torsion':
    1820             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1808            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    18211809            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,False)
    18221810            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESRCHANGEVAL,False)
     
    18251813            UpdateTorsionRestr(torsionRestData)
    18261814        elif text == 'Ramachandran':
    1827             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1815            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    18281816            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,False)
    18291817            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESRCHANGEVAL,False)
     
    18331821            wx.CallAfter(G2plt.PlotRama,G2frame,phaseName,rama,ramaName)
    18341822        elif text == 'Chem. comp.':
    1835             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1823            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    18361824            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,True)
    18371825            G2frame.dataFrame.RestraintEdit.SetLabel(G2gd.wxID_RESRCHANGEVAL,'Change factor')
     
    18411829            UpdateChemcompRestr(chemcompRestData)
    18421830        elif text == 'Texture':
    1843             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
     1831            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
    18441832            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTRAINTADD,True)
    18451833            G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESRCHANGEVAL,True)
    18461834            textureRestData = restrData['Texture']
    18471835            UpdateTextureRestr(textureRestData)
    1848            
    18491836        event.Skip()
    18501837
    1851     def RaisePage(event):
    1852         'Respond to a "select tab" menu button'
    1853         # class PseudoEvent(object):
    1854         #     def __init__(self,page): self.page = page
    1855         #     def Skip(self): pass
    1856         #     def GetSelection(self): return self.page
    1857         try:
    1858             i = tabIndex.get(event.GetId())
    1859             G2frame.dataDisplay.SetSelection(i)
    1860             #OnPageChanged(PseudoEvent(i))
    1861         except ValueError:
    1862             print('Unexpected event in RaisePage')
    1863 
    1864     if G2frame.dataDisplay:
    1865         G2frame.dataDisplay.Destroy()
    1866        
    1867     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RestraintMenu)
    1868     G2frame.dataFrame.SetLabel('restraints for '+phaseName)
     1838#    def RaisePage(event):
     1839#        'Respond to a "select tab" menu button'
     1840#        # class PseudoEvent(object):
     1841#        #     def __init__(self,page): self.page = page
     1842#        #     def Skip(self): pass
     1843#        #     def GetSelection(self): return self.page
     1844#        try:
     1845#            i = tabIndex.get(event.GetId())
     1846#            G2frame.restrBook.SetSelection(i)
     1847#            #OnPageChanged(PseudoEvent(i))
     1848#        except ValueError:
     1849#            print('Unexpected event in RaisePage')
     1850#       
     1851    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RestraintMenu)
     1852    G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'restraints for '+phaseName)
     1853    G2frame.dataWindow.ClearData()
    18691854   
    1870     G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTSELPHASE,False)
     1855    G2frame.dataWindow.RestraintEdit.Enable(G2gd.wxID_RESTSELPHASE,False)
    18711856    if len(Phases) > 1:
    1872         G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_RESTSELPHASE,True)
    1873         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_RESTSELPHASE)
     1857        G2frame.dataWindow.RestraintEdit.Enable(G2gd.wxID_RESTSELPHASE,True)
     1858        G2frame.dataWindow.Bind(wx.EVT_MENU, OnSelectPhase, id=G2gd.wxID_RESTSELPHASE)
    18741859    G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddRestraint, id=G2gd.wxID_RESTRAINTADD)
    18751860    if 'macro' in phasedata['General']['Type']:
    1876         G2frame.dataFrame.RestraintEdit.Enable(G2gd.wxID_AARESTRAINTADD,True)
    1877         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddAARestraint, id=G2gd.wxID_AARESTRAINTADD)
    1878         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotAARestraint, id=G2gd.wxID_AARESTRAINTPLOT)
    1879     G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     1861        G2frame.dataWindow.RestraintEdit.Enable(G2gd.wxID_AARESTRAINTADD,True)
     1862        G2frame.dataWindow.Bind(wx.EVT_MENU, OnAddAARestraint, id=G2gd.wxID_AARESTRAINTADD)
     1863        G2frame.dataWindow.Bind(wx.EVT_MENU, OnPlotAARestraint, id=G2gd.wxID_AARESTRAINTPLOT)
     1864    G2frame.restrBook = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize())
    18801865   
    18811866    # clear menu and menu pointers
    1882     tabIndex.clear()
    1883     tabcount = -1
    1884     for i in G2frame.dataFrame.RestraintTab.GetMenuItems():
    1885         G2frame.dataFrame.RestraintTab.DestroyItem(i)       
    18861867
    18871868    txt = 'Bond'
    1888     BondRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1889     G2frame.dataDisplay.AddPage(BondRestr,txt)
    1890     item = G2frame.dataFrame.RestraintTab.Append(
    1891         id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1892         help='Select restraint editing tab')
    1893     G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1894     tabcount += 1
    1895     tabIndex[item.GetId()] = tabcount
     1869    BondRestr = wx.ScrolledWindow(G2frame.restrBook)
     1870    G2frame.restrBook.AddPage(BondRestr,txt)
    18961871
    18971872    txt = 'Angle'
    1898     AngleRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1899     G2frame.dataDisplay.AddPage(AngleRestr,txt)
    1900     item = G2frame.dataFrame.RestraintTab.Append(
    1901         id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1902         help='Select restraint editing tab')
    1903     G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1904     tabcount += 1
    1905     tabIndex[item.GetId()] = tabcount
     1873    AngleRestr = wx.ScrolledWindow(G2frame.restrBook)
     1874    G2frame.restrBook.AddPage(AngleRestr,txt)
    19061875   
    19071876    txt = 'Plane'
    1908     PlaneRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1909     G2frame.dataDisplay.AddPage(PlaneRestr,txt)
    1910     item = G2frame.dataFrame.RestraintTab.Append(
    1911         id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1912         help='Select restraint editing tab')
    1913     G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1914     tabcount += 1
    1915     tabIndex[item.GetId()] = tabcount
     1877    PlaneRestr = wx.ScrolledWindow(G2frame.restrBook)
     1878    G2frame.restrBook.AddPage(PlaneRestr,txt)
    19161879
    19171880    txt = 'Chiral'
    1918     ChiralRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1919     G2frame.dataDisplay.AddPage(ChiralRestr,txt)
    1920     item = G2frame.dataFrame.RestraintTab.Append(
    1921         id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1922         help='Select restraint editing tab')
    1923     G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1924     tabcount += 1
    1925     tabIndex[item.GetId()] = tabcount
     1881    ChiralRestr = wx.ScrolledWindow(G2frame.restrBook)
     1882    G2frame.restrBook.AddPage(ChiralRestr,txt)
    19261883
    19271884    if 'macro' in General['Type']:
    19281885        txt = 'Torsion'
    1929         TorsionRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1930         G2frame.dataDisplay.AddPage(TorsionRestr,txt)
    1931         item = G2frame.dataFrame.RestraintTab.Append(
    1932             id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1933             help='Select restraint editing tab')
    1934         G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1935         tabcount += 1
    1936         tabIndex[item.GetId()] = tabcount
     1886        TorsionRestr = wx.ScrolledWindow(G2frame.restrBook)
     1887        G2frame.restrBook.AddPage(TorsionRestr,txt)
    19371888
    19381889        txt = 'Ramachandran'
    1939         RamaRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1940         G2frame.dataDisplay.AddPage(RamaRestr,txt)
    1941         item = G2frame.dataFrame.RestraintTab.Append(
    1942             id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1943             help='Select restraint editing tab')
    1944         G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1945         tabcount += 1
    1946         tabIndex[item.GetId()] = tabcount
     1890        RamaRestr = wx.ScrolledWindow(G2frame.restrBook)
     1891        G2frame.restrBook.AddPage(RamaRestr,txt)
    19471892
    19481893    txt = 'Chem. comp.'
    1949     ChemCompRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1950     G2frame.dataDisplay.AddPage(ChemCompRestr,txt)
    1951     item = G2frame.dataFrame.RestraintTab.Append(
    1952         id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1953         help='Select restraint editing tab')
    1954     G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1955     tabcount += 1
    1956     tabIndex[item.GetId()] = tabcount
     1894    ChemCompRestr = wx.ScrolledWindow(G2frame.restrBook)
     1895    G2frame.restrBook.AddPage(ChemCompRestr,txt)
    19571896   
    19581897    if General['SH Texture']['Order']:
    19591898        txt = 'Texture'
    1960         TextureRestr = wx.ScrolledWindow(G2frame.dataDisplay)
    1961         G2frame.dataDisplay.AddPage(TextureRestr,txt)
    1962         item = G2frame.dataFrame.RestraintTab.Append(
    1963             id=wx.ID_ANY, kind=wx.ITEM_NORMAL,text=txt,
    1964             help='Select restraint editing tab')
    1965         G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=item.GetId())
    1966         tabcount += 1
    1967         tabIndex[item.GetId()] = tabcount
     1899        TextureRestr = wx.ScrolledWindow(G2frame.restrBook)
     1900        G2frame.restrBook.AddPage(TextureRestr,txt)
    19681901   
    19691902    UpdateBondRestr(restrData['Bond'])
    19701903
    1971     G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     1904    G2frame.restrBook.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
  • TabularUnified branch/2frame/gltext.py

    r2591 r2888  
    278278        Destructor
    279279        """
    280         self.deleteTexture()
     280#        self.deleteTexture()
     281        del self._texture
    281282
    282283    #---Getters/Setters
Note: See TracChangeset for help on using the changeset viewer.