Changeset 1831

Timestamp:

May 1, 2015 6:38:23 PM (9 years ago)

Author:

toby

Message:

move remaining generic controls to G2ctrls

Location:

trunk

Files:

• GSASII.py (modified) (4 diffs)
• GSASIIIO.py (modified) (8 diffs)
• GSASIIconstrGUI.py (modified) (6 diffs)
• GSASIIctrls.py (modified) (12 diffs)
• GSASIIgrid.py (modified) (15 diffs)
• GSASIIimgGUI.py (modified) (6 diffs)
• GSASIIphsGUI.py (modified) (18 diffs)
• GSASIIplot.py (modified) (1 diff)
• GSASIIpwdGUI.py (modified) (16 diffs)
• GSASIIrestrGUI.py (modified) (25 diffs)
• exports/G2export_CIF.py (modified) (10 diffs)

trunk/GSASII.py

@@ -644 +644 @@
         notOK = True
         while notOK:
-            result = G2gd.ItemSelector(TextList,self,header,header='Add histogram(s)',multiple=True)
+            result = G2G.ItemSelector(TextList,self,header,header='Add histogram(s)',multiple=True)
             if not result: return
             # check that selected single crystal histograms are not already in use!
@@ -804 +804 @@
         for Name in newHistList:
             header += '\n  '+str(Name)
-        result = G2gd.ItemSelector(phaseNameList,self,header,header='Add to phase(s)',multiple=True)
+        result = G2G.ItemSelector(phaseNameList,self,header,header='Add to phase(s)',multiple=True)
         if not result: return
         # connect new phases to histograms
@@ -1404 +1404 @@
             header += '\n  '+str(Name)
 
-        result = G2gd.ItemSelector(phaseNameList,self,header,header='Add to phase(s)',multiple=True)
+        result = G2G.ItemSelector(phaseNameList,self,header,header='Add to phase(s)',multiple=True)
         if not result: return
         # connect new phases to histograms
@@ -1569 +1569 @@
         if not phaseNameList: return # no phases yet, nothing to do
         header = 'Select phase(s) to add the new\npowder simulation (dummy) dataset to:'
-        result = G2gd.ItemSelector(phaseNameList,self,header,header='Add to phase(s)',multiple=True)
+        result = G2G.ItemSelector(phaseNameList,self,header,header='Add to phase(s)',multiple=True)
         if not result: return
         # connect new phases to histograms

trunk/GSASIIIO.py

@@ -1925 +1925 @@
             elif self.multiple: 
                 choices = sorted(self.Phases.keys())
-                phasenum = G2gd.ItemSelector(choices,self.G2frame,multiple=True)
+                phasenum = G2G.ItemSelector(choices,self.G2frame,multiple=True)
                 if phasenum is None: return True
                 self.phasenam = [choices[i] for i in phasenum]
@@ -1932 +1932 @@
             else:
                 choices = sorted(self.Phases.keys())
-                phasenum = G2gd.ItemSelector(choices,self.G2frame)
+                phasenum = G2G.ItemSelector(choices,self.G2frame)
                 if phasenum is None: return True
                 self.phasenam = [choices[phasenum]]
@@ -1946 +1946 @@
             elif self.multiple:
                 choices = sorted(self.xtalDict.values())
-                hnum = G2gd.ItemSelector(choices,self.G2frame,multiple=True)
+                hnum = G2G.ItemSelector(choices,self.G2frame,multiple=True)
                 if not hnum: return True
                 self.histnam = [choices[i] for i in hnum]
@@ -1952 +1952 @@
             else:
                 choices = sorted(self.xtalDict.values())
-                hnum = G2gd.ItemSelector(choices,self.G2frame)
+                hnum = G2G.ItemSelector(choices,self.G2frame)
                 if hnum is None: return True
                 self.histnam = [choices[hnum]]
@@ -1966 +1966 @@
             elif self.multiple:
                 choices = sorted(self.powderDict.values())
-                hnum = G2gd.ItemSelector(choices,self.G2frame,multiple=True)
+                hnum = G2G.ItemSelector(choices,self.G2frame,multiple=True)
                 if not hnum: return True
                 self.histnam = [choices[i] for i in hnum]
@@ -1972 +1972 @@
             else:
                 choices = sorted(self.powderDict.values())
-                hnum = G2gd.ItemSelector(choices,self.G2frame)
+                hnum = G2G.ItemSelector(choices,self.G2frame)
                 if hnum is None: return True
                 self.histnam = [choices[hnum]]
@@ -1986 +1986 @@
             else:
                 choices = sorted(self.Histograms.keys())
-                hnum = G2gd.ItemSelector(choices,self.G2frame,multiple=self.multiple)
+                hnum = G2G.ItemSelector(choices,self.G2frame,multiple=self.multiple)
                 if self.multiple:
                     if not hnum: return True
@@ -2019 +2019 @@
                 self.phasenam = mapPhases
             else: 
-                phasenum = G2gd.ItemSelector(choices,self.G2frame,multiple=self.multiple)
+                phasenum = G2G.ItemSelector(choices,self.G2frame,multiple=self.multiple)
                 if self.multiple:
                     if not phasenum: return True

trunk/GSASIIconstrGUI.py

@@ -998 +998 @@
         G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=id)
 
-    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame)
+    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame)
     # note that order of pages is hard-coded in RaisePage
     PhaseConstr = wx.ScrolledWindow(G2frame.dataDisplay)
@@ -1470 +1470 @@
                 table.append(list(xyz)+[rbData['rbTypes'][ivec],]+list(XYZ[ivec]))
                 rowLabels.append(str(ivec))
-            vecTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            vecGrid = G2gd.GSGrid(VectorRBDisplay)
+            vecTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            vecGrid = G2G.GSGrid(VectorRBDisplay)
             vecGrid.SetTable(vecTable, True)
             vecGrid.Bind(wg.EVT_GRID_CELL_CHANGE, ChangeCell)
@@ -1477 +1477 @@
                 vecGrid.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, TypeSelect)
             attr = wx.grid.GridCellAttr()
-            attr.SetEditor(G2gd.GridFractionEditor(vecGrid))
+            attr.SetEditor(G2G.GridFractionEditor(vecGrid))
             for c in range(3):
                 vecGrid.SetColAttr(c, attr)
@@ -1638 +1638 @@
                 table.append([rbData['atNames'][ivec],]+[rbData['rbTypes'][ivec],]+list(xyz))
                 rowLabels.append(str(ivec))
-            vecTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            vecGrid = G2gd.GSGrid(ResidueRBDisplay)
+            vecTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            vecGrid = G2G.GSGrid(ResidueRBDisplay)
             Indx[vecGrid.GetId()] = rbId
             resList.append(vecGrid)
@@ -1647 +1647 @@
             vecGrid.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, RowSelect)
             attr = wx.grid.GridCellAttr()
-            attr.SetEditor(G2gd.GridFractionEditor(vecGrid))
+            attr.SetEditor(G2G.GridFractionEditor(vecGrid))
             for c in range(3):
                 vecGrid.SetColAttr(c, attr)
@@ -1826 +1826 @@
     SetStatusLine('')
 
-    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
+    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
 
     VectorRB = wx.ScrolledWindow(G2frame.dataDisplay)

trunk/GSASIIctrls.py

@@ -18 +18 @@
 '''
 import wx
-# import wx.grid as wg
+import wx.grid as wg
 # import wx.wizard as wz
-# import wx.aui
+import wx.aui
 import wx.lib.scrolledpanel as wxscroll
 import time
@@ -766 +766 @@
 
 ################################################################################
-#### Edit a large number of values
+def HorizontalLine(sizer,parent):
+    '''Draws a horizontal line as wide as the window.
+    This shows up on the Mac as a very thin line, no matter what I do
+    '''
+    line = wx.StaticLine(parent,-1, size=(-1,3), style=wx.LI_HORIZONTAL)
+    sizer.Add(line, 0, wx.EXPAND|wx.ALIGN_CENTER|wx.ALL, 10)
+
+################################################################################
+class G2LoggedButton(wx.Button):
+    '''A version of wx.Button that creates logging events. Bindings are saved
+    in the object, and are looked up rather than directly set with a bind.
+    An index to these buttons is saved as log.ButtonBindingLookup
+    :param wx.Panel parent: parent widget
+    :param int id: Id for button
+    :param str label: label for button
+    :param str locationcode: a label used internally to uniquely indentify the button
+    :param function handler: a routine to call when the button is pressed
+    '''
+    def __init__(self,parent,id=wx.ID_ANY,label='',locationcode='',
+                 handler=None,*args,**kwargs):
+        super(self.__class__,self).__init__(parent,id,label,*args,**kwargs)
+        self.label = label
+        self.handler = handler
+        self.locationcode = locationcode
+        key = locationcode + '+' + label # hash code to find button
+        self.Bind(wx.EVT_BUTTON,self.onPress)
+        log.ButtonBindingLookup[key] = self
+    def onPress(self,event):
+        'create log event and call handler'
+        log.MakeButtonLog(self.locationcode,self.label)
+        self.handler(event)
+        
+################################################################################
+class EnumSelector(wx.ComboBox):
+    '''A customized :class:`wxpython.ComboBox` that selects items from a list
+    of choices, but sets a dict (list) entry to the corresponding
+    entry from the input list of values.
+
+    :param wx.Panel parent: the parent to the :class:`~wxpython.ComboBox` (usually a
+      frame or panel)
+    :param dict dct: a dict (or list) to contain the value set
+      for the :class:`~wxpython.ComboBox`.
+    :param item: the dict key (or list index) where ``dct[item]`` will 
+      be set to the value selected in the :class:`~wxpython.ComboBox`. Also, dct[item]
+      contains the starting value shown in the widget. If the value
+      does not match an entry in :data:`values`, the first value
+      in :data:`choices` is used as the default, but ``dct[item]`` is
+      not changed.    
+    :param list choices: a list of choices to be displayed to the
+      user such as
+      ::
+      
+      ["default","option 1","option 2",]
+
+      Note that these options will correspond to the entries in 
+      :data:`values` (if specified) item by item. 
+    :param list values: a list of values that correspond to
+      the options in :data:`choices`, such as
+      ::
+      
+      [0,1,2]
+      
+      The default for :data:`values` is to use the same list as
+      specified for :data:`choices`.
+    :param (other): additional keyword arguments accepted by
+      :class:`~wxpython.ComboBox` can be specified.
+    '''
+    def __init__(self,parent,dct,item,choices,values=None,**kw):
+        if values is None:
+            values = choices
+        if dct[item] in values:
+            i = values.index(dct[item])
+        else:
+            i = 0
+        startval = choices[i]
+        wx.ComboBox.__init__(self,parent,wx.ID_ANY,startval,
+                             choices = choices,
+                             style=wx.CB_DROPDOWN|wx.CB_READONLY,
+                             **kw)
+        self.choices = choices
+        self.values = values
+        self.dct = dct
+        self.item = item
+        self.Bind(wx.EVT_COMBOBOX, self.onSelection)
+    def onSelection(self,event):
+        # respond to a selection by setting the enum value in the CIF dictionary
+        if self.GetValue() in self.choices: # should always be true!
+            self.dct[self.item] = self.values[self.choices.index(self.GetValue())]
+        else:
+            self.dct[self.item] = self.values[0] # unknown
+
+################################################################################
+class G2ChoiceButton(wx.Choice):
+    '''A customized version of a wx.Choice that automatically initializes
+    the control to match a supplied value and saves the choice directly
+    into an array or list. Optionally a function can be called each time a
+    choice is selected. The widget can be used with an array item that is set to 
+    to the choice by number (``indLoc[indKey]``) or by string value
+    (``strLoc[strKey]``) or both. The initial value is taken from ``indLoc[indKey]``
+    if not None or ``strLoc[strKey]`` if not None. 
+
+    :param wx.Panel parent: name of panel or frame that will be
+      the parent to the widget. Can be None.
+    :param list choiceList: a list or tuple of choices to offer the user.
+    :param dict/list indLoc: a dict or list with the initial value to be
+      placed in the Choice button. If this is None, this is ignored. 
+    :param int/str indKey: the dict key or the list index for the value to be
+      edited by the Choice button. If indLoc is not None then this
+      must be specified and the ``indLoc[indKey]`` will be set. If the value
+      for ``indLoc[indKey]`` is not None, it should be an integer in
+      range(len(choiceList)). The Choice button will be initialized to the
+      choice corresponding to the value in this element if not None.
+    :param dict/list strLoc: a dict or list with the string value corresponding to
+      indLoc/indKey. Default (None) means that this is not used. 
+    :param int/str strKey: the dict key or the list index for the string value 
+      The ``strLoc[strKey]`` element must exist or strLoc must be None (default).
+    :param function onChoice: name of a function to call when the choice is made.
+    '''
+    def __init__(self,parent,choiceList,indLoc=None,indKey=None,strLoc=None,strKey=None,
+                 onChoice=None,**kwargs):
+        wx.Choice.__init__(self,parent,choices=choiceList,id=wx.ID_ANY,**kwargs)
+        self.choiceList = choiceList
+        self.indLoc = indLoc
+        self.indKey = indKey
+        self.strLoc = strLoc
+        self.strKey = strKey
+        self.onChoice = None
+        self.SetSelection(wx.NOT_FOUND)
+        if self.indLoc is not None and self.indLoc.get(self.indKey) is not None:
+            self.SetSelection(self.indLoc[self.indKey])
+            if self.strLoc is not None:
+                self.strLoc[self.strKey] = self.GetStringSelection()
+                log.LogVarChange(self.strLoc,self.strKey)
+        elif self.strLoc is not None and self.strLoc.get(self.strKey) is not None:
+            try:
+                self.SetSelection(choiceList.index(self.strLoc[self.strKey]))
+                if self.indLoc is not None:
+                    self.indLoc[self.indKey] = self.GetSelection()
+                    log.LogVarChange(self.indLoc,self.indKey)
+            except ValueError:
+                pass
+        self.Bind(wx.EVT_CHOICE, self._OnChoice)
+        #if self.strLoc is not None: # make sure strLoc gets initialized
+        #    self._OnChoice(None) # note that onChoice will not be called
+        self.onChoice = onChoice
+    def _OnChoice(self,event):
+        if self.indLoc is not None:
+            self.indLoc[self.indKey] = self.GetSelection()
+            log.LogVarChange(self.indLoc,self.indKey)
+        if self.strLoc is not None:
+            self.strLoc[self.strKey] = self.GetStringSelection()
+            log.LogVarChange(self.strLoc,self.strKey)
+        if self.onChoice:
+            self.onChoice()
+
+############################################################### Custom checkbox that saves values into dict/list as used
+class G2CheckBox(wx.CheckBox):
+    '''A customized version of a CheckBox that automatically initializes
+    the control to a supplied list or dict entry and updates that
+    entry as the widget is used.
+
+    :param wx.Panel parent: name of panel or frame that will be
+      the parent to the widget. Can be None.
+    :param str label: text to put on check button
+    :param dict/list loc: the dict or list with the initial value to be
+      placed in the CheckBox. 
+    :param int/str key: the dict key or the list index for the value to be
+      edited by the CheckBox. The ``loc[key]`` element must exist.
+      The CheckBox will be initialized from this value.
+      If the value is anything other that True (or 1), it will be taken as
+      False. 
+    '''
+    def __init__(self,parent,label,loc,key):
+        wx.CheckBox.__init__(self,parent,id=wx.ID_ANY,label=label)
+        self.loc = loc
+        self.key = key
+        self.SetValue(self.loc[self.key]==True)
+        self.Bind(wx.EVT_CHECKBOX, self._OnCheckBox)
+    def _OnCheckBox(self,event):
+        self.loc[self.key] = self.GetValue()
+        log.LogVarChange(self.loc,self.key)
+            
+################################################################################
+#### Commonly used dialogs
 ################################################################################
 def CallScrolledMultiEditor(parent,dictlst,elemlst,prelbl=[],postlbl=[],
@@ -788 +971 @@
         return False
 
+################################################################################
 class ScrolledMultiEditor(wx.Dialog):
     '''Define a window for editing a potentially large number of dict- or
