Changeset 3000 for trunk/GSASIIphsGUI.py


Ignore:
Timestamp:
Aug 11, 2017 5:34:54 PM (5 years ago)
Author:
toby
Message:

make the two frame version the trunk as we hit version 3000

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/GSASIIphsGUI.py

    r2880 r3000  
    3939import GSASIIddataGUI as G2ddG
    4040import GSASIIplot as G2plt
    41 import GSASIIgrid as G2gd
     41import GSASIIdataGUI as G2gd
    4242import GSASIIIO as G2IO
    4343import GSASIIstrMain as G2stMn
     
    4747import GSASIIpy3 as G2py3
    4848import GSASIIobj as G2obj
    49 import GSASIIctrls as G2G
     49import GSASIIctrlGUI as G2G
    5050import GSASIIconstrGUI as G2cnstG
    5151import numpy as np
     
    6767atan2d = lambda x,y: 180.*np.arctan2(y,x)/np.pi
    6868
    69 def SetPhaseWindow(mainFrame,phasePage,mainSizer=None,size=None,Scroll=0):
    70     if not mainSizer is None:
     69################################################################################
     70#### phase class definitions
     71################################################################################
     72class SGMagSpinBox(wx.Dialog):
     73    ''' Special version of MessageBox that displays magnetic spin text
     74    '''
     75    def __init__(self,parent,title,text,table,names,spins,):
     76        wx.Dialog.__init__(self,parent,wx.ID_ANY,title,pos=wx.DefaultPosition,
     77            style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER,size=wx.Size(420,350))
     78        self.text = text
     79        self.table = table
     80        self.names = names
     81        self.spins = spins
     82        self.panel = wxscroll.ScrolledPanel(self)
     83        mainSizer = wx.BoxSizer(wx.VERTICAL)
     84        mainSizer.Add((0,10))
     85        first = text[0].split(':')[-1].strip()
     86        cents = [0,]
     87        if 'P' != first[0]:
     88            cents = text[-1].split(';')
     89        for line in text:
     90            mainSizer.Add(wx.StaticText(self.panel,label='     %s     '%(line)),0,WACV)
     91        ncol = self.table[0].count(',')+2
     92        for ic,cent in enumerate(cents):
     93            if cent:
     94                cent = cent.strip(' (').strip(')+\n')
     95                mainSizer.Add(wx.StaticText(self.panel,label=' for (%s)+'%(cent)),0,WACV)
     96            tableSizer = wx.FlexGridSizer(0,2*ncol+3,0,0)
     97            for j,item in enumerate(self.table):
     98                flds = item.split(')')[1]
     99                tableSizer.Add(wx.StaticText(self.panel,label='  (%2d)  '%(j+1)),0,WACV|wx.ALIGN_LEFT)           
     100                flds = flds.replace(' ','').split(',')
     101                for i,fld in enumerate(flds):
     102                    if i < ncol-1:
     103                        text = wx.StaticText(self.panel,label='%s, '%(fld))
     104                        tableSizer.Add(text,0,WACV|wx.ALIGN_RIGHT)
     105                    else:
     106                        text = wx.StaticText(self.panel,label='%s '%(fld))
     107                        tableSizer.Add(text,0,WACV|wx.ALIGN_RIGHT)
     108                text = wx.StaticText(self.panel,label=' (%s) '%(self.names[j]))
     109                if self.spins[j+ic*len(self.table)] < 0:
     110                    text.SetForegroundColour('Red')
     111                tableSizer.Add(text,0,WACV|wx.ALIGN_RIGHT)
     112                if not j%2:
     113                    tableSizer.Add((20,0))
     114            mainSizer.Add(tableSizer,0,wx.ALIGN_CENTER)
     115           
     116        btnsizer = wx.StdDialogButtonSizer()
     117        OKbtn = wx.Button(self.panel, wx.ID_OK)
     118        OKbtn.SetDefault()
     119        btnsizer.AddButton(OKbtn)
     120        btnsizer.Realize()
     121        mainSizer.Add((0,10))
     122        mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
     123        self.panel.SetSizer(mainSizer)
     124        size = np.array(self.GetSize())
     125        self.panel.SetupScrolling()
     126        size = [size[0]-5,size[1]-20]       #this fiddling is needed for older wx!
     127        self.panel.SetSize(size)
     128        self.panel.SetAutoLayout(1)
     129
     130    def Show(self):
     131        '''Use this method after creating the dialog to post it
     132        '''
     133        self.ShowModal()
     134        return
     135
     136################################################################################
     137class SymOpDialog(wx.Dialog):
     138    '''Class to select a symmetry operator
     139    '''
     140    def __init__(self,parent,SGData,New=True,ForceUnit=False):
     141        wx.Dialog.__init__(self,parent,-1,'Select symmetry operator',
     142            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     143        panel = wx.Panel(self)
     144        self.SGData = SGData
     145        self.New = New
     146        self.Force = ForceUnit
     147        self.OpSelected = [0,0,0,[0,0,0],False,False]
     148        mainSizer = wx.BoxSizer(wx.VERTICAL)
     149        if ForceUnit:
     150            choice = ['No','Yes']
     151            self.force = wx.RadioBox(panel,-1,'Force to unit cell?',choices=choice)
     152            self.force.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     153            mainSizer.Add(self.force,0,WACV|wx.TOP,5)
     154#        if SGData['SGInv']:
     155        choice = ['No','Yes']
     156        self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
     157        self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     158        mainSizer.Add(self.inv,0,WACV)
     159        if SGData['SGLatt'] != 'P':
     160            LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
     161            self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
     162            self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     163            mainSizer.Add(self.latt,0,WACV)
     164        if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
     165            Ncol = 2
     166        else:
     167            Ncol = 3
     168        OpList = []
     169        for Opr in SGData['SGOps']:
     170            OpList.append(G2spc.MT2text(Opr))
     171        self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
     172            majorDimension=Ncol)
     173        self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     174        mainSizer.Add(self.oprs,0,WACV|wx.BOTTOM,5)
     175        mainSizer.Add(wx.StaticText(panel,-1,"   Choose unit cell?"),0,WACV)
     176        cellSizer = wx.BoxSizer(wx.HORIZONTAL)
     177        cellName = ['X','Y','Z']
     178        self.cell = []
     179        for i in range(3):
     180            self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
     181            self.cell[-1].SetRange(-3,3)
     182            self.cell[-1].SetValue(0)
     183            self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
     184            cellSizer.Add(self.cell[-1],0,WACV)
     185        mainSizer.Add(cellSizer,0,WACV|wx.BOTTOM,5)
     186        if self.New:
     187            choice = ['No','Yes']
     188            self.new = wx.RadioBox(panel,-1,'Generate new positions?',choices=choice)
     189            self.new.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     190            mainSizer.Add(self.new,0,WACV)
     191
     192        OkBtn = wx.Button(panel,-1,"Ok")
     193        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     194        cancelBtn = wx.Button(panel,-1,"Cancel")
     195        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     196        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     197        btnSizer.Add((20,20),1)
     198        btnSizer.Add(OkBtn)
     199        btnSizer.Add((20,20),1)
     200        btnSizer.Add(cancelBtn)
     201        btnSizer.Add((20,20),1)
     202
     203        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     204        panel.SetSizer(mainSizer)
     205        panel.Fit()
     206        self.Fit()
     207
     208    def OnOpSelect(self,event):
     209#        if self.SGData['SGInv']:
     210        self.OpSelected[0] = self.inv.GetSelection()
     211        if self.SGData['SGLatt'] != 'P':
     212            self.OpSelected[1] = self.latt.GetSelection()
     213        self.OpSelected[2] = self.oprs.GetSelection()
     214        for i in range(3):
     215            self.OpSelected[3][i] = float(self.cell[i].GetValue())
     216        if self.New:
     217            self.OpSelected[4] = self.new.GetSelection()
     218        if self.Force:
     219            self.OpSelected[5] = self.force.GetSelection()
     220
     221    def GetSelection(self):
     222        return self.OpSelected
     223
     224    def OnOk(self,event):
     225        parent = self.GetParent()
     226        parent.Raise()
     227        self.EndModal(wx.ID_OK)
     228
     229    def OnCancel(self,event):
     230        parent = self.GetParent()
     231        parent.Raise()
     232        self.EndModal(wx.ID_CANCEL)
     233################################################################################
     234class SphereEnclosure(wx.Dialog):
     235    ''' Add atoms within sphere of enclosure to drawing
     236   
     237    :param wx.Frame parent: reference to parent frame (or None)
     238    :param general: general data (includes drawing data)
     239    :param atoms: drawing atoms data
     240    :param indx: list of selected atoms (may be empty)
     241   
     242    '''
     243    def __init__(self,parent,general,drawing,indx):
     244        wx.Dialog.__init__(self,parent,wx.ID_ANY,'Setup phase transformation',
     245            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     246        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
     247        self.General = general
     248        self.Drawing = drawing
     249        self.indx = indx
     250        self.Sphere = [1.0,]
     251        self.centers = []
     252        self.atomTypes = [[item,True] for item in self.General['AtomTypes']]
     253       
     254        self.Draw()
     255       
     256    def Draw(self):
     257       
     258        def OnAtomType(event):
     259            Obj = event.GetEventObject()
     260            id = Ind[Obj.GetId()]
     261            self.atomTypes[id][1] = Obj.GetValue()
     262       
     263        self.panel.Destroy()
     264        self.panel = wx.Panel(self)
     265        mainSizer = wx.BoxSizer(wx.VERTICAL)
     266        mainSizer.Add(wx.StaticText(self.panel,label=' Sphere of enclosure controls:'),0,WACV)
     267        topSizer = wx.BoxSizer(wx.HORIZONTAL)
     268        atoms = []
     269        if len(self.indx):
     270            topSizer.Add(wx.StaticText(self.panel,label=' Sphere centered at atoms: '),0,WACV)
     271            cx,ct,cs = self.Drawing['atomPtrs'][:3]
     272            for id in self.indx:
     273                atom = self.Drawing['Atoms'][id]
     274                self.centers.append(atom[cx:cx+3])
     275                atoms.append('%s(%s)'%(atom[ct-1],atom[cs-1]))
     276            topSizer.Add(wx.ComboBox(self.panel,choices=atoms,value=atoms[0],
     277                style=wx.CB_READONLY|wx.CB_DROPDOWN),0,WACV)
     278        else:
     279            topSizer.Add(wx.StaticText(self.panel,label=' Sphere centered at drawing view point'),0,WACV)
     280            self.centers.append(self.Drawing['viewPoint'][0])
     281        mainSizer.Add(topSizer,0,WACV)
     282        sphereSizer = wx.BoxSizer(wx.HORIZONTAL)
     283        sphereSizer.Add(wx.StaticText(self.panel,label=' Sphere radius: '),0,WACV)
     284        radius = G2G.ValidatedTxtCtrl(self.panel,self.Sphere,0,nDig=(10,3),size=(65,25))
     285        sphereSizer.Add(radius,0,WACV)
     286        mainSizer.Add(sphereSizer,0,WACV)
     287        mainSizer.Add(wx.StaticText(self.panel,label=' Target selected atoms:'),0,WACV)
     288        atSizer = wx.BoxSizer(wx.HORIZONTAL)
     289        Ind = {}
     290        for i,item in enumerate(self.atomTypes):
     291            atm = wx.CheckBox(self.panel,label=item[0])
     292            atm.SetValue(item[1])
     293            atm.Bind(wx.EVT_CHECKBOX, OnAtomType)
     294            Ind[atm.GetId()] = i
     295            atSizer.Add(atm,0,WACV)
     296        mainSizer.Add(atSizer,0,WACV)
     297       
     298        OkBtn = wx.Button(self.panel,-1,"Ok")
     299        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     300        cancelBtn = wx.Button(self.panel,-1,"Cancel")
     301        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     302        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     303        btnSizer.Add((20,20),1)
     304        btnSizer.Add(OkBtn)
     305        btnSizer.Add((20,20),1)
     306        btnSizer.Add(cancelBtn)
     307        btnSizer.Add((20,20),1)
     308       
     309        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     310        self.panel.SetSizer(mainSizer)
     311        self.panel.Fit()
     312        self.Fit()
     313       
     314    def GetSelection(self):
     315        used = []
     316        for atm in self.atomTypes:
     317            if atm[1]:
     318                used.append(str(atm[0]))
     319        return self.centers,self.Sphere[0],used
     320
     321    def OnOk(self,event):
     322        parent = self.GetParent()
     323        parent.Raise()
     324        self.EndModal(wx.ID_OK)
     325
     326    def OnCancel(self,event):
     327        parent = self.GetParent()
     328        parent.Raise()
     329        self.EndModal(wx.ID_CANCEL)
     330
     331################################################################################
     332class TransformDialog(wx.Dialog):
     333    ''' Phase transformation
     334   
     335    :param wx.Frame parent: reference to parent frame (or None)
     336    :param phase: phase data
     337   
     338    #NB: commonNames & commonTrans defined in GSASIIdataGUI = G2gd
     339    '''
     340    def __init__(self,parent,phase):
     341        wx.Dialog.__init__(self,parent,wx.ID_ANY,'Setup phase transformation',
     342            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     343        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
     344        self.Phase = copy.deepcopy(phase)   #will be a new phase!
     345#        self.Super = phase['General']['Super']
     346#        if self.Super:
     347#            self.Trans = np.eye(4)
     348#            self.Vec = np.zeros(4)
     349#        else:
     350        self.Trans = np.eye(3)
     351        self.Vec = np.zeros(3)
     352        self.oldSpGrp = phase['General']['SGData']['SpGrp']
     353        self.oldSGdata = phase['General']['SGData']
     354        self.newSpGrp = self.Phase['General']['SGData']['SpGrp']
     355        self.oldCell = phase['General']['Cell'][1:8]
     356        self.newCell = self.Phase['General']['Cell'][1:8]
     357        self.Common = 'abc'
     358        self.ifMag = False
     359        self.ifConstr = True
     360        self.Draw()
     361
     362    def Draw(self):
     363               
     364        def OnCommon(event):
     365            Obj = event.GetEventObject()
     366            self.Common = Obj.GetValue()
     367            if '*' in self.Common:
     368                A,B = G2lat.cell2AB(self.oldCell[:6])
     369                self.newCell[2:5] = [A[2,2],90.,90.]
     370                a,b = G2lat.cell2AB(self.newCell[:6])
     371                self.Trans = np.inner(a.T,B)    #correct!
     372                self.ifConstr = False
     373                self.newSpGrp = 'P 1'
     374                SGErr,SGData = G2spc.SpcGroup(self.newSpGrp)
     375                self.Phase['General']['SGData'] = SGData
     376            else:
     377                if self.Common == G2gd.commonNames[-1]:      #change setting
     378                    self.Vec = G2spc.spg2origins[self.oldSpGrp]
     379                    self.newSpGrp = self.oldSpGrp
     380                else:
     381                    self.Trans = G2gd.commonTrans[self.Common]
     382                    if 'R' == self.Common[-1]:
     383                        self.newSpGrp += ' r'
     384                        SGErr,SGData = G2spc.SpcGroup(self.newSpGrp)
     385                        self.Phase['General']['SGData'] = SGData
     386                        SGTxt.SetValue(self.newSpGrp)
     387            OnTest(event)
     388       
     389        def OnSpaceGroup(event):
     390            event.Skip()
     391            Flds = SGTxt.GetValue().split()
     392            Flds[0] = Flds[0].upper()
     393            #get rid of extra spaces between fields first
     394            for fld in Flds: fld = fld.strip()
     395            SpcGp = ' '.join(Flds)
     396            if SpcGp == self.newSpGrp: #didn't change it!
     397                return
     398            # try a lookup on the user-supplied name
     399            SpGrpNorm = G2spc.StandardizeSpcName(SpcGp)
     400            if SpGrpNorm:
     401                SGErr,SGData = G2spc.SpcGroup(SpGrpNorm)
     402            else:
     403                SGErr,SGData = G2spc.SpcGroup(SpcGp)
     404            if SGErr:
     405                text = [G2spc.SGErrors(SGErr)+'\nSpace Group set to previous']
     406                SGTxt.SetValue(self.newSpGrp)
     407                msg = 'Space Group Error'
     408                Style = wx.ICON_EXCLAMATION
     409                Text = '\n'.join(text)
     410                wx.MessageBox(Text,caption=msg,style=Style)
     411            else:
     412                text,table = G2spc.SGPrint(SGData)
     413                self.Phase['General']['SGData'] = SGData
     414                self.newSpGrp = SpcGp
     415                SGTxt.SetValue(self.Phase['General']['SGData']['SpGrp'])
     416                msg = 'Space Group Information'
     417                G2G.SGMessageBox(self.panel,msg,text,table).Show()
     418            if self.Phase['General']['Type'] == 'magnetic':
     419                Nops = len(SGData['SGOps'])*len(SGData['SGCen'])
     420                if SGData['SGInv']:
     421                    Nops *= 2
     422                SGData['SpnFlp'] = Nops*[1,]
     423#            if self.Phase['General']['Type'] in ['modulated',]:
     424#                self.Phase['General']['SuperSg'] = SetDefaultSSsymbol()
     425#                self.Phase['General']['SSGData'] = G2spc.SSpcGroup(generalData['SGData'],generalData['SuperSg'])[1]
     426
     427        def OnTest(event):
     428            self.newCell = G2lat.TransformCell(self.oldCell[:6],self.Trans)
     429            wx.CallAfter(self.Draw)
     430           
     431        def OnMag(event):
     432            self.ifMag = mag.GetValue()
     433           
     434        def OnConstr(event):
     435            self.ifConstr = constr.GetValue()
     436
     437        self.panel.Destroy()
     438        self.panel = wx.Panel(self)
     439        mainSizer = wx.BoxSizer(wx.VERTICAL)
     440        MatSizer = wx.BoxSizer(wx.HORIZONTAL)
     441        transSizer = wx.BoxSizer(wx.VERTICAL)
     442        transSizer.Add(wx.StaticText(self.panel,label=" XYZ Transformation matrix & vector: M*X+V = X'"))
     443#        if self.Super:
     444#            Trmat = wx.FlexGridSizer(4,4,0,0)
     445#        else:
     446        commonSizer = wx.BoxSizer(wx.HORIZONTAL)
     447        commonSizer.Add(wx.StaticText(self.panel,label=' Common transformations: '),0,WACV)
     448        if self.oldSpGrp not in G2spc.spg2origins:
     449            common = wx.ComboBox(self.panel,value=self.Common,choices=G2gd.commonNames[:-1],
     450                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     451        else:
     452            common = wx.ComboBox(self.panel,value=self.Common,choices=G2gd.commonNames,
     453                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     454        common.Bind(wx.EVT_COMBOBOX,OnCommon)
     455        commonSizer.Add(common,0,WACV)
     456        transSizer.Add(commonSizer)
     457        Trmat = wx.FlexGridSizer(3,5,0,0)
     458        for iy,line in enumerate(self.Trans):
     459            for ix,val in enumerate(line):
     460                item = G2G.ValidatedTxtCtrl(self.panel,self.Trans[iy],ix,nDig=(10,3),size=(65,25))
     461                Trmat.Add(item)
     462            Trmat.Add((25,0),0)
     463            vec = G2G.ValidatedTxtCtrl(self.panel,self.Vec,iy,nDig=(10,3),size=(65,25))
     464            Trmat.Add(vec)
     465        transSizer.Add(Trmat)
     466        MatSizer.Add((10,0),0)
     467        MatSizer.Add(transSizer)
     468        mainSizer.Add(MatSizer)
     469        mainSizer.Add(wx.StaticText(self.panel,label=' Old lattice parameters:'),0,WACV)
     470        mainSizer.Add(wx.StaticText(self.panel,label=
     471            ' a = %.5f       b = %.5f      c = %.5f'%(self.oldCell[0],self.oldCell[1],self.oldCell[2])),0,WACV)
     472        mainSizer.Add(wx.StaticText(self.panel,label=' alpha = %.3f beta = %.3f gamma = %.3f'%
     473            (self.oldCell[3],self.oldCell[4],self.oldCell[5])),0,WACV)
     474        mainSizer.Add(wx.StaticText(self.panel,label=' volume = %.3f'%(self.oldCell[6])),0,WACV)
     475        mainSizer.Add(wx.StaticText(self.panel,label=' New lattice parameters:'),0,WACV)
     476        mainSizer.Add(wx.StaticText(self.panel,label=
     477            ' a = %.5f       b = %.5f      c = %.5f'%(self.newCell[0],self.newCell[1],self.newCell[2])),0,WACV)
     478        mainSizer.Add(wx.StaticText(self.panel,label=' alpha = %.3f beta = %.3f gamma = %.3f'%
     479            (self.newCell[3],self.newCell[4],self.newCell[5])),0,WACV)
     480        mainSizer.Add(wx.StaticText(self.panel,label=' volume = %.3f'%(self.newCell[6])),0,WACV)
     481        sgSizer = wx.BoxSizer(wx.HORIZONTAL)
     482        sgSizer.Add(wx.StaticText(self.panel,label='  Space group: '),0,WACV)
     483        SGTxt = wx.TextCtrl(self.panel,value=self.newSpGrp,style=wx.TE_PROCESS_ENTER)
     484        SGTxt.Bind(wx.EVT_TEXT_ENTER,OnSpaceGroup)
     485        SGTxt.Bind(wx.EVT_KILL_FOCUS,OnSpaceGroup)
     486        sgSizer.Add(SGTxt,0,WACV)
     487        mainSizer.Add(sgSizer,0,WACV)
     488        if 'magnetic' not in self.Phase['General']['Type']:
     489            mag = wx.CheckBox(self.panel,label=' Make new phase magnetic?')
     490            mag.Bind(wx.EVT_CHECKBOX,OnMag)
     491            mainSizer.Add(mag,0,WACV)
     492            mainSizer.Add(wx.StaticText(self.panel, \
     493                label=' NB: Nonmagnetic atoms will be deleted from new phase'),0,WACV)
     494            constr = wx.CheckBox(self.panel,label=' Make constraints between phases?')
     495            mainSizer.Add(wx.StaticText(self.panel, \
     496                label=' Constraints not correct for non-diagonal transforms'),0,WACV)
     497            constr.SetValue(self.ifConstr)
     498            constr.Bind(wx.EVT_CHECKBOX,OnConstr)
     499            mainSizer.Add(constr,0,WACV)
     500
     501        TestBtn = wx.Button(self.panel,-1,"Test")
     502        TestBtn.Bind(wx.EVT_BUTTON, OnTest)
     503        OkBtn = wx.Button(self.panel,-1,"Ok")
     504        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     505        cancelBtn = wx.Button(self.panel,-1,"Cancel")
     506        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     507        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     508        btnSizer.Add((20,20),1)
     509        btnSizer.Add(TestBtn)
     510        btnSizer.Add((20,20),1)
     511        btnSizer.Add(OkBtn)
     512        btnSizer.Add((20,20),1)
     513        btnSizer.Add(cancelBtn)
     514        btnSizer.Add((20,20),1)
     515       
     516        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     517        self.panel.SetSizer(mainSizer)
     518        self.panel.Fit()
     519        self.Fit()
     520       
     521    def GetSelection(self):
     522        if self.ifMag:
     523            self.Phase['General']['Name'] += ' mag'
     524        else:
     525            self.Phase['General']['Name'] += ' %s'%(self.Common)
     526        self.Phase['General']['Cell'][1:] = G2lat.TransformCell(self.oldCell[:6],self.Trans)           
     527        return self.Phase,self.Trans,self.Vec,self.ifMag,self.ifConstr,self.Common
     528
     529    def OnOk(self,event):
     530        parent = self.GetParent()
     531        parent.Raise()
     532        self.EndModal(wx.ID_OK)
     533
     534    def OnCancel(self,event):
     535        parent = self.GetParent()
     536        parent.Raise()
     537        self.EndModal(wx.ID_CANCEL)
     538       
     539################################################################################
     540class UseMagAtomDialog(wx.Dialog):
     541    '''Get user selected magnetic atoms after cell transformation
     542    '''
     543    def __init__(self,parent,Atoms,atCodes):
     544        wx.Dialog.__init__(self,parent,wx.ID_ANY,'Magnetic atom selection',
     545            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     546        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
     547        self.Atoms = Atoms
     548        self.atCodes = atCodes
     549        self.Use = len(self.Atoms)*[True,]
     550        self.Draw()
     551       
     552    def Draw(self):
     553       
     554        def OnUseChk(event):
     555            Obj = event.GetEventObject()
     556            iuse = Indx[Obj.GetId()]
     557            self.Use[iuse] = not self.Use[iuse]
     558            Obj.SetValue(self.Use[iuse])
     559       
     560        self.panel.Destroy()
     561        self.panel = wx.Panel(self)
     562        Indx = {}
     563        mainSizer = wx.BoxSizer(wx.VERTICAL)
     564       
     565        mainSizer.Add(wx.StaticText(self.panel,label=' Name, x, y, z:'),0,WACV)
     566        atmSizer = wx.FlexGridSizer(0,2,5,5)
     567        for iuse,[use,atom] in enumerate(zip(self.Use,self.Atoms)):
     568            useChk = wx.CheckBox(self.panel,label='Use?')
     569            Indx[useChk.GetId()] = iuse
     570            useChk.SetValue(use)
     571            useChk.Bind(wx.EVT_CHECKBOX, OnUseChk)
     572            atmSizer.Add(useChk,0,WACV)
     573            text = ' %s %10.5f %10.5f %10.5f'%(atom[0],atom[3],atom[4],atom[5])
     574            atmSizer.Add(wx.StaticText(self.panel,label=text),0,WACV)
     575        mainSizer.Add(atmSizer)
     576       
     577        OkBtn = wx.Button(self.panel,-1,"Ok")
     578        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     579        cancelBtn = wx.Button(self.panel,-1,"Use All")
     580        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     581        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     582        btnSizer.Add((20,20),1)
     583        btnSizer.Add(OkBtn)
     584        btnSizer.Add((20,20),1)
     585        btnSizer.Add(cancelBtn)
     586        btnSizer.Add((20,20),1)
     587       
     588        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     589        self.panel.SetSizer(mainSizer)
     590        self.panel.Fit()
     591        self.Fit()
     592       
     593    def GetSelection(self):
     594        useAtoms = []
     595        useatCodes = []
     596        for use,atom,code in zip(self.Use,self.Atoms,self.atCodes):
     597            if use:
     598                useAtoms.append(atom)
     599                useatCodes.append(code)
     600        return useAtoms,useatCodes
     601
     602    def OnOk(self,event):
     603        parent = self.GetParent()
     604        parent.Raise()
     605        self.EndModal(wx.ID_OK)
     606
     607    def OnCancel(self,event):
     608        parent = self.GetParent()
     609        parent.Raise()
     610        self.EndModal(wx.ID_CANCEL)
     611           
     612               
     613################################################################################
     614class RotationDialog(wx.Dialog):
     615    ''' Get Rotate & translate matrix & vector - currently not used
     616    needs rethinking - possible use to rotate a group of atoms about some
     617    vector/origin + translation
     618   
     619    '''
     620    def __init__(self,parent):
     621        wx.Dialog.__init__(self,parent,wx.ID_ANY,'Atom group rotation/translation',
     622            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     623        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
     624        self.Trans = np.eye(3)
     625        self.Vec = np.zeros(3)
     626        self.rotAngle = 0.
     627        self.rotVec = np.array([0.,0.,1.])
     628        self.Expand = ''
     629        self.Draw()
     630
     631    def Draw(self):
     632
     633        def OnExpand(event):
     634            self.Expand = expand.GetValue()
     635           
     636        def OnRotAngle(event):
     637            event.Skip()
     638            self.rotAngle = float(rotangle.GetValue())
     639            rotangle.SetValue('%5.3f'%(self.rotAngle))
     640            Q = G2mth.AVdeg2Q(self.rotAngle,self.rotVec)
     641            self.Trans = G2mth.Q2Mat(Q)
     642            self.Draw()
     643           
     644        def OnRotVec(event):
     645            event.Skip()
     646            vals = rotvec.GetValue()
     647            vals = vals.split()
     648            self.rotVec = np.array([float(val) for val in vals])
     649            rotvec.SetValue('%5.3f %5.3f %5.3f'%(self.rotVec[0],self.rotVec[1],self.rotVec[2]))
     650            Q = G2mth.AVdeg2Q(self.rotAngle,self.rotVec)
     651            self.Trans = G2mth.Q2Mat(Q)
     652            self.Draw()
     653           
     654        self.panel.Destroy()
     655        self.panel = wx.Panel(self)
     656        mainSizer = wx.BoxSizer(wx.VERTICAL)
     657        MatSizer = wx.BoxSizer(wx.HORIZONTAL)
     658        transSizer = wx.BoxSizer(wx.VERTICAL)
     659        transSizer.Add(wx.StaticText(self.panel,label=" XYZ Transformation matrix && vector: "+ \
     660            "\n B*M*A*(X-V)+V = X'\n A,B: Cartesian transformation matrices"))
     661        Trmat = wx.FlexGridSizer(3,5,0,0)
     662        for iy,line in enumerate(self.Trans):
     663            for ix,val in enumerate(line):
     664                item = G2G.ValidatedTxtCtrl(self.panel,self.Trans[iy],ix,nDig=(10,3),size=(65,25))
     665                Trmat.Add(item)
     666            Trmat.Add((25,0),0)
     667            vec = G2G.ValidatedTxtCtrl(self.panel,self.Vec,iy,nDig=(10,3),size=(65,25))
     668            Trmat.Add(vec)
     669        transSizer.Add(Trmat)
     670        MatSizer.Add((10,0),0)
     671        MatSizer.Add(transSizer)
     672        mainSizer.Add(MatSizer)
     673        rotationBox = wx.BoxSizer(wx.HORIZONTAL)
     674        rotationBox.Add(wx.StaticText(self.panel,label=' Rotation angle: '),0,WACV)
     675        rotangle = wx.TextCtrl(self.panel,value='%5.3f'%(self.rotAngle),
     676            size=(50,25),style=wx.TE_PROCESS_ENTER)
     677        rotangle.Bind(wx.EVT_TEXT_ENTER,OnRotAngle)
     678        rotangle.Bind(wx.EVT_KILL_FOCUS,OnRotAngle)
     679        rotationBox.Add(rotangle,0,WACV)
     680        rotationBox.Add(wx.StaticText(self.panel,label=' about vector: '),0,WACV)
     681        rotvec = wx.TextCtrl(self.panel,value='%5.3f %5.3f %5.3f'%(self.rotVec[0],self.rotVec[1],self.rotVec[2]),
     682            size=(100,25),style=wx.TE_PROCESS_ENTER)
     683        rotvec.Bind(wx.EVT_TEXT_ENTER,OnRotVec)
     684        rotvec.Bind(wx.EVT_KILL_FOCUS,OnRotVec)
     685        rotationBox.Add(rotvec,0,WACV)
     686        mainSizer.Add(rotationBox,0,WACV)
     687        expandChoice = ['','xy','xz','yz','xyz']
     688        expandBox = wx.BoxSizer(wx.HORIZONTAL)
     689        expandBox.Add(wx.StaticText(self.panel,label=' Expand -1 to +1 on: '),0,WACV)
     690        expand = wx.ComboBox(self.panel,value=self.Expand,choices=expandChoice,
     691            style=wx.CB_READONLY|wx.CB_DROPDOWN)
     692        expand.Bind(wx.EVT_COMBOBOX,OnExpand)
     693        expandBox.Add(expand,0,WACV)
     694        expandBox.Add(wx.StaticText(self.panel,label=' and find unique atoms '),0,WACV)       
     695        mainSizer.Add(expandBox)
     696               
     697        OkBtn = wx.Button(self.panel,-1,"Ok")
     698        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     699        cancelBtn = wx.Button(self.panel,-1,"Cancel")
     700        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     701        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     702        btnSizer.Add((20,20),1)
     703        btnSizer.Add(OkBtn)
     704        btnSizer.Add((20,20),1)
     705        btnSizer.Add(cancelBtn)
     706        btnSizer.Add((20,20),1)
     707       
     708        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     709        self.panel.SetSizer(mainSizer)
     710        self.panel.Fit()
     711        self.Fit()
     712
     713    def GetSelection(self):
     714        return self.Trans,self.Vec,self.Expand
     715
     716    def OnOk(self,event):
     717        parent = self.GetParent()
     718        parent.Raise()
     719        self.EndModal(wx.ID_OK)
     720
     721    def OnCancel(self,event):
     722        parent = self.GetParent()
     723        parent.Raise()
     724        self.EndModal(wx.ID_CANCEL)   
     725       
     726################################################################################
     727class DIFFaXcontrols(wx.Dialog):
     728    ''' Solicit items needed to prepare DIFFaX control.dif file
     729    '''
     730    def __init__(self,parent,ctrls,parms=None):
     731        wx.Dialog.__init__(self,parent,wx.ID_ANY,'DIFFaX controls',
     732            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     733        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
     734        self.ctrls = ctrls
     735        self.calcType = 'powder pattern'
     736        self.plane = 'h0l'
     737        self.planeChoice = ['h0l','0kl','hhl','h-hl',]
     738        self.lmax = '2'
     739        self.lmaxChoice = [str(i+1) for i in range(6)]
     740        self.Parms = parms
     741        self.Parm = None
     742        if self.Parms != None:
     743            self.Parm = self.Parms[0]
     744        self.parmRange = [0.,1.]
     745        self.parmStep = 2
     746        self.Inst = 'Gaussian'
     747        self.Draw()
     748       
     749    def Draw(self):
     750       
     751        def OnCalcType(event):
     752            self.calcType = calcType.GetValue()
     753            wx.CallAfter(self.Draw)
     754           
     755        def OnPlane(event):
     756            self.plane = plane.GetValue()
     757           
     758        def OnMaxL(event):
     759            self.lmax = lmax.GetValue()
     760           
     761        def OnParmSel(event):
     762            self.Parm = parmsel.GetValue()
     763           
     764        def OnNumStep(event):
     765            self.parmStep = int(numStep.GetValue())
     766           
     767        def OnParmRange(event):
     768            event.Skip()
     769            vals = parmrange.GetValue().split()
     770            try:
     771                vals = [float(vals[0]),float(vals[1])]
     772            except ValueError:
     773                vals = self.parmRange
     774            parmrange.SetValue('%.3f %.3f'%(vals[0],vals[1]))
     775            self.parmRange = vals
     776           
     777        def OnInstSel(event):
     778            self.Inst = instsel.GetValue()
     779       
     780        self.panel.Destroy()
     781        self.panel = wx.Panel(self)
     782        mainSizer = wx.BoxSizer(wx.VERTICAL)
     783        mainSizer.Add(wx.StaticText(self.panel,label=' Controls for DIFFaX'),0,WACV)
     784        if self.Parms:
     785            mainSizer.Add(wx.StaticText(self.panel,label=' Sequential powder pattern simulation'),0,WACV)
     786        else:
     787            calcChoice = ['powder pattern','selected area']
     788            calcSizer = wx.BoxSizer(wx.HORIZONTAL)
     789            calcSizer.Add(wx.StaticText(self.panel,label=' Select calculation type: '),0,WACV)
     790            calcType = wx.ComboBox(self.panel,value=self.calcType,choices=calcChoice,
     791                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     792            calcType.Bind(wx.EVT_COMBOBOX,OnCalcType)
     793            calcSizer.Add(calcType,0,WACV)
     794            mainSizer.Add(calcSizer)
     795        if self.Parms:
     796            parmSel = wx.BoxSizer(wx.HORIZONTAL)
     797            parmSel.Add(wx.StaticText(self.panel,label=' Select parameter to vary: '),0,WACV)
     798            parmsel = wx.ComboBox(self.panel,value=self.Parm,choices=self.Parms,
     799                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     800            parmsel.Bind(wx.EVT_COMBOBOX,OnParmSel)
     801            parmSel.Add(parmsel,0,WACV)
     802            mainSizer.Add(parmSel)
     803            mainSizer.Add(wx.StaticText(self.panel,label=' Enter parameter range & no. steps: '),0,WACV)
     804            parmRange =  wx.BoxSizer(wx.HORIZONTAL)
     805            numChoice = [str(i+1) for i in range(10)]
     806            parmrange = wx.TextCtrl(self.panel,value='%.3f %.3f'%(self.parmRange[0],self.parmRange[1]),
     807                style=wx.TE_PROCESS_ENTER)
     808            parmrange.Bind(wx.EVT_TEXT_ENTER,OnParmRange)
     809            parmrange.Bind(wx.EVT_KILL_FOCUS,OnParmRange)
     810            parmRange.Add(parmrange,0,WACV)
     811            numStep = wx.ComboBox(self.panel,value=str(self.parmStep),choices=numChoice,
     812                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     813            numStep.Bind(wx.EVT_COMBOBOX,OnNumStep)
     814            parmRange.Add(numStep,0,WACV)
     815            mainSizer.Add(parmRange)           
     816        if 'selected' in self.calcType:
     817            planeSizer = wx.BoxSizer(wx.HORIZONTAL)
     818            planeSizer.Add(wx.StaticText(self.panel,label=' Select plane: '),0,WACV)
     819            plane = wx.ComboBox(self.panel,value=self.plane,choices=self.planeChoice,
     820                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     821            plane.Bind(wx.EVT_COMBOBOX,OnPlane)
     822            planeSizer.Add(plane,0,WACV)
     823            planeSizer.Add(wx.StaticText(self.panel,label=' Max. l index: '),0,WACV)
     824            lmax = wx.ComboBox(self.panel,value=self.lmax,choices=self.lmaxChoice,
     825                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     826            lmax.Bind(wx.EVT_COMBOBOX,OnMaxL)
     827            planeSizer.Add(lmax,0,WACV)           
     828            mainSizer.Add(planeSizer)
     829        else:
     830            instChoice = ['None','Mean Gaussian','Gaussian',]
     831            instSizer = wx.BoxSizer(wx.HORIZONTAL)
     832            instSizer.Add(wx.StaticText(self.panel,label=' Select instrument broadening: '),0,WACV)
     833            instsel = wx.ComboBox(self.panel,value=self.Inst,choices=instChoice,
     834                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     835            instsel.Bind(wx.EVT_COMBOBOX,OnInstSel)
     836            instSizer.Add(instsel,0,WACV)
     837            mainSizer.Add(instSizer)
     838        OkBtn = wx.Button(self.panel,-1,"Ok")
     839        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     840        cancelBtn = wx.Button(self.panel,-1,"Cancel")
     841        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     842        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     843        btnSizer.Add((20,20),1)
     844        btnSizer.Add(OkBtn)
     845        btnSizer.Add((20,20),1)
     846        btnSizer.Add(cancelBtn)
     847        btnSizer.Add((20,20),1)
     848       
     849        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     850        self.panel.SetSizer(mainSizer)
     851        self.panel.Fit()
     852        self.Fit()
     853       
     854    def GetSelection(self):
     855        if 'powder' in self.calcType:
     856            return 'PWDR',self.Inst,self.Parm,self.parmRange,self.parmStep
     857        elif 'selected' in self.calcType:
     858            return 'SADP',self.plane,self.lmax
     859
     860    def OnOk(self,event):
     861        parent = self.GetParent()
     862        parent.Raise()
     863        self.EndModal(wx.ID_OK)
     864
     865    def OnCancel(self,event):
     866        parent = self.GetParent()
     867        parent.Raise()
     868        self.EndModal(wx.ID_CANCEL)
     869
     870################################################################################
     871class AddHatomDialog(wx.Dialog):
     872    '''H atom addition dialog. After :meth:`ShowModal` returns, the results
     873    are found in dict :attr:`self.data`, which is accessed using :meth:`GetData`.
     874   
     875    :param wx.Frame parent: reference to parent frame (or None)
     876    :param dict Neigh: a dict of atom names with list of atom name, dist pairs for neighboring atoms
     877    :param dict phase: a dict containing the phase as defined by
     878      :ref:`Phase Tree Item <Phase_table>`   
     879    '''
     880    def __init__(self,parent,Neigh,phase):
     881        wx.Dialog.__init__(self,parent,wx.ID_ANY,'H atom add',
     882            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     883        self.panel = wxscroll.ScrolledPanel(self)         #just a dummy - gets destroyed in Draw!
     884        self.Neigh = Neigh
     885        self.phase = phase
     886        self.Hatoms = []
     887        self.Draw(self.Neigh,self.phase)
     888           
     889    def Draw(self,Neigh,phase):
     890        '''Creates the contents of the dialog. Normally called
     891        by :meth:`__init__`.
     892        '''
     893        def OnHSelect(event):
     894            Obj = event.GetEventObject()
     895            item,i = Indx[Obj.GetId()]
     896            for obj in Indx[item]:
     897                obj.SetValue(False)
     898            Obj.SetValue(True)
     899            self.Neigh[item][2] = i
     900           
     901        def OnBond(event):
     902            Obj = event.GetEventObject()
     903            inei,ibond = Indx[Obj.GetId()]
     904            self.Neigh[inei][1][0][ibond][2] = Obj.GetValue()
     905           
     906        self.panel.Destroy()
     907        self.panel = wxscroll.ScrolledPanel(self,style = wx.DEFAULT_DIALOG_STYLE)
     908        mainSizer = wx.BoxSizer(wx.VERTICAL)
     909        mainSizer.Add(wx.StaticText(self.panel,-1,'H atom add controls for phase %s:'%(phase['General']['Name'])),
     910            0,wx.LEFT|wx.TOP,10)
     911        mainSizer.Add(wx.StaticText(self.panel,-1,'NB: Check selections as they may not be correct'),0,WACV|wx.LEFT,10)
     912        mainSizer.Add(wx.StaticText(self.panel,-1," Atom:  Add # H's          Use: Neighbors, dist"),0,wx.TOP|wx.LEFT,5)
     913        nHatms = ['0','1','2','3']
     914        dataSizer = wx.FlexGridSizer(0,3,0,0)
     915        Indx = {}
     916        for inei,neigh in enumerate(Neigh):
     917            dataSizer.Add(wx.StaticText(self.panel,-1,' %s:  '%(neigh[0])),0,WACV)
     918            nH = 1      #for O atom
     919            if 'C' in neigh[0] or 'N' in neigh[0]:
     920                nH = 4-len(neigh[1][0])
     921            checks = wx.BoxSizer(wx.HORIZONTAL)
     922            Ids = []
     923            for i in range(nH+1):
     924                nHs = wx.CheckBox(self.panel,-1,label=nHatms[i])
     925                if i == neigh[2]:
     926                    nHs.SetValue(True)
     927                Indx[nHs.GetId()] = [inei,i]
     928                Ids.append(nHs)
     929                nHs.Bind(wx.EVT_CHECKBOX, OnHSelect)
     930                checks.Add(nHs,0,WACV)
     931            Indx[inei] = Ids
     932            dataSizer.Add(checks,0,WACV)
     933            lineSizer = wx.BoxSizer(wx.HORIZONTAL)
     934            for ib,bond in enumerate(neigh[1][0]):
     935                Bond = wx.CheckBox(self.panel,-1,label=': %s, %.3f'%(bond[0],bond[1]))
     936                Bond.SetValue(bond[2])
     937                Indx[Bond.GetId()] = [inei,ib]
     938                Bond.Bind(wx.EVT_CHECKBOX,OnBond)               
     939                lineSizer.Add(Bond,0,WACV)               
     940            dataSizer.Add(lineSizer,0,WACV|wx.RIGHT,10)
     941        mainSizer.Add(dataSizer,0,wx.LEFT,5)
     942
     943        CancelBtn = wx.Button(self.panel,-1,'Cancel')
     944        CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     945        OkBtn = wx.Button(self.panel,-1,'Ok')
     946        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     947        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     948        btnSizer.Add((20,20),1)
     949        btnSizer.Add(OkBtn)
     950        btnSizer.Add((20,20),1)
     951        btnSizer.Add(CancelBtn)
     952        btnSizer.Add((20,20),1)
     953        mainSizer.Add(btnSizer,0,wx.BOTTOM|wx.TOP, 10)
     954        self.panel.SetSizer(mainSizer)
     955        size = np.array(self.GetSize())
     956        self.panel.SetupScrolling()
     957        self.panel.SetAutoLayout(1)
     958        size = [size[0]-5,size[1]-20]       #this fiddling is needed for older wx!
     959        self.panel.SetSize(size)
     960       
     961    def GetData(self):
     962        'Returns the values from the dialog'
     963        for neigh in self.Neigh:
     964            for ibond,bond in enumerate(neigh[1][0]):
     965                if not bond[2]:
     966                    neigh[1][1][1][ibond] = 0   #deselected bond
     967            neigh[1][1][1] = [a for a in  neigh[1][1][1] if a]
     968        return self.Neigh       #has #Hs to add for each entry
     969       
     970    def OnOk(self,event):
     971        'Called when the OK button is pressed'
     972        parent = self.GetParent()
     973        parent.Raise()
     974        self.EndModal(wx.ID_OK)             
     975
     976    def OnCancel(self,event):
     977        parent = self.GetParent()
     978        parent.Raise()
     979        self.EndModal(wx.ID_CANCEL)
     980
     981################################################################################
     982################################################################################
     983################################################################################
     984   
     985   
     986def SetPhaseWindow(phasePage,mainSizer=None,Scroll=0):
     987    if mainSizer is not None:
    71988        phasePage.SetSizer(mainSizer)
    72         Size = mainSizer.GetMinSize()
    73     else:
    74         Size = phasePage.GetBestSize()
    75     Size[0] += 40
    76     phasePage.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
     989    phasePage.SetAutoLayout(True)
     990    phasePage.SetScrollRate(1,1)
     991    phasePage.SendSizeEvent()
    77992    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)
     993
    85994   
    86995def FindBondsDraw(data):   
     
    1551064    '''Create the data display window contents when a phase is clicked on
    1561065    in the main (data tree) window.
    157     Called only from :meth:`GSASIIgrid.SelectDataTreeItem`,
    158     which in turn is called from :meth:`GSASII.GSASII.OnDataTreeSelChanged`
     1066    Called only from :meth:`GSASIIdataGUI.SelectDataTreeItem`,
     1067    which in turn is called from :meth:`GSASIIdataGUI.GSASII.OnDataTreeSelChanged`
    1591068    when a Phase tree item is selected. This creates all tabs on the page and fills
    1601069    their contents. Routine OnPageChanged is called each time a tab is pressed
     
    1771086        for reflName in reflNames:
    1781087            if 'PWDR' in reflName:
    179                 PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
    180                 reflSets = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
     1088                PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
     1089                reflSets = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Reflection Lists'))
    1811090                reflData = reflSets[phaseName]
    1821091            elif 'HKLF' in reflName:
    183                 PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
    184                 reflData = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     1092                PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
     1093                reflData = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    1851094                if 'Type' not in reflData:
    1861095                    reflData['Type'] = 'SXC'
     
    2201129        if 'Algolrithm' in generalData.get('MCSA controls',{}) or \
    2211130            'MCSA controls' not in generalData:
    222             generalData['MCSA controls'] = {'Data source':'','Annealing':[50.,0.001,50],
    223             'dmin':2.0,'Algorithm':'log','Jump coeff':[0.95,0.5],'boltzmann':1.0,
    224             'fast parms':[1.0,1.0,1.0],'log slope':0.9,'Cycles':1,'Results':[],'newDmin':True}
     1131            generalData['MCSA controls'] = {'Data source':'','Annealing':[0.7,0.1,250],
     1132            'dmin':2.8,'Algorithm':'log','fast parms':[0.8,0.6],'log slope':0.9,
     1133            'Cycles':1,'Results':[],'newDmin':True}
    2251134        if 'AtomPtrs' not in generalData:
    2261135            generalData['AtomPtrs'] = [3,1,7,9]
     
    3341243        """       
    3351244        # UpdateGeneral execution starts here
    336         #General.DestroyChildren() # bad, deletes scrollbars on Mac!
    337         if General.GetSizer():
    338             General.GetSizer().Clear(True)
     1245        if General.GetSizer(): General.GetSizer().Clear(True)
    3391246        phaseTypes = ['nuclear','magnetic','macromolecular','faulted']
    3401247        SetupGeneral()
     
    3711278                    generalData['Name'] = newName
    3721279                    G2frame.G2plotNB.Rename(oldName,generalData['Name'])
    373                     G2frame.dataFrame.SetLabel('Phase Data for '+generalData['Name'])
    374                     G2frame.PatternTree.SetItemText(Item,generalData['Name'])
     1280                    #G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+generalData['Name'])
     1281                    G2frame.SetTitle('Phase Data for '+generalData['Name'])                   
     1282                    G2frame.GPXtree.SetItemText(Item,generalData['Name'])
    3751283                    # change phase name key in Reflection Lists for each histogram
    3761284                    for hist in data['Histograms']:
    377                         ht = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    378                         rt = G2gd.GetPatternTreeItemId(G2frame,ht,'Reflection Lists')
     1285                        ht = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     1286                        rt = G2gd.GetGPXtreeItemId(G2frame,ht,'Reflection Lists')
    3791287                        if not rt: continue
    380                         RfList = G2frame.PatternTree.GetItemPyData(rt)
     1288                        RfList = G2frame.GPXtree.GetItemPyData(rt)
    3811289                        if oldName not in RfList:
    3821290                            print('Warning: '+oldName+' not in Reflection List for '+
     
    3901298                if not len(generalData['AtomTypes']):             #can change only if no atoms!
    3911299                    generalData['Type'] = TypeTxt.GetValue()
    392                     pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
     1300                    pages = [G2frame.phaseDisplay.GetPageText(PageNum) for PageNum in range(G2frame.phaseDisplay.GetPageCount())]
    3931301                    if generalData['Type'] == 'faulted':
    394                         G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
    395                         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSimulate, id=G2gd.wxID_LAYERSIMULATE)
    396                         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2gd.wxID_SEQUENCESIMULATE)
    397                         G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitLayers, id=G2gd.wxID_LAYERSFIT)                       
     1302                        G2frame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2G.wxID_LOADDIFFAX)
     1303                        G2frame.Bind(wx.EVT_MENU, OnSimulate, id=G2G.wxID_LAYERSIMULATE)
     1304                        G2frame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2G.wxID_SEQUENCESIMULATE)
     1305                        G2frame.Bind(wx.EVT_MENU, OnFitLayers, id=G2G.wxID_LAYERSFIT)                       
    3981306                        if 'Wave Data' in pages:
    3991307                            pass
    400 #                            G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     1308#                            G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
    4011309                        if 'MC/SA' in pages:
    4021310                            pass
    403 #                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))
     1311#                            G2frame.phaseDisplay.DeletePage(pages.index('MC/SA'))
    4041312                        if 'RB Models' in pages:
    4051313                            pass
    406 #                            G2frame.dataDisplay.DeletePage(pages.index('RB Models'))
     1314#                            G2frame.phaseDisplay.DeletePage(pages.index('RB Models'))
    4071315                        if 'Layers' not in pages:
    4081316                            if 'Layers' not in data:
     
    4101318                                    'Width':[[1.,1.],[False,False]],'Toler':0.01,'AtInfo':{},
    4111319                                    'Layers':[],'Stacking':[],'Transitions':[]}
    412                             G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
    413                             G2frame.dataDisplay.InsertPage(3,G2frame.layerData,'Layers')
     1320                            G2frame.layerData = wx.ScrolledWindow(G2frame.phaseDisplay)
     1321                            G2frame.phaseDisplay.InsertPage(3,G2frame.layerData,'Layers')
    4141322                            Id = wx.NewId()
    4151323                            TabSelectionIdDict[Id] = 'Layers'
     
    4231331                    else:
    4241332                        if 'Wave Data' in pages:
    425                             G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     1333                            G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
    4261334                        if 'MC/SA' not in pages:
    427                             G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
    428                             G2frame.dataDisplay.InsertPage(7,G2frame.MCSA,'MC/SA')
     1335                            G2frame.MCSA = wx.ScrolledWindow(G2frame.phaseDisplay)
     1336                            G2frame.phaseDisplay.InsertPage(7,G2frame.MCSA,'MC/SA')
    4291337                            Id = wx.NewId()
    4301338                            TabSelectionIdDict[Id] = 'MC/SA'
     
    5281436            def OnModulated(event):
    5291437                if not len(generalData['AtomTypes']):             #can change only if no atoms!
    530                     pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
     1438                    pages = [G2frame.phaseDisplay.GetPageText(PageNum) for PageNum in range(G2frame.phaseDisplay.GetPageCount())]
    5311439                    if generalData['Type'] in ['nuclear','magnetic']:
    5321440                        generalData['Modulated'] = modulated.GetValue()
     
    5441452                            if 'MC/SA' in pages:
    5451453                                pass
    546     #                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
     1454    #                            G2frame.phaseDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
    5471455                            if 'Layers' in pages:
    5481456                                pass
    549     #                            G2frame.dataDisplay.DeletePage(pages.index('Layers'))
     1457    #                            G2frame.phaseDisplay.DeletePage(pages.index('Layers'))
    5501458                            if 'Wave Data' not in pages:
    551                                 G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
    552                                 G2frame.dataDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
     1459                                G2frame.waveData = wx.ScrolledWindow(G2frame.phaseDisplay)
     1460                                G2frame.phaseDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
    5531461                                Id = wx.NewId()
    5541462                                TabSelectionIdDict[Id] = 'Wave Data'
    5551463                        else:
    5561464                            if 'Wave Data' in pages:
    557                                 G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     1465                                G2frame.phaseDisplay.DeletePage(pages.index('Wave Data'))
    5581466                        wx.CallAfter(UpdateGeneral)
    5591467                else:
     
    7001608                cellSizer.Add(wx.StaticText(General,label=txt),0,WACV)
    7011609                if ifEdit:          #a,b,c,etc.
    702 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    7031610                    cellVal = wx.TextCtrl(General,value=(fmt%(cell[Id+1])),
    7041611                        style=wx.TE_PROCESS_ENTER)
     
    7831690                    else:
    7841691                        gfacTxt = G2G.ValidatedTxtCtrl(General,generalData['Lande g'],ig,
    785                             min=0.5,max=3.0,nDig=(10,2),typeHint=float)
     1692                            min=0.5,max=3.0,nDig=(10,2))
    7861693                        elemSizer.Add(gfacTxt,0,WACV)
    7871694            return elemSizer
     
    8211728                text[0] = ' Magnetic Space Group: '+SGData['MagSpGrp']
    8221729                text[3] = ' The magnetic lattice point group is '+SGData['MagPtGp']
    823                 G2gd.SGMagSpinBox(General,msg,text,table,OprNames,SpnFlp).Show()
    824                
    825             def OnDminVal(event):
    826                 event.Skip()
    827                 try:
    828                     val = float(dminVal.GetValue())
    829                     if val > 0.7:
    830                         generalData['MagDmin'] = val
    831                 except ValueError:
    832                     pass
    833                 dminVal.SetValue("%.4f"%(generalData['MagDmin']))
    834                
     1730                SGMagSpinBox(General,msg,text,table,OprNames,SpnFlp).Show()
     1731                               
    8351732            SGData = generalData['SGData']           
    8361733            Indx = {}
     
    8631760            dminSizer = wx.BoxSizer(wx.HORIZONTAL)
    8641761            dminSizer.Add(wx.StaticText(General,label=' Magnetic reflection d-min: '),0,WACV)
    865 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    866             dminVal = wx.TextCtrl(General,value='%.4f'%(generalData['MagDmin']),style=wx.TE_PROCESS_ENTER)
    867             dminVal.Bind(wx.EVT_TEXT_ENTER,OnDminVal)       
    868             dminVal.Bind(wx.EVT_KILL_FOCUS,OnDminVal)
     1762            dminVal = G2G.ValidatedTxtCtrl(General,generalData,'MagDmin',nDig=(10,4),min=0.7)
    8691763            dminSizer.Add(dminVal,0,WACV)
    8701764            magSizer.Add(dminSizer,0,WACV)
     
    8841778            pawleySizer.Add(wx.StaticText(General,label=' Pawley dmin: '),0,WACV)
    8851779            pawlVal = G2G.ValidatedTxtCtrl(General,generalData,'Pawley dmin',
    886                 min=0.25,max=20.,nDig=(10,5),typeHint=float)
     1780                min=0.25,max=20.,nDig=(10,5))
    8871781            pawleySizer.Add(pawlVal,0,WACV)
    8881782            pawleySizer.Add(wx.StaticText(General,label=' Pawley neg. wt.: '),0,WACV)
    8891783            pawlNegWt = G2G.ValidatedTxtCtrl(General,generalData,'Pawley neg wt',
    890                 min=0.,max=1.,nDig=(10,4),typeHint=float)
     1784                min=0.,max=1.,nDig=(10,4))
    8911785            pawleySizer.Add(pawlNegWt,0,WACV)
    8921786            return pawleySizer
     
    9151809                    wx.MessageBox(Text,caption=msg,style=Style)
    9161810                wx.CallAfter(UpdateGeneral)               
    917            
    918             def OnVec(event):
    919                 event.Skip()
    920                 Obj = event.GetEventObject()
    921                 ind = Indx[Obj.GetId()]
    922                 val = Obj.GetValue()
    923                 try:
    924                     val = min(2.0,max(-1.0,float(val)))
    925                 except ValueError:
    926                     val = generalData['SuperVec'][0][ind]
    927                 generalData['SuperVec'][0][ind] = val
    928                 Obj.SetValue('%.4f'%(generalData['SuperVec'][0][ind]))
    929                
     1811                           
    9301812            def OnVecRef(event):
    9311813                generalData['SuperVec'][1] = Ref.GetValue()
     
    9621844            for i,[val,show] in enumerate(zip(generalData['SuperVec'][0],ifShow)):
    9631845                if show:
    964 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    965                     modVal = wx.TextCtrl(General,value=('%.4f'%(val)),
    966                         size=wx.Size(50,20),style=wx.TE_PROCESS_ENTER)
    967                     modVal.Bind(wx.EVT_TEXT_ENTER,OnVec)       
    968                     modVal.Bind(wx.EVT_KILL_FOCUS,OnVec)
     1846                    modVal = G2G.ValidatedTxtCtrl(General,generalData['SuperVec'][0],i,nDig=(10,4),min=-1.,max=2.)
    9691847                    vecSizer.Add(modVal,0,WACV)
    9701848                    Indx[modVal.GetId()] = i
     
    9891867            def OnRefList(event):
    9901868                if not refsList:
    991                     G2G.G2MessageBox(G2frame.dataFrame,'No reflections')
     1869                    G2G.G2MessageBox(G2frame,'No reflections')
    9921870                    return
    9931871                dlg = G2G.G2MultiChoiceDialog(G2frame, 'Select reflection sets to use',
     
    10051883                    dlg.Destroy()
    10061884                wx.CallAfter(UpdateGeneral,General.GetScrollPos(wx.VERTICAL))               
    1007                
    1008             def OnResVal(event):
    1009                 event.Skip()
    1010                 try:
    1011                     res = float(mapRes.GetValue())
    1012                     if 0.25 <= res <= 20.:
    1013                         Map['Resolution'] = res
    1014                 except ValueError:
    1015                     pass
    1016                 mapRes.SetValue("%.2f"%(Map['Resolution']))          #reset in case of error
    1017            
    1018             def OnCutOff(event):
    1019                 event.Skip()
    1020                 try:
    1021                     res = float(cutOff.GetValue())
    1022                     if 1.0 <= res <= 100.:
    1023                         Map['cutOff'] = res
    1024                 except ValueError:
    1025                     pass
    1026                 cutOff.SetValue("%.1f"%(Map['cutOff']))          #reset in case of error
    1027            
     1885                           
    10281886            #patch
    10291887            if 'cutOff' not in Map:
     
    10521910            line2Sizer = wx.BoxSizer(wx.HORIZONTAL)
    10531911            line2Sizer.Add(wx.StaticText(General,label=' Resolution: '),0,WACV)
    1054 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1055             mapRes =  wx.TextCtrl(General,value='%.2f'%(Map['Resolution']),style=wx.TE_PROCESS_ENTER)
    1056             mapRes.Bind(wx.EVT_TEXT_ENTER,OnResVal)       
    1057             mapRes.Bind(wx.EVT_KILL_FOCUS,OnResVal)
     1912            mapRes = G2G.ValidatedTxtCtrl(General,Map,'Resolution',nDig=(10,2),min=0.25,max=20.)
    10581913            line2Sizer.Add(mapRes,0,WACV)
    10591914            line2Sizer.Add(wx.StaticText(General,label=' Peak cutoff %: '),0,WACV)
    1060 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1061             cutOff =  wx.TextCtrl(General,value='%.1f'%(Map['cutOff']),style=wx.TE_PROCESS_ENTER)
    1062             cutOff.Bind(wx.EVT_TEXT_ENTER,OnCutOff)       
    1063             cutOff.Bind(wx.EVT_KILL_FOCUS,OnCutOff)
     1915            cutOff = G2G.ValidatedTxtCtrl(General,Map,'cutOff',nDig=(10,1),min=1.0,max=100.)
    10641916            line2Sizer.Add(cutOff,0,WACV)
    10651917            mapSizer.Add(line2Sizer,0,WACV)
     
    10911943                    normElem.SetLabel(Flip['Norm element'])
    10921944                PE.Destroy()               
    1093                
    1094             def OnResVal(event):
    1095                 event.Skip()
    1096                 try:
    1097                     res = float(flipRes.GetValue())
    1098                     if 0.25 <= res <= 20.:
    1099                         Flip['Resolution'] = res
    1100                 except ValueError:
    1101                     pass
    1102                 flipRes.SetValue("%.2f"%(Flip['Resolution']))          #reset in case of error
    1103            
    1104             def OnkFactor(event):
    1105                 event.Skip()
    1106                 try:
    1107                     res = float(kFactor.GetValue())
    1108                     if 0.1 <= res <= 1.2:
    1109                         Flip['k-factor'] = res
    1110                 except ValueError:
    1111                     pass
    1112                 kFactor.SetValue("%.3f"%(Flip['k-factor']))          #reset in case of error
    1113            
    1114             def OnkMax(event):
    1115                 event.Skip()
    1116                 try:
    1117                     res = float(kMax.GetValue())
    1118                     if res >= 10.:
    1119                         Flip['k-Max'] = res
    1120                 except ValueError:
    1121                     pass
    1122                 kMax.SetValue("%.1f"%(Flip['k-Max']))          #reset in case of error
    1123                
     1945                                       
    11241946            def OnTestHKL(event):
    11251947                event.Skip()
     
    11531975            line2Sizer = wx.BoxSizer(wx.HORIZONTAL)
    11541976            line2Sizer.Add(wx.StaticText(General,label=' Resolution: '),0,WACV)
    1155 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1156             flipRes =  wx.TextCtrl(General,value='%.2f'%(Flip['Resolution']),style=wx.TE_PROCESS_ENTER)
    1157             flipRes.Bind(wx.EVT_TEXT_ENTER,OnResVal)       
    1158             flipRes.Bind(wx.EVT_KILL_FOCUS,OnResVal)
     1977            flipRes = G2G.ValidatedTxtCtrl(General,Flip,'Resolution',nDig=(10,2),min=0.25,max=2.)
    11591978            line2Sizer.Add(flipRes,0,WACV)
    11601979            line2Sizer.Add(wx.StaticText(General,label=' k-Factor (0.1-1.2): '),0,WACV)
    1161 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1162             kFactor =  wx.TextCtrl(General,value='%.3f'%(Flip['k-factor']),style=wx.TE_PROCESS_ENTER)
    1163             kFactor.Bind(wx.EVT_TEXT_ENTER,OnkFactor)       
    1164             kFactor.Bind(wx.EVT_KILL_FOCUS,OnkFactor)
     1980            kFactor = G2G.ValidatedTxtCtrl(General,Flip,'k-factor',nDig=(10,3),min=0.1,max=1.2)
    11651981            line2Sizer.Add(kFactor,0,WACV)
    11661982            line2Sizer.Add(wx.StaticText(General,label=' k-Max (>=10.0): '),0,WACV)
    1167 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1168             kMax = wx.TextCtrl(General,value='%.1f'%(Flip['k-Max']),style=wx.TE_PROCESS_ENTER)
    1169             kMax.Bind(wx.EVT_TEXT_ENTER,OnkMax)       
    1170             kMax.Bind(wx.EVT_KILL_FOCUS,OnkMax)
     1983            kMax = G2G.ValidatedTxtCtrl(General,Flip,'k-Max',nDig=(10,1),min=10.)
    11711984            line2Sizer.Add(kMax,0,WACV)
    11721985            flipSizer.Add(line2Sizer,0,WACV)
     
    11902003                MCSAdata['Data source'] = refList.GetValue()
    11912004           
    1192             def OnDmin(event):
    1193                 event.Skip()
    1194                 try:
    1195                     val = float(dmin.GetValue())
    1196                     if 1.0 <= val < 5.0:
    1197                         MCSAdata['dmin'] = val
    1198                 except ValueError:
    1199                     pass
    1200                 dmin.SetValue("%.3f"%(MCSAdata['dmin']))          #reset in case of error
    1201                 MCSAdata['newDmin'] = True
    1202 
    12032005            def OnCycles(event):
    12042006                MCSAdata['Cycles'] = int(cycles.GetValue())
     
    12062008            def OnAlist(event):
    12072009                MCSAdata['Algorithm'] = Alist.GetValue()
     2010                OnShowTsched()               
    12082011                wx.CallAfter(UpdateGeneral,General.GetScrollPos(wx.VERTICAL))
    1209                
    1210             def OnSlope(event):
    1211                 event.Skip()
    1212                 try:
    1213                     val = float(slope.GetValue())
    1214                     if .25 <= val < 1.0:
    1215                         MCSAdata['log slope'] = val
    1216                 except ValueError:
    1217                     pass
    1218                 slope.SetValue("%.3f"%(MCSAdata['log slope']))          #reset in case of error               
    1219            
    1220             def OnAjump(event):
    1221                 event.Skip()
    1222                 Obj = event.GetEventObject()
    1223                 name,ind = Indx[Obj.GetId()]
    1224                 try:
    1225                     val = float(Obj.GetValue())
    1226                     if .0 <= val <= 1.0:
    1227                         MCSAdata[name][ind] = val
    1228                 except ValueError:
    1229                     pass
    1230                 Obj.SetValue("%.3f"%(MCSAdata[name][ind]))
    12312012               
    12322013            def OnRanStart(event):
     
    12362017#                MCSAdata['autoRan'] = autoRan.GetValue()
    12372018               
    1238             def OnRanRange(event):
    1239                 event.Skip()
    1240                 try:
    1241                     val = float(ranRange.GetValue())/100
    1242                     if 0.01 <= val <= 0.99:
    1243                         MCSAdata['ranRange'] = val
    1244                 except ValueError:
    1245                     pass
    1246                 ranRange.SetValue('%.1f'%(MCSAdata['ranRange']*100.))
    1247            
    12482019            def OnAnneal(event):
    12492020                event.Skip()
     
    12662037                        MCSAdata['Annealing'][ind] = None                   
    12672038                        Obj.SetValue(str(MCSAdata['Annealing'][ind]))
     2039                       
     2040            def ShowTsched(invalid,value,tc):
     2041                OnShowTsched()
     2042               
     2043            def OnShowTsched():
     2044                if MCSAdata['Algorithm'] in ['fast','log']:
     2045                    Y = G2mth.makeTsched(MCSAdata)
     2046                    XY = [np.arange(len(Y)),np.log10(Y)]
     2047                    G2plt.PlotXY(G2frame,[XY,],labelX='T-step',labelY='log(T)',newPlot=True,lines=True,Title='Annealing schedule')
    12682048                       
     2049#            OnShowTsched()
    12692050            refList = []
    12702051            if len(data['Pawley ref']):
     
    12812062            lineSizer.Add(refList,0,WACV)
    12822063            lineSizer.Add(wx.StaticText(General,label=' d-min: '),0,WACV)
    1283 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1284             dmin = wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata['dmin']),style=wx.TE_PROCESS_ENTER)
    1285             dmin.Bind(wx.EVT_TEXT_ENTER,OnDmin)       
    1286             dmin.Bind(wx.EVT_KILL_FOCUS,OnDmin)
     2064            dmin = G2G.ValidatedTxtCtrl(General,MCSAdata,'dmin',nDig=(10,3),min=1.,max=5.)
    12872065            lineSizer.Add(dmin,0,WACV)
    12882066            mcsaSizer.Add(lineSizer)
     
    12902068            line2Sizer = wx.BoxSizer(wx.HORIZONTAL)
    12912069            line2Sizer.Add(wx.StaticText(General,label=' MC/SA runs: '),0,WACV)
    1292             Cchoice = ['1','2','4','8','16','32','64','128','256']
     2070            Cchoice = [str(2**i) for i in range(13)]
    12932071            cycles = wx.ComboBox(General,-1,value=str(MCSAdata.get('Cycles',1)),choices=Cchoice,
    12942072                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     
    13002078            ranStart.SetValue(MCSAdata.get('ranStart',False))
    13012079            line2Sizer.Add(ranStart,0,WACV)
    1302 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1303             ranRange = wx.TextCtrl(General,-1,value='%.1f'%(MCSAdata.get('ranRange',0.10)*100),style=wx.TE_PROCESS_ENTER)
    1304             ranRange.Bind(wx.EVT_TEXT_ENTER,OnRanRange)       
    1305             ranRange.Bind(wx.EVT_KILL_FOCUS,OnRanRange)
     2080            MCSAdata['ranRange'] = MCSAdata.get('ranRange',10.)  #patch for old gpx files
     2081            ranRange = G2G.ValidatedTxtCtrl(General,MCSAdata,'ranRange',nDig=(10,1),min=1.,max=99.)
    13062082            line2Sizer.Add(ranRange,0,WACV)
    13072083            line2Sizer.Add(wx.StaticText(General,label='% of ranges. '),0,WACV)
    1308 #            autoRan = wx.CheckBox(General,-1,label=' Do auto range reduction? ')
    1309 #            autoRan.Bind(wx.EVT_CHECKBOX, OnAutoRan)
    1310 #            autoRan.SetValue(MCSAdata.get('autoRan',False))
    1311 #            line2Sizer.Add(autoRan,0,WACV)
    13122084            mcsaSizer.Add(line2Sizer)
    13132085            mcsaSizer.Add((5,5),)
    13142086            line3Sizer = wx.BoxSizer(wx.HORIZONTAL)
    1315             Achoice = ['log','fast']                #these work
    1316 #            Achoice = ['log','fast','cauchy','boltzmann']
     2087            Achoice = ['log','fast','Basin Hopping']                #these work not 'boltzmann','cauchy',
    13172088            line3Sizer.Add(wx.StaticText(General,label=' MC/SA schedule: '),0,WACV)
    13182089            Alist = wx.ComboBox(General,-1,value=MCSAdata['Algorithm'],choices=Achoice,
     
    13202091            Alist.Bind(wx.EVT_COMBOBOX,OnAlist)
    13212092            line3Sizer.Add(Alist,0,WACV)
    1322             if MCSAdata['Algorithm'] in ['fast','boltzmann','cauchy']:
    1323                 Names = [' A-jump: ',' B-jump: ']
    1324                 parms = 'Jump coeff'
    1325                 if MCSAdata['Algorithm'] in ['boltzmann','cauchy']:
    1326                     Names = [' A-jump: ']
    1327                 elif 'fast' in MCSAdata['Algorithm']:
    1328                     Names = [' quench: ',' m-factor: ',' n-factor: ']
    1329                     parms = 'fast parms'
     2093            if MCSAdata['Algorithm'] in ['fast',]:
     2094                Names = [' quench: ',' c-factor: ']
     2095                parms = 'fast parms'
    13302096                for i,name in enumerate(Names):
    13312097                    line3Sizer.Add(wx.StaticText(General,label=name),0,WACV)
    1332 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1333                     Ajump =  wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata[parms][i]),style=wx.TE_PROCESS_ENTER)
    1334                     Ajump.Bind(wx.EVT_TEXT_ENTER,OnAjump)       
    1335                     Ajump.Bind(wx.EVT_KILL_FOCUS,OnAjump)
    1336                     Indx[Ajump.GetId()] = [parms,i]
     2098                    Ajump = G2G.ValidatedTxtCtrl(General,MCSAdata[parms],i,nDig=(10,2),min=0.1,max=1.,OnLeave=ShowTsched)
    13372099                    line3Sizer.Add(Ajump,0,WACV)
    13382100            elif 'log' in MCSAdata['Algorithm']:
    13392101                line3Sizer.Add(wx.StaticText(General,label=' slope: '),0,WACV)
    1340 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    1341                 slope =  wx.TextCtrl(General,-1,value='%.3f'%(MCSAdata['log slope']),style=wx.TE_PROCESS_ENTER)
    1342                 slope.Bind(wx.EVT_TEXT_ENTER,OnSlope)       
    1343                 slope.Bind(wx.EVT_KILL_FOCUS,OnSlope)
     2102                slope = G2G.ValidatedTxtCtrl(General,MCSAdata,'log slope',nDig=(10,3),min=0.25,max=1.0,OnLeave=ShowTsched)
    13442103                line3Sizer.Add(slope,0,WACV)
     2104            elif 'Basin Hopping' in MCSAdata['Algorithm']:
     2105                pass        #TODO basinhopping controls here?
    13452106            mcsaSizer.Add(line3Sizer)
    13462107            mcsaSizer.Add((5,5),)
    13472108            line3Sizer = wx.BoxSizer(wx.HORIZONTAL)
    13482109            line3Sizer.Add(wx.StaticText(General,label=' Annealing schedule: '),0,WACV)
    1349             names = [' Start temp: ',' Final temp: ',' No. trials: ']
    1350             fmts = ['%.1f','%.5f','%d']
    1351             for i,[name,fmt] in enumerate(zip(names,fmts)):
    1352                 if MCSAdata['Annealing'][i]:
    1353                     text = fmt%(MCSAdata['Annealing'][i])
    1354                 else:
    1355                     text = 'None'
    1356                 line3Sizer.Add(wx.StaticText(General,label=name),0,WACV)
    1357                 anneal =  wx.TextCtrl(General,-1,value=text,style=wx.TE_PROCESS_ENTER)
    1358                 anneal.Bind(wx.EVT_TEXT_ENTER,OnAnneal)       
    1359                 anneal.Bind(wx.EVT_KILL_FOCUS,OnAnneal)
    1360                 Indx[anneal.GetId()] = [i,fmt]
    1361                 line3Sizer.Add(anneal,0,WACV)
     2110            if 'Basin Hopping' in MCSAdata['Algorithm']:
     2111                line3Sizer.Add(wx.StaticText(General,label=' Test temp: '),0,WACV)
     2112                line3Sizer.Add(G2G.ValidatedTxtCtrl(General,MCSAdata['Annealing'],0,nDig=(10,5)),0,WACV)               
     2113            else:
     2114                line3Sizer.Add(wx.StaticText(General,label=' Start temp: '),0,WACV)
     2115                line3Sizer.Add(G2G.ValidatedTxtCtrl(General,MCSAdata['Annealing'],0,nDig=(10,5),OnLeave=ShowTsched),0,WACV)
     2116                line3Sizer.Add(wx.StaticText(General,label=' Final temp: '),0,WACV)
     2117                line3Sizer.Add(G2G.ValidatedTxtCtrl(General,MCSAdata['Annealing'],1,nDig=(10,5),OnLeave=ShowTsched),0,WACV)
     2118            line3Sizer.Add(wx.StaticText(General,label=' No. trials: '),0,WACV)
     2119            line3Sizer.Add(G2G.ValidatedTxtCtrl(General,MCSAdata['Annealing'],2),0,WACV)
    13622120            mcsaSizer.Add(line3Sizer)           
    13632121            return mcsaSizer
     
    13902148
    13912149        if generalData['Modulated']:
    1392             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_SINGLEMCSA,False)
    1393             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_MULTIMCSA,False)
    1394             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_4DCHARGEFLIP,True)
     2150            G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_SINGLEMCSA,False)
     2151            G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_MULTIMCSA,False)
     2152            G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_4DCHARGEFLIP,True)
    13952153            mainSizer.Add(ModulatedSizer(generalData['Type']))
    13962154            G2G.HorizontalLine(mainSizer,General)
    13972155        else:
    1398             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_SINGLEMCSA,True)
    1399             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_MULTIMCSA,True)
    1400             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_4DCHARGEFLIP,False)
     2156            G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_SINGLEMCSA,True)
     2157            G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_MULTIMCSA,True)
     2158            G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_4DCHARGEFLIP,False)
    14012159
    14022160        mainSizer.Add(PawleySizer())
     
    14102168            G2G.HorizontalLine(mainSizer,General)
    14112169            mainSizer.Add(MCSASizer())
    1412         G2frame.dataFrame.SetStatusText('')
    1413         SetPhaseWindow(G2frame.dataFrame,General,mainSizer,Scroll=Scroll)
     2170        G2frame.GetStatusBar().SetStatusText('',1)
     2171        SetPhaseWindow(General,mainSizer,Scroll=Scroll)
    14142172       
    14152173    def OnTransform(event):
    1416         dlg = G2gd.TransformDialog(G2frame,data)
     2174        dlg = TransformDialog(G2frame,data)
    14172175        try:
    14182176            if dlg.ShowModal() == wx.ID_OK:
     
    14422200            Atoms = newPhase['Atoms']
    14432201            if ifMag:
    1444                 dlg = G2gd.UseMagAtomDialog(G2frame,Atoms,atCodes)
     2202                dlg = UseMagAtomDialog(G2frame,Atoms,atCodes)
    14452203                try:
    14462204                    if dlg.ShowModal() == wx.ID_OK:
     
    14612219                UseList[hist]['HStrain'] = [NDij*[0.0,],NDij*[False,]]
    14622220            newPhase['General']['Map'] = mapDefault.copy()
    1463             sub = G2frame.PatternTree.AppendItem(parent=
    1464                 G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'),text=phaseName)
    1465             G2frame.PatternTree.SetItemPyData(sub,newPhase)
     2221            sub = G2frame.GPXtree.AppendItem(parent=
     2222                G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases'),text=phaseName)
     2223            G2frame.GPXtree.SetItemPyData(sub,newPhase)
    14662224            newPhase['Drawing'] = []
    14672225           
     
    14692227                G2frame.GetUsedHistogramsAndPhasesfromTree()
    14702228                G2cnstG.MagConstraints(G2frame,data,newPhase,Trans,Vec,atCodes)     #data is old phase
    1471             G2frame.PatternTree.SelectItem(sub)
     2229            G2frame.GPXtree.SelectItem(sub)
    14722230       
    14732231################################################################################
     
    17102468            if not (event.AltDown() or (event.ShiftDown() and event.ControlDown())):
    17112469                Atoms.frm = -1
    1712                 G2frame.dataFrame.SetStatusText('')                   
     2470                G2frame.GetStatusBar().SetStatusText('',1)                   
    17132471            if r < 0 and c < 0:
    17142472                if Atoms.IsSelection():
     
    17392497                            Atoms.SelectRow(r,True)
    17402498                            n = colLabels.index('Name')
    1741                             G2frame.dataFrame.SetStatusText('Atom '+atomData[r][n]+' is to be moved')
     2499                            G2frame.GetStatusBar().SetStatusText('Atom '+atomData[r][n]+' is to be moved',1)
    17422500                        else:                       #move it
    17432501                            item = atomData.pop(Atoms.frm)
    17442502                            atomData.insert(r,item)
    17452503                            Atoms.frm = -1
    1746                             G2frame.dataFrame.SetStatusText('')
     2504                            G2frame.GetStatusBar().SetStatusText('',1)
     2505                            data['Drawing']['Atoms'] = []           #clear & rebuild Draw atoms table
     2506                            UpdateDrawAtoms()
    17472507                            wx.CallAfter(Paint)
    17482508                else:
     
    18482608                            Atoms.SetCellStyle(row,c,VERY_LIGHT_GREY,True)
    18492609            Atoms.AutoSizeColumns(False)
    1850             SetPhaseWindow(G2frame.dataFrame,Atoms,size=[700,300])
     2610            SetPhaseWindow(Atoms)
    18512611
    18522612        # FillAtomsGrid executable code starts here
     
    18702630                    rbAtmDict[id] += 'U'           
    18712631        # exclList will be 'x' or 'xu' if TLS used in RB
    1872         Items = [G2gd.wxID_ATOMSEDITINSERT,G2gd.wxID_ATOMSEDITDELETE,
    1873             G2gd.wxID_ATOMSMODIFY,G2gd.wxID_ATOMSTRANSFORM,G2gd.wxID_MAKEMOLECULE,
    1874             G2gd.wxID_ATOMVIEWINSERT,G2gd.wxID_ATOMMOVE,G2gd.wxID_ADDHATOM]
     2632        Items = [G2G.wxID_ATOMSEDITINSERT,G2G.wxID_ATOMSEDITDELETE,
     2633            G2G.wxID_ATOMSMODIFY,G2G.wxID_ATOMSTRANSFORM,G2G.wxID_MAKEMOLECULE,
     2634            G2G.wxID_ATOMVIEWINSERT,G2G.wxID_ATOMMOVE,G2G.wxID_ADDHATOM]
    18752635        if atomData:
    18762636            for item in Items:   
    1877                 G2frame.dataFrame.AtomsMenu.Enable(item,True)
     2637                G2frame.dataWindow.AtomsMenu.Enable(item,True)
    18782638        else:
    18792639            for item in Items:
    1880                 G2frame.dataFrame.AtomsMenu.Enable(item,False)
    1881         Items = [G2gd.wxID_ATOMVIEWINSERT, G2gd.wxID_ATOMSVIEWADD,G2gd.wxID_ATOMMOVE]
     2640                G2frame.dataWindow.AtomsMenu.Enable(item,False)
     2641        Items = [G2G.wxID_ATOMVIEWINSERT, G2G.wxID_ATOMSVIEWADD,G2G.wxID_ATOMMOVE]
    18822642        if 'showABC' in data['Drawing']:
    18832643            for item in Items:
    1884                 G2frame.dataFrame.AtomsMenu.Enable(item,True)
     2644                G2frame.dataWindow.AtomsMenu.Enable(item,True)
    18852645        else:
    18862646            for item in Items:
    1887                 G2frame.dataFrame.AtomsMenu.Enable(item,False)
     2647                G2frame.dataWindow.AtomsMenu.Enable(item,False)
    18882648        parmChoice = ': ,X,XU,U,F,FX,FXU,FU'
    18892649        if generalData['Type'] == 'magnetic':
     
    19062666            Types = Types[:7]+3*[wg.GRID_VALUE_FLOAT+':10,4',]+Types[7:]
    19072667        SGData = data['General']['SGData']
    1908         G2frame.dataFrame.SetStatusText('')
     2668        G2frame.GetStatusBar().SetStatusText('',1)
    19092669        if SGData['SGPolax']:
    1910             G2frame.dataFrame.SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'])
     2670            G2frame.GetStatusBar().SetStatusText('Warning: The location of the origin is arbitrary in '+SGData['SGPolax'],1)
    19112671        Atoms.Bind(wg.EVT_GRID_CELL_CHANGE, ChangeAtomCell)
    19122672        Atoms.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, AtomTypeSelect)
     
    20012761        if 'DisAglCtls' in generalData:
    20022762            DisAglCtls = generalData['DisAglCtls']
     2763        dlg = G2G.DisAglDialog(G2frame,DisAglCtls,generalData,Reset=False)
     2764        if dlg.ShowModal() == wx.ID_OK:
     2765            DisAglCtls = dlg.GetData()
    20032766            if 'H' not in DisAglCtls['AtomTypes']:
    20042767                DisAglCtls['AtomTypes'].append('H')
    20052768                DisAglCtls['AngleRadii'].append(0.5)
    20062769                DisAglCtls['BondRadii'].append(0.5)
    2007         dlg = G2gd.DisAglDialog(G2frame,DisAglCtls,generalData,Reset=False)
    2008         if dlg.ShowModal() == wx.ID_OK:
    2009             DisAglCtls = dlg.GetData()
    20102770        else:
    20112771            dlg.Destroy()
     
    20572817            HydIds = {}
    20582818            mapError = False
    2059             dlg = G2gd.AddHatomDialog(G2frame,Neigh,data)
     2819            dlg = AddHatomDialog(G2frame,Neigh,data)
    20602820            if dlg.ShowModal() == wx.ID_OK:
    20612821                Nat = len(atomData)
     
    20802840            SetupGeneral()
    20812841            data['General']['HydIds'].update(HydIds)
    2082             G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,True)
     2842            G2frame.dataWindow.AtomEdit.Enable(G2G.wxID_UPDATEHATOM,True)
    20832843            data['Drawing']['Atoms'] = []
    20842844            UpdateDrawAtoms()
     
    20882848        else:
    20892849            wx.MessageBox('No candidates found',caption='Add H atom Error',style=wx.ICON_EXCLAMATION)
    2090                
     2850       
    20912851    def OnHydAtomUpdate(event):
    20922852        generalData = data['General']
     
    21112871            del HydIds[HId]
    21122872        if not len(HydIds):
    2113             G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,False)
     2873            G2frame.dataWindow.AtomEdit.Enable(G2G.wxID_UPDATEHATOM,False)
    21142874        data['Drawing']['Atoms'] = []
    21152875        UpdateDrawAtoms()
     
    22192979            atom = atomData[ind]
    22202980            if atom[ci+8] in rbAtmDict:
    2221                 G2frame.dataFrame.SetStatusText('**** ERROR - atom is in a rigid body and can not be deleted ****')
     2981                G2frame.GetStatusBar().SetStatusText('**** ERROR - atom is in a rigid body and can not be deleted ****',1)
    22222982            else:
    22232983                if atom[ci+8] in HydIds:    #remove Hs from Hatom update dict
     
    22342994        SetupGeneral()
    22352995        if not len(HydIds):
    2236             G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,False)
     2996            G2frame.dataWindow.AtomEdit.Enable(G2G.wxID_UPDATEHATOM,False)
    22372997        event.StopPropagation()
    22382998
     
    23953155        atomData = data['Atoms']
    23963156        SGData = generalData['SGData']
    2397         dlg = G2gd.SymOpDialog(G2frame,SGData,True,True)
     3157        dlg = SymOpDialog(G2frame,SGData,True,True)
    23983158        New = False
    23993159        try:
     
    25003260            if 'DisAglCtls' in generalData:
    25013261                DisAglCtls = generalData['DisAglCtls']
    2502             dlg = G2gd.DisAglDialog(G2frame,DisAglCtls,generalData)
     3262            dlg = G2G.DisAglDialog(G2frame,DisAglCtls,generalData)
    25033263            if dlg.ShowModal() == wx.ID_OK:
    25043264                DisAglCtls = dlg.GetData()
     
    25283288        msg = 'Density of phase {:s} = {:.3f} g/cc'.format(data['General']['Name'],density)
    25293289        print(msg)
    2530         G2G.G2MessageBox(G2frame.dataFrame,msg,'Density')
     3290        G2G.G2MessageBox(G2frame,msg,'Density')
    25313291       
    25323292    def OnValidProtein(event):
    2533         G2mth.validProtein(data)
     3293        resNames,Probs = G2mth.validProtein(data)
     3294        G2plt.PlotAAProb(G2frame,resNames,Probs,Title='Error score for %s'%(data['General']['Name']),
     3295            thresh=[17.190823041860433,11.526684477428809])
    25343296
    25353297    def OnSetAll(event):
     
    25563318            if 'DisAglCtls' in generalData:
    25573319                DisAglCtls = generalData['DisAglCtls']
    2558             dlg = G2gd.DisAglDialog(G2frame,DisAglCtls,generalData)
     3320            dlg = G2G.DisAglDialog(G2frame,DisAglCtls,generalData)
    25593321            if dlg.ShowModal() == wx.ID_OK:
    25603322                DisAglCtls = dlg.GetData()
     
    25793341            if 'pId' in data:
    25803342                DisAglData['pId'] = data['pId']
    2581                 DisAglData['covData'] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
     3343                DisAglData['covData'] = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Covariance'))
    25823344            try:
    25833345                if fp:
     
    26343396        Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree() # init for constraint
    26353397        # make a lookup table for constraints
    2636         sub = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Constraints')
    2637         Constraints = G2frame.PatternTree.GetItemPyData(sub)
     3398        sub = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Constraints')
     3399        Constraints = G2frame.GPXtree.GetItemPyData(sub)
    26383400        constDict = {}
    26393401        for item in Constraints:
     
    27703532        generalData = data['General']
    27713533        cx,ct,cs,cia = generalData['AtomPtrs']
    2772         reqrdr = G2frame.dataFrame.ReImportMenuId.get(event.GetId())
     3534        reqrdr = G2frame.dataWindow.ReImportMenuId.get(event.GetId())
    27733535        rdlist = G2frame.OnImportGeneric(reqrdr,
    27743536            G2frame.ImportPhaseReaderlist,'phase')
     
    28573619            wx.CallAfter(UpdateLayerData)
    28583620       
    2859         def OnToler(event): #used when Laue = unknown
    2860             event.Skip()
    2861             try:
    2862                 val = float(toler.GetValue())
    2863             except ValueError:
    2864                 val = Layers['Toler']
    2865             Layers['Toler'] = val
    2866             toler.SetValue('%.3f'%(Layers['Toler']))
    2867            
    28683621        def OnSadpPlot(event):
    28693622            sadpPlot.SetValue(False)
     
    29463699            for txt,fmt,ifEdit,Id in useGUI[2]:
    29473700                cellSizer.Add(wx.StaticText(layerData,label=txt),0,WACV)
    2948 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    29493701                cellVal = wx.TextCtrl(layerData,value=(fmt%(cell[Id+1])),
    29503702                    style=wx.TE_PROCESS_ENTER)
     
    29593711        def WidthSizer():
    29603712           
    2961             def OnWidthChange(event):
    2962                 event.Skip()
    2963                 Obj = event.GetEventObject()
    2964                 id = Indx[Obj]
    2965                 try:
    2966                     Layers['Width'][0][id] = max(0.005,min(1.0,float(Obj.GetValue())))
    2967                 except ValueError:
    2968                     pass
    2969                 Obj.SetValue('%.3f'%(Layers['Width'][0][id]))
    2970                
    29713713            def OnRefWidth(event):
    29723714                id = Indx[event.GetEventObject()]
     
    29743716           
    29753717            Labels = ['a','b']
    2976             widths = Layers['Width'][0]
    29773718            flags = Layers['Width'][1]
    29783719            widthSizer = wx.BoxSizer(wx.HORIZONTAL)
    29793720            for i in range(2):
    29803721                widthSizer.Add(wx.StaticText(layerData,label=u' layer width(%s) (<= 1\xb5m): '%(Labels[i])),0,WACV)
    2981 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    2982                 widthVal = wx.TextCtrl(layerData,value='%.3f'%(widths[i]),style=wx.TE_PROCESS_ENTER)
    2983                 widthVal.Bind(wx.EVT_TEXT_ENTER,OnWidthChange)       
    2984                 widthVal.Bind(wx.EVT_KILL_FOCUS,OnWidthChange)
    2985                 Indx[widthVal] = i
     3722                widthVal = G2G.ValidatedTxtCtrl(layerData,Layers['Width'][0],i,nDig=(10,3),min=0.005,max=1.0)
    29863723                widthSizer.Add(widthVal,0,WACV)
    29873724                widthRef = wx.CheckBox(layerData,label='Refine?')
     
    31343871            atomGrid = G2G.GSGrid(layerData)
    31353872            atomGrid.SetTable(atomTable,True)
    3136             atomGrid.SetScrollRate(0,0)    #get rid of automatic scroll bars
     3873#            atomGrid.SetScrollRate(0,0)    #get rid of automatic scroll bars
    31373874            for c in range(2,5):
    31383875                attr = wx.grid.GridCellAttr()
     
    32203957                transGrid = G2G.GSGrid(layerData)
    32213958                transGrid.SetTable(transTable,True)
    3222                 transGrid.SetScrollRate(0,0)    #get rid of automatic scroll bars
     3959#                transGrid.SetScrollRate(0,0)    #get rid of automatic scroll bars
    32233960                Indx[transGrid.GetId()] = Yi
    32243961                for c in range(0,4):
     
    33654102            if Layers['Stacking'][0] == 'recursive':
    33664103                topLine.Add(wx.StaticText(layerData,label=' number of layers (<1022 or "infinite"): '),0,WACV)
    3367 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    33684104                numLayers = wx.TextCtrl(layerData,value=data['Layers']['Stacking'][1],style=wx.TE_PROCESS_ENTER)
    33694105                numLayers.Bind(wx.EVT_TEXT_ENTER,OnNumLayers)       
     
    34054141        if len(Layers['Layers']):
    34064142            layerNames = [layer['Name'] for layer in Layers['Layers']]
    3407         G2frame.dataFrame.SetStatusText('')
     4143        G2frame.GetStatusBar().SetStatusText('',1)
    34084144        layerData = G2frame.layerData
    34094145        if layerData.GetSizer():
     
    34314167        if Layers['Laue'] == 'unknown':
    34324168            laueSizer.Add(wx.StaticText(layerData,label=' Diffraction symmetry tolerance: '),0,WACV)
    3433 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    3434             toler = wx.TextCtrl(layerData,value='%.3f'%(Layers['Toler']),style=wx.TE_PROCESS_ENTER)
    3435             toler.Bind(wx.EVT_TEXT_ENTER,OnToler)       
    3436             toler.Bind(wx.EVT_KILL_FOCUS,OnToler)
     4169            toler = G2G.ValidatedTxtCtrl(layerData,Layers,'Toler',nDig=(10,3))
    34374170            laueSizer.Add(toler,0,WACV)
    34384171        topSizer.Add(laueSizer,0,WACV)
     
    34644197        bottomSizer.Add(StackSizer())
    34654198        mainSizer.Add(bottomSizer)
    3466         SetPhaseWindow(G2frame.dataFrame,G2frame.layerData,mainSizer,Scroll=Scroll)
     4199        SetPhaseWindow(G2frame.layerData,mainSizer,Scroll=Scroll)
    34674200       
    34684201    def OnCopyPhase(event):
     
    35124245        if debug: idebug = 1
    35134246        ctrls = ''
    3514         dlg = G2gd.DIFFaXcontrols(G2frame,ctrls)
     4247        dlg = DIFFaXcontrols(G2frame,ctrls)
    35154248        if dlg.ShowModal() == wx.ID_OK:
    35164249            simCodes = dlg.GetSelection()
     
    35334266                return
    35344267            dlg.Destroy()
    3535             G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistName)
    3536             sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4268            G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistName)
     4269            sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    35374270                G2frame,G2frame.PatternId, 'Sample Parameters'))
    35384271            scale = sample['Scale'][0]
    3539             background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4272            background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    35404273                G2frame,G2frame.PatternId, 'Background'))       
    3541             limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4274            limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    35424275                G2frame,G2frame.PatternId, 'Limits'))[1]
    3543             inst = G2frame.PatternTree.GetItemPyData(
    3544                 G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     4276            inst = G2frame.GPXtree.GetItemPyData(
     4277                G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    35454278            if 'T' in inst['Type'][0]:
    35464279                wx.MessageBox("Can't simulate neutron TOF patterns yet",caption='Data error',style=wx.ICON_EXCLAMATION)
    35474280                return           
    3548             profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1]
     4281            profile = G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[1]
    35494282            G2pwd.CalcStackingPWDR(data['Layers'],scale,background,limits,inst,profile,debug)
    35504283            if debug:
     
    36044337        data['Layers']['seqCodes'] = []
    36054338        Parms = G2pwd.GetStackParms(data['Layers'])
    3606         dlg = G2gd.DIFFaXcontrols(G2frame,ctrls,Parms)
     4339        dlg = DIFFaXcontrols(G2frame,ctrls,Parms)
    36074340        if dlg.ShowModal() == wx.ID_OK:
    36084341            simCodes = dlg.GetSelection()
     
    36234356            return
    36244357        dlg.Destroy()
    3625         G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistName)
    3626         sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4358        G2frame.PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistName)
     4359        sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    36274360            G2frame,G2frame.PatternId, 'Sample Parameters'))
    36284361        scale = sample['Scale'][0]
    3629         background = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4362        background = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    36304363            G2frame,G2frame.PatternId, 'Background'))       
    3631         limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     4364        limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    36324365            G2frame,G2frame.PatternId, 'Limits'))[1]
    3633         inst = G2frame.PatternTree.GetItemPyData(
    3634             G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     4366        inst = G2frame.GPXtree.GetItemPyData(
     4367            G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
    36354368        if 'T' in inst['Type'][0]:
    36364369            wx.MessageBox("Can't simulate neutron TOF patterns yet",caption='Data error',style=wx.ICON_EXCLAMATION)
    36374370            return           
    3638         profile = np.copy(G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1])
     4371        profile = np.copy(G2frame.GPXtree.GetItemPyData(G2frame.PatternId)[1])
    36394372        resultXY2 = []
    36404373        resultXY = [np.vstack((profile[0],profile[1])),]    #observed data
     
    37084441        Indx = {}
    37094442        waveData = G2frame.waveData
    3710         G2frame.dataFrame.SetStatusText('')
     4443        G2frame.GetStatusBar().SetStatusText('',1)
    37114444        generalData = data['General']
    37124445        SGData = generalData['SGData']
     
    37394472            mainSizer.Add(G2frame.bottomSizer)
    37404473            mainSizer.Layout()
    3741             G2frame.dataFrame.Refresh()
     4474            G2frame.dataWindow.Refresh()
    37424475            waveData.SetVirtualSize(mainSizer.GetMinSize())
    37434476            waveData.Scroll(0,Scroll)
    3744             G2frame.dataFrame.SendSizeEvent()
     4477            G2frame.dataWindow.SendSizeEvent()
    37454478           
    37464479        def ShowAtomInfo():
     
    37514484                    atom[-1]['SS1']['waveType'] = waveType.GetValue()
    37524485                    atom[-1]['SS1']['Spos'] = []
    3753                     RepaintAtomInfo(G2frame.waveData.GetScrollPos(wx.VERTICAL))               
     4486                    wx.CallAfter(RepaintAtomInfo,G2frame.waveData.GetScrollPos(wx.VERTICAL))               
    37544487                   
    37554488                def OnShowWave(event):
     
    37854518                        nt = numVals[waveType]
    37864519                    atomData[iatm][-1]['SS1'][item].append([[0.0 for i in range(nt)],False])
    3787                     RepaintAtomInfo(G2frame.waveData.GetScrollPos(wx.VERTICAL))
     4520                    wx.CallAfter(RepaintAtomInfo,G2frame.waveData.GetScrollPos(wx.VERTICAL))
    37884521                   
    37894522                def OnWaveVal(event):
     
    38124545                    iatm,item,iwave = Indx[Obj.GetId()]
    38134546                    del atomData[iatm][-1]['SS1'][item][iwave]
    3814                     RepaintAtomInfo(G2frame.waveData.GetScrollPos(wx.VERTICAL))               
     4547                    wx.CallAfter(RepaintAtomInfo,G2frame.waveData.GetScrollPos(wx.VERTICAL))               
    38154548               
    38164549                waveSizer = wx.BoxSizer(wx.VERTICAL)
     
    38534586                        for ival,val in enumerate(wave[0]):
    38544587                            if np.any(CSI[Stype][0][ival]):
    3855 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    38564588                                waveVal = wx.TextCtrl(waveData,value='%.5f'%(val),style=wx.TE_PROCESS_ENTER)
    38574589                                waveVal.Bind(wx.EVT_TEXT_ENTER,OnWaveVal)
     
    39014633        G2frame.bottomSizer = ShowAtomInfo()
    39024634        mainSizer.Add(G2frame.bottomSizer)
    3903         SetPhaseWindow(G2frame.dataFrame,G2frame.waveData,mainSizer,Scroll=Scroll)
     4635        SetPhaseWindow(G2frame.waveData,mainSizer,Scroll=Scroll)
    39044636   
    39054637    def OnWaveVary(event):
     
    39884720    def OnRestraint(event):       
    39894721        indx = drawAtoms.GetSelectedRows()
    3990         restData = G2frame.PatternTree.GetItemPyData(   
    3991             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Restraints'))
     4722        restData = G2frame.GPXtree.GetItemPyData(   
     4723            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Restraints'))
    39924724        drawingData = data['Drawing']
    39934725        generalData = data['General']
     
    40024734            atSymOp.append(atomData[item][cs-1])
    40034735            atIndx.append(atomData[item][ci])
    4004         if event.GetId() == G2gd.wxID_DRAWRESTRBOND and len(indx) == 2:
     4736        if event.GetId() == G2G.wxID_DRAWRESTRBOND and len(indx) == 2:
    40054737            try:
    40064738                bondData = restData[PhaseName]['Bond']
     
    40104742                restData[PhaseName]['Bond'] = bondData
    40114743            bondData['Bonds'].append([atIndx,atSymOp,1.54,0.01])
    4012         elif event.GetId() == G2gd.wxID_DRAWRESTRANGLE and len(indx) == 3:
     4744        elif event.GetId() == G2G.wxID_DRAWRESTRANGLE and len(indx) == 3:
    40134745            try:
    40144746                angleData = restData[PhaseName]['Angle']
     
    40184750                restData[PhaseName]['Angle'] = angleData
    40194751            angleData['Angles'].append([atIndx,atSymOp,109.5,1.0])           
    4020         elif event.GetId() == G2gd.wxID_DRAWRESTRPLANE and len(indx) > 3:
     4752        elif event.GetId() == G2G.wxID_DRAWRESTRPLANE and len(indx) > 3:
    40214753            try:
    40224754                planeData = restData[PhaseName]['Plane']
     
    40264758                restData[PhaseName]['Plane'] = planeData
    40274759            planeData['Planes'].append([atIndx,atSymOp,0.0,0.01])           
    4028         elif event.GetId() == G2gd.wxID_DRAWRESTRCHIRAL and len(indx) == 4:
     4760        elif event.GetId() == G2G.wxID_DRAWRESTRCHIRAL and len(indx) == 4:
    40294761            try:
    40304762                chiralData = restData[PhaseName]['Chiral']
     
    40374769            print '**** ERROR wrong number of atoms selected for this restraint'
    40384770            return
    4039         G2frame.PatternTree.SetItemPyData(   
    4040             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Restraints'),restData)
     4771        G2frame.GPXtree.SetItemPyData(   
     4772            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Restraints'),restData)
    40414773
    40424774    def OnDefineRB(event):
    40434775        indx = drawAtoms.GetSelectedRows()
    40444776        indx.sort()
    4045         RBData = G2frame.PatternTree.GetItemPyData(   
    4046             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     4777        RBData = G2frame.GPXtree.GetItemPyData(   
     4778            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    40474779        drawingData = data['Drawing']
    40484780        generalData = data['General']
     
    40744806            'atNames':atNames,'rbRef':[0,1,2,False],'rbSeq':[],'SelSeq':[0,0],'useCount':0}
    40754807        RBData['RBIds']['Residue'].append(rbId)
    4076         G2frame.dataFrame.SetStatusText('New rigid body UNKRB added to set of Residue rigid bodies')
     4808        G2frame.GetStatusBar().SetStatusText('New rigid body UNKRB added to set of Residue rigid bodies',1)
    40774809
    40784810################################################################################
     
    42134945
    42144946        # UpdateDrawAtoms executable code starts here
    4215         G2frame.dataFrame.SetStatusText('')
     4947        G2frame.GetStatusBar().SetStatusText('',1)
    42164948        generalData = data['General']
    42174949        SetupDrawingData()
     
    42715003           if colLabels[c] not in ['Style','Label','Color']:
    42725004                drawAtoms.SetColAttr(c,attr)
    4273         SetPhaseWindow(G2frame.dataFrame,drawAtoms,size=[600,300])
     5005        SetPhaseWindow(drawAtoms)
    42745006
    42755007        FindBondsDraw(data)
     
    43245056        if indx:
    43255057            if len(indx) > 1:
    4326                 G2frame.dataFrame.SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK')
     5058                G2frame.GetStatusBar().SetStatusText('Select Custom Color, change color, Add to Custom Colors, then OK',1)
    43275059            else:
    4328                 G2frame.dataFrame.SetStatusText('Change color, Add to Custom Colors, then OK')
     5060                G2frame.GetStatusBar().SetStatusText('Change color, Add to Custom Colors, then OK',1)
    43295061            atomData = data['Drawing']['Atoms']
    43305062            cx,ct,cs,ci = data['Drawing']['atomPtrs']
     
    43535085            drawAtoms.ClearSelection()
    43545086            dlg.Destroy()
    4355             G2frame.dataFrame.SetStatusText('')
     5087            G2frame.GetStatusBar().SetStatusText('',1)
    43565088            G2plt.PlotStructure(G2frame,data)
    43575089           
     
    43725104        if 'DisAglCtls' in generalData:
    43735105            DisAglCtls = generalData['DisAglCtls']
    4374         dlg = G2gd.DisAglDialog(G2frame,DisAglCtls,generalData,Angle=False)
     5106        dlg = G2G.DisAglDialog(G2frame,DisAglCtls,generalData,Angle=False)
    43755107        if dlg.ShowModal() == wx.ID_OK:
    43765108            DisAglCtls = dlg.GetData()
     
    44115143            SGData = generalData['SGData']
    44125144            SpnFlp = SGData.get('SpnFlp',[])
    4413             dlg = G2gd.SymOpDialog(G2frame,SGData,False,True)
     5145            dlg = SymOpDialog(G2frame,SGData,False,True)
    44145146            try:
    44155147                if dlg.ShowModal() == wx.ID_OK:
     
    44675199        indx = drawAtoms.GetSelectedRows()
    44685200        indx.sort()
    4469         dlg = G2gd.SphereEnclosure(G2frame,data['General'],data['Drawing'],indx)
     5201        dlg = SphereEnclosure(G2frame,data['General'],data['Drawing'],indx)
    44705202        try:
    44715203            if dlg.ShowModal() == wx.ID_OK:
     
    45225254            SGData = generalData['SGData']
    45235255            SpnFlp = SGData.get('SpnFlp',[])
    4524             dlg = G2gd.SymOpDialog(G2frame,SGData,False,True)
     5256            dlg = SymOpDialog(G2frame,SGData,False,True)
    45255257            try:
    45265258                if dlg.ShowModal() == wx.ID_OK:
     
    47795511        if 'pId' in data:
    47805512            DATData['pId'] = data['pId']
    4781             DATData['covData'] = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
     5513            DATData['covData'] = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Covariance'))
    47825514        G2stMn.DisAglTor(DATData)
    47835515                       
     
    47995531                ZclipTxt.SetLabel(' Z clipping: '+'%.2fA'%(drawingData['Zclip']*drawingData['cameraPos']/100.))
    48005532                G2plt.PlotStructure(G2frame,data)
    4801                
    4802             def OnZstep(event):
    4803                 event.Skip()
    4804                 try:
    4805                     step = float(Zstep.GetValue())
    4806                     if not (0.01 <= step <= 1.0):
    4807                         raise ValueError
    4808                 except ValueError:
    4809                     step = drawingData['Zstep']
    4810                 drawingData['Zstep'] = step
    4811                 Zstep.SetValue('%.2fA'%(drawingData['Zstep']))
    48125533               
    48135534            def OnMoveZ(event):
     
    48625583            cameraPosTxt = wx.StaticText(drawOptions,-1,
    48635584                ' Camera Distance: '+'%.2f'%(drawingData['cameraPos']),name='cameraPos')
    4864             G2frame.dataDisplay.cameraPosTxt = cameraPosTxt
     5585            G2frame.phaseDisplay.cameraPosTxt = cameraPosTxt
    48655586            slideSizer.Add(cameraPosTxt,0,WACV)
    48665587            cameraPos = wx.Slider(drawOptions,style=wx.SL_HORIZONTAL,value=drawingData['cameraPos'],name='cameraSlider')
    48675588            cameraPos.SetRange(10,500)
    48685589            cameraPos.Bind(wx.EVT_SLIDER, OnCameraPos)
    4869             G2frame.dataDisplay.cameraSlider = cameraPos
     5590            G2frame.phaseDisplay.cameraSlider = cameraPos
    48705591            slideSizer.Add(cameraPos,1,wx.EXPAND|wx.RIGHT)
    48715592           
     
    48795600            ZstepSizer = wx.BoxSizer(wx.HORIZONTAL)
    48805601            ZstepSizer.Add(wx.StaticText(drawOptions,-1,' Z step:'),0,WACV)
    4881 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    4882             Zstep = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['Zstep']),
    4883                 style=wx.TE_PROCESS_ENTER)
    4884             Zstep.Bind(wx.EVT_TEXT_ENTER,OnZstep)
    4885             Zstep.Bind(wx.EVT_KILL_FOCUS,OnZstep)
     5602            Zstep = G2G.ValidatedTxtCtrl(drawOptions,drawingData,'Zstep',nDig=(10,2),min=0.01,max=1.0)
    48865603            ZstepSizer.Add(Zstep,0,WACV)
    48875604            slideSizer.Add(ZstepSizer)
     
    50115728            viewDir.Bind(wx.EVT_TEXT_ENTER,OnViewDir)
    50125729            viewDir.Bind(wx.EVT_KILL_FOCUS,OnViewDir)
    5013             G2frame.dataDisplay.viewDir = viewDir
     5730            G2frame.phaseDisplay.viewDir = viewDir
    50145731            lineSizer.Add(viewDir,0,WACV)
    50155732            showSizer.Add(lineSizer)
     
    50255742            viewPoint = wx.TextCtrl(drawOptions,value='%.3f %.3f %.3f'%(VP[0],VP[1],VP[2]),
    50265743                style=wx.TE_PROCESS_ENTER,size=wx.Size(140,20),name='viewPoint')
    5027             G2frame.dataDisplay.viewPoint = viewPoint
     5744            G2frame.phaseDisplay.viewPoint = viewPoint
    50285745            viewPoint.Bind(wx.EVT_TEXT_ENTER,OnViewPoint)
    50295746            viewPoint.Bind(wx.EVT_KILL_FOCUS,OnViewPoint)
     
    50545771        def RadSizer():
    50555772           
    5056             def OnSizeHatoms(event):
    5057                 event.Skip()
    5058                 try:
    5059                     value = max(0.1,min(1.2,float(sizeH.GetValue())))
    5060                 except ValueError:
    5061                     value = 0.5
    5062                 drawingData['sizeH'] = value
    5063                 sizeH.SetValue("%.2f"%(value))
     5773            def OnSizeHatoms(invalid,value,tc):
    50645774                G2plt.PlotStructure(G2frame,data)
    50655775               
    5066             def OnRadFactor(event):
    5067                 event.Skip()
    5068                 try:
    5069                     value = max(0.1,min(1.2,float(radFactor.GetValue())))
    5070                 except ValueError:
    5071                     value = 0.85
    5072                 drawingData['radiusFactor'] = value
    5073                 radFactor.SetValue("%.2f"%(value))
     5776            def OnRadFactor(invalid,value,tc):
    50745777                FindBondsDraw(data)
    50755778                G2plt.PlotStructure(G2frame,data)
     
    50775780            radSizer = wx.BoxSizer(wx.HORIZONTAL)
    50785781            radSizer.Add(wx.StaticText(drawOptions,-1,' Hydrogen radius, A:  '),0,WACV)
    5079 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    5080             sizeH = wx.TextCtrl(drawOptions,-1,value='%.2f'%(drawingData['sizeH']),size=wx.Size(60,20),style=wx.TE_PROCESS_ENTER)
    5081             sizeH.Bind(wx.EVT_TEXT_ENTER,OnSizeHatoms)
    5082             sizeH.Bind(wx.EVT_KILL_FOCUS,OnSizeHatoms)
     5782            sizeH = G2G.ValidatedTxtCtrl(drawOptions,drawingData,'sizeH',nDig=(10,2),min=0.1,max=1.2,size=wx.Size(60,20),OnLeave=OnSizeHatoms)
    50835783            radSizer.Add(sizeH,0,WACV)
    50845784   
    50855785            radSizer.Add(wx.StaticText(drawOptions,-1,' Bond search factor:  '),0,WACV)
    5086 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    5087             radFactor = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['radiusFactor']),size=wx.Size(60,20),style=wx.TE_PROCESS_ENTER)
    5088             radFactor.Bind(wx.EVT_TEXT_ENTER,OnRadFactor)
    5089             radFactor.Bind(wx.EVT_KILL_FOCUS,OnRadFactor)
     5786            radFactor = G2G.ValidatedTxtCtrl(drawOptions,drawingData,'radiusFactor',nDig=(10,2),min=0.1,max=1.2,size=wx.Size(60,20),OnLeave=OnRadFactor)
    50905787            radSizer.Add(radFactor,0,WACV)
    50915788            return radSizer
     
    51145811                G2plt.PlotStructure(G2frame,data)
    51155812               
    5116             def OnPhase(event):
    5117                 event.Skip()
    5118                 try:
    5119                     val = float(phase.GetValue())
    5120                 except ValueError:
    5121                     val = drawingData['Plane'][3]
    5122                 drawingData['Plane'][3] = val
    5123                 phase.SetValue('%.2f'%(val))
     5813            def OnPhase(invalid,value,tc):
    51245814                G2plt.PlotStructure(G2frame,data)
    51255815           
     
    51475837            planeSizer2 = wx.BoxSizer(wx.HORIZONTAL)
    51485838            planeSizer2.Add(wx.StaticText(drawOptions,label=' Phase shift (deg): '),0,WACV)
    5149 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    5150             phase = wx.TextCtrl(drawOptions,value='%.2f'%(drawingData['Plane'][3]),
    5151                 style=wx.TE_PROCESS_ENTER)
    5152             phase.Bind(wx.EVT_TEXT_ENTER,OnPhase)
    5153             phase.Bind(wx.EVT_KILL_FOCUS,OnPhase)
     5839            phase = G2G.ValidatedTxtCtrl(drawOptions,drawingData['Plane'],3,nDig=(10,2),OnLeave=OnPhase)
    51545840            planeSizer2.Add(phase,0,WACV)
    51555841            planeSizer2.Add(wx.StaticText(drawOptions,-1,' Plane color: '),0,WACV)
     
    51685854        drawingData = data['Drawing']
    51695855
    5170         G2frame.dataFrame.SetStatusText('')
     5856        G2frame.GetStatusBar().SetStatusText('',1)
    51715857        if drawOptions.GetSizer():
    51725858            drawOptions.GetSizer().Clear(True)
     
    51825868        mainSizer.Add((5,5),0)
    51835869        mainSizer.Add(PlaneSizer(),0,)
    5184         SetPhaseWindow(G2frame.dataFrame,drawOptions,mainSizer)
     5870        SetPhaseWindow(drawOptions,mainSizer)
    51855871
    51865872################################################################################
     
    52365922            textureData[angIndx[Obj.GetId()]][0] = Obj.GetValue()
    52375923           
    5238         def OnAngValue(event):
    5239             event.Skip()
    5240             Obj = event.GetEventObject()
    5241             try:
    5242                 value =  float(Obj.GetValue())
    5243             except ValueError:
    5244                 value = textureData[valIndx[Obj.GetId()]][1]
    5245             Obj.SetValue('%8.2f'%(value))
    5246             textureData[valIndx[Obj.GetId()]][1] = value
    5247            
    5248         def OnODFValue(event):
    5249             event.Skip()
    5250             Obj = event.GetEventObject()
    5251             try:
    5252                 value =  float(Obj.GetValue())
    5253             except ValueError:
    5254                 value = textureData['SH Coeff'][1][ODFIndx[Obj.GetId()]]
    5255             Obj.SetValue('%8.3f'%(value))
    5256             textureData['SH Coeff'][1][ODFIndx[Obj.GetId()]] = value
     5924        def OnODFValue(invalid,value,tc):
    52575925            wx.CallAfter(G2plt.PlotTexture,G2frame,data)
    52585926           
     
    54076075                wx.CallLater(100,UpdateTexture)
    54086076               
    5409             def OnshToler(event):
    5410                 event.Skip()
    5411                 try:
    5412                     value = float(shToler.GetValue())
    5413                     Penalty[1] = value
    5414                 except ValueError:
    5415                     pass
    5416                 shToler.SetValue('%.2f'%(Penalty[1]))
    5417            
    54186077            A = G2lat.cell2A(generalData['Cell'][1:7])
    54196078            hkls = G2lat.GenPfHKLs(10,SGData,A)   
     
    54266085            shPenalty.Add(hklList,0,WACV)
    54276086            shPenalty.Add(wx.StaticText(Texture,wx.ID_ANY,' Zero MRD tolerance: '),0,WACV)
    5428 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    5429             shToler = wx.TextCtrl(Texture,wx.ID_ANY,'%.2f'%(Penalty[1]),style=wx.TE_PROCESS_ENTER)
    5430             shToler.Bind(wx.EVT_TEXT_ENTER,OnshToler)
    5431             shToler.Bind(wx.EVT_KILL_FOCUS,OnshToler)
     6087            shToler = G2G.ValidatedTxtCtrl(Texture,Penalty,1,nDig=(10,2),min=0.001)
    54326088            shPenalty.Add(shToler,0,WACV)
    54336089            return shPenalty   
    54346090       
    54356091        # UpdateTexture executable starts here
    5436         #Texture.DestroyChildren() # bad, deletes scrollbars on Mac!
    5437         if Texture.GetSizer():
    5438             Texture.GetSizer().Clear(True)
    5439         G2frame.dataFrame.SetStatusText('')
     6092        if Texture.GetSizer(): Texture.GetSizer().Clear(True)
     6093        G2frame.GetStatusBar().SetStatusText('',1)
    54406094        generalData = data['General']       
    54416095        SGData = generalData['SGData']
     
    55076161            PTSizer.Add(wx.StaticText(Texture,-1,' Inverse pole figure XYZ: '),0,WACV)
    55086162            PX = textureData['PFxyz']
    5509 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    55106163            pfVal = wx.TextCtrl(Texture,-1,'%3.1f %3.1f %3.1f'%(PX[0],PX[1],PX[2]),style=wx.TE_PROCESS_ENTER)
    55116164        pfVal.Bind(wx.EVT_TEXT_ENTER,OnPFValue)
     
    55306183            mainSizer.Add((0,5),0)
    55316184            ODFSizer = wx.FlexGridSizer(0,8,2,2)
    5532             ODFIndx = {}
    55336185            ODFkeys = textureData['SH Coeff'][1].keys()
    55346186            ODFkeys.sort()
    55356187            for item in ODFkeys:
    55366188                ODFSizer.Add(wx.StaticText(Texture,-1,item),0,WACV)
    5537 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    5538                 ODFval = wx.TextCtrl(Texture,wx.ID_ANY,'%8.3f'%(textureData['SH Coeff'][1][item]),style=wx.TE_PROCESS_ENTER)
    5539                 ODFIndx[ODFval.GetId()] = item
    5540                 ODFval.Bind(wx.EVT_TEXT_ENTER,OnODFValue)
    5541                 ODFval.Bind(wx.EVT_KILL_FOCUS,OnODFValue)
     6189                ODFval = G2G.ValidatedTxtCtrl(Texture,textureData['SH Coeff'][1],item,nDig=(8,3),OnLeave=OnODFValue)
    55426190                ODFSizer.Add(ODFval,0,WACV)
    55436191            mainSizer.Add(ODFSizer,0,WACV)
     
    55486196        angSizer = wx.BoxSizer(wx.HORIZONTAL)
    55496197        angIndx = {}
    5550         valIndx = {}
    55516198        for item in ['Sample omega','Sample chi','Sample phi']:
    55526199            angRef = wx.CheckBox(Texture,-1,label=item+': ')
     
    55556202            angRef.Bind(wx.EVT_CHECKBOX, OnAngRef)
    55566203            angSizer.Add(angRef,0,WACV)
    5557 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    5558             angVal = wx.TextCtrl(Texture,wx.ID_ANY,'%8.2f'%(textureData[item][1]),style=wx.TE_PROCESS_ENTER)
    5559             valIndx[angVal.GetId()] = item
    5560             angVal.Bind(wx.EVT_TEXT_ENTER,OnAngValue)
    5561             angVal.Bind(wx.EVT_KILL_FOCUS,OnAngValue)
     6204            angVal = G2G.ValidatedTxtCtrl(Texture,textureData[item],1,nDig=(8,2))
    55626205            angSizer.Add(angVal,0,WACV|wx.LEFT,5)
    55636206        mainSizer.Add(angSizer,0,WACV|wx.LEFT,5)
    55646207#        mainSizer.Add(SHPenalty(textureData['Penalty']),0,WACV|wx.LEFT,5)  for future
    5565         SetPhaseWindow(G2frame.dataFrame,Texture,mainSizer)
     6208        SetPhaseWindow(Texture,mainSizer)
    55666209
    55676210################################################################################
     
    55726215        keyList = data['Histograms'].keys()
    55736216        TextList = []
    5574         if not G2frame.PatternTree.GetCount():
     6217        if not G2frame.GPXtree.GetCount():
    55756218            return
    55766219       
    5577         item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     6220        item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    55786221        while item:
    5579             name = G2frame.PatternTree.GetItemText(item)
     6222            name = G2frame.GPXtree.GetItemText(item)
    55806223            if name not in keyList and 'HKLF' in name:
    55816224                TextList.append(name)
    5582             item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)                       
     6225            item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)                       
    55836226            if not TextList:
    5584                 G2G.G2MessageBox(G2frame.dataFrame,'No reflections')
     6227                G2G.G2MessageBox(G2frame,'No reflections')
    55856228                return
    55866229        dlg = G2G.G2MultiChoiceDialog(G2frame, 'Select reflection sets to use',
     
    56166259        for i in result:
    56176260            histoName = TextList[i]
    5618             Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
    5619             refDict,reflData = G2frame.PatternTree.GetItemPyData(Id)
     6261            Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
     6262            refDict,reflData = G2frame.GPXtree.GetItemPyData(Id)
    56206263            data['Histograms'][histoName] = {'Histogram':histoName,'Show':False,'Scale':[1.0,True],
    56216264                'Babinet':{'BabA':[0.0,False],'BabU':[0.0,False]},
     
    56376280       
    56386281    def OnDataUse(event):
    5639         hist = G2frame.hist
     6282#        hist = G2frame.hist
    56406283        if data['Histograms']:
    5641             dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Use histograms',
    5642                 'Use which histograms?',G2frame.dataFrame.HistsInPhase)
     6284            dlg = G2G.G2MultiChoiceDialog(G2frame, 'Use histograms',
     6285                'Use which histograms?',G2frame.dataWindow.HistsInPhase)
    56436286            try:
    56446287                if dlg.ShowModal() == wx.ID_OK:
    56456288                    sel = dlg.GetSelections()
    5646                     for id,item in enumerate(G2frame.dataFrame.HistsInPhase):
     6289                    for id,item in enumerate(G2frame.dataWindow.HistsInPhase):
    56476290                        if id in sel:
    56486291                            data['Histograms'][item]['Use'] = True
     
    56566299    # def UpdateHKLFdata(histoName):
    56576300    #     generalData = data['General']
    5658     #     Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
    5659     #     refDict,reflData = G2frame.PatternTree.GetItemPyData(Id)
     6301    #     Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
     6302    #     refDict,reflData = G2frame.GPXtree.GetItemPyData(Id)
    56606303    #     SGData = generalData['SGData']
    56616304    #     Cell = generalData['Cell'][1:7]
     
    56756318    def UpdateHKLFdata(histoName):
    56766319        generalData = data['General']
    5677         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
    5678         refDict,reflData = G2frame.PatternTree.GetItemPyData(Id)
     6320        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
     6321        refDict,reflData = G2frame.GPXtree.GetItemPyData(Id)
    56796322        SGData = generalData['SGData']
    56806323        Cell = generalData['Cell'][1:7]
     
    56876330    def OnDataCopy(event):
    56886331        hist = G2frame.hist
    5689         keyList = G2frame.dataFrame.HistsInPhase[:]
     6332        keyList = G2frame.dataWindow.HistsInPhase[:]
    56906333        if hist in keyList: keyList.remove(hist)
    56916334        if not keyList:
    5692             G2G.G2MessageBox(G2frame.dataFrame,'No histograms to copy to')
     6335            G2G.G2MessageBox(G2frame,'No histograms to copy to')
    56936336            return
    56946337        sourceDict = data['Histograms'][hist]
     
    57006343        for name in copyNames:
    57016344            copyDict[name] = copy.deepcopy(sourceDict[name])        #force copy
    5702         dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,
    5703                 u'Copy phase/histogram parameters\nfrom '+hist[5:][:35],
     6345        dlg = G2G.G2MultiChoiceDialog(G2frame,u'Copy phase/histogram parameters\nfrom '+hist[5:][:35],
    57046346                'Copy phase/hist parameters', keyList)
    57056347        try:
     
    57436385                for bab in babNames:
    57446386                    copyDict[name][bab] = sourceDict[name][bab][1]                       
    5745         keyList = G2frame.dataFrame.HistsInPhase[:]
     6387        keyList = G2frame.dataWindow.HistsInPhase[:]
    57466388        if hist in keyList: keyList.remove(hist)
    57476389        if not keyList:
    5748             G2G.G2MessageBox(G2frame.dataFrame,'No histograms to copy to')
     6390            G2G.G2MessageBox(G2frame,'No histograms to copy to')
    57496391            return
    5750         dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,
    5751                 u'Copy phase/histogram flags\nfrom '+hist[5:][:35],
     6392        dlg = G2G.G2MultiChoiceDialog(G2frame,u'Copy phase/histogram flags\nfrom '+hist[5:][:35],
    57526393                'Copy phase/hist flags', keyList)
    57536394        try:
     
    57896430        hist = G2frame.hist
    57906431        sourceDict = data['Histograms'][hist]
    5791         keyList = G2frame.dataFrame.HistsInPhase[:]
     6432        keyList = G2frame.dataWindow.HistsInPhase[:]
    57926433        if hist in keyList: keyList.remove(hist)
    57936434        if not keyList:
    5794             G2G.G2MessageBox(G2frame.dataFrame,'No histograms to copy to')
     6435            G2G.G2MessageBox(G2frame,'No histograms to copy to')
    57956436            return
    57966437        copyDict = {}
     
    57996440        else:  #PWDR 
    58006441            copyNames = ['Scale','Pref.Ori.','Size','Mustrain','HStrain','Extinction','Babinet','LeBail']
    5801         dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,'Select which parameters to copy',
     6442        dlg = G2G.G2MultiChoiceDialog(G2frame,'Select which parameters to copy',
    58026443            'Select phase data parameters', copyNames)
    58036444        selectedItems = []
     
    58116452        for parm in selectedItems:
    58126453            copyDict[parm] = copy.deepcopy(sourceDict[parm])
    5813         dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame,
    5814                         u'Copy selected phase/histogram parameters\nfrom '+hist[5:][:35],
    5815                         'Copy selected phase/hist parameters', keyList)
     6454        dlg = G2G.G2MultiChoiceDialog(G2frame,u'Copy selected phase/histogram parameters\nfrom '+hist[5:][:35],
     6455            'Copy selected phase/hist parameters', keyList)
    58166456        try:
    58176457            if dlg.ShowModal() == wx.ID_OK:
     
    58296469        keyList = data['Histograms'].keys()
    58306470        TextList = []
    5831         if G2frame.PatternTree.GetCount():
    5832             item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
     6471        if G2frame.GPXtree.GetCount():
     6472            item, cookie = G2frame.GPXtree.GetFirstChild(G2frame.root)
    58336473            while item:
    5834                 name = G2frame.PatternTree.GetItemText(item)
     6474                name = G2frame.GPXtree.GetItemText(item)
    58356475                if name not in keyList and 'PWDR' in name:
    58366476                    TextList.append(name)
    5837                 item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
     6477                item, cookie = G2frame.GPXtree.GetNextChild(G2frame.root, cookie)
    58386478            if not TextList:
    5839                 G2G.G2MessageBox(G2frame.dataFrame,'No histograms')
     6479                G2G.G2MessageBox(G2frame,'No histograms')
    58406480                return
    58416481            dlg = G2G.G2MultiChoiceDialog(G2frame, 'Select powder histograms to use',
    5842                     'Use data',TextList)
     6482                'Use data',TextList)
    58436483            try:
    58446484                if dlg.ShowModal() == wx.ID_OK:
     
    58486488                        newList = TextList[1:]
    58496489                    for histoName in newList:
    5850                         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,histoName)
     6490                        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,histoName)
    58516491                        data['Histograms'][histoName] = {'Histogram':histoName,'Show':False,'LeBail':False,'newLeBail':True,
    58526492                            'Scale':[1.0,False],'Pref.Ori.':['MD',1.0,False,[0,0,1],0,{},['',],0.1],
     
    58576497                            'HStrain':[NDij*[0.0,],NDij*[False,]],                         
    58586498                            'Extinction':[0.0,False],'Babinet':{'BabA':[0.0,False],'BabU':[0.0,False]}}
    5859                         refList = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Reflection Lists'))
     6499                        refList = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Reflection Lists'))
    58606500                        refList[generalData['Name']] = {}                       
    58616501                    wx.CallAfter(G2ddG.UpdateDData,G2frame,DData,data)
     
    58646504               
    58656505    def OnDataDelete(event):
    5866         if G2frame.dataFrame.HistsInPhase:
     6506        if G2frame.dataWindow.HistsInPhase:
    58676507            DelList = []
    5868             dlg = G2G.G2MultiChoiceDialog(G2frame.dataFrame, 'Delete histogram',
    5869                 'Which histogram to delete from this phase?',G2frame.dataFrame.HistsInPhase)
     6508            dlg = G2G.G2MultiChoiceDialog(G2frame, 'Delete histogram',
     6509                'Which histogram to delete from this phase?',G2frame.dataWindow.HistsInPhase)
    58706510            try:
    58716511                if dlg.ShowModal() == wx.ID_OK:
    5872                     DelList = [G2frame.dataFrame.HistsInPhase[i] for i in dlg.GetSelections()]
     6512                    DelList = [G2frame.dataWindow.HistsInPhase[i] for i in dlg.GetSelections()]
    58736513                    for i in DelList:
    58746514                        del data['Histograms'][i]
     
    59086548        def ThermDataSizer(RBObj,rbType):
    59096549           
    5910             def OnThermval(event):
    5911                 event.Skip()
    5912                 Obj = event.GetEventObject()
    5913                 item = Indx[Obj.GetId()]
    5914                 try:
    5915                     val = float(Obj.GetValue())
    5916                     RBObj['ThermalMotion'][1][item] = val
    5917                 except ValueError:
    5918                     pass
    5919                 Obj.SetValue('%8.4f'%(RBObj['ThermalMotion'][1][item]))
     6550            def OnThermval(invalid,value,tc):
    59206551                Cart = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,rbType)[1]
    59216552                Uout = G2mth.UpdateRBUIJ(Bmat,Cart,RBObj)
     
    59456576            for i,name in enumerate(names):
    59466577                thermSizer.Add(wx.StaticText(RigidBodies,-1,name+': '),0,WACV)
    5947 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    5948                 thermVal = wx.TextCtrl(RigidBodies,-1,value='%8.4f'%(model[1][i]),
    5949                     style=wx.TE_PROCESS_ENTER)
    5950                 thermVal.Bind(wx.EVT_TEXT_ENTER,OnThermval)
    5951                 thermVal.Bind(wx.EVT_KILL_FOCUS,OnThermval)
    5952                 Indx[thermVal.GetId()] = i
     6578                thermVal = G2G.ValidatedTxtCtrl(RigidBodies,model[1],i,nDig=(8,4),OnLeave=OnThermval)
    59536579                thermSizer.Add(thermVal)
    59546580                Tcheck = wx.CheckBox(RigidBodies,-1,'Refine?')
     
    59676593                RBObj['Orient'][1] = Qcheck.GetValue()
    59686594               
    5969             def OnOrigX(event):
    5970                 event.Skip()
    5971                 Obj = event.GetEventObject()
    5972                 item = Indx[Obj.GetId()]
    5973                 try:
    5974                     val = float(Obj.GetValue())
    5975                     RBObj['Orig'][0][item] = val
    5976                     Obj.SetValue('%8.5f'%(val))
    5977                     newXYZ = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,rbType)[0]
    5978                     for i,id in enumerate(RBObj['Ids']):
    5979                         data['Atoms'][AtLookUp[id]][cx:cx+3] = newXYZ[i]
    5980                     data['Drawing']['Atoms'] = []
    5981                     UpdateDrawAtoms(atomStyle)
    5982                     G2plt.PlotStructure(G2frame,data)
    5983                 except ValueError:
    5984                     pass
     6595            def OnOrigX(invalid,value,tc):
     6596                newXYZ = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,rbType)[0]
     6597                for i,id in enumerate(RBObj['Ids']):
     6598                    data['Atoms'][AtLookUp[id]][cx:cx+3] = newXYZ[i]
     6599                data['Drawing']['Atoms'] = []
     6600                UpdateDrawAtoms(atomStyle)
     6601                G2plt.PlotStructure(G2frame,data)
    59856602               
    59866603            def OnOrien(event):
     
    60186635            topSizer.Add(wx.StaticText(RigidBodies,-1,'Origin x,y,z:'),0,WACV)
    60196636            for ix,x in enumerate(Orig):
    6020 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    6021                 origX = wx.TextCtrl(RigidBodies,-1,value='%8.5f'%(x),style=wx.TE_PROCESS_ENTER)
    6022                 origX.Bind(wx.EVT_TEXT_ENTER,OnOrigX)
    6023                 origX.Bind(wx.EVT_KILL_FOCUS,OnOrigX)
    6024                 Indx[origX.GetId()] = ix
     6637                origX = G2G.ValidatedTxtCtrl(RigidBodies,Orig,ix,nDig=(8,5),OnLeave=OnOrigX)
    60256638                topSizer.Add(origX,0,WACV)
    60266639            topSizer.Add((5,0),)
     
    60316644            topSizer.Add(wx.StaticText(RigidBodies,-1,'Rotation angle, vector:'),0,WACV)
    60326645            for ix,x in enumerate(Orien):
    6033 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    60346646                orien = wx.TextCtrl(RigidBodies,-1,value='%8.4f'%(x),style=wx.TE_PROCESS_ENTER)
    60356647                orien.Bind(wx.EVT_TEXT_ENTER,OnOrien)
     
    60516663                RBObj['Torsions'][item][1] = Obj.GetValue()               
    60526664               
    6053             def OnTorsion(event):
    6054                 event.Skip()
    6055                 Obj = event.GetEventObject()
    6056                 item = Indx[Obj.GetId()]
    6057                 try:
    6058                     val = float(Obj.GetValue())
    6059                     RBObj['Torsions'][item][0] = val
    6060                     newXYZ = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,'Residue')[0]
    6061                     for i,id in enumerate(RBObj['Ids']):
    6062                         data['Atoms'][AtLookUp[id]][cx:cx+3] = newXYZ[i]
    6063                 except ValueError:
    6064                     pass
    6065                 Obj.SetValue("%10.3f"%(RBObj['Torsions'][item][0]))               
     6665            def OnTorsion(invalid,value,tc):
     6666                newXYZ = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,'Residue')[0]
     6667                for i,id in enumerate(RBObj['Ids']):
     6668                    data['Atoms'][AtLookUp[id]][cx:cx+3] = newXYZ[i]
    60666669                data['Drawing']['Atoms'] = []
    60676670                UpdateDrawAtoms(atomStyle)
     
    60966699            for itors,tors in enumerate(RBObj['Torsions']):
    60976700                torSizer.Add(wx.StaticText(RigidBodies,-1,'Torsion '+'%d'%(itors)),0,WACV)
    6098 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    6099                 torsTxt = wx.TextCtrl(RigidBodies,-1,value='%.3f'%(tors[0]),style=wx.TE_PROCESS_ENTER)
    6100                 torsTxt.Bind(wx.EVT_TEXT_ENTER,OnTorsion)
    6101                 torsTxt.Bind(wx.EVT_KILL_FOCUS,OnTorsion)
    6102                 Indx[torsTxt.GetId()] = itors
     6701                torsTxt = G2G.ValidatedTxtCtrl(RigidBodies,RBObj['Torsions'][itors],0,nDig=(10,3),OnLeave=OnTorsion)
    61036702                torSizer.Add(torsTxt)
    61046703                torCheck = wx.CheckBox(RigidBodies,-1,'Refine?')
     
    61236722           
    61246723        def VecrbSizer(RBObj):
    6125             G2frame.dataFrame.SetStatusText('NB: Rotation vector is in crystallographic space')
     6724            G2frame.GetStatusBar().SetStatusText('NB: Rotation vector is in crystallographic space',1)
    61266725                   
    61276726            def OnDelVecRB(event):
     
    61776776            mainSizer.Add(G2frame.bottomSizer)
    61786777            mainSizer.Layout()
    6179             G2frame.dataFrame.Refresh()
     6778            G2frame.dataWindow.Refresh()
    61806779            RigidBodies.SetVirtualSize(mainSizer.GetMinSize())
    61816780            RigidBodies.Scroll(0,Scroll)
    6182             G2frame.dataFrame.SendSizeEvent()
     6781            G2frame.dataWindow.SendSizeEvent()
    61836782            G2plt.PlotStructure(G2frame,data)
    61846783            wx.CallAfter(oldFocus.SetFocus)
     
    61866785        # FillRigidBodyGrid executable code starts here
    61876786        if refresh:
    6188             #RigidBodies.DestroyChildren() # bad, deletes scrollbars on Mac!
    6189             if RigidBodies.GetSizer():
    6190                 RigidBodies.GetSizer().Clear(True)
     6787            if RigidBodies.GetSizer(): RigidBodies.GetSizer().Clear(True)
    61916788        general = data['General']
    61926789        cx,ct,cs,cia = general['AtomPtrs']
    61936790        AtLookUp = G2mth.FillAtomLookUp(data['Atoms'],cia+8)
    61946791        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
    6195         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies')
     6792        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies')
    61966793        if not Id:
    61976794            return
    6198         RBData = G2frame.PatternTree.GetItemPyData(Id)
     6795        RBData = G2frame.GPXtree.GetItemPyData(Id)
    61996796        Indx = {}
    62006797        atomStyle = 'balls & sticks'
    62016798        if 'macro' in general['Type']:
    62026799            atomStyle = 'sticks'
    6203         G2frame.dataFrame.SetStatusText('')
     6800        G2frame.GetStatusBar().SetStatusText('',1)
    62046801        mainSizer = wx.BoxSizer(wx.VERTICAL)
    62056802        if not data['RBModels']:
     
    62266823            G2frame.bottomSizer.Add(ResrbSizer(rbObj))
    62276824            mainSizer.Add(G2frame.bottomSizer)
    6228             G2frame.dataFrame.SetStatusText('NB: Rotation vector is in crystallographic space')
     6825            G2frame.GetStatusBar().SetStatusText('NB: Rotation vector is in crystallographic space',1)
    62296826            G2plt.PlotStructure(G2frame,data)
    62306827        if 'Vector' in data['RBModels'] and len(data['RBModels']['Vector']):
     
    62356832                mainSizer.Add(VecrbSizer(RBObj))
    62366833
    6237         SetPhaseWindow(G2frame.dataFrame,RigidBodies,mainSizer)
     6834        SetPhaseWindow(RigidBodies,mainSizer)
    62386835
    62396836    def OnRBCopyParms(event):
     
    62696866    def OnRBAssign(event):
    62706867       
    6271         G2frame.dataFrame.SetStatusText('')
    6272         RBData = G2frame.PatternTree.GetItemPyData(   
    6273             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     6868        G2frame.GetStatusBar().SetStatusText('',1)
     6869        RBData = G2frame.GPXtree.GetItemPyData(   
     6870            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    62746871        rbNames = {}
    62756872        for rbVec in RBData['Vector']:
     
    64567053                val = float(Obj.GetValue())/10.
    64577054                Tors[0] = val
    6458                 ang.SetValue('%8.3f'%(val))
     7055                ang.SetValue(val)
    64597056                G2plt.PlotStructure(G2frame,data)
    64607057
     
    64627059                G2plt.PlotStructure(G2frame,data)
    64637060                   
    6464             #RigidBodies.DestroyChildren() # bad, deletes scrollbars on Mac!
    6465             if RigidBodies.GetSizer():
    6466                 RigidBodies.GetSizer().Clear(True)
     7061            if RigidBodies.GetSizer(): RigidBodies.GetSizer().Clear(True)
    64677062            mainSizer = wx.BoxSizer(wx.VERTICAL)
    64687063            mainSizer.Add((5,5),0)
     
    65657160            btnSizer.Add((20,20),1)
    65667161            mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
    6567             SetPhaseWindow(G2frame.dataFrame,RigidBodies,mainSizer)
     7162            SetPhaseWindow(RigidBodies,mainSizer)
    65687163        wx.CallAfter(Draw)
    65697164       
    65707165    def OnAutoFindResRB(event):
    6571         RBData = G2frame.PatternTree.GetItemPyData(   
    6572             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     7166        RBData = G2frame.GPXtree.GetItemPyData(   
     7167            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    65737168        rbKeys = RBData['Residue'].keys()
    65747169        rbKeys.remove('AtInfo')
     
    66577252        data['RBModels']['Residue'] = []
    66587253        data['RBModels']['Vector'] = []
    6659         RBData = G2frame.PatternTree.GetItemPyData(   
    6660             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     7254        RBData = G2frame.GPXtree.GetItemPyData(   
     7255            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    66617256        for RBType in ['Vector','Residue']:
    66627257            for rbId in RBData[RBType]:
     
    67687363            model[item][1][ix] = Obj.GetValue()
    67697364           
    6770         def OnPosVal(event):
    6771             event.Skip()
    6772             Obj = event.GetEventObject()
    6773             model,item,ix = Indx[Obj.GetId()]
    6774             try:
    6775                 model[item][0][ix] = float(Obj.GetValue())
    6776             except ValueError:
    6777                 pass
    6778             Obj.SetValue("%.4f"%(model[item][0][ix]))
     7365        def OnPosVal(invalid,value,tc):
    67797366            G2plt.PlotStructure(G2frame,data)
    67807367           
     
    68037390                Indx[posRef.GetId()] = [model,'Pos',ix]
    68047391                atomsizer.Add(posRef,0,WACV)
    6805 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    6806                 posVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(model['Pos'][0][ix]),style=wx.TE_PROCESS_ENTER)
    6807                 posVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
    6808                 posVal.Bind(wx.EVT_KILL_FOCUS,OnPosVal)
    6809                 Indx[posVal.GetId()] = [model,'Pos',ix]
     7392                posVal = G2G.ValidatedTxtCtrl(G2frame.MCSA,model['Pos'][0],ix,nDig=(10,4),OnLeave=OnPosVal)
    68107393                atomsizer.Add(posVal,0,WACV)
    68117394            atomsizer.Add((5,5),0)
     
    68587441                    ObjV.SetValue('%.3f %.3f %.3f'%(V[0],V[1],V[2]))
    68597442                G2plt.PlotStructure(G2frame,data)
    6860 #                UpdateMCSA()
    68617443
    68627444            def OnMolCent(event):
     
    68777459                Indx[posRef.GetId()] = [model,'Pos',ix]
    68787460                rbsizer1.Add(posRef,0,WACV)
    6879 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    6880                 posVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(model['Pos'][0][ix]),style=wx.TE_PROCESS_ENTER)
    6881                 posVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
    6882                 posVal.Bind(wx.EVT_KILL_FOCUS,OnPosVal)
    6883                 Indx[posVal.GetId()] = [model,'Pos',ix]
     7461                posVal = G2G.ValidatedTxtCtrl(G2frame.MCSA,model['Pos'][0],ix,nDig=(10,4),OnLeave=OnPosVal)
    68847462                rbsizer1.Add(posVal,0,WACV)
    68857463            molcent = wx.CheckBox(G2frame.MCSA,-1,label=' Use mol. center? ')
     
    69007478            Ori = model['Ori'][0]
    69017479            rbsizer2.Add(wx.StaticText(G2frame.MCSA,-1,'Oa: '),0,WACV)
    6902 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    69037480            angVal = wx.TextCtrl(G2frame.MCSA,-1,'%.5f'%(Ori[0]),style=wx.TE_PROCESS_ENTER)
    69047481            angVal.Bind(wx.EVT_TEXT_ENTER,OnOriVal)
     
    69487525                    Indx[torRef.GetId()] = [model,'Tor',it]
    69497526                    rbsizer3.Add(torRef,0,WACV)
    6950 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    6951                     torVal = wx.TextCtrl(G2frame.MCSA,-1,'%.4f'%(tor),style=wx.TE_PROCESS_ENTER)
    6952                     torVal.Bind(wx.EVT_TEXT_ENTER,OnPosVal)
    6953                     torVal.Bind(wx.EVT_KILL_FOCUS,OnPosVal)
    6954                     Indx[torVal.GetId()] = [model,'Tor',it]
     7527                    torVal = G2G.ValidatedTxtCtrl(G2frame.MCSA,model['Tor'][0],it,nDig=(10,4),OnLeave=OnPosVal)
    69557528                    rbsizer3.Add(torVal,0,WACV)
    69567529                    rbsizer3.Add(wx.StaticText(G2frame.MCSA,-1,' Range: '),0,WACV)
     
    69697542            def OnPORef(event):
    69707543                POData['Coef'][1] = poRef.GetValue()
    6971                
    6972             def OnPOVal(event):
    6973                 event.Skip()
    6974                 try:
    6975                     mdVal = float(poVal.GetValue())
    6976                     if mdVal > 0:
    6977                         POData['Coef'][0] = mdVal
    6978                 except ValueError:
    6979                     pass
    6980                 poVal.SetValue("%.3f"%(POData['Coef'][0]))
    69817544               
    69827545            def OnPORange(event):
     
    70127575            poRef.Bind(wx.EVT_CHECKBOX,OnPORef)
    70137576            poSizer.Add(poRef,0,WACV)
    7014 #        azmthOff = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'azmthOff',nDig=(10,2),typeHint=float,OnLeave=OnAzmthOff)
    7015             poVal = wx.TextCtrl(G2frame.MCSA,-1,'%.3f'%(POData['Coef'][0]),style=wx.TE_PROCESS_ENTER)
    7016             poVal.Bind(wx.EVT_TEXT_ENTER,OnPOVal)
    7017             poVal.Bind(wx.EVT_KILL_FOCUS,OnPOVal)
     7577            poVal = G2G.ValidatedTxtCtrl(G2frame.MCSA,POData['Coef'],0,nDig=(10,3),min=0.)
    70187578            poSizer.Add(poVal,0,WACV)
    70197579            poSizer.Add(wx.StaticText(G2frame.MCSA,-1,' Range: '),0,WACV)
     
    70447604                    Results[r][0] = True
    70457605                    resultsTable.SetValue(r,0,True)
     7606#                    resultsGrid.ForceRefresh()
    70467607                    G2plt.PlotStructure(G2frame,data)
    70477608                    wx.CallAfter(UpdateMCSA,G2frame.MCSA.GetScrollPos(wx.VERTICAL))
    7048                     resultsGrid.ForceRefresh()
    70497609                elif c == 1:
    70507610                    if Results[r][1]:
     
    70727632            resultsGrid.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, OnCellChange)
    70737633            resultsGrid.AutoSizeColumns(True)
     7634            resultsGrid.SetMargins(0,0)
    70747635            for r in range(resultsGrid.GetNumberRows()):
    70757636                for c in range(resultsGrid.GetNumberCols()):
     
    70787639                    else:
    70797640                        resultsGrid.SetCellStyle(r,c,VERY_LIGHT_GREY,True)
    7080             resultsSizer.Add(resultsGrid)
     7641#            resultsGrid.SetScrollRate(0,0)
     7642            resultsSizer.Add(resultsGrid,0,wx.EXPAND)
    70817643            return resultsSizer
    70827644       
    70837645        # UpdateMCSA executable code starts here
    7084         #G2frame.MCSA.DestroyChildren() # bad, deletes scrollbars on Mac!
    7085         if G2frame.MCSA.GetSizer():
    7086             G2frame.MCSA.GetSizer().Clear(True)
     7646        if G2frame.MCSA.GetSizer(): G2frame.MCSA.GetSizer().Clear(True)
    70877647        if not data['Drawing']:                 #if new drawing - no drawing data!
    70887648            SetupDrawingData()
    70897649        general = data['General']
    70907650        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
    7091         Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies')
     7651        Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies')
    70927652        if not Id:
    70937653            return
    7094         RBData = G2frame.PatternTree.GetItemPyData(Id)
     7654        RBData = G2frame.GPXtree.GetItemPyData(Id)
    70957655        Indx = {}
    70967656#        atomStyle = 'balls & sticks'
    70977657#        if 'macro' in general['Type']:
    70987658#            atomStyle = 'sticks'
    7099         G2frame.dataFrame.SetStatusText('')
     7659        G2frame.GetStatusBar().SetStatusText('',1)
    71007660        mainSizer = wx.BoxSizer(wx.VERTICAL)
    71017661        if not data['MCSA']['Models']:
     
    71307690            mainSizer.Add((5,5),0)
    71317691            Results = data['MCSA']['Results']
    7132             mainSizer.Add(ResultsSizer(Results))
    7133            
    7134         SetPhaseWindow(G2frame.dataFrame,G2frame.MCSA,mainSizer)
     7692            mainSizer.Add(ResultsSizer(Results),0,wx.EXPAND)
     7693           
     7694        SetPhaseWindow(G2frame.MCSA,mainSizer)
    71357695       
    71367696    def SetSolution(result,Models):
     
    71727732        covData = {}
    71737733        if 'PWDR' in reflName:
    7174             PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
    7175             reflSets = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Reflection Lists'))
     7734            PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
     7735            reflSets = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Reflection Lists'))
    71767736            try:        #patch for old reflection data
    71777737                reflData = reflSets[phaseName]['RefList']
     
    71807740            reflType = 'PWDR'
    71817741        elif 'HKLF' in reflName:
    7182             PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root, reflName)
     7742            PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, reflName)
    71837743            try:
    7184                 reflData = G2frame.PatternTree.GetItemPyData(PatternId)[1]['RefList']
     7744                reflData = G2frame.GPXtree.GetItemPyData(PatternId)[1]['RefList']
    71857745            except TypeError:
    7186                 reflData = G2frame.PatternTree.GetItemPyData(PatternId)[1]
     7746                reflData = G2frame.GPXtree.GetItemPyData(PatternId)[1]
    71877747            reflType = 'HKLF'
    71887748        elif reflName == 'Pawley reflections':
    71897749            reflData = data['Pawley ref']
    7190             covData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.root, 'Covariance'))
     7750            covData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Covariance'))
    71917751            reflType = 'Pawley'
    71927752        else:
     
    71957755        print 'MC/SA run:'
    71967756        print 'Reflection type:',reflType,' Total No. reflections: ',len(reflData)
    7197         RBdata = G2frame.PatternTree.GetItemPyData(   
    7198             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     7757        RBdata = G2frame.GPXtree.GetItemPyData(   
     7758            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    71997759        MCSAmodels = MCSAdata['Models']
    72007760        if not len(MCSAmodels):
     
    72187778                for i in range(nCyc):
    72197779                    pgbar.SetTitle('MC/SA run '+str(i+1)+' of '+str(nCyc))
    7220                     Result,tsum = G2mth.mcsaSearch(data,RBdata,reflType,reflData,covData,pgbar)
     7780                    Result,tsum,nsum,rcov = G2mth.mcsaSearch(data,RBdata,reflType,reflData,covData,pgbar)
    72217781                    MCSAdata['Results'].append(Result)
    7222                     print ' MC/SA run completed: %d residual: %.3f%% SFcalc time: %.2fs'%(i,100*Result[2],tsum)
     7782                    print ' MC/SA run completed: %d residual: %.3f%% SFcalc time: %.2fs Nsfcalc: %d'%(i,100*Result[2],tsum,nsum)
    72237783                    tsf += tsum
    7224                 print ' Structure factor time: %.2f'%(tsf)
     7784                print ' Total SF time: %.2fs'%(tsf)
     7785                XY = np.mgrid[0:rcov.shape[0],0:rcov.shape[1]]
     7786                G2plt.PlotXYZ(G2frame,XY,rcov,labelX='ref No.',labelY='ref No.',newPlot=False,
     7787                    Title='Reflection covariance matrix',zrange=[-1.,1.],color='RdYlGn')
    72257788            else:
    7226                 MCSAdata['Results'] = G2mth.MPmcsaSearch(nCyc,data,RBdata,reflType,reflData,covData)
    7227             print ' MC/SA run time: %.2f'%(time.time()-time1)
     7789                nprocs = GSASIIpath.GetConfigValue('Multiprocessing_cores')
     7790                Results,sftime,numsf = G2mth.MPmcsaSearch(nCyc,data,RBdata,reflType,reflData,covData,nprocs)
     7791                MCSAdata['Results'] += Results   #+= to  any saved ones
     7792                print ' Total SF time: %.2fs MC/SA run time: %.2fs Nsfcalc: %d'%(sftime,time.time()-time1,numsf)
    72287793        finally:
    72297794            if process == 'single':
     
    72327797        MCSAdata['Results'][0][0] = True
    72337798        SetSolution(MCSAdata['Results'][0],data['MCSA']['Models'])
    7234         G2frame.dataDisplay.SetFocus()
    7235         Page = G2frame.dataDisplay.FindPage('MC/SA')
    7236         G2frame.dataDisplay.SetSelection(Page)
     7799        G2frame.phaseDisplay.SetFocus()
     7800        Page = G2frame.phaseDisplay.FindPage('MC/SA')
     7801        G2frame.phaseDisplay.SetSelection(Page)
    72377802        G2plt.PlotStructure(G2frame,data)
    72387803        wx.CallAfter(UpdateMCSA)
     
    72547819       
    72557820    def OnMCSAaddRB(event):
    7256         rbData = G2frame.PatternTree.GetItemPyData(   
    7257             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     7821        rbData = G2frame.GPXtree.GetItemPyData(   
     7822            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
    72587823        rbNames = {}
    72597824        for rbVec in rbData['Vector']:
     
    72667831            print '**** ERROR - no rigid bodies defined ****'
    72677832            return
    7268         dlg = wx.SingleChoiceDialog(G2frame.dataFrame,'Select','Rigid body',rbNames.keys())
     7833        dlg = wx.SingleChoiceDialog(G2frame,'Select','Rigid body',rbNames.keys())
    72697834        if dlg.ShowModal() == wx.ID_OK:
    72707835            sel = dlg.GetSelection()
     
    72847849        data['MCSA']['rbData'] = rbData
    72857850        data['MCSA']['AtInfo'].update(rbData[rbType]['AtInfo'])
    7286         G2plt.PlotStructure(G2frame,data)
    72877851        UpdateMCSA()
     7852        wx.CallAfter(G2plt.PlotStructure,G2frame,data)
    72887853       
    72897854    def OnMCSAclear(event):
     
    73387903           
    73397904        # FillPawleyReflectionsGrid executable starts here
    7340         G2frame.dataFrame.SetStatusText('To delete a Pawley reflection: select row & press Delete')                       
     7905        G2frame.GetStatusBar().SetStatusText('To delete a Pawley reflection: select row & press Delete',1)                       
    73417906        generalData = data['General']
    73427907        if 'Pawley ref' in data:
     
    73657930            G2frame.PawleyRefl.SetMargins(0,0)
    73667931            G2frame.PawleyRefl.AutoSizeColumns(False)
    7367             SetPhaseWindow(G2frame.dataFrame,G2frame.PawleyRefl,size=[450,300])
     7932            SetPhaseWindow(G2frame.PawleyRefl)
    73687933                   
    73697934    def OnPawleySet(event):
     
    73777942        generalData = data['General']
    73787943        startDmin = generalData['Pawley dmin']
    7379         General = wx.Dialog(G2frame.dataFrame,wx.ID_ANY,'Set Pawley Parameters',
     7944        genDlg = wx.Dialog(G2frame,wx.ID_ANY,'Set Pawley Parameters',
    73807945                        style=wx.DEFAULT_DIALOG_STYLE)
    73817946        mainSizer = wx.BoxSizer(wx.VERTICAL)
    7382         mainSizer.Add(wx.StaticText(General,wx.ID_ANY,
     7947        mainSizer.Add(wx.StaticText(genDlg,wx.ID_ANY,
    73837948                                    'Set Pawley Extraction Parameters for phase '+
    73847949                                    generalData.get('Name','?')))
    73857950        mainSizer.Add([5,10])
    73867951        pawleySizer = wx.BoxSizer(wx.HORIZONTAL)
    7387         pawleySizer.Add(wx.StaticText(General,label=' Do Pawley refinement?: '),0,WACV)
    7388         pawlRef = G2G.G2CheckBox(General,'',generalData,'doPawley',
     7952        pawleySizer.Add(wx.StaticText(genDlg,label=' Do Pawley refinement?: '),0,WACV)
     7953        pawlRef = G2G.G2CheckBox(genDlg,'',generalData,'doPawley',
    73897954                             DisablePawleyOpts)
    73907955        pawleySizer.Add(pawlRef,0,WACV)
    73917956        mainSizer.Add(pawleySizer)
    73927957        pawleySizer = wx.BoxSizer(wx.HORIZONTAL)
    7393         pawleySizer.Add(wx.StaticText(General,label=' Pawley dmin: '),0,WACV)
     7958        pawleySizer.Add(wx.StaticText(genDlg,label=' Pawley dmin: '),0,WACV)
    73947959        def d2Q(*a,**kw):
    73957960            temp['Qmax'] = 2 * math.pi / generalData['Pawley dmin']
    73967961            pawlQVal.SetValue(temp['Qmax'])
    7397         pawlVal = G2G.ValidatedTxtCtrl(General,generalData,'Pawley dmin',
     7962        pawlVal = G2G.ValidatedTxtCtrl(genDlg,generalData,'Pawley dmin',
    73987963               min=0.25,max=20.,nDig=(10,5),typeHint=float,OnLeave=d2Q)
    73997964        pawleySizer.Add(pawlVal,0,WACV)
    7400         pawleySizer.Add(wx.StaticText(General,label='   Qmax: '),0,WACV)
     7965        pawleySizer.Add(wx.StaticText(genDlg,label='   Qmax: '),0,WACV)
    74017966        temp = {'Qmax':2 * math.pi / generalData['Pawley dmin']}
    74027967        def Q2D(*args,**kw):
    74037968            generalData['Pawley dmin'] = 2 * math.pi / temp['Qmax']
    74047969            pawlVal.SetValue(generalData['Pawley dmin'])       
    7405         pawlQVal = G2G.ValidatedTxtCtrl(General,temp,'Qmax',
     7970        pawlQVal = G2G.ValidatedTxtCtrl(genDlg,temp,'Qmax',
    74067971               min=0.314,max=25.,nDig=(10,5),typeHint=float,OnLeave=Q2D)
    74077972        pawleySizer.Add(pawlQVal,0,WACV)
    74087973        mainSizer.Add(pawleySizer)
    74097974        pawleySizer = wx.BoxSizer(wx.HORIZONTAL)
    7410         pawleySizer.Add(wx.StaticText(General,label=' Pawley neg. wt.: '),0,WACV)
    7411         pawlNegWt = G2G.ValidatedTxtCtrl(General,generalData,'Pawley neg wt',
     7975        pawleySizer.Add(wx.StaticText(genDlg,label=' Pawley neg. wt.: '),0,WACV)
     7976        pawlNegWt = G2G.ValidatedTxtCtrl(genDlg,generalData,'Pawley neg wt',
    74127977                    min=0.,max=1.,nDig=(10,4),typeHint=float)
    74137978        pawleySizer.Add(pawlNegWt,0,WACV)
     
    74157980
    74167981        # make OK button
    7417         def OnOK(event): General.EndModal(wx.ID_OK)
     7982        def OnOK(event): genDlg.EndModal(wx.ID_OK)
    74187983        mainSizer.Add([5,5])
    74197984        btnsizer = wx.StdDialogButtonSizer()
    7420         btn = wx.Button(General, wx.ID_OK)
     7985        btn = wx.Button(genDlg, wx.ID_OK)
    74217986        btn.Bind(wx.EVT_BUTTON, OnOK)
    74227987        btn.SetDefault()
    74237988        btnsizer.AddButton(btn)
    7424         btn = wx.Button(General, wx.ID_CANCEL)
     7989        btn = wx.Button(genDlg, wx.ID_CANCEL)
    74257990        btnsizer.AddButton(btn)
    74267991        btnsizer.Realize()
    74277992        mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER|wx.ALL, 5)
    74287993
    7429         General.SetSizer(mainSizer)
    7430         mainSizer.Fit(General)
    7431         General.CenterOnParent()
    7432         res = General.ShowModal()
    7433         General.Destroy()
     7994        genDlg.SetSizer(mainSizer)
     7995        mainSizer.Fit(genDlg)
     7996        genDlg.CenterOnParent()
     7997        res = genDlg.ShowModal()
     7998        genDlg.Destroy()
    74347999
    74358000        if generalData['doPawley'] and res == wx.ID_OK and startDmin != generalData['Pawley dmin']:
     
    74538018        for hist in histograms:
    74548019            if 'PWDR' in hist[:4]:
    7455                 Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
    7456                 inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     8020                Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,hist)
     8021                inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(
    74578022                    G2frame,Id, 'Instrument Parameters'))[0]
    7458                 limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Limits'))
     8023                limits = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id, 'Limits'))
    74598024                Tmin = G2lat.Dsp2pos(inst,dmin)
    74608025                if 'T' in inst['Type'][0]:
     
    75098074            G2frame.ErrorDialog('Pawley estimate','No histograms defined for this phase')
    75108075            return
    7511         PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistoNames[0])       #only use 1st histogram
    7512         xdata = G2frame.PatternTree.GetItemPyData(PatternId)[1]
    7513         Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Instrument Parameters'))[0]
    7514         Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId,'Sample Parameters'))
     8076        PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistoNames[0])       #only use 1st histogram
     8077        xdata = G2frame.GPXtree.GetItemPyData(PatternId)[1]
     8078        Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Instrument Parameters'))[0]
     8079        Sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId,'Sample Parameters'))
    75158080        wave = G2mth.getWave(Inst)
    75168081        const = 9.e-2/(np.pi*Sample['Gonio. radius'])                  #shifts in microns
     
    75598124            return
    75608125        HistoNames = Histograms.keys()
    7561         PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistoNames[0])
    7562         refData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,  \
     8126        PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,HistoNames[0])
     8127        refData = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,  \
    75638128            PatternId,'Reflection Lists'))[PhaseName]['RefList']
    75648129        im = 0
     
    76508215            G2plt.PlotStructure(G2frame,data)                   
    76518216           
    7652         G2frame.dataFrame.SetStatusText('')
     8217        G2frame.GetStatusBar().SetStatusText('',1)
    76538218        if 'Map Peaks' in data:
    7654             G2frame.dataFrame.SetStatusText('Double click any column heading to sort')
     8219            G2frame.GetStatusBar().SetStatusText('Double click any column heading to sort',1)
    76558220            mapPeaks = data['Map Peaks']                       
    76568221            rowLabels = []
     
    76668231            MapPeaks.SetMargins(0,0)
    76678232            MapPeaks.AutoSizeColumns(False)
    7668             SetPhaseWindow(G2frame.dataFrame,MapPeaks,size=[440,300])
     8233            SetPhaseWindow(MapPeaks)
    76698234                   
    76708235    def OnPeaksMove(event):
    76718236        if 'Map Peaks' in data:
    76728237            mapPeaks = np.array(data['Map Peaks'])
    7673             peakMax = np.fmax(mapPeaks.T[0])
     8238            peakMax = np.amax(mapPeaks.T[0])
    76748239            Ind = MapPeaks.GetSelectedRows()
    76758240            for ind in Ind:
     
    77158280        if generalData['Map'].get('Show bonds',False):
    77168281            generalData['Map']['Show bonds'] = False
    7717             G2frame.dataFrame.MapPeaksEdit.SetLabel(G2gd.wxID_SHOWBONDS,'Show bonds')
     8282            G2frame.dataWindow.MapPeaksEdit.SetLabel(G2G.wxID_SHOWBONDS,'Show bonds')
    77188283        else:
    77198284            generalData['Map']['Show bonds'] = True
    7720             G2frame.dataFrame.MapPeaksEdit.SetLabel(G2gd.wxID_SHOWBONDS,'Hide bonds')
     8285            G2frame.dataWindow.MapPeaksEdit.SetLabel(G2G.wxID_SHOWBONDS,'Hide bonds')
    77218286        FillMapPeaksGrid()
    77228287        G2plt.PlotStructure(G2frame,data)
     
    78828447            print ' Map search finished, time = %.2fs'%(time.time()-time0)
    78838448            print ' No.peaks found:',len(peaks)   
    7884             Page = G2frame.dataDisplay.FindPage('Map peaks')
    7885             G2frame.dataDisplay.SetSelection(Page)
     8449            Page = G2frame.phaseDisplay.FindPage('Map peaks')
     8450            G2frame.phaseDisplay.SetSelection(Page)
    78868451            wx.CallAfter(FillMapPeaksGrid)
    78878452            UpdateDrawAtoms()
     
    79808545                it = 0
    79818546                histNames.append(name)
    7982                 Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
    7983                 Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Instrument Parameters'))
    7984                 Sample = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Sample Parameters'))
     8547                Id = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,name)
     8548                Inst = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Instrument Parameters'))
     8549                Sample = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Sample Parameters'))
    79858550                Gangls[name] = copy.copy([Sample[item] for item in['Phi','Chi','Omega','Azimuth']])
    7986                 RefDict = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Reflection Lists'))[phaseName]
     8551                RefDict = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,Id,'Reflection Lists'))[phaseName]
    79878552                Refs = RefDict['RefList'].T  #np.array!
    79888553                if RefDict['Super']: im = 1     #(3+1) offset for m
     
    80278592                return               
    80288593            # find the matching tab
    8029             for PageNum in range(G2frame.dataDisplay.GetPageCount()):
    8030                 if tabname == G2frame.dataDisplay.GetPageText(PageNum):
    8031                     G2frame.dataDisplay.SetSelection(PageNum)
     8594            for PageNum in range(G2frame.phaseDisplay.GetPageCount()):
     8595                if tabname == G2frame.phaseDisplay.GetPageText(PageNum):
     8596                    G2frame.phaseDisplay.SetSelection(PageNum)
    80328597                    return
    80338598            else:
     
    80468611        on a Phase data item window
    80478612        '''
    8048         for page in G2frame.dataDisplay.gridList: # clear out all grids, forcing edits in progress to complete
     8613        for page in G2frame.phaseDisplay.gridList: # clear out all grids, forcing edits in progress to complete
    80498614            page.ClearGrid()
    80508615        page = event.GetSelection()
     8616        G2frame.phaseDisplay.SetSize(G2frame.dataWindow.GetClientSize())    #TODO -almost right
    80518617        ChangePage(page)
    80528618       
    80538619    def ChangePage(page):
    8054         text = G2frame.dataDisplay.GetPageText(page)
    8055         G2frame.dataDisplayPhaseText = text
    8056         G2frame.dataFrame.helpKey = text # use name of Phase tab for help lookup
     8620        text = G2frame.phaseDisplay.GetPageText(page)
     8621        G2frame.phaseDisplayPhaseText = text
     8622        G2frame.dataWindow.helpKey = text # use name of Phase tab for help lookup
    80578623        if text == 'General':
    8058             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataGeneral)
     8624            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataGeneral)
    80598625            UpdateGeneral()
    80608626        elif text == 'Data':
    8061             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataMenu)
     8627            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataMenu)
    80628628            G2ddG.UpdateDData(G2frame,DData,data)
    80638629            wx.CallAfter(G2plt.PlotSizeStrainPO,G2frame,data,hist='',Start=True)           
    80648630        elif text == 'Atoms':
    8065             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.AtomsMenu)
     8631            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.AtomsMenu)
    80668632            FillAtomsGrid(Atoms)
    80678633        elif text == 'Layers':
    8068             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LayerData)
     8634            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.LayerData)
    80698635            UpdateLayerData()
    80708636        elif text == 'Wave Data' and data['General']['Modulated']:
    8071             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.WavesData)
     8637            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.WavesData)
    80728638            UpdateWavesData()
    80738639            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80748640        elif text == 'Draw Options':
    8075             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataDrawOptions)
     8641            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DataDrawOptions)
    80768642            UpdateDrawOptions()
    80778643            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80788644        elif text == 'Draw Atoms':
    8079             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DrawAtomsMenu)
     8645            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.DrawAtomsMenu)
    80808646            UpdateDrawAtoms()
    80818647            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80828648        elif text == 'RB Models':
    8083             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodiesMenu)
     8649            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodiesMenu)
    80848650            FillRigidBodyGrid()
    80858651        elif text == 'Map peaks':
    8086             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MapPeaksMenu)
     8652            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MapPeaksMenu)
    80878653            FillMapPeaksGrid()
    80888654            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80898655        elif text == 'MC/SA':
    8090             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MCSAMenu)
     8656            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.MCSAMenu)
    80918657            UpdateMCSA()                       
    80928658            wx.CallAfter(G2plt.PlotStructure,G2frame,data,firstCall=True)
    80938659        elif text == 'Texture':
    8094             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.TextureMenu)
     8660            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.TextureMenu)
    80958661            UpdateTexture()                       
    80968662            wx.CallAfter(G2plt.PlotTexture,G2frame,data,Start=True)           
    80978663        elif text == 'Pawley reflections':
    8098             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.PawleyMenu)
     8664            G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.PawleyMenu)
    80998665            FillPawleyReflectionsGrid()
    81008666        else:
     
    81058671        '''
    81068672        # General
    8107         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataGeneral)
    8108         G2frame.dataFrame.Bind(wx.EVT_MENU, OnFourierMaps, id=G2gd.wxID_FOURCALC)
    8109         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSearchMaps, id=G2gd.wxID_FOURSEARCH)
    8110         G2frame.dataFrame.Bind(wx.EVT_MENU, OnChargeFlip, id=G2gd.wxID_CHARGEFLIP)
    8111         G2frame.dataFrame.Bind(wx.EVT_MENU, On4DChargeFlip, id=G2gd.wxID_4DCHARGEFLIP)
    8112         G2frame.dataFrame.Bind(wx.EVT_MENU, OnFourClear, id=G2gd.wxID_FOURCLEAR)
    8113         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRunSingleMCSA, id=G2gd.wxID_SINGLEMCSA)
    8114         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRunMultiMCSA, id=G2gd.wxID_MULTIMCSA)
    8115         G2frame.dataFrame.Bind(wx.EVT_MENU, OnTransform, id=G2gd.wxID_TRANSFORMSTRUCTURE)
     8673        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataGeneral)
     8674        G2frame.Bind(wx.EVT_MENU, OnFourierMaps, id=G2G.wxID_FOURCALC)
     8675        G2frame.Bind(wx.EVT_MENU, OnSearchMaps, id=G2G.wxID_FOURSEARCH)
     8676        G2frame.Bind(wx.EVT_MENU, OnChargeFlip, id=G2G.wxID_CHARGEFLIP)
     8677        G2frame.Bind(wx.EVT_MENU, On4DChargeFlip, id=G2G.wxID_4DCHARGEFLIP)
     8678        G2frame.Bind(wx.EVT_MENU, OnFourClear, id=G2G.wxID_FOURCLEAR)
     8679        G2frame.Bind(wx.EVT_MENU, OnRunSingleMCSA, id=G2G.wxID_SINGLEMCSA)
     8680        G2frame.Bind(wx.EVT_MENU, OnRunMultiMCSA, id=G2G.wxID_MULTIMCSA)
     8681        G2frame.Bind(wx.EVT_MENU, OnTransform, id=G2G.wxID_TRANSFORMSTRUCTURE)
    81168682        # Data
    8117         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataMenu)
    8118         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataUse, id=G2gd.wxID_DATAUSE)
    8119         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataCopy, id=G2gd.wxID_DATACOPY)
    8120         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataCopyFlags, id=G2gd.wxID_DATACOPYFLAGS)
    8121         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSelDataCopy, id=G2gd.wxID_DATASELCOPY)
    8122         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPwdrAdd, id=G2gd.wxID_PWDRADD)
    8123         G2frame.dataFrame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2gd.wxID_HKLFADD)
    8124         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataDelete, id=G2gd.wxID_DATADELETE)
     8683        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataMenu)
     8684        G2frame.Bind(wx.EVT_MENU, OnDataUse, id=G2G.wxID_DATAUSE)
     8685        G2frame.Bind(wx.EVT_MENU, OnDataCopy, id=G2G.wxID_DATACOPY)
     8686        G2frame.Bind(wx.EVT_MENU, OnDataCopyFlags, id=G2G.wxID_DATACOPYFLAGS)
     8687        G2frame.Bind(wx.EVT_MENU, OnSelDataCopy, id=G2G.wxID_DATASELCOPY)
     8688        G2frame.Bind(wx.EVT_MENU, OnPwdrAdd, id=G2G.wxID_PWDRADD)
     8689        G2frame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2G.wxID_HKLFADD)
     8690        G2frame.Bind(wx.EVT_MENU, OnDataDelete, id=G2G.wxID_DATADELETE)
    81258691        # Atoms
    8126         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.AtomsMenu)
    8127         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSetAll, id=G2gd.wxID_ATOMSSETALL)
    8128         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomRefine, id=G2gd.wxID_ATOMSSETSEL)
    8129         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomModify, id=G2gd.wxID_ATOMSMODIFY)
    8130         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
    8131         G2frame.dataFrame.Bind(wx.EVT_MENU, OnHydAtomAdd, id=G2gd.wxID_ADDHATOM)
    8132         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
    8133         G2frame.dataFrame.Bind(wx.EVT_MENU, AtomTransform, id=G2gd.wxID_ATOMSTRANSFORM)
    8134 #        G2frame.dataFrame.Bind(wx.EVT_MENU, AtomRotate, id=G2gd.wxID_ATOMSROTATE)
    8135        
    8136         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
    8137         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewAdd, id=G2gd.wxID_ATOMSVIEWADD)
    8138         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewInsert, id=G2gd.wxID_ATOMVIEWINSERT)
    8139         G2frame.dataFrame.Bind(wx.EVT_MENU, OnHydAtomUpdate, id=G2gd.wxID_UPDATEHATOM)
    8140         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomMove, id=G2gd.wxID_ATOMMOVE)
    8141         G2frame.dataFrame.Bind(wx.EVT_MENU, MakeMolecule, id=G2gd.wxID_MAKEMOLECULE)
    8142         G2frame.dataFrame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
    8143         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
    8144         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAnglePrt, id=G2gd.wxID_ATOMSPDISAGL)
    8145         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDensity, id=G2gd.wxID_ATOMSDENSITY)
    8146         G2frame.dataFrame.Bind(wx.EVT_MENU, OnValidProtein, id=G2gd.wxID_VALIDPROTEIN)
    8147         G2frame.dataFrame.Bind(wx.EVT_MENU, OnIsoDistortCalc, id=G2gd.wxID_ISODISP)
     8692        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.AtomsMenu)
     8693        G2frame.Bind(wx.EVT_MENU, OnSetAll, id=G2G.wxID_ATOMSSETALL)
     8694        G2frame.Bind(wx.EVT_MENU, AtomRefine, id=G2G.wxID_ATOMSSETSEL)
     8695        G2frame.Bind(wx.EVT_MENU, AtomModify, id=G2G.wxID_ATOMSMODIFY)
     8696        G2frame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2G.wxID_ATOMSEDITINSERT)
     8697        G2frame.Bind(wx.EVT_MENU, OnHydAtomAdd, id=G2G.wxID_ADDHATOM)
     8698        G2frame.Bind(wx.EVT_MENU, AtomDelete, id=G2G.wxID_ATOMSEDITDELETE)
     8699        G2frame.Bind(wx.EVT_MENU, AtomTransform, id=G2G.wxID_ATOMSTRANSFORM)
     8700#        G2frame.Bind(wx.EVT_MENU, AtomRotate, id=G2G.wxID_ATOMSROTATE)
     8701       
     8702        G2frame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2G.wxID_ATOMSEDITADD)
     8703        G2frame.Bind(wx.EVT_MENU, OnAtomViewAdd, id=G2G.wxID_ATOMSVIEWADD)
     8704        G2frame.Bind(wx.EVT_MENU, OnAtomViewInsert, id=G2G.wxID_ATOMVIEWINSERT)
     8705        G2frame.Bind(wx.EVT_MENU, OnHydAtomUpdate, id=G2G.wxID_UPDATEHATOM)
     8706        G2frame.Bind(wx.EVT_MENU, OnAtomMove, id=G2G.wxID_ATOMMOVE)
     8707        G2frame.Bind(wx.EVT_MENU, MakeMolecule, id=G2G.wxID_MAKEMOLECULE)
     8708        G2frame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2G.wxID_RELOADDRAWATOMS)
     8709        G2frame.Bind(wx.EVT_MENU, OnDistAngle, id=G2G.wxID_ATOMSDISAGL)
     8710        G2frame.Bind(wx.EVT_MENU, OnDistAnglePrt, id=G2G.wxID_ATOMSPDISAGL)
     8711        G2frame.Bind(wx.EVT_MENU, OnDensity, id=G2G.wxID_ATOMSDENSITY)
     8712        G2frame.Bind(wx.EVT_MENU, OnValidProtein, id=G2G.wxID_VALIDPROTEIN)
     8713        G2frame.Bind(wx.EVT_MENU, OnIsoDistortCalc, id=G2G.wxID_ISODISP)
    81488714        if 'HydIds' in data['General']:
    8149             G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,True)
     8715            G2frame.dataWindow.AtomEdit.Enable(G2G.wxID_UPDATEHATOM,True)
    81508716        else:
    8151             G2frame.dataFrame.AtomEdit.Enable(G2gd.wxID_UPDATEHATOM,False)
    8152         for id in G2frame.dataFrame.ReImportMenuId:     #loop over submenu items
    8153             G2frame.dataFrame.Bind(wx.EVT_MENU, OnReImport, id=id)
     8717            G2frame.dataWindow.AtomEdit.Enable(G2G.wxID_UPDATEHATOM,False)
     8718        for id in G2frame.dataWindow.ReImportMenuId:     #loop over submenu items
     8719            G2frame.Bind(wx.EVT_MENU, OnReImport, id=id)
    81548720        # Wave Data
    81558721        if data['General']['Modulated']:
    8156             FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.WavesData)
    8157             G2frame.dataFrame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)
     8722            FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.WavesData)
     8723            G2frame.Bind(wx.EVT_MENU, OnWaveVary, id=G2G.wxID_WAVEVARY)
    81588724        # Stacking faults
    8159         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.LayerData)
    8160         G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyPhase, id=G2gd.wxID_COPYPHASE)
    8161         G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
    8162         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSimulate, id=G2gd.wxID_LAYERSIMULATE)
    8163         G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitLayers, id=G2gd.wxID_LAYERSFIT)                       
    8164         G2frame.dataFrame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2gd.wxID_SEQUENCESIMULATE)
     8725        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.LayerData)
     8726        G2frame.Bind(wx.EVT_MENU, OnCopyPhase, id=G2G.wxID_COPYPHASE)
     8727        G2frame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2G.wxID_LOADDIFFAX)
     8728        G2frame.Bind(wx.EVT_MENU, OnSimulate, id=G2G.wxID_LAYERSIMULATE)
     8729        G2frame.Bind(wx.EVT_MENU, OnFitLayers, id=G2G.wxID_LAYERSFIT)                       
     8730        G2frame.Bind(wx.EVT_MENU, OnSeqSimulate, id=G2G.wxID_SEQUENCESIMULATE)
    81658731        # Draw Options
    8166         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataDrawOptions)
     8732        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DataDrawOptions)
    81678733        # Draw Atoms
    8168         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DrawAtomsMenu)
    8169         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2gd.wxID_DRAWATOMSTYLE)
    8170         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2gd.wxID_DRAWATOMLABEL)
    8171         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomColor, id=G2gd.wxID_DRAWATOMCOLOR)
    8172         G2frame.dataFrame.Bind(wx.EVT_MENU, ResetAtomColors, id=G2gd.wxID_DRAWATOMRESETCOLOR)
    8173         G2frame.dataFrame.Bind(wx.EVT_MENU, OnEditAtomRadii, id=G2gd.wxID_DRWAEDITRADII)   
    8174         G2frame.dataFrame.Bind(wx.EVT_MENU, SetViewPoint, id=G2gd.wxID_DRAWVIEWPOINT)
    8175         G2frame.dataFrame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2gd.wxID_DRAWADDEQUIV)
    8176         G2frame.dataFrame.Bind(wx.EVT_MENU, AddSphere, id=G2gd.wxID_DRAWADDSPHERE)
    8177         G2frame.dataFrame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2gd.wxID_DRAWTRANSFORM)
    8178         G2frame.dataFrame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2gd.wxID_DRAWFILLCOORD)           
    8179         G2frame.dataFrame.Bind(wx.EVT_MENU, FillUnitCell, id=G2gd.wxID_DRAWFILLCELL)
    8180         G2frame.dataFrame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2gd.wxID_DRAWDELETE)
    8181         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawDistVP, id=G2gd.wxID_DRAWDISTVP)
    8182         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawDAT, id=G2gd.wxID_DRAWDISAGLTOR)
    8183         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2gd.wxID_DRAWPLANE)
    8184         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRBOND)
    8185         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRANGLE)
    8186         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRPLANE)
    8187         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRestraint, id=G2gd.wxID_DRAWRESTRCHIRAL)
    8188         G2frame.dataFrame.Bind(wx.EVT_MENU, OnDefineRB, id=G2gd.wxID_DRAWDEFINERB)
     8734        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.DrawAtomsMenu)
     8735        G2frame.Bind(wx.EVT_MENU, DrawAtomStyle, id=G2G.wxID_DRAWATOMSTYLE)
     8736        G2frame.Bind(wx.EVT_MENU, DrawAtomLabel, id=G2G.wxID_DRAWATOMLABEL)
     8737        G2frame.Bind(wx.EVT_MENU, DrawAtomColor, id=G2G.wxID_DRAWATOMCOLOR)
     8738        G2frame.Bind(wx.EVT_MENU, ResetAtomColors, id=G2G.wxID_DRAWATOMRESETCOLOR)
     8739        G2frame.Bind(wx.EVT_MENU, OnEditAtomRadii, id=G2G.wxID_DRWAEDITRADII)   
     8740        G2frame.Bind(wx.EVT_MENU, SetViewPoint, id=G2G.wxID_DRAWVIEWPOINT)
     8741        G2frame.Bind(wx.EVT_MENU, AddSymEquiv, id=G2G.wxID_DRAWADDEQUIV)
     8742        G2frame.Bind(wx.EVT_MENU, AddSphere, id=G2G.wxID_DRAWADDSPHERE)
     8743        G2frame.Bind(wx.EVT_MENU, TransformSymEquiv, id=G2G.wxID_DRAWTRANSFORM)
     8744        G2frame.Bind(wx.EVT_MENU, FillCoordSphere, id=G2G.wxID_DRAWFILLCOORD)           
     8745        G2frame.Bind(wx.EVT_MENU, FillUnitCell, id=G2G.wxID_DRAWFILLCELL)
     8746        G2frame.Bind(wx.EVT_MENU, DrawAtomsDelete, id=G2G.wxID_DRAWDELETE)
     8747        G2frame.Bind(wx.EVT_MENU, OnDrawDistVP, id=G2G.wxID_DRAWDISTVP)
     8748        G2frame.Bind(wx.EVT_MENU, OnDrawDAT, id=G2G.wxID_DRAWDISAGLTOR)
     8749        G2frame.Bind(wx.EVT_MENU, OnDrawPlane, id=G2G.wxID_DRAWPLANE)
     8750        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2G.wxID_DRAWRESTRBOND)
     8751        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2G.wxID_DRAWRESTRANGLE)
     8752        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2G.wxID_DRAWRESTRPLANE)
     8753        G2frame.Bind(wx.EVT_MENU, OnRestraint, id=G2G.wxID_DRAWRESTRCHIRAL)
     8754        G2frame.Bind(wx.EVT_MENU, OnDefineRB, id=G2G.wxID_DRAWDEFINERB)
    81898755        # RB Models
    8190         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.RigidBodiesMenu)
    8191         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAutoFindResRB, id=G2gd.wxID_AUTOFINDRESRB)
    8192         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBAssign, id=G2gd.wxID_ASSIGNATMS2RB)
    8193         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBCopyParms, id=G2gd.wxID_COPYRBPARMS)
    8194         G2frame.dataFrame.Bind(wx.EVT_MENU, OnGlobalResRBTherm, id=G2gd.wxID_GLOBALTHERM)
    8195         G2frame.dataFrame.Bind(wx.EVT_MENU, OnGlobalResRBRef, id=G2gd.wxID_GLOBALRESREFINE)
    8196         G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBRemoveAll, id=G2gd.wxID_RBREMOVEALL)
     8756        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.RigidBodiesMenu)
     8757        G2frame.Bind(wx.EVT_MENU, OnAutoFindResRB, id=G2G.wxID_AUTOFINDRESRB)
     8758        G2frame.Bind(wx.EVT_MENU, OnRBAssign, id=G2G.wxID_ASSIGNATMS2RB)
     8759        G2frame.Bind(wx.EVT_MENU, OnRBCopyParms, id=G2G.wxID_COPYRBPARMS)
     8760        G2frame.Bind(wx.EVT_MENU, OnGlobalResRBTherm, id=G2G.wxID_GLOBALTHERM)
     8761        G2frame.Bind(wx.EVT_MENU, OnGlobalResRBRef, id=G2G.wxID_GLOBALRESREFINE)
     8762        G2frame.Bind(wx.EVT_MENU, OnRBRemoveAll, id=G2G.wxID_RBREMOVEALL)
    81978763        # Map peaks
    8198         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.MapPeaksMenu)
    8199         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksMove, id=G2gd.wxID_PEAKSMOVE)
    8200         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksViewPoint, id=G2gd.wxID_PEAKSVIEWPT)
    8201         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDistVP, id=G2gd.wxID_PEAKSDISTVP)
    8202         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDA, id=G2gd.wxID_PEAKSDA)
    8203         G2frame.dataFrame.Bind(wx.EVT_MENU, OnShowBonds, id=G2gd.wxID_SHOWBONDS)
    8204         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksEquiv, id=G2gd.wxID_FINDEQVPEAKS)
    8205         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksUnique, id=G2gd.wxID_PEAKSUNIQUE)
    8206         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksDelete, id=G2gd.wxID_PEAKSDELETE)
    8207         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPeaksClear, id=G2gd.wxID_PEAKSCLEAR)
     8764        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.MapPeaksMenu)
     8765        G2frame.Bind(wx.EVT_MENU, OnPeaksMove, id=G2G.wxID_PEAKSMOVE)
     8766        G2frame.Bind(wx.EVT_MENU, OnPeaksViewPoint, id=G2G.wxID_PEAKSVIEWPT)
     8767        G2frame.Bind(wx.EVT_MENU, OnPeaksDistVP, id=G2G.wxID_PEAKSDISTVP)
     8768        G2frame.Bind(wx.EVT_MENU, OnPeaksDA, id=G2G.wxID_PEAKSDA)
     8769        G2frame.Bind(wx.EVT_MENU, OnShowBonds, id=G2G.wxID_SHOWBONDS)
     8770        G2frame.Bind(wx.EVT_MENU, OnPeaksEquiv, id=G2G.wxID_FINDEQVPEAKS)
     8771        G2frame.Bind(wx.EVT_MENU, OnPeaksUnique, id=G2G.wxID_PEAKSUNIQUE)
     8772        G2frame.Bind(wx.EVT_MENU, OnPeaksDelete, id=G2G.wxID_PEAKSDELETE)
     8773        G2frame.Bind(wx.EVT_MENU, OnPeaksClear, id=G2G.wxID_PEAKSCLEAR)
    82088774        # MC/SA
    8209         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.MCSAMenu)
    8210         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAaddAtom, id=G2gd.wxID_ADDMCSAATOM)
    8211         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAaddRB, id=G2gd.wxID_ADDMCSARB)
    8212         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAclear, id=G2gd.wxID_CLEARMCSARB)
    8213         G2frame.dataFrame.Bind(wx.EVT_MENU, OnMCSAmove, id=G2gd.wxID_MOVEMCSA)
    8214         G2frame.dataFrame.Bind(wx.EVT_MENU, OnClearResults, id=G2gd.wxID_MCSACLEARRESULTS)
     8775        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.MCSAMenu)
     8776        G2frame.Bind(wx.EVT_MENU, OnMCSAaddAtom, id=G2G.wxID_ADDMCSAATOM)
     8777        G2frame.Bind(wx.EVT_MENU, OnMCSAaddRB, id=G2G.wxID_ADDMCSARB)
     8778        G2frame.Bind(wx.EVT_MENU, OnMCSAclear, id=G2G.wxID_CLEARMCSARB)
     8779        G2frame.Bind(wx.EVT_MENU, OnMCSAmove, id=G2G.wxID_MOVEMCSA)
     8780        G2frame.Bind(wx.EVT_MENU, OnClearResults, id=G2G.wxID_MCSACLEARRESULTS)
    82158781        # Texture
    8216         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.TextureMenu)
    8217         G2frame.dataFrame.Bind(wx.EVT_MENU, OnTextureRefine, id=G2gd.wxID_REFINETEXTURE)
    8218 #        G2frame.dataFrame.Bind(wx.EVT_MENU, OnTextureClear, id=G2gd.wxID_CLEARTEXTURE)
     8782        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.TextureMenu)
     8783        G2frame.Bind(wx.EVT_MENU, OnTextureRefine, id=G2G.wxID_REFINETEXTURE)
     8784#        G2frame.Bind(wx.EVT_MENU, OnTextureClear, id=G2G.wxID_CLEARTEXTURE)
    82198785        # Pawley reflections
    8220         FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.PawleyMenu)
    8221         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySet, id=G2gd.wxID_PAWLEYSET)
    8222         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyLoad, id=G2gd.wxID_PAWLEYLOAD)
    8223         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyEstimate, id=G2gd.wxID_PAWLEYESTIMATE)
    8224         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyUpdate, id=G2gd.wxID_PAWLEYUPDATE)
    8225         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySelAll, id=G2gd.wxID_PAWLEYSELALL)
    8226         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleySelNone, id=G2gd.wxID_PAWLEYSELNONE)
    8227         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPawleyToggle, id=G2gd.wxID_PAWLEYSELTOGGLE)
     8786        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.PawleyMenu)
     8787        G2frame.Bind(wx.EVT_MENU, OnPawleySet, id=G2G.wxID_PAWLEYSET)
     8788        G2frame.Bind(wx.EVT_MENU, OnPawleyLoad, id=G2G.wxID_PAWLEYLOAD)
     8789        G2frame.Bind(wx.EVT_MENU, OnPawleyEstimate, id=G2G.wxID_PAWLEYESTIMATE)
     8790        G2frame.Bind(wx.EVT_MENU, OnPawleyUpdate, id=G2G.wxID_PAWLEYUPDATE)
     8791        G2frame.Bind(wx.EVT_MENU, OnPawleySelAll, id=G2G.wxID_PAWLEYSELALL)
     8792        G2frame.Bind(wx.EVT_MENU, OnPawleySelNone, id=G2G.wxID_PAWLEYSELNONE)
     8793        G2frame.Bind(wx.EVT_MENU, OnPawleyToggle, id=G2G.wxID_PAWLEYSELTOGGLE)
    82288794       
    82298795    # UpdatePhaseData execution starts here
     
    82458811    global rbAtmDict   
    82468812    rbAtmDict = {}
    8247     if G2frame.dataDisplay:
    8248         G2frame.dataDisplay.Destroy()
    8249     PhaseName = G2frame.PatternTree.GetItemText(Item)
     8813    PhaseName = G2frame.GPXtree.GetItemText(Item)
    82508814    G2gd.SetDataMenuBar(G2frame)
    8251     G2frame.dataFrame.SetLabel('Phase Data for '+PhaseName)
    8252     G2frame.dataFrame.CreateStatusBar()
    8253     if GSASIIpath.GetConfigValue('debug'):
    8254         G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
    8255             style=wx.aui.AUI_NB_DEFAULT_STYLE ^ wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB)
    8256     else:
    8257         G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
    8258     G2frame.dataDisplay.gridList = [] # list of all grids in notebook
     8815    #G2frame.SetLabel(G2frame.GetLabel().split('||')[0]+' || '+'Phase Data for '+PhaseName)
     8816    G2frame.SetTitle('Phase Data for '+PhaseName)
     8817    # Bob: why do this differently in debug mode? Is this code to test if tabs can be moved around? #TODO - yup, flaky tho.
     8818#    if GSASIIpath.GetConfigValue('debug'):
     8819#        G2frame.phaseDisplay = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize(),
     8820#            style=wx.aui.AUI_NB_TOP | wx.aui.AUI_NB_TAB_SPLIT | wx.aui.AUI_NB_TAB_MOVE)
     8821#    else:
     8822#        G2frame.phaseDisplay = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize())
     8823    G2frame.phaseDisplay = G2G.GSNoteBook(parent=G2frame.dataWindow)
     8824    G2frame.dataWindow.GetSizer().Add(G2frame.phaseDisplay,1,wx.ALL|wx.EXPAND,1)
     8825    G2frame.phaseDisplay.gridList = [] # list of all grids in notebook
    82598826    Pages = []   
    8260     G2frame.dataDisplay.gridList = []
    8261     General = wx.ScrolledWindow(G2frame.dataDisplay)
    8262     G2frame.dataDisplay.AddPage(General,'General')
     8827    General = wx.ScrolledWindow(G2frame.phaseDisplay)
     8828    G2frame.phaseDisplay.AddPage(General,'General')
    82638829    Pages.append('General')
    8264     DData = wx.ScrolledWindow(G2frame.dataDisplay)
    8265     G2frame.dataDisplay.AddPage(DData,'Data')
     8830    DData = wx.ScrolledWindow(G2frame.phaseDisplay)
     8831    G2frame.phaseDisplay.AddPage(DData,'Data')
    82668832    Pages.append('Data')
    8267     Atoms = G2G.GSGrid(G2frame.dataDisplay)
    8268     G2frame.dataDisplay.gridList.append(Atoms)
    8269     G2frame.dataDisplay.AddPage(Atoms,'Atoms')
     8833    Atoms = G2G.GSGrid(G2frame.phaseDisplay)
     8834#    Atoms.SetScrollRate(0,0)
     8835    G2frame.phaseDisplay.gridList.append(Atoms)
     8836    G2frame.phaseDisplay.AddPage(Atoms,'Atoms')
    82708837    Pages.append('Atoms')
    82718838    if data['General']['Modulated']:
    8272         G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
    8273         G2frame.dataDisplay.AddPage(G2frame.waveData,'Wave Data')
     8839        G2frame.waveData = wx.ScrolledWindow(G2frame.phaseDisplay)
     8840        G2frame.phaseDisplay.AddPage(G2frame.waveData,'Wave Data')
    82748841        Pages.append('Wave Data')
    82758842    if data['General']['Type'] == 'faulted':
    8276         G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
    8277         G2frame.dataDisplay.AddPage(G2frame.layerData,'Layers')
     8843        G2frame.layerData = wx.ScrolledWindow(G2frame.phaseDisplay)
     8844        G2frame.phaseDisplay.AddPage(G2frame.layerData,'Layers')
    82788845        Pages.append('Layers')               
    8279     drawOptions = wx.ScrolledWindow(G2frame.dataDisplay)
    8280     G2frame.dataDisplay.AddPage(drawOptions,'Draw Options')
     8846    drawOptions = wx.ScrolledWindow(G2frame.phaseDisplay)
     8847    G2frame.phaseDisplay.AddPage(drawOptions,'Draw Options')
    82818848    Pages.append('Draw Options')
    8282     drawAtoms = G2G.GSGrid(G2frame.dataDisplay)
    8283     G2frame.dataDisplay.gridList.append(drawAtoms)
    8284     G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
     8849    drawAtoms = G2G.GSGrid(G2frame.phaseDisplay)
     8850#    drawAtoms.SetScrollRate(0,0)
     8851    G2frame.phaseDisplay.gridList.append(drawAtoms)
     8852    G2frame.phaseDisplay.AddPage(drawAtoms,'Draw Atoms')
    82858853    Pages.append('Draw Atoms')
    82868854    if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
    8287         RigidBodies = wx.ScrolledWindow(G2frame.dataDisplay)
    8288         G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
     8855        RigidBodies = wx.ScrolledWindow(G2frame.phaseDisplay)
     8856        G2frame.phaseDisplay.AddPage(RigidBodies,'RB Models')
    82898857        Pages.append('RB Models')
    8290     MapPeaks = G2G.GSGrid(G2frame.dataDisplay)
    8291     G2frame.dataDisplay.gridList.append(MapPeaks)   
    8292     G2frame.dataDisplay.AddPage(MapPeaks,'Map peaks')
     8858    MapPeaks = G2G.GSGrid(G2frame.phaseDisplay)
     8859#    MapPeaks.SetScrollRate(0,0)
     8860    G2frame.phaseDisplay.gridList.append(MapPeaks)   
     8861    G2frame.phaseDisplay.AddPage(MapPeaks,'Map peaks')
    82938862    Pages.append('Map peaks')
    82948863    if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
    8295         G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
    8296         G2frame.dataDisplay.AddPage(G2frame.MCSA,'MC/SA')
     8864        G2frame.MCSA = wx.ScrolledWindow(G2frame.phaseDisplay)
     8865        G2frame.phaseDisplay.AddPage(G2frame.MCSA,'MC/SA')
    82978866        Pages.append('MC/SA')
    8298     Texture = wx.ScrolledWindow(G2frame.dataDisplay)
    8299     G2frame.dataDisplay.AddPage(Texture,'Texture')
     8867    Texture = wx.ScrolledWindow(G2frame.phaseDisplay)
     8868    G2frame.phaseDisplay.AddPage(Texture,'Texture')
    83008869    Pages.append('Texture')
    8301     G2frame.PawleyRefl = G2G.GSGrid(G2frame.dataDisplay)
    8302     G2frame.dataDisplay.gridList.append(G2frame.PawleyRefl)
    8303     G2frame.dataDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
     8870    G2frame.PawleyRefl = G2G.GSGrid(G2frame.phaseDisplay)
     8871#    G2frame.PawleyRefl.SetScrollRate(0,0)
     8872    G2frame.phaseDisplay.gridList.append(G2frame.PawleyRefl)
     8873    G2frame.phaseDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')
    83048874    Pages.append('Pawley reflections')
    8305     G2frame.dataFrame.AtomCompute.Enable(G2gd.wxID_ISODISP,'ISODISTORT' in data)
    8306     G2frame.dataFrame.AtomCompute.Enable(G2gd.wxID_VALIDPROTEIN,'macro' in data['General']['Type'])
    8307     G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     8875    G2frame.dataWindow.AtomCompute.Enable(G2G.wxID_ISODISP,'ISODISTORT' in data)
     8876    G2frame.dataWindow.AtomCompute.Enable(G2G.wxID_VALIDPROTEIN,'macro' in data['General']['Type'])
     8877    G2frame.phaseDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
    83088878    FillMenus()
    83098879    if oldPage is None or oldPage == 0:
    83108880        ChangePage(0)
    8311         wx.CallAfter(G2frame.dataDisplay.SendSizeEvent)
     8881        #wx.CallAfter(G2frame.phaseDisplay.SendSizeEvent)
    83128882    elif oldPage:
    83138883        SetupGeneral()    # not sure why one might need this when moving from phase to phase; but does not hurt
    8314         G2frame.dataDisplay.SetSelection(oldPage)
     8884        G2frame.phaseDisplay.SetSelection(oldPage)
Note: See TracChangeset for help on using the changeset viewer.