Ticket #1140: gGridEditors.py

"""Grid Editors

20080131 - GNT
"""

import wx
import dabo
import datetime
import time
import locale
import sys
dabo.ui.loadUI("wx")
#Todo: I still haven't got the Tool Tip showing for the control.

# I'm unsure of how to import this as dabo.ui.dDateTextBox.CalPanel is not available.  Coppied and Pasted here, with some minor changes:
class CalPanel(dabo.ui.dPanel):
    def __init__(self, parent, pos=None, dt=None, ctrl=None ):
        if dt is None:
            self.date = datetime.date.today()
        else:
            self.date = dt
        self.ctrl = ctrl
        super(CalPanel, self).__init__(parent, pos=pos)
        
    
    def afterInit(self):
        """ Create the calendar control, and resize this panel 
        to the calendar's size.
        """
        self.cal = dabo.ui.dCalendar(self, Position=(5, 5))
        self.cal.Date = self.date
        self.cal.bindEvent(dabo.dEvents.Hit, self.onCalSelection)
        self.cal.bindEvent(dabo.dEvents.KeyChar, self.onCalKey)
        wd, ht = self.cal.Size
        self.Size = (wd+10, ht+10)
        self.BackColor = (192, 192, 0)
        self.cal.Visible = True
        
        
    def onCalSelection(self, evt):
        if self.ctrl is not None:
            self.ctrl.setDate(self.cal.Date)
            self.ctrl.setFocus()
        self.Visible = False
    
    
    def onCalKey(self, evt):
        if evt.keyCode == wx.WXK_ESCAPE:
            evt.Continue = False
            if self.ctrl is not None:
                self.ctrl.setFocus()
            self.Visible = False



class GridDateTextBox(dabo.ui.dDateTextBox):
        def showCalendar(self):
        if self.ReadOnly:
            # ignore
            return
        availHt = self.Parent.Parent.Bottom - self.Bottom
        try:
            self.calPanel.cal.Date = self.Value
        except:
            self.calPanel = CalPanel(self.Parent, dt=self.Value, ctrl=self)
        cp = self.calPanel
        cp.Position = (self.Left, self.Bottom)
        if self.Bottom + cp.Height > self.Parent.Parent.Bottom:
            # Maybe we should move it above
            if cp.Height <= self.Top:
                cp.Bottom = self.Top
            else:
                # We can't fit it cleanly, so try to fit as much as possible
                cp.Top = max(0, (self.Parent.Parent.Height - cp.Height) )
        if self.Left + cp.Width > self.Parent.Parent.Right:
            # Try moving it to the left
            cp.Left = max(0, (self.Parent.Parent.Width - cp.Width) )
        cp.Visible = True
        cp.bringToFront()
        # Commented out so that the grid control will receive the update from the Calendar
        # For some reaons the application crashes when the Cal losses focus and the focus
        #  doesn't return to the control.  I might need to execute this line but pass to the
        #  control the "End Edit" function from the GridDataEditor.
        #  Now it appears this doesn't work at all? Correction:  Seems to die when editing
        #  a bizobj DataSource?  It turns out the crash is just once the control is selected...
        # Crash is a segfault within wx libraries
        #cp.setFocus()
        
    def initEvents(self):
        self.bindEvent(dabo.dEvents.KeyChar, self.__onChar)
        self.bindEvent(dabo.dEvents.LostFocus, self.__onLostFocus)
        self.bindEvent(dabo.dEvents.MouseLeftDoubleClick, self.__onDblClick)
    
    
    def __onDblClick(self, evt):
        """ Display a calendar to allow users to select dates."""
        self.showCalendar()
        
        
    def __onChar(self, evt):
        """ If a shortcut key was pressed, process that. Otherwise, eat 
        inappropriate characters.
        """
        try:
            key = evt.keyChar.lower()
            ctrl = evt.controlDown
            shift = evt.shiftDown
            
            if ctrl:
                if shift and self.Application.Platform == "GTK":
                    # Linux reads keys differently depending on the Shift key
                    key = {72: "h", 77: "m", 83: "s"}[evt.keyCode]
                else:
                    key = {8: "h", 13: "m", 19: "s"}[evt.keyCode]
        except:
            # spurious key event; ignore
            return
        
        shortcutKeys = "t+-mhsyrc[]"
        dateEntryKeys = "0123456789/- :."
        if self.ampm:
            dateEntryKeys + "apm"
        
        if key in shortcutKeys and not self.ReadOnly:
            # There is a conflict if the key, such as '-', is used in both the 
            # date formatting and as a shortcut. So let's check the text
            # of this field to see if it is a full date or if the user is typing in
            # a value.
            adjust = True
            val = self.Value
            
            if val:
                    if isinstance(val, str) or isinstance(val, unicode):
                        valDt = self.strToDate(str(val), testing=True)
                    else:
                            valDt = val
                            
                if valDt is None:
                    adjust = False
                else:
                    # They've just finished typing a new date, or are just
                    # positioned on the field. Either way, update the stored 
                    # date to make sure they are in sync.
                    self.Value = valDt
                    evt.Continue = False
                    
                if adjust:
                    self.adjustDate(key, ctrl, shift)
    
        elif key in dateEntryKeys:
            # key can be used for date entry: allow
            pass
        elif evt.keyCode in range(32, 129):
            # key is in ascii range, but isn't one of the above
            # allowed key sets. Disallow.
            evt.stop()
        else:
            # Pass the key up the chain to process - perhaps a Tab, Enter, or Backspace...
            pass

    
    def __onLostFocus(self, evt):
        val = self.Value
        try:
            newVal = self.strToDate(self.GetValue())
            if newVal != val:
                self.Value = newVal
        except: pass
        
