Ticket #1140: gGridEditors-v2.py

"""Grid Editors

20080131 - GNT
"""

import wx
import dabo
import datetime
import time
import locale
import sys
dabo.ui.loadUI("wx")
from dabo.dBug import loggit

# There is an issue with this renderer class where a black highlight remains around changed cells.  This is caused
# purely by the use of this renderer.

# todo: sometimes the column is formated bold, not always
# todo: if the row/column is selected and a diffent cell then the gDropdownList-Column, then the background is
#       not displayed properly.        
# todo: if in editmode and the header is click to sort, the dropdownlist is not updated
# todo: if started, the keys are not found, i.e. Draw is called before getLookupDict
# todo: sorts by keys, not values.

# TODO: If this becomes included within dabo, it is recommended to remove the need for 
# getKeys, getChoices, getValueMode and set these arguements in the dGrid._updateEditor function as with the existing List Editor
class gGridDropdownListRenderer(wx.grid.PyGridCellRenderer):
    """Display the Lookup value of a combo or list box instead of the actual value.
    You must inherit this class and override the getKeys, getChoices and getValueMode Functions."""
    def __init__(self, *args, **kwargs):
        self.__valueLookupDict = self.getLookupDict()
        super(gGridDropdownListRenderer, self).__init__(*args, **kwargs)

    # These functions must be overriden
    @loggit
    def getKeys(self):
        """Override this function to return a list of stored keys stored in this datafield."""
        return [2, 4, 6, 8]
    def getChoices(self):
        """Override this function to return a list of values to be displayed for this datafield."""
        return ["The Ants", "Go Marching", "Two by Two", "Hoorah, Hoorah"]
    def getValueMode(self):
        """Override this Function to return the ValueMode for the Combo or List box."""
        return 'Key'
        
    def getLookupDict(self):
        """Override this function to return a dictionary of values to display.  The dictionary key is the stored value."""
        if self.getValueMode() == 'Key':
            keys = self.getKeys()
            choices = self.getChoices()
            return dict(zip(keys,choices))
    
        # This is the function overriden from the parent class.
    def Draw(self, grid, attr, dc, rect, row, col, isSelected): 
        """Customisation Point: Draw the data from grid in the rectangle with attributes using the dc""" 
        self.clip(dc, rect) 
        # We use our custom attr, not the one wx passes:
        attr = grid._Table.GetAttr(row, col)
        try: 
            txt = self.getValueText(grid, row, col) 
            dc.Clear()
            super(gGridDropdownListRenderer, self).Draw(grid, attr, dc, rect, row, col, isSelected)
            self.drawText(txt, attr, dc, rect) 
            #super(gGridDropdownListRenderer, self).Draw(grid, attr, dc, rect, row, col, isSelected)
        finally: 
            self.unclip(dc) 
    @loggit            
    def getValueText(self, grid, row, col): 
        """Returns the text to display in the grid.  If the key does not exist, then the 
        key will be displayed."""
        key = grid._Table.GetValue(row, col)
        return self.__valueLookupDict.get(key, "key not found")

    def drawText(self, txt, attr, dc, rect):
        dc.DrawText(txt, rect.x, rect.y) 
    def clip(self, dc, rect): 
        """Setup the clipping rectangle""" 
        dc.SetClippingRegion(rect.x, rect.y, rect.width, rect.height) 
    def unclip(self, dc): 
        """Destroy the clipping rectangle""" 
        dc.DestroyClippingRegion() 

class gGridDropdownListDebug(dabo.ui.dDropdownList):
    def onDestroy(self, evt):
        dabo.infoLog.write("gGridDropdownList: OnDestroy")
        #super(gGridDropdownListEditor, self).__init__(*args, **kwargs)
    def onCreate(self, evt):
        dabo.infoLog.write("gGridDropdownList: OnCreate ")
    def onMouseEvent(self, evt):
        dabo.infoLog.write("gGridDropdownList: MouseEvent ")
    def onGotFocus(self, evt):
        dabo.infoLog.write("gGridDropdownList: GotFocus")
    def onLostFocus(self, evt):
        dabo.infoLog.write("gGridDropdownList: LostFocus")
    def onHit(self, evt):
        dabo.infoLog.write("gGridDropdownList: Hit")
        evt.Continue = True
        #print "New Key, ", evt.EventData['index']
        #print "New Choice, ", evt.EventObject
        #evt.EventObject.SetFocus()
        args = self.endEditArgs
        kwargs = self.endEditKwargs
        self.endEdit(*args, **kwargs)
    def onValueChanged(self, evt):
        dabo.infoLog.write("gGridDropdownList: ValueChanged")
    def setEndEdit(self, endEdit, *args, **kwargs):
        self.endEdit = endEdit
        self.endEditArgs = args
        self.endEditKwargs = kwargs

