src/generic/grideditors.cpp

///////////////////////////////////////////////////////////////////////////\r
// Name:        src/generic/grideditors.cpp\r
// Purpose:     wxGridCellEditorEvtHandler and wxGrid editors\r
// Author:      Michael Bedward (based on code by Julian Smart, Robin Dunn)\r
// Modified by: Robin Dunn, Vadim Zeitlin, Santiago Palacios\r
// Created:     1/08/1999\r
// RCS-ID:      $Id$\r
// Copyright:   (c) Michael Bedward (mbedward@ozemail.com.au)\r
// Licence:     wxWindows licence\r
/////////////////////////////////////////////////////////////////////////////\r
\r
// For compilers that support precompilation, includes "wx/wx.h".\r
#include "wx/wxprec.h"\r
\r
#ifdef __BORLANDC__\r
    #pragma hdrstop\r
#endif\r
\r
#if wxUSE_GRID\r
\r
#include "wx/grid.h"\r
\r
#ifndef WX_PRECOMP\r
    #include "wx/utils.h"\r
    #include "wx/dcclient.h"\r
    #include "wx/settings.h"\r
    #include "wx/log.h"\r
    #include "wx/textctrl.h"\r
    #include "wx/checkbox.h"\r
    #include "wx/combobox.h"\r
    #include "wx/valtext.h"\r
    #include "wx/intl.h"\r
    #include "wx/math.h"\r
    #include "wx/listbox.h"\r
#endif\r
\r
#include "wx/textfile.h"\r
#include "wx/spinctrl.h"\r
#include "wx/tokenzr.h"\r
#include "wx/renderer.h"\r
#include "wx/headerctrl.h"\r
\r
#include "wx/generic/gridsel.h"\r
#include "wx/generic/grideditors.h"\r
#include "wx/generic/private/grid.h"\r
\r
#if defined(__WXMOTIF__)\r
    #define WXUNUSED_MOTIF(identifier)  WXUNUSED(identifier)\r
#else\r
    #define WXUNUSED_MOTIF(identifier)  identifier\r
#endif\r
\r
#if defined(__WXGTK__)\r
    #define WXUNUSED_GTK(identifier)    WXUNUSED(identifier)\r
#else\r
    #define WXUNUSED_GTK(identifier)    identifier\r
#endif\r
\r
// Required for wxIs... functions\r
#include <ctype.h>\r
\r
// ============================================================================\r
// implementation\r
// ============================================================================\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellEditorEvtHandler\r
// ----------------------------------------------------------------------------\r
\r
void wxGridCellEditorEvtHandler::OnKillFocus(wxFocusEvent& event)\r
{\r
    // Don't disable the cell if we're just starting to edit it\r
    if ( m_inSetFocus )\r
    {\r
        event.Skip();\r
        return;\r
    }\r
\r
    // accept changes\r
    m_grid->DisableCellEditControl();\r
\r
    // notice that we must not skip the event here because the call above may\r
    // delete the control which received the kill focus event in the first\r
    // place and if we pretend not having processed the event, the search for a\r
    // handler for it will continue using the now deleted object resulting in a\r
    // crash\r
}\r
\r
void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)\r
{\r
    switch ( event.GetKeyCode() )\r
    {\r
        case WXK_ESCAPE:\r
            m_editor->Reset();\r
            m_grid->DisableCellEditControl();\r
            break;\r
\r
        case WXK_TAB:\r
            m_grid->GetEventHandler()->ProcessEvent( event );\r
            break;\r
\r
        case WXK_RETURN:\r
        case WXK_NUMPAD_ENTER:\r
            if (!m_grid->GetEventHandler()->ProcessEvent(event))\r
                m_editor->HandleReturn(event);\r
            break;\r
\r
        default:\r
            event.Skip();\r
            break;\r
    }\r
}\r
\r
void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)\r
{\r
    int row = m_grid->GetGridCursorRow();\r
    int col = m_grid->GetGridCursorCol();\r
    wxRect rect = m_grid->CellToRect( row, col );\r
    int cw, ch;\r
    m_grid->GetGridWindow()->GetClientSize( &cw, &ch );\r
\r
    // if cell width is smaller than grid client area, cell is wholly visible\r
    bool wholeCellVisible = (rect.GetWidth() < cw);\r
\r
    switch ( event.GetKeyCode() )\r
    {\r
        case WXK_ESCAPE:\r
        case WXK_TAB:\r
        case WXK_RETURN:\r
        case WXK_NUMPAD_ENTER:\r
            break;\r
\r
        case WXK_HOME:\r
        {\r
            if ( wholeCellVisible )\r
            {\r
                // no special processing needed...\r
                event.Skip();\r
                break;\r
            }\r
\r
            // do special processing for partly visible cell...\r
\r
            // get the widths of all cells previous to this one\r
            int colXPos = 0;\r
            for ( int i = 0; i < col; i++ )\r
            {\r
                colXPos += m_grid->GetColSize(i);\r
            }\r
\r
            int xUnit = 1, yUnit = 1;\r
            m_grid->GetScrollPixelsPerUnit(&xUnit, &yUnit);\r
            if (col != 0)\r
            {\r
                m_grid->Scroll(colXPos / xUnit - 1, m_grid->GetScrollPos(wxVERTICAL));\r
            }\r
            else\r
            {\r
                m_grid->Scroll(colXPos / xUnit, m_grid->GetScrollPos(wxVERTICAL));\r
            }\r
            event.Skip();\r
            break;\r
        }\r
\r
        case WXK_END:\r
        {\r
            if ( wholeCellVisible )\r
            {\r
                // no special processing needed...\r
                event.Skip();\r
                break;\r
            }\r
\r
            // do special processing for partly visible cell...\r
\r
            int textWidth = 0;\r
            wxString value = m_grid->GetCellValue(row, col);\r
            if ( wxEmptyString != value )\r
            {\r
                // get width of cell CONTENTS (text)\r
                int y;\r
                wxFont font = m_grid->GetCellFont(row, col);\r
                m_grid->GetTextExtent(value, &textWidth, &y, NULL, NULL, &font);\r
\r
                // try to RIGHT align the text by scrolling\r
                int client_right = m_grid->GetGridWindow()->GetClientSize().GetWidth();\r
\r
                // (m_grid->GetScrollLineX()*2) is a factor for not scrolling to far,\r
                // otherwise the last part of the cell content might be hidden below the scroll bar\r
                // FIXME: maybe there is a more suitable correction?\r
                textWidth -= (client_right - (m_grid->GetScrollLineX() * 2));\r
                if ( textWidth < 0 )\r
                {\r
                    textWidth = 0;\r
                }\r
            }\r
\r
            // get the widths of all cells previous to this one\r
            int colXPos = 0;\r
            for ( int i = 0; i < col; i++ )\r
            {\r
                colXPos += m_grid->GetColSize(i);\r
            }\r
\r
            // and add the (modified) text width of the cell contents\r
            // as we'd like to see the last part of the cell contents\r
            colXPos += textWidth;\r
\r
            int xUnit = 1, yUnit = 1;\r
            m_grid->GetScrollPixelsPerUnit(&xUnit, &yUnit);\r
            m_grid->Scroll(colXPos / xUnit - 1, m_grid->GetScrollPos(wxVERTICAL));\r
            event.Skip();\r
            break;\r
        }\r
\r
        default:\r
            event.Skip();\r
            break;\r
    }\r
}\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellEditor\r
// ----------------------------------------------------------------------------\r
\r
wxGridCellEditor::wxGridCellEditor()\r
{\r
    m_control = NULL;\r
    m_attr = NULL;\r
}\r
\r
wxGridCellEditor::~wxGridCellEditor()\r
{\r
    Destroy();\r
}\r
\r
void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),\r
                              wxWindowID WXUNUSED(id),\r
                              wxEvtHandler* evtHandler)\r
{\r
    if ( evtHandler )\r
        m_control->PushEventHandler(evtHandler);\r
}\r
\r
void wxGridCellEditor::PaintBackground(const wxRect& rectCell,\r
                                       wxGridCellAttr *attr)\r
{\r
    // erase the background because we might not fill the cell\r
    wxClientDC dc(m_control->GetParent());\r
    wxGridWindow* gridWindow = wxDynamicCast(m_control->GetParent(), wxGridWindow);\r
    if (gridWindow)\r
        gridWindow->GetOwner()->PrepareDC(dc);\r
\r
    dc.SetPen(*wxTRANSPARENT_PEN);\r
    dc.SetBrush(wxBrush(attr->GetBackgroundColour()));\r
    dc.DrawRectangle(rectCell);\r
\r
    // redraw the control we just painted over\r
    m_control->Refresh();\r
}\r
\r
void wxGridCellEditor::Destroy()\r
{\r
    if (m_control)\r
    {\r
        m_control->PopEventHandler( true /* delete it*/ );\r
\r
        m_control->Destroy();\r
        m_control = NULL;\r
    }\r
}\r
\r
void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)\r
{\r
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));\r
\r
    m_control->Show(show);\r
