Changeset 2888


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

Legend:

Unmodified
Added
Removed
  • 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()
  • 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)
  • 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):       
  • 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)
  • 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():
  • 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###########################################################################
  • 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)
  • 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)
  • 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</