@@ -1011 +1195 @@
             self.OKbtn.Disable()
 
-################################################################################
-#### Multichoice Dialog with set all, toggle & filter options
-################################################################################
+###############################################  Multichoice Dialog with set all, toggle & filter options
 class G2MultiChoiceDialog(wx.Dialog):
     '''A dialog similar to MultiChoiceDialog except that buttons are
@@ -1391 +1573 @@
         dlg.Destroy()
 
-################################################################################
-#### Single choice Dialog with filter options
-################################################################################
+################################################################        Single choice Dialog with filter options
 class G2SingleChoiceDialog(wx.Dialog):
     '''A dialog similar to wx.SingleChoiceDialog except that a filter can be
@@ -1508 +1688 @@
 
 ################################################################################
-#### Custom checkbox that saves values into dict/list as used
-################################################################################
-class G2CheckBox(wx.CheckBox):
-    '''A customized version of a CheckBox that automatically initializes
-    the control to a supplied list or dict entry and updates that
-    entry as the widget is used.
-
-    :param wx.Panel parent: name of panel or frame that will be
-      the parent to the widget. Can be None.
-    :param str label: text to put on check button
-    :param dict/list loc: the dict or list with the initial value to be
-      placed in the CheckBox. 
-    :param int/str key: the dict key or the list index for the value to be
-      edited by the CheckBox. The ``loc[key]`` element must exist.
-      The CheckBox will be initialized from this value.
-      If the value is anything other that True (or 1), it will be taken as
-      False. 
+def G2MessageBox(parent,msg,title='Error'):
+    '''Simple code to display a error or warning message
     '''
-    def __init__(self,parent,label,loc,key):
-        wx.CheckBox.__init__(self,parent,id=wx.ID_ANY,label=label)
-        self.loc = loc
-        self.key = key
-        self.SetValue(self.loc[self.key]==True)
-        self.Bind(wx.EVT_CHECKBOX, self._OnCheckBox)
-    def _OnCheckBox(self,event):
-        self.loc[self.key] = self.GetValue()
-        log.LogVarChange(self.loc,self.key)
-
-################################################################################
-####
+    dlg = wx.MessageDialog(parent,StripIndents(msg), title, wx.OK)
+    dlg.ShowModal()
+    dlg.Destroy()
+    
 ################################################################################
 class PickTwoDialog(wx.Dialog):
@@ -1606 +1763 @@
 
 ################################################################################
-#### Column-order selection
+class SingleFloatDialog(wx.Dialog):
+    'Dialog to obtain a single float value from user'
+    def __init__(self,parent,title,prompt,value,limits=[0.,1.],format='%.5g'):
+        wx.Dialog.__init__(self,parent,-1,title, 
+            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
+        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
+        self.limits = limits
+        self.value = value
+        self.prompt = prompt
+        self.format = format
+        self.Draw()
+        
+    def Draw(self):
+        
+        def OnValItem(event):
+            try:
+                val = float(valItem.GetValue())
+                if val < self.limits[0] or val > self.limits[1]:
+                    raise ValueError
+            except ValueError:
+                val = self.value
+            self.value = val
+            valItem.SetValue(self.format%(self.value))
+            
+        self.panel.Destroy()
+        self.panel = wx.Panel(self)
+        mainSizer = wx.BoxSizer(wx.VERTICAL)
+        mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
+        valItem = wx.TextCtrl(self.panel,-1,value=self.format%(self.value),style=wx.TE_PROCESS_ENTER)
+        mainSizer.Add(valItem,0,wx.ALIGN_CENTER)
+        valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
+        valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
+        OkBtn = wx.Button(self.panel,-1,"Ok")
+        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
+        CancelBtn = wx.Button(self.panel,-1,'Cancel')
+        CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
+        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+        btnSizer.Add((20,20),1)
+        btnSizer.Add(OkBtn)
+        btnSizer.Add(CancelBtn)
+        btnSizer.Add((20,20),1)
+        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
+        self.panel.SetSizer(mainSizer)
+        self.panel.Fit()
+        self.Fit()
+
+    def GetValue(self):
+        return self.value
+        
+    def OnOk(self,event):
+        parent = self.GetParent()
+        parent.Raise()
+        self.EndModal(wx.ID_OK)              
+        
+    def OnCancel(self,event):
+        parent = self.GetParent()
+        parent.Raise()
+        self.EndModal(wx.ID_CANCEL)
+
 ################################################################################
-
+class SingleStringDialog(wx.Dialog):
+    '''Dialog to obtain a single string value from user
+    
+    :param wx.Frame parent: name of parent frame
+    :param str title: title string for dialog
+    :param str prompt: string to tell use what they are inputting
+    :param str value: default input value, if any
+    '''
+    def __init__(self,parent,title,prompt,value='',size=(200,-1)):
+        wx.Dialog.__init__(self,parent,wx.ID_ANY,title, 
+                           pos=wx.DefaultPosition,
+                           style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
+        self.value = value
+        self.prompt = prompt
+        self.CenterOnParent()
+        self.panel = wx.Panel(self)
+        mainSizer = wx.BoxSizer(wx.VERTICAL)
+        mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
+        self.valItem = wx.TextCtrl(self.panel,-1,value=self.value,size=size)
+        mainSizer.Add(self.valItem,0,wx.ALIGN_CENTER)
+        btnsizer = wx.StdDialogButtonSizer()
+        OKbtn = wx.Button(self.panel, wx.ID_OK)
+        OKbtn.SetDefault()
+        btnsizer.AddButton(OKbtn)
+        btn = wx.Button(self.panel, wx.ID_CANCEL)
+        btnsizer.AddButton(btn)
+        btnsizer.Realize()
+        mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
+        self.panel.SetSizer(mainSizer)
+        self.panel.Fit()
+        self.Fit()
+
+    def Show(self):
+        '''Use this method after creating the dialog to post it
+        :returns: True if the user pressed OK; False if the User pressed Cancel
+        '''
+        if self.ShowModal() == wx.ID_OK:
+            self.value = self.valItem.GetValue()
+            return True
+        else:
+            return False
+
+    def GetValue(self):
+        '''Use this method to get the value entered by the user
+        :returns: string entered by user
+        '''
+        return self.value
+
+################################################################################
+class MultiStringDialog(wx.Dialog):
+    '''Dialog to obtain a multi string values from user
+    
+    :param wx.Frame parent: name of parent frame
+    :param str title: title string for dialog
+    :param str prompts: strings to tell use what they are inputting
+    :param str values: default input values, if any
+    '''
+    def __init__(self,parent,title,prompts,values=[]):      #,size=(200,-1)?
+        
+        wx.Dialog.__init__(self,parent,wx.ID_ANY,title, 
+                           pos=wx.DefaultPosition,
+                           style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
+        self.values = values
+        self.prompts = prompts
+        self.CenterOnParent()
+        self.panel = wx.Panel(self)
+        mainSizer = wx.BoxSizer(wx.VERTICAL)
+        promptSizer = wx.FlexGridSizer(0,2,5,5)
+        self.Indx = {}
+        for prompt,value in zip(prompts,values):
+            promptSizer.Add(wx.StaticText(self.panel,-1,prompt),0,WACV)
+            valItem = wx.TextCtrl(self.panel,-1,value=value,style=wx.TE_PROCESS_ENTER)
+            self.Indx[valItem.GetId()] = prompt
+            valItem.Bind(wx.EVT_TEXT,self.newValue)
+            promptSizer.Add(valItem,0,WACV)
+        mainSizer.Add(promptSizer,0)
+        btnsizer = wx.StdDialogButtonSizer()
+        OKbtn = wx.Button(self.panel, wx.ID_OK)
+        OKbtn.SetDefault()
+        btnsizer.AddButton(OKbtn)
+        btn = wx.Button(self.panel, wx.ID_CANCEL)
+        btnsizer.AddButton(btn)
+        btnsizer.Realize()
+        mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
+        self.panel.SetSizer(mainSizer)
+        self.panel.Fit()
+        self.Fit()
+        
+    def newValue(self,event):
+        Obj = event.GetEventObject()
+        item = self.Indx[Obj.GetId()]
+        id = self.prompts.index(item)
+        self.values[id] = Obj.GetValue()
+
+    def Show(self):
+        '''Use this method after creating the dialog to post it
+        :returns: True if the user pressed OK; False if the User pressed Cancel
+        '''
+        if self.ShowModal() == wx.ID_OK:
+            return True
+        else:
+            return False
+
+    def GetValues(self):
+        '''Use this method to get the value entered by the user
+        :returns: string entered by user
+        '''
+        return self.values
+
+################################################################################
+class G2ColumnIDDialog(wx.Dialog):
+    '''A dialog for matching column data to desired items; some columns may be ignored.
+    
+    :param wx.Frame ParentFrame: reference to parent frame
+    :param str title: heading above list of choices
+    :param str header: Title to place on window frame 
+    :param list ChoiceList: a list of possible choices for the columns
+    :param list ColumnData: lists of column data to be matched with ChoiceList
+    :param bool monoFont: If False (default), use a variable-spaced font;
+      if True use a equally-spaced font.
+    :param kw: optional keyword parameters for the wx.Dialog may
+      be included such as size [which defaults to `(320,310)`] and
+      style (which defaults to ``wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER | wx.CENTRE | wx.OK | wx.CANCEL``);
+      note that ``wx.OK`` and ``wx.CANCEL`` controls
+      the presence of the eponymous buttons in the dialog.
+    :returns: the name of the created dialog
+    
+    '''
+
+    def __init__(self,parent, title, header,Comments,ChoiceList, ColumnData,
+                 monoFont=False, **kw):
+
+        def OnOk(sevent):
+            OK = True
+            selCols = []
+            for col in self.sel:
+                item = col.GetValue()
+                if item != ' ' and item in selCols:
+                    OK = False
+                    break
+                else:
+                    selCols.append(item)
+            parent = self.GetParent()
+            if not OK:
+                parent.ErrorDialog('Duplicate',item+' selected more than once')
+                return
+            parent.Raise()
+            self.EndModal(wx.ID_OK)
+            
+        def OnModify(event):
+            Obj = event.GetEventObject()
+            icol,colData = Indx[Obj.GetId()]
+            modify = Obj.GetValue()
+            if not modify:
+                return
+            print 'Modify column',icol,' by', modify
+            for i,item in enumerate(self.ColumnData[icol]):
+                self.ColumnData[icol][i] = str(eval(item+modify))
+            colData.SetValue('\n'.join(self.ColumnData[icol]))
+            Obj.SetValue('')
+            
+        # process keyword parameters, notably style
+        options = {'size':(600,310), # default Frame keywords
+                   'style':wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.CENTRE| wx.OK | wx.CANCEL,
+                   }
+        options.update(kw)
+        self.Comments = ''.join(Comments)
+        self.ChoiceList = ChoiceList
+        self.ColumnData = ColumnData
+        nCol = len(ColumnData)
+        if options['style'] & wx.OK:
+            useOK = True
+            options['style'] ^= wx.OK
+        else:
+            useOK = False
+        if options['style'] & wx.CANCEL:
+            useCANCEL = True
+            options['style'] ^= wx.CANCEL
+        else:
+            useCANCEL = False        
+        # create the dialog frame
+        wx.Dialog.__init__(self,parent,wx.ID_ANY,header,**options)
+        panel = wxscroll.ScrolledPanel(self)
+        # fill the dialog
+        Sizer = wx.BoxSizer(wx.VERTICAL)
+        Sizer.Add((-1,5))
+        Sizer.Add(wx.StaticText(panel,label=title),0,WACV)
+        if self.Comments:
+            Sizer.Add(wx.StaticText(panel,label=' Header lines:'),0,WACV)
+            Sizer.Add(wx.TextCtrl(panel,value=self.Comments,size=(200,-1),
+                style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP),0,wx.ALL|wx.EXPAND|WACV,8)
+        columnsSizer = wx.FlexGridSizer(0,nCol,5,10)
+        self.sel = []
+        self.mod = []
+        Indx = {}
+        for icol,col in enumerate(self.ColumnData):
+            colSizer = wx.BoxSizer(wx.VERTICAL)
+            colSizer.Add(wx.StaticText(panel,label=' Column #%d Select:'%(icol)),0,WACV)
+            self.sel.append(wx.ComboBox(panel,value=' ',choices=self.ChoiceList,style=wx.CB_READONLY|wx.CB_DROPDOWN))
+            colSizer.Add(self.sel[-1])
+            colData = wx.TextCtrl(panel,value='\n'.join(self.ColumnData[icol]),size=(120,-1),
+                style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP)
+            colSizer.Add(colData,0,WACV)
+            colSizer.Add(wx.StaticText(panel,label=' Modify by:'),0,WACV)
+            mod = wx.TextCtrl(panel,size=(120,-1),value='',style=wx.TE_PROCESS_ENTER)
+            mod.Bind(wx.EVT_TEXT_ENTER,OnModify)
+            mod.Bind(wx.EVT_KILL_FOCUS,OnModify)
+            Indx[mod.GetId()] = [icol,colData]
+            colSizer.Add(mod,0,WACV)
+            columnsSizer.Add(colSizer)
+        Sizer.Add(columnsSizer)
+        Sizer.Add(wx.StaticText(panel,label=' For modify by, enter arithmetic string eg. "-12345.67". "+","-","*","/","**" all allowed'),0,WACV) 
+        Sizer.Add((-1,10))
+        # OK/Cancel buttons
+        btnsizer = wx.StdDialogButtonSizer()
+        if useOK:
+            self.OKbtn = wx.Button(panel, wx.ID_OK)
+            self.OKbtn.SetDefault()
+            btnsizer.AddButton(self.OKbtn)
+            self.OKbtn.Bind(wx.EVT_BUTTON, OnOk)
+        if useCANCEL:
+            btn = wx.Button(panel, wx.ID_CANCEL)
+            btnsizer.AddButton(btn)
+        btnsizer.Realize()
+        Sizer.Add((-1,5))
+        Sizer.Add(btnsizer,0,wx.ALIGN_LEFT,20)
+        Sizer.Add((-1,5))
+        # OK done, let's get outa here
+        panel.SetSizer(Sizer)
+        panel.SetAutoLayout(1)
+        panel.SetupScrolling()
+        Size = [450,375]
+        panel.SetSize(Size)
+        Size[0] += 25; Size[1]+= 25
+        self.SetSize(Size)
+        
+    def GetSelection(self):
+        'Returns the selected sample parm for each column'
+        selCols = []
+        for item in self.sel:
+            selCols.append(item.GetValue())
+        return selCols,self.ColumnData
+    
+################################################################################
+def ItemSelector(ChoiceList, ParentFrame=None,
+                 title='Select an item',
+                 size=None, header='Item Selector',
+                 useCancel=True,multiple=False):
+    ''' Provide a wx dialog to select a single item or multiple items from list of choices
+
+    :param list ChoiceList: a list of choices where one will be selected
+    :param wx.Frame ParentFrame: Name of parent frame (default None)
+    :param str title: heading above list of choices (default 'Select an item')
+    :param wx.Size size: Size for dialog to be created (default None -- size as needed)
+    :param str header: Title to place on window frame (default 'Item Selector')
+    :param bool useCancel: If True (default) both the OK and Cancel buttons are offered
+    :param bool multiple: If True then multiple items can be selected (default False)
+    
+    :returns: the selection index or None or a selection list if multiple is true
+    '''
+    if multiple:
+        if useCancel:
+            dlg = G2G.G2MultiChoiceDialog(
+                ParentFrame,title, header, ChoiceList)
+        else:
+            dlg = G2G.G2MultiChoiceDialog(
+                ParentFrame,title, header, ChoiceList,
+                style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.OK|wx.CENTRE)
+    else:
+        if useCancel:
+            dlg = wx.SingleChoiceDialog(
+                ParentFrame,title, header, ChoiceList)
+        else:
+            dlg = wx.SingleChoiceDialog(
+                ParentFrame,title, header,ChoiceList,
+                style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.OK|wx.CENTRE)
+    if size: dlg.SetSize(size)
+    if dlg.ShowModal() == wx.ID_OK:
+        if multiple:
+            dlg.Destroy()
+            return dlg.GetSelections()
+        else:
+            dlg.Destroy()
+            return dlg.GetSelection()
+    else:
+        dlg.Destroy()
+        return None
+    dlg.Destroy()
+
+######################################################### Column-order selection dialog
 def GetItemOrder(parent,keylist,vallookup,posdict):
     '''Creates a panel where items can be ordered into columns