\r
    if ( show )\r
    {\r
        // set the colours/fonts if we have any\r
        if ( attr )\r
        {\r
            m_colFgOld = m_control->GetForegroundColour();\r
            m_control->SetForegroundColour(attr->GetTextColour());\r
\r
            m_colBgOld = m_control->GetBackgroundColour();\r
            m_control->SetBackgroundColour(attr->GetBackgroundColour());\r
\r
// Workaround for GTK+1 font setting problem on some platforms\r
#if !defined(__WXGTK__) || defined(__WXGTK20__)\r
            m_fontOld = m_control->GetFont();\r
            m_control->SetFont(attr->GetFont());\r
#endif\r
\r
            // can't do anything more in the base class version, the other\r
            // attributes may only be used by the derived classes\r
        }\r
    }\r
    else\r
    {\r
        // restore the standard colours fonts\r
        if ( m_colFgOld.Ok() )\r
        {\r
            m_control->SetForegroundColour(m_colFgOld);\r
            m_colFgOld = wxNullColour;\r
        }\r
\r
        if ( m_colBgOld.Ok() )\r
        {\r
            m_control->SetBackgroundColour(m_colBgOld);\r
            m_colBgOld = wxNullColour;\r
        }\r
\r
// Workaround for GTK+1 font setting problem on some platforms\r
#if !defined(__WXGTK__) || defined(__WXGTK20__)\r
        if ( m_fontOld.Ok() )\r
        {\r
            m_control->SetFont(m_fontOld);\r
            m_fontOld = wxNullFont;\r
        }\r
#endif\r
    }\r
}\r
\r
void wxGridCellEditor::SetSize(const wxRect& rect)\r
{\r
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));\r
\r
    m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);\r
}\r
\r
void wxGridCellEditor::HandleReturn(wxKeyEvent& event)\r
{\r
    event.Skip();\r
}\r
\r
bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)\r
{\r
    bool ctrl = event.ControlDown();\r
    bool alt  = event.AltDown();\r
\r
#ifdef __WXMAC__\r
    // On the Mac the Alt key is more like shift and is used for entry of\r
    // valid characters, so check for Ctrl and Meta instead.\r
    alt = event.MetaDown();\r
#endif\r
\r
    // Assume it's not a valid char if ctrl or alt is down, but if both are\r
    // down then it may be because of an AltGr key combination, so let them\r
    // through in that case.\r
    if ((ctrl || alt) && !(ctrl && alt))\r
        return false;\r
\r
#if wxUSE_UNICODE\r
    // if the unicode key code is not really a unicode character (it may\r
    // be a function key or etc., the platforms appear to always give us a\r
    // small value in this case) then fallback to the ASCII key code but\r
    // don't do anything for function keys or etc.\r
    if ( event.GetUnicodeKey() > 127 && event.GetKeyCode() > 127 )\r
        return false;\r
#else\r
    if ( event.GetKeyCode() > 255 )\r
        return false;\r
#endif\r
\r
    return true;\r
}\r
\r
void wxGridCellEditor::StartingKey(wxKeyEvent& event)\r
{\r
    event.Skip();\r
}\r
\r
void wxGridCellEditor::StartingClick()\r
{\r
}\r
\r
#if wxUSE_TEXTCTRL\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellTextEditor\r
// ----------------------------------------------------------------------------\r
\r
wxGridCellTextEditor::wxGridCellTextEditor()\r
{\r
    m_maxChars = 0;\r
}\r
\r
void wxGridCellTextEditor::Create(wxWindow* parent,\r
                                  wxWindowID id,\r
                                  wxEvtHandler* evtHandler)\r
{\r
    DoCreate(parent, id, evtHandler);\r
}\r
\r
void wxGridCellTextEditor::DoCreate(wxWindow* parent,\r
                                    wxWindowID id,\r
                                    wxEvtHandler* evtHandler,\r
                                    long style)\r
{\r
    style |= wxTE_PROCESS_ENTER | wxTE_PROCESS_TAB | wxNO_BORDER;\r
\r
    m_control = new wxTextCtrl(parent, id, wxEmptyString,\r
                               wxDefaultPosition, wxDefaultSize,\r
                               style);\r
\r
    // set max length allowed in the textctrl, if the parameter was set\r
    if ( m_maxChars != 0 )\r
    {\r
        Text()->SetMaxLength(m_maxChars);\r
    }\r
\r
    wxGridCellEditor::Create(parent, id, evtHandler);\r
}\r
\r
void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),\r
                                           wxGridCellAttr * WXUNUSED(attr))\r
{\r
    // as we fill the entire client area,\r
    // don't do anything here to minimize flicker\r
}\r
\r
void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)\r
{\r
    wxRect rect(rectOrig);\r
\r
    // Make the edit control large enough to allow for internal margins\r
    //\r
    // TODO: remove this if the text ctrl sizing is improved esp. for unix\r
    //\r
#if defined(__WXGTK__)\r
    if (rect.x != 0)\r
    {\r
        rect.x += 1;\r
        rect.y += 1;\r
        rect.width -= 1;\r
        rect.height -= 1;\r
    }\r
#elif defined(__WXMSW__)\r
    if ( rect.x == 0 )\r
        rect.x += 2;\r
    else\r
        rect.x += 3;\r
\r
    if ( rect.y == 0 )\r
        rect.y += 2;\r
    else\r
        rect.y += 3;\r
\r
    rect.width -= 2;\r
    rect.height -= 2;\r
#else\r
    int extra_x = ( rect.x > 2 ) ? 2 : 1;\r
    int extra_y = ( rect.y > 2 ) ? 2 : 1;\r
\r
    #if defined(__WXMOTIF__)\r
        extra_x *= 2;\r
        extra_y *= 2;\r
    #endif\r
\r
    rect.SetLeft( wxMax(0, rect.x - extra_x) );\r
    rect.SetTop( wxMax(0, rect.y - extra_y) );\r
    rect.SetRight( rect.GetRight() + 2 * extra_x );\r
    rect.SetBottom( rect.GetBottom() + 2 * extra_y );\r
#endif\r
\r
    wxGridCellEditor::SetSize(rect);\r
}\r
\r
void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)\r
{\r
    wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));\r