class GridDateEditor(wx.grid.PyGridCellEditor):
    def __init__(self, *args, **kwargs):
                super(GridDateEditor, self).__init__(*args, **kwargs)

    def Create(self, parent, id, evtHandler, *args, **kwargs):
        control = GridDateTextBox(parent=parent, id=id)
        self.control = control
        self.SetControl(self.control)
        if evtHandler:
            self.control.PushEventHandler(evtHandler)
        #super(GridDateEditor, self).Create(parent, id, evtHandler)
        

    def Clone(self):
        return self.__class__()

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

    def BeginEdit(self, row, col, grid):
        self.value = grid.GetTable().GetValue(row, col)
        update = True
                #datetime.datetime.fromtimestamp(time.mktime(time.strptime(mytime, time_format)))
                
        try:
                try:
                        timeValue = time.strptime(self.value, self.DateFormat)
                    except ValueError:
                            #Take our best Guess
                            dabo.infoLog.write("GridDateEditor: Guessing Time Format")
                            try:
                                    timeValue = self.control.strToDate(self.value).timetuple()
                            except:
                                    # Still No Luck, default to today
                                    update = dabo.ui.areYouSure(title='Error in Existing Date Format', message='Do you want to reset this date field?',
                                                             cancelButton=False)
                                        timeValue = datetime.date.today().timetuple()
                    
                    if update:      
                    dateValue = datetime.date(timeValue[0], timeValue[1], timeValue[2])
                    self.control.Value = dateValue
                    #self.control.Value = self.value

        except ValueError, vError:
            dabo.infoLog.write("GridDateEditor: ValueError in BeginEdit: " + str(vError))

                if not update:
                        self.Reset()
                   
        self.control.SetFocus()

    def EndEdit(self, row, col, grid):
        changed = False
        v = self.control.Value.strftime(self.DateFormat)
        #v = self.control.Value
        
        if v != self.value:
            changed = True
        if changed:
            grid.GetTable().SetValue(row, col, v)
            # I don't think the DateTextBox handles an empty value?
        #self.value = ""
        #self.control.Value = self.value
        return changed

    def Reset(self):
        self.control.Value = self.value

    def SetSize(self, rectorig):
        rect = rectorig
        self.control.SetDimensions(rect.x+3, rect.y+3, rect.width-2, rect.height-2)

    def IsAcceptedKey(self, key):
        return True

        #Properties
    def _getDateFormat(self):
                # Get the date format - Make it up if none is given using the system locale
                if hasattr(self, "_dateFormat"):
                return self._dateFormat
        else:
                        #dateFormat = locale.nl_langinfo(locale.D_FMT) # %d/%m/%y
                        #pos = dateFormat.find("%")+1
                        #date1 = dateFormat[pos]
                        #pos = dateFormat.find("%", pos)+1
                        #date2 = dateFormat[pos]
                        #pos = dateFormat.find("%", pos)+1
                        #date3 = dateFormat[pos]
                        #return "%" + date1 + "-%" + date2 + "-%" + date3
                        return "%Y-%m-%d"
        
    def _setDateFormat(self, val):
            #Todo: Check format is valid
        self._dateFormat = val
    DateFormat = property(_getDateFormat, _setDateFormat, None, 
            "Get or Set the Date Format String for this Control.")


#gbd info:
#Program received signal SIGSEGV, Segmentation fault.
#[Switching to Thread 0xb7c9b6c0 (LWP 6096)]
#---Type <return> to continue, or q <return> to quit---
#0xb733a91e in wxGridCellEditor::Show () from /usr/lib/libwx_gtk2u_adv-2.8.so.0


# 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: 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
        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':
                        thisDict = {}
                        keys = self.getKeys()
                        choices = self.getChoices()
                        for i in range(len(keys)):
                                thisDict[keys[i]] = choices[i]
                        return thisDict
                
        # 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) 
                        pass
                
                
    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."""
            value = grid._Table.GetValue(row, col)
            if value in self.__valueLookupDict:
                return self.__valueLookupDict[value]
        else:
                return value

    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(dabo.ui.dDropdownList):
        """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."""

    def __init__(self, *args, **kwargs):
                # This is to allow experimentation with combo boxes as well
        self.controlClass = gGridDropdownList
        #This must be called for reasons I don't understand, and called upon this class.
                super(gGridDropdownListEditor, self).__init__(*args, **kwargs)
                
        # 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 = self.controlClass(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)
        try:
                if self.value in self.control.Keys:
                    self.control.Value = self.value
        except ValueError:
            #dabo.infoLog.write("gGridDropdownListEditor: Value not in Choices")
            pass
        
        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
        if changed:
            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

class _dGrid_test(dabo.ui.dGrid):
    def initProperties(self):
        self.DataSet = [
                {"name" : "Ed Leafe", "age" : 49, "coder" :  True, "color": "2008-10-10"},
                {"name" : "Paul McNett", "age" : 37, "coder" :  True, "color": "11-10-2008"},
                {"name" : "Ted Roche", "age" : 48, "coder" :  True, "color": "2008-10-12"},
                {"name" : "Derek Jeter", "age": 32 , "coder" :  False, "color": "white"},
                {"name" : "One", "age" : 38, "coder" :  False, "color": "orange"},
                {"name" : "Steve Wozniak", "age" : 56, "coder" :  True, "color": "yellow"},
                {"name" : 6, "age" : 22, "coder" :  False, "color": "gold"},
                {"name" : "Madeline Albright", "age" : 69, "coder" :  False, "color": "red"}]
        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
        #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 = gGridDropdownListEditor
        #col.CustomEditorClass = GridListEditor
        col.CustomEditorClass = GridDateEditor

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

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

if __name__ == '__main__':
    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