@@ -1749 +2253 @@
 
 ################################################################################
+#####  Customized Grid Support
+################################################################################           
+class GSGrid(wg.Grid):
+    '''Basic wx.Grid implementation
+    '''
+    def __init__(self, parent, name=''):
+        wg.Grid.__init__(self,parent,-1,name=name)                    
+        #self.SetSize(parent.GetClientSize())
+        # above removed to speed drawing of initial grid
+        # does not appear to be needed
+            
+    def Clear(self):
+        wg.Grid.ClearGrid(self)
+        
+    def SetCellReadOnly(self,r,c,readonly=True):
+        self.SetReadOnly(r,c,isReadOnly=readonly)
+        
+    def SetCellStyle(self,r,c,color="white",readonly=True):
+        self.SetCellBackgroundColour(r,c,color)
+        self.SetReadOnly(r,c,isReadOnly=readonly)
+        
+    def GetSelection(self):
+        #this is to satisfy structure drawing stuff in G2plt when focus changes
+        return None
+
+    def InstallGridToolTip(self, rowcolhintcallback,
+                           colLblCallback=None,rowLblCallback=None):
+        '''code to display a tooltip for each item on a grid
+        from http://wiki.wxpython.org/wxGrid%20ToolTips (buggy!), expanded to
+        column and row labels using hints from
+        https://groups.google.com/forum/#!topic/wxPython-users/bm8OARRVDCs
+
+        :param function rowcolhintcallback: a routine that returns a text
+          string depending on the selected row and column, to be used in
+          explaining grid entries.
+        :param function colLblCallback: a routine that returns a text
+          string depending on the selected column, to be used in
+          explaining grid columns (if None, the default), column labels
+          do not get a tooltip.
+        :param function rowLblCallback: a routine that returns a text
+          string depending on the selected row, to be used in
+          explaining grid rows (if None, the default), row labels
+          do not get a tooltip.
+        '''
+        prev_rowcol = [None,None,None]
+        def OnMouseMotion(event):
+            # event.GetRow() and event.GetCol() would be nice to have here,
+            # but as this is a mouse event, not a grid event, they are not
+            # available and we need to compute them by hand.
+            x, y = self.CalcUnscrolledPosition(event.GetPosition())
+            row = self.YToRow(y)
+            col = self.XToCol(x)
+            hinttext = ''
+            win = event.GetEventObject()
+            if [row,col,win] == prev_rowcol: # no change from last position
+                event.Skip()
+                return
+            if win == self.GetGridWindow() and row >= 0 and col >= 0:
+                hinttext = rowcolhintcallback(row, col)
+            elif win == self.GetGridColLabelWindow() and col >= 0:
+                if colLblCallback: hinttext = colLblCallback(col)
+            elif win == self.GetGridRowLabelWindow() and row >= 0:
+                if rowLblCallback: hinttext = rowLblCallback(row)
+            else: # this should be the upper left corner, which is empty
+                event.Skip()
+                return
+            if hinttext is None: hinttext = ''
+            win.SetToolTipString(hinttext)
+            prev_rowcol[:] = [row,col,win]
+            event.Skip()
+
+        wx.EVT_MOTION(self.GetGridWindow(), OnMouseMotion)
+        if colLblCallback: wx.EVT_MOTION(self.GetGridColLabelWindow(), OnMouseMotion)
+        if rowLblCallback: wx.EVT_MOTION(self.GetGridRowLabelWindow(), OnMouseMotion)
+                                                    
+################################################################################           
+class Table(wg.PyGridTableBase):
+    '''Basic data table for use with GSgrid
+    '''
+    def __init__(self, data=[], rowLabels=None, colLabels=None, types = None):
+        wg.PyGridTableBase.__init__(self)
+        self.colLabels = colLabels
+        self.rowLabels = rowLabels
+        self.dataTypes = types
+        self.data = data
+        
+    def AppendRows(self, numRows=1):
+        self.data.append([])
+        return True
+        
+    def CanGetValueAs(self, row, col, typeName):
+        if self.dataTypes:
+            colType = self.dataTypes[col].split(':')[0]
+            if typeName == colType:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    def CanSetValueAs(self, row, col, typeName):
+        return self.CanGetValueAs(row, col, typeName)
+
+    def DeleteRow(self,pos):
+        data = self.GetData()
+        self.SetData([])
+        new = []
+        for irow,row in enumerate(data):
+            if irow <> pos:
+                new.append(row)
+        self.SetData(new)
+        
+    def GetColLabelValue(self, col):
+        if self.colLabels:
+            return self.colLabels[col]
+            
+    def GetData(self):
+        data = []
+        for row in range(self.GetNumberRows()):
+            data.append(self.GetRowValues(row))
+        return data
+        
+    def GetNumberCols(self):
+        try:
+            return len(self.colLabels)
+        except TypeError:
+            return None
+        
+    def GetNumberRows(self):
+        return len(self.data)
+        
+    def GetRowLabelValue(self, row):
+        if self.rowLabels:
+            return self.rowLabels[row]
+        
+    def GetColValues(self, col):
+        data = []
+        for row in range(self.GetNumberRows()):
+            data.append(self.GetValue(row, col))
+        return data
+        
+    def GetRowValues(self, row):
+        data = []
+        for col in range(self.GetNumberCols()):
+            data.append(self.GetValue(row, col))
+        return data
+        
+    def GetTypeName(self, row, col):
+        try:
+            if self.data[row][col] is None: return None
+            return self.dataTypes[col]
+        except (TypeError,IndexError):
+            return None
+
+    def GetValue(self, row, col):
+        try:
+            if self.data[row][col] is None: return ""
+            return self.data[row][col]
+        except IndexError:
+            return None
+            
+    def InsertRows(self, pos, rows):
+        for row in range(rows):
+            self.data.insert(pos,[])
+            pos += 1
+        
+    def IsEmptyCell(self,row,col):
+        try:
+            return not self.data[row][col]
+        except IndexError:
+            return True
+        
+    def OnKeyPress(self, event):
+        dellist = self.GetSelectedRows()
+        if event.GetKeyCode() == wx.WXK_DELETE and dellist:
+            grid = self.GetView()
+            for i in dellist: grid.DeleteRow(i)
+                
+    def SetColLabelValue(self, col, label):
+        numcols = self.GetNumberCols()
+        if col > numcols-1:
+            self.colLabels.append(label)
+        else:
+            self.colLabels[col]=label
+        
+    def SetData(self,data):
+        for row in range(len(data)):
+            self.SetRowValues(row,data[row])
+                
+    def SetRowLabelValue(self, row, label):
+        self.rowLabels[row]=label
+            
+    def SetRowValues(self,row,data):
+        self.data[row] = data
+            
+    def SetValue(self, row, col, value):
+        def innerSetValue(row, col, value):
+            try:
+                self.data[row][col] = value
+            except TypeError:
+                return
+            except IndexError:
+                print row,col,value
+                # add a new row
+                if row > self.GetNumberRows():
+                    self.data.append([''] * self.GetNumberCols())
+                elif col > self.GetNumberCols():
+                    for row in range(self.GetNumberRows):
+                        self.data[row].append('')
+                print self.data
+                self.data[row][col] = value
+        innerSetValue(row, col, value)
+
+################################################################################
+class GridFractionEditor(wg.PyGridCellEditor):
+    '''A grid cell editor class that allows entry of values as fractions as well
+    as sine and cosine values [as s() and c()]
+    '''
+    def __init__(self,grid):
+        wg.PyGridCellEditor.__init__(self)
+
+    def Create(self, parent, id, evtHandler):
+        self._tc = wx.TextCtrl(parent, id, "")
+        self._tc.SetInsertionPoint(0)
+        self.SetControl(self._tc)
+
+        if evtHandler:
+            self._tc.PushEventHandler(evtHandler)
+
+        self._tc.Bind(wx.EVT_CHAR, self.OnChar)
+
+    def SetSize(self, rect):
+        self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
+                               wx.SIZE_ALLOW_MINUS_ONE)
+
+    def BeginEdit(self, row, col, grid):
+        self.startValue = grid.GetTable().GetValue(row, col)
+        self._tc.SetValue(str(self.startValue))
+        self._tc.SetInsertionPointEnd()
+        self._tc.SetFocus()
+        self._tc.SetSelection(0, self._tc.GetLastPosition())
+
+    def EndEdit(self, row, col, grid, oldVal=None):
+        changed = False
+
+        self.nextval = self.startValue
+        val = self._tc.GetValue().lower()
+        if val != self.startValue:
+            changed = True
+            neg = False
+            if '-' in val:
+                neg = True
+            if '/' in val and '.' not in val:
+                val += '.'
+            elif 's' in val and not 'sind(' in val:
+                if neg:
+                    val = '-sind('+val.strip('-s')+')'
+                else:
+                    val = 'sind('+val.strip('s')+')'
+            elif 'c' in val and not 'cosd(' in val:
+                if neg:
+                    val = '-cosd('+val.strip('-c')+')'
+                else:
+                    val = 'cosd('+val.strip('c')+')'
+            try:
+                self.nextval = val = float(eval(val))
+            except (SyntaxError,NameError,ZeroDivisionError):
+                val = self.startValue
+                return None
+            
+            if oldVal is None: # this arg appears in 2.9+; before, we should go ahead & change the table
+                grid.GetTable().SetValue(row, col, val) # update the table
+            # otherwise self.ApplyEdit gets called
+
+        self.startValue = ''
+        self._tc.SetValue('')
+        return changed
+    
+    def ApplyEdit(self, row, col, grid):
+        """ Called only in wx >= 2.9
+        Save the value of the control into the grid if EndEdit() returns as True
+        """
+        grid.GetTable().SetValue(row, col, self.nextval) # update the table
+
+    def Reset(self):
+        self._tc.SetValue(self.startValue)
+        self._tc.SetInsertionPointEnd()
+
+    def Clone(self):
+        return GridFractionEditor(grid)
+
+    def StartingKey(self, evt):
+        self.OnChar(evt)
+        if evt.GetSkipped():
+            self._tc.EmulateKeyPress(evt)
+
+    def OnChar(self, evt):
+        key = evt.GetKeyCode()
+        if key == 15:
+            return
+        if key > 255:
+            evt.Skip()
+            return
+        char = chr(key)
+        if char in '.+-/0123456789cosind()':
+            self._tc.WriteText(char)
+        else:
+            evt.Skip()
+            
+################################################################################
+#####  Customized Notebook
+################################################################################           
+class GSNoteBook(wx.aui.AuiNotebook):
+    '''Notebook used in various locations; implemented with wx.aui extension
+    '''
+    def __init__(self, parent, name='',size = None):
+        wx.aui.AuiNotebook.__init__(self, parent, -1,
+                                    style=wx.aui.AUI_NB_TOP |
+                                    wx.aui.AUI_NB_SCROLL_BUTTONS)
+        if size: self.SetSize(size)
+        self.parent = parent
+        self.PageChangeHandler = None
+        
+    def PageChangeEvent(self,event):
+        G2frame = self.parent.G2frame
+        page = event.GetSelection()
+        if self.PageChangeHandler:
+            if log.LogInfo['Logging']:
+                log.MakeTabLog(
+                    G2frame.dataFrame.GetTitle(),
+                    G2frame.dataDisplay.GetPageText(page)
+                    )
+            self.PageChangeHandler(event)
+            
+    def Bind(self,eventtype,handler,*args,**kwargs):
+        '''Override the Bind() function so that page change events can be trapped
+        '''
+        if eventtype == wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED:
+            self.PageChangeHandler = handler
+            wx.aui.AuiNotebook.Bind(self,eventtype,self.PageChangeEvent)
+            return
+        wx.aui.AuiNotebook.Bind(self,eventtype,handler,*args,**kwargs)
+                                                      
+    def Clear(self):        
+        GSNoteBook.DeleteAllPages(self)
+        
+    def FindPage(self,name):
+        numPage = self.GetPageCount()
+        for page in range(numPage):
+            if self.GetPageText(page) == name:
+                return page
+
+    def ChangeSelection(self,page):
+        # in wx.Notebook ChangeSelection is like SetSelection, but it
+        # does not invoke the event related to pressing the tab button
+        # I don't see a way to do that in aui.
+        oldPage = self.GetSelection()
+        self.SetSelection(page)
+        return oldPage
+
+    # def __getattribute__(self,name):
+    #     '''This method provides a way to print out a message every time
+    #     that a method in a class is called -- to see what all the calls
+    #     might be, or where they might be coming from.
+    #     Cute trick for debugging!
+    #     '''
+    #     attr = object.__getattribute__(self, name)
+    #     if hasattr(attr, '__call__'):
+    #         def newfunc(*args, **kwargs):
+    #             print('GSauiNoteBook calling %s' %attr.__name__)
+    #             result = attr(*args, **kwargs)
+    #             return result
+    #         return newfunc
+    #     else:
+    #         return attr
+            
+################################################################################
 #### Help support routines
 ################################################################################