\r
    m_value = grid->GetTable()->GetValue(row, col);\r
\r
    DoBeginEdit(m_value);\r
}\r
\r
void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)\r
{\r
    Text()->SetValue(startValue);\r
    Text()->SetInsertionPointEnd();\r
    Text()->SetSelection(-1, -1);\r
    Text()->SetFocus();\r
}\r
\r
bool wxGridCellTextEditor::EndEdit(int WXUNUSED(row),\r
                                   int WXUNUSED(col),\r
                                   const wxGrid* WXUNUSED(grid),\r
                                   const wxString& WXUNUSED(oldval),\r
                                   wxString *newval)\r
{\r
    wxCHECK_MSG( m_control, false,\r
                 "wxGridCellTextEditor must be created first!" );\r
\r
    const wxString value = Text()->GetValue();\r
    if ( value == m_value )\r
        return false;\r
\r
    m_value = value;\r
\r
    if ( newval )\r
        *newval = m_value;\r
\r
    return true;\r
}\r
\r
void wxGridCellTextEditor::ApplyEdit(int row, int col, wxGrid* grid)\r
{\r
    grid->GetTable()->SetValue(row, col, m_value);\r
    m_value.clear();\r
}\r
\r
void wxGridCellTextEditor::Reset()\r
{\r
    wxASSERT_MSG( m_control, "wxGridCellTextEditor must be created first!" );\r
\r
    DoReset(m_value);\r
}\r
\r
void wxGridCellTextEditor::DoReset(const wxString& startValue)\r
{\r
    Text()->SetValue(startValue);\r
    Text()->SetInsertionPointEnd();\r
}\r
\r
bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)\r
{\r
    return wxGridCellEditor::IsAcceptedKey(event);\r
}\r
\r
void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)\r
{\r
    // Since this is now happening in the EVT_CHAR event EmulateKeyPress is no\r
    // longer an appropriate way to get the character into the text control.\r
    // Do it ourselves instead.  We know that if we get this far that we have\r
    // a valid character, so not a whole lot of testing needs to be done.\r
\r
    wxTextCtrl* tc = Text();\r
    wxChar ch;\r
    long pos;\r
\r
#if wxUSE_UNICODE\r
    ch = event.GetUnicodeKey();\r
    if (ch <= 127)\r
        ch = (wxChar)event.GetKeyCode();\r
#else\r
    ch = (wxChar)event.GetKeyCode();\r
#endif\r
\r
    switch (ch)\r
    {\r
        case WXK_DELETE:\r
            // delete the character at the cursor\r
            pos = tc->GetInsertionPoint();\r
            if (pos < tc->GetLastPosition())\r
                tc->Remove(pos, pos + 1);\r
            break;\r
\r
        case WXK_BACK:\r
            // delete the character before the cursor\r
            pos = tc->GetInsertionPoint();\r
            if (pos > 0)\r
                tc->Remove(pos - 1, pos);\r
            break;\r
\r
        default:\r
            tc->WriteText(ch);\r
            break;\r
    }\r
}\r
\r
void wxGridCellTextEditor::HandleReturn( wxKeyEvent&\r
                                         WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )\r
{\r
#if defined(__WXMOTIF__) || defined(__WXGTK__)\r
    // wxMotif needs a little extra help...\r
    size_t pos = (size_t)( Text()->GetInsertionPoint() );\r
    wxString s( Text()->GetValue() );\r
    s = s.Left(pos) + wxT("\n") + s.Mid(pos);\r
    Text()->SetValue(s);\r
    Text()->SetInsertionPoint( pos );\r
#else\r
    // the other ports can handle a Return key press\r
    //\r
    event.Skip();\r
#endif\r
}\r
\r
void wxGridCellTextEditor::SetParameters(const wxString& params)\r
{\r
    if ( !params )\r
    {\r
        // reset to default\r
        m_maxChars = 0;\r
    }\r
    else\r
    {\r
        long tmp;\r
        if ( params.ToLong(&tmp) )\r
        {\r
            m_maxChars = (size_t)tmp;\r
        }\r
        else\r
        {\r
            wxLogDebug( _T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str() );\r
        }\r
    }\r
}\r
\r
// return the value in the text control\r
wxString wxGridCellTextEditor::GetValue() const\r
{\r
    return Text()->GetValue();\r
}\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellNumberEditor\r
// ----------------------------------------------------------------------------\r
\r
wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)\r
{\r
    m_min = min;\r
    m_max = max;\r
}\r
\r
void wxGridCellNumberEditor::Create(wxWindow* parent,\r
                                    wxWindowID id,\r
                                    wxEvtHandler* evtHandler)\r
{\r
#if wxUSE_SPINCTRL\r
    if ( HasRange() )\r
    {\r
        // create a spin ctrl\r
        m_control = new wxSpinCtrl(parent, wxID_ANY, wxEmptyString,\r
                                   wxDefaultPosition, wxDefaultSize,\r
                                   wxSP_ARROW_KEYS,\r
                                   m_min, m_max);\r
\r
        wxGridCellEditor::Create(parent, id, evtHandler);\r
    }\r
    else\r
#endif\r
    {\r
        // just a text control\r
        wxGridCellTextEditor::Create(parent, id, evtHandler);\r
\r
#if wxUSE_VALIDATORS\r
        Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));\r