class gGridDropdownList(gGridDropdownListDebug):
    """Due to an issue with PyGridCellEditor calling EndEdit on control 
       lostFocus (and the DropdownList/wx.Choice looses focus a little early),
       this class has been created with the intention of still capturing user input."""
    # I suspect that wx.grid.GridCellChoiceEditor is designed specifically 
    # not to loose focus during editing. It might be worth overriding
    # some of the functionality of dDropdownList / wx.Choice in a new subclass to behave in a similiar manner.
    def onHit(self, evt):
        args = self.endEditArgs
        kwargs = self.endEditKwargs
        self.endEdit(*args, **kwargs)

    def setEndEdit(self, endEdit, *args, **kwargs):
        self.endEdit = endEdit
        self.endEditArgs = args
        self.endEditKwargs = kwargs

# TODO: If this becomes included within dabo, it is recommended to remove the need for 
# getKeys, getChoices, getValueMode and set these arguements in the dGrid._updateEditor function as with the existing List Editor
class gGridDropdownListEditor(wx.grid.PyGridCellEditor):
    """GridComboListEditor embeds a (dabo) combo box or (dabo) list box within a (dabo) grid.
       This class must be inherited and have the getKeys, getChoices and getValueMode methods overriden."""

    # This function must be overriden
    def getKeys(self):
        """Override this function to return a list of stored keys stored in this datafield."""
        return [2, 4, 6, 8]
    def getChoices(self):
        """Override this function to return a list of values to be displayed for this datafield."""
        return ["The Ants", "Go Marching", "Two by Two", "Hoorah, Hoorah"]
    def getValueMode(self):
        """Override this Function to return the ValueMode for the Combo or List box."""
        return 'Key'
        
    def Create(self, parent, id, evtHandler, *args, **kwargs):
        control = gGridDropdownList(parent=parent, id=id, Keys=self.getKeys(), Choices=self.getChoices(), ValueMode=self.getValueMode())
        self.control = control
        self.SetControl(self.control)
        if evtHandler:
            self.control.PushEventHandler(evtHandler)
        # This Control does not appear to be receiving mouse events properly... I had this problem with the DateTextBox
        # Once the drop down list is selected, the control looses focus and then the grid will no longer be updated.
        # This is because EndEdit is called after the object has lost focus (I think). Quick Fix is to catch event in
        # above class (gGridDropdownList)
        super(gGridDropdownListEditor, self).Create(parent, id, evtHandler)
         
    def Clone(self):
        return self.__class__()

    def SetParameters(self, paramStr):
        dabo.infoLog.write("gGridDropdownListEditor: SetParameters: %s" % paramStr)
        #self.control.Choices = eval(paramStr)

    def BeginEdit(self, row, col, grid):
        self.value = grid.GetTable().GetValue(row, col)
        # todo: adapt for choice mode
        if self.value in self.control.Keys:
            self.control.Value = self.value
        else:
            dabo.infoLog.write("gGridDropdownListEditor.BeginEdit: Value not in Choices")
        self.control.setEndEdit(self.EndEdit, row, col, grid)
        self.control.SetFocus()

    def EndEdit(self, row, col, grid):
        changed = False
        v = self.control.Value
        if v != self.value and v is not None:
            changed = True
            grid.GetTable().SetValue(row, col, v)
            self.value = ""
        self.control.Value = self.value
        return changed
        
#   def SetSize(self, rectorig):
#       dabo.infoLog.write("GridListEditor: SetSize: %s" % rectorig)
#       dabo.infoLog.write("GridListEditor: type of rectorig: %s" % type(rectorig))
#       rect = wx.Rect(rectorig.X, rectorig.Y, rectorig.Width+10, rectorig.Height+10)
#       #rect = rectorig
#       dabo.infoLog.write("GridListEditor RECT: %s" % rect)
#       super(gGridDropdownListEditor, self).SetSize(rect)
#       #self.control.fitToSizer()

    def Reset(self):
        self.control.Value = self.value
    def IsAcceptedKey(self, key):
        return True
        