@@ -2117 +2998 @@
         msg1 = msg.replace('\n ','\n')
     return msg.replace('\n\t','\n')
-
-def G2MessageBox(parent,msg,title='Error'):
-    '''Simple code to display a error or warning message
-    '''
-    dlg = wx.MessageDialog(parent,StripIndents(msg), title, wx.OK)
-    dlg.ShowModal()
-    dlg.Destroy()
         
 ################################################################################
@@ -2204 +3078 @@
         'Get the version number in the dialog'
         return self.spin.GetValue()
+
 ################################################################################
 #### Display Help information
@@ -2246 +3121 @@
         else:
             webbrowser.open(pfx+helplink, new=0, autoraise=True)
+
 def ShowWebPage(URL,frame):
     '''Called to show a tutorial web page.
@@ -2277 +3153 @@
         else:
             webbrowser.open(pfx+URL, new=0, autoraise=True)
+
 ################################################################################
-#### Tutorials selector
+#### Tutorials support
 ################################################################################
 G2BaseURL = "https://subversion.xray.aps.anl.gov/pyGSAS"

trunk/GSASIIgrid.py

@@ -12 +12 @@
 --------------------------------
 
-Note that a number of routines here should be moved to GSASIIctrls eventually, such as
-G2LoggedButton, EnumSelector, G2ChoiceButton, SingleFloatDialog, SingleStringDialog,
-MultiStringDialog, G2ColumnIDDialog, ItemSelector, GridFractionEditor
-
-Probably SGMessageBox, SymOpDialog, DisAglDialog, too. 
-
 '''
 import wx
 import wx.grid as wg
-import wx.wizard as wz
-import wx.aui
+#import wx.wizard as wz
+#import wx.aui
 import wx.lib.scrolledpanel as wxscroll
 import time
@@ -156 +150 @@
 
 VERY_LIGHT_GREY = wx.Colour(235,235,235)
+
+# Aliases for Classes/Functions moved to GSASIIctrls, all should be tracked down but leaving as a reminder
+#SingleFloatDialog = G2G.SingleFloatDialog
+#SingleStringDialog = G2G.SingleStringDialog
+#MultiStringDialog = G2G.MultiStringDialog
+#G2ColumnIDDialog = G2G.G2ColumnIDDialog
+#ItemSelector = G2G.ItemSelector
+#HorizontalLine = G2G.HorizontalLine
+#G2LoggedButton = G2G.G2LoggedButton
+#EnumSelector = G2G.EnumSelector
+#G2ChoiceButton = G2G.G2ChoiceButton
+#GSGrid = G2G.GSGrid
+#Table = G2G.Table
+#GridFractionEditor = G2G.GridFractionEditor
+#GSNoteBook = G2G.GSNoteBook
+
+# Should SGMessageBox, SymOpDialog, DisAglDialog be moved? 
+
 ################################################################################
 #### GSAS-II class definitions
@@ -206 +218 @@
         self.ShowModal()
         return
-
-class G2LoggedButton(wx.Button):
-    '''A version of wx.Button that creates logging events. Bindings are saved
-    in the object, and are looked up rather than directly set with a bind.
-    An index to these buttons is saved as log.ButtonBindingLookup
-    :param wx.Panel parent: parent widget
-    :param int id: Id for button
-    :param str label: label for button
-    :param str locationcode: a label used internally to uniquely indentify the button
-    :param function handler: a routine to call when the button is pressed
-    '''
-    def __init__(self,parent,id=wx.ID_ANY,label='',locationcode='',
-                 handler=None,*args,**kwargs):
-        super(self.__class__,self).__init__(parent,id,label,*args,**kwargs)
-        self.label = label
-        self.handler = handler
-        self.locationcode = locationcode
-        key = locationcode + '+' + label # hash code to find button
-        self.Bind(wx.EVT_BUTTON,self.onPress)
-        log.ButtonBindingLookup[key] = self
-    def onPress(self,event):
-        'create log event and call handler'
-        log.MakeButtonLog(self.locationcode,self.label)
-        self.handler(event)
-        
-################################################################################
-################################################################################
-class EnumSelector(wx.ComboBox):
-    '''A customized :class:`wxpython.ComboBox` that selects items from a list
-    of choices, but sets a dict (list) entry to the corresponding
-    entry from the input list of values.
-
-    :param wx.Panel parent: the parent to the :class:`~wxpython.ComboBox` (usually a
-      frame or panel)
-    :param dict dct: a dict (or list) to contain the value set
-      for the :class:`~wxpython.ComboBox`.
-    :param item: the dict key (or list index) where ``dct[item]`` will 
-      be set to the value selected in the :class:`~wxpython.ComboBox`. Also, dct[item]
-      contains the starting value shown in the widget. If the value
-      does not match an entry in :data:`values`, the first value
-      in :data:`choices` is used as the default, but ``dct[item]`` is
-      not changed.    
-    :param list choices: a list of choices to be displayed to the
-      user such as
-      ::
-      
-      ["default","option 1","option 2",]
-
-      Note that these options will correspond to the entries in 
-      :data:`values` (if specified) item by item. 
-    :param list values: a list of values that correspond to
-      the options in :data:`choices`, such as
-      ::
-      
-      [0,1,2]
-      
-      The default for :data:`values` is to use the same list as
-      specified for :data:`choices`.
-    :param (other): additional keyword arguments accepted by
-      :class:`~wxpython.ComboBox` can be specified.
-    '''
-    def __init__(self,parent,dct,item,choices,values=None,**kw):
-        if values is None:
-            values = choices
-        if dct[item] in values:
-            i = values.index(dct[item])
-        else:
-            i = 0
-        startval = choices[i]
-        wx.ComboBox.__init__(self,parent,wx.ID_ANY,startval,
-                             choices = choices,
-                             style=wx.CB_DROPDOWN|wx.CB_READONLY,
-                             **kw)
-        self.choices = choices
-        self.values = values
-        self.dct = dct
-        self.item = item
-        self.Bind(wx.EVT_COMBOBOX, self.onSelection)
-    def onSelection(self,event):
-        # respond to a selection by setting the enum value in the CIF dictionary
-        if self.GetValue() in self.choices: # should always be true!
-            self.dct[self.item] = self.values[self.choices.index(self.GetValue())]
-        else:
-            self.dct[self.item] = self.values[0] # unknown
-
-################################################################################
-################################################################################
-class G2ChoiceButton(wx.Choice):
-    '''A customized version of a wx.Choice that automatically initializes
-    the control to match a supplied value and saves the choice directly
-    into an array or list. Optionally a function can be called each time a
-    choice is selected. The widget can be used with an array item that is set to 
-    to the choice by number (``indLoc[indKey]``) or by string value
-    (``strLoc[strKey]``) or both. The initial value is taken from ``indLoc[indKey]``
-    if not None or ``strLoc[strKey]`` if not None. 
-
-    :param wx.Panel parent: name of panel or frame that will be
-      the parent to the widget. Can be None.
-    :param list choiceList: a list or tuple of choices to offer the user.
-    :param dict/list indLoc: a dict or list with the initial value to be
-      placed in the Choice button. If this is None, this is ignored. 
-    :param int/str indKey: the dict key or the list index for the value to be
-      edited by the Choice button. If indLoc is not None then this
-      must be specified and the ``indLoc[indKey]`` will be set. If the value
-      for ``indLoc[indKey]`` is not None, it should be an integer in
-      range(len(choiceList)). The Choice button will be initialized to the
-      choice corresponding to the value in this element if not None.
-    :param dict/list strLoc: a dict or list with the string value corresponding to
-      indLoc/indKey. Default (None) means that this is not used. 
-    :param int/str strKey: the dict key or the list index for the string value 
-      The ``strLoc[strKey]`` element must exist or strLoc must be None (default).
-    :param function onChoice: name of a function to call when the choice is made.
-    '''
-    def __init__(self,parent,choiceList,indLoc=None,indKey=None,strLoc=None,strKey=None,
-                 onChoice=None,**kwargs):
-        wx.Choice.__init__(self,parent,choices=choiceList,id=wx.ID_ANY,**kwargs)
-        self.choiceList = choiceList
-        self.indLoc = indLoc
-        self.indKey = indKey
-        self.strLoc = strLoc
-        self.strKey = strKey
-        self.onChoice = None
-        self.SetSelection(wx.NOT_FOUND)
-        if self.indLoc is not None and self.indLoc.get(self.indKey) is not None:
-            self.SetSelection(self.indLoc[self.indKey])
-            if self.strLoc is not None:
-                self.strLoc[self.strKey] = self.GetStringSelection()
-                log.LogVarChange(self.strLoc,self.strKey)
-        elif self.strLoc is not None and self.strLoc.get(self.strKey) is not None:
-            try:
-                self.SetSelection(choiceList.index(self.strLoc[self.strKey]))
-                if self.indLoc is not None:
-                    self.indLoc[self.indKey] = self.GetSelection()
-                    log.LogVarChange(self.indLoc,self.indKey)
-            except ValueError:
-                pass
-        self.Bind(wx.EVT_CHOICE, self._OnChoice)
-        #if self.strLoc is not None: # make sure strLoc gets initialized
-        #    self._OnChoice(None) # note that onChoice will not be called
-        self.onChoice = onChoice
-    def _OnChoice(self,event):
-        if self.indLoc is not None:
-            self.indLoc[self.indKey] = self.GetSelection()
-            log.LogVarChange(self.indLoc,self.indKey)
-        if self.strLoc is not None:
-            self.strLoc[self.strKey] = self.GetStringSelection()
-            log.LogVarChange(self.strLoc,self.strKey)
-        if self.onChoice:
-            self.onChoice()
 
 ################################################################################
@@ -577 +440 @@
         self.Draw(self.data)
                 