#endif\r
    }\r
}\r
\r
void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)\r
{\r
    // first get the value\r
    wxGridTableBase *table = grid->GetTable();\r
    if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )\r
    {\r
        m_value = table->GetValueAsLong(row, col);\r
    }\r
    else\r
    {\r
        m_value = 0;\r
        wxString sValue = table->GetValue(row, col);\r
        if (! sValue.ToLong(&m_value) && ! sValue.empty())\r
        {\r
            wxFAIL_MSG( _T("this cell doesn't have numeric value") );\r
            return;\r
        }\r
    }\r
\r
#if wxUSE_SPINCTRL\r
    if ( HasRange() )\r
    {\r
        Spin()->SetValue((int)m_value);\r
        Spin()->SetFocus();\r
    }\r
    else\r
#endif\r
    {\r
        DoBeginEdit(GetString());\r
    }\r
}\r
\r
bool wxGridCellNumberEditor::EndEdit(int WXUNUSED(row),\r
                                     int WXUNUSED(col),\r
                                     const wxGrid* WXUNUSED(grid),\r
                                     const wxString& oldval, wxString *newval)\r
{\r
    long value = 0;\r
    wxString text;\r
\r
#if wxUSE_SPINCTRL\r
    if ( HasRange() )\r
    {\r
        value = Spin()->GetValue();\r
        if ( value == m_value )\r
            return false;\r
\r
        text.Printf(wxT("%ld"), value);\r
    }\r
    else // using unconstrained input\r
#endif // wxUSE_SPINCTRL\r
    {\r
        text = Text()->GetValue();\r
        if ( text.empty() )\r
        {\r
            if ( oldval.empty() )\r
                return false;\r
        }\r
        else // non-empty text now (maybe 0)\r
        {\r
            if ( !text.ToLong(&value) )\r
                return false;\r
\r
            // if value == m_value == 0 but old text was "" and new one is\r
            // "0" something still did change\r
            if ( value == m_value && (value || !oldval.empty()) )\r
                return false;\r
        }\r
    }\r
\r
    m_value = value;\r
\r
    if ( newval )\r
        *newval = text;\r
\r
    return true;\r
}\r
\r
void wxGridCellNumberEditor::ApplyEdit(int row, int col, wxGrid* grid)\r
{\r
    wxGridTableBase * const table = grid->GetTable();\r
    if ( table->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER) )\r
        table->SetValueAsLong(row, col, m_value);\r
    else\r
        table->SetValue(row, col, wxString::Format("%ld", m_value));\r
}\r
\r
void wxGridCellNumberEditor::Reset()\r
{\r
#if wxUSE_SPINCTRL\r
    if ( HasRange() )\r
    {\r
        Spin()->SetValue((int)m_value);\r
    }\r
    else\r
#endif\r
    {\r
        DoReset(GetString());\r
    }\r
}\r
\r
bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)\r
{\r
    if ( wxGridCellEditor::IsAcceptedKey(event) )\r
    {\r
        int keycode = event.GetKeyCode();\r
        if ( (keycode < 128) &&\r
             (wxIsdigit(keycode) || keycode == '+' || keycode == '-'))\r
        {\r
            return true;\r
        }\r
    }\r
\r
    return false;\r
}\r
\r
void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)\r
{\r
    int keycode = event.GetKeyCode();\r
    if ( !HasRange() )\r
    {\r
        if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-')\r
        {\r
            wxGridCellTextEditor::StartingKey(event);\r
\r
            // skip Skip() below\r
            return;\r
        }\r
    }\r
#if wxUSE_SPINCTRL\r
    else\r
    {\r
        if ( wxIsdigit(keycode) )\r
        {\r
            wxSpinCtrl* spin = (wxSpinCtrl*)m_control;\r
            spin->SetValue(keycode - '0');\r
            spin->SetSelection(1,1);\r
            return;\r
        }\r
    }\r
#endif\r
\r
    event.Skip();\r
}\r
\r
void wxGridCellNumberEditor::SetParameters(const wxString& params)\r
{\r
    if ( !params )\r
    {\r
        // reset to default\r
        m_min =\r
        m_max = -1;\r
    }\r
    else\r
    {\r
        long tmp;\r
        if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )\r
        {\r
            m_min = (int)tmp;\r
\r
            if ( params.AfterFirst(_T(',')).ToLong(&tmp) )\r
            {\r
                m_max = (int)tmp;\r
\r
                // skip the error message below\r
                return;\r
            }\r
        }\r
\r
        wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());\r
    }\r
}\r
\r
// return the value in the spin control if it is there (the text control otherwise)\r
wxString wxGridCellNumberEditor::GetValue() const\r
{\r
    wxString s;\r
\r
#if wxUSE_SPINCTRL\r
    if ( HasRange() )\r
    {\r
        long value = Spin()->GetValue();\r
        s.Printf(wxT("%ld"), value);\r
    }\r
    else\r
#endif\r
    {\r
        s = Text()->GetValue();\r
    }\r
\r
    return s;\r
}\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellFloatEditor\r
// ----------------------------------------------------------------------------\r
\r
wxGridCellFloatEditor::wxGridCellFloatEditor(int width, int precision)\r
{\r
    m_width = width;\r
    m_precision = precision;\r
}\r
\r
void wxGridCellFloatEditor::Create(wxWindow* parent,\r
                                   wxWindowID id,\r
                                   wxEvtHandler* evtHandler)\r
{\r
    wxGridCellTextEditor::Create(parent, id, evtHandler);\r
\r
#if wxUSE_VALIDATORS\r
    Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));\r
