src/generic/grideditors.cpp

   1 ///////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/grideditors.cpp
   3 // Purpose:     wxGridCellEditorEvtHandler and wxGrid editors
   4 // Author:      Michael Bedward (based on code by Julian Smart, Robin Dunn)
   5 // Modified by: Robin Dunn, Vadim Zeitlin, Santiago Palacios
   6 // Created:     1/08/1999
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Michael Bedward (mbedward@ozemail.com.au)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_GRID
  20
  21 #include "wx/grid.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/utils.h"
  25     #include "wx/dcclient.h"
  26     #include "wx/settings.h"
  27     #include "wx/log.h"
  28     #include "wx/textctrl.h"
  29     #include "wx/checkbox.h"
  30     #include "wx/combobox.h"
  31     #include "wx/intl.h"
  32     #include "wx/math.h"
  33     #include "wx/listbox.h"
  34 #endif
  35
  36 #include "wx/valnum.h"
  37 #include "wx/textfile.h"
  38 #include "wx/spinctrl.h"
  39 #include "wx/tokenzr.h"
  40 #include "wx/renderer.h"
  41 #include "wx/headerctrl.h"
  42
  43 #include "wx/generic/gridsel.h"
  44 #include "wx/generic/grideditors.h"
  45 #include "wx/generic/private/grid.h"
  46
  47 #if defined(__WXMOTIF__)
  48     #define WXUNUSED_MOTIF(identifier)  WXUNUSED(identifier)
  49 #else
  50     #define WXUNUSED_MOTIF(identifier)  identifier
  51 #endif
  52
  53 #if defined(__WXGTK__)
  54     #define WXUNUSED_GTK(identifier)    WXUNUSED(identifier)
  55 #else
  56     #define WXUNUSED_GTK(identifier)    identifier
  57 #endif
  58
  59 #ifdef __WXOSX__
  60 #include "wx/osx/private.h"
  61 #endif
  62
  63 // Required for wxIs... functions
  64 #include <ctype.h>
  65
  66 // ============================================================================
  67 // implementation
  68 // ============================================================================
  69
  70 wxDEFINE_EVENT( wxEVT_GRID_HIDE_EDITOR, wxCommandEvent );
  71
  72 // ----------------------------------------------------------------------------
  73 // wxGridCellEditorEvtHandler
  74 // ----------------------------------------------------------------------------
  75
  76 void wxGridCellEditorEvtHandler::OnKillFocus(wxFocusEvent& event)
  77 {
  78     // We must let the native control have this event so in any case don't mark
  79     // it as handled, otherwise various weird problems can happen (see #11681).
  80     event.Skip();
  81
  82     // Don't disable the cell if we're just starting to edit it
  83     if (m_inSetFocus)
  84         return;
  85
  86     // Tell the grid to dismiss the control but don't do it immediately as it
  87     // could result in the editor being destroyed right now and a crash in the
  88     // code searching for the next event handler, so post an event asking the
  89     // grid to do it slightly later instead.
  90
  91     // FIXME-VC6: Once we drop support for VC6, we should use a simpler
  92     //            m_grid->CallAfter(&wxGrid::DisableCellEditControl) and get
  93     //            rid of wxEVT_GRID_HIDE_EDITOR entirely.
  94     m_grid->GetEventHandler()->
  95         AddPendingEvent(wxCommandEvent(wxEVT_GRID_HIDE_EDITOR));
  96 }
  97
  98 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
  99 {
 100     switch ( event.GetKeyCode() )
 101     {
 102         case WXK_ESCAPE:
 103             m_editor->Reset();
 104             m_grid->DisableCellEditControl();
 105             break;
 106
 107         case WXK_TAB:
 108             m_grid->GetEventHandler()->ProcessEvent( event );
 109             break;
 110
 111         case WXK_RETURN:
 112         case WXK_NUMPAD_ENTER:
 113             if (!m_grid->GetEventHandler()->ProcessEvent(event))
 114                 m_editor->HandleReturn(event);
 115             break;
 116
 117         default:
 118             event.Skip();
 119             break;
 120     }
 121 }
 122
 123 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
 124 {
 125     int row = m_grid->GetGridCursorRow();
 126     int col = m_grid->GetGridCursorCol();
 127     wxRect rect = m_grid->CellToRect( row, col );
 128     int cw, ch;
 129     m_grid->GetGridWindow()->GetClientSize( &cw, &ch );
 130
 131     // if cell width is smaller than grid client area, cell is wholly visible
 132     bool wholeCellVisible = (rect.GetWidth() < cw);
 133
 134     switch ( event.GetKeyCode() )
 135     {
 136         case WXK_ESCAPE:
 137         case WXK_TAB:
 138         case WXK_RETURN:
 139         case WXK_NUMPAD_ENTER:
 140             break;
 141
 142         case WXK_HOME:
 143         {
 144             if ( wholeCellVisible )
 145             {
 146                 // no special processing needed...
 147                 event.Skip();
 148                 break;
 149             }
 150
 151             // do special processing for partly visible cell...
 152
 153             // get the widths of all cells previous to this one
 154             int colXPos = 0;
 155             for ( int i = 0; i < col; i++ )
 156             {
 157                 colXPos += m_grid->GetColSize(i);
 158             }
 159
 160             int xUnit = 1, yUnit = 1;
 161             m_grid->GetScrollPixelsPerUnit(&xUnit, &yUnit);
 162             if (col != 0)
 163             {
 164                 m_grid->Scroll(colXPos / xUnit - 1, m_grid->GetScrollPos(wxVERTICAL));
 165             }
 166             else
 167             {
 168                 m_grid->Scroll(colXPos / xUnit, m_grid->GetScrollPos(wxVERTICAL));
 169             }
 170             event.Skip();
 171             break;
 172         }
 173
 174         case WXK_END:
 175         {
 176             if ( wholeCellVisible )
 177             {
 178                 // no special processing needed...
 179                 event.Skip();
 180                 break;
 181             }
 182
 183             // do special processing for partly visible cell...
 184
 185             int textWidth = 0;
 186             wxString value = m_grid->GetCellValue(row, col);
 187             if ( wxEmptyString != value )
 188             {
 189                 // get width of cell CONTENTS (text)
 190                 int y;
 191                 wxFont font = m_grid->GetCellFont(row, col);
 192                 m_grid->GetTextExtent(value, &textWidth, &y, NULL, NULL, &font);
 193
 194                 // try to RIGHT align the text by scrolling
 195                 int client_right = m_grid->GetGridWindow()->GetClientSize().GetWidth();
 196
 197                 // (m_grid->GetScrollLineX()*2) is a factor for not scrolling to far,
 198                 // otherwise the last part of the cell content might be hidden below the scroll bar
 199                 // FIXME: maybe there is a more suitable correction?
 200                 textWidth -= (client_right - (m_grid->GetScrollLineX() * 2));
 201                 if ( textWidth < 0 )
 202                 {
 203                     textWidth = 0;
 204                 }
 205             }
 206
 207             // get the widths of all cells previous to this one
 208             int colXPos = 0;
 209             for ( int i = 0; i < col; i++ )
 210             {
 211                 colXPos += m_grid->GetColSize(i);
 212             }
 213
 214             // and add the (modified) text width of the cell contents
 215             // as we'd like to see the last part of the cell contents
 216             colXPos += textWidth;
 217
 218             int xUnit = 1, yUnit = 1;
 219             m_grid->GetScrollPixelsPerUnit(&xUnit, &yUnit);
 220             m_grid->Scroll(colXPos / xUnit - 1, m_grid->GetScrollPos(wxVERTICAL));
 221             event.Skip();
 222             break;
 223         }
 224
 225         default:
 226             event.Skip();
 227             break;
 228     }
 229 }
 230
 231 // ----------------------------------------------------------------------------
 232 // wxGridCellEditor
 233 // ----------------------------------------------------------------------------
 234
 235 wxGridCellEditor::wxGridCellEditor()
 236 {
 237     m_control = NULL;
 238     m_attr = NULL;
 239 }
 240
 241 wxGridCellEditor::~wxGridCellEditor()
 242 {
 243     Destroy();
 244 }
 245
 246 void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
 247                               wxWindowID WXUNUSED(id),
 248                               wxEvtHandler* evtHandler)
 249 {
 250     if ( evtHandler )
 251         m_control->PushEventHandler(evtHandler);
 252 }
 253
 254 void wxGridCellEditor::PaintBackground(wxDC& dc,
 255                                        const wxRect& rectCell,
 256                                        const wxGridCellAttr& attr)
 257 {
 258     // erase the background because we might not fill the cell
 259     dc.SetPen(*wxTRANSPARENT_PEN);
 260     dc.SetBrush(wxBrush(attr.GetBackgroundColour()));
 261     dc.DrawRectangle(rectCell);
 262 }
 263
 264 void wxGridCellEditor::Destroy()
 265 {
 266     if (m_control)
 267     {
 268         m_control->PopEventHandler( true /* delete it*/ );
 269
 270         m_control->Destroy();
 271         m_control = NULL;
 272     }
 273 }
 274
 275 void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
 276 {
 277     wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
 278
 279     m_control->Show(show);
 280
 281     if ( show )
 282     {
 283         // set the colours/fonts if we have any
 284         if ( attr )
 285         {
 286             m_colFgOld = m_control->GetForegroundColour();
 287             m_control->SetForegroundColour(attr->GetTextColour());
 288
 289             m_colBgOld = m_control->GetBackgroundColour();
 290             m_control->SetBackgroundColour(attr->GetBackgroundColour());
 291
 292 // Workaround for GTK+1 font setting problem on some platforms
 293 #if !defined(__WXGTK__) || defined(__WXGTK20__)
 294             m_fontOld = m_control->GetFont();
 295             m_control->SetFont(attr->GetFont());
 296 #endif
 297
 298             // can't do anything more in the base class version, the other
 299             // attributes may only be used by the derived classes
 300         }
 301     }
 302     else
 303     {
 304         // restore the standard colours fonts
 305         if ( m_colFgOld.IsOk() )
 306         {
 307             m_control->SetForegroundColour(m_colFgOld);
 308             m_colFgOld = wxNullColour;
 309         }
 310
 311         if ( m_colBgOld.IsOk() )
 312         {
 313             m_control->SetBackgroundColour(m_colBgOld);
 314             m_colBgOld = wxNullColour;
 315         }
 316
 317 // Workaround for GTK+1 font setting problem on some platforms
 318 #if !defined(__WXGTK__) || defined(__WXGTK20__)
 319         if ( m_fontOld.IsOk() )
 320         {
 321             m_control->SetFont(m_fontOld);
 322             m_fontOld = wxNullFont;
 323         }
 324 #endif
 325     }
 326 }
 327
 328 void wxGridCellEditor::SetSize(const wxRect& rect)
 329 {
 330     wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
 331
 332     m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
 333 }
 334
 335 void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
 336 {
 337     event.Skip();
 338 }
 339
 340 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
 341 {
 342     bool ctrl = event.ControlDown();
 343     bool alt;
 344
 345 #ifdef __WXMAC__
 346     // On the Mac the Alt key is more like shift and is used for entry of
 347     // valid characters, so check for Ctrl and Meta instead.
 348     alt = event.MetaDown();
 349 #else // !__WXMAC__
 350     alt = event.AltDown();
 351 #endif // __WXMAC__/!__WXMAC__
 352
 353     // Assume it's not a valid char if ctrl or alt is down, but if both are
 354     // down then it may be because of an AltGr key combination, so let them
 355     // through in that case.
 356     if ((ctrl || alt) && !(ctrl && alt))
 357         return false;
 358
 359 #if wxUSE_UNICODE
 360     if ( static_cast<int>(event.GetUnicodeKey()) == WXK_NONE )
 361         return false;
 362 #else
 363     if ( event.GetKeyCode() > WXK_START )
 364         return false;
 365 #endif
 366
 367     return true;
 368 }
 369
 370 void wxGridCellEditor::StartingKey(wxKeyEvent& event)
 371 {
 372     event.Skip();
 373 }
 374
 375 void wxGridCellEditor::StartingClick()
 376 {
 377 }
 378
 379 #if wxUSE_TEXTCTRL
 380
 381 // ----------------------------------------------------------------------------
 382 // wxGridCellTextEditor
 383 // ----------------------------------------------------------------------------
 384
 385 wxGridCellTextEditor::wxGridCellTextEditor(size_t maxChars)
 386 {
 387     m_maxChars = maxChars;
 388 }
 389
 390 void wxGridCellTextEditor::Create(wxWindow* parent,
 391                                   wxWindowID id,
 392                                   wxEvtHandler* evtHandler)
 393 {
 394     DoCreate(parent, id, evtHandler);
 395 }
 396
 397 void wxGridCellTextEditor::DoCreate(wxWindow* parent,
 398                                     wxWindowID id,
 399                                     wxEvtHandler* evtHandler,
 400                                     long style)
 401 {
 402     style |= wxTE_PROCESS_ENTER | wxTE_PROCESS_TAB | wxNO_BORDER;
 403
 404     wxTextCtrl* const text = new wxTextCtrl(parent, id, wxEmptyString,
 405                                             wxDefaultPosition, wxDefaultSize,
 406                                             style);
 407     text->SetMargins(0, 0);
 408     m_control = text;
 409
 410 #ifdef __WXOSX__
 411     wxWidgetImpl* impl = m_control->GetPeer();
 412     impl->SetNeedsFocusRect(false);
 413 #endif
 414     // set max length allowed in the textctrl, if the parameter was set
 415     if ( m_maxChars != 0 )
 416     {
 417         Text()->SetMaxLength(m_maxChars);
 418     }
 419     // validate text in textctrl, if validator is set
 420     if ( m_validator )
 421     {
 422         Text()->SetValidator(*m_validator);
 423     }
 424
 425     wxGridCellEditor::Create(parent, id, evtHandler);
 426 }
 427
 428 void wxGridCellTextEditor::PaintBackground(wxDC& WXUNUSED(dc),
 429                                            const wxRect& WXUNUSED(rectCell),
 430                                            const wxGridCellAttr& WXUNUSED(attr))
 431 {
 432     // as we fill the entire client area,
 433     // don't do anything here to minimize flicker
 434 }
 435
 436 void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
 437 {
 438     wxRect rect(rectOrig);
 439
 440     // Make the edit control large enough to allow for internal margins
 441     //
 442     // TODO: remove this if the text ctrl sizing is improved esp. for unix
 443     //
 444 #if defined(__WXGTK__)
 445     if (rect.x != 0)
 446     {
 447         rect.x += 1;
 448         rect.y += 1;
 449         rect.width -= 1;
 450         rect.height -= 1;
 451     }
 452 #elif defined(__WXMSW__)
 453     if ( rect.x == 0 )
 454         rect.x += 2;
 455     else
 456         rect.x += 3;
 457
 458     if ( rect.y == 0 )
 459         rect.y += 2;
 460     else
 461         rect.y += 3;
 462
 463     rect.width -= 2;
 464     rect.height -= 2;
 465 #elif defined(__WXOSX__)
 466     rect.x += 1;
 467     rect.y += 1;
 468
 469     rect.width -= 1;
 470     rect.height -= 1;
 471 #else
 472     int extra_x = ( rect.x > 2 ) ? 2 : 1;
 473     int extra_y = ( rect.y > 2 ) ? 2 : 1;
 474
 475     #if defined(__WXMOTIF__)
 476         extra_x *= 2;
 477         extra_y *= 2;
 478     #endif
 479
 480     rect.SetLeft( wxMax(0, rect.x - extra_x) );
 481     rect.SetTop( wxMax(0, rect.y - extra_y) );
 482     rect.SetRight( rect.GetRight() + 2 * extra_x );
 483     rect.SetBottom( rect.GetBottom() + 2 * extra_y );
 484 #endif
 485
 486     wxGridCellEditor::SetSize(rect);
 487 }
 488
 489 void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
 490 {
 491     wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
 492
 493     m_value = grid->GetTable()->GetValue(row, col);
 494
 495     DoBeginEdit(m_value);
 496 }
 497
 498 void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
 499 {
 500     Text()->SetValue(startValue);
 501     Text()->SetInsertionPointEnd();
 502     Text()->SelectAll();
 503     Text()->SetFocus();
 504 }
 505
 506 bool wxGridCellTextEditor::EndEdit(int WXUNUSED(row),
 507                                    int WXUNUSED(col),
 508                                    const wxGrid* WXUNUSED(grid),
 509                                    const wxString& WXUNUSED(oldval),
 510                                    wxString *newval)
 511 {
 512     wxCHECK_MSG( m_control, false,
 513                  "wxGridCellTextEditor must be created first!" );
 514
 515     const wxString value = Text()->GetValue();
 516     if ( value == m_value )
 517         return false;
 518
 519     m_value = value;
 520
 521     if ( newval )
 522         *newval = m_value;
 523
 524     return true;
 525 }
 526
 527 void wxGridCellTextEditor::ApplyEdit(int row, int col, wxGrid* grid)
 528 {
 529     grid->GetTable()->SetValue(row, col, m_value);
 530     m_value.clear();
 531 }
 532
 533 void wxGridCellTextEditor::Reset()
 534 {
 535     wxASSERT_MSG( m_control, "wxGridCellTextEditor must be created first!" );
 536
 537     DoReset(m_value);
 538 }
 539
 540 void wxGridCellTextEditor::DoReset(const wxString& startValue)
 541 {
 542     Text()->SetValue(startValue);
 543     Text()->SetInsertionPointEnd();
 544 }
 545
 546 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)
 547 {
 548     switch ( event.GetKeyCode() )
 549     {
 550         case WXK_DELETE:
 551         case WXK_BACK:
 552             return true;
 553
 554         default:
 555             return wxGridCellEditor::IsAcceptedKey(event);
 556     }
 557 }
 558
 559 void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
 560 {
 561     // Since this is now happening in the EVT_CHAR event EmulateKeyPress is no
 562     // longer an appropriate way to get the character into the text control.
 563     // Do it ourselves instead.  We know that if we get this far that we have
 564     // a valid character, so not a whole lot of testing needs to be done.
 565
 566     wxTextCtrl* tc = Text();
 567     int ch;
 568
 569     bool isPrintable;
 570
 571 #if wxUSE_UNICODE
 572     ch = event.GetUnicodeKey();
 573     if ( ch != WXK_NONE )
 574         isPrintable = true;
 575     else
 576 #endif // wxUSE_UNICODE
 577     {
 578         ch = event.GetKeyCode();
 579         isPrintable = ch >= WXK_SPACE && ch < WXK_START;
 580     }
 581
 582     switch (ch)
 583     {
 584         case WXK_DELETE:
 585             // Delete the initial character when starting to edit with DELETE.
 586             tc->Remove(0, 1);
 587             break;
 588
 589         case WXK_BACK:
 590             // Delete the last character when starting to edit with BACKSPACE.
 591             {
 592                 const long pos = tc->GetLastPosition();
 593                 tc->Remove(pos - 1, pos);
 594             }
 595             break;
 596
 597         default:
 598             if ( isPrintable )
 599                 tc->WriteText(static_cast<wxChar>(ch));
 600             break;
 601     }
 602 }
 603
 604 void wxGridCellTextEditor::HandleReturn( wxKeyEvent&
 605                                          WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )
 606 {
 607 #if defined(__WXMOTIF__) || defined(__WXGTK__)
 608     // wxMotif needs a little extra help...
 609     size_t pos = (size_t)( Text()->GetInsertionPoint() );
 610     wxString s( Text()->GetValue() );
 611     s = s.Left(pos) + wxT("\n") + s.Mid(pos);
 612     Text()->SetValue(s);
 613     Text()->SetInsertionPoint( pos );
 614 #else
 615     // the other ports can handle a Return key press
 616     //
 617     event.Skip();
 618 #endif
 619 }
 620
 621 void wxGridCellTextEditor::SetParameters(const wxString& params)
 622 {
 623     if ( !params )
 624     {
 625         // reset to default
 626         m_maxChars = 0;
 627     }
 628     else
 629     {
 630         long tmp;
 631         if ( params.ToLong(&tmp) )
 632         {
 633             m_maxChars = (size_t)tmp;
 634         }
 635         else
 636         {
 637             wxLogDebug( wxT("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str() );
 638         }
 639     }
 640 }
 641
 642 void wxGridCellTextEditor::SetValidator(const wxValidator& validator)
 643 {
 644     m_validator.reset(static_cast<wxValidator*>(validator.Clone()));
 645 }
 646
 647 wxGridCellEditor *wxGridCellTextEditor::Clone() const
 648 {
 649     wxGridCellTextEditor* editor = new wxGridCellTextEditor(m_maxChars);
 650     if ( m_validator )
 651     {
 652         editor->SetValidator(*m_validator);
 653     }
 654     return editor;
 655 }
 656
 657 // return the value in the text control
 658 wxString wxGridCellTextEditor::GetValue() const
 659 {
 660     return Text()->GetValue();
 661 }
 662
 663 // ----------------------------------------------------------------------------
 664 // wxGridCellNumberEditor
 665 // ----------------------------------------------------------------------------
 666
 667 wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
 668 {
 669     m_min = min;
 670     m_max = max;
 671 }
 672
 673 void wxGridCellNumberEditor::Create(wxWindow* parent,
 674                                     wxWindowID id,
 675                                     wxEvtHandler* evtHandler)
 676 {
 677 #if wxUSE_SPINCTRL
 678     if ( HasRange() )
 679     {
 680         // create a spin ctrl
 681         m_control = new wxSpinCtrl(parent, wxID_ANY, wxEmptyString,
 682                                    wxDefaultPosition, wxDefaultSize,
 683                                    wxSP_ARROW_KEYS,
 684                                    m_min, m_max);
 685
 686         wxGridCellEditor::Create(parent, id, evtHandler);
 687     }
 688     else
 689 #endif
 690     {
 691         // just a text control
 692         wxGridCellTextEditor::Create(parent, id, evtHandler);
 693
 694 #if wxUSE_VALIDATORS
 695         Text()->SetValidator(wxIntegerValidator<int>());
 696 #endif
 697     }
 698 }
 699
 700 void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
 701 {
 702     // first get the value
 703     wxGridTableBase *table = grid->GetTable();
 704     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
 705     {
 706         m_value = table->GetValueAsLong(row, col);
 707     }
 708     else
 709     {
 710         m_value = 0;
 711         wxString sValue = table->GetValue(row, col);
 712         if (! sValue.ToLong(&m_value) && ! sValue.empty())
 713         {
 714             wxFAIL_MSG( wxT("this cell doesn't have numeric value") );
 715             return;
 716         }
 717     }
 718
 719 #if wxUSE_SPINCTRL
 720     if ( HasRange() )
 721     {
 722         Spin()->SetValue((int)m_value);
 723         Spin()->SetFocus();
 724     }
 725     else
 726 #endif
 727     {
 728         DoBeginEdit(GetString());
 729     }
 730 }
 731
 732 bool wxGridCellNumberEditor::EndEdit(int WXUNUSED(row),
 733                                      int WXUNUSED(col),
 734                                      const wxGrid* WXUNUSED(grid),
 735                                      const wxString& oldval, wxString *newval)
 736 {
 737     long value = 0;
 738     wxString text;
 739
 740 #if wxUSE_SPINCTRL
 741     if ( HasRange() )
 742     {
 743         value = Spin()->GetValue();
 744         if ( value == m_value )
 745             return false;
 746
 747         text.Printf(wxT("%ld"), value);
 748     }
 749     else // using unconstrained input
 750 #endif // wxUSE_SPINCTRL
 751     {
 752         text = Text()->GetValue();
 753         if ( text.empty() )
 754         {
 755             if ( oldval.empty() )
 756                 return false;
 757         }
 758         else // non-empty text now (maybe 0)
 759         {
 760             if ( !text.ToLong(&value) )
 761                 return false;
 762
 763             // if value == m_value == 0 but old text was "" and new one is
 764             // "0" something still did change
 765             if ( value == m_value && (value || !oldval.empty()) )
 766                 return false;
 767         }
 768     }
 769
 770     m_value = value;
 771
 772     if ( newval )
 773         *newval = text;
 774
 775     return true;
 776 }
 777
 778 void wxGridCellNumberEditor::ApplyEdit(int row, int col, wxGrid* grid)
 779 {
 780     wxGridTableBase * const table = grid->GetTable();
 781     if ( table->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER) )
 782         table->SetValueAsLong(row, col, m_value);
 783     else
 784         table->SetValue(row, col, wxString::Format("%ld", m_value));
 785 }
 786
 787 void wxGridCellNumberEditor::Reset()
 788 {
 789 #if wxUSE_SPINCTRL
 790     if ( HasRange() )
 791     {
 792         Spin()->SetValue((int)m_value);
 793     }
 794     else
 795 #endif
 796     {
 797         DoReset(GetString());
 798     }
 799 }
 800
 801 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
 802 {
 803     if ( wxGridCellEditor::IsAcceptedKey(event) )
 804     {
 805         int keycode = event.GetKeyCode();
 806         if ( (keycode < 128) &&
 807              (wxIsdigit(keycode) || keycode == '+' || keycode == '-'))
 808         {
 809             return true;
 810         }
 811     }
 812
 813     return false;
 814 }
 815
 816 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
 817 {
 818     int keycode = event.GetKeyCode();
 819     if ( !HasRange() )
 820     {
 821         if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-')
 822         {
 823             wxGridCellTextEditor::StartingKey(event);
 824
 825             // skip Skip() below
 826             return;
 827         }
 828     }
 829 #if wxUSE_SPINCTRL
 830     else
 831     {
 832         if ( wxIsdigit(keycode) )
 833         {
 834             wxSpinCtrl* spin = (wxSpinCtrl*)m_control;
 835             spin->SetValue(keycode - '0');
 836             spin->SetSelection(1,1);
 837             return;
 838         }
 839     }
 840 #endif
 841
 842     event.Skip();
 843 }
 844
 845 void wxGridCellNumberEditor::SetParameters(const wxString& params)
 846 {
 847     if ( !params )
 848     {
 849         // reset to default
 850         m_min =
 851         m_max = -1;
 852     }
 853     else
 854     {
 855         long tmp;
 856         if ( params.BeforeFirst(wxT(',')).ToLong(&tmp) )
 857         {
 858             m_min = (int)tmp;
 859
 860             if ( params.AfterFirst(wxT(',')).ToLong(&tmp) )
 861             {
 862                 m_max = (int)tmp;
 863
 864                 // skip the error message below
 865                 return;
 866             }
 867         }
 868
 869         wxLogDebug(wxT("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());
 870     }
 871 }
 872
 873 // return the value in the spin control if it is there (the text control otherwise)
 874 wxString wxGridCellNumberEditor::GetValue() const
 875 {
 876     wxString s;
 877
 878 #if wxUSE_SPINCTRL
 879     if ( HasRange() )
 880     {
 881         long value = Spin()->GetValue();
 882         s.Printf(wxT("%ld"), value);
 883     }
 884     else
 885 #endif
 886     {
 887         s = Text()->GetValue();
 888     }
 889
 890     return s;
 891 }
 892
 893 // ----------------------------------------------------------------------------
 894 // wxGridCellFloatEditor
 895 // ----------------------------------------------------------------------------
 896
 897 wxGridCellFloatEditor::wxGridCellFloatEditor(int width,
 898                                              int precision,
 899                                              int format)
 900 {
 901     m_width = width;
 902     m_precision = precision;
 903     m_style = format;
 904 }
 905
 906 void wxGridCellFloatEditor::Create(wxWindow* parent,
 907                                    wxWindowID id,
 908                                    wxEvtHandler* evtHandler)
 909 {
 910     wxGridCellTextEditor::Create(parent, id, evtHandler);
 911
 912 #if wxUSE_VALIDATORS
 913     Text()->SetValidator(wxFloatingPointValidator<double>(m_precision));
 914 #endif
 915 }
 916
 917 void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
 918 {
 919     // first get the value
 920     wxGridTableBase * const table = grid->GetTable();
 921     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
 922     {
 923         m_value = table->GetValueAsDouble(row, col);
 924     }
 925     else
 926     {
 927         m_value = 0.0;
 928
 929         const wxString value = table->GetValue(row, col);
 930         if ( !value.empty() )
 931         {
 932             if ( !value.ToDouble(&m_value) )
 933             {
 934                 wxFAIL_MSG( wxT("this cell doesn't have float value") );
 935                 return;
 936             }
 937         }
 938     }
 939
 940     DoBeginEdit(GetString());
 941 }
 942
 943 bool wxGridCellFloatEditor::EndEdit(int WXUNUSED(row),
 944                                     int WXUNUSED(col),
 945                                     const wxGrid* WXUNUSED(grid),
 946                                     const wxString& oldval, wxString *newval)
 947 {
 948     const wxString text(Text()->GetValue());
 949
 950     double value;
 951     if ( !text.empty() )
 952     {
 953         if ( !text.ToDouble(&value) )
 954             return false;
 955     }
 956     else // new value is empty string
 957     {
 958         if ( oldval.empty() )
 959             return false;           // nothing changed
 960
 961         value = 0.;
 962     }
 963
 964     // the test for empty strings ensures that we don't skip the value setting
 965     // when "" is replaced by "0" or vice versa as "" numeric value is also 0.
 966     if ( wxIsSameDouble(value, m_value) && !text.empty() && !oldval.empty() )
 967         return false;           // nothing changed
 968
 969     m_value = value;
 970
 971     if ( newval )
 972         *newval = text;
 973
 974     return true;
 975 }
 976
 977 void wxGridCellFloatEditor::ApplyEdit(int row, int col, wxGrid* grid)
 978 {
 979     wxGridTableBase * const table = grid->GetTable();
 980
 981     if ( table->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT) )
 982         table->SetValueAsDouble(row, col, m_value);
 983     else
 984         table->SetValue(row, col, Text()->GetValue());
 985 }
 986
 987 void wxGridCellFloatEditor::Reset()
 988 {
 989     DoReset(GetString());
 990 }
 991
 992 void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
 993 {
 994     int keycode = event.GetKeyCode();
 995     char tmpbuf[2];
 996     tmpbuf[0] = (char) keycode;
 997     tmpbuf[1] = '\0';
 998     wxString strbuf(tmpbuf, *wxConvCurrent);
 999
1000 #if wxUSE_INTL
1001     bool is_decimal_point = ( strbuf ==
1002        wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER) );
1003 #else
1004     bool is_decimal_point = ( strbuf == wxT(".") );
1005 #endif
1006
1007     if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'
1008          || is_decimal_point )
1009     {
1010         wxGridCellTextEditor::StartingKey(event);
1011
1012         // skip Skip() below
1013         return;
1014     }
1015
1016     event.Skip();
1017 }
1018
1019 void wxGridCellFloatEditor::SetParameters(const wxString& params)
1020 {
1021     if ( !params )
1022     {
1023         // reset to default
1024         m_width =
1025         m_precision = -1;
1026         m_style = wxGRID_FLOAT_FORMAT_DEFAULT;
1027         m_format.clear();
1028     }
1029     else
1030     {
1031         wxString rest;
1032         wxString tmp = params.BeforeFirst(wxT(','), &rest);
1033         if ( !tmp.empty() )
1034         {
1035             long width;
1036             if ( tmp.ToLong(&width) )
1037             {
1038                 m_width = (int)width;
1039             }
1040             else
1041             {
1042                 wxLogDebug(wxT("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
1043             }
1044         }
1045
1046         tmp = rest.BeforeFirst(wxT(','));
1047         if ( !tmp.empty() )
1048         {
1049             long precision;
1050             if ( tmp.ToLong(&precision) )
1051             {
1052                 m_precision = (int)precision;
1053             }
1054             else
1055             {
1056                 wxLogDebug(wxT("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
1057             }
1058         }
1059
1060         tmp = rest.AfterFirst(wxT(','));
1061         if ( !tmp.empty() )
1062         {
1063             if ( tmp[0] == wxT('f') )
1064             {
1065                 m_style = wxGRID_FLOAT_FORMAT_FIXED;
1066             }
1067             else if ( tmp[0] == wxT('e') )
1068             {
1069                 m_style = wxGRID_FLOAT_FORMAT_SCIENTIFIC;
1070             }
1071             else if ( tmp[0] == wxT('g') )
1072             {
1073                 m_style = wxGRID_FLOAT_FORMAT_COMPACT;
1074             }
1075             else if ( tmp[0] == wxT('E') )
1076             {
1077                 m_style = wxGRID_FLOAT_FORMAT_SCIENTIFIC |
1078                           wxGRID_FLOAT_FORMAT_UPPER;
1079             }
1080             else if ( tmp[0] == wxT('F') )
1081             {
1082                 m_style = wxGRID_FLOAT_FORMAT_FIXED |
1083                           wxGRID_FLOAT_FORMAT_UPPER;
1084             }
1085             else if ( tmp[0] == wxT('G') )
1086             {
1087                 m_style = wxGRID_FLOAT_FORMAT_COMPACT |
1088                           wxGRID_FLOAT_FORMAT_UPPER;
1089             }
1090             else
1091             {
1092                 wxLogDebug("Invalid wxGridCellFloatRenderer format "
1093                            "parameter string '%s ignored", params);
1094             }
1095         }
1096     }
1097 }
1098
1099 wxString wxGridCellFloatEditor::GetString()
1100 {
1101     if ( !m_format )
1102     {
1103         if ( m_precision == -1 && m_width != -1)
1104         {
1105             // default precision
1106             m_format.Printf(wxT("%%%d."), m_width);
1107         }
1108         else if ( m_precision != -1 && m_width == -1)
1109         {
1110             // default width
1111             m_format.Printf(wxT("%%.%d"), m_precision);
1112         }
1113         else if ( m_precision != -1 && m_width != -1 )
1114         {
1115             m_format.Printf(wxT("%%%d.%d"), m_width, m_precision);
1116         }
1117         else
1118         {
1119             // default width/precision
1120             m_format = wxT("%");
1121         }
1122
1123         bool isUpper = (m_style & wxGRID_FLOAT_FORMAT_UPPER) != 0;
1124         if ( m_style & wxGRID_FLOAT_FORMAT_SCIENTIFIC )
1125             m_format += isUpper ? wxT('E') : wxT('e');
1126         else if ( m_style & wxGRID_FLOAT_FORMAT_COMPACT )
1127             m_format += isUpper ? wxT('G') : wxT('g');
1128         else
1129             m_format += wxT('f');
1130     }
1131
1132     return wxString::Format(m_format, m_value);
1133 }
1134
1135 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
1136 {
1137     if ( wxGridCellEditor::IsAcceptedKey(event) )
1138     {
1139         const int keycode = event.GetKeyCode();
1140         if ( wxIsascii(keycode) )
1141         {
1142 #if wxUSE_INTL
1143             const wxString decimalPoint =
1144                 wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER);
1145 #else
1146             const wxString decimalPoint(wxT('.'));
1147 #endif
1148
1149             // accept digits, 'e' as in '1e+6', also '-', '+', and '.'
1150             if ( wxIsdigit(keycode) ||
1151                     tolower(keycode) == 'e' ||
1152                         keycode == decimalPoint ||
1153                             keycode == '+' ||
1154                                 keycode == '-' )
1155             {
1156                 return true;
1157             }
1158         }
1159     }
1160
1161     return false;
1162 }
1163
1164 #endif // wxUSE_TEXTCTRL
1165
1166 #if wxUSE_CHECKBOX
1167
1168 // ----------------------------------------------------------------------------
1169 // wxGridCellBoolEditor
1170 // ----------------------------------------------------------------------------
1171
1172 // the default values for GetValue()
1173 wxString wxGridCellBoolEditor::ms_stringValues[2] = { wxT(""), wxT("1") };
1174
1175 void wxGridCellBoolEditor::Create(wxWindow* parent,
1176                                   wxWindowID id,
1177                                   wxEvtHandler* evtHandler)
1178 {
1179     m_control = new wxCheckBox(parent, id, wxEmptyString,
1180                                wxDefaultPosition, wxDefaultSize,
1181                                wxNO_BORDER);
1182
1183     wxGridCellEditor::Create(parent, id, evtHandler);
1184 }
1185
1186 void wxGridCellBoolEditor::SetSize(const wxRect& r)
1187 {
1188     bool resize = false;
1189     wxSize size = m_control->GetSize();
1190     wxCoord minSize = wxMin(r.width, r.height);
1191
1192     // check if the checkbox is not too big/small for this cell
1193     wxSize sizeBest = m_control->GetBestSize();
1194     if ( !(size == sizeBest) )
1195     {
1196         // reset to default size if it had been made smaller
1197         size = sizeBest;
1198
1199         resize = true;
1200     }
1201
1202     if ( size.x >= minSize || size.y >= minSize )
1203     {
1204         // leave 1 pixel margin
1205         size.x = size.y = minSize - 2;
1206
1207         resize = true;
1208     }
1209
1210     if ( resize )
1211     {
1212         m_control->SetSize(size);
1213     }
1214
1215     // position it in the centre of the rectangle (TODO: support alignment?)
1216
1217 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1218     // the checkbox without label still has some space to the right in wxGTK,
1219     // so shift it to the right
1220     size.x -= 8;
1221 #elif defined(__WXMSW__)
1222     // here too, but in other way
1223     size.x += 1;
1224     size.y -= 2;
1225 #endif
1226
1227     int hAlign = wxALIGN_CENTRE;
1228     int vAlign = wxALIGN_CENTRE;
1229     if (GetCellAttr())
1230         GetCellAttr()->GetAlignment(& hAlign, & vAlign);
1231
1232     int x = 0, y = 0;
1233     if (hAlign == wxALIGN_LEFT)
1234     {
1235         x = r.x + 2;
1236
1237 #ifdef __WXMSW__
1238         x += 2;
1239 #endif
1240
1241         y = r.y + r.height / 2 - size.y / 2;
1242     }
1243     else if (hAlign == wxALIGN_RIGHT)
1244     {
1245         x = r.x + r.width - size.x - 2;
1246         y = r.y + r.height / 2 - size.y / 2;
1247     }
1248     else if (hAlign == wxALIGN_CENTRE)
1249     {
1250         x = r.x + r.width / 2 - size.x / 2;
1251         y = r.y + r.height / 2 - size.y / 2;
1252     }
1253
1254     m_control->Move(x, y);
1255 }
1256
1257 void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
1258 {
1259     m_control->Show(show);
1260
1261     if ( show )
1262     {
1263         wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
1264         CBox()->SetBackgroundColour(colBg);
1265     }
1266 }
1267
1268 void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
1269 {
1270     wxASSERT_MSG(m_control,
1271                  wxT("The wxGridCellEditor must be created first!"));
1272
1273     if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1274     {
1275         m_value = grid->GetTable()->GetValueAsBool(row, col);
1276     }
1277     else
1278     {
1279         wxString cellval( grid->GetTable()->GetValue(row, col) );
1280
1281         if ( cellval == ms_stringValues[false] )
1282             m_value = false;
1283         else if ( cellval == ms_stringValues[true] )
1284             m_value = true;
1285         else
1286         {
1287             // do not try to be smart here and convert it to true or false
1288             // because we'll still overwrite it with something different and
1289             // this risks to be very surprising for the user code, let them
1290             // know about it
1291             wxFAIL_MSG( wxT("invalid value for a cell with bool editor!") );
1292         }
1293     }
1294
1295     CBox()->SetValue(m_value);
1296     CBox()->SetFocus();
1297 }
1298
1299 bool wxGridCellBoolEditor::EndEdit(int WXUNUSED(row),
1300                                    int WXUNUSED(col),
1301                                    const wxGrid* WXUNUSED(grid),
1302                                    const wxString& WXUNUSED(oldval),
1303                                    wxString *newval)
1304 {
1305     bool value = CBox()->GetValue();
1306     if ( value == m_value )
1307         return false;
1308
1309     m_value = value;
1310
1311     if ( newval )
1312         *newval = GetValue();
1313
1314     return true;
1315 }
1316
1317 void wxGridCellBoolEditor::ApplyEdit(int row, int col, wxGrid* grid)
1318 {
1319     wxGridTableBase * const table = grid->GetTable();
1320     if ( table->CanSetValueAs(row, col, wxGRID_VALUE_BOOL) )
1321         table->SetValueAsBool(row, col, m_value);
1322     else
1323         table->SetValue(row, col, GetValue());
1324 }
1325
1326 void wxGridCellBoolEditor::Reset()
1327 {
1328     wxASSERT_MSG(m_control,
1329                  wxT("The wxGridCellEditor must be created first!"));
1330
1331     CBox()->SetValue(m_value);
1332 }
1333
1334 void wxGridCellBoolEditor::StartingClick()
1335 {
1336     CBox()->SetValue(!CBox()->GetValue());
1337 }
1338
1339 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
1340 {
1341     if ( wxGridCellEditor::IsAcceptedKey(event) )
1342     {
1343         int keycode = event.GetKeyCode();
1344         switch ( keycode )
1345         {
1346             case WXK_SPACE:
1347             case '+':
1348             case '-':
1349                 return true;
1350         }
1351     }
1352
1353     return false;
1354 }
1355
1356 void wxGridCellBoolEditor::StartingKey(wxKeyEvent& event)
1357 {
1358     int keycode = event.GetKeyCode();
1359     switch ( keycode )
1360     {
1361         case WXK_SPACE:
1362             CBox()->SetValue(!CBox()->GetValue());
1363             break;
1364
1365         case '+':
1366             CBox()->SetValue(true);
1367             break;
1368
1369         case '-':
1370             CBox()->SetValue(false);
1371             break;
1372     }
1373 }
1374
1375 wxString wxGridCellBoolEditor::GetValue() const
1376 {
1377   return ms_stringValues[CBox()->GetValue()];
1378 }
1379
1380 /* static */ void
1381 wxGridCellBoolEditor::UseStringValues(const wxString& valueTrue,
1382                                       const wxString& valueFalse)
1383 {
1384     ms_stringValues[false] = valueFalse;
1385     ms_stringValues[true] = valueTrue;
1386 }
1387
1388 /* static */ bool
1389 wxGridCellBoolEditor::IsTrueValue(const wxString& value)
1390 {
1391     return value == ms_stringValues[true];
1392 }
1393
1394 #endif // wxUSE_CHECKBOX
1395
1396 #if wxUSE_COMBOBOX
1397
1398 // ----------------------------------------------------------------------------
1399 // wxGridCellChoiceEditor
1400 // ----------------------------------------------------------------------------
1401
1402 wxGridCellChoiceEditor::wxGridCellChoiceEditor(const wxArrayString& choices,
1403                                                bool allowOthers)
1404     : m_choices(choices),
1405       m_allowOthers(allowOthers) { }
1406
1407 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
1408                                                const wxString choices[],
1409                                                bool allowOthers)
1410                       : m_allowOthers(allowOthers)
1411 {
1412     if ( count )
1413     {
1414         m_choices.Alloc(count);
1415         for ( size_t n = 0; n < count; n++ )
1416         {
1417             m_choices.Add(choices[n]);
1418         }
1419     }
1420 }
1421
1422 wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
1423 {
1424     wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
1425     editor->m_allowOthers = m_allowOthers;
1426     editor->m_choices = m_choices;
1427
1428     return editor;
1429 }
1430
1431 void wxGridCellChoiceEditor::Create(wxWindow* parent,
1432                                     wxWindowID id,
1433                                     wxEvtHandler* evtHandler)
1434 {
1435     int style = wxTE_PROCESS_ENTER |
1436                 wxTE_PROCESS_TAB |
1437                 wxBORDER_NONE;
1438
1439     if ( !m_allowOthers )
1440         style |= wxCB_READONLY;
1441     m_control = new wxComboBox(parent, id, wxEmptyString,
1442                                wxDefaultPosition, wxDefaultSize,
1443                                m_choices,
1444                                style);
1445
1446     wxGridCellEditor::Create(parent, id, evtHandler);
1447 }
1448
1449 void wxGridCellChoiceEditor::SetSize(const wxRect& rect)
1450 {
1451     wxASSERT_MSG(m_control,
1452                  wxT("The wxGridCellChoiceEditor must be created first!"));
1453
1454     // Check that the height is not too small to fit the combobox.
1455     wxRect rectTallEnough = rect;
1456     const wxSize bestSize = m_control->GetBestSize();
1457     const wxCoord diffY = bestSize.GetHeight() - rectTallEnough.GetHeight();
1458     if ( diffY > 0 )
1459     {
1460         // Do make it tall enough.
1461         rectTallEnough.height += diffY;
1462
1463         // Also centre the effective rectangle vertically with respect to the
1464         // original one.
1465         rectTallEnough.y -= diffY/2;
1466     }
1467     //else: The rectangle provided is already tall enough.
1468
1469     wxGridCellEditor::SetSize(rectTallEnough);
1470 }
1471
1472 void wxGridCellChoiceEditor::PaintBackground(wxDC& dc,
1473                                              const wxRect& rectCell,
1474                                              const wxGridCellAttr& attr)
1475 {
1476     // as we fill the entire client area, don't do anything here to minimize
1477     // flicker
1478
1479     // TODO: It doesn't actually fill the client area since the height of a
1480     // combo always defaults to the standard.  Until someone has time to
1481     // figure out the right rectangle to paint, just do it the normal way.
1482     wxGridCellEditor::PaintBackground(dc, rectCell, attr);
1483 }
1484
1485 void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
1486 {
1487     wxASSERT_MSG(m_control,
1488                  wxT("The wxGridCellEditor must be created first!"));
1489
1490     wxGridCellEditorEvtHandler* evtHandler = NULL;
1491     if (m_control)
1492         evtHandler = wxDynamicCast(m_control->GetEventHandler(), wxGridCellEditorEvtHandler);
1493
1494     // Don't immediately end if we get a kill focus event within BeginEdit
1495     if (evtHandler)
1496         evtHandler->SetInSetFocus(true);
1497
1498     m_value = grid->GetTable()->GetValue(row, col);
1499
1500     Reset(); // this updates combo box to correspond to m_value
1501
1502     Combo()->SetFocus();
1503
1504 #ifdef __WXOSX_COCOA__
1505     // This is a work around for the combobox being simply dismissed when a
1506     // choice is made in it under OS X. The bug is almost certainly due to a
1507     // problem in focus events generation logic but it's not obvious to fix and
1508     // for now this at least allows to use wxGrid.
1509     Combo()->Popup();
1510 #endif
1511
1512     if (evtHandler)
1513     {
1514         // When dropping down the menu, a kill focus event
1515         // happens after this point, so we can't reset the flag yet.
1516 #if !defined(__WXGTK20__)
1517         evtHandler->SetInSetFocus(false);
1518 #endif
1519     }
1520 }
1521
1522 bool wxGridCellChoiceEditor::EndEdit(int WXUNUSED(row),
1523                                      int WXUNUSED(col),
1524                                      const wxGrid* WXUNUSED(grid),
1525                                      const wxString& WXUNUSED(oldval),
1526                                      wxString *newval)
1527 {
1528     const wxString value = Combo()->GetValue();
1529     if ( value == m_value )
1530         return false;
1531
1532     m_value = value;
1533
1534     if ( newval )
1535         *newval = value;
1536
1537     return true;
1538 }
1539
1540 void wxGridCellChoiceEditor::ApplyEdit(int row, int col, wxGrid* grid)
1541 {
1542     grid->GetTable()->SetValue(row, col, m_value);
1543 }
1544
1545 void wxGridCellChoiceEditor::Reset()
1546 {
1547     if (m_allowOthers)
1548     {
1549         Combo()->SetValue(m_value);
1550         Combo()->SetInsertionPointEnd();
1551     }
1552     else // the combobox is read-only
1553     {
1554         // find the right position, or default to the first if not found
1555         int pos = Combo()->FindString(m_value);
1556         if (pos == wxNOT_FOUND)
1557             pos = 0;
1558         Combo()->SetSelection(pos);
1559     }
1560 }
1561
1562 void wxGridCellChoiceEditor::SetParameters(const wxString& params)
1563 {
1564     if ( !params )
1565     {
1566         // what can we do?
1567         return;
1568     }
1569
1570     m_choices.Empty();
1571
1572     wxStringTokenizer tk(params, wxT(','));
1573     while ( tk.HasMoreTokens() )
1574     {
1575         m_choices.Add(tk.GetNextToken());
1576     }
1577 }
1578
1579 // return the value in the text control
1580 wxString wxGridCellChoiceEditor::GetValue() const
1581 {
1582   return Combo()->GetValue();
1583 }
1584
1585 #endif // wxUSE_COMBOBOX
1586
1587 #if wxUSE_COMBOBOX
1588
1589 // ----------------------------------------------------------------------------
1590 // wxGridCellEnumEditor
1591 // ----------------------------------------------------------------------------
1592
1593 // A cell editor which displays an enum number as a textual equivalent. eg
1594 // data in cell is 0,1,2 ... n the cell could be displayed as
1595 // "John","Fred"..."Bob" in the combo choice box
1596
1597 wxGridCellEnumEditor::wxGridCellEnumEditor(const wxString& choices)
1598                      :wxGridCellChoiceEditor()
1599 {
1600     m_index = -1;
1601
1602     if (!choices.empty())
1603         SetParameters(choices);
1604 }
1605
1606 wxGridCellEditor *wxGridCellEnumEditor::Clone() const
1607 {
1608     wxGridCellEnumEditor *editor = new wxGridCellEnumEditor();
1609     editor->m_index = m_index;
1610     return editor;
1611 }
1612
1613 void wxGridCellEnumEditor::BeginEdit(int row, int col, wxGrid* grid)
1614 {
1615     wxASSERT_MSG(m_control,
1616                  wxT("The wxGridCellEnumEditor must be Created first!"));
1617
1618     wxGridCellEditorEvtHandler* evtHandler = NULL;
1619     if (m_control)
1620         evtHandler = wxDynamicCast(m_control->GetEventHandler(), wxGridCellEditorEvtHandler);
1621
1622     // Don't immediately end if we get a kill focus event within BeginEdit
1623     if (evtHandler)
1624         evtHandler->SetInSetFocus(true);
1625
1626     wxGridTableBase *table = grid->GetTable();
1627
1628     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1629     {
1630         m_index = table->GetValueAsLong(row, col);
1631     }
1632     else
1633     {
1634         wxString startValue = table->GetValue(row, col);
1635         if (startValue.IsNumber() && !startValue.empty())
1636         {
1637             startValue.ToLong(&m_index);
1638         }
1639         else
1640         {
1641             m_index = -1;
1642         }
1643     }
1644
1645     Combo()->SetSelection(m_index);
1646     Combo()->SetFocus();
1647
1648 #ifdef __WXOSX_COCOA__
1649     // This is a work around for the combobox being simply dismissed when a
1650     // choice is made in it under OS X. The bug is almost certainly due to a
1651     // problem in focus events generation logic but it's not obvious to fix and
1652     // for now this at least allows to use wxGrid.
1653     Combo()->Popup();
1654 #endif
1655
1656     if (evtHandler)
1657     {
1658         // When dropping down the menu, a kill focus event
1659         // happens after this point, so we can't reset the flag yet.
1660 #if !defined(__WXGTK20__)
1661         evtHandler->SetInSetFocus(false);
1662 #endif
1663     }
1664 }
1665
1666 bool wxGridCellEnumEditor::EndEdit(int WXUNUSED(row),
1667                                    int WXUNUSED(col),
1668                                    const wxGrid* WXUNUSED(grid),
1669                                    const wxString& WXUNUSED(oldval),
1670                                    wxString *newval)
1671 {
1672     long idx = Combo()->GetSelection();
1673     if ( idx == m_index )
1674         return false;
1675
1676     m_index = idx;
1677
1678     if ( newval )
1679         newval->Printf("%ld", m_index);
1680
1681     return true;
1682 }
1683
1684 void wxGridCellEnumEditor::ApplyEdit(int row, int col, wxGrid* grid)
1685 {
1686     wxGridTableBase * const table = grid->GetTable();
1687     if ( table->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1688         table->SetValueAsLong(row, col, m_index);
1689     else
1690         table->SetValue(row, col, wxString::Format("%ld", m_index));
1691 }
1692
1693 #endif // wxUSE_COMBOBOX
1694
1695 // ----------------------------------------------------------------------------
1696 // wxGridCellAutoWrapStringEditor
1697 // ----------------------------------------------------------------------------
1698
1699 void
1700 wxGridCellAutoWrapStringEditor::Create(wxWindow* parent,
1701                                        wxWindowID id,
1702                                        wxEvtHandler* evtHandler)
1703 {
1704     wxGridCellTextEditor::DoCreate(parent, id, evtHandler,
1705                                     wxTE_MULTILINE | wxTE_RICH);
1706 }
1707
1708
1709 #endif // wxUSE_GRID