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