if __name__ == '__main__':
    class _dGrid_test(dabo.ui.dGrid):
        def initProperties(self):
            self.DataSet = [
                    {"name" : "2", "age" : 49, "coder" :  True, "color": "orange"},
                    {"name" : "4", "age" : 37, "coder" :  True, "color": "yellow"},
                    {"name" : "6", "age" : 48, "coder" :  True, "color": "red"},
                    {"name" : "8", "age": 32 , "coder" :  False, "color": "white"}]
            self.Width = 360
            self.Height = 150
            self.Editable = True
            #self.Sortable = False
            #self.Searchable = False

        def afterInit(self):
            self.super()

            self.addColumn(Name="Geek", DataField="coder", Caption="Geek?",
                    Order=10, DataType="bool", Width=60, Sortable=False,
                    Searchable=False, Editable=True, HeaderFontBold=False)

            col = dabo.ui.dColumn(self, Name="Person", Order=20, DataField="name",
                    DataType="string", Width=200, Caption="Celebrity Name",
                    Sortable=True, Searchable=True, Editable=True, Expand=False)
            self.addColumn(col)

            col.HeaderFontItalic = True
            col.HeaderBackColor = "orange"
            col.HeaderVerticalAlignment = "Top"
            col.HeaderHorizontalAlignment = "Left"
            #col.ListEditorChoices = dabo.dColors.colors
            #col.CustomEditorClass = GridListEditor

            col.CustomEditorClass = gGridDropdownListEditor
            col.CustomRendererClass = gGridDropdownListRenderer #this calls getLookupDict
            #col.CustomRendererClass = wx.grid.GridCellStringRenderer

            self.addColumn(Name="Age", Order=30, DataField="age",
                    DataType="integer", Width=40, Caption="Age",
                    Sortable=True, Searchable=True, Editable=True)

            col = dabo.ui.dColumn(self, Name="Color", Order=40, DataField="color",
                    DataType="string", Width=40, Caption="Favorite Color",
                    Sortable=True, Searchable=True, Editable=True, Expand=False)
            self.addColumn(col)

            col.ListEditorChoices = dabo.dColors.colors
            col.CustomEditorClass = col.listEditorClass
            #col.CustomEditorClass = dabo.ui.dGrid.GridListEditor
            #col.CustomEditorClass = gGridDropdownListEditor

            col.HeaderVerticalAlignment = "Bottom"
            col.HeaderHorizontalAlignment = "Right"
            col.HeaderForeColor = "brown"

            self.RowLabels = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
            #self.ShowRowLabels = True

    class TestForm(dabo.ui.dForm):
        def afterInit(self):
            self.BackColor = "khaki"
            g = self.grid = _dGrid_test(self, RegID="sampleGrid")
            self.Sizer.append(g, 1, "x", border=40, borderSides="all")
            self.Sizer.appendSpacer(10)
            gsz = dabo.ui.dGridSizer(HGap=50)

            chk = dabo.ui.dCheckBox(self, Caption="Edit Table", RegID="geekEdit",
                    DataSource="sampleGrid", DataField="Editable")
            chk.refresh()
            gsz.append(chk, row=0, col=0)

            chk = dabo.ui.dCheckBox(self, Caption="Show Row Labels",
                    RegID="showRowLabels", DataSource="sampleGrid",
                    DataField="ShowRowLabels")
            gsz.append(chk, row=1, col=0)
            chk.refresh()

            chk = dabo.ui.dCheckBox(self, Caption="Allow Multiple Selection",
                    RegID="multiSelect", DataSource="sampleGrid",
                    DataField="MultipleSelection")
            chk.refresh()
            gsz.append(chk, row=2, col=0)

            radSelect = dabo.ui.dRadioList(self, Choices=["Row", "Col", "Cell"],
                    ValueMode="string", Caption="Sel Mode", BackColor=self.BackColor,
                    DataSource="sampleGrid", DataField="SelectionMode", RegID="radSelect")
            radSelect.refresh()
            gsz.append(radSelect, row=0, col=1, rowSpan=3)

            self.Sizer.append(gsz, halign="Center", border=10)
            gsz.setColExpand(True, 1)
            self.layout()

            self.fitToSizer(20,20)


    app = dabo.dApp(MainFormClass=TestForm)
    app.setup()
    app.MainForm.radSelect.setFocus()
    app.start()
    
# GridCellChoice