-class SingleFloatDialog(wx.Dialog):
-    'Dialog to obtain a single float value from user'
-    def __init__(self,parent,title,prompt,value,limits=[0.,1.],format='%.5g'):
-        wx.Dialog.__init__(self,parent,-1,title, 
-            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
-        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
-        self.limits = limits
-        self.value = value
-        self.prompt = prompt
-        self.format = format
-        self.Draw()
-        
-    def Draw(self):
-        
-        def OnValItem(event):
-            try:
-                val = float(valItem.GetValue())
-                if val < self.limits[0] or val > self.limits[1]:
-                    raise ValueError
-            except ValueError:
-                val = self.value
-            self.value = val
-            valItem.SetValue(self.format%(self.value))
-            
-        self.panel.Destroy()
-        self.panel = wx.Panel(self)
-        mainSizer = wx.BoxSizer(wx.VERTICAL)
-        mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
-        valItem = wx.TextCtrl(self.panel,-1,value=self.format%(self.value),style=wx.TE_PROCESS_ENTER)
-        mainSizer.Add(valItem,0,wx.ALIGN_CENTER)
-        valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
-        valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
-        OkBtn = wx.Button(self.panel,-1,"Ok")
-        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
-        CancelBtn = wx.Button(self.panel,-1,'Cancel')
-        CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
-        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
-        btnSizer.Add((20,20),1)
-        btnSizer.Add(OkBtn)
-        btnSizer.Add(CancelBtn)
-        btnSizer.Add((20,20),1)
-        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
-        self.panel.SetSizer(mainSizer)
-        self.panel.Fit()
-        self.Fit()
-
-    def GetValue(self):
-        return self.value
-        
-    def OnOk(self,event):
-        parent = self.GetParent()
-        parent.Raise()
-        self.EndModal(wx.ID_OK)              
-        
-    def OnCancel(self,event):
-        parent = self.GetParent()
-        parent.Raise()
-        self.EndModal(wx.ID_CANCEL)
-
-################################################################################
-class SingleStringDialog(wx.Dialog):
-    '''Dialog to obtain a single string value from user
-    
-    :param wx.Frame parent: name of parent frame
-    :param str title: title string for dialog
-    :param str prompt: string to tell use what they are inputting
-    :param str value: default input value, if any
-    '''
-    def __init__(self,parent,title,prompt,value='',size=(200,-1)):
-        wx.Dialog.__init__(self,parent,wx.ID_ANY,title, 
-                           pos=wx.DefaultPosition,
-                           style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
-        self.value = value
-        self.prompt = prompt
-        self.CenterOnParent()
-        self.panel = wx.Panel(self)
-        mainSizer = wx.BoxSizer(wx.VERTICAL)
-        mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
-        self.valItem = wx.TextCtrl(self.panel,-1,value=self.value,size=size)
-        mainSizer.Add(self.valItem,0,wx.ALIGN_CENTER)
-        btnsizer = wx.StdDialogButtonSizer()
-        OKbtn = wx.Button(self.panel, wx.ID_OK)
-        OKbtn.SetDefault()
-        btnsizer.AddButton(OKbtn)
-        btn = wx.Button(self.panel, wx.ID_CANCEL)
-        btnsizer.AddButton(btn)
-        btnsizer.Realize()
-        mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
-        self.panel.SetSizer(mainSizer)
-        self.panel.Fit()
-        self.Fit()
-
-    def Show(self):
-        '''Use this method after creating the dialog to post it
-        :returns: True if the user pressed OK; False if the User pressed Cancel
-        '''
-        if self.ShowModal() == wx.ID_OK:
-            self.value = self.valItem.GetValue()
-            return True
-        else:
-            return False
-
-    def GetValue(self):
-        '''Use this method to get the value entered by the user
-        :returns: string entered by user
-        '''
-        return self.value
-
-################################################################################
-class MultiStringDialog(wx.Dialog):
-    '''Dialog to obtain a multi string values from user
-    
-    :param wx.Frame parent: name of parent frame
-    :param str title: title string for dialog
-    :param str prompts: strings to tell use what they are inputting
-    :param str values: default input values, if any
-    '''
-    def __init__(self,parent,title,prompts,values=[]):      #,size=(200,-1)?
-        
-        wx.Dialog.__init__(self,parent,wx.ID_ANY,title, 
-                           pos=wx.DefaultPosition,
-                           style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
-        self.values = values
-        self.prompts = prompts
-        self.CenterOnParent()
-        self.panel = wx.Panel(self)
-        mainSizer = wx.BoxSizer(wx.VERTICAL)
-        promptSizer = wx.FlexGridSizer(0,2,5,5)
-        self.Indx = {}
-        for prompt,value in zip(prompts,values):
-            promptSizer.Add(wx.StaticText(self.panel,-1,prompt),0,WACV)
-            valItem = wx.TextCtrl(self.panel,-1,value=value,style=wx.TE_PROCESS_ENTER)
-            self.Indx[valItem.GetId()] = prompt
-            valItem.Bind(wx.EVT_TEXT,self.newValue)
-            promptSizer.Add(valItem,0,WACV)
-        mainSizer.Add(promptSizer,0)
-        btnsizer = wx.StdDialogButtonSizer()
-        OKbtn = wx.Button(self.panel, wx.ID_OK)
-        OKbtn.SetDefault()
-        btnsizer.AddButton(OKbtn)
-        btn = wx.Button(self.panel, wx.ID_CANCEL)
-        btnsizer.AddButton(btn)
-        btnsizer.Realize()
-        mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER)
-        self.panel.SetSizer(mainSizer)
-        self.panel.Fit()
-        self.Fit()
-        
-    def newValue(self,event):
-        Obj = event.GetEventObject()
-        item = self.Indx[Obj.GetId()]
-        id = self.prompts.index(item)
-        self.values[id] = Obj.GetValue()
-
-    def Show(self):
-        '''Use this method after creating the dialog to post it
-        :returns: True if the user pressed OK; False if the User pressed Cancel
-        '''
-        if self.ShowModal() == wx.ID_OK:
-            return True
-        else:
-            return False
-
-    def GetValues(self):
-        '''Use this method to get the value entered by the user
-        :returns: string entered by user
-        '''
-        return self.values
-
-################################################################################
-
-class G2ColumnIDDialog(wx.Dialog):
-    '''A dialog for matching column data to desired items; some columns may be ignored.
-    
-    :param wx.Frame ParentFrame: reference to parent frame
-    :param str title: heading above list of choices
-    :param str header: Title to place on window frame 
-    :param list ChoiceList: a list of possible choices for the columns
-    :param list ColumnData: lists of column data to be matched with ChoiceList
-    :param bool monoFont: If False (default), use a variable-spaced font;
-      if True use a equally-spaced font.
-    :param kw: optional keyword parameters for the wx.Dialog may
-      be included such as size [which defaults to `(320,310)`] and
-      style (which defaults to ``wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER | wx.CENTRE | wx.OK | wx.CANCEL``);
-      note that ``wx.OK`` and ``wx.CANCEL`` controls
-      the presence of the eponymous buttons in the dialog.
-    :returns: the name of the created dialog
-    
-    '''
-
-    def __init__(self,parent, title, header,Comments,ChoiceList, ColumnData,
-                 monoFont=False, **kw):
-
-        def OnOk(sevent):
-            OK = True
-            selCols = []
-            for col in self.sel:
-                item = col.GetValue()
-                if item != ' ' and item in selCols:
-                    OK = False
-                    break
-                else:
-                    selCols.append(item)
-            parent = self.GetParent()
-            if not OK:
-                parent.ErrorDialog('Duplicate',item+' selected more than once')
-                return
-            parent.Raise()
-            self.EndModal(wx.ID_OK)
-            
-        def OnModify(event):
-            Obj = event.GetEventObject()
-            icol,colData = Indx[Obj.GetId()]
-            modify = Obj.GetValue()
-            if not modify:
-                return
-            print 'Modify column',icol,' by', modify
-            for i,item in enumerate(self.ColumnData[icol]):
-                self.ColumnData[icol][i] = str(eval(item+modify))
-            colData.SetValue('\n'.join(self.ColumnData[icol]))
-            Obj.SetValue('')
-            
-        # process keyword parameters, notably style
-        options = {'size':(600,310), # default Frame keywords
-                   'style':wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.CENTRE| wx.OK | wx.CANCEL,
-                   }
-        options.update(kw)
-        self.Comments = ''.join(Comments)
-        self.ChoiceList = ChoiceList
-        self.ColumnData = ColumnData
-        nCol = len(ColumnData)
-        if options['style'] & wx.OK:
-            useOK = True
-            options['style'] ^= wx.OK
-        else:
-            useOK = False
-        if options['style'] & wx.CANCEL:
-            useCANCEL = True
-            options['style'] ^= wx.CANCEL
-        else:
-            useCANCEL = False        
-        # create the dialog frame
-        wx.Dialog.__init__(self,parent,wx.ID_ANY,header,**options)
-        panel = wxscroll.ScrolledPanel(self)
-        # fill the dialog
-        Sizer = wx.BoxSizer(wx.VERTICAL)
-        Sizer.Add((-1,5))
-        Sizer.Add(wx.StaticText(panel,label=title),0,WACV)
-        if self.Comments:
-            Sizer.Add(wx.StaticText(panel,label=' Header lines:'),0,WACV)
-            Sizer.Add(wx.TextCtrl(panel,value=self.Comments,size=(200,-1),
-                style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP),0,wx.ALL|wx.EXPAND|WACV,8)
-        columnsSizer = wx.FlexGridSizer(0,nCol,5,10)
-        self.sel = []
-        self.mod = []
-        Indx = {}
-        for icol,col in enumerate(self.ColumnData):
-            colSizer = wx.BoxSizer(wx.VERTICAL)
-            colSizer.Add(wx.StaticText(panel,label=' Column #%d Select:'%(icol)),0,WACV)
-            self.sel.append(wx.ComboBox(panel,value=' ',choices=self.ChoiceList,style=wx.CB_READONLY|wx.CB_DROPDOWN))
-            colSizer.Add(self.sel[-1])
-            colData = wx.TextCtrl(panel,value='\n'.join(self.ColumnData[icol]),size=(120,-1),
-                style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_DONTWRAP)
-            colSizer.Add(colData,0,WACV)
-            colSizer.Add(wx.StaticText(panel,label=' Modify by:'),0,WACV)
-            mod = wx.TextCtrl(panel,size=(120,-1),value='',style=wx.TE_PROCESS_ENTER)
-            mod.Bind(wx.EVT_TEXT_ENTER,OnModify)
-            mod.Bind(wx.EVT_KILL_FOCUS,OnModify)
-            Indx[mod.GetId()] = [icol,colData]
-            colSizer.Add(mod,0,WACV)
-            columnsSizer.Add(colSizer)
-        Sizer.Add(columnsSizer)
-        Sizer.Add(wx.StaticText(panel,label=' For modify by, enter arithmetic string eg. "-12345.67". "+","-","*","/","**" all allowed'),0,WACV) 
-        Sizer.Add((-1,10))
-        # OK/Cancel buttons
-        btnsizer = wx.StdDialogButtonSizer()
-        if useOK:
-            self.OKbtn = wx.Button(panel, wx.ID_OK)
-            self.OKbtn.SetDefault()
-            btnsizer.AddButton(self.OKbtn)
-            self.OKbtn.Bind(wx.EVT_BUTTON, OnOk)
-        if useCANCEL:
-            btn = wx.Button(panel, wx.ID_CANCEL)
-            btnsizer.AddButton(btn)
-        btnsizer.Realize()
-        Sizer.Add((-1,5))
-        Sizer.Add(btnsizer,0,wx.ALIGN_LEFT,20)
-        Sizer.Add((-1,5))
-        # OK done, let's get outa here
-        panel.SetSizer(Sizer)
-        panel.SetAutoLayout(1)
-        panel.SetupScrolling()
-        Size = [450,375]
-        panel.SetSize(Size)
-        Size[0] += 25; Size[1]+= 25
-        self.SetSize(Size)
-        
-    def GetSelection(self):
-        'Returns the selected sample parm for each column'
-        selCols = []
-        for item in self.sel:
-            selCols.append(item.GetValue())
-        return selCols,self.ColumnData
-
-################################################################################
-
-def ItemSelector(ChoiceList, ParentFrame=None,
-                 title='Select an item',
-                 size=None, header='Item Selector',
-                 useCancel=True,multiple=False):
-    ''' Provide a wx dialog to select a single item or multiple items from list of choices
-
-    :param list ChoiceList: a list of choices where one will be selected
-    :param wx.Frame ParentFrame: Name of parent frame (default None)
-    :param str title: heading above list of choices (default 'Select an item')
-    :param wx.Size size: Size for dialog to be created (default None -- size as needed)
-    :param str header: Title to place on window frame (default 'Item Selector')
-    :param bool useCancel: If True (default) both the OK and Cancel buttons are offered
-    :param bool multiple: If True then multiple items can be selected (default False)
-    
-    :returns: the selection index or None or a selection list if multiple is true
-    '''
-    if multiple:
-        if useCancel:
-            dlg = G2G.G2MultiChoiceDialog(
-                ParentFrame,title, header, ChoiceList)
-        else:
-            dlg = G2G.G2MultiChoiceDialog(
-                ParentFrame,title, header, ChoiceList,
-                style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.OK|wx.CENTRE)
-    else:
-        if useCancel:
-            dlg = wx.SingleChoiceDialog(
-                ParentFrame,title, header, ChoiceList)
-        else:
-            dlg = wx.SingleChoiceDialog(
-                ParentFrame,title, header,ChoiceList,
-                style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.OK|wx.CENTRE)
-    if size: dlg.SetSize(size)
-    if dlg.ShowModal() == wx.ID_OK:
-        if multiple:
-            dlg.Destroy()
-            return dlg.GetSelections()
-        else:
-            dlg.Destroy()
-            return dlg.GetSelection()
-    else:
-        dlg.Destroy()
-        return None
-    dlg.Destroy()
-
-################################################################################
-class GridFractionEditor(wg.PyGridCellEditor):
-    '''A grid cell editor class that allows entry of values as fractions as well
-    as sine and cosine values [as s() and c()]
-    '''
-    def __init__(self,grid):
-        wg.PyGridCellEditor.__init__(self)
-
-    def Create(self, parent, id, evtHandler):
-        self._tc = wx.TextCtrl(parent, id, "")
-        self._tc.SetInsertionPoint(0)
-        self.SetControl(self._tc)
-
-        if evtHandler:
-            self._tc.PushEventHandler(evtHandler)
-
-        self._tc.Bind(wx.EVT_CHAR, self.OnChar)
-
-    def SetSize(self, rect):
-        self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
-                               wx.SIZE_ALLOW_MINUS_ONE)
-
-    def BeginEdit(self, row, col, grid):
-        self.startValue = grid.GetTable().GetValue(row, col)
-        self._tc.SetValue(str(self.startValue))
-        self._tc.SetInsertionPointEnd()
-        self._tc.SetFocus()
-        self._tc.SetSelection(0, self._tc.GetLastPosition())
-
-    def EndEdit(self, row, col, grid, oldVal=None):
-        changed = False
-
-        self.nextval = self.startValue
-        val = self._tc.GetValue().lower()
-        if val != self.startValue:
-            changed = True
-            neg = False
-            if '-' in val:
-                neg = True
-            if '/' in val and '.' not in val:
-                val += '.'
-            elif 's' in val and not 'sind(' in val:
-                if neg:
-                    val = '-sind('+val.strip('-s')+')'
-                else:
-                    val = 'sind('+val.strip('s')+')'
-            elif 'c' in val and not 'cosd(' in val:
-                if neg:
-                    val = '-cosd('+val.strip('-c')+')'
-                else:
-                    val = 'cosd('+val.strip('c')+')'
-            try:
-                self.nextval = val = float(eval(val))
-            except (SyntaxError,NameError,ZeroDivisionError):
-                val = self.startValue
-                return None
-            
-            if oldVal is None: # this arg appears in 2.9+; before, we should go ahead & change the table
-                grid.GetTable().SetValue(row, col, val) # update the table
-            # otherwise self.ApplyEdit gets called
-
-        self.startValue = ''
-        self._tc.SetValue('')
-        return changed
-    
-    def ApplyEdit(self, row, col, grid):
-        """ Called only in wx >= 2.9
-        Save the value of the control into the grid if EndEdit() returns as True
-        """
-        grid.GetTable().SetValue(row, col, self.nextval) # update the table
-
-    def Reset(self):
-        self._tc.SetValue(self.startValue)
-        self._tc.SetInsertionPointEnd()
-
-    def Clone(self):
-        return GridFractionEditor(grid)
-
-    def StartingKey(self, evt):
-        self.OnChar(evt)
-        if evt.GetSkipped():
-            self._tc.EmulateKeyPress(evt)
-
-    def OnChar(self, evt):
-        key = evt.GetKeyCode()
-        if key == 15:
-            return
-        if key > 255:
-            evt.Skip()
-            return
-        char = chr(key)
-        if char in '.+-/0123456789cosind()':
-            self._tc.WriteText(char)
-        else:
-            evt.Skip()
-
 ################################################################################
 class ShowLSParms(wx.Dialog):
@@ -1927 +1343 @@
         self.DestroyChildren()
                    
+
 ################################################################################
-#####  GSNotebook
-################################################################################           
-       
-class GSNoteBook(wx.aui.AuiNotebook):
-    '''Notebook used in various locations; implemented with wx.aui extension
-    '''
-    def __init__(self, parent, name='',size = None):
-        wx.aui.AuiNotebook.__init__(self, parent, -1,
-                                    style=wx.aui.AUI_NB_TOP |
-                                    wx.aui.AUI_NB_SCROLL_BUTTONS)
-        if size: self.SetSize(size)
-        self.parent = parent
-        self.PageChangeHandler = None
-        
-    def PageChangeEvent(self,event):
-        G2frame = self.parent.G2frame
-        page = event.GetSelection()
-        if self.PageChangeHandler:
-            if log.LogInfo['Logging']:
-                log.MakeTabLog(
-                    G2frame.dataFrame.GetTitle(),
-                    G2frame.dataDisplay.GetPageText(page)
-                    )
-            self.PageChangeHandler(event)
-            
-    def Bind(self,eventtype,handler,*args,**kwargs):
-        '''Override the Bind() function so that page change events can be trapped
-        '''
-        if eventtype == wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED:
-            self.PageChangeHandler = handler
-            wx.aui.AuiNotebook.Bind(self,eventtype,self.PageChangeEvent)
-            return
-        wx.aui.AuiNotebook.Bind(self,eventtype,handler,*args,**kwargs)
-                                                      
-    def Clear(self):        
-        GSNoteBook.DeleteAllPages(self)
-        
-    def FindPage(self,name):
-        numPage = self.GetPageCount()
-        for page in range(numPage):
-            if self.GetPageText(page) == name:
-                return page
-
-    def ChangeSelection(self,page):
-        # in wx.Notebook ChangeSelection is like SetSelection, but it
-        # does not invoke the event related to pressing the tab button
-        # I don't see a way to do that in aui.
-        oldPage = self.GetSelection()
-        self.SetSelection(page)
-        return oldPage
-
-    # def __getattribute__(self,name):
-    #     '''This method provides a way to print out a message every time
-    #     that a method in a class is called -- to see what all the calls
-    #     might be, or where they might be coming from.
-    #     Cute trick for debugging!
-    #     '''
-    #     attr = object.__getattribute__(self, name)
-    #     if hasattr(attr, '__call__'):
-    #         def newfunc(*args, **kwargs):
-    #             print('GSauiNoteBook calling %s' %attr.__name__)
-    #             result = attr(*args, **kwargs)
-    #             return result
-    #         return newfunc
-    #     else:
-    #         return attr
-            
-################################################################################
-#####  GSGrid
-################################################################################           
-       
-class GSGrid(wg.Grid):
-    '''Basic wx.Grid implementation
-    '''
-    def __init__(self, parent, name=''):
-        wg.Grid.__init__(self,parent,-1,name=name)                    
-        #self.SetSize(parent.GetClientSize())
-        # above removed to speed drawing of initial grid
-        # does not appear to be needed
-            
-    def Clear(self):
-        wg.Grid.ClearGrid(self)
-        
-    def SetCellReadOnly(self,r,c,readonly=True):
-        self.SetReadOnly(r,c,isReadOnly=readonly)
-        
-    def SetCellStyle(self,r,c,color="white",readonly=True):
-        self.SetCellBackgroundColour(r,c,color)
-        self.SetReadOnly(r,c,isReadOnly=readonly)
-        
-    def GetSelection(self):
-        #this is to satisfy structure drawing stuff in G2plt when focus changes
-        return None
-
-    def InstallGridToolTip(self, rowcolhintcallback,
-                           colLblCallback=None,rowLblCallback=None):
-        '''code to display a tooltip for each item on a grid
-        from http://wiki.wxpython.org/wxGrid%20ToolTips (buggy!), expanded to
-        column and row labels using hints from
-        https://groups.google.com/forum/#!topic/wxPython-users/bm8OARRVDCs
-
-        :param function rowcolhintcallback: a routine that returns a text
-          string depending on the selected row and column, to be used in
-          explaining grid entries.
-        :param function colLblCallback: a routine that returns a text
-          string depending on the selected column, to be used in
-          explaining grid columns (if None, the default), column labels
-          do not get a tooltip.
-        :param function rowLblCallback: a routine that returns a text
-          string depending on the selected row, to be used in
-          explaining grid rows (if None, the default), row labels
-          do not get a tooltip.
-        '''
-        prev_rowcol = [None,None,None]
-        def OnMouseMotion(event):
-            # event.GetRow() and event.GetCol() would be nice to have here,
-            # but as this is a mouse event, not a grid event, they are not
-            # available and we need to compute them by hand.
-            x, y = self.CalcUnscrolledPosition(event.GetPosition())
-            row = self.YToRow(y)
-            col = self.XToCol(x)
-            hinttext = ''
-            win = event.GetEventObject()
-            if [row,col,win] == prev_rowcol: # no change from last position
-                event.Skip()
-                return
-            if win == self.GetGridWindow() and row >= 0 and col >= 0:
-                hinttext = rowcolhintcallback(row, col)
-            elif win == self.GetGridColLabelWindow() and col >= 0:
-                if colLblCallback: hinttext = colLblCallback(col)
-            elif win == self.GetGridRowLabelWindow() and row >= 0:
-                if rowLblCallback: hinttext = rowLblCallback(row)
-            else: # this should be the upper left corner, which is empty
-                event.Skip()
-                return
-            if hinttext is None: hinttext = ''
-            win.SetToolTipString(hinttext)
-            prev_rowcol[:] = [row,col,win]
-            event.Skip()
-
-        wx.EVT_MOTION(self.GetGridWindow(), OnMouseMotion)
-        if colLblCallback: wx.EVT_MOTION(self.GetGridColLabelWindow(), OnMouseMotion)
-        if rowLblCallback: wx.EVT_MOTION(self.GetGridRowLabelWindow(), OnMouseMotion)
-                                                    
-################################################################################
-#####  Table
-################################################################################           
-       
-class Table(wg.PyGridTableBase):
-    '''Basic data table for use with GSgrid
-    '''
-    def __init__(self, data=[], rowLabels=None, colLabels=None, types = None):
-        wg.PyGridTableBase.__init__(self)
-        self.colLabels = colLabels
-        self.rowLabels = rowLabels
-        self.dataTypes = types
-        self.data = data
-        
-    def AppendRows(self, numRows=1):
-        self.data.append([])
-        return True
-        
-    def CanGetValueAs(self, row, col, typeName):
-        if self.dataTypes:
-            colType = self.dataTypes[col].split(':')[0]
-            if typeName == colType:
-                return True
-            else:
-                return False
-        else:
-            return False
-
-    def CanSetValueAs(self, row, col, typeName):
-        return self.CanGetValueAs(row, col, typeName)
-
-    def DeleteRow(self,pos):
-        data = self.GetData()
-        self.SetData([])
-        new = []
-        for irow,row in enumerate(data):
-            if irow <> pos:
-                new.append(row)
-        self.SetData(new)
-        
-    def GetColLabelValue(self, col):
-        if self.colLabels:
-            return self.colLabels[col]
-            
-    def GetData(self):
-        data = []
-        for row in range(self.GetNumberRows()):
-            data.append(self.GetRowValues(row))
-        return data
-        
-    def GetNumberCols(self):
-        try:
-            return len(self.colLabels)
-        except TypeError:
-            return None
-        
-    def GetNumberRows(self):
-        return len(self.data)
-        
-    def GetRowLabelValue(self, row):
-        if self.rowLabels:
-            return self.rowLabels[row]
-        
-    def GetColValues(self, col):
-        data = []
-        for row in range(self.GetNumberRows()):
-            data.append(self.GetValue(row, col))
-        return data
-        
-    def GetRowValues(self, row):
-        data = []
-        for col in range(self.GetNumberCols()):
-            data.append(self.GetValue(row, col))
-        return data
-        
-    def GetTypeName(self, row, col):
-        try:
-            if self.data[row][col] is None: return None
-            return self.dataTypes[col]
-        except (TypeError,IndexError):
-            return None
-
-    def GetValue(self, row, col):
-        try:
-            if self.data[row][col] is None: return ""
-            return self.data[row][col]
-        except IndexError:
-            return None
-            
-    def InsertRows(self, pos, rows):
-        for row in range(rows):
-            self.data.insert(pos,[])
-            pos += 1
-        
-    def IsEmptyCell(self,row,col):
-        try:
-            return not self.data[row][col]
-        except IndexError:
-            return True
-        
-    def OnKeyPress(self, event):
-        dellist = self.GetSelectedRows()
-        if event.GetKeyCode() == wx.WXK_DELETE and dellist:
-            grid = self.GetView()
-            for i in dellist: grid.DeleteRow(i)
-                
-    def SetColLabelValue(self, col, label):
-        numcols = self.GetNumberCols()
-        if col > numcols-1:
-            self.colLabels.append(label)
-        else:
-            self.colLabels[col]=label
-        
-    def SetData(self,data):
-        for row in range(len(data)):
-            self.SetRowValues(row,data[row])
-                
-    def SetRowLabelValue(self, row, label):
-        self.rowLabels[row]=label
-            
-    def SetRowValues(self,row,data):
-        self.data[row] = data
-            
-    def SetValue(self, row, col, value):
-        def innerSetValue(row, col, value):
-            try:
-                self.data[row][col] = value
-            except TypeError:
-                return
-            except IndexError:
-                print row,col,value
-                # add a new row
-                if row > self.GetNumberRows():
-                    self.data.append([''] * self.GetNumberCols())
-                elif col > self.GetNumberCols():
-                    for row in range(self.GetNumberRows):
-                        self.data[row].append('')
-                print self.data
-                self.data[row][col] = value
-        innerSetValue(row, col, value)
-
-################################################################################
-#####  Notebook
-################################################################################           
-       
+#####  Notebook Tree Item editor
+################################################################################                  
 def UpdateNotebook(G2frame,data):
     '''Called when the data tree notebook entry is selected. Allows for
@@ -2240 +1370 @@
             
 ################################################################################
-#####  Controls
+#####  Controls Tree Item editor
 ################################################################################           
-       
 def UpdateControls(G2frame,data):
     '''Edit overall GSAS-II controls in main Controls data tree entry
@@ -2602 +1731 @@
                 'No columns selected in table. Click on column labels to select fields for rename.')
             return
