Is It Possible To Embed Controls In wxgrid?

I was wondering it it was possible to embed wxpython controls directly into a wx,grid cell. An example would be a wx,Choice control.

Yes. Have a look at the wxPython demo. The Grid demo includes such examples.

If you don’t have the demo, have a look here: Index of /wxPython4/extras
Go to the subdirectory matching your wxPython version and download the demo archive.
Then unpack the archive and run demo.py.

Thanks for the tip. I downloaded the demo. I saw examples of using the built-in wx.grid cell renderers (like float and bool). I did not see and example where you can embed a GUI control like wx.choice directly into a grid cell. Am I missing something? Thanks.

E.g. GridCustEditor.py: this uses a text control, but you can use others as well:

class MyCellEditor(gridlib.GridCellEditor):
    ...
    def Create(self, parent, id, evtHandler):
        self._tc = wx.TextCtrl(parent, id, "")
        ...
        self.SetControl(self._tc)

Ah ok, Thanks so much, I’ll play around with it. I’m writing an app to control dozens of radios remotely, so I opted for a grid monitoring design. I have it running fine as a prototype.

Well, if the number of radios does not change a lot, you still may use grid sizer in a scrolled window.
Depending on your requirements, that could be easier.

I’ll send you a screen shot when I have it running. Could be hundreds of radio that need to be monitored. In order to do this I had to design a new type of radio driver architecture. It’s works well talking to wxpython.

I would say, like Dietmar, wx.ScrolledWindow as a base and on that any mix of sizers/controls works; if the underlying window manager gets too full the load can be ‘blocked’ and scrolling is still ok (almost like virtual scroll)

I have the basic wx.grid / Editor code working to display a list of embedded wx.choice controls. I was wondering if there was a way to force the grid cell to display the first choice in the wx.choice widget. It seems to require a click into the cell first to activate the control.

Source code:

import wx
import wx.grid as gridlib