#endif\r
}\r
\r
void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)\r
{\r
    // first get the value\r
    wxGridTableBase * const table = grid->GetTable();\r
    if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )\r
    {\r
        m_value = table->GetValueAsDouble(row, col);\r
    }\r
    else\r
    {\r
        m_value = 0.0;\r
\r
        const wxString value = table->GetValue(row, col);\r
        if ( !value.empty() )\r
        {\r
            if ( !value.ToDouble(&m_value) )\r
            {\r
                wxFAIL_MSG( _T("this cell doesn't have float value") );\r
                return;\r
            }\r
        }\r
    }\r
\r
    DoBeginEdit(GetString());\r
}\r
\r
bool wxGridCellFloatEditor::EndEdit(int WXUNUSED(row),\r
                                    int WXUNUSED(col),\r
                                    const wxGrid* WXUNUSED(grid),\r
                                    const wxString& oldval, wxString *newval)\r
{\r
    const wxString text(Text()->GetValue());\r
\r
    double value;\r
    if ( !text.empty() )\r
    {\r
        if ( !text.ToDouble(&value) )\r
            return false;\r
    }\r
    else // new value is empty string\r
    {\r
        if ( oldval.empty() )\r
            return false;           // nothing changed\r
\r
        value = 0.;\r
    }\r
\r
    // the test for empty strings ensures that we don't skip the value setting\r
    // when "" is replaced by "0" or vice versa as "" numeric value is also 0.\r
    if ( wxIsSameDouble(value, m_value) && !text.empty() && !oldval.empty() )\r
        return false;           // nothing changed\r
\r
    m_value = value;\r
\r
    if ( newval )\r
        *newval = text;\r
\r
    return true;\r
}\r
\r
void wxGridCellFloatEditor::ApplyEdit(int row, int col, wxGrid* grid)\r
{\r
    wxGridTableBase * const table = grid->GetTable();\r
\r
    if ( table->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT) )\r
        table->SetValueAsDouble(row, col, m_value);\r
    else\r
        table->SetValue(row, col, Text()->GetValue());\r
}\r
\r
void wxGridCellFloatEditor::Reset()\r
{\r
    DoReset(GetString());\r
}\r
\r
void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)\r
{\r
    int keycode = event.GetKeyCode();\r
    char tmpbuf[2];\r
    tmpbuf[0] = (char) keycode;\r
    tmpbuf[1] = '\0';\r
    wxString strbuf(tmpbuf, *wxConvCurrent);\r
\r
#if wxUSE_INTL\r
    bool is_decimal_point = ( strbuf ==\r
       wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER) );\r
#else\r
    bool is_decimal_point = ( strbuf == _T(".") );\r
#endif\r
\r
    if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'\r
         || is_decimal_point )\r
    {\r
        wxGridCellTextEditor::StartingKey(event);\r
\r
        // skip Skip() below\r
        return;\r
    }\r