-        dlg = MultiStringDialog(G2frame.dataDisplay,'Set column names',colNames,newNames)
+        dlg = G2G.MultiStringDialog(G2frame.dataDisplay,'Set column names',colNames,newNames)
         if dlg.Show():
             newNames = dlg.GetValues()            
@@ -2760 +1889 @@
         'Ask the user to select a pseudo var expression to delete'
         choices = Controls['SeqPseudoVars'].keys()
-        selected = ItemSelector(
+        selected = G2G.ItemSelector(
             choices,G2frame.dataFrame,
             multiple=True,
@@ -2777 +1906 @@
             selected = 0
         else:
-            selected = ItemSelector(
+            selected = G2G.ItemSelector(
                 choices,G2frame.dataFrame,
                 multiple=False,
@@ -3015 +2144 @@
         'Ask the user to select function to delete'
         txtlst = [obj.GetDepVar()+' = '+obj.expression for obj in Controls['SeqParFitEqList']]
-        selected = ItemSelector(
+        selected = G2G.ItemSelector(
             txtlst,G2frame.dataFrame,
             multiple=True,
@@ -3031 +2160 @@
             selected = 0
         else:
-            selected = ItemSelector(
+            selected = G2G.ItemSelector(
                 txtlst,G2frame.dataFrame,
                 multiple=False,
@@ -3083 +2212 @@
             selected = 0
         else:
-            selected = ItemSelector(
+            selected = G2G.ItemSelector(
                 txtlst,G2frame.dataFrame,
                 multiple=False,
@@ -3132 +2261 @@
         var = colLabels[col]
         lbl = variableLabels.get(var,G2obj.fmtVarDescr(var))
-        dlg = SingleStringDialog(G2frame.dataFrame,'Set variable label',
+        dlg = G2G.SingleStringDialog(G2frame.dataFrame,'Set variable label',
                                  'Set a new name for variable '+var,lbl,size=(400,-1))
         if dlg.Show():
@@ -3473 +2602 @@
     depVarDict.update({var:val for var,val in data[name].get('newCellDict',{}).values()})
 
-    G2frame.dataDisplay = GSGrid(parent=G2frame.dataFrame)
-    G2frame.SeqTable = Table(
+    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
+    G2frame.SeqTable = G2G.Table(
         [list(c) for c in zip(*colList)],     # convert from columns to rows
         colLabels=colLabels,rowLabels=histNames,types=Types)
@@ -4054 +3183 @@
             G2frame.dataFrame.SetMenuBar(menu)
 
-def HorizontalLine(sizer,parent):
-    '''Draws a horizontal line as wide as the window.
-    This shows up on the Mac as a very thin line, no matter what I do
-    '''
-    line = wx.StaticLine(parent,-1, size=(-1,3), style=wx.LI_HORIZONTAL)
-    sizer.Add(line, 0, wx.EXPAND|wx.ALIGN_CENTER|wx.ALL, 10)
-
 def HowDidIgetHere():
     '''Show a traceback with calls that brought us to the current location.

trunk/GSASIIimgGUI.py

@@ -1278 +1278 @@
                                            max=100.,OnLeave=Replot,nDig=[8,2])
                 littleSizer.Add(spotDiameter,0,WACV)
-                spotDelete = G2gd.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                spotDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
                                             locationcode='Delete+Points+'+str(i),
                                             handler=onDeleteMask)
@@ -1301 +1301 @@
                                            min=0.001,max=1.,OnLeave=Replot,nDig=[8,3])
                 littleSizer.Add(ringThick,0,WACV)
-                ringDelete = G2gd.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                ringDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
                                             locationcode='Delete+Rings+'+str(i),
                                             handler=onDeleteMask)
@@ -1331 +1331 @@
                                            min=0.001,max=20.,OnLeave=Replot,nDig=[8,3])
                 littleSizer.Add(arcThick,0,WACV)
-                arcDelete = G2gd.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                arcDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
                                             locationcode='Delete+Arcs+'+str(i),
                                             handler=onDeleteMask)
@@ -1349 +1349 @@
                 polyText = wx.ComboBox(G2frame.dataDisplay,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
                 littleSizer.Add(polyText,0,WACV)
-                polyDelete = G2gd.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+                polyDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
                                             locationcode='Delete+Polygons+'+str(i),
                                             handler=onDeleteMask)
@@ -1365 +1365 @@
         frameText = wx.ComboBox(G2frame.dataDisplay,value=frameList[0],choices=frameList,style=wx.CB_READONLY)
         littleSizer.Add(frameText,0,WACV)
-        frameDelete = G2gd.G2LoggedButton(G2frame.dataDisplay,label='delete?',
+        frameDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
                                             locationcode='Delete+Frame',
                                             handler=onDeleteFrame)
@@ -1515 +1515 @@
         ifany = False
         Names = [' ','Sample phi','Sample z','Sample load']
-        dlg = G2gd.G2ColumnIDDialog( G2frame,' Choose multihistogram metadata columns:',
+        dlg = G2G.G2ColumnIDDialog( G2frame,' Choose multihistogram metadata columns:',
             'Select columns',Comments,Names,np.array(newItems).T)
         try:

trunk/GSASIIphsGUI.py

@@ -1050 +1050 @@
             mainSizer.Add((5,5),0)            
             mainSizer.Add(ElemSizer())
-        G2gd.HorizontalLine(mainSizer,General)
+        G2G.HorizontalLine(mainSizer,General)
         
         if generalData['Type'] in ['modulated','magnetic',]:
@@ -1057 +1057 @@
             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_4DCHARGEFLIP,True)
             mainSizer.Add(ModulatedSizer(generalData['Type']))
-            G2gd.HorizontalLine(mainSizer,General)
+            G2G.HorizontalLine(mainSizer,General)
         else:
             G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_SINGLEMCSA,True)
@@ -1064 +1064 @@
 
         mainSizer.Add(PawleySizer())
-        G2gd.HorizontalLine(mainSizer,General)
+        G2G.HorizontalLine(mainSizer,General)
         
         mainSizer.Add(MapSizer())
-        G2gd.HorizontalLine(mainSizer,General)
+        G2G.HorizontalLine(mainSizer,General)
         
         mainSizer.Add(FlipSizer())
         if generalData['Type'] in ['nuclear','macromolecular']:
-            G2gd.HorizontalLine(mainSizer,General)
+            G2G.HorizontalLine(mainSizer,General)
             mainSizer.Add(MCSASizer())
         G2frame.dataFrame.SetStatusText('')
@@ -1375 +1375 @@
                 table.append(atom)
                 rowLabels.append(str(i))
-            atomTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            atomTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
             Atoms.SetTable(atomTable, True)
             Atoms.frm = -1            
@@ -1387 +1387 @@
             attr = wx.grid.GridCellAttr()
             attr.IncRef()               #fix from Jim Hester
-            attr.SetEditor(G2gd.GridFractionEditor(Atoms))
+            attr.SetEditor(G2G.GridFractionEditor(Atoms))
             for c in range(colX,colX+3):
                 attr = wx.grid.GridCellAttr()
                 attr.IncRef()               #fix from Jim Hester
-                attr.SetEditor(G2gd.GridFractionEditor(Atoms))
+                attr.SetEditor(G2G.GridFractionEditor(Atoms))
                 Atoms.SetColAttr(c, attr)
             for i in range(colU11-1,colU11+6):
@@ -1729 +1729 @@
                     limits = [0.,0.25]
                     val = 0.01
-                dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for '+parm,val,limits)
+                dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new value for '+parm,val,limits)
                 if dlg.ShowModal() == wx.ID_OK:
                     parm = dlg.GetValue()
@@ -1741 +1741 @@
                 limits = [-1.,1.]
                 val = 0.
-                dlg = G2gd.SingleFloatDialog(G2frame,'Atom shift','Enter shift for '+parm,val,limits)
+                dlg = G2G.SingleFloatDialog(G2frame,'Atom shift','Enter shift for '+parm,val,limits)
                 if dlg.ShowModal() == wx.ID_OK:
                     parm = dlg.GetValue()
@@ -2292 +2292 @@
                 uij = atom[cia+2:cia+8]
                 for SS in ['SS1',]:  #future SS2 & SS3 - I doubt it!
-                    G2gd.HorizontalLine(mainSizer,waveData)
+                    G2G.HorizontalLine(mainSizer,waveData)
                     mainSizer.Add(AtomSizer(SS,atom))
                     for Stype in ['Sfrac','Spos','Sadp','Smag']:
@@ -2641 +2641 @@
             rowLabels.append(str(i))
 
-        atomTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+        atomTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
         drawAtoms.SetTable(atomTable, True)
         drawAtoms.SetMargins(0,0)
@@ -5130 +5130 @@
             Types = [wg.GRID_VALUE_BOOL,wg.GRID_VALUE_BOOL,wg.GRID_VALUE_FLOAT+':10,4',
                 wg.GRID_VALUE_FLOAT+':10,4',]+maxVary*[wg.GRID_VALUE_FLOAT+':10,5',]
-            resultsTable = G2gd.Table(resultVals,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            resultsGrid = G2gd.GSGrid(G2frame.MCSA)
+            resultsTable = G2G.Table(resultVals,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            resultsGrid = G2G.GSGrid(G2frame.MCSA)
             resultsGrid.SetTable(resultsTable, True)
             resultsGrid.Bind(wg.EVT_GRID_CELL_LEFT_CLICK, OnCellChange)
@@ -5180 +5180 @@
                     mainSizer.Add(Rsizer)
                     Xsize = max(Rsizer.GetMinSize()[0],Xsize)
-                G2gd.HorizontalLine(mainSizer,G2frame.MCSA)
+                G2G.HorizontalLine(mainSizer,G2frame.MCSA)
                 
         if not data['MCSA']['Results']:
@@ -5419 +5419 @@
                     2*[wg.GRID_VALUE_FLOAT+':10,2',]
                 pos = [5,6]
-            PawleyTable = G2gd.Table(PawleyPeaks,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            PawleyTable = G2G.Table(PawleyPeaks,rowLabels=rowLabels,colLabels=colLabels,types=Types)
             G2frame.PawleyRefl.SetTable(PawleyTable, True)
             G2frame.PawleyRefl.Bind(wx.EVT_KEY_DOWN, KeyEditPawleyGrid)                 
@@ -5614 +5614 @@
             colLabels = ['mag','x','y','z','dzero','dcent']
             Types = 6*[wg.GRID_VALUE_FLOAT+':10,4',]
-            G2frame.MapPeaksTable = G2gd.Table(mapPeaks,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            G2frame.MapPeaksTable = G2G.Table(mapPeaks,rowLabels=rowLabels,colLabels=colLabels,types=Types)
             MapPeaks.SetTable(G2frame.MapPeaksTable, True)
             MapPeaks.Bind(wg.EVT_GRID_LABEL_LEFT_CLICK, RowSelect)
@@ -6147 +6147 @@
     G2frame.dataFrame.SetLabel('Phase Data for '+PhaseName)
     G2frame.dataFrame.CreateStatusBar()
-    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
+    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     G2frame.dataDisplay.gridList = [] # list of all grids in notebook
     Pages = []    
@@ -6158 +6158 @@
     G2frame.dataDisplay.AddPage(DData,'Data')
     Pages.append('Data')
-    Atoms = G2gd.GSGrid(G2frame.dataDisplay)
+    Atoms = G2G.GSGrid(G2frame.dataDisplay)
     G2frame.dataDisplay.gridList.append(Atoms)
     G2frame.dataDisplay.AddPage(Atoms,'Atoms')
@@ -6169 +6169 @@
     G2frame.dataDisplay.AddPage(drawOptions,'Draw Options')
     Pages.append('Draw Options')
-    drawAtoms = G2gd.GSGrid(G2frame.dataDisplay)
+    drawAtoms = G2G.GSGrid(G2frame.dataDisplay)
     G2frame.dataDisplay.gridList.append(drawAtoms)
     G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
@@ -6176 +6176 @@
     G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
     Pages.append('RB Models')
-    MapPeaks = G2gd.GSGrid(G2frame.dataDisplay)
+    MapPeaks = G2G.GSGrid(G2frame.dataDisplay)
     G2frame.dataDisplay.gridList.append(MapPeaks)    
     G2frame.dataDisplay.AddPage(MapPeaks,'Map peaks')
@@ -6187 +6187 @@
     G2frame.dataDisplay.AddPage(Texture,'Texture')
     Pages.append('Texture')
-    G2frame.PawleyRefl = G2gd.GSGrid(G2frame.dataDisplay)
+    G2frame.PawleyRefl = G2G.GSGrid(G2frame.dataDisplay)
     G2frame.dataDisplay.gridList.append(G2frame.PawleyRefl)
     G2frame.dataDisplay.AddPage(G2frame.PawleyRefl,'Pawley reflections')

trunk/GSASIIplot.py

@@ -3248 +3248 @@
             Draw()
         elif event.key == 't':
-            dlg = G2gd.MultiStringDialog(G2frame,'Set titles & labels',[' Title ',' x-Label ',' y-Label '],
+            dlg = G2G.MultiStringDialog(G2frame,'Set titles & labels',[' Title ',' x-Label ',' y-Label '],
                 [Title,xLabel,yLabel])
             if dlg.Show():

trunk/GSASIIpwdGUI.py

@@ -704 +704 @@
     data['peaks'] = X
     G2frame.PatternTree.SetItemPyData(G2frame.PickId,data)
-    G2frame.PeakTable = G2gd.Table(data['peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
+    G2frame.PeakTable = G2G.Table(data['peaks'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
     G2frame.dataFrame.SetLabel('Peak List')
-    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
+    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
     G2frame.dataDisplay.SetTable(G2frame.PeakTable, True)
     setBackgroundColors()                         
@@ -914 +914 @@
             wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
             wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
-            debyeTable = G2gd.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            debyeGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
+            debyeTable = G2G.Table(data[1]['debyeTerms'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            debyeGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
             debyeGrid.SetTable(debyeTable, True)
             debyeGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
@@ -974 +974 @@
             wg.GRID_VALUE_FLOAT+':10,3',wg.GRID_VALUE_BOOL,
             wg.GRID_VALUE_FLOAT+':10,5',wg.GRID_VALUE_BOOL]
-            peaksTable = G2gd.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            peaksGrid = G2gd.GSGrid(parent=G2frame.dataDisplay)
+            peaksTable = G2G.Table(data[1]['peaksList'],rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            peaksGrid = G2G.GSGrid(parent=G2frame.dataDisplay)
             peaksGrid.SetTable(peaksTable, True)
             peaksGrid.Bind(wx.EVT_KEY_DOWN, KeyEditPeakGrid)
@@ -1071 +1071 @@
         rowLabels.append('exclude')
     Types = 2*[wg.GRID_VALUE_FLOAT+':12,5',]
-    G2frame.LimitsTable = G2gd.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+    G2frame.LimitsTable = G2G.Table(data,rowLabels=rowLabels,colLabels=colLabels,types=Types)
     G2frame.dataFrame.SetLabel('Limits')
     G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LimitMenu)
@@ -1078 +1078 @@
     G2frame.Bind(wx.EVT_MENU,OnLimitCopy,id=G2gd.wxID_LIMITCOPY)
     G2frame.Bind(wx.EVT_MENU,OnAddExcl,id=G2gd.wxID_ADDEXCLREGION)    
-    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)
+    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)
     G2frame.dataDisplay.SetTable(G2frame.LimitsTable, True)    
     G2frame.dataDisplay.SetCellStyle(0,0,VERY_LIGHT_GREY,True)
@@ -1717 +1717 @@
             freeNames[Controls[name]] = name
             Names.append(Controls[name])
-        dlg = G2gd.G2ColumnIDDialog( G2frame,' Choose multihistogram metadata columns:',
+        dlg = G2G.G2ColumnIDDialog( G2frame,' Choose multihistogram metadata columns:',
             'Select columns',Comments,Names,np.array(newItems).T)
         try:
@@ -2023 +2023 @@
         else:
             choices = ['Debye-Scherrer','Bragg-Brentano',]
-        histoType = G2gd.G2ChoiceButton(G2frame.dataDisplay,choices,
+        histoType = G2G.G2ChoiceButton(G2frame.dataDisplay,choices,
                     strLoc=data,strKey='Type',
                     onChoice=OnHistoChange)
@@ -2216 +2216 @@
             4*[wg.GRID_VALUE_LONG,]+2*[wg.GRID_VALUE_FLOAT+':10,5',]
     G2frame.PatternTree.SetItemPyData(IndexId,data)
-    G2frame.IndexPeaksTable = G2gd.Table(data[0],rowLabels=rowLabels,colLabels=colLabels,types=Types)
+    G2frame.IndexPeaksTable = G2G.Table(data[0],rowLabels=rowLabels,colLabels=colLabels,types=Types)
     G2frame.dataFrame.SetLabel('Index Peak List')
-    G2frame.dataDisplay = G2gd.GSGrid(parent=G2frame.dataFrame)                
+    G2frame.dataDisplay = G2G.GSGrid(parent=G2frame.dataFrame)                
     G2frame.dataDisplay.SetTable(G2frame.IndexPeaksTable, True)
     XY = []
@@ -2906 +2906 @@
                     hkl.insert(4,G2lat.Dsp2pos(Inst,hkl[3])+controls[1])
             table.append(row)
-        UnitCellsTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-        gridDisplay = G2gd.GSGrid(G2frame.dataDisplay)
+        UnitCellsTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+        gridDisplay = G2G.GSGrid(G2frame.dataDisplay)
         gridDisplay.SetTable(UnitCellsTable, True)
         G2frame.dataFrame.CopyCell.Enable(True)
@@ -2983 +2983 @@
         
     def MakeReflectionTable(phaseName):
-        '''Returns a wx.grid table (G2gd.Table) containing a list of all reflections
+        '''Returns a wx.grid table (G2G.Table) containing a list of all reflections
         for a phase.        
         '''
@@ -3037 +3037 @@
             if Super:
                 colLabels.insert(3,'M')
-        return G2gd.Table(refs,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+        return G2G.Table(refs,rowLabels=rowLabels,colLabels=colLabels,types=Types)
 
     def ShowReflTable(phaseName):
@@ -3143 +3143 @@
         G2frame.dataFrame.SelectPhase.Enable(False)
             
-    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
+    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     G2frame.refTable = {}
     for tabnum,phase in enumerate(phases):
-        G2frame.refTable[phase] = G2gd.GSGrid(parent=G2frame.dataDisplay)
+        G2frame.refTable[phase] = G2G.GSGrid(parent=G2frame.dataDisplay)
         G2frame.dataDisplay.AddPage(G2frame.refTable[phase],phase)
     if phaseName not in G2frame.refTable:
@@ -3365 +3365 @@
             0,WACV)
         for name in data['Substances']:
-            G2gd.HorizontalLine(substSizer,G2frame.dataDisplay)    
+            G2G.HorizontalLine(substSizer,G2frame.dataDisplay)    
             substSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Data for '+name+':'),
                 0,WACV)
@@ -4030 +4030 @@
         partSizer.Add(topSizer,0,)
         for ilev,level in enumerate(data['Particle']['Levels']):
-            G2gd.HorizontalLine(partSizer,G2frame.dataDisplay)
+            G2G.HorizontalLine(partSizer,G2frame.dataDisplay)
             topLevel = wx.BoxSizer(wx.HORIZONTAL)
             topLevel.Add(wx.StaticText(G2frame.dataDisplay,label=' Model component %d: '%(ilev)),0,WACV)
@@ -4117 +4117 @@
     topSizer.Add(esdScale,0,WACV)
     mainSizer.Add(topSizer)
-    G2gd.HorizontalLine(mainSizer,G2frame.dataDisplay)
+    G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)
     if 'Size' in data['Current']:
         if 'MaxEnt' in data['Size']['Method']:
@@ -4126 +4126 @@
     elif 'Particle' in data['Current']:
         mainSizer.Add(PartSizer(),1,wx.ALIGN_LEFT|wx.EXPAND)
-    G2gd.HorizontalLine(mainSizer,G2frame.dataDisplay)    
+    G2G.HorizontalLine(mainSizer,G2frame.dataDisplay)    
     backSizer = wx.BoxSizer(wx.HORIZONTAL)
     backSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Background:'),0,WACV)

trunk/GSASIIrestrGUI.py

@@ -29 +29 @@
 import GSASIIplot as G2plt
 import GSASIIdata as G2data
+import GSASIIctrls as G2G
 
 VERY_LIGHT_GREY = wx.Colour(235,235,235)
@@ -224 +225 @@
         if len(Lists['origin']) and len(Lists['target']):
             bond = 1.54
-            dlg = G2gd.SingleFloatDialog(G2frame,'Distance','Enter restraint distance for bond',bond,[0.01,4.],'%.4f')
+            dlg = G2G.SingleFloatDialog(G2frame,'Distance','Enter restraint distance for bond',bond,[0.01,4.],'%.4f')
             if dlg.ShowModal() == wx.ID_OK:
                 bond = dlg.GetValue()
@@ -334 +335 @@
         if len(Lists['B-atom']):
             value = 109.54
-            dlg = G2gd.SingleFloatDialog(G2frame,'Angle','Enter restraint angle ',value,[30.,180.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'Angle','Enter restraint angle ',value,[30.,180.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 value = dlg.GetValue()
@@ -722 +723 @@
             if len(ids) > 2:
                 value = 1.0
-                dlg = G2gd.SingleFloatDialog(G2frame,'Angle','Enter unit cell sum ',value,[-1.e6,1.e6],'%.2f')
+                dlg = G2G.SingleFloatDialog(G2frame,'Angle','Enter unit cell sum ',value,[-1.e6,1.e6],'%.2f')
                 if dlg.ShowModal() == wx.ID_OK:
                     value = dlg.GetValue()                
@@ -836 +837 @@
             Bonds.ClearSelection()
             val = bondList[rows[0]][2]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for bond',val,[0.,5.],'%.4f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new value for bond',val,[0.,5.],'%.4f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -850 +851 @@
             Bonds.ClearSelection()
             val = bondList[rows[0]][3]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for bond',val,[0.,1.],'%.4f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new esd for bond',val,[0.,1.],'%.4f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -918 +919 @@
                 for ibad in bad:
                     del bondList[ibad]
-            bondTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            Bonds = G2gd.GSGrid(BondRestr)
+            bondTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            Bonds = G2G.GSGrid(BondRestr)
             Bonds.SetTable(bondTable, True)
             Bonds.AutoSizeColumns(False)
@@ -966 +967 @@
             Angles.ClearSelection()
             val = angleList[rows[0]][2]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for angle',val,[0.,360.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new value for angle',val,[0.,360.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -980 +981 @@
             Angles.ClearSelection()
             val = angleList[rows[0]][3]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for angle',val,[0.,5.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new esd for angle',val,[0.,5.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -1047 +1048 @@
                 for ibad in bad:
                     del angleList[ibad]
-            angleTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            Angles = G2gd.GSGrid(AngleRestr)
+            angleTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            Angles = G2G.GSGrid(AngleRestr)
             Angles.SetTable(angleTable, True)
             Angles.AutoSizeColumns(False)
@@ -1100 +1101 @@
             Planes.ClearSelection()
             val = planeList[rows[0]][3]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for plane',val,[0.,5.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new esd for plane',val,[0.,5.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -1172 +1173 @@
                 for ibad in bad:
                     del planeList[ibad]
-            planeTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            Planes = G2gd.GSGrid(PlaneRestr)
+            planeTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            Planes = G2G.GSGrid(PlaneRestr)
             Planes.SetTable(planeTable, True)
             Planes.AutoSizeColumns(False)
@@ -1231 +1232 @@
             Volumes.ClearSelection()
             val = volumeList[rows[0]][2]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for chiral volume',val,[0.,360.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new value for chiral volume',val,[0.,360.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -1245 +1246 @@
             Volumes.ClearSelection()
             val = volumeList[rows[0]][3]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for chiral volume',val,[0.,5.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new esd for chiral volume',val,[0.,5.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -1302 +1303 @@
                 for ibad in bad:
                     del volumeList[ibad]
-            volumeTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            Volumes = G2gd.GSGrid(ChiralRestr)
+            volumeTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            Volumes = G2G.GSGrid(ChiralRestr)
             Volumes.SetTable(volumeTable, True)
             Volumes.AutoSizeColumns(False)
@@ -1360 +1361 @@
             Torsions.ClearSelection()
             val = torsionList[rows[0]][4]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for torsion restraints',val,[0.,5.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new esd for torsion restraints',val,[0.,5.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -1403 +1404 @@
                 for ibad in bad:
                     del torsionList[ibad]
-            torsionTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            TorsionRestr.Torsions = G2gd.GSGrid(TorsionRestr)
+            torsionTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            TorsionRestr.Torsions = G2G.GSGrid(TorsionRestr)
             TorsionRestr.Torsions.SetTable(torsionTable, True)
             TorsionRestr.Torsions.AutoSizeColumns(False)
@@ -1429 +1430 @@
                 rowLabels.append(item)
                 table.append(coeffDict[item])
-            coeffTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            Coeff = G2gd.GSGrid(TorsionRestr)
+            coeffTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            Coeff = G2G.GSGrid(TorsionRestr)
             Coeff.SetTable(coeffTable, True)
             Coeff.AutoSizeColumns(False)
@@ -1479 +1480 @@
             Ramas.ClearSelection()
             val = ramaList[rows[0]][4]
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for energy',val,[0.,5.],'%.2f')
+            dlg = G2G.SingleFloatDialog(G2frame,'New value','Enter new esd for energy',val,[0.,5.],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
                 parm = dlg.GetValue()
@@ -1523 +1524 @@
                 for ibad in bad:
                     del ramaList[ibad]
-            ramaTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            RamaRestr.Ramas = G2gd.GSGrid(RamaRestr)
+            ramaTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            RamaRestr.Ramas = G2G.GSGrid(RamaRestr)
             RamaRestr.Ramas.SetTable(ramaTable, True)
             RamaRestr.Ramas.AutoSizeColumns(False)
@@ -1552 +1553 @@
                     rowLabels.append(item+' term:'+str(i))
                     table.append(term)
-            coeffTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            Coeff = G2gd.GSGrid(RamaRestr)
+            coeffTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            Coeff = G2G.GSGrid(RamaRestr)
             Coeff.SetTable(coeffTable, True)
             Coeff.AutoSizeColumns(False)
@@ -1610 +1611 @@
                 return
             ChemComps.ClearSelection()
-            dlg = G2gd.SingleFloatDialog(G2frame,'New value',
+            dlg = G2G.SingleFloatDialog(G2frame,'New value',
                 'Enter new value for restraint multiplier',1.0,[-1.e6,1.e6],'%.2f')
             if dlg.ShowModal() == wx.ID_OK:
@@ -1659 +1660 @@
                 for ibad in bad:
                     del chemcompList[ibad]
-            chemcompTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            ChemComps = G2gd.GSGrid(ChemCompRestr)
+            chemcompTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            ChemComps = G2G.GSGrid(ChemCompRestr)
             ChemComps.SetTable(chemcompTable, True)
             ChemComps.AutoSizeColumns(False)
@@ -1752 +1753 @@
                 table.append(['%d %d %d'%(hkl[0],hkl[1],hkl[2]),grid,esd1,ifesd2,esd2])
                 rowLabels.append(str(i))
-            textureTable = G2gd.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
-            Textures = G2gd.GSGrid(TextureRestr)
+            textureTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
+            Textures = G2G.GSGrid(TextureRestr)
             Textures.SetTable(textureTable, True)
             Textures.AutoSizeColumns(False)
@@ -1866 +1867 @@
         G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddAARestraint, id=G2gd.wxID_AARESTRAINTADD)
         G2frame.dataFrame.Bind(wx.EVT_MENU, OnPlotAARestraint, id=G2gd.wxID_AARESTRAINTPLOT)
-    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
+    G2frame.dataDisplay = G2G.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
     
     # clear menu and menu pointers

trunk/exports/G2export_CIF.py

@@ -47 +47 @@
 import GSASIIphsGUI as G2pg
 import GSASIIstrMain as G2stMn
+import GSASIIctrls as G2G
 
 DEBUG = False    #True to skip printing of reflection/powder profile lists
@@ -1277 +1278 @@
             'dialog to edit the CIF author info'
             'Edit the CIF author name'
-            dlg = G2gd.SingleStringDialog(self.G2frame,
+            dlg = G2G.SingleStringDialog(self.G2frame,
                                           'Get CIF Author',
                                           'Provide CIF Author name (Last, First)',
@@ -1350 +1351 @@
             cpnl = wxscroll.ScrolledPanel(self.cifdefs,size=(300,300))
             cbox = wx.BoxSizer(wx.VERTICAL)
-            G2gd.HorizontalLine(cbox,cpnl)          
+            G2G.HorizontalLine(cbox,cpnl)          
             cbox.Add(
                 CIFtemplateSelect(self.cifdefs,
@@ -1359 +1360 @@
                 0,wx.EXPAND|wx.ALIGN_LEFT|wx.ALL)
             for phasenam in sorted(self.Phases.keys()):
-                G2gd.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)          
                 title = 'Phase '+phasenam
                 phasedict = self.Phases[phasenam] # pointer to current phase info            
@@ -1382 +1383 @@
                 cbox.Add((-1,2))
             for i in sorted(self.powderDict.keys()):
-                G2gd.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)          
                 hist = self.powderDict[i]
                 histblk = self.Histograms[hist]
@@ -1394 +1395 @@
                     0,wx.EXPAND|wx.ALIGN_LEFT|wx.ALL)
             for i in sorted(self.xtalDict.keys()):
-                G2gd.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)          
                 hist = self.xtalDict[i]
                 histblk = self.Histograms[hist]
@@ -1524 +1525 @@
             hbox.Add(but)
             but.SetValue(True)
-            G2gd.HorizontalLine(vbox,dlg)          
+            G2G.HorizontalLine(vbox,dlg)          
             
             cpnl = wxscroll.ScrolledPanel(dlg,size=(400,300))
@@ -1571 +1572 @@
                                  )
                 cbox.Add(dbox)
-                G2gd.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)          
             cpnl.SetSizer(cbox)
             cpnl.SetAutoLayout(1)
@@ -2215 +2216 @@
         cpnl = EditCIFpanel(self,cifblk,loopstructure,CIFdic,OKbuttons,size=(300,300))
         vbox.Add(cpnl, 1, wx.ALIGN_LEFT|wx.ALL|wx.EXPAND, 0)
-        G2gd.HorizontalLine(vbox,self)
+        G2G.HorizontalLine(vbox,self)
         vbox.Add(self.helptxt, 0, wx.EXPAND|wx.ALL, 5)
-        G2gd.HorizontalLine(vbox,self)
+        G2G.HorizontalLine(vbox,self)
         btnsizer = wx.BoxSizer(wx.HORIZONTAL)
         btn = wx.Button(self, wx.ID_CANCEL)
@@ -2439 +2440 @@
                 for i in self.cifdic[dataname].get('_enumeration_detail',values):
                     choices.append(G2IO.trim(i))
-                ent = G2gd.EnumSelector(self, dct, item, choices, values, size=(200, -1))
+                ent = G2G.EnumSelector(self, dct, item, choices, values, size=(200, -1))
                 return ent
             if self.cifdic[dataname].get('_type') == 'numb':