import string
#---------------------------------------------------------------------------
class MyCellEditor(gridlib.GridCellEditor):
#class MyCellEditor(wx.grid.GridCellFloatEditor):
    """
    This is a sample GridCellEditor that shows you how to make your own custom
    grid editors.  All the methods that can be overridden are show here.  The
    ones that must be overridden are marked with "*Must Override*" in the
    docstring.
    The sample custom editor is a choice editor.

    Notice that in order to call the base class version of these special
    methods we use the method name preceded by "base_".  This is because these
    methods are "virtual" in C++ so if we try to call wx.grid.GridCellEditor. Create
    for example, then when the wx.Python extension module tries to call
    ptr->Create(...) then it actually calls the derived class version which
    looks up the method in this class and calls it, causing a recursion loop.
    If you don't understand any of this, don't worry, just call the "base_"
    version instead.

    NB: It comes from GridCustEditor.py available in the demo.
    """
    def __init__(self, anotherparent,controldata):
        self.superParent = anotherparent
        self.controlData = controldata
        self.choicesList = self.controlData['choices']
        print("Choices List ", self.choicesList) 
        wx.grid.GridCellEditor.__init__(self)


    def Create(self, parent, id, evtHandler):
        """
        Called to create the control, which must derive from wxControl.
        *Must Override*
        """
        self._tc = wx.Choice(parent, id, (100, 50), choices = self.choicesList)
        # display top of the lchoice list element
        self._tc.SetSelection(0) # added by rtg - no effect on grid display

        self.SetControl(self._tc)
        if evtHandler:
            self._tc.PushEventHandler(evtHandler)


    def SetSize(self, rect):
        """
        Called to position/size the edit control within the cell rectangle.
        If you don't fill the cell (the rect) then be sure to override
        PaintBackground and do something meaningful there.
        """
        #self.log.write("MyCellEditor: SetSize %s\n" % rect)
        self._tc.SetSize(rect.x, rect.y, rect.width+2, rect.height+2,
                               wx.SIZE_ALLOW_MINUS_ONE)


    def Show(self, show, attr):
        """
        Show or hide the edit control.  You can use the attr (if not None)
        to set colours or fonts for the control.
        """
        #self.log.write("MyCellEditor: Show(self, %s, %s)\n" % (show, attr))
        #self.base_Show(show, attr)
        super(MyCellEditor, self).Show(show, attr)


    def PaintBackground(self, rect, attr):
        """
        Draws the part of the cell not occupied by the edit control.  The
        base  class version just fills it with background colour from the
        attribute.  In this class the edit control fills the whole cell so
        don't do anything at all in order to reduce flicker.
        """
        pass
       # self.log.write("MyCellEditor: PaintBackground\n")


    def BeginEdit(self, row, col, grid):
        """
        Fetch the value from the table and prepare the edit control
        to begin editing.  Set the focus to the edit control.
        *Must Override*
        """
        #self.log.write("MyCellEditor: BeginEdit (%d,%d)\n" % (row, col))
        self.startValue = grid.GetTable().GetValue(row, col)
        print("Start Value ", self.startValue)
        self._tc.SetStringSelection(self.startValue)
        self._tc.SetFocus()


    def EndEdit(self, row, col, grid, oldVal):
        """
        Complete the editing of the current cell. Returns True if the value
        has changed.  If necessary, the control may be destroyed.
        *Must Override*
        """
        val = ''
        print("In ENDEDIT")
        #self.log.write("MyCellEditor: EndEdit (%d,%d)\n" % (row, col))
        changed = False
        #val = self._tc.GetValue()
        val = grid.GetTable().GetValue(row, col) # update the table
        
        valueIndex = self._tc.GetCurrentSelection() # this works
        textSelection = self.choicesList[valueIndex]
        print("Get choice current selection ", textSelection)
        # update the cell with the new value
        self.superParent.setCellValue(row,col,textSelection)
        #self.SetCellValue(0, 0, textSelection)
        
        #if val != oldVal:   #self.startValue:
         #   return val

    def ApplyEdit(self, row, col, grid):
        """
        This function should save the value of the control into the
        grid or grid table. It is called only after EndEdit() returns
        a non-None value.
        *Must Override*
        """
        print("In APPLYEDIT")
        #self.log.write("MyCellEditor: ApplyEdit (%d,%d)\n" % (row, col))
        #val = self._tc.SetSelection()
        #print("Got ApplyEdit value", val)
        grid.GetTable().SetValue(row, col, val) # update the table
        val = grid.GetTable().GetValue(row, col) # update the table
        val = self._tc.GetCurrentSelection()
        print("ApplyEdit ", val)

        self.startValue = ''
        self._tc.SetValue('')


    def Reset(self):
        """
        Reset the value in the control back to its starting value.
        *Must Override*
        """
        pass
        #self.log.write("MyCellEditor: Reset\n")
        #self._tc.SetStringSelection(self.startValue)
        #self._tc.SetInsertionPointEnd()


    def IsAcceptedKey(self, evt):
        """
        Return True to allow the given key to start editing: the base class
        version only checks that the event has no modifiers.  F2 is special
        and will always start the editor.
        """
        
        #self.log.write("MyCellEditor: IsAcceptedKey: %d\n" % (evt.GetKeyCode()))

        ## Oops, there's a bug here, we'll have to do it ourself..
        ##return self.base_IsAcceptedKey(evt)

        return (not (evt.ControlDown() or evt.AltDown()) and
                evt.GetKeyCode() != wx.WXK_SHIFT)


    def StartingKey(self, evt):
        """
        If the editor is enabled by pressing keys on the grid, this will be
        called to let the editor do something about that first key if desired.
        """
        self.log.write("MyCellEditor: StartingKey %d\n" % evt.GetKeyCode())
        key = evt.GetKeyCode()
        ch = None
        if key in [wx.WXK_NUMPAD0, wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3, wx.WXK_NUMPAD4,
                   wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7, wx.WXK_NUMPAD8, wx.WXK_NUMPAD9]:
            ch = ch = chr(ord('0') + key - wx.WXK_NUMPAD0)

        elif key < 256 and key >= 0 and chr(key) in string.printable:
            ch = chr(key)
            if not evt.ShiftDown():
                ch = ch.lower()

        if ch is not None:
            self._tc.SetStringSelection(ch)
        else:
            evt.Skip()


    def StartingClick(self):
        """
        If the editor is enabled by clicking on the cell, this method will be
        called to allow the editor to simulate the click on the control if
        needed.
        """
        pass
        #self.log.write("MyCellEditor: StartingClick\n")


    def Destroy(self):
        """final cleanup"""
        #self.log.write("MyCellEditor: Destroy\n")
        self.base_Destroy()


    def Clone(self):
        """
        Create a new object which is the copy of this one
        *Must Override*
        """
        self.log.write("MyCellEditor: Clone\n")
        return MyCellEditor(self.log)