\r
    event.Skip();\r
}\r
\r
void wxGridCellFloatEditor::SetParameters(const wxString& params)\r
{\r
    if ( !params )\r
    {\r
        // reset to default\r
        m_width =\r
        m_precision = -1;\r
    }\r
    else\r
    {\r
        long tmp;\r
        if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )\r
        {\r
            m_width = (int)tmp;\r
\r
            if ( params.AfterFirst(_T(',')).ToLong(&tmp) )\r
            {\r
                m_precision = (int)tmp;\r
\r
                // skip the error message below\r
                return;\r
            }\r
        }\r
\r
        wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params.c_str());\r
    }\r
}\r
\r
wxString wxGridCellFloatEditor::GetString() const\r
{\r
    wxString fmt;\r
    if ( m_precision == -1 && m_width != -1)\r
    {\r
        // default precision\r
        fmt.Printf(_T("%%%d.f"), m_width);\r
    }\r
    else if ( m_precision != -1 && m_width == -1)\r
    {\r
        // default width\r
        fmt.Printf(_T("%%.%df"), m_precision);\r
    }\r
    else if ( m_precision != -1 && m_width != -1 )\r
    {\r
        fmt.Printf(_T("%%%d.%df"), m_width, m_precision);\r
    }\r
    else\r
    {\r
        // default width/precision\r
        fmt = _T("%f");\r
    }\r
\r
    return wxString::Format(fmt, m_value);\r
}\r
\r
bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)\r
{\r
    if ( wxGridCellEditor::IsAcceptedKey(event) )\r
    {\r
        const int keycode = event.GetKeyCode();\r
        if ( isascii(keycode) )\r
        {\r
            char tmpbuf[2];\r
            tmpbuf[0] = (char) keycode;\r
            tmpbuf[1] = '\0';\r
            wxString strbuf(tmpbuf, *wxConvCurrent);\r
\r
#if wxUSE_INTL\r
            const wxString decimalPoint =\r
                wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER);\r
#else\r
            const wxString decimalPoint(_T('.'));\r
#endif\r
\r
            // accept digits, 'e' as in '1e+6', also '-', '+', and '.'\r
            if ( wxIsdigit(keycode) ||\r
                    tolower(keycode) == 'e' ||\r
                        keycode == decimalPoint ||\r
                            keycode == '+' ||\r
                                keycode == '-' )\r
            {\r
                return true;\r
            }\r
        }\r
    }\r
\r
    return false;\r
}\r
\r
#endif // wxUSE_TEXTCTRL\r
\r
#if wxUSE_CHECKBOX\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellBoolEditor\r
// ----------------------------------------------------------------------------\r
\r
// the default values for GetValue()\r
wxString wxGridCellBoolEditor::ms_stringValues[2] = { _T(""), _T("1") };\r
\r
void wxGridCellBoolEditor::Create(wxWindow* parent,\r
                                  wxWindowID id,\r
                                  wxEvtHandler* evtHandler)\r
{\r
    m_control = new wxCheckBox(parent, id, wxEmptyString,\r
                               wxDefaultPosition, wxDefaultSize,\r
                               wxNO_BORDER);\r
\r
    wxGridCellEditor::Create(parent, id, evtHandler);\r
}\r
\r
void wxGridCellBoolEditor::SetSize(const wxRect& r)\r
{\r
    bool resize = false;\r
    wxSize size = m_control->GetSize();\r
    wxCoord minSize = wxMin(r.width, r.height);\r
\r
    // check if the checkbox is not too big/small for this cell\r
    wxSize sizeBest = m_control->GetBestSize();\r
    if ( !(size == sizeBest) )\r
    {\r
        // reset to default size if it had been made smaller\r
        size = sizeBest;\r
\r
        resize = true;\r
    }\r
\r
    if ( size.x >= minSize || size.y >= minSize )\r
    {\r
        // leave 1 pixel margin\r
        size.x = size.y = minSize - 2;\r
\r
        resize = true;\r
    }\r
\r
    if ( resize )\r
    {\r
        m_control->SetSize(size);\r
    }\r
\r
    // position it in the centre of the rectangle (TODO: support alignment?)\r
\r
#if defined(__WXGTK__) || defined (__WXMOTIF__)\r
    // the checkbox without label still has some space to the right in wxGTK,\r
    // so shift it to the right\r
    size.x -= 8;\r
#elif defined(__WXMSW__)\r
    // here too, but in other way\r
    size.x += 1;\r
    size.y -= 2;\r
#endif\r
\r
    int hAlign = wxALIGN_CENTRE;\r
    int vAlign = wxALIGN_CENTRE;\r
    if (GetCellAttr())\r
        GetCellAttr()->GetAlignment(& hAlign, & vAlign);\r
\r
    int x = 0, y = 0;\r
    if (hAlign == wxALIGN_LEFT)\r
    {\r
        x = r.x + 2;\r
\r
#ifdef __WXMSW__\r
        x += 2;\r
#endif\r
\r
        y = r.y + r.height / 2 - size.y / 2;\r
    }\r
    else if (hAlign == wxALIGN_RIGHT)\r
    {\r
        x = r.x + r.width - size.x - 2;\r
        y = r.y + r.height / 2 - size.y / 2;\r
    }\r
    else if (hAlign == wxALIGN_CENTRE)\r
    {\r
        x = r.x + r.width / 2 - size.x / 2;\r
        y = r.y + r.height / 2 - size.y / 2;\r
    }\r
\r
    m_control->Move(x, y);\r
}\r
\r
void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)\r
{\r
    m_control->Show(show);\r
\r
    if ( show )\r
    {\r
        wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;\r
        CBox()->SetBackgroundColour(colBg);\r
    }\r
}\r
\r
void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)\r
{\r
    wxASSERT_MSG(m_control,\r
                 wxT("The wxGridCellEditor must be created first!"));\r
\r
    if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))\r
    {\r
        m_value = grid->GetTable()->GetValueAsBool(row, col);\r
    }\r
    else\r
    {\r
        wxString cellval( grid->GetTable()->GetValue(row, col) );\r
\r
        if ( cellval == ms_stringValues[false] )\r
            m_value = false;\r
        else if ( cellval == ms_stringValues[true] )\r
            m_value = true;\r
        else\r
        {\r
            // do not try to be smart here and convert it to true or false\r
            // because we'll still overwrite it with something different and\r
            // this risks to be very surprising for the user code, let them\r
            // know about it\r
            wxFAIL_MSG( _T("invalid value for a cell with bool editor!") );\r
        }\r
    }\r
