Ticket #1138: gGridEditors.3.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):
        dabo.infoLog.write("GridDateEditor: Init ")
        dabo.infoLog.write(str(args))
        dabo.infoLog.write(str(kwargs))

                super(GridDateEditor, self).__init__(*args, **kwargs)

    def Create(self, parent, id, evtHandler, *args, **kwargs):
        dabo.infoLog.write("GridDateEditor: Create")
        dabo.infoLog.write(str(args))
        dabo.infoLog.write(str(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):
        dabo.infoLog.write("GridDateEditor: BeginEdit (%d,%d)" % (row, col))
        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:
                            dabo.infoLog.write("GridDateEditor: Control Text does not Match Date Format")
                            #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
                                    dabo.infoLog.write("GridDateEditor: %s" %(str(sys.exc_info()[0])))
                                    dabo.infoLog.write("GridDateEditor: Setting Unknown Control Value 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




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" : "Halle Berry", "age" : 38, "coder" :  False, "color": "orange"},
                {"name" : "Steve Wozniak", "age" : 56, "coder" :  True, "color": "yellow"},
                {"name" : "LeBron James", "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"

        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 = gGridEditors.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()