#---------------------------------------------------------------------------
class GridEditorTest(wx.grid.Grid):
    def __init__(self, parent, metadatalist):
        wx.grid.Grid.__init__(self, parent, -1)
        metaDataList = metadatalist
        anotherParent = self
        self.log = None
        self.CreateGrid(10, 3)

        # task is to create pop-up controls for first row of GUI
        row = 0
        column = 0
        for control in metaDataList:
            # but for this example, we'll just set the custom editor on one cell
            #self.SetCellEditor(row, column, MyCellEditor(anotherParent,control))
            # and on a column
            print("Control data ", control)
            self.SetColLabelValue(column, control['columnname'])
            self.SetCellEditor(0, column, MyCellEditor(anotherParent,control))
            attr = wx.grid.GridCellAttr()
            attr.SetEditor(MyCellEditor(anotherParent,control))
            self.SetColAttr(column, attr)
            #self.SetCellValue(row, column, control['columnname'])
            self.SetColSize(row, 150)
            #self.SetColSize(1, 150)
            #self.SetColSize(2, 75)
            # need cell refresh command ????
            # refresh a cell stub
            column += 1

    def setCellValue(self,row, col,textString):
        print("setCellValue ",textString)
        self.SetCellValue(row, col, textString)


#---------------------------------------------------------------------------

class TestFrame(wx.Frame):
    def __init__(self, parent, log):
        wx.Frame.__init__(self, parent, -1, "Custom Grid Cell Editor Test",
                         size=(640,480))
        # create GUI pop-up controls
        metaDataList =[]
        MODE = {}
        MODE['row'] = 0
        MODE['column'] =0
        MODE['columnname'] ="Mode Control"
        MODE['controltype'] = 'wxchoice'
        MODE['choices'] =   ["Select Mode", "CW", "CW1", "LSB", "USB", "ISB", "AM", "SYNC", "FM", "DIG"]
        metaDataList.append(MODE)
        BW = {}
        BW['row'] = 0
        BW['column'] =1
        BW['columnname'] ="Bandwidth Control"
        BW['controltype'] = 'wxchoice'
        BW['choices'] = ['Select Bandwidth','16000', '15200', '14400', '13600', '12800','12000','11200','10400','9600', '8800','8000','7600','7200','6800','6400','6000','5600','5200','4800','4400','4000', '3800', '3600', '3400', '3200','3000','2800', '2600', '2400', '2200', '2000', '1900', '1800', '1700','1600', '1500', '1400','1300','1200','1100','1000', '900', '800','700','600', '500','450', '400','350', '300','250','220','200','170','150','120','100']
        metaDataList.append(BW)

        AGC = {}
        AGC['row'] = 0
        AGC['column'] =2
        AGC['columnname'] ="AGC Control"
        AGC['controltype'] = 'wxchoice'
        AGC['choices'] =  ['Select Agc' ,'Slow', 'Medium', 'Fast']
        metaDataList.append(AGC)
     
        grid = GridEditorTest(self, metaDataList)

#---------------------------------------------------------------------------

if __name__ == '__main__':
    import sys
    app = wx.App(False)
    frame = TestFrame(None, sys.stdout)
    frame.Show(True)
    app.MainLoop()

well, is not quite what I thought of but, anyway, I rather like it (wouldn’t have thought anything like that was possible) :ghost:

To define what is showing in the cell when the editor is not active you need to create a cell renderer class which will draw the content of the cell. There are examples of this in the demo.