\r
    CBox()->SetValue(m_value);\r
    CBox()->SetFocus();\r
}\r
\r
bool wxGridCellBoolEditor::EndEdit(int WXUNUSED(row),\r
                                   int WXUNUSED(col),\r
                                   const wxGrid* WXUNUSED(grid),\r
                                   const wxString& WXUNUSED(oldval),\r
                                   wxString *newval)\r
{\r
    bool value = CBox()->GetValue();\r
    if ( value == m_value )\r
        return false;\r
\r
    m_value = value;\r
\r
    if ( newval )\r
        *newval = GetValue();\r
\r
    return true;\r
}\r
\r
void wxGridCellBoolEditor::ApplyEdit(int row, int col, wxGrid* grid)\r
{\r
    wxGridTableBase * const table = grid->GetTable();\r
    if ( table->CanSetValueAs(row, col, wxGRID_VALUE_BOOL) )\r
        table->SetValueAsBool(row, col, m_value);\r
    else\r
        table->SetValue(row, col, GetValue());\r
}\r
\r
void wxGridCellBoolEditor::Reset()\r
{\r
    wxASSERT_MSG(m_control,\r
                 wxT("The wxGridCellEditor must be created first!"));\r
\r
    CBox()->SetValue(m_value);\r
}\r
\r
void wxGridCellBoolEditor::StartingClick()\r
{\r
    CBox()->SetValue(!CBox()->GetValue());\r
}\r
\r
bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)\r
{\r
    if ( wxGridCellEditor::IsAcceptedKey(event) )\r
    {\r
        int keycode = event.GetKeyCode();\r
        switch ( keycode )\r
        {\r
            case WXK_SPACE:\r
            case '+':\r
            case '-':\r
                return true;\r
        }\r
    }\r
\r
    return false;\r
}\r
\r
void wxGridCellBoolEditor::StartingKey(wxKeyEvent& event)\r
{\r
    int keycode = event.GetKeyCode();\r
    switch ( keycode )\r
    {\r
        case WXK_SPACE:\r
            CBox()->SetValue(!CBox()->GetValue());\r
            break;\r
\r
        case '+':\r
            CBox()->SetValue(true);\r
            break;\r
\r
        case '-':\r
            CBox()->SetValue(false);\r
            break;\r
    }\r
}\r
\r
wxString wxGridCellBoolEditor::GetValue() const\r
{\r
  return ms_stringValues[CBox()->GetValue()];\r
}\r
\r
/* static */ void\r
wxGridCellBoolEditor::UseStringValues(const wxString& valueTrue,\r
                                      const wxString& valueFalse)\r
{\r
    ms_stringValues[false] = valueFalse;\r
    ms_stringValues[true] = valueTrue;\r
}\r
\r
/* static */ bool\r
wxGridCellBoolEditor::IsTrueValue(const wxString& value)\r
{\r
    return value == ms_stringValues[true];\r
}\r
\r
#endif // wxUSE_CHECKBOX\r
\r
#if wxUSE_COMBOBOX\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellChoiceEditor\r
// ----------------------------------------------------------------------------\r
\r
wxGridCellChoiceEditor::wxGridCellChoiceEditor(const wxArrayString& choices,\r
                                               bool allowOthers)\r
    : m_choices(choices),\r
      m_allowOthers(allowOthers) { }\r
\r
wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,\r
                                               const wxString choices[],\r
                                               bool allowOthers)\r
                      : m_allowOthers(allowOthers)\r
{\r
    if ( count )\r
    {\r
        m_choices.Alloc(count);\r
        for ( size_t n = 0; n < count; n++ )\r
        {\r
            m_choices.Add(choices[n]);\r
        }\r
    }\r
}\r
\r
wxGridCellEditor *wxGridCellChoiceEditor::Clone() const\r
{\r
    wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;\r
    editor->m_allowOthers = m_allowOthers;\r
    editor->m_choices = m_choices;\r
\r
    return editor;\r
}\r
\r
void wxGridCellChoiceEditor::Create(wxWindow* parent,\r
                                    wxWindowID id,\r
                                    wxEvtHandler* evtHandler)\r
{\r
    int style = wxTE_PROCESS_ENTER |\r
                wxTE_PROCESS_TAB |\r
                wxBORDER_NONE;\r
\r
    if ( !m_allowOthers )\r
        style |= wxCB_READONLY;\r
    m_control = new wxComboBox(parent, id, wxEmptyString,\r
                               wxDefaultPosition, wxDefaultSize,\r
                               m_choices,\r
                               style);\r
\r
    wxGridCellEditor::Create(parent, id, evtHandler);\r
}\r
\r
void wxGridCellChoiceEditor::PaintBackground(const wxRect& rectCell,\r
                                             wxGridCellAttr * attr)\r
{\r
    // as we fill the entire client area, don't do anything here to minimize\r
    // flicker\r
\r
    // TODO: It doesn't actually fill the client area since the height of a\r
    // combo always defaults to the standard.  Until someone has time to\r
    // figure out the right rectangle to paint, just do it the normal way.\r
    wxGridCellEditor::PaintBackground(rectCell, attr);\r
}\r
\r
void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)\r
{\r
    wxASSERT_MSG(m_control,\r
                 wxT("The wxGridCellEditor must be created first!"));\r
\r
    wxGridCellEditorEvtHandler* evtHandler = NULL;\r
    if (m_control)\r
        evtHandler = wxDynamicCast(m_control->GetEventHandler(), wxGridCellEditorEvtHandler);\r
\r
    // Don't immediately end if we get a kill focus event within BeginEdit\r
    if (evtHandler)\r
        evtHandler->SetInSetFocus(true);\r
\r
    m_value = grid->GetTable()->GetValue(row, col);\r
\r
    Reset(); // this updates combo box to correspond to m_value\r
\r
    Combo()->SetFocus();\r
\r
    if (evtHandler)\r
    {\r
        // When dropping down the menu, a kill focus event\r
        // happens after this point, so we can't reset the flag yet.\r
#if !defined(__WXGTK20__)\r
        evtHandler->SetInSetFocus(false);\r
#endif\r
    }\r
}\r
\r
bool wxGridCellChoiceEditor::EndEdit(int WXUNUSED(row),\r
                                     int WXUNUSED(col),\r
                                     const wxGrid* WXUNUSED(grid),\r
                                     const wxString& WXUNUSED(oldval),\r
                                     wxString *newval)\r
{\r
    const wxString value = Combo()->GetValue();\r
    if ( value == m_value )\r
        return false;\r
\r
    m_value = value;\r
\r
    if ( newval )\r
        *newval = value;\r
\r
    return true;\r
}\r
\r
void wxGridCellChoiceEditor::ApplyEdit(int row, int col, wxGrid* grid)\r
{\r
    grid->GetTable()->SetValue(row, col, m_value);\r
}\r
\r
void wxGridCellChoiceEditor::Reset()\r
{\r
    if (m_allowOthers)\r
    {\r
        Combo()->SetValue(m_value);\r
        Combo()->SetInsertionPointEnd();\r
    }\r
    else // the combobox is read-only\r
    {\r
        // find the right position, or default to the first if not found\r
        int pos = Combo()->FindString(m_value);\r
        if (pos == wxNOT_FOUND)\r
            pos = 0;\r
        Combo()->SetSelection(pos);\r
    }\r
}\r
\r
void wxGridCellChoiceEditor::SetParameters(const wxString& params)\r
{\r
    if ( !params )\r
    {\r
        // what can we do?\r
        return;\r
    }\r
\r
    m_choices.Empty();\r
\r
    wxStringTokenizer tk(params, _T(','));\r
    while ( tk.HasMoreTokens() )\r
    {\r
        m_choices.Add(tk.GetNextToken());\r
    }\r
}\r
\r
// return the value in the text control\r
wxString wxGridCellChoiceEditor::GetValue() const\r
{\r
  return Combo()->GetValue();\r
}\r
\r
#endif // wxUSE_COMBOBOX\r
\r
#if wxUSE_COMBOBOX\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellEnumEditor\r
// ----------------------------------------------------------------------------\r
\r
// A cell editor which displays an enum number as a textual equivalent. eg\r
// data in cell is 0,1,2 ... n the cell could be displayed as\r
// "John","Fred"..."Bob" in the combo choice box\r
\r
wxGridCellEnumEditor::wxGridCellEnumEditor(const wxString& choices)\r
                     :wxGridCellChoiceEditor()\r
{\r
    m_index = -1;\r
\r
    if (!choices.empty())\r
        SetParameters(choices);\r
}\r
\r
wxGridCellEditor *wxGridCellEnumEditor::Clone() const\r
{\r
    wxGridCellEnumEditor *editor = new wxGridCellEnumEditor();\r
    editor->m_index = m_index;\r
    return editor;\r
}\r
\r
void wxGridCellEnumEditor::BeginEdit(int row, int col, wxGrid* grid)\r
{\r
    wxASSERT_MSG(m_control,\r
                 wxT("The wxGridCellEnumEditor must be Created first!"));\r
\r
    wxGridTableBase *table = grid->GetTable();\r
\r
    if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )\r
    {\r
        m_index = table->GetValueAsLong(row, col);\r
    }\r
    else\r
    {\r
        wxString startValue = table->GetValue(row, col);\r
        if (startValue.IsNumber() && !startValue.empty())\r
        {\r
            startValue.ToLong(&m_index);\r
        }\r
        else\r
        {\r
            m_index = -1;\r
        }\r
    }\r
\r
    Combo()->SetSelection(m_index);\r
    Combo()->SetInsertionPointEnd();\r
    Combo()->SetFocus();\r
\r
}\r
\r
bool wxGridCellEnumEditor::EndEdit(int WXUNUSED(row),\r
                                   int WXUNUSED(col),\r
                                   const wxGrid* WXUNUSED(grid),\r
                                   const wxString& WXUNUSED(oldval),\r
                                   wxString *newval)\r
{\r
    long idx = Combo()->GetSelection();\r
    if ( idx == m_index )\r
        return false;\r
\r
    m_index = idx;\r
\r
    if ( newval )\r
        newval->Printf("%ld", m_index);\r
\r
    return true;\r
}\r
\r
void wxGridCellEnumEditor::ApplyEdit(int row, int col, wxGrid* grid)\r
{\r
    wxGridTableBase * const table = grid->GetTable();\r
    if ( table->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER) )\r
        table->SetValueAsLong(row, col, m_index);\r
    else\r
        table->SetValue(row, col, wxString::Format("%ld", m_index));\r
}\r
\r
#endif // wxUSE_COMBOBOX\r
\r
// ----------------------------------------------------------------------------\r
// wxGridCellAutoWrapStringEditor\r
// ----------------------------------------------------------------------------\r
\r
void\r
wxGridCellAutoWrapStringEditor::Create(wxWindow* parent,\r
                                       wxWindowID id,\r
                                       wxEvtHandler* evtHandler)\r
{\r
    wxGridCellTextEditor::DoCreate(parent, id, evtHandler,\r
                                    wxTE_MULTILINE | wxTE_RICH);\r
}\r
\r
\r
#endif // wxUSE_GRID\r