]> git.saurik.com Git - wxWidgets.git/blob - src/generic/grid.cpp
projects / wxWidgets.git / blob
? search:


4ff5e599b6cf7eb525404b631abca266a256b255
[wxWidgets.git] / src / generic / grid.cpp
1 ///////////////////////////////////////////////////////////////////////////
2 // Name: generic/grid.cpp
3 // Purpose: wxGrid and related classes
4 // Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
5 // Modified by: Robin Dunn, Vadim Zeitlin
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 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "grid.h"
22 #endif
23
24 // For compilers that support precompilatixon, includes "wx/wx.h".
25 #include "wx/wxprec.h"
26
27 #include "wx/defs.h"
28
29 #ifdef __BORLANDC__
30 #pragma hdrstop
31 #endif
32
33 #if wxUSE_GRID
34
35 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
36 #include "gridg.cpp"
37 #else // wxUSE_NEW_GRID
38
39 #ifndef WX_PRECOMP
40 #include "wx/utils.h"
41 #include "wx/dcclient.h"
42 #include "wx/settings.h"
43 #include "wx/log.h"
44 #include "wx/textctrl.h"
45 #include "wx/checkbox.h"
46 #include "wx/combobox.h"
47 #include "wx/valtext.h"
48 #endif
49
50 #include "wx/textfile.h"
51 #include "wx/spinctrl.h"
52 #include "wx/tokenzr.h"
53
54 #include "wx/grid.h"
55 #include "wx/generic/gridsel.h"
56
57 #if defined(__WXMOTIF__)
58 #define WXUNUSED_MOTIF(identifier) WXUNUSED(identifier)
59 #else
60 #define WXUNUSED_MOTIF(identifier) identifier
61 #endif
62
63 #if defined(__WXGTK__)
64 #define WXUNUSED_GTK(identifier) WXUNUSED(identifier)
65 #else
66 #define WXUNUSED_GTK(identifier) identifier
67 #endif
68
69 // Required for wxIs... functions
70 #include <ctype.h>
71
72 // ----------------------------------------------------------------------------
73 // array classes
74 // ----------------------------------------------------------------------------
75
76 WX_DEFINE_EXPORTED_ARRAY(wxGridCellAttr *, wxArrayAttrs);
77
78 struct wxGridCellWithAttr
79 {
80 wxGridCellWithAttr(int row, int col, wxGridCellAttr *attr_)
81 : coords(row, col), attr(attr_)
82 {
83 }
84
85 ~wxGridCellWithAttr()
86 {
87 attr->DecRef();
88 }
89
90 wxGridCellCoords coords;
91 wxGridCellAttr *attr;
92 };
93
94 WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
95
96 #include "wx/arrimpl.cpp"
97
98 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
99 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
100
101 // ----------------------------------------------------------------------------
102 // events
103 // ----------------------------------------------------------------------------
104
105 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK)
106 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK)
107 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK)
108 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK)
109 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK)
110 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK)
111 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK)
112 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK)
113 DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE)
114 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE)
115 DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT)
116 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE)
117 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL)
118 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN)
119 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN)
120 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED)
121
122 // ----------------------------------------------------------------------------
123 // private classes
124 // ----------------------------------------------------------------------------
125
126 class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
127 {
128 public:
129 wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
130 wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
131 const wxPoint &pos, const wxSize &size );
132
133 private:
134 wxGrid *m_owner;
135
136 void OnPaint( wxPaintEvent& event );
137 void OnMouseEvent( wxMouseEvent& event );
138 void OnMouseWheel( wxMouseEvent& event );
139 void OnKeyDown( wxKeyEvent& event );
140 void OnKeyUp( wxKeyEvent& );
141
142 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
143 DECLARE_EVENT_TABLE()
144 };
145
146
147 class WXDLLEXPORT wxGridColLabelWindow : public wxWindow
148 {
149 public:
150 wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
151 wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
152 const wxPoint &pos, const wxSize &size );
153
154 private:
155 wxGrid *m_owner;
156
157 void OnPaint( wxPaintEvent &event );
158 void OnMouseEvent( wxMouseEvent& event );
159 void OnMouseWheel( wxMouseEvent& event );
160 void OnKeyDown( wxKeyEvent& event );
161 void OnKeyUp( wxKeyEvent& );
162
163 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
164 DECLARE_EVENT_TABLE()
165 };
166
167
168 class WXDLLEXPORT wxGridCornerLabelWindow : public wxWindow
169 {
170 public:
171 wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
172 wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
173 const wxPoint &pos, const wxSize &size );
174
175 private:
176 wxGrid *m_owner;
177
178 void OnMouseEvent( wxMouseEvent& event );
179 void OnMouseWheel( wxMouseEvent& event );
180 void OnKeyDown( wxKeyEvent& event );
181 void OnKeyUp( wxKeyEvent& );
182 void OnPaint( wxPaintEvent& event );
183
184 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
185 DECLARE_EVENT_TABLE()
186 };
187
188 class WXDLLEXPORT wxGridWindow : public wxPanel
189 {
190 public:
191 wxGridWindow()
192 {
193 m_owner = (wxGrid *)NULL;
194 m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
195 m_colLabelWin = (wxGridColLabelWindow *)NULL;
196 }
197
198 wxGridWindow( wxGrid *parent,
199 wxGridRowLabelWindow *rowLblWin,
200 wxGridColLabelWindow *colLblWin,
201 wxWindowID id, const wxPoint &pos, const wxSize &size );
202 ~wxGridWindow();
203
204 void ScrollWindow( int dx, int dy, const wxRect *rect );
205
206 private:
207 wxGrid *m_owner;
208 wxGridRowLabelWindow *m_rowLabelWin;
209 wxGridColLabelWindow *m_colLabelWin;
210
211 void OnPaint( wxPaintEvent &event );
212 void OnMouseWheel( wxMouseEvent& event );
213 void OnMouseEvent( wxMouseEvent& event );
214 void OnKeyDown( wxKeyEvent& );
215 void OnKeyUp( wxKeyEvent& );
216 void OnEraseBackground( wxEraseEvent& );
217
218
219 DECLARE_DYNAMIC_CLASS(wxGridWindow)
220 DECLARE_EVENT_TABLE()
221 };
222
223
224
225 class wxGridCellEditorEvtHandler : public wxEvtHandler
226 {
227 public:
228 wxGridCellEditorEvtHandler()
229 : m_grid(0), m_editor(0)
230 { }
231 wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
232 : m_grid(grid), m_editor(editor)
233 { }
234
235 void OnKeyDown(wxKeyEvent& event);
236 void OnChar(wxKeyEvent& event);
237
238 private:
239 wxGrid* m_grid;
240 wxGridCellEditor* m_editor;
241 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
242 DECLARE_EVENT_TABLE()
243 };
244
245
246 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
247 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
248 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
249 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
250 END_EVENT_TABLE()
251
252
253
254 // ----------------------------------------------------------------------------
255 // the internal data representation used by wxGridCellAttrProvider
256 // ----------------------------------------------------------------------------
257
258 // this class stores attributes set for cells
259 class WXDLLEXPORT wxGridCellAttrData
260 {
261 public:
262 void SetAttr(wxGridCellAttr *attr, int row, int col);
263 wxGridCellAttr *GetAttr(int row, int col) const;
264 void UpdateAttrRows( size_t pos, int numRows );
265 void UpdateAttrCols( size_t pos, int numCols );
266
267 private:
268 // searches for the attr for given cell, returns wxNOT_FOUND if not found
269 int FindIndex(int row, int col) const;
270
271 wxGridCellWithAttrArray m_attrs;
272 };
273
274 // this class stores attributes set for rows or columns
275 class WXDLLEXPORT wxGridRowOrColAttrData
276 {
277 public:
278 // empty ctor to suppress warnings
279 wxGridRowOrColAttrData() { }
280 ~wxGridRowOrColAttrData();
281
282 void SetAttr(wxGridCellAttr *attr, int rowOrCol);
283 wxGridCellAttr *GetAttr(int rowOrCol) const;
284 void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );
285
286 private:
287 wxArrayInt m_rowsOrCols;
288 wxArrayAttrs m_attrs;
289 };
290
291 // NB: this is just a wrapper around 3 objects: one which stores cell
292 // attributes, and 2 others for row/col ones
293 class WXDLLEXPORT wxGridCellAttrProviderData
294 {
295 public:
296 wxGridCellAttrData m_cellAttrs;
297 wxGridRowOrColAttrData m_rowAttrs,
298 m_colAttrs;
299 };
300
301
302 // ----------------------------------------------------------------------------
303 // data structures used for the data type registry
304 // ----------------------------------------------------------------------------
305
306 struct wxGridDataTypeInfo
307 {
308 wxGridDataTypeInfo(const wxString& typeName,
309 wxGridCellRenderer* renderer,
310 wxGridCellEditor* editor)
311 : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
312 { }
313
314 ~wxGridDataTypeInfo()
315 {
316 wxSafeDecRef(m_renderer);
317 wxSafeDecRef(m_editor);
318 }
319
320 wxString m_typeName;
321 wxGridCellRenderer* m_renderer;
322 wxGridCellEditor* m_editor;
323 };
324
325
326 WX_DEFINE_EXPORTED_ARRAY(wxGridDataTypeInfo*, wxGridDataTypeInfoArray);
327
328
329 class WXDLLEXPORT wxGridTypeRegistry
330 {
331 public:
332 wxGridTypeRegistry() {}
333 ~wxGridTypeRegistry();
334
335 void RegisterDataType(const wxString& typeName,
336 wxGridCellRenderer* renderer,
337 wxGridCellEditor* editor);
338
339 // find one of already registered data types
340 int FindRegisteredDataType(const wxString& typeName);
341
342 // try to FindRegisteredDataType(), if this fails and typeName is one of
343 // standard typenames, register it and return its index
344 int FindDataType(const wxString& typeName);
345
346 // try to FindDataType(), if it fails see if it is not one of already
347 // registered data types with some params in which case clone the
348 // registered data type and set params for it
349 int FindOrCloneDataType(const wxString& typeName);
350
351 wxGridCellRenderer* GetRenderer(int index);
352 wxGridCellEditor* GetEditor(int index);
353
354 private:
355 wxGridDataTypeInfoArray m_typeinfo;
356 };
357
358 // ----------------------------------------------------------------------------
359 // conditional compilation
360 // ----------------------------------------------------------------------------
361
362 #ifndef WXGRID_DRAW_LINES
363 #define WXGRID_DRAW_LINES 1
364 #endif
365
366 // ----------------------------------------------------------------------------
367 // globals
368 // ----------------------------------------------------------------------------
369
370 //#define DEBUG_ATTR_CACHE
371 #ifdef DEBUG_ATTR_CACHE
372 static size_t gs_nAttrCacheHits = 0;
373 static size_t gs_nAttrCacheMisses = 0;
374 #endif // DEBUG_ATTR_CACHE
375
376 // ----------------------------------------------------------------------------
377 // constants
378 // ----------------------------------------------------------------------------
379
380 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
381 wxRect wxGridNoCellRect( -1, -1, -1, -1 );
382
383 // scroll line size
384 // TODO: this doesn't work at all, grid cells have different sizes and approx
385 // calculations don't work as because of the size mismatch scrollbars
386 // sometimes fail to be shown when they should be or vice versa
387 //
388 // The scroll bars may be a little flakey once in a while, but that is
389 // surely much less horrible than having scroll lines of only 1!!!
390 // -- Robin
391 //
392 // Well, it's still seriously broken so it might be better but needs
393 // fixing anyhow
394 // -- Vadim
395 static const size_t GRID_SCROLL_LINE_X = 15; // 1;
396 static const size_t GRID_SCROLL_LINE_Y = GRID_SCROLL_LINE_X;
397
398 // the size of hash tables used a bit everywhere (the max number of elements
399 // in these hash tables is the number of rows/columns)
400 static const int GRID_HASH_SIZE = 100;
401
402 // ----------------------------------------------------------------------------
403 // private functions
404 // ----------------------------------------------------------------------------
405
406 static inline int GetScrollX(int x)
407 {
408 return (x + GRID_SCROLL_LINE_X - 1) / GRID_SCROLL_LINE_X;
409 }
410
411 static inline int GetScrollY(int y)
412 {
413 return (y + GRID_SCROLL_LINE_Y - 1) / GRID_SCROLL_LINE_Y;
414 }
415
416 // ============================================================================
417 // implementation
418 // ============================================================================
419
420 // ----------------------------------------------------------------------------
421 // wxGridCellEditor
422 // ----------------------------------------------------------------------------
423
424 wxGridCellEditor::wxGridCellEditor()
425 {
426 m_control = NULL;
427 }
428
429
430 wxGridCellEditor::~wxGridCellEditor()
431 {
432 Destroy();
433 }
434
435 void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
436 wxWindowID WXUNUSED(id),
437 wxEvtHandler* evtHandler)
438 {
439 if ( evtHandler )
440 m_control->PushEventHandler(evtHandler);
441 }
442
443 void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
444 wxGridCellAttr *attr)
445 {
446 // erase the background because we might not fill the cell
447 wxClientDC dc(m_control->GetParent());
448 dc.SetPen(*wxTRANSPARENT_PEN);
449 dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
450 dc.DrawRectangle(rectCell);
451
452 // redraw the control we just painted over
453 m_control->Refresh();
454 }
455
456 void wxGridCellEditor::Destroy()
457 {
458 if (m_control)
459 {
460 m_control->PopEventHandler(TRUE /* delete it*/);
461
462 m_control->Destroy();
463 m_control = NULL;
464 }
465 }
466
467 void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
468 {
469 wxASSERT_MSG(m_control,
470 wxT("The wxGridCellEditor must be Created first!"));
471 m_control->Show(show);
472
473 if ( show )
474 {
475 // set the colours/fonts if we have any
476 if ( attr )
477 {
478 m_colFgOld = m_control->GetForegroundColour();
479 m_control->SetForegroundColour(attr->GetTextColour());
480
481 m_colBgOld = m_control->GetBackgroundColour();
482 m_control->SetBackgroundColour(attr->GetBackgroundColour());
483
484 m_fontOld = m_control->GetFont();
485 m_control->SetFont(attr->GetFont());
486
487 // can't do anything more in the base class version, the other
488 // attributes may only be used by the derived classes
489 }
490 }
491 else
492 {
493 // restore the standard colours fonts
494 if ( m_colFgOld.Ok() )
495 {
496 m_control->SetForegroundColour(m_colFgOld);
497 m_colFgOld = wxNullColour;
498 }
499
500 if ( m_colBgOld.Ok() )
501 {
502 m_control->SetBackgroundColour(m_colBgOld);
503 m_colBgOld = wxNullColour;
504 }
505
506 if ( m_fontOld.Ok() )
507 {
508 m_control->SetFont(m_fontOld);
509 m_fontOld = wxNullFont;
510 }
511 }
512 }
513
514 void wxGridCellEditor::SetSize(const wxRect& rect)
515 {
516 wxASSERT_MSG(m_control,
517 wxT("The wxGridCellEditor must be Created first!"));
518 m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
519 }
520
521 void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
522 {
523 event.Skip();
524 }
525
526 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
527 {
528 // accept the simple key presses, not anything with Ctrl/Alt/Meta
529 return !(event.ControlDown() || event.AltDown());
530 }
531
532 void wxGridCellEditor::StartingKey(wxKeyEvent& event)
533 {
534 event.Skip();
535 }
536
537 void wxGridCellEditor::StartingClick()
538 {
539 }
540
541 #if wxUSE_TEXTCTRL
542
543 // ----------------------------------------------------------------------------
544 // wxGridCellTextEditor
545 // ----------------------------------------------------------------------------
546
547 wxGridCellTextEditor::wxGridCellTextEditor()
548 {
549 m_maxChars = 0;
550 }
551
552 void wxGridCellTextEditor::Create(wxWindow* parent,
553 wxWindowID id,
554 wxEvtHandler* evtHandler)
555 {
556 m_control = new wxTextCtrl(parent, id, wxEmptyString,
557 wxDefaultPosition, wxDefaultSize
558 #if defined(__WXMSW__)
559 , wxTE_PROCESS_TAB | wxTE_MULTILINE |
560 wxTE_NO_VSCROLL | wxTE_AUTO_SCROLL
561 #endif
562 );
563
564 // TODO: use m_maxChars
565
566 wxGridCellEditor::Create(parent, id, evtHandler);
567 }
568
569 void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
570 wxGridCellAttr * WXUNUSED(attr))
571 {
572 // as we fill the entire client area, don't do anything here to minimize
573 // flicker
574 }
575
576 void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
577 {
578 wxRect rect(rectOrig);
579
580 // Make the edit control large enough to allow for internal
581 // margins
582 //
583 // TODO: remove this if the text ctrl sizing is improved esp. for
584 // unix
585 //
586 #if defined(__WXGTK__)
587 if (rect.x != 0)
588 {
589 rect.x += 1;
590 rect.y += 1;
591 rect.width -= 1;
592 rect.height -= 1;
593 }
594 #else // !GTK
595 int extra_x = ( rect.x > 2 )? 2 : 1;
596
597 // MB: treat MSW separately here otherwise the caret doesn't show
598 // when the editor is in the first row.
599 #if defined(__WXMSW__)
600 int extra_y = 2;
601 #else
602 int extra_y = ( rect.y > 2 )? 2 : 1;
603 #endif // MSW
604
605 #if defined(__WXMOTIF__)
606 extra_x *= 2;
607 extra_y *= 2;
608 #endif
609 rect.SetLeft( wxMax(0, rect.x - extra_x) );
610 rect.SetTop( wxMax(0, rect.y - extra_y) );
611 rect.SetRight( rect.GetRight() + 2*extra_x );
612 rect.SetBottom( rect.GetBottom() + 2*extra_y );
613 #endif // GTK/!GTK
614
615 wxGridCellEditor::SetSize(rect);
616 }
617
618 void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
619 {
620 wxASSERT_MSG(m_control,
621 wxT("The wxGridCellEditor must be Created first!"));
622
623 m_startValue = grid->GetTable()->GetValue(row, col);
624
625 DoBeginEdit(m_startValue);
626 }
627
628 void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
629 {
630 Text()->SetValue(startValue);
631 Text()->SetInsertionPointEnd();
632 Text()->SetFocus();
633 }
634
635 bool wxGridCellTextEditor::EndEdit(int row, int col,
636 wxGrid* grid)
637 {
638 wxASSERT_MSG(m_control,
639 wxT("The wxGridCellEditor must be Created first!"));
640
641 bool changed = FALSE;
642 wxString value = Text()->GetValue();
643 if (value != m_startValue)
644 changed = TRUE;
645
646 if (changed)
647 grid->GetTable()->SetValue(row, col, value);
648
649 m_startValue = wxEmptyString;
650 Text()->SetValue(m_startValue);
651
652 return changed;
653 }
654
655
656 void wxGridCellTextEditor::Reset()
657 {
658 wxASSERT_MSG(m_control,
659 wxT("The wxGridCellEditor must be Created first!"));
660
661 DoReset(m_startValue);
662 }
663
664 void wxGridCellTextEditor::DoReset(const wxString& startValue)
665 {
666 Text()->SetValue(startValue);
667 Text()->SetInsertionPointEnd();
668 }
669
670 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)
671 {
672 if ( wxGridCellEditor::IsAcceptedKey(event) )
673 {
674 int keycode = event.GetKeyCode();
675 switch ( keycode )
676 {
677 case WXK_NUMPAD0:
678 case WXK_NUMPAD1:
679 case WXK_NUMPAD2:
680 case WXK_NUMPAD3:
681 case WXK_NUMPAD4:
682 case WXK_NUMPAD5:
683 case WXK_NUMPAD6:
684 case WXK_NUMPAD7:
685 case WXK_NUMPAD8:
686 case WXK_NUMPAD9:
687 case WXK_MULTIPLY:
688 case WXK_NUMPAD_MULTIPLY:
689 case WXK_ADD:
690 case WXK_NUMPAD_ADD:
691 case WXK_SUBTRACT:
692 case WXK_NUMPAD_SUBTRACT:
693 case WXK_DECIMAL:
694 case WXK_NUMPAD_DECIMAL:
695 case WXK_DIVIDE:
696 case WXK_NUMPAD_DIVIDE:
697 return TRUE;
698
699 default:
700 // accept 8 bit chars too if isprint() agrees
701 if ( (keycode < 255) && (isprint(keycode)) )
702 return TRUE;
703 }
704 }
705
706 return FALSE;
707 }
708
709 void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
710 {
711 // we don't check for !HasModifiers() because IsAcceptedKey() did it
712
713 // insert the key in the control
714 wxChar ch;
715 int keycode = event.GetKeyCode();
716 switch ( keycode )
717 {
718 case WXK_NUMPAD0:
719 case WXK_NUMPAD1:
720 case WXK_NUMPAD2:
721 case WXK_NUMPAD3:
722 case WXK_NUMPAD4:
723 case WXK_NUMPAD5:
724 case WXK_NUMPAD6:
725 case WXK_NUMPAD7:
726 case WXK_NUMPAD8:
727 case WXK_NUMPAD9:
728 ch = _T('0') + keycode - WXK_NUMPAD0;
729 break;
730
731 case WXK_MULTIPLY:
732 case WXK_NUMPAD_MULTIPLY:
733 ch = _T('*');
734 break;
735
736 case WXK_ADD:
737 case WXK_NUMPAD_ADD:
738 ch = _T('+');
739 break;
740
741 case WXK_SUBTRACT:
742 case WXK_NUMPAD_SUBTRACT:
743 ch = _T('-');
744 break;
745
746 case WXK_DECIMAL:
747 case WXK_NUMPAD_DECIMAL:
748 ch = _T('.');
749 break;
750
751 case WXK_DIVIDE:
752 case WXK_NUMPAD_DIVIDE:
753 ch = _T('/');
754 break;
755
756 default:
757 if ( keycode < 256 && keycode >= 0 && isprint(keycode) )
758 {
759 // FIXME this is not going to work for non letters...
760 if ( !event.ShiftDown() )
761 {
762 keycode = tolower(keycode);
763 }
764
765 ch = (wxChar)keycode;
766 }
767 else
768 {
769 ch = _T('\0');
770 }
771 }
772
773 if ( ch )
774 {
775 Text()->AppendText(ch);
776 }
777 else
778 {
779 event.Skip();
780 }
781 }
782
783 void wxGridCellTextEditor::HandleReturn( wxKeyEvent&
784 WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )
785 {
786 #if defined(__WXMOTIF__) || defined(__WXGTK__)
787 // wxMotif needs a little extra help...
788 size_t pos = (size_t)( Text()->GetInsertionPoint() );
789 wxString s( Text()->GetValue() );
790 s = s.Left(pos) + "\n" + s.Mid(pos);
791 Text()->SetValue(s);
792 Text()->SetInsertionPoint( pos );
793 #else
794 // the other ports can handle a Return key press
795 //
796 event.Skip();
797 #endif
798 }
799
800 void wxGridCellTextEditor::SetParameters(const wxString& params)
801 {
802 if ( !params )
803 {
804 // reset to default
805 m_maxChars = 0;
806 }
807 else
808 {
809 long tmp;
810 if ( !params.ToLong(&tmp) )
811 {
812 wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str());
813 }
814 else
815 {
816 m_maxChars = (size_t)tmp;
817 }
818 }
819 }
820
821 // ----------------------------------------------------------------------------
822 // wxGridCellNumberEditor
823 // ----------------------------------------------------------------------------
824
825 wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
826 {
827 m_min = min;
828 m_max = max;
829 }
830
831 void wxGridCellNumberEditor::Create(wxWindow* parent,
832 wxWindowID id,
833 wxEvtHandler* evtHandler)
834 {
835 if ( HasRange() )
836 {
837 // create a spin ctrl
838 m_control = new wxSpinCtrl(parent, -1, wxEmptyString,
839 wxDefaultPosition, wxDefaultSize,
840 wxSP_ARROW_KEYS,
841 m_min, m_max);
842
843 wxGridCellEditor::Create(parent, id, evtHandler);
844 }
845 else
846 {
847 // just a text control
848 wxGridCellTextEditor::Create(parent, id, evtHandler);
849
850 #if wxUSE_VALIDATORS
851 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
852 #endif // wxUSE_VALIDATORS
853 }
854 }
855
856 void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
857 {
858 // first get the value
859 wxGridTableBase *table = grid->GetTable();
860 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
861 {
862 m_valueOld = table->GetValueAsLong(row, col);
863 }
864 else
865 {
866 wxString sValue = table->GetValue(row, col);
867 if (! sValue.ToLong(&m_valueOld))
868 {
869 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
870 return;
871 }
872 }
873
874 if ( HasRange() )
875 {
876 Spin()->SetValue((int)m_valueOld);
877 Spin()->SetFocus();
878 }
879 else
880 {
881 DoBeginEdit(GetString());
882 }
883 }
884
885 bool wxGridCellNumberEditor::EndEdit(int row, int col,
886 wxGrid* grid)
887 {
888 bool changed;
889 long value;
890
891 if ( HasRange() )
892 {
893 value = Spin()->GetValue();
894 changed = value != m_valueOld;
895 }
896 else
897 {
898 changed = Text()->GetValue().ToLong(&value) && (value != m_valueOld);
899 }
900
901 if ( changed )
902 {
903 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
904 grid->GetTable()->SetValueAsLong(row, col, value);
905 else
906 grid->GetTable()->SetValue(row, col, wxString::Format(wxT("%ld"), value));
907 }
908
909 return changed;
910 }
911
912 void wxGridCellNumberEditor::Reset()
913 {
914 if ( HasRange() )
915 {
916 Spin()->SetValue((int)m_valueOld);
917 }
918 else
919 {
920 DoReset(GetString());
921 }
922 }
923
924 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
925 {
926 if ( wxGridCellEditor::IsAcceptedKey(event) )
927 {
928 int keycode = event.GetKeyCode();
929 switch ( keycode )
930 {
931 case WXK_NUMPAD0:
932 case WXK_NUMPAD1:
933 case WXK_NUMPAD2:
934 case WXK_NUMPAD3:
935 case WXK_NUMPAD4:
936 case WXK_NUMPAD5:
937 case WXK_NUMPAD6:
938 case WXK_NUMPAD7:
939 case WXK_NUMPAD8:
940 case WXK_NUMPAD9:
941 case WXK_ADD:
942 case WXK_NUMPAD_ADD:
943 case WXK_SUBTRACT:
944 case WXK_NUMPAD_SUBTRACT:
945 case WXK_UP:
946 case WXK_DOWN:
947 return TRUE;
948
949 default:
950 if ( (keycode < 128) && isdigit(keycode) )
951 return TRUE;
952 }
953 }
954
955 return FALSE;
956 }
957
958 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
959 {
960 if ( !HasRange() )
961 {
962 int keycode = (int) event.KeyCode();
963 if ( isdigit(keycode) || keycode == '+' || keycode == '-' )
964 {
965 wxGridCellTextEditor::StartingKey(event);
966
967 // skip Skip() below
968 return;
969 }
970 }
971
972 event.Skip();
973 }
974
975 void wxGridCellNumberEditor::SetParameters(const wxString& params)
976 {
977 if ( !params )
978 {
979 // reset to default
980 m_min =
981 m_max = -1;
982 }
983 else
984 {
985 long tmp;
986 if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
987 {
988 m_min = (int)tmp;
989
990 if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
991 {
992 m_max = (int)tmp;
993
994 // skip the error message below
995 return;
996 }
997 }
998
999 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());
1000 }
1001 }
1002
1003 // ----------------------------------------------------------------------------
1004 // wxGridCellFloatEditor
1005 // ----------------------------------------------------------------------------
1006
1007 wxGridCellFloatEditor::wxGridCellFloatEditor(int width, int precision)
1008 {
1009 m_width = width;
1010 m_precision = precision;
1011 }
1012
1013 void wxGridCellFloatEditor::Create(wxWindow* parent,
1014 wxWindowID id,
1015 wxEvtHandler* evtHandler)
1016 {
1017 wxGridCellTextEditor::Create(parent, id, evtHandler);
1018
1019 #if wxUSE_VALIDATORS
1020 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
1021 #endif // wxUSE_VALIDATORS
1022 }
1023
1024 void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
1025 {
1026 // first get the value
1027 wxGridTableBase *table = grid->GetTable();
1028 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1029 {
1030 m_valueOld = table->GetValueAsDouble(row, col);
1031 }
1032 else
1033 {
1034 wxString sValue = table->GetValue(row, col);
1035 if (! sValue.ToDouble(&m_valueOld))
1036 {
1037 wxFAIL_MSG( _T("this cell doesn't have float value") );
1038 return;
1039 }
1040 }
1041
1042 DoBeginEdit(GetString());
1043 }
1044
1045 bool wxGridCellFloatEditor::EndEdit(int row, int col,
1046 wxGrid* grid)
1047 {
1048 double value;
1049 if ( Text()->GetValue().ToDouble(&value) && (value != m_valueOld) )
1050 {
1051 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
1052 grid->GetTable()->SetValueAsDouble(row, col, value);
1053 else
1054 grid->GetTable()->SetValue(row, col, wxString::Format(wxT("%f"), value));
1055
1056 return TRUE;
1057 }
1058 else
1059 {
1060 return FALSE;
1061 }
1062 }
1063
1064 void wxGridCellFloatEditor::Reset()
1065 {
1066 DoReset(GetString());
1067 }
1068
1069 void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
1070 {
1071 int keycode = (int)event.KeyCode();
1072 if ( isdigit(keycode) ||
1073 keycode == '+' || keycode == '-' || keycode == '.' )
1074 {
1075 wxGridCellTextEditor::StartingKey(event);
1076
1077 // skip Skip() below
1078 return;
1079 }
1080
1081 event.Skip();
1082 }
1083
1084 void wxGridCellFloatEditor::SetParameters(const wxString& params)
1085 {
1086 if ( !params )
1087 {
1088 // reset to default
1089 m_width =
1090 m_precision = -1;
1091 }
1092 else
1093 {
1094 long tmp;
1095 if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
1096 {
1097 m_width = (int)tmp;
1098
1099 if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
1100 {
1101 m_precision = (int)tmp;
1102
1103 // skip the error message below
1104 return;
1105 }
1106 }
1107
1108 wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params.c_str());
1109 }
1110 }
1111
1112 wxString wxGridCellFloatEditor::GetString() const
1113 {
1114 wxString fmt;
1115 if ( m_width == -1 )
1116 {
1117 // default width/precision
1118 fmt = _T("%g");
1119 }
1120 else if ( m_precision == -1 )
1121 {
1122 // default precision
1123 fmt.Printf(_T("%%%d.g"), m_width);
1124 }
1125 else
1126 {
1127 fmt.Printf(_T("%%%d.%dg"), m_width, m_precision);
1128 }
1129
1130 return wxString::Format(fmt, m_valueOld);
1131 }
1132
1133 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
1134 {
1135 if ( wxGridCellEditor::IsAcceptedKey(event) )
1136 {
1137 int keycode = event.GetKeyCode();
1138 switch ( keycode )
1139 {
1140 case WXK_NUMPAD0:
1141 case WXK_NUMPAD1:
1142 case WXK_NUMPAD2:
1143 case WXK_NUMPAD3:
1144 case WXK_NUMPAD4:
1145 case WXK_NUMPAD5:
1146 case WXK_NUMPAD6:
1147 case WXK_NUMPAD7:
1148 case WXK_NUMPAD8:
1149 case WXK_NUMPAD9:
1150 case WXK_ADD:
1151 case WXK_NUMPAD_ADD:
1152 case WXK_SUBTRACT:
1153 case WXK_NUMPAD_SUBTRACT:
1154 case WXK_DECIMAL:
1155 case WXK_NUMPAD_DECIMAL:
1156 return TRUE;
1157
1158 default:
1159 // additionally accept 'e' as in '1e+6'
1160 if ( (keycode < 128) &&
1161 (isdigit(keycode) || tolower(keycode) == 'e') )
1162 return TRUE;
1163 }
1164 }
1165
1166 return FALSE;
1167 }
1168
1169 #endif // wxUSE_TEXTCTRL
1170
1171 #if wxUSE_CHECKBOX
1172
1173 // ----------------------------------------------------------------------------
1174 // wxGridCellBoolEditor
1175 // ----------------------------------------------------------------------------
1176
1177 void wxGridCellBoolEditor::Create(wxWindow* parent,
1178 wxWindowID id,
1179 wxEvtHandler* evtHandler)
1180 {
1181 m_control = new wxCheckBox(parent, id, wxEmptyString,
1182 wxDefaultPosition, wxDefaultSize,
1183 wxNO_BORDER);
1184
1185 wxGridCellEditor::Create(parent, id, evtHandler);
1186 }
1187
1188 void wxGridCellBoolEditor::SetSize(const wxRect& r)
1189 {
1190 bool resize = FALSE;
1191 wxSize size = m_control->GetSize();
1192 wxCoord minSize = wxMin(r.width, r.height);
1193
1194 // check if the checkbox is not too big/small for this cell
1195 wxSize sizeBest = m_control->GetBestSize();
1196 if ( !(size == sizeBest) )
1197 {
1198 // reset to default size if it had been made smaller
1199 size = sizeBest;
1200
1201 resize = TRUE;
1202 }
1203
1204 if ( size.x >= minSize || size.y >= minSize )
1205 {
1206 // leave 1 pixel margin
1207 size.x = size.y = minSize - 2;
1208
1209 resize = TRUE;
1210 }
1211
1212 if ( resize )
1213 {
1214 m_control->SetSize(size);
1215 }
1216
1217 // position it in the centre of the rectangle (TODO: support alignment?)
1218
1219 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1220 // the checkbox without label still has some space to the right in wxGTK,
1221 // so shift it to the right
1222 size.x -= 8;
1223 #elif defined(__WXMSW__)
1224 // here too, but in other way
1225 size.x += 1;
1226 size.y -= 2;
1227 #endif
1228
1229 m_control->Move(r.x + r.width/2 - size.x/2, r.y + r.height/2 - size.y/2);
1230 }
1231
1232 void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
1233 {
1234 m_control->Show(show);
1235
1236 if ( show )
1237 {
1238 wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
1239 CBox()->SetBackgroundColour(colBg);
1240 }
1241 }
1242
1243 void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
1244 {
1245 wxASSERT_MSG(m_control,
1246 wxT("The wxGridCellEditor must be Created first!"));
1247
1248 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1249 m_startValue = grid->GetTable()->GetValueAsBool(row, col);
1250 else
1251 {
1252 wxString cellval( grid->GetTable()->GetValue(row, col) );
1253 m_startValue = !( !cellval || (cellval == "0") );
1254 }
1255 CBox()->SetValue(m_startValue);
1256 CBox()->SetFocus();
1257 }
1258
1259 bool wxGridCellBoolEditor::EndEdit(int row, int col,
1260 wxGrid* grid)
1261 {
1262 wxASSERT_MSG(m_control,
1263 wxT("The wxGridCellEditor must be Created first!"));
1264
1265 bool changed = FALSE;
1266 bool value = CBox()->GetValue();
1267 if ( value != m_startValue )
1268 changed = TRUE;
1269
1270 if ( changed )
1271 {
1272 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1273 grid->GetTable()->SetValueAsBool(row, col, value);
1274 else
1275 grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
1276 }
1277
1278 return changed;
1279 }
1280
1281 void wxGridCellBoolEditor::Reset()
1282 {
1283 wxASSERT_MSG(m_control,
1284 wxT("The wxGridCellEditor must be Created first!"));
1285
1286 CBox()->SetValue(m_startValue);
1287 }
1288
1289 void wxGridCellBoolEditor::StartingClick()
1290 {
1291 CBox()->SetValue(!CBox()->GetValue());
1292 }
1293
1294 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
1295 {
1296 if ( wxGridCellEditor::IsAcceptedKey(event) )
1297 {
1298 int keycode = event.GetKeyCode();
1299 switch ( keycode )
1300 {
1301 case WXK_MULTIPLY:
1302 case WXK_NUMPAD_MULTIPLY:
1303 case WXK_ADD:
1304 case WXK_NUMPAD_ADD:
1305 case WXK_SUBTRACT:
1306 case WXK_NUMPAD_SUBTRACT:
1307 case WXK_SPACE:
1308 case '+':
1309 case '-':
1310 return TRUE;
1311 }
1312 }
1313
1314 return FALSE;
1315 }
1316
1317 #endif // wxUSE_CHECKBOX
1318
1319 #if wxUSE_COMBOBOX
1320
1321 // ----------------------------------------------------------------------------
1322 // wxGridCellChoiceEditor
1323 // ----------------------------------------------------------------------------
1324
1325 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
1326 const wxString choices[],
1327 bool allowOthers)
1328 : m_allowOthers(allowOthers)
1329 {
1330 if ( count )
1331 {
1332 m_choices.Alloc(count);
1333 for ( size_t n = 0; n < count; n++ )
1334 {
1335 m_choices.Add(choices[n]);
1336 }
1337 }
1338 }
1339
1340 wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
1341 {
1342 wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
1343 editor->m_allowOthers = m_allowOthers;
1344 editor->m_choices = m_choices;
1345
1346 return editor;
1347 }
1348
1349 void wxGridCellChoiceEditor::Create(wxWindow* parent,
1350 wxWindowID id,
1351 wxEvtHandler* evtHandler)
1352 {
1353 size_t count = m_choices.GetCount();
1354 wxString *choices = new wxString[count];
1355 for ( size_t n = 0; n < count; n++ )
1356 {
1357 choices[n] = m_choices[n];
1358 }
1359
1360 m_control = new wxComboBox(parent, id, wxEmptyString,
1361 wxDefaultPosition, wxDefaultSize,
1362 count, choices,
1363 m_allowOthers ? 0 : wxCB_READONLY);
1364
1365 delete [] choices;
1366
1367 wxGridCellEditor::Create(parent, id, evtHandler);
1368 }
1369
1370 void wxGridCellChoiceEditor::PaintBackground(const wxRect& rectCell,
1371 wxGridCellAttr * attr)
1372 {
1373 // as we fill the entire client area, don't do anything here to minimize
1374 // flicker
1375
1376 // TODO: It doesn't actually fill the client area since the height of a
1377 // combo always defaults to the standard... Until someone has time to
1378 // figure out the right rectangle to paint, just do it the normal way...
1379 wxGridCellEditor::PaintBackground(rectCell, attr);
1380 }
1381
1382 void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
1383 {
1384 wxASSERT_MSG(m_control,
1385 wxT("The wxGridCellEditor must be Created first!"));
1386
1387 m_startValue = grid->GetTable()->GetValue(row, col);
1388
1389 Combo()->SetValue(m_startValue);
1390 size_t count = m_choices.GetCount();
1391 for (size_t i=0; i<count; i++)
1392 {
1393 if (m_startValue == m_choices[i])
1394 {
1395 Combo()->SetSelection(i);
1396 break;
1397 }
1398 }
1399 Combo()->SetInsertionPointEnd();
1400 Combo()->SetFocus();
1401 }
1402
1403 bool wxGridCellChoiceEditor::EndEdit(int row, int col,
1404 wxGrid* grid)
1405 {
1406 wxString value = Combo()->GetValue();
1407 bool changed = value != m_startValue;
1408
1409 if ( changed )
1410 grid->GetTable()->SetValue(row, col, value);
1411
1412 m_startValue = wxEmptyString;
1413 Combo()->SetValue(m_startValue);
1414
1415 return changed;
1416 }
1417
1418 void wxGridCellChoiceEditor::Reset()
1419 {
1420 Combo()->SetValue(m_startValue);
1421 Combo()->SetInsertionPointEnd();
1422 }
1423
1424 void wxGridCellChoiceEditor::SetParameters(const wxString& params)
1425 {
1426 if ( !params )
1427 {
1428 // what can we do?
1429 return;
1430 }
1431
1432 m_choices.Empty();
1433
1434 wxStringTokenizer tk(params, _T(','));
1435 while ( tk.HasMoreTokens() )
1436 {
1437 m_choices.Add(tk.GetNextToken());
1438 }
1439 }
1440
1441 #endif // wxUSE_COMBOBOX
1442
1443 // ----------------------------------------------------------------------------
1444 // wxGridCellEditorEvtHandler
1445 // ----------------------------------------------------------------------------
1446
1447 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
1448 {
1449 switch ( event.KeyCode() )
1450 {
1451 case WXK_ESCAPE:
1452 m_editor->Reset();
1453 m_grid->DisableCellEditControl();
1454 break;
1455
1456 case WXK_TAB:
1457 m_grid->GetEventHandler()->ProcessEvent( event );
1458 break;
1459
1460 case WXK_RETURN:
1461 case WXK_NUMPAD_ENTER:
1462 if (!m_grid->GetEventHandler()->ProcessEvent(event))
1463 m_editor->HandleReturn(event);
1464 break;
1465
1466
1467 default:
1468 event.Skip();
1469 }
1470 }
1471
1472 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
1473 {
1474 switch ( event.KeyCode() )
1475 {
1476 case WXK_ESCAPE:
1477 case WXK_TAB:
1478 case WXK_RETURN:
1479 case WXK_NUMPAD_ENTER:
1480 break;
1481
1482 default:
1483 event.Skip();
1484 }
1485 }
1486
1487 // ----------------------------------------------------------------------------
1488 // wxGridCellWorker is an (almost) empty common base class for
1489 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1490 // ----------------------------------------------------------------------------
1491
1492 void wxGridCellWorker::SetParameters(const wxString& WXUNUSED(params))
1493 {
1494 // nothing to do
1495 }
1496
1497 wxGridCellWorker::~wxGridCellWorker()
1498 {
1499 }
1500
1501 // ============================================================================
1502 // renderer classes
1503 // ============================================================================
1504
1505 // ----------------------------------------------------------------------------
1506 // wxGridCellRenderer
1507 // ----------------------------------------------------------------------------
1508
1509 void wxGridCellRenderer::Draw(wxGrid& grid,
1510 wxGridCellAttr& attr,
1511 wxDC& dc,
1512 const wxRect& rect,
1513 int WXUNUSED(row), int WXUNUSED(col),
1514 bool isSelected)
1515 {
1516 dc.SetBackgroundMode( wxSOLID );
1517
1518 if ( isSelected )
1519 {
1520 dc.SetBrush( wxBrush(grid.GetSelectionBackground(), wxSOLID) );
1521 }
1522 else
1523 {
1524 dc.SetBrush( wxBrush(attr.GetBackgroundColour(), wxSOLID) );
1525 }
1526
1527 dc.SetPen( *wxTRANSPARENT_PEN );
1528 dc.DrawRectangle(rect);
1529 }
1530
1531 // ----------------------------------------------------------------------------
1532 // wxGridCellStringRenderer
1533 // ----------------------------------------------------------------------------
1534
1535 void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
1536 wxGridCellAttr& attr,
1537 wxDC& dc,
1538 bool isSelected)
1539 {
1540 dc.SetBackgroundMode( wxTRANSPARENT );
1541
1542 // TODO some special colours for attr.IsReadOnly() case?
1543
1544 if ( isSelected )
1545 {
1546 dc.SetTextBackground( grid.GetSelectionBackground() );
1547 dc.SetTextForeground( grid.GetSelectionForeground() );
1548 }
1549 else
1550 {
1551 dc.SetTextBackground( attr.GetBackgroundColour() );
1552 dc.SetTextForeground( attr.GetTextColour() );
1553 }
1554
1555 dc.SetFont( attr.GetFont() );
1556 }
1557
1558 wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
1559 wxDC& dc,
1560 const wxString& text)
1561 {
1562 wxCoord x = 0, y = 0, max_x = 0;
1563 dc.SetFont(attr.GetFont());
1564 wxStringTokenizer tk(text, _T('\n'));
1565 while ( tk.HasMoreTokens() )
1566 {
1567 dc.GetTextExtent(tk.GetNextToken(), &x, &y);
1568 max_x = wxMax(max_x, x);
1569 }
1570
1571 y *= 1 + text.Freq(wxT('\n')); // multiply by the number of lines.
1572
1573 return wxSize(max_x, y);
1574 }
1575
1576 wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
1577 wxGridCellAttr& attr,
1578 wxDC& dc,
1579 int row, int col)
1580 {
1581 return DoGetBestSize(attr, dc, grid.GetCellValue(row, col));
1582 }
1583
1584 void wxGridCellStringRenderer::Draw(wxGrid& grid,
1585 wxGridCellAttr& attr,
1586 wxDC& dc,
1587 const wxRect& rectCell,
1588 int row, int col,
1589 bool isSelected)
1590 {
1591 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1592
1593 // now we only have to draw the text
1594 SetTextColoursAndFont(grid, attr, dc, isSelected);
1595
1596 int hAlign, vAlign;
1597 attr.GetAlignment(&hAlign, &vAlign);
1598
1599 wxRect rect = rectCell;
1600 rect.Inflate(-1);
1601
1602 grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
1603 rect, hAlign, vAlign);
1604 }
1605
1606 // ----------------------------------------------------------------------------
1607 // wxGridCellNumberRenderer
1608 // ----------------------------------------------------------------------------
1609
1610 wxString wxGridCellNumberRenderer::GetString(wxGrid& grid, int row, int col)
1611 {
1612 wxGridTableBase *table = grid.GetTable();
1613 wxString text;
1614 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1615 {
1616 text.Printf(_T("%ld"), table->GetValueAsLong(row, col));
1617 }
1618 else
1619 {
1620 text = table->GetValue(row, col);
1621 }
1622
1623 return text;
1624 }
1625
1626 void wxGridCellNumberRenderer::Draw(wxGrid& grid,
1627 wxGridCellAttr& attr,
1628 wxDC& dc,
1629 const wxRect& rectCell,
1630 int row, int col,
1631 bool isSelected)
1632 {
1633 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1634
1635 SetTextColoursAndFont(grid, attr, dc, isSelected);
1636
1637 // draw the text right aligned by default
1638 int hAlign, vAlign;
1639 attr.GetAlignment(&hAlign, &vAlign);
1640 hAlign = wxALIGN_RIGHT;
1641
1642 wxRect rect = rectCell;
1643 rect.Inflate(-1);
1644
1645 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1646 }
1647
1648 wxSize wxGridCellNumberRenderer::GetBestSize(wxGrid& grid,
1649 wxGridCellAttr& attr,
1650 wxDC& dc,
1651 int row, int col)
1652 {
1653 return DoGetBestSize(attr, dc, GetString(grid, row, col));
1654 }
1655
1656 // ----------------------------------------------------------------------------
1657 // wxGridCellFloatRenderer
1658 // ----------------------------------------------------------------------------
1659
1660 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width, int precision)
1661 {
1662 SetWidth(width);
1663 SetPrecision(precision);
1664 }
1665
1666 wxGridCellRenderer *wxGridCellFloatRenderer::Clone() const
1667 {
1668 wxGridCellFloatRenderer *renderer = new wxGridCellFloatRenderer;
1669 renderer->m_width = m_width;
1670 renderer->m_precision = m_precision;
1671 renderer->m_format = m_format;
1672
1673 return renderer;
1674 }
1675
1676 wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
1677 {
1678 wxGridTableBase *table = grid.GetTable();
1679
1680 bool hasDouble;
1681 double val;
1682 wxString text;
1683 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1684 {
1685 val = table->GetValueAsDouble(row, col);
1686 hasDouble = TRUE;
1687 }
1688 else
1689 {
1690 text = table->GetValue(row, col);
1691 hasDouble = text.ToDouble(&val);
1692 }
1693
1694 if ( hasDouble )
1695 {
1696 if ( !m_format )
1697 {
1698 if ( m_width == -1 )
1699 {
1700 if ( m_precision == -1 )
1701 {
1702 // default width/precision
1703 m_format = _T("%f");
1704 }
1705 else
1706 {
1707 m_format.Printf(_T("%%.%df"), m_precision);
1708 }
1709 }
1710 else if ( m_precision == -1 )
1711 {
1712 // default precision
1713 m_format.Printf(_T("%%%d.f"), m_width);
1714 }
1715 else
1716 {
1717 m_format.Printf(_T("%%%d.%df"), m_width, m_precision);
1718 }
1719 }
1720
1721 text.Printf(m_format, val);
1722
1723 }
1724 //else: text already contains the string
1725
1726 return text;
1727 }
1728
1729 void wxGridCellFloatRenderer::Draw(wxGrid& grid,
1730 wxGridCellAttr& attr,
1731 wxDC& dc,
1732 const wxRect& rectCell,
1733 int row, int col,
1734 bool isSelected)
1735 {
1736 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1737
1738 SetTextColoursAndFont(grid, attr, dc, isSelected);
1739
1740 // draw the text right aligned by default
1741 int hAlign, vAlign;
1742 attr.GetAlignment(&hAlign, &vAlign);
1743 hAlign = wxALIGN_RIGHT;
1744
1745 wxRect rect = rectCell;
1746 rect.Inflate(-1);
1747
1748 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1749 }
1750
1751 wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
1752 wxGridCellAttr& attr,
1753 wxDC& dc,
1754 int row, int col)
1755 {
1756 return DoGetBestSize(attr, dc, GetString(grid, row, col));
1757 }
1758
1759 void wxGridCellFloatRenderer::SetParameters(const wxString& params)
1760 {
1761 if ( !params )
1762 {
1763 // reset to defaults
1764 SetWidth(-1);
1765 SetPrecision(-1);
1766 }
1767 else
1768 {
1769 wxString tmp = params.BeforeFirst(_T(','));
1770 if ( !!tmp )
1771 {
1772 long width;
1773 if ( tmp.ToLong(&width) )
1774 {
1775 SetWidth((int)width);
1776 }
1777 else
1778 {
1779 wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
1780 }
1781
1782 }
1783 tmp = params.AfterFirst(_T(','));
1784 if ( !!tmp )
1785 {
1786 long precision;
1787 if ( tmp.ToLong(&precision) )
1788 {
1789 SetPrecision((int)precision);
1790 }
1791 else
1792 {
1793 wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
1794 }
1795
1796 }
1797 }
1798 }
1799
1800
1801 // ----------------------------------------------------------------------------
1802 // wxGridCellBoolRenderer
1803 // ----------------------------------------------------------------------------
1804
1805 wxSize wxGridCellBoolRenderer::ms_sizeCheckMark;
1806
1807 // FIXME these checkbox size calculations are really ugly...
1808
1809 // between checkmark and box
1810 static const wxCoord wxGRID_CHECKMARK_MARGIN = 2;
1811
1812 wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
1813 wxGridCellAttr& WXUNUSED(attr),
1814 wxDC& WXUNUSED(dc),
1815 int WXUNUSED(row),
1816 int WXUNUSED(col))
1817 {
1818 // compute it only once (no locks for MT safeness in GUI thread...)
1819 if ( !ms_sizeCheckMark.x )
1820 {
1821 // get checkbox size
1822 wxCoord checkSize = 0;
1823 wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
1824 wxSize size = checkbox->GetBestSize();
1825 checkSize = size.y + 2*wxGRID_CHECKMARK_MARGIN;
1826
1827 // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
1828 #if defined(__WXGTK__) || defined(__WXMOTIF__)
1829 checkSize -= size.y / 2;
1830 #endif
1831
1832 delete checkbox;
1833
1834 ms_sizeCheckMark.x = ms_sizeCheckMark.y = checkSize;
1835 }
1836
1837 return ms_sizeCheckMark;
1838 }
1839
1840 void wxGridCellBoolRenderer::Draw(wxGrid& grid,
1841 wxGridCellAttr& attr,
1842 wxDC& dc,
1843 const wxRect& rect,
1844 int row, int col,
1845 bool isSelected)
1846 {
1847 wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
1848
1849 // draw a check mark in the centre (ignoring alignment - TODO)
1850 wxSize size = GetBestSize(grid, attr, dc, row, col);
1851
1852 // don't draw outside the cell
1853 wxCoord minSize = wxMin(rect.width, rect.height);
1854 if ( size.x >= minSize || size.y >= minSize )
1855 {
1856 // and even leave (at least) 1 pixel margin
1857 size.x = size.y = minSize - 2;
1858 }
1859
1860 // draw a border around checkmark
1861 wxRect rectBorder;
1862 rectBorder.x = rect.x + rect.width/2 - size.x/2;
1863 rectBorder.y = rect.y + rect.height/2 - size.y/2;
1864 rectBorder.width = size.x;
1865 rectBorder.height = size.y;
1866
1867 bool value;
1868 if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
1869 value = grid.GetTable()->GetValueAsBool(row, col);
1870 else
1871 {
1872 wxString cellval( grid.GetTable()->GetValue(row, col) );
1873 value = !( !cellval || (cellval == "0") );
1874 }
1875
1876 if ( value )
1877 {
1878 wxRect rectMark = rectBorder;
1879 #ifdef __WXMSW__
1880 // MSW DrawCheckMark() is weird (and should probably be changed...)
1881 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN/2);
1882 rectMark.x++;
1883 rectMark.y++;
1884 #else // !MSW
1885 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN);
1886 #endif // MSW/!MSW
1887
1888 dc.SetTextForeground(attr.GetTextColour());
1889 dc.DrawCheckMark(rectMark);
1890 }
1891
1892 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1893 dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
1894 dc.DrawRectangle(rectBorder);
1895 }
1896
1897 // ----------------------------------------------------------------------------
1898 // wxGridCellAttr
1899 // ----------------------------------------------------------------------------
1900
1901 wxGridCellAttr *wxGridCellAttr::Clone() const
1902 {
1903 wxGridCellAttr *attr = new wxGridCellAttr;
1904 if ( HasTextColour() )
1905 attr->SetTextColour(GetTextColour());
1906 if ( HasBackgroundColour() )
1907 attr->SetBackgroundColour(GetBackgroundColour());
1908 if ( HasFont() )
1909 attr->SetFont(GetFont());
1910 if ( HasAlignment() )
1911 attr->SetAlignment(m_hAlign, m_vAlign);
1912
1913 if ( m_renderer )
1914 {
1915 attr->SetRenderer(m_renderer);
1916 m_renderer->IncRef();
1917 }
1918 if ( m_editor )
1919 {
1920 attr->SetEditor(m_editor);
1921 m_editor->IncRef();
1922 }
1923
1924 if ( IsReadOnly() )
1925 attr->SetReadOnly();
1926
1927 attr->SetKind( m_attrkind );
1928
1929 attr->SetDefAttr(m_defGridAttr);
1930
1931 return attr;
1932 }
1933
1934 void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
1935 {
1936 if ( !HasTextColour() && mergefrom->HasTextColour() )
1937 SetTextColour(mergefrom->GetTextColour());
1938 if ( !HasBackgroundColour() && mergefrom->HasBackgroundColour() )
1939 SetBackgroundColour(mergefrom->GetBackgroundColour());
1940 if ( !HasFont() && mergefrom->HasFont() )
1941 SetFont(mergefrom->GetFont());
1942 if ( !!HasAlignment() && mergefrom->HasAlignment() ){
1943 int hAlign, vAlign;
1944 mergefrom->GetAlignment( &hAlign, &vAlign);
1945 SetAlignment(hAlign, vAlign);
1946 }
1947
1948 // Directly access member functions as GetRender/Editor don't just return
1949 // m_renderer/m_editor
1950 //
1951 // Maybe add support for merge of Render and Editor?
1952 if (!HasRenderer() && mergefrom->HasRenderer() )
1953 {
1954 m_renderer = mergefrom->m_renderer;
1955 m_renderer->IncRef();
1956 }
1957 if ( !HasEditor() && mergefrom->HasEditor() )
1958 {
1959 m_editor = mergefrom->m_editor;
1960 m_editor->IncRef();
1961 }
1962 if ( !HasReadWriteMode() && mergefrom->HasReadWriteMode() )
1963 SetReadOnly(mergefrom->IsReadOnly());
1964
1965 SetDefAttr(mergefrom->m_defGridAttr);
1966 }
1967
1968 const wxColour& wxGridCellAttr::GetTextColour() const
1969 {
1970 if (HasTextColour())
1971 {
1972 return m_colText;
1973 }
1974 else if (m_defGridAttr != this)
1975 {
1976 return m_defGridAttr->GetTextColour();
1977 }
1978 else
1979 {
1980 wxFAIL_MSG(wxT("Missing default cell attribute"));
1981 return wxNullColour;
1982 }
1983 }
1984
1985
1986 const wxColour& wxGridCellAttr::GetBackgroundColour() const
1987 {
1988 if (HasBackgroundColour())
1989 return m_colBack;
1990 else if (m_defGridAttr != this)
1991 return m_defGridAttr->GetBackgroundColour();
1992 else
1993 {
1994 wxFAIL_MSG(wxT("Missing default cell attribute"));
1995 return wxNullColour;
1996 }
1997 }
1998
1999
2000 const wxFont& wxGridCellAttr::GetFont() const
2001 {
2002 if (HasFont())
2003 return m_font;
2004 else if (m_defGridAttr != this)
2005 return m_defGridAttr->GetFont();
2006 else
2007 {
2008 wxFAIL_MSG(wxT("Missing default cell attribute"));
2009 return wxNullFont;
2010 }
2011 }
2012
2013
2014 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
2015 {
2016 if (HasAlignment())
2017 {
2018 if ( hAlign ) *hAlign = m_hAlign;
2019 if ( vAlign ) *vAlign = m_vAlign;
2020 }
2021 else if (m_defGridAttr != this)
2022 m_defGridAttr->GetAlignment(hAlign, vAlign);
2023 else
2024 {
2025 wxFAIL_MSG(wxT("Missing default cell attribute"));
2026 }
2027 }
2028
2029
2030 // GetRenderer and GetEditor use a slightly different decision path about
2031 // which attribute to use. If a non-default attr object has one then it is
2032 // used, otherwise the default editor or renderer is fetched from the grid and
2033 // used. It should be the default for the data type of the cell. If it is
2034 // NULL (because the table has a type that the grid does not have in its
2035 // registry,) then the grid's default editor or renderer is used.
2036
2037 wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
2038 {
2039 wxGridCellRenderer *renderer;
2040
2041 if ( m_renderer && this != m_defGridAttr )
2042 {
2043 // use the cells renderer if it has one
2044 renderer = m_renderer;
2045 renderer->IncRef();
2046 }
2047 else // no non default cell renderer
2048 {
2049 // get default renderer for the data type
2050 if ( grid )
2051 {
2052 // GetDefaultRendererForCell() will do IncRef() for us
2053 renderer = grid->GetDefaultRendererForCell(row, col);
2054 }
2055 else
2056 {
2057 renderer = NULL;
2058 }
2059
2060 if ( !renderer )
2061 {
2062 if ( this != m_defGridAttr )
2063 {
2064 // if we still don't have one then use the grid default
2065 // (no need for IncRef() here neither)
2066 renderer = m_defGridAttr->GetRenderer(NULL, 0, 0);
2067 }
2068 else // default grid attr
2069 {
2070 // use m_renderer which we had decided not to use initially
2071 renderer = m_renderer;
2072 if ( renderer )
2073 renderer->IncRef();
2074 }
2075 }
2076 }
2077
2078 // we're supposed to always find something
2079 wxASSERT_MSG(renderer, wxT("Missing default cell renderer"));
2080
2081 return renderer;
2082 }
2083
2084 // same as above, except for s/renderer/editor/g
2085 wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
2086 {
2087 wxGridCellEditor *editor;
2088
2089 if ( m_editor && this != m_defGridAttr )
2090 {
2091 // use the cells editor if it has one
2092 editor = m_editor;
2093 editor->IncRef();
2094 }
2095 else // no non default cell editor
2096 {
2097 // get default editor for the data type
2098 if ( grid )
2099 {
2100 // GetDefaultEditorForCell() will do IncRef() for us
2101 editor = grid->GetDefaultEditorForCell(row, col);
2102 }
2103 else
2104 {
2105 editor = NULL;
2106 }
2107
2108 if ( !editor )
2109 {
2110 if ( this != m_defGridAttr )
2111 {
2112 // if we still don't have one then use the grid default
2113 // (no need for IncRef() here neither)
2114 editor = m_defGridAttr->GetEditor(NULL, 0, 0);
2115 }
2116 else // default grid attr
2117 {
2118 // use m_editor which we had decided not to use initially
2119 editor = m_editor;
2120 if ( editor )
2121 editor->IncRef();
2122 }
2123 }
2124 }
2125
2126 // we're supposed to always find something
2127 wxASSERT_MSG(editor, wxT("Missing default cell editor"));
2128
2129 return editor;
2130 }
2131
2132 // ----------------------------------------------------------------------------
2133 // wxGridCellAttrData
2134 // ----------------------------------------------------------------------------
2135
2136 void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
2137 {
2138 int n = FindIndex(row, col);
2139 if ( n == wxNOT_FOUND )
2140 {
2141 // add the attribute
2142 m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
2143 }
2144 else
2145 {
2146 // free the old attribute
2147 m_attrs[(size_t)n].attr->DecRef();
2148
2149 if ( attr )
2150 {
2151 // change the attribute
2152 m_attrs[(size_t)n].attr = attr;
2153 }
2154 else
2155 {
2156 // remove this attribute
2157 m_attrs.RemoveAt((size_t)n);
2158 }
2159 }
2160 }
2161
2162 wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
2163 {
2164 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2165
2166 int n = FindIndex(row, col);
2167 if ( n != wxNOT_FOUND )
2168 {
2169 attr = m_attrs[(size_t)n].attr;
2170 attr->IncRef();
2171 }
2172
2173 return attr;
2174 }
2175
2176 void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
2177 {
2178 size_t count = m_attrs.GetCount();
2179 for ( size_t n = 0; n < count; n++ )
2180 {
2181 wxGridCellCoords& coords = m_attrs[n].coords;
2182 wxCoord row = coords.GetRow();
2183 if ((size_t)row >= pos)
2184 {
2185 if (numRows > 0)
2186 {
2187 // If rows inserted, include row counter where necessary
2188 coords.SetRow(row + numRows);
2189 }
2190 else if (numRows < 0)
2191 {
2192 // If rows deleted ...
2193 if ((size_t)row >= pos - numRows)
2194 {
2195 // ...either decrement row counter (if row still exists)...
2196 coords.SetRow(row + numRows);
2197 }
2198 else
2199 {
2200 // ...or remove the attribute
2201 m_attrs.RemoveAt((size_t)n);
2202 n--; count--;
2203 }
2204 }
2205 }
2206 }
2207 }
2208
2209 void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
2210 {
2211 size_t count = m_attrs.GetCount();
2212 for ( size_t n = 0; n < count; n++ )
2213 {
2214 wxGridCellCoords& coords = m_attrs[n].coords;
2215 wxCoord col = coords.GetCol();
2216 if ( (size_t)col >= pos )
2217 {
2218 if ( numCols > 0 )
2219 {
2220 // If rows inserted, include row counter where necessary
2221 coords.SetCol(col + numCols);
2222 }
2223 else if (numCols < 0)
2224 {
2225 // If rows deleted ...
2226 if ((size_t)col >= pos - numCols)
2227 {
2228 // ...either decrement row counter (if row still exists)...
2229 coords.SetCol(col + numCols);
2230 }
2231 else
2232 {
2233 // ...or remove the attribute
2234 m_attrs.RemoveAt((size_t)n);
2235 n--; count--;
2236 }
2237 }
2238 }
2239 }
2240 }
2241
2242 int wxGridCellAttrData::FindIndex(int row, int col) const
2243 {
2244 size_t count = m_attrs.GetCount();
2245 for ( size_t n = 0; n < count; n++ )
2246 {
2247 const wxGridCellCoords& coords = m_attrs[n].coords;
2248 if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
2249 {
2250 return n;
2251 }
2252 }
2253
2254 return wxNOT_FOUND;
2255 }
2256
2257 // ----------------------------------------------------------------------------
2258 // wxGridRowOrColAttrData
2259 // ----------------------------------------------------------------------------
2260
2261 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2262 {
2263 size_t count = m_attrs.Count();
2264 for ( size_t n = 0; n < count; n++ )
2265 {
2266 m_attrs[n]->DecRef();
2267 }
2268 }
2269
2270 wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
2271 {
2272 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2273
2274 int n = m_rowsOrCols.Index(rowOrCol);
2275 if ( n != wxNOT_FOUND )
2276 {
2277 attr = m_attrs[(size_t)n];
2278 attr->IncRef();
2279 }
2280
2281 return attr;
2282 }
2283
2284 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
2285 {
2286 int i = m_rowsOrCols.Index(rowOrCol);
2287 if ( i == wxNOT_FOUND )
2288 {
2289 // add the attribute
2290 m_rowsOrCols.Add(rowOrCol);
2291 m_attrs.Add(attr);
2292 }
2293 else
2294 {
2295 size_t n = (size_t)i;
2296 if ( attr )
2297 {
2298 // change the attribute
2299 m_attrs[n]->DecRef();
2300 m_attrs[n] = attr;
2301 }
2302 else
2303 {
2304 // remove this attribute
2305 m_attrs[n]->DecRef();
2306 m_rowsOrCols.RemoveAt(n);
2307 m_attrs.RemoveAt(n);
2308 }
2309 }
2310 }
2311
2312 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
2313 {
2314 size_t count = m_attrs.GetCount();
2315 for ( size_t n = 0; n < count; n++ )
2316 {
2317 int & rowOrCol = m_rowsOrCols[n];
2318 if ( (size_t)rowOrCol >= pos )
2319 {
2320 if ( numRowsOrCols > 0 )
2321 {
2322 // If rows inserted, include row counter where necessary
2323 rowOrCol += numRowsOrCols;
2324 }
2325 else if ( numRowsOrCols < 0)
2326 {
2327 // If rows deleted, either decrement row counter (if row still exists)
2328 if ((size_t)rowOrCol >= pos - numRowsOrCols)
2329 rowOrCol += numRowsOrCols;
2330 else
2331 {
2332 m_rowsOrCols.RemoveAt((size_t)n);
2333 m_attrs.RemoveAt((size_t)n);
2334 n--; count--;
2335 }
2336 }
2337 }
2338 }
2339 }
2340
2341 // ----------------------------------------------------------------------------
2342 // wxGridCellAttrProvider
2343 // ----------------------------------------------------------------------------
2344
2345 wxGridCellAttrProvider::wxGridCellAttrProvider()
2346 {
2347 m_data = (wxGridCellAttrProviderData *)NULL;
2348 }
2349
2350 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2351 {
2352 delete m_data;
2353 }
2354
2355 void wxGridCellAttrProvider::InitData()
2356 {
2357 m_data = new wxGridCellAttrProviderData;
2358 }
2359
2360 wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
2361 wxGridCellAttr::wxAttrKind kind ) const
2362 {
2363 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2364 if ( m_data )
2365 {
2366 switch(kind)
2367 {
2368 case (wxGridCellAttr::Any):
2369 //Get cached merge attributes.
2370 // Currenlty not used as no cache implemented as not mutiable
2371 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2372 if(!attr)
2373 {
2374 //Basicaly implement old version.
2375 //Also check merge cache, so we don't have to re-merge every time..
2376 wxGridCellAttr *attrcell = (wxGridCellAttr *)NULL,
2377 *attrrow = (wxGridCellAttr *)NULL,
2378 *attrcol = (wxGridCellAttr *)NULL;
2379
2380 attrcell = m_data->m_cellAttrs.GetAttr(row, col);
2381 attrcol = m_data->m_colAttrs.GetAttr(col);
2382 attrrow = m_data->m_rowAttrs.GetAttr(row);
2383
2384 if((attrcell != attrrow) && (attrrow !=attrcol) && (attrcell != attrcol)){
2385 // Two or move are non NULL
2386 attr = new wxGridCellAttr;
2387 attr->SetKind(wxGridCellAttr::Merged);
2388
2389 //Order important..
2390 if(attrcell){
2391 attr->MergeWith(attrcell);
2392 attrcell->DecRef();
2393 }
2394 if(attrcol){
2395 attr->MergeWith(attrcol);
2396 attrcol->DecRef();
2397 }
2398 if(attrrow){
2399 attr->MergeWith(attrrow);
2400 attrrow->DecRef();
2401 }
2402 //store merge attr if cache implemented
2403 //attr->IncRef();
2404 //m_data->m_mergeAttr.SetAttr(attr, row, col);
2405 }
2406 else
2407 {
2408 // one or none is non null return it or null.
2409 if(attrrow) attr = attrrow;
2410 if(attrcol) attr = attrcol;
2411 if(attrcell) attr = attrcell;
2412 }
2413 }
2414 break;
2415 case (wxGridCellAttr::Cell):
2416 attr = m_data->m_cellAttrs.GetAttr(row, col);
2417 break;
2418 case (wxGridCellAttr::Col):
2419 attr = m_data->m_colAttrs.GetAttr(col);
2420 break;
2421 case (wxGridCellAttr::Row):
2422 attr = m_data->m_rowAttrs.GetAttr(row);
2423 break;
2424 default:
2425 // unused as yet...
2426 // (wxGridCellAttr::Default):
2427 // (wxGridCellAttr::Merged):
2428 break;
2429 }
2430 }
2431 return attr;
2432 }
2433
2434 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
2435 int row, int col)
2436 {
2437 if ( !m_data )
2438 InitData();
2439
2440 m_data->m_cellAttrs.SetAttr(attr, row, col);
2441 }
2442
2443 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
2444 {
2445 if ( !m_data )
2446 InitData();
2447
2448 m_data->m_rowAttrs.SetAttr(attr, row);
2449 }
2450
2451 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
2452 {
2453 if ( !m_data )
2454 InitData();
2455
2456 m_data->m_colAttrs.SetAttr(attr, col);
2457 }
2458
2459 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
2460 {
2461 if ( m_data )
2462 {
2463 m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
2464
2465 m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
2466 }
2467 }
2468
2469 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
2470 {
2471 if ( m_data )
2472 {
2473 m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
2474
2475 m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
2476 }
2477 }
2478
2479 // ----------------------------------------------------------------------------
2480 // wxGridTypeRegistry
2481 // ----------------------------------------------------------------------------
2482
2483 wxGridTypeRegistry::~wxGridTypeRegistry()
2484 {
2485 size_t count = m_typeinfo.Count();
2486 for ( size_t i = 0; i < count; i++ )
2487 delete m_typeinfo[i];
2488 }
2489
2490
2491 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
2492 wxGridCellRenderer* renderer,
2493 wxGridCellEditor* editor)
2494 {
2495 wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
2496
2497 // is it already registered?
2498 int loc = FindRegisteredDataType(typeName);
2499 if ( loc != wxNOT_FOUND )
2500 {
2501 delete m_typeinfo[loc];
2502 m_typeinfo[loc] = info;
2503 }
2504 else
2505 {
2506 m_typeinfo.Add(info);
2507 }
2508 }
2509
2510 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
2511 {
2512 size_t count = m_typeinfo.GetCount();
2513 for ( size_t i = 0; i < count; i++ )
2514 {
2515 if ( typeName == m_typeinfo[i]->m_typeName )
2516 {
2517 return i;
2518 }
2519 }
2520
2521 return wxNOT_FOUND;
2522 }
2523
2524 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
2525 {
2526 int index = FindRegisteredDataType(typeName);
2527 if ( index == wxNOT_FOUND )
2528 {
2529 // check whether this is one of the standard ones, in which case
2530 // register it "on the fly"
2531 #if wxUSE_TEXTCTRL
2532 if ( typeName == wxGRID_VALUE_STRING )
2533 {
2534 RegisterDataType(wxGRID_VALUE_STRING,
2535 new wxGridCellStringRenderer,
2536 new wxGridCellTextEditor);
2537 } else
2538 #endif // wxUSE_TEXTCTRL
2539 #if wxUSE_CHECKBOX
2540 if ( typeName == wxGRID_VALUE_BOOL )
2541 {
2542 RegisterDataType(wxGRID_VALUE_BOOL,
2543 new wxGridCellBoolRenderer,
2544 new wxGridCellBoolEditor);
2545 } else
2546 #endif // wxUSE_CHECKBOX
2547 #if wxUSE_TEXTCTRL
2548 if ( typeName == wxGRID_VALUE_NUMBER )
2549 {
2550 RegisterDataType(wxGRID_VALUE_NUMBER,
2551 new wxGridCellNumberRenderer,
2552 new wxGridCellNumberEditor);
2553 }
2554 else if ( typeName == wxGRID_VALUE_FLOAT )
2555 {
2556 RegisterDataType(wxGRID_VALUE_FLOAT,
2557 new wxGridCellFloatRenderer,
2558 new wxGridCellFloatEditor);
2559 } else
2560 #endif // wxUSE_TEXTCTRL
2561 #if wxUSE_COMBOBOX
2562 if ( typeName == wxGRID_VALUE_CHOICE )
2563 {
2564 RegisterDataType(wxGRID_VALUE_CHOICE,
2565 new wxGridCellStringRenderer,
2566 new wxGridCellChoiceEditor);
2567 } else
2568 #endif // wxUSE_COMBOBOX
2569 {
2570 return wxNOT_FOUND;
2571 }
2572
2573 // we get here only if just added the entry for this type, so return
2574 // the last index
2575 index = m_typeinfo.GetCount() - 1;
2576 }
2577
2578 return index;
2579 }
2580
2581 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
2582 {
2583 int index = FindDataType(typeName);
2584 if ( index == wxNOT_FOUND )
2585 {
2586 // the first part of the typename is the "real" type, anything after ':'
2587 // are the parameters for the renderer
2588 index = FindDataType(typeName.BeforeFirst(_T(':')));
2589 if ( index == wxNOT_FOUND )
2590 {
2591 return wxNOT_FOUND;
2592 }
2593
2594 wxGridCellRenderer *renderer = GetRenderer(index);
2595 wxGridCellRenderer *rendererOld = renderer;
2596 renderer = renderer->Clone();
2597 rendererOld->DecRef();
2598
2599 wxGridCellEditor *editor = GetEditor(index);
2600 wxGridCellEditor *editorOld = editor;
2601 editor = editor->Clone();
2602 editorOld->DecRef();
2603
2604 // do it even if there are no parameters to reset them to defaults
2605 wxString params = typeName.AfterFirst(_T(':'));
2606 renderer->SetParameters(params);
2607 editor->SetParameters(params);
2608
2609 // register the new typename
2610 RegisterDataType(typeName, renderer, editor);
2611
2612 // we just registered it, it's the last one
2613 index = m_typeinfo.GetCount() - 1;
2614 }
2615
2616 return index;
2617 }
2618
2619 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
2620 {
2621 wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
2622 if (renderer)
2623 renderer->IncRef();
2624 return renderer;
2625 }
2626
2627 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
2628 {
2629 wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
2630 if (editor)
2631 editor->IncRef();
2632 return editor;
2633 }
2634
2635 // ----------------------------------------------------------------------------
2636 // wxGridTableBase
2637 // ----------------------------------------------------------------------------
2638
2639 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
2640
2641
2642 wxGridTableBase::wxGridTableBase()
2643 {
2644 m_view = (wxGrid *) NULL;
2645 m_attrProvider = (wxGridCellAttrProvider *) NULL;
2646 }
2647
2648 wxGridTableBase::~wxGridTableBase()
2649 {
2650 delete m_attrProvider;
2651 }
2652
2653 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
2654 {
2655 delete m_attrProvider;
2656 m_attrProvider = attrProvider;
2657 }
2658
2659 bool wxGridTableBase::CanHaveAttributes()
2660 {
2661 if ( ! GetAttrProvider() )
2662 {
2663 // use the default attr provider by default
2664 SetAttrProvider(new wxGridCellAttrProvider);
2665 }
2666 return TRUE;
2667 }
2668
2669 wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind)
2670 {
2671 if ( m_attrProvider )
2672 return m_attrProvider->GetAttr(row, col, kind);
2673 else
2674 return (wxGridCellAttr *)NULL;
2675 }
2676
2677 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
2678 {
2679 if ( m_attrProvider )
2680 {
2681 attr->SetKind(wxGridCellAttr::Cell);
2682 m_attrProvider->SetAttr(attr, row, col);
2683 }
2684 else
2685 {
2686 // as we take ownership of the pointer and don't store it, we must
2687 // free it now
2688 wxSafeDecRef(attr);
2689 }
2690 }
2691
2692 void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
2693 {
2694 if ( m_attrProvider )
2695 {
2696 attr->SetKind(wxGridCellAttr::Row);
2697 m_attrProvider->SetRowAttr(attr, row);
2698 }
2699 else
2700 {
2701 // as we take ownership of the pointer and don't store it, we must
2702 // free it now
2703 wxSafeDecRef(attr);
2704 }
2705 }
2706
2707 void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
2708 {
2709 if ( m_attrProvider )
2710 {
2711 attr->SetKind(wxGridCellAttr::Col);
2712 m_attrProvider->SetColAttr(attr, col);
2713 }
2714 else
2715 {
2716 // as we take ownership of the pointer and don't store it, we must
2717 // free it now
2718 wxSafeDecRef(attr);
2719 }
2720 }
2721
2722 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
2723 size_t WXUNUSED(numRows) )
2724 {
2725 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2726
2727 return FALSE;
2728 }
2729
2730 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
2731 {
2732 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2733
2734 return FALSE;
2735 }
2736
2737 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
2738 size_t WXUNUSED(numRows) )
2739 {
2740 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2741
2742 return FALSE;
2743 }
2744
2745 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
2746 size_t WXUNUSED(numCols) )
2747 {
2748 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2749
2750 return FALSE;
2751 }
2752
2753 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
2754 {
2755 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
2756
2757 return FALSE;
2758 }
2759
2760 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
2761 size_t WXUNUSED(numCols) )
2762 {
2763 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
2764
2765 return FALSE;
2766 }
2767
2768
2769 wxString wxGridTableBase::GetRowLabelValue( int row )
2770 {
2771 wxString s;
2772 s << row + 1; // RD: Starting the rows at zero confuses users, no matter
2773 // how much it makes sense to us geeks.
2774 return s;
2775 }
2776
2777 wxString wxGridTableBase::GetColLabelValue( int col )
2778 {
2779 // default col labels are:
2780 // cols 0 to 25 : A-Z
2781 // cols 26 to 675 : AA-ZZ
2782 // etc.
2783
2784 wxString s;
2785 unsigned int i, n;
2786 for ( n = 1; ; n++ )
2787 {
2788 s += (_T('A') + (wxChar)( col%26 ));
2789 col = col/26 - 1;
2790 if ( col < 0 ) break;
2791 }
2792
2793 // reverse the string...
2794 wxString s2;
2795 for ( i = 0; i < n; i++ )
2796 {
2797 s2 += s[n-i-1];
2798 }
2799
2800 return s2;
2801 }
2802
2803
2804 wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
2805 {
2806 return wxGRID_VALUE_STRING;
2807 }
2808
2809 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
2810 const wxString& typeName )
2811 {
2812 return typeName == wxGRID_VALUE_STRING;
2813 }
2814
2815 bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
2816 {
2817 return CanGetValueAs(row, col, typeName);
2818 }
2819
2820 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
2821 {
2822 return 0;
2823 }
2824
2825 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
2826 {
2827 return 0.0;
2828 }
2829
2830 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
2831 {
2832 return FALSE;
2833 }
2834
2835 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
2836 long WXUNUSED(value) )
2837 {
2838 }
2839
2840 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
2841 double WXUNUSED(value) )
2842 {
2843 }
2844
2845 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
2846 bool WXUNUSED(value) )
2847 {
2848 }
2849
2850
2851 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2852 const wxString& WXUNUSED(typeName) )
2853 {
2854 return NULL;
2855 }
2856
2857 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2858 const wxString& WXUNUSED(typeName),
2859 void* WXUNUSED(value) )
2860 {
2861 }
2862
2863 //////////////////////////////////////////////////////////////////////
2864 //
2865 // Message class for the grid table to send requests and notifications
2866 // to the grid view
2867 //
2868
2869 wxGridTableMessage::wxGridTableMessage()
2870 {
2871 m_table = (wxGridTableBase *) NULL;
2872 m_id = -1;
2873 m_comInt1 = -1;
2874 m_comInt2 = -1;
2875 }
2876
2877 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
2878 int commandInt1, int commandInt2 )
2879 {
2880 m_table = table;
2881 m_id = id;
2882 m_comInt1 = commandInt1;
2883 m_comInt2 = commandInt2;
2884 }
2885
2886
2887
2888 //////////////////////////////////////////////////////////////////////
2889 //
2890 // A basic grid table for string data. An object of this class will
2891 // created by wxGrid if you don't specify an alternative table class.
2892 //
2893
2894 WX_DEFINE_OBJARRAY(wxGridStringArray)
2895
2896 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
2897
2898 wxGridStringTable::wxGridStringTable()
2899 : wxGridTableBase()
2900 {
2901 }
2902
2903 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
2904 : wxGridTableBase()
2905 {
2906 int row, col;
2907
2908 m_data.Alloc( numRows );
2909
2910 wxArrayString sa;
2911 sa.Alloc( numCols );
2912 for ( col = 0; col < numCols; col++ )
2913 {
2914 sa.Add( wxEmptyString );
2915 }
2916
2917 for ( row = 0; row < numRows; row++ )
2918 {
2919 m_data.Add( sa );
2920 }
2921 }
2922
2923 wxGridStringTable::~wxGridStringTable()
2924 {
2925 }
2926
2927 int wxGridStringTable::GetNumberRows()
2928 {
2929 return m_data.GetCount();
2930 }
2931
2932 int wxGridStringTable::GetNumberCols()
2933 {
2934 if ( m_data.GetCount() > 0 )
2935 return m_data[0].GetCount();
2936 else
2937 return 0;
2938 }
2939
2940 wxString wxGridStringTable::GetValue( int row, int col )
2941 {
2942 wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2943 _T("invalid row or column index in wxGridStringTable") );
2944
2945 return m_data[row][col];
2946 }
2947
2948 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
2949 {
2950 wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2951 _T("invalid row or column index in wxGridStringTable") );
2952
2953 m_data[row][col] = value;
2954 }
2955
2956 bool wxGridStringTable::IsEmptyCell( int row, int col )
2957 {
2958 wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2959 _T("invalid row or column index in wxGridStringTable") );
2960
2961 return (m_data[row][col] == wxEmptyString);
2962 }
2963
2964 void wxGridStringTable::Clear()
2965 {
2966 int row, col;
2967 int numRows, numCols;
2968
2969 numRows = m_data.GetCount();
2970 if ( numRows > 0 )
2971 {
2972 numCols = m_data[0].GetCount();
2973
2974 for ( row = 0; row < numRows; row++ )
2975 {
2976 for ( col = 0; col < numCols; col++ )
2977 {
2978 m_data[row][col] = wxEmptyString;
2979 }
2980 }
2981 }
2982 }
2983
2984
2985 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
2986 {
2987 size_t row, col;
2988
2989 size_t curNumRows = m_data.GetCount();
2990 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
2991 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2992
2993 if ( pos >= curNumRows )
2994 {
2995 return AppendRows( numRows );
2996 }
2997
2998 wxArrayString sa;
2999 sa.Alloc( curNumCols );
3000 for ( col = 0; col < curNumCols; col++ )
3001 {
3002 sa.Add( wxEmptyString );
3003 }
3004
3005 for ( row = pos; row < pos + numRows; row++ )
3006 {
3007 m_data.Insert( sa, row );
3008 }
3009 if ( GetView() )
3010 {
3011 wxGridTableMessage msg( this,
3012 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
3013 pos,
3014 numRows );
3015
3016 GetView()->ProcessTableMessage( msg );
3017 }
3018
3019 return TRUE;
3020 }
3021
3022 bool wxGridStringTable::AppendRows( size_t numRows )
3023 {
3024 size_t row, col;
3025
3026 size_t curNumRows = m_data.GetCount();
3027 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3028 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3029
3030 wxArrayString sa;
3031 if ( curNumCols > 0 )
3032 {
3033 sa.Alloc( curNumCols );
3034 for ( col = 0; col < curNumCols; col++ )
3035 {
3036 sa.Add( wxEmptyString );
3037 }
3038 }
3039
3040 for ( row = 0; row < numRows; row++ )
3041 {
3042 m_data.Add( sa );
3043 }
3044
3045 if ( GetView() )
3046 {
3047 wxGridTableMessage msg( this,
3048 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
3049 numRows );
3050
3051 GetView()->ProcessTableMessage( msg );
3052 }
3053
3054 return TRUE;
3055 }
3056
3057 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
3058 {
3059 size_t n;
3060
3061 size_t curNumRows = m_data.GetCount();
3062
3063 if ( pos >= curNumRows )
3064 {
3065 wxString errmsg;
3066 errmsg.Printf(wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\nPos value is invalid for present table with %d rows"),
3067 pos, numRows, curNumRows );
3068 wxFAIL_MSG( errmsg );
3069 return FALSE;
3070 }
3071
3072 if ( numRows > curNumRows - pos )
3073 {
3074 numRows = curNumRows - pos;
3075 }
3076
3077 if ( numRows >= curNumRows )
3078 {
3079 m_data.Empty(); // don't release memory just yet
3080 }
3081 else
3082 {
3083 for ( n = 0; n < numRows; n++ )
3084 {
3085 m_data.RemoveAt( pos );
3086 }
3087 }
3088 if ( GetView() )
3089 {
3090 wxGridTableMessage msg( this,
3091 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
3092 pos,
3093 numRows );
3094
3095 GetView()->ProcessTableMessage( msg );
3096 }
3097
3098 return TRUE;
3099 }
3100
3101 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
3102 {
3103 size_t row, col;
3104
3105 size_t curNumRows = m_data.GetCount();
3106 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3107 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3108
3109 if ( pos >= curNumCols )
3110 {
3111 return AppendCols( numCols );
3112 }
3113
3114 for ( row = 0; row < curNumRows; row++ )
3115 {
3116 for ( col = pos; col < pos + numCols; col++ )
3117 {
3118 m_data[row].Insert( wxEmptyString, col );
3119 }
3120 }
3121 if ( GetView() )
3122 {
3123 wxGridTableMessage msg( this,
3124 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
3125 pos,
3126 numCols );
3127
3128 GetView()->ProcessTableMessage( msg );
3129 }
3130
3131 return TRUE;
3132 }
3133
3134 bool wxGridStringTable::AppendCols( size_t numCols )
3135 {
3136 size_t row, n;
3137
3138 size_t curNumRows = m_data.GetCount();
3139 #if 0
3140 if ( !curNumRows )
3141 {
3142 // TODO: something better than this ?
3143 //
3144 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3145 return FALSE;
3146 }
3147 #endif
3148
3149 for ( row = 0; row < curNumRows; row++ )
3150 {
3151 for ( n = 0; n < numCols; n++ )
3152 {
3153 m_data[row].Add( wxEmptyString );
3154 }
3155 }
3156
3157 if ( GetView() )
3158 {
3159 wxGridTableMessage msg( this,
3160 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
3161 numCols );
3162
3163 GetView()->ProcessTableMessage( msg );
3164 }
3165
3166 return TRUE;
3167 }
3168
3169 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
3170 {
3171 size_t row, n;
3172
3173 size_t curNumRows = m_data.GetCount();
3174 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3175 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3176
3177 if ( pos >= curNumCols )
3178 {
3179 wxString errmsg;
3180 errmsg.Printf( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\nPos value is invalid for present table with %d cols"),
3181 pos, numCols, curNumCols );
3182 wxFAIL_MSG( errmsg );
3183 return FALSE;
3184 }
3185
3186 if ( numCols > curNumCols - pos )
3187 {
3188 numCols = curNumCols - pos;
3189 }
3190
3191 for ( row = 0; row < curNumRows; row++ )
3192 {
3193 if ( numCols >= curNumCols )
3194 {
3195 m_data[row].Clear();
3196 }
3197 else
3198 {
3199 for ( n = 0; n < numCols; n++ )
3200 {
3201 m_data[row].RemoveAt( pos );
3202 }
3203 }
3204 }
3205 if ( GetView() )
3206 {
3207 wxGridTableMessage msg( this,
3208 wxGRIDTABLE_NOTIFY_COLS_DELETED,
3209 pos,
3210 numCols );
3211
3212 GetView()->ProcessTableMessage( msg );
3213 }
3214
3215 return TRUE;
3216 }
3217
3218 wxString wxGridStringTable::GetRowLabelValue( int row )
3219 {
3220 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3221 {
3222 // using default label
3223 //
3224 return wxGridTableBase::GetRowLabelValue( row );
3225 }
3226 else
3227 {
3228 return m_rowLabels[ row ];
3229 }
3230 }
3231
3232 wxString wxGridStringTable::GetColLabelValue( int col )
3233 {
3234 if ( col > (int)(m_colLabels.GetCount()) - 1 )
3235 {
3236 // using default label
3237 //
3238 return wxGridTableBase::GetColLabelValue( col );
3239 }
3240 else
3241 {
3242 return m_colLabels[ col ];
3243 }
3244 }
3245
3246 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
3247 {
3248 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3249 {
3250 int n = m_rowLabels.GetCount();
3251 int i;
3252 for ( i = n; i <= row; i++ )
3253 {
3254 m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
3255 }
3256 }
3257
3258 m_rowLabels[row] = value;
3259 }
3260
3261 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
3262 {
3263 if ( col > (int)(m_colLabels.GetCount()) - 1 )
3264 {
3265 int n = m_colLabels.GetCount();
3266 int i;
3267 for ( i = n; i <= col; i++ )
3268 {
3269 m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
3270 }
3271 }
3272
3273 m_colLabels[col] = value;
3274 }
3275
3276
3277
3278 //////////////////////////////////////////////////////////////////////
3279 //////////////////////////////////////////////////////////////////////
3280
3281 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
3282
3283 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
3284 EVT_PAINT( wxGridRowLabelWindow::OnPaint )
3285 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel)
3286 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
3287 EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
3288 EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
3289 END_EVENT_TABLE()
3290
3291 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
3292 wxWindowID id,
3293 const wxPoint &pos, const wxSize &size )
3294 : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3295 {
3296 m_owner = parent;
3297 }
3298
3299 void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3300 {
3301 wxPaintDC dc(this);
3302
3303 // NO - don't do this because it will set both the x and y origin
3304 // coords to match the parent scrolled window and we just want to
3305 // set the y coord - MB
3306 //
3307 // m_owner->PrepareDC( dc );
3308
3309 int x, y;
3310 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3311 dc.SetDeviceOrigin( 0, -y );
3312
3313 wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
3314 m_owner->DrawRowLabels( dc , rows );
3315 }
3316
3317
3318 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
3319 {
3320 m_owner->ProcessRowLabelMouseEvent( event );
3321 }
3322
3323
3324 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
3325 {
3326 m_owner->GetEventHandler()->ProcessEvent(event);
3327 }
3328
3329
3330 // This seems to be required for wxMotif otherwise the mouse
3331 // cursor must be in the cell edit control to get key events
3332 //
3333 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
3334 {
3335 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3336 }
3337
3338 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
3339 {
3340 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3341 }
3342
3343
3344
3345 //////////////////////////////////////////////////////////////////////
3346
3347 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
3348
3349 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
3350 EVT_PAINT( wxGridColLabelWindow::OnPaint )
3351 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel)
3352 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
3353 EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
3354 EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
3355 END_EVENT_TABLE()
3356
3357 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
3358 wxWindowID id,
3359 const wxPoint &pos, const wxSize &size )
3360 : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3361 {
3362 m_owner = parent;
3363 }
3364
3365 void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3366 {
3367 wxPaintDC dc(this);
3368
3369 // NO - don't do this because it will set both the x and y origin
3370 // coords to match the parent scrolled window and we just want to
3371 // set the x coord - MB
3372 //
3373 // m_owner->PrepareDC( dc );
3374
3375 int x, y;
3376 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3377 dc.SetDeviceOrigin( -x, 0 );
3378
3379 wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
3380 m_owner->DrawColLabels( dc , cols );
3381 }
3382
3383
3384 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
3385 {
3386 m_owner->ProcessColLabelMouseEvent( event );
3387 }
3388
3389 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
3390 {
3391 m_owner->GetEventHandler()->ProcessEvent(event);
3392 }
3393
3394
3395 // This seems to be required for wxMotif otherwise the mouse
3396 // cursor must be in the cell edit control to get key events
3397 //
3398 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
3399 {
3400 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3401 }
3402
3403 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
3404 {
3405 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3406 }
3407
3408
3409
3410 //////////////////////////////////////////////////////////////////////
3411
3412 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
3413
3414 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
3415 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel)
3416 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
3417 EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
3418 EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
3419 EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp )
3420 END_EVENT_TABLE()
3421
3422 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
3423 wxWindowID id,
3424 const wxPoint &pos, const wxSize &size )
3425 : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3426 {
3427 m_owner = parent;
3428 }
3429
3430 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3431 {
3432 wxPaintDC dc(this);
3433
3434 int client_height = 0;
3435 int client_width = 0;
3436 GetClientSize( &client_width, &client_height );
3437
3438 dc.SetPen( *wxBLACK_PEN );
3439 dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
3440 dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
3441
3442 dc.SetPen( *wxWHITE_PEN );
3443 dc.DrawLine( 0, 0, client_width, 0 );
3444 dc.DrawLine( 0, 0, 0, client_height );
3445 }
3446
3447
3448 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
3449 {
3450 m_owner->ProcessCornerLabelMouseEvent( event );
3451 }
3452
3453
3454 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
3455 {
3456 m_owner->GetEventHandler()->ProcessEvent(event);
3457 }
3458
3459 // This seems to be required for wxMotif otherwise the mouse
3460 // cursor must be in the cell edit control to get key events
3461 //
3462 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
3463 {
3464 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3465 }
3466
3467 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
3468 {
3469 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3470 }
3471
3472
3473
3474 //////////////////////////////////////////////////////////////////////
3475
3476 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
3477
3478 BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
3479 EVT_PAINT( wxGridWindow::OnPaint )
3480 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel)
3481 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
3482 EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
3483 EVT_KEY_UP( wxGridWindow::OnKeyUp )
3484 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
3485 END_EVENT_TABLE()
3486
3487 wxGridWindow::wxGridWindow( wxGrid *parent,
3488 wxGridRowLabelWindow *rowLblWin,
3489 wxGridColLabelWindow *colLblWin,
3490 wxWindowID id, const wxPoint &pos, const wxSize &size )
3491 : wxPanel( parent, id, pos, size, wxWANTS_CHARS, "grid window" )
3492 {
3493 m_owner = parent;
3494 m_rowLabelWin = rowLblWin;
3495 m_colLabelWin = colLblWin;
3496 SetBackgroundColour(_T("WHITE"));
3497 }
3498
3499
3500 wxGridWindow::~wxGridWindow()
3501 {
3502 }
3503
3504
3505 void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
3506 {
3507 wxPaintDC dc( this );
3508 m_owner->PrepareDC( dc );
3509 wxRegion reg = GetUpdateRegion();
3510 wxGridCellCoordsArray DirtyCells = m_owner->CalcCellsExposed( reg );
3511 m_owner->DrawGridCellArea( dc , DirtyCells);
3512 #if WXGRID_DRAW_LINES
3513 m_owner->DrawAllGridLines( dc, reg );
3514 #endif
3515 m_owner->DrawGridSpace( dc );
3516 m_owner->DrawHighlight( dc , DirtyCells );
3517 }
3518
3519
3520 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
3521 {
3522 wxPanel::ScrollWindow( dx, dy, rect );
3523 m_rowLabelWin->ScrollWindow( 0, dy, rect );
3524 m_colLabelWin->ScrollWindow( dx, 0, rect );
3525 }
3526
3527
3528 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
3529 {
3530 m_owner->ProcessGridCellMouseEvent( event );
3531 }
3532
3533 void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
3534 {
3535 m_owner->GetEventHandler()->ProcessEvent(event);
3536 }
3537
3538 // This seems to be required for wxMotif/wxGTK otherwise the mouse
3539 // cursor must be in the cell edit control to get key events
3540 //
3541 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
3542 {
3543 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3544 }
3545
3546 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
3547 {
3548 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3549 }
3550
3551 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
3552 {
3553 }
3554
3555
3556 //////////////////////////////////////////////////////////////////////
3557
3558
3559 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
3560
3561 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
3562 EVT_PAINT( wxGrid::OnPaint )
3563 EVT_SIZE( wxGrid::OnSize )
3564 EVT_KEY_DOWN( wxGrid::OnKeyDown )
3565 EVT_KEY_UP( wxGrid::OnKeyUp )
3566 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
3567 END_EVENT_TABLE()
3568
3569 wxGrid::wxGrid( wxWindow *parent,
3570 wxWindowID id,
3571 const wxPoint& pos,
3572 const wxSize& size,
3573 long style,
3574 const wxString& name )
3575 : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
3576 m_colMinWidths(GRID_HASH_SIZE),
3577 m_rowMinHeights(GRID_HASH_SIZE)
3578 {
3579 Create();
3580 }
3581
3582
3583 wxGrid::~wxGrid()
3584 {
3585 // Must do this or ~wxScrollHelper will pop the wrong event handler
3586 SetTargetWindow(this);
3587 ClearAttrCache();
3588 wxSafeDecRef(m_defaultCellAttr);
3589
3590 #ifdef DEBUG_ATTR_CACHE
3591 size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
3592 wxPrintf(_T("wxGrid attribute cache statistics: "
3593 "total: %u, hits: %u (%u%%)\n"),
3594 total, gs_nAttrCacheHits,
3595 total ? (gs_nAttrCacheHits*100) / total : 0);
3596 #endif
3597
3598 if (m_ownTable)
3599 delete m_table;
3600
3601 delete m_typeRegistry;
3602 delete m_selection;
3603 }
3604
3605
3606 //
3607 // ----- internal init and update functions
3608 //
3609
3610 void wxGrid::Create()
3611 {
3612 m_created = FALSE; // set to TRUE by CreateGrid
3613
3614 m_table = (wxGridTableBase *) NULL;
3615 m_ownTable = FALSE;
3616
3617 m_cellEditCtrlEnabled = FALSE;
3618
3619 m_defaultCellAttr = new wxGridCellAttr;
3620 m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
3621
3622 // Set default cell attributes
3623 m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
3624 m_defaultCellAttr->SetFont(GetFont());
3625 m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
3626 m_defaultCellAttr->SetTextColour(
3627 wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
3628 m_defaultCellAttr->SetBackgroundColour(
3629 wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
3630 m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
3631 m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
3632
3633
3634 m_numRows = 0;
3635 m_numCols = 0;
3636 m_currentCellCoords = wxGridNoCellCoords;
3637
3638 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3639 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3640
3641 // create the type registry
3642 m_typeRegistry = new wxGridTypeRegistry;
3643 m_selection = 0;
3644 // subwindow components that make up the wxGrid
3645 m_cornerLabelWin = new wxGridCornerLabelWindow( this,
3646 -1,
3647 wxDefaultPosition,
3648 wxDefaultSize );
3649
3650 m_rowLabelWin = new wxGridRowLabelWindow( this,
3651 -1,
3652 wxDefaultPosition,
3653 wxDefaultSize );
3654
3655 m_colLabelWin = new wxGridColLabelWindow( this,
3656 -1,
3657 wxDefaultPosition,
3658 wxDefaultSize );
3659
3660 m_gridWin = new wxGridWindow( this,
3661 m_rowLabelWin,
3662 m_colLabelWin,
3663 -1,
3664 wxDefaultPosition,
3665 wxDefaultSize );
3666
3667 SetTargetWindow( m_gridWin );
3668
3669 Init();
3670 }
3671
3672
3673 bool wxGrid::CreateGrid( int numRows, int numCols,
3674 wxGrid::wxGridSelectionModes selmode )
3675 {
3676 wxCHECK_MSG( !m_created,
3677 FALSE,
3678 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3679
3680 m_numRows = numRows;
3681 m_numCols = numCols;
3682
3683 m_table = new wxGridStringTable( m_numRows, m_numCols );
3684 m_table->SetView( this );
3685 m_ownTable = TRUE;
3686 m_selection = new wxGridSelection( this, selmode );
3687
3688 CalcDimensions();
3689
3690 m_created = TRUE;
3691
3692 return m_created;
3693 }
3694
3695 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
3696 {
3697 wxCHECK_RET( m_created,
3698 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3699
3700 m_selection->SetSelectionMode( selmode );
3701 }
3702
3703 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
3704 wxGrid::wxGridSelectionModes selmode )
3705 {
3706 if ( m_created )
3707 {
3708 // RD: Actually, this should probably be allowed. I think it would be
3709 // nice to be able to switch multiple Tables in and out of a single
3710 // View at runtime. Is there anything in the implmentation that would
3711 // prevent this?
3712
3713 // At least, you now have to cope with m_selection
3714 wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3715 return FALSE;
3716 }
3717 else
3718 {
3719 m_numRows = table->GetNumberRows();
3720 m_numCols = table->GetNumberCols();
3721
3722 m_table = table;
3723 m_table->SetView( this );
3724 if (takeOwnership)
3725 m_ownTable = TRUE;
3726 m_selection = new wxGridSelection( this, selmode );
3727
3728 CalcDimensions();
3729
3730 m_created = TRUE;
3731 }
3732
3733 return m_created;
3734 }
3735
3736
3737 void wxGrid::Init()
3738 {
3739 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3740 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3741
3742 if ( m_rowLabelWin )
3743 {
3744 m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
3745 }
3746 else
3747 {
3748 m_labelBackgroundColour = wxColour( _T("WHITE") );
3749 }
3750
3751 m_labelTextColour = wxColour( _T("BLACK") );
3752
3753 // init attr cache
3754 m_attrCache.row = -1;
3755
3756 // TODO: something better than this ?
3757 //
3758 m_labelFont = this->GetFont();
3759 m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
3760
3761 m_rowLabelHorizAlign = wxALIGN_LEFT;
3762 m_rowLabelVertAlign = wxALIGN_CENTRE;
3763
3764 m_colLabelHorizAlign = wxALIGN_CENTRE;
3765 m_colLabelVertAlign = wxALIGN_TOP;
3766
3767 m_defaultColWidth = WXGRID_DEFAULT_COL_WIDTH;
3768 m_defaultRowHeight = m_gridWin->GetCharHeight();
3769
3770 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
3771 m_defaultRowHeight += 8;
3772 #else
3773 m_defaultRowHeight += 4;
3774 #endif
3775
3776 m_gridLineColour = wxColour( 128, 128, 255 );
3777 m_gridLinesEnabled = TRUE;
3778 m_cellHighlightColour = m_gridLineColour;
3779 m_cellHighlightPenWidth = 2;
3780 m_cellHighlightROPenWidth = 1;
3781
3782 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
3783 m_winCapture = (wxWindow *)NULL;
3784 m_canDragRowSize = TRUE;
3785 m_canDragColSize = TRUE;
3786 m_canDragGridSize = TRUE;
3787 m_dragLastPos = -1;
3788 m_dragRowOrCol = -1;
3789 m_isDragging = FALSE;
3790 m_startDragPos = wxDefaultPosition;
3791
3792 m_waitForSlowClick = FALSE;
3793
3794 m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
3795 m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
3796
3797 m_currentCellCoords = wxGridNoCellCoords;
3798
3799 m_selectingTopLeft = wxGridNoCellCoords;
3800 m_selectingBottomRight = wxGridNoCellCoords;
3801 m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
3802 m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
3803
3804 m_editable = TRUE; // default for whole grid
3805
3806 m_inOnKeyDown = FALSE;
3807 m_batchCount = 0;
3808
3809 m_extraWidth =
3810 m_extraHeight = 50;
3811 }
3812
3813 // ----------------------------------------------------------------------------
3814 // the idea is to call these functions only when necessary because they create
3815 // quite big arrays which eat memory mostly unnecessary - in particular, if
3816 // default widths/heights are used for all rows/columns, we may not use these
3817 // arrays at all
3818 //
3819 // with some extra code, it should be possible to only store the
3820 // widths/heights different from default ones but this will be done later...
3821 // ----------------------------------------------------------------------------
3822
3823 void wxGrid::InitRowHeights()
3824 {
3825 m_rowHeights.Empty();
3826 m_rowBottoms.Empty();
3827
3828 m_rowHeights.Alloc( m_numRows );
3829 m_rowBottoms.Alloc( m_numRows );
3830
3831 int rowBottom = 0;
3832 for ( int i = 0; i < m_numRows; i++ )
3833 {
3834 m_rowHeights.Add( m_defaultRowHeight );
3835 rowBottom += m_defaultRowHeight;
3836 m_rowBottoms.Add( rowBottom );
3837 }
3838 }
3839
3840 void wxGrid::InitColWidths()
3841 {
3842 m_colWidths.Empty();
3843 m_colRights.Empty();
3844
3845 m_colWidths.Alloc( m_numCols );
3846 m_colRights.Alloc( m_numCols );
3847 int colRight = 0;
3848 for ( int i = 0; i < m_numCols; i++ )
3849 {
3850 m_colWidths.Add( m_defaultColWidth );
3851 colRight += m_defaultColWidth;
3852 m_colRights.Add( colRight );
3853 }
3854 }
3855
3856 int wxGrid::GetColWidth(int col) const
3857 {
3858 return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
3859 }
3860
3861 int wxGrid::GetColLeft(int col) const
3862 {
3863 return m_colRights.IsEmpty() ? col * m_defaultColWidth
3864 : m_colRights[col] - m_colWidths[col];
3865 }
3866
3867 int wxGrid::GetColRight(int col) const
3868 {
3869 return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
3870 : m_colRights[col];
3871 }
3872
3873 int wxGrid::GetRowHeight(int row) const
3874 {
3875 return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
3876 }
3877
3878 int wxGrid::GetRowTop(int row) const
3879 {
3880 return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
3881 : m_rowBottoms[row] - m_rowHeights[row];
3882 }
3883
3884 int wxGrid::GetRowBottom(int row) const
3885 {
3886 return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
3887 : m_rowBottoms[row];
3888 }
3889
3890 void wxGrid::CalcDimensions()
3891 {
3892 int cw, ch;
3893 GetClientSize( &cw, &ch );
3894
3895 if ( m_colLabelWin->IsShown() )
3896 cw -= m_rowLabelWidth;
3897 if ( m_rowLabelWin->IsShown() )
3898 ch -= m_colLabelHeight;
3899
3900 // grid total size
3901 int w = m_numCols > 0 ? GetColRight(m_numCols - 1) + m_extraWidth + 1 : 0;
3902 int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
3903
3904 // preserve (more or less) the previous position
3905 int x, y;
3906 GetViewStart( &x, &y );
3907
3908 // maybe we don't need scrollbars at all?
3909 //
3910 // also adjust the position to be valid for the new scroll rangs
3911 if ( w <= cw )
3912 {
3913 w = x = 0;
3914 }
3915 else
3916 {
3917 if ( x >= w )
3918 x = w - 1;
3919 }
3920
3921 if ( h <= ch )
3922 {
3923 h = y = 0;
3924 }
3925 else
3926 {
3927 if ( y >= h )
3928 y = h - 1;
3929 }
3930
3931 // do set scrollbar parameters
3932 SetScrollbars( GRID_SCROLL_LINE_X, GRID_SCROLL_LINE_Y,
3933 GetScrollX(w), GetScrollY(h), x, y,
3934 GetBatchCount() != 0);
3935 }
3936
3937
3938 void wxGrid::CalcWindowSizes()
3939 {
3940 int cw, ch;
3941 GetClientSize( &cw, &ch );
3942
3943 if ( m_cornerLabelWin->IsShown() )
3944 m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
3945
3946 if ( m_colLabelWin->IsShown() )
3947 m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
3948
3949 if ( m_rowLabelWin->IsShown() )
3950 m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
3951
3952 if ( m_gridWin->IsShown() )
3953 m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
3954 }
3955
3956
3957 // this is called when the grid table sends a message to say that it
3958 // has been redimensioned
3959 //
3960 bool wxGrid::Redimension( wxGridTableMessage& msg )
3961 {
3962 int i;
3963 bool result = FALSE;
3964
3965 #if 0
3966 // if we were using the default widths/heights so far, we must change them
3967 // now
3968 if ( m_colWidths.IsEmpty() )
3969 {
3970 InitColWidths();
3971 }
3972
3973 if ( m_rowHeights.IsEmpty() )
3974 {
3975 InitRowHeights();
3976 }
3977 #endif
3978
3979 switch ( msg.GetId() )
3980 {
3981 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
3982 {
3983 size_t pos = msg.GetCommandInt();
3984 int numRows = msg.GetCommandInt2();
3985
3986 m_numRows += numRows;
3987
3988 if ( !m_rowHeights.IsEmpty() )
3989 {
3990 for ( i = 0; i < numRows; i++ )
3991 {
3992 m_rowHeights.Insert( m_defaultRowHeight, pos );
3993 m_rowBottoms.Insert( 0, pos );
3994 }
3995
3996 int bottom = 0;
3997 if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
3998
3999 for ( i = pos; i < m_numRows; i++ )
4000 {
4001 bottom += m_rowHeights[i];
4002 m_rowBottoms[i] = bottom;
4003 }
4004 }
4005 if ( m_currentCellCoords == wxGridNoCellCoords )
4006 {
4007 // if we have just inserted cols into an empty grid the current
4008 // cell will be undefined...
4009 //
4010 SetCurrentCell( 0, 0 );
4011 }
4012 m_selection->UpdateRows( pos, numRows );
4013 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4014 if (attrProvider)
4015 attrProvider->UpdateAttrRows( pos, numRows );
4016
4017 if ( !GetBatchCount() )
4018 {
4019 CalcDimensions();
4020 m_rowLabelWin->Refresh();
4021 }
4022 }
4023 result = TRUE;
4024 break;
4025
4026 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4027 {
4028 int numRows = msg.GetCommandInt();
4029 int oldNumRows = m_numRows;
4030 m_numRows += numRows;
4031
4032 if ( !m_rowHeights.IsEmpty() )
4033 {
4034 for ( i = 0; i < numRows; i++ )
4035 {
4036 m_rowHeights.Add( m_defaultRowHeight );
4037 m_rowBottoms.Add( 0 );
4038 }
4039
4040 int bottom = 0;
4041 if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
4042
4043 for ( i = oldNumRows; i < m_numRows; i++ )
4044 {
4045 bottom += m_rowHeights[i];
4046 m_rowBottoms[i] = bottom;
4047 }
4048 }
4049 if ( m_currentCellCoords == wxGridNoCellCoords )
4050 {
4051 // if we have just inserted cols into an empty grid the current
4052 // cell will be undefined...
4053 //
4054 SetCurrentCell( 0, 0 );
4055 }
4056 if ( !GetBatchCount() )
4057 {
4058 CalcDimensions();
4059 m_rowLabelWin->Refresh();
4060 }
4061 }
4062 result = TRUE;
4063 break;
4064
4065 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4066 {
4067 size_t pos = msg.GetCommandInt();
4068 int numRows = msg.GetCommandInt2();
4069 m_numRows -= numRows;
4070
4071 if ( !m_rowHeights.IsEmpty() )
4072 {
4073 for ( i = 0; i < numRows; i++ )
4074 {
4075 m_rowHeights.RemoveAt( pos );
4076 m_rowBottoms.RemoveAt( pos );
4077 }
4078
4079 int h = 0;
4080 for ( i = 0; i < m_numRows; i++ )
4081 {
4082 h += m_rowHeights[i];
4083 m_rowBottoms[i] = h;
4084 }
4085 }
4086 if ( !m_numRows )
4087 {
4088 m_currentCellCoords = wxGridNoCellCoords;
4089 }
4090 else
4091 {
4092 if ( m_currentCellCoords.GetRow() >= m_numRows )
4093 m_currentCellCoords.Set( 0, 0 );
4094 }
4095 m_selection->UpdateRows( pos, -((int)numRows) );
4096 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4097 if (attrProvider) {
4098 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
4099 // ifdef'd out following patch from Paul Gammans
4100 #if 0
4101 // No need to touch column attributes, unless we
4102 // removed _all_ rows, in this case, we remove
4103 // all column attributes.
4104 // I hate to do this here, but the
4105 // needed data is not available inside UpdateAttrRows.
4106 if ( !GetNumberRows() )
4107 attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
4108 #endif
4109 }
4110 if ( !GetBatchCount() )
4111 {
4112 CalcDimensions();
4113 m_rowLabelWin->Refresh();
4114 }
4115 }
4116 result = TRUE;
4117 break;
4118
4119 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4120 {
4121 size_t pos = msg.GetCommandInt();
4122 int numCols = msg.GetCommandInt2();
4123 m_numCols += numCols;
4124
4125 if ( !m_colWidths.IsEmpty() )
4126 {
4127 for ( i = 0; i < numCols; i++ )
4128 {
4129 m_colWidths.Insert( m_defaultColWidth, pos );
4130 m_colRights.Insert( 0, pos );
4131 }
4132
4133 int right = 0;
4134 if ( pos > 0 ) right = m_colRights[pos-1];
4135
4136 for ( i = pos; i < m_numCols; i++ )
4137 {
4138 right += m_colWidths[i];
4139 m_colRights[i] = right;
4140 }
4141 }
4142 if ( m_currentCellCoords == wxGridNoCellCoords )
4143 {
4144 // if we have just inserted cols into an empty grid the current
4145 // cell will be undefined...
4146 //
4147 SetCurrentCell( 0, 0 );
4148 }
4149 m_selection->UpdateCols( pos, numCols );
4150 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4151 if (attrProvider)
4152 attrProvider->UpdateAttrCols( pos, numCols );
4153 if ( !GetBatchCount() )
4154 {
4155 CalcDimensions();
4156 m_colLabelWin->Refresh();
4157 }
4158
4159 }
4160 result = TRUE;
4161 break;
4162
4163 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4164 {
4165 int numCols = msg.GetCommandInt();
4166 int oldNumCols = m_numCols;
4167 m_numCols += numCols;
4168 if ( !m_colWidths.IsEmpty() )
4169 {
4170 for ( i = 0; i < numCols; i++ )
4171 {
4172 m_colWidths.Add( m_defaultColWidth );
4173 m_colRights.Add( 0 );
4174 }
4175
4176 int right = 0;
4177 if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
4178
4179 for ( i = oldNumCols; i < m_numCols; i++ )
4180 {
4181 right += m_colWidths[i];
4182 m_colRights[i] = right;
4183 }
4184 }
4185 if ( m_currentCellCoords == wxGridNoCellCoords )
4186 {
4187 // if we have just inserted cols into an empty grid the current
4188 // cell will be undefined...
4189 //
4190 SetCurrentCell( 0, 0 );
4191 }
4192 if ( !GetBatchCount() )
4193 {
4194 CalcDimensions();
4195 m_colLabelWin->Refresh();
4196 }
4197 }
4198 result = TRUE;
4199 break;
4200
4201 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4202 {
4203 size_t pos = msg.GetCommandInt();
4204 int numCols = msg.GetCommandInt2();
4205 m_numCols -= numCols;
4206
4207 if ( !m_colWidths.IsEmpty() )
4208 {
4209 for ( i = 0; i < numCols; i++ )
4210 {
4211 m_colWidths.RemoveAt( pos );
4212 m_colRights.RemoveAt( pos );
4213 }
4214
4215 int w = 0;
4216 for ( i = 0; i < m_numCols; i++ )
4217 {
4218 w += m_colWidths[i];
4219 m_colRights[i] = w;
4220 }
4221 }
4222 if ( !m_numCols )
4223 {
4224 m_currentCellCoords = wxGridNoCellCoords;
4225 }
4226 else
4227 {
4228 if ( m_currentCellCoords.GetCol() >= m_numCols )
4229 m_currentCellCoords.Set( 0, 0 );
4230 }
4231 m_selection->UpdateCols( pos, -((int)numCols) );
4232 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4233 if (attrProvider) {
4234 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
4235 // ifdef'd out following patch from Paul Gammans
4236 #if 0
4237 // No need to touch row attributes, unless we
4238 // removed _all_ columns, in this case, we remove
4239 // all row attributes.
4240 // I hate to do this here, but the
4241 // needed data is not available inside UpdateAttrCols.
4242 if ( !GetNumberCols() )
4243 attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
4244 #endif
4245 }
4246 if ( !GetBatchCount() )
4247 {
4248 CalcDimensions();
4249 m_colLabelWin->Refresh();
4250 }
4251 }
4252 result = TRUE;
4253 break;
4254 }
4255
4256 if (result && !GetBatchCount() )
4257 m_gridWin->Refresh();
4258 return result;
4259 }
4260
4261
4262 wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
4263 {
4264 wxRegionIterator iter( reg );
4265 wxRect r;
4266
4267 wxArrayInt rowlabels;
4268
4269 int top, bottom;
4270 while ( iter )
4271 {
4272 r = iter.GetRect();
4273
4274 // TODO: remove this when we can...
4275 // There is a bug in wxMotif that gives garbage update
4276 // rectangles if you jump-scroll a long way by clicking the
4277 // scrollbar with middle button. This is a work-around
4278 //
4279 #if defined(__WXMOTIF__)
4280 int cw, ch;
4281 m_gridWin->GetClientSize( &cw, &ch );
4282 if ( r.GetTop() > ch ) r.SetTop( 0 );
4283 r.SetBottom( wxMin( r.GetBottom(), ch ) );
4284 #endif
4285
4286 // logical bounds of update region
4287 //
4288 int dummy;
4289 CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
4290 CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
4291
4292 // find the row labels within these bounds
4293 //
4294 int row;
4295 for ( row = 0; row < m_numRows; row++ )
4296 {
4297 if ( GetRowBottom(row) < top )
4298 continue;
4299
4300 if ( GetRowTop(row) > bottom )
4301 break;
4302
4303 rowlabels.Add( row );
4304 }
4305
4306 iter++ ;
4307 }
4308
4309 return rowlabels;
4310 }
4311
4312
4313 wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
4314 {
4315 wxRegionIterator iter( reg );
4316 wxRect r;
4317
4318 wxArrayInt colLabels;
4319
4320 int left, right;
4321 while ( iter )
4322 {
4323 r = iter.GetRect();
4324
4325 // TODO: remove this when we can...
4326 // There is a bug in wxMotif that gives garbage update
4327 // rectangles if you jump-scroll a long way by clicking the
4328 // scrollbar with middle button. This is a work-around
4329 //
4330 #if defined(__WXMOTIF__)
4331 int cw, ch;
4332 m_gridWin->GetClientSize( &cw, &ch );
4333 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4334 r.SetRight( wxMin( r.GetRight(), cw ) );
4335 #endif
4336
4337 // logical bounds of update region
4338 //
4339 int dummy;
4340 CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
4341 CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
4342
4343 // find the cells within these bounds
4344 //
4345 int col;
4346 for ( col = 0; col < m_numCols; col++ )
4347 {
4348 if ( GetColRight(col) < left )
4349 continue;
4350
4351 if ( GetColLeft(col) > right )
4352 break;
4353
4354 colLabels.Add( col );
4355 }
4356
4357 iter++ ;
4358 }
4359 return colLabels;
4360 }
4361
4362
4363 wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
4364 {
4365 wxRegionIterator iter( reg );
4366 wxRect r;
4367
4368 wxGridCellCoordsArray cellsExposed;
4369
4370 int left, top, right, bottom;
4371 while ( iter )
4372 {
4373 r = iter.GetRect();
4374
4375 // TODO: remove this when we can...
4376 // There is a bug in wxMotif that gives garbage update
4377 // rectangles if you jump-scroll a long way by clicking the
4378 // scrollbar with middle button. This is a work-around
4379 //
4380 #if defined(__WXMOTIF__)
4381 int cw, ch;
4382 m_gridWin->GetClientSize( &cw, &ch );
4383 if ( r.GetTop() > ch ) r.SetTop( 0 );
4384 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4385 r.SetRight( wxMin( r.GetRight(), cw ) );
4386 r.SetBottom( wxMin( r.GetBottom(), ch ) );
4387 #endif
4388
4389 // logical bounds of update region
4390 //
4391 CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
4392 CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
4393
4394 // find the cells within these bounds
4395 //
4396 int row, col;
4397 for ( row = 0; row < m_numRows; row++ )
4398 {
4399 if ( GetRowBottom(row) <= top )
4400 continue;
4401
4402 if ( GetRowTop(row) > bottom )
4403 break;
4404
4405
4406 for ( col = 0; col < m_numCols; col++ )
4407 {
4408 if ( GetColRight(col) <= left )
4409 continue;
4410
4411 if ( GetColLeft(col) > right )
4412 break;
4413
4414 cellsExposed.Add( wxGridCellCoords( row, col ) );
4415 }
4416 }
4417
4418 iter++;
4419 }
4420
4421 return cellsExposed;
4422 }
4423
4424
4425 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
4426 {
4427 int x, y, row;
4428 wxPoint pos( event.GetPosition() );
4429 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4430
4431 if ( event.Dragging() )
4432 {
4433 m_isDragging = TRUE;
4434
4435 if ( event.LeftIsDown() )
4436 {
4437 switch( m_cursorMode )
4438 {
4439 case WXGRID_CURSOR_RESIZE_ROW:
4440 {
4441 int cw, ch, left, dummy;
4442 m_gridWin->GetClientSize( &cw, &ch );
4443 CalcUnscrolledPosition( 0, 0, &left, &dummy );
4444
4445 wxClientDC dc( m_gridWin );
4446 PrepareDC( dc );
4447 y = wxMax( y,
4448 GetRowTop(m_dragRowOrCol) +
4449 GetRowMinimalHeight(m_dragRowOrCol) );
4450 dc.SetLogicalFunction(wxINVERT);
4451 if ( m_dragLastPos >= 0 )
4452 {
4453 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4454 }
4455 dc.DrawLine( left, y, left+cw, y );
4456 m_dragLastPos = y;
4457 }
4458 break;
4459
4460 case WXGRID_CURSOR_SELECT_ROW:
4461 if ( (row = YToRow( y )) >= 0 )
4462 {
4463 m_selection->SelectRow( row,
4464 event.ControlDown(),
4465 event.ShiftDown(),
4466 event.AltDown(),
4467 event.MetaDown() );
4468 }
4469
4470 // default label to suppress warnings about "enumeration value
4471 // 'xxx' not handled in switch
4472 default:
4473 break;
4474 }
4475 }
4476 return;
4477 }
4478
4479 m_isDragging = FALSE;
4480
4481
4482 // ------------ Entering or leaving the window
4483 //
4484 if ( event.Entering() || event.Leaving() )
4485 {
4486 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4487 }
4488
4489
4490 // ------------ Left button pressed
4491 //
4492 else if ( event.LeftDown() )
4493 {
4494 // don't send a label click event for a hit on the
4495 // edge of the row label - this is probably the user
4496 // wanting to resize the row
4497 //
4498 if ( YToEdgeOfRow(y) < 0 )
4499 {
4500 row = YToRow(y);
4501 if ( row >= 0 &&
4502 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
4503 {
4504 if ( !event.ShiftDown() && !event.ControlDown() )
4505 ClearSelection();
4506 if ( event.ShiftDown() )
4507 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4508 0,
4509 row,
4510 GetNumberCols() - 1,
4511 event.ControlDown(),
4512 event.ShiftDown(),
4513 event.AltDown(),
4514 event.MetaDown() );
4515 else
4516 m_selection->SelectRow( row,
4517 event.ControlDown(),
4518 event.ShiftDown(),
4519 event.AltDown(),
4520 event.MetaDown() );
4521 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
4522 }
4523 }
4524 else
4525 {
4526 // starting to drag-resize a row
4527 //
4528 if ( CanDragRowSize() )
4529 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
4530 }
4531 }
4532
4533
4534 // ------------ Left double click
4535 //
4536 else if (event.LeftDClick() )
4537 {
4538 if ( YToEdgeOfRow(y) < 0 )
4539 {
4540 row = YToRow(y);
4541 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
4542 }
4543 }
4544
4545
4546 // ------------ Left button released
4547 //
4548 else if ( event.LeftUp() )
4549 {
4550 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4551 {
4552 DoEndDragResizeRow();
4553
4554 // Note: we are ending the event *after* doing
4555 // default processing in this case
4556 //
4557 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4558 }
4559
4560 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4561 m_dragLastPos = -1;
4562 }
4563
4564
4565 // ------------ Right button down
4566 //
4567 else if ( event.RightDown() )
4568 {
4569 row = YToRow(y);
4570 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
4571 {
4572 // no default action at the moment
4573 }
4574 }
4575
4576
4577 // ------------ Right double click
4578 //
4579 else if ( event.RightDClick() )
4580 {
4581 row = YToRow(y);
4582 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
4583 {
4584 // no default action at the moment
4585 }
4586 }
4587
4588
4589 // ------------ No buttons down and mouse moving
4590 //
4591 else if ( event.Moving() )
4592 {
4593 m_dragRowOrCol = YToEdgeOfRow( y );
4594 if ( m_dragRowOrCol >= 0 )
4595 {
4596 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4597 {
4598 // don't capture the mouse yet
4599 if ( CanDragRowSize() )
4600 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
4601 }
4602 }
4603 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4604 {
4605 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
4606 }
4607 }
4608 }
4609
4610
4611 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
4612 {
4613 int x, y, col;
4614 wxPoint pos( event.GetPosition() );
4615 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4616
4617 if ( event.Dragging() )
4618 {
4619 m_isDragging = TRUE;
4620
4621 if ( event.LeftIsDown() )
4622 {
4623 switch( m_cursorMode )
4624 {
4625 case WXGRID_CURSOR_RESIZE_COL:
4626 {
4627 int cw, ch, dummy, top;
4628 m_gridWin->GetClientSize( &cw, &ch );
4629 CalcUnscrolledPosition( 0, 0, &dummy, &top );
4630
4631 wxClientDC dc( m_gridWin );
4632 PrepareDC( dc );
4633
4634 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4635 GetColMinimalWidth(m_dragRowOrCol));
4636 dc.SetLogicalFunction(wxINVERT);
4637 if ( m_dragLastPos >= 0 )
4638 {
4639 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4640 }
4641 dc.DrawLine( x, top, x, top+ch );
4642 m_dragLastPos = x;
4643 }
4644 break;
4645
4646 case WXGRID_CURSOR_SELECT_COL:
4647 if ( (col = XToCol( x )) >= 0 )
4648 {
4649 m_selection->SelectCol( col,
4650 event.ControlDown(),
4651 event.ShiftDown(),
4652 event.AltDown(),
4653 event.MetaDown() );
4654 }
4655
4656 // default label to suppress warnings about "enumeration value
4657 // 'xxx' not handled in switch
4658 default:
4659 break;
4660 }
4661 }
4662 return;
4663 }
4664
4665 m_isDragging = FALSE;
4666
4667
4668 // ------------ Entering or leaving the window
4669 //
4670 if ( event.Entering() || event.Leaving() )
4671 {
4672 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4673 }
4674
4675
4676 // ------------ Left button pressed
4677 //
4678 else if ( event.LeftDown() )
4679 {
4680 // don't send a label click event for a hit on the
4681 // edge of the col label - this is probably the user
4682 // wanting to resize the col
4683 //
4684 if ( XToEdgeOfCol(x) < 0 )
4685 {
4686 col = XToCol(x);
4687 if ( col >= 0 &&
4688 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
4689 {
4690 if ( !event.ShiftDown() && !event.ControlDown() )
4691 ClearSelection();
4692 if ( event.ShiftDown() )
4693 m_selection->SelectBlock( 0,
4694 m_currentCellCoords.GetCol(),
4695 GetNumberRows() - 1, col,
4696 event.ControlDown(),
4697 event.ShiftDown(),
4698 event.AltDown(),
4699 event.MetaDown() );
4700 else
4701 m_selection->SelectCol( col,
4702 event.ControlDown(),
4703 event.ShiftDown(),
4704 event.AltDown(),
4705 event.MetaDown() );
4706 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
4707 }
4708 }
4709 else
4710 {
4711 // starting to drag-resize a col
4712 //
4713 if ( CanDragColSize() )
4714 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
4715 }
4716 }
4717
4718
4719 // ------------ Left double click
4720 //
4721 if ( event.LeftDClick() )
4722 {
4723 if ( XToEdgeOfCol(x) < 0 )
4724 {
4725 col = XToCol(x);
4726 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
4727 }
4728 }
4729
4730
4731 // ------------ Left button released
4732 //
4733 else if ( event.LeftUp() )
4734 {
4735 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4736 {
4737 DoEndDragResizeCol();
4738
4739 // Note: we are ending the event *after* doing
4740 // default processing in this case
4741 //
4742 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
4743 }
4744
4745 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4746 m_dragLastPos = -1;
4747 }
4748
4749
4750 // ------------ Right button down
4751 //
4752 else if ( event.RightDown() )
4753 {
4754 col = XToCol(x);
4755 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
4756 {
4757 // no default action at the moment
4758 }
4759 }
4760
4761
4762 // ------------ Right double click
4763 //
4764 else if ( event.RightDClick() )
4765 {
4766 col = XToCol(x);
4767 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
4768 {
4769 // no default action at the moment
4770 }
4771 }
4772
4773
4774 // ------------ No buttons down and mouse moving
4775 //
4776 else if ( event.Moving() )
4777 {
4778 m_dragRowOrCol = XToEdgeOfCol( x );
4779 if ( m_dragRowOrCol >= 0 )
4780 {
4781 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4782 {
4783 // don't capture the cursor yet
4784 if ( CanDragColSize() )
4785 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
4786 }
4787 }
4788 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4789 {
4790 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
4791 }
4792 }
4793 }
4794
4795
4796 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
4797 {
4798 if ( event.LeftDown() )
4799 {
4800 // indicate corner label by having both row and
4801 // col args == -1
4802 //
4803 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
4804 {
4805 SelectAll();
4806 }
4807 }
4808
4809 else if ( event.LeftDClick() )
4810 {
4811 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
4812 }
4813
4814 else if ( event.RightDown() )
4815 {
4816 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
4817 {
4818 // no default action at the moment
4819 }
4820 }
4821
4822 else if ( event.RightDClick() )
4823 {
4824 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
4825 {
4826 // no default action at the moment
4827 }
4828 }
4829 }
4830
4831 void wxGrid::ChangeCursorMode(CursorMode mode,
4832 wxWindow *win,
4833 bool captureMouse)
4834 {
4835 #ifdef __WXDEBUG__
4836 static const wxChar *cursorModes[] =
4837 {
4838 _T("SELECT_CELL"),
4839 _T("RESIZE_ROW"),
4840 _T("RESIZE_COL"),
4841 _T("SELECT_ROW"),
4842 _T("SELECT_COL")
4843 };
4844
4845 wxLogTrace(_T("grid"),
4846 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
4847 win == m_colLabelWin ? _T("colLabelWin")
4848 : win ? _T("rowLabelWin")
4849 : _T("gridWin"),
4850 cursorModes[m_cursorMode], cursorModes[mode]);
4851 #endif // __WXDEBUG__
4852
4853 if ( mode == m_cursorMode &&
4854 win == m_winCapture &&
4855 captureMouse == (m_winCapture != NULL))
4856 return;
4857
4858 if ( !win )
4859 {
4860 // by default use the grid itself
4861 win = m_gridWin;
4862 }
4863
4864 if ( m_winCapture )
4865 {
4866 m_winCapture->ReleaseMouse();
4867 m_winCapture = (wxWindow *)NULL;
4868 }
4869
4870 m_cursorMode = mode;
4871
4872 switch ( m_cursorMode )
4873 {
4874 case WXGRID_CURSOR_RESIZE_ROW:
4875 win->SetCursor( m_rowResizeCursor );
4876 break;
4877
4878 case WXGRID_CURSOR_RESIZE_COL:
4879 win->SetCursor( m_colResizeCursor );
4880 break;
4881
4882 default:
4883 win->SetCursor( *wxSTANDARD_CURSOR );
4884 }
4885
4886 // we need to capture mouse when resizing
4887 bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
4888 m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
4889
4890 if ( captureMouse && resize )
4891 {
4892 win->CaptureMouse();
4893 m_winCapture = win;
4894 }
4895 }
4896
4897 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
4898 {
4899 int x, y;
4900 wxPoint pos( event.GetPosition() );
4901 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4902
4903 wxGridCellCoords coords;
4904 XYToCell( x, y, coords );
4905
4906 if ( event.Dragging() )
4907 {
4908 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
4909
4910 // Don't start doing anything until the mouse has been drug at
4911 // least 3 pixels in any direction...
4912 if (! m_isDragging)
4913 {
4914 if (m_startDragPos == wxDefaultPosition)
4915 {
4916 m_startDragPos = pos;
4917 return;
4918 }
4919 if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
4920 return;
4921 }
4922
4923 m_isDragging = TRUE;
4924 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4925 {
4926 // Hide the edit control, so it
4927 // won't interfer with drag-shrinking.
4928 if ( IsCellEditControlShown() )
4929 {
4930 HideCellEditControl();
4931 SaveEditControlValue();
4932 }
4933
4934 // Have we captured the mouse yet?
4935 if (! m_winCapture)
4936 {
4937 m_winCapture = m_gridWin;
4938 m_winCapture->CaptureMouse();
4939 }
4940
4941 if ( coords != wxGridNoCellCoords )
4942 {
4943 if ( event.ControlDown() )
4944 {
4945 if ( m_selectingKeyboard == wxGridNoCellCoords)
4946 m_selectingKeyboard = coords;
4947 HighlightBlock ( m_selectingKeyboard, coords );
4948 }
4949 else
4950 {
4951 if ( !IsSelection() )
4952 {
4953 HighlightBlock( coords, coords );
4954 }
4955 else
4956 {
4957 HighlightBlock( m_currentCellCoords, coords );
4958 }
4959 }
4960
4961 if (! IsVisible(coords))
4962 {
4963 MakeCellVisible(coords);
4964 // TODO: need to introduce a delay or something here. The
4965 // scrolling is way to fast, at least on MSW - also on GTK.
4966 }
4967 }
4968 }
4969 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4970 {
4971 int cw, ch, left, dummy;
4972 m_gridWin->GetClientSize( &cw, &ch );
4973 CalcUnscrolledPosition( 0, 0, &left, &dummy );
4974
4975 wxClientDC dc( m_gridWin );
4976 PrepareDC( dc );
4977 y = wxMax( y, GetRowTop(m_dragRowOrCol) +
4978 GetRowMinimalHeight(m_dragRowOrCol) );
4979 dc.SetLogicalFunction(wxINVERT);
4980 if ( m_dragLastPos >= 0 )
4981 {
4982 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4983 }
4984 dc.DrawLine( left, y, left+cw, y );
4985 m_dragLastPos = y;
4986 }
4987 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4988 {
4989 int cw, ch, dummy, top;
4990 m_gridWin->GetClientSize( &cw, &ch );
4991 CalcUnscrolledPosition( 0, 0, &dummy, &top );
4992
4993 wxClientDC dc( m_gridWin );
4994 PrepareDC( dc );
4995 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4996 GetColMinimalWidth(m_dragRowOrCol) );
4997 dc.SetLogicalFunction(wxINVERT);
4998 if ( m_dragLastPos >= 0 )
4999 {
5000 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5001 }
5002 dc.DrawLine( x, top, x, top+ch );
5003 m_dragLastPos = x;
5004 }
5005
5006 return;
5007 }
5008
5009 m_isDragging = FALSE;
5010 m_startDragPos = wxDefaultPosition;
5011
5012 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
5013 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
5014 // wxGTK
5015 #if 0
5016 if ( event.Entering() || event.Leaving() )
5017 {
5018 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5019 m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
5020 }
5021 else
5022 #endif // 0
5023
5024 // ------------ Left button pressed
5025 //
5026 if ( event.LeftDown() && coords != wxGridNoCellCoords )
5027 {
5028 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
5029 coords.GetRow(),
5030 coords.GetCol(),
5031 event ) )
5032 {
5033 if ( !event.ControlDown() )
5034 ClearSelection();
5035 if ( event.ShiftDown() )
5036 {
5037 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
5038 m_currentCellCoords.GetCol(),
5039 coords.GetRow(),
5040 coords.GetCol(),
5041 event.ControlDown(),
5042 event.ShiftDown(),
5043 event.AltDown(),
5044 event.MetaDown() );
5045 }
5046 else if ( XToEdgeOfCol(x) < 0 &&
5047 YToEdgeOfRow(y) < 0 )
5048 {
5049 DisableCellEditControl();
5050 MakeCellVisible( coords );
5051
5052 // if this is the second click on this cell then start
5053 // the edit control
5054 if ( m_waitForSlowClick &&
5055 (coords == m_currentCellCoords) &&
5056 CanEnableCellControl())
5057 {
5058 EnableCellEditControl();
5059
5060 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5061 wxGridCellEditor *editor = attr->GetEditor(this,
5062 coords.GetRow(),
5063 coords.GetCol());
5064 editor->StartingClick();
5065 editor->DecRef();
5066 attr->DecRef();
5067
5068 m_waitForSlowClick = FALSE;
5069 }
5070 else
5071 {
5072 if ( event.ControlDown() )
5073 {
5074 m_selection->ToggleCellSelection( coords.GetRow(),
5075 coords.GetCol(),
5076 event.ControlDown(),
5077 event.ShiftDown(),
5078 event.AltDown(),
5079 event.MetaDown() );
5080 m_selectingTopLeft = wxGridNoCellCoords;
5081 m_selectingBottomRight = wxGridNoCellCoords;
5082 m_selectingKeyboard = coords;
5083 }
5084 else
5085 {
5086 SetCurrentCell( coords );
5087 if ( m_selection->GetSelectionMode()
5088 != wxGrid::wxGridSelectCells)
5089 HighlightBlock( coords, coords );
5090 }
5091 m_waitForSlowClick = TRUE;
5092 }
5093 }
5094 }
5095 }
5096
5097
5098 // ------------ Left double click
5099 //
5100 else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
5101 {
5102 DisableCellEditControl();
5103
5104 if ( XToEdgeOfCol(x) < 0 && YToEdgeOfRow(y) < 0 )
5105 {
5106 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
5107 coords.GetRow(),
5108 coords.GetCol(),
5109 event );
5110 }
5111 }
5112
5113
5114 // ------------ Left button released
5115 //
5116 else if ( event.LeftUp() )
5117 {
5118 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5119 {
5120 if ( m_selectingTopLeft != wxGridNoCellCoords &&
5121 m_selectingBottomRight != wxGridNoCellCoords )
5122 {
5123 if (m_winCapture)
5124 {
5125 m_winCapture->ReleaseMouse();
5126 m_winCapture = NULL;
5127 }
5128 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5129 m_selectingTopLeft.GetCol(),
5130 m_selectingBottomRight.GetRow(),
5131 m_selectingBottomRight.GetCol(),
5132 event.ControlDown(),
5133 event.ShiftDown(),
5134 event.AltDown(),
5135 event.MetaDown() );
5136 m_selectingTopLeft = wxGridNoCellCoords;
5137 m_selectingBottomRight = wxGridNoCellCoords;
5138 }
5139
5140 // Show the edit control, if it has been hidden for
5141 // drag-shrinking.
5142 ShowCellEditControl();
5143 }
5144 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5145 {
5146 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5147 DoEndDragResizeRow();
5148
5149 // Note: we are ending the event *after* doing
5150 // default processing in this case
5151 //
5152 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
5153 }
5154 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5155 {
5156 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5157 DoEndDragResizeCol();
5158
5159 // Note: we are ending the event *after* doing
5160 // default processing in this case
5161 //
5162 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5163 }
5164
5165 m_dragLastPos = -1;
5166 }
5167
5168
5169 // ------------ Right button down
5170 //
5171 else if ( event.RightDown() && coords != wxGridNoCellCoords )
5172 {
5173 DisableCellEditControl();
5174 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
5175 coords.GetRow(),
5176 coords.GetCol(),
5177 event ) )
5178 {
5179 // no default action at the moment
5180 }
5181 }
5182
5183
5184 // ------------ Right double click
5185 //
5186 else if ( event.RightDClick() && coords != wxGridNoCellCoords )
5187 {
5188 DisableCellEditControl();
5189 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
5190 coords.GetRow(),
5191 coords.GetCol(),
5192 event ) )
5193 {
5194 // no default action at the moment
5195 }
5196 }
5197
5198 // ------------ Moving and no button action
5199 //
5200 else if ( event.Moving() && !event.IsButton() )
5201 {
5202 int dragRow = YToEdgeOfRow( y );
5203 int dragCol = XToEdgeOfCol( x );
5204
5205 // Dragging on the corner of a cell to resize in both
5206 // directions is not implemented yet...
5207 //
5208 if ( dragRow >= 0 && dragCol >= 0 )
5209 {
5210 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5211 return;
5212 }
5213
5214 if ( dragRow >= 0 )
5215 {
5216 m_dragRowOrCol = dragRow;
5217
5218 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5219 {
5220 if ( CanDragRowSize() && CanDragGridSize() )
5221 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
5222 }
5223
5224 if ( dragCol >= 0 )
5225 {
5226 m_dragRowOrCol = dragCol;
5227 }
5228
5229 return;
5230 }
5231
5232 if ( dragCol >= 0 )
5233 {
5234 m_dragRowOrCol = dragCol;
5235
5236 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5237 {
5238 if ( CanDragColSize() && CanDragGridSize() )
5239 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
5240 }
5241
5242 return;
5243 }
5244
5245 // Neither on a row or col edge
5246 //
5247 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5248 {
5249 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5250 }
5251 }
5252 }
5253
5254
5255 void wxGrid::DoEndDragResizeRow()
5256 {
5257 if ( m_dragLastPos >= 0 )
5258 {
5259 // erase the last line and resize the row
5260 //
5261 int cw, ch, left, dummy;
5262 m_gridWin->GetClientSize( &cw, &ch );
5263 CalcUnscrolledPosition( 0, 0, &left, &dummy );
5264
5265 wxClientDC dc( m_gridWin );
5266 PrepareDC( dc );
5267 dc.SetLogicalFunction( wxINVERT );
5268 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5269 HideCellEditControl();
5270 SaveEditControlValue();
5271
5272 int rowTop = GetRowTop(m_dragRowOrCol);
5273 SetRowSize( m_dragRowOrCol,
5274 wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
5275
5276 if ( !GetBatchCount() )
5277 {
5278 // Only needed to get the correct rect.y:
5279 wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
5280 rect.x = 0;
5281 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5282 rect.width = m_rowLabelWidth;
5283 rect.height = ch - rect.y;
5284 m_rowLabelWin->Refresh( TRUE, &rect );
5285 rect.width = cw;
5286 m_gridWin->Refresh( FALSE, &rect );
5287 }
5288
5289 ShowCellEditControl();
5290 }
5291 }
5292
5293
5294 void wxGrid::DoEndDragResizeCol()
5295 {
5296 if ( m_dragLastPos >= 0 )
5297 {
5298 // erase the last line and resize the col
5299 //
5300 int cw, ch, dummy, top;
5301 m_gridWin->GetClientSize( &cw, &ch );
5302 CalcUnscrolledPosition( 0, 0, &dummy, &top );
5303
5304 wxClientDC dc( m_gridWin );
5305 PrepareDC( dc );
5306 dc.SetLogicalFunction( wxINVERT );
5307 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5308 HideCellEditControl();
5309 SaveEditControlValue();
5310
5311 int colLeft = GetColLeft(m_dragRowOrCol);
5312 SetColSize( m_dragRowOrCol,
5313 wxMax( m_dragLastPos - colLeft,
5314 GetColMinimalWidth(m_dragRowOrCol) ) );
5315
5316 if ( !GetBatchCount() )
5317 {
5318 // Only needed to get the correct rect.x:
5319 wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
5320 rect.y = 0;
5321 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5322 rect.width = cw - rect.x;
5323 rect.height = m_colLabelHeight;
5324 m_colLabelWin->Refresh( TRUE, &rect );
5325 rect.height = ch;
5326 m_gridWin->Refresh( FALSE, &rect );
5327 }
5328
5329 ShowCellEditControl();
5330 }
5331 }
5332
5333
5334
5335 //
5336 // ------ interaction with data model
5337 //
5338 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
5339 {
5340 switch ( msg.GetId() )
5341 {
5342 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
5343 return GetModelValues();
5344
5345 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
5346 return SetModelValues();
5347
5348 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
5349 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
5350 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
5351 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
5352 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
5353 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5354 return Redimension( msg );
5355
5356 default:
5357 return FALSE;
5358 }
5359 }
5360
5361
5362
5363 // The behaviour of this function depends on the grid table class
5364 // Clear() function. For the default wxGridStringTable class the
5365 // behavious is to replace all cell contents with wxEmptyString but
5366 // not to change the number of rows or cols.
5367 //
5368 void wxGrid::ClearGrid()
5369 {
5370 if ( m_table )
5371 {
5372 if (IsCellEditControlEnabled())
5373 DisableCellEditControl();
5374
5375 m_table->Clear();
5376 if ( !GetBatchCount() ) m_gridWin->Refresh();
5377 }
5378 }
5379
5380
5381 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5382 {
5383 // TODO: something with updateLabels flag
5384
5385 if ( !m_created )
5386 {
5387 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5388 return FALSE;
5389 }
5390
5391 if ( m_table )
5392 {
5393 if (IsCellEditControlEnabled())
5394 DisableCellEditControl();
5395
5396 return m_table->InsertRows( pos, numRows );
5397
5398 // the table will have sent the results of the insert row
5399 // operation to this view object as a grid table message
5400 }
5401 return FALSE;
5402 }
5403
5404
5405 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
5406 {
5407 // TODO: something with updateLabels flag
5408
5409 if ( !m_created )
5410 {
5411 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5412 return FALSE;
5413 }
5414
5415 return ( m_table && m_table->AppendRows( numRows ) );
5416 // the table will have sent the results of the append row
5417 // operation to this view object as a grid table message
5418 }
5419
5420
5421 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5422 {
5423 // TODO: something with updateLabels flag
5424
5425 if ( !m_created )
5426 {
5427 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5428 return FALSE;
5429 }
5430
5431 if ( m_table )
5432 {
5433 if (IsCellEditControlEnabled())
5434 DisableCellEditControl();
5435
5436 return (m_table->DeleteRows( pos, numRows ));
5437 // the table will have sent the results of the delete row
5438 // operation to this view object as a grid table message
5439 }
5440 return FALSE;
5441 }
5442
5443
5444 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5445 {
5446 // TODO: something with updateLabels flag
5447
5448 if ( !m_created )
5449 {
5450 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5451 return FALSE;
5452 }
5453
5454 if ( m_table )
5455 {
5456 if (IsCellEditControlEnabled())
5457 DisableCellEditControl();
5458
5459 return m_table->InsertCols( pos, numCols );
5460 // the table will have sent the results of the insert col
5461 // operation to this view object as a grid table message
5462 }
5463 return FALSE;
5464 }
5465
5466
5467 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
5468 {
5469 // TODO: something with updateLabels flag
5470
5471 if ( !m_created )
5472 {
5473 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5474 return FALSE;
5475 }
5476
5477 return ( m_table && m_table->AppendCols( numCols ) );
5478 // the table will have sent the results of the append col
5479 // operation to this view object as a grid table message
5480 }
5481
5482
5483 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5484 {
5485 // TODO: something with updateLabels flag
5486
5487 if ( !m_created )
5488 {
5489 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5490 return FALSE;
5491 }
5492
5493 if ( m_table )
5494 {
5495 if (IsCellEditControlEnabled())
5496 DisableCellEditControl();
5497
5498 return ( m_table->DeleteCols( pos, numCols ) );
5499 // the table will have sent the results of the delete col
5500 // operation to this view object as a grid table message
5501 }
5502 return FALSE;
5503 }
5504
5505
5506
5507 //
5508 // ----- event handlers
5509 //
5510
5511 // Generate a grid event based on a mouse event and
5512 // return the result of ProcessEvent()
5513 //
5514 int wxGrid::SendEvent( const wxEventType type,
5515 int row, int col,
5516 wxMouseEvent& mouseEv )
5517 {
5518 bool claimed;
5519 bool vetoed= FALSE;
5520
5521 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5522 {
5523 int rowOrCol = (row == -1 ? col : row);
5524
5525 wxGridSizeEvent gridEvt( GetId(),
5526 type,
5527 this,
5528 rowOrCol,
5529 mouseEv.GetX() + GetRowLabelSize(),
5530 mouseEv.GetY() + GetColLabelSize(),
5531 mouseEv.ControlDown(),
5532 mouseEv.ShiftDown(),
5533 mouseEv.AltDown(),
5534 mouseEv.MetaDown() );
5535
5536 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5537 vetoed = !gridEvt.IsAllowed();
5538 }
5539 else if ( type == wxEVT_GRID_RANGE_SELECT )
5540 {
5541 // Right now, it should _never_ end up here!
5542 wxGridRangeSelectEvent gridEvt( GetId(),
5543 type,
5544 this,
5545 m_selectingTopLeft,
5546 m_selectingBottomRight,
5547 TRUE,
5548 mouseEv.ControlDown(),
5549 mouseEv.ShiftDown(),
5550 mouseEv.AltDown(),
5551 mouseEv.MetaDown() );
5552
5553 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5554 vetoed = !gridEvt.IsAllowed();
5555 }
5556 else
5557 {
5558 wxGridEvent gridEvt( GetId(),
5559 type,
5560 this,
5561 row, col,
5562 mouseEv.GetX() + GetRowLabelSize(),
5563 mouseEv.GetY() + GetColLabelSize(),
5564 FALSE,
5565 mouseEv.ControlDown(),
5566 mouseEv.ShiftDown(),
5567 mouseEv.AltDown(),
5568 mouseEv.MetaDown() );
5569 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5570 vetoed = !gridEvt.IsAllowed();
5571 }
5572
5573 // A Veto'd event may not be `claimed' so test this first
5574 if (vetoed) return -1;
5575 return claimed ? 1 : 0;
5576 }
5577
5578
5579 // Generate a grid event of specified type and return the result
5580 // of ProcessEvent().
5581 //
5582 int wxGrid::SendEvent( const wxEventType type,
5583 int row, int col )
5584 {
5585 bool claimed;
5586 bool vetoed= FALSE;
5587
5588 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5589 {
5590 int rowOrCol = (row == -1 ? col : row);
5591
5592 wxGridSizeEvent gridEvt( GetId(),
5593 type,
5594 this,
5595 rowOrCol );
5596
5597 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5598 vetoed = !gridEvt.IsAllowed();
5599 }
5600 else
5601 {
5602 wxGridEvent gridEvt( GetId(),
5603 type,
5604 this,
5605 row, col );
5606
5607 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5608 vetoed = !gridEvt.IsAllowed();
5609 }
5610
5611 // A Veto'd event may not be `claimed' so test this first
5612 if (vetoed) return -1;
5613 return claimed ? 1 : 0;
5614 }
5615
5616
5617 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
5618 {
5619 wxPaintDC dc(this); // needed to prevent zillions of paint events on MSW
5620 }
5621
5622
5623 void wxGrid::OnSize( wxSizeEvent& event )
5624 {
5625 // position the child windows
5626 CalcWindowSizes();
5627
5628 // don't call CalcDimensions() from here, the base class handles the size
5629 // changes itself
5630 event.Skip();
5631 }
5632
5633
5634 void wxGrid::OnKeyDown( wxKeyEvent& event )
5635 {
5636 if ( m_inOnKeyDown )
5637 {
5638 // shouldn't be here - we are going round in circles...
5639 //
5640 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
5641 }
5642
5643 m_inOnKeyDown = TRUE;
5644
5645 // propagate the event up and see if it gets processed
5646 //
5647 wxWindow *parent = GetParent();
5648 wxKeyEvent keyEvt( event );
5649 keyEvt.SetEventObject( parent );
5650
5651 if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
5652 {
5653
5654 // try local handlers
5655 //
5656 switch ( event.KeyCode() )
5657 {
5658 case WXK_UP:
5659 if ( event.ControlDown() )
5660 {
5661 MoveCursorUpBlock( event.ShiftDown() );
5662 }
5663 else
5664 {
5665 MoveCursorUp( event.ShiftDown() );
5666 }
5667 break;
5668
5669 case WXK_DOWN:
5670 if ( event.ControlDown() )
5671 {
5672 MoveCursorDownBlock( event.ShiftDown() );
5673 }
5674 else
5675 {
5676 MoveCursorDown( event.ShiftDown() );
5677 }
5678 break;
5679
5680 case WXK_LEFT:
5681 if ( event.ControlDown() )
5682 {
5683 MoveCursorLeftBlock( event.ShiftDown() );
5684 }
5685 else
5686 {
5687 MoveCursorLeft( event.ShiftDown() );
5688 }
5689 break;
5690
5691 case WXK_RIGHT:
5692 if ( event.ControlDown() )
5693 {
5694 MoveCursorRightBlock( event.ShiftDown() );
5695 }
5696 else
5697 {
5698 MoveCursorRight( event.ShiftDown() );
5699 }
5700 break;
5701
5702 case WXK_RETURN:
5703 case WXK_NUMPAD_ENTER:
5704 if ( event.ControlDown() )
5705 {
5706 event.Skip(); // to let the edit control have the return
5707 }
5708 else
5709 {
5710 if ( GetGridCursorRow() < GetNumberRows()-1 )
5711 {
5712 MoveCursorDown( event.ShiftDown() );
5713 }
5714 else
5715 {
5716 // at the bottom of a column
5717 HideCellEditControl();
5718 SaveEditControlValue();
5719 }
5720 }
5721 break;
5722
5723 case WXK_ESCAPE:
5724 ClearSelection();
5725 break;
5726
5727 case WXK_TAB:
5728 if (event.ShiftDown())
5729 {
5730 if ( GetGridCursorCol() > 0 )
5731 {
5732 MoveCursorLeft( FALSE );
5733 }
5734 else
5735 {
5736 // at left of grid
5737 HideCellEditControl();
5738 SaveEditControlValue();
5739 }
5740 }
5741 else
5742 {
5743 if ( GetGridCursorCol() < GetNumberCols()-1 )
5744 {
5745 MoveCursorRight( FALSE );
5746 }
5747 else
5748 {
5749 // at right of grid
5750 HideCellEditControl();
5751 SaveEditControlValue();
5752 }
5753 }
5754 break;
5755
5756 case WXK_HOME:
5757 if ( event.ControlDown() )
5758 {
5759 MakeCellVisible( 0, 0 );
5760 SetCurrentCell( 0, 0 );
5761 }
5762 else
5763 {
5764 event.Skip();
5765 }
5766 break;
5767
5768 case WXK_END:
5769 if ( event.ControlDown() )
5770 {
5771 MakeCellVisible( m_numRows-1, m_numCols-1 );
5772 SetCurrentCell( m_numRows-1, m_numCols-1 );
5773 }
5774 else
5775 {
5776 event.Skip();
5777 }
5778 break;
5779
5780 case WXK_PRIOR:
5781 MovePageUp();
5782 break;
5783
5784 case WXK_NEXT:
5785 MovePageDown();
5786 break;
5787
5788 case WXK_SPACE:
5789 if ( event.ControlDown() )
5790 {
5791 m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
5792 m_currentCellCoords.GetCol(),
5793 event.ControlDown(),
5794 event.ShiftDown(),
5795 event.AltDown(),
5796 event.MetaDown() );
5797 break;
5798 }
5799 if ( !IsEditable() )
5800 {
5801 MoveCursorRight( FALSE );
5802 break;
5803 }
5804 // Otherwise fall through to default
5805
5806 default:
5807 // is it possible to edit the current cell at all?
5808 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
5809 {
5810 // yes, now check whether the cells editor accepts the key
5811 int row = m_currentCellCoords.GetRow();
5812 int col = m_currentCellCoords.GetCol();
5813 wxGridCellAttr* attr = GetCellAttr(row, col);
5814 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5815
5816 // <F2> is special and will always start editing, for
5817 // other keys - ask the editor itself
5818 if ( (event.KeyCode() == WXK_F2 && !event.HasModifiers())
5819 || editor->IsAcceptedKey(event) )
5820 {
5821 EnableCellEditControl();
5822 editor->StartingKey(event);
5823 }
5824 else
5825 {
5826 event.Skip();
5827 }
5828
5829 editor->DecRef();
5830 attr->DecRef();
5831 }
5832 else
5833 {
5834 // let others process char events with modifiers or all
5835 // char events for readonly cells
5836 event.Skip();
5837 }
5838 break;
5839 }
5840 }
5841
5842 m_inOnKeyDown = FALSE;
5843 }
5844
5845 void wxGrid::OnKeyUp( wxKeyEvent& event )
5846 {
5847 // try local handlers
5848 //
5849 if ( event.KeyCode() == WXK_SHIFT )
5850 {
5851 if ( m_selectingTopLeft != wxGridNoCellCoords &&
5852 m_selectingBottomRight != wxGridNoCellCoords )
5853 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5854 m_selectingTopLeft.GetCol(),
5855 m_selectingBottomRight.GetRow(),
5856 m_selectingBottomRight.GetCol(),
5857 event.ControlDown(),
5858 TRUE,
5859 event.AltDown(),
5860 event.MetaDown() );
5861 m_selectingTopLeft = wxGridNoCellCoords;
5862 m_selectingBottomRight = wxGridNoCellCoords;
5863 m_selectingKeyboard = wxGridNoCellCoords;
5864 }
5865 }
5866
5867 void wxGrid::OnEraseBackground(wxEraseEvent&)
5868 {
5869 }
5870
5871 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
5872 {
5873 if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
5874 {
5875 // the event has been intercepted - do nothing
5876 return;
5877 }
5878
5879 wxClientDC dc(m_gridWin);
5880 PrepareDC(dc);
5881
5882 if ( m_currentCellCoords != wxGridNoCellCoords )
5883 {
5884 HideCellEditControl();
5885 DisableCellEditControl();
5886
5887 if ( IsVisible( m_currentCellCoords, FALSE ) )
5888 {
5889 wxRect r;
5890 r = BlockToDeviceRect(m_currentCellCoords, coords);
5891 if ( !m_gridLinesEnabled )
5892 {
5893 r.x--;
5894 r.y--;
5895 r.width++;
5896 r.height++;
5897 }
5898
5899 wxGridCellCoordsArray cells = CalcCellsExposed( r );
5900
5901 // Otherwise refresh redraws the highlight!
5902 m_currentCellCoords = coords;
5903
5904 DrawGridCellArea(dc,cells);
5905 DrawAllGridLines( dc, r );
5906 }
5907 }
5908
5909 m_currentCellCoords = coords;
5910
5911 wxGridCellAttr* attr = GetCellAttr(coords);
5912 DrawCellHighlight(dc, attr);
5913 attr->DecRef();
5914 }
5915
5916
5917 void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
5918 {
5919 int temp;
5920 wxGridCellCoords updateTopLeft, updateBottomRight;
5921
5922 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
5923 {
5924 leftCol = 0;
5925 rightCol = GetNumberCols() - 1;
5926 }
5927 else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
5928 {
5929 topRow = 0;
5930 bottomRow = GetNumberRows() - 1;
5931 }
5932 if ( topRow > bottomRow )
5933 {
5934 temp = topRow;
5935 topRow = bottomRow;
5936 bottomRow = temp;
5937 }
5938
5939 if ( leftCol > rightCol )
5940 {
5941 temp = leftCol;
5942 leftCol = rightCol;
5943 rightCol = temp;
5944 }
5945
5946 updateTopLeft = wxGridCellCoords( topRow, leftCol );
5947 updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
5948
5949 if ( m_selectingTopLeft != updateTopLeft ||
5950 m_selectingBottomRight != updateBottomRight )
5951 {
5952 // Compute two optimal update rectangles:
5953 // Either one rectangle is a real subset of the
5954 // other, or they are (almost) disjoint!
5955 wxRect rect[4];
5956 bool need_refresh[4];
5957 need_refresh[0] =
5958 need_refresh[1] =
5959 need_refresh[2] =
5960 need_refresh[3] = FALSE;
5961 int i;
5962
5963 // Store intermediate values
5964 wxCoord oldLeft = m_selectingTopLeft.GetCol();
5965 wxCoord oldTop = m_selectingTopLeft.GetRow();
5966 wxCoord oldRight = m_selectingBottomRight.GetCol();
5967 wxCoord oldBottom = m_selectingBottomRight.GetRow();
5968
5969 // Determine the outer/inner coordinates.
5970 if (oldLeft > leftCol)
5971 {
5972 temp = oldLeft;
5973 oldLeft = leftCol;
5974 leftCol = temp;
5975 }
5976 if (oldTop > topRow )
5977 {
5978 temp = oldTop;
5979 oldTop = topRow;
5980 topRow = temp;
5981 }
5982 if (oldRight < rightCol )
5983 {
5984 temp = oldRight;
5985 oldRight = rightCol;
5986 rightCol = temp;
5987 }
5988 if (oldBottom < bottomRow)
5989 {
5990 temp = oldBottom;
5991 oldBottom = bottomRow;
5992 bottomRow = temp;
5993 }
5994
5995 // Now, either the stuff marked old is the outer
5996 // rectangle or we don't have a situation where one
5997 // is contained in the other.
5998
5999 if ( oldLeft < leftCol )
6000 {
6001 need_refresh[0] = TRUE;
6002 rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6003 oldLeft ),
6004 wxGridCellCoords ( oldBottom,
6005 leftCol - 1 ) );
6006 }
6007
6008 if ( oldTop < topRow )
6009 {
6010 need_refresh[1] = TRUE;
6011 rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6012 leftCol ),
6013 wxGridCellCoords ( topRow - 1,
6014 rightCol ) );
6015 }
6016
6017 if ( oldRight > rightCol )
6018 {
6019 need_refresh[2] = TRUE;
6020 rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6021 rightCol + 1 ),
6022 wxGridCellCoords ( oldBottom,
6023 oldRight ) );
6024 }
6025
6026 if ( oldBottom > bottomRow )
6027 {
6028 need_refresh[3] = TRUE;
6029 rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
6030 leftCol ),
6031 wxGridCellCoords ( oldBottom,
6032 rightCol ) );
6033 }
6034
6035
6036 // Change Selection
6037 m_selectingTopLeft = updateTopLeft;
6038 m_selectingBottomRight = updateBottomRight;
6039
6040 // various Refresh() calls
6041 for (i = 0; i < 4; i++ )
6042 if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6043 m_gridWin->Refresh( FALSE, &(rect[i]) );
6044 }
6045
6046 // never generate an event as it will be generated from
6047 // wxGridSelection::SelectBlock!
6048 // (old comment from when this was the body of SelectBlock)
6049 }
6050
6051 //
6052 // ------ functions to get/send data (see also public functions)
6053 //
6054
6055 bool wxGrid::GetModelValues()
6056 {
6057 if ( m_table )
6058 {
6059 // all we need to do is repaint the grid
6060 //
6061 m_gridWin->Refresh();
6062 return TRUE;
6063 }
6064
6065 return FALSE;
6066 }
6067
6068
6069 bool wxGrid::SetModelValues()
6070 {
6071 int row, col;
6072
6073 if ( m_table )
6074 {
6075 for ( row = 0; row < m_numRows; row++ )
6076 {
6077 for ( col = 0; col < m_numCols; col++ )
6078 {
6079 m_table->SetValue( row, col, GetCellValue(row, col) );
6080 }
6081 }
6082
6083 return TRUE;
6084 }
6085
6086 return FALSE;
6087 }
6088
6089
6090
6091 // Note - this function only draws cells that are in the list of
6092 // exposed cells (usually set from the update region by
6093 // CalcExposedCells)
6094 //
6095 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
6096 {
6097 if ( !m_numRows || !m_numCols ) return;
6098
6099 size_t i;
6100 size_t numCells = cells.GetCount();
6101
6102 for ( i = 0; i < numCells; i++ )
6103 {
6104 DrawCell( dc, cells[i] );
6105 }
6106 }
6107
6108
6109 void wxGrid::DrawGridSpace( wxDC& dc )
6110 {
6111 int cw, ch;
6112 m_gridWin->GetClientSize( &cw, &ch );
6113
6114 int right, bottom;
6115 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6116
6117 int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
6118 int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
6119
6120 if ( right > rightCol || bottom > bottomRow )
6121 {
6122 int left, top;
6123 CalcUnscrolledPosition( 0, 0, &left, &top );
6124
6125 dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
6126 dc.SetPen( *wxTRANSPARENT_PEN );
6127
6128 if ( right > rightCol )
6129 {
6130 dc.DrawRectangle( rightCol, top, right - rightCol, ch);
6131 }
6132
6133 if ( bottom > bottomRow )
6134 {
6135 dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
6136 }
6137 }
6138 }
6139
6140
6141 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
6142 {
6143 int row = coords.GetRow();
6144 int col = coords.GetCol();
6145
6146 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6147 return;
6148
6149 // we draw the cell border ourselves
6150 #if !WXGRID_DRAW_LINES
6151 if ( m_gridLinesEnabled )
6152 DrawCellBorder( dc, coords );
6153 #endif
6154
6155 wxGridCellAttr* attr = GetCellAttr(row, col);
6156
6157 bool isCurrent = coords == m_currentCellCoords;
6158
6159 wxRect rect = CellToRect( row, col );
6160
6161 // if the editor is shown, we should use it and not the renderer
6162 // Note: However, only if it is really _shown_, i.e. not hidden!
6163 if ( isCurrent && IsCellEditControlShown() )
6164 {
6165 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6166 editor->PaintBackground(rect, attr);
6167 editor->DecRef();
6168 }
6169 else
6170 {
6171 // but all the rest is drawn by the cell renderer and hence may be
6172 // customized
6173 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
6174 renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
6175 renderer->DecRef();
6176 }
6177
6178 attr->DecRef();
6179 }
6180
6181 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
6182 {
6183 int row = m_currentCellCoords.GetRow();
6184 int col = m_currentCellCoords.GetCol();
6185
6186 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6187 return;
6188
6189 wxRect rect = CellToRect(row, col);
6190
6191 // hmmm... what could we do here to show that the cell is disabled?
6192 // for now, I just draw a thinner border than for the other ones, but
6193 // it doesn't look really good
6194
6195 int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
6196
6197 if (penWidth > 0) {
6198
6199 // The center of th drawn line is where the position/width/height of
6200 // the rectangle is actually at, (on wxMSW atr least,) so we will
6201 // reduce the size of the rectangle to compensate for the thickness of
6202 // the line. If this is too strange on non wxMSW platforms then
6203 // please #ifdef this appropriately.
6204 rect.x += penWidth/2;
6205 rect.y += penWidth/2;
6206 rect.width -= penWidth-1;
6207 rect.height -= penWidth-1;
6208
6209
6210 // Now draw the rectangle
6211 dc.SetPen(wxPen(m_cellHighlightColour, penWidth, wxSOLID));
6212 dc.SetBrush(*wxTRANSPARENT_BRUSH);
6213 dc.DrawRectangle(rect);
6214 }
6215
6216 #if 0
6217 // VZ: my experiments with 3d borders...
6218
6219 // how to properly set colours for arbitrary bg?
6220 wxCoord x1 = rect.x,
6221 y1 = rect.y,
6222 x2 = rect.x + rect.width -1,
6223 y2 = rect.y + rect.height -1;
6224
6225 dc.SetPen(*wxWHITE_PEN);
6226 dc.DrawLine(x1, y1, x2, y1);
6227 dc.DrawLine(x1, y1, x1, y2);
6228
6229 dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
6230 dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
6231
6232 dc.SetPen(*wxBLACK_PEN);
6233 dc.DrawLine(x1, y2, x2, y2);
6234 dc.DrawLine(x2, y1, x2, y2+1);
6235 #endif // 0
6236 }
6237
6238
6239 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
6240 {
6241 int row = coords.GetRow();
6242 int col = coords.GetCol();
6243 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6244 return;
6245
6246 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6247
6248 // right hand border
6249 //
6250 dc.DrawLine( GetColRight(col), GetRowTop(row),
6251 GetColRight(col), GetRowBottom(row) );
6252
6253 // bottom border
6254 //
6255 dc.DrawLine( GetColLeft(col), GetRowBottom(row),
6256 GetColRight(col), GetRowBottom(row) );
6257 }
6258
6259 void wxGrid::DrawHighlight(wxDC& dc,const wxGridCellCoordsArray& cells)
6260 {
6261 // This if block was previously in wxGrid::OnPaint but that doesn't
6262 // seem to get called under wxGTK - MB
6263 //
6264 if ( m_currentCellCoords == wxGridNoCellCoords &&
6265 m_numRows && m_numCols )
6266 {
6267 m_currentCellCoords.Set(0, 0);
6268 }
6269
6270 if ( IsCellEditControlShown() )
6271 {
6272 // don't show highlight when the edit control is shown
6273 return;
6274 }
6275
6276 // if the active cell was repainted, repaint its highlight too because it
6277 // might have been damaged by the grid lines
6278 size_t count = cells.GetCount();
6279 for ( size_t n = 0; n < count; n++ )
6280 {
6281 if ( cells[n] == m_currentCellCoords )
6282 {
6283 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6284 DrawCellHighlight(dc, attr);
6285 attr->DecRef();
6286
6287 break;
6288 }
6289 }
6290 }
6291
6292 // TODO: remove this ???
6293 // This is used to redraw all grid lines e.g. when the grid line colour
6294 // has been changed
6295 //
6296 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
6297 {
6298 if ( !m_gridLinesEnabled ||
6299 !m_numRows ||
6300 !m_numCols ) return;
6301
6302 int top, bottom, left, right;
6303
6304 #if 0 //#ifndef __WXGTK__
6305 if (reg.IsEmpty())
6306 {
6307 int cw, ch;
6308 m_gridWin->GetClientSize(&cw, &ch);
6309
6310 // virtual coords of visible area
6311 //
6312 CalcUnscrolledPosition( 0, 0, &left, &top );
6313 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6314 }
6315 else
6316 {
6317 wxCoord x, y, w, h;
6318 reg.GetBox(x, y, w, h);
6319 CalcUnscrolledPosition( x, y, &left, &top );
6320 CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
6321 }
6322 #else
6323 int cw, ch;
6324 m_gridWin->GetClientSize(&cw, &ch);
6325 CalcUnscrolledPosition( 0, 0, &left, &top );
6326 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6327 #endif
6328
6329 // avoid drawing grid lines past the last row and col
6330 //
6331 right = wxMin( right, GetColRight(m_numCols - 1) );
6332 bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
6333
6334 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6335
6336 // horizontal grid lines
6337 //
6338 int i;
6339 for ( i = 0; i < m_numRows; i++ )
6340 {
6341 int bot = GetRowBottom(i) - 1;
6342
6343 if ( bot > bottom )
6344 {
6345 break;
6346 }
6347
6348 if ( bot >= top )
6349 {
6350 dc.DrawLine( left, bot, right, bot );
6351 }
6352 }
6353
6354
6355 // vertical grid lines
6356 //
6357 for ( i = 0; i < m_numCols; i++ )
6358 {
6359 int colRight = GetColRight(i) - 1;
6360 if ( colRight > right )
6361 {
6362 break;
6363 }
6364
6365 if ( colRight >= left )
6366 {
6367 dc.DrawLine( colRight, top, colRight, bottom );
6368 }
6369 }
6370 }
6371
6372
6373 void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
6374 {
6375 if ( !m_numRows ) return;
6376
6377 size_t i;
6378 size_t numLabels = rows.GetCount();
6379
6380 for ( i = 0; i < numLabels; i++ )
6381 {
6382 DrawRowLabel( dc, rows[i] );
6383 }
6384 }
6385
6386
6387 void wxGrid::DrawRowLabel( wxDC& dc, int row )
6388 {
6389 if ( GetRowHeight(row) <= 0 )
6390 return;
6391
6392 int rowTop = GetRowTop(row),
6393 rowBottom = GetRowBottom(row) - 1;
6394
6395 dc.SetPen( *wxBLACK_PEN );
6396 dc.DrawLine( m_rowLabelWidth-1, rowTop,
6397 m_rowLabelWidth-1, rowBottom );
6398
6399 dc.DrawLine( 0, rowBottom, m_rowLabelWidth-1, rowBottom );
6400
6401 dc.SetPen( *wxWHITE_PEN );
6402 dc.DrawLine( 0, rowTop, 0, rowBottom );
6403 dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
6404
6405 dc.SetBackgroundMode( wxTRANSPARENT );
6406 dc.SetTextForeground( GetLabelTextColour() );
6407 dc.SetFont( GetLabelFont() );
6408
6409 int hAlign, vAlign;
6410 GetRowLabelAlignment( &hAlign, &vAlign );
6411
6412 wxRect rect;
6413 rect.SetX( 2 );
6414 rect.SetY( GetRowTop(row) + 2 );
6415 rect.SetWidth( m_rowLabelWidth - 4 );
6416 rect.SetHeight( GetRowHeight(row) - 4 );
6417 DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
6418 }
6419
6420
6421 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
6422 {
6423 if ( !m_numCols ) return;
6424
6425 size_t i;
6426 size_t numLabels = cols.GetCount();
6427
6428 for ( i = 0; i < numLabels; i++ )
6429 {
6430 DrawColLabel( dc, cols[i] );
6431 }
6432 }
6433
6434
6435 void wxGrid::DrawColLabel( wxDC& dc, int col )
6436 {
6437 if ( GetColWidth(col) <= 0 )
6438 return;
6439
6440 int colLeft = GetColLeft(col),
6441 colRight = GetColRight(col) - 1;
6442
6443 dc.SetPen( *wxBLACK_PEN );
6444 dc.DrawLine( colRight, 0,
6445 colRight, m_colLabelHeight-1 );
6446
6447 dc.DrawLine( colLeft, m_colLabelHeight-1,
6448 colRight, m_colLabelHeight-1 );
6449
6450 dc.SetPen( *wxWHITE_PEN );
6451 dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
6452 dc.DrawLine( colLeft, 0, colRight, 0 );
6453
6454 dc.SetBackgroundMode( wxTRANSPARENT );
6455 dc.SetTextForeground( GetLabelTextColour() );
6456 dc.SetFont( GetLabelFont() );
6457
6458 dc.SetBackgroundMode( wxTRANSPARENT );
6459 dc.SetTextForeground( GetLabelTextColour() );
6460 dc.SetFont( GetLabelFont() );
6461
6462 int hAlign, vAlign;
6463 GetColLabelAlignment( &hAlign, &vAlign );
6464
6465 wxRect rect;
6466 rect.SetX( colLeft + 2 );
6467 rect.SetY( 2 );
6468 rect.SetWidth( GetColWidth(col) - 4 );
6469 rect.SetHeight( m_colLabelHeight - 4 );
6470 DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
6471 }
6472
6473 void wxGrid::DrawTextRectangle( wxDC& dc,
6474 const wxString& value,
6475 const wxRect& rect,
6476 int horizAlign,
6477 int vertAlign )
6478 {
6479 wxArrayString lines;
6480
6481 dc.SetClippingRegion( rect );
6482 StringToLines( value, lines );
6483
6484
6485 //Forward to new API.
6486 DrawTextRectangle( dc,
6487 lines,
6488 rect,
6489 horizAlign,
6490 vertAlign );
6491
6492 }
6493
6494 void wxGrid::DrawTextRectangle( wxDC& dc,
6495 const wxArrayString& lines,
6496 const wxRect& rect,
6497 int horizAlign,
6498 int vertAlign )
6499 {
6500 long textWidth, textHeight;
6501 long lineWidth, lineHeight;
6502
6503 if ( lines.GetCount() )
6504 {
6505 GetTextBoxSize( dc, lines, &textWidth, &textHeight );
6506 dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
6507
6508 float x, y;
6509 switch ( horizAlign )
6510 {
6511 case wxALIGN_RIGHT:
6512 x = rect.x + (rect.width - textWidth - 1);
6513 break;
6514
6515 case wxALIGN_CENTRE:
6516 x = rect.x + ((rect.width - textWidth)/2);
6517 break;
6518
6519 case wxALIGN_LEFT:
6520 default:
6521 x = rect.x + 1;
6522 break;
6523 }
6524
6525 switch ( vertAlign )
6526 {
6527 case wxALIGN_BOTTOM:
6528 y = rect.y + (rect.height - textHeight - 1);
6529 break;
6530
6531 case wxALIGN_CENTRE:
6532 y = rect.y + ((rect.height - textHeight)/2);
6533 break;
6534
6535 case wxALIGN_TOP:
6536 default:
6537 y = rect.y + 1;
6538 break;
6539 }
6540
6541 for ( size_t i = 0; i < lines.GetCount(); i++ )
6542 {
6543 dc.DrawText( lines[i], (int)x, (int)y );
6544 y += lineHeight;
6545 }
6546 }
6547
6548 dc.DestroyClippingRegion();
6549 }
6550
6551
6552 // Split multi line text up into an array of strings. Any existing
6553 // contents of the string array are preserved.
6554 //
6555 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
6556 {
6557 int startPos = 0;
6558 int pos;
6559 wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
6560 wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
6561
6562 while ( startPos < (int)tVal.Length() )
6563 {
6564 pos = tVal.Mid(startPos).Find( eol );
6565 if ( pos < 0 )
6566 {
6567 break;
6568 }
6569 else if ( pos == 0 )
6570 {
6571 lines.Add( wxEmptyString );
6572 }
6573 else
6574 {
6575 lines.Add( value.Mid(startPos, pos) );
6576 }
6577 startPos += pos+1;
6578 }
6579 if ( startPos < (int)value.Length() )
6580 {
6581 lines.Add( value.Mid( startPos ) );
6582 }
6583 }
6584
6585
6586 void wxGrid::GetTextBoxSize( wxDC& dc,
6587 const wxArrayString& lines,
6588 long *width, long *height )
6589 {
6590 long w = 0;
6591 long h = 0;
6592 long lineW, lineH;
6593
6594 size_t i;
6595 for ( i = 0; i < lines.GetCount(); i++ )
6596 {
6597 dc.GetTextExtent( lines[i], &lineW, &lineH );
6598 w = wxMax( w, lineW );
6599 h += lineH;
6600 }
6601
6602 *width = w;
6603 *height = h;
6604 }
6605
6606 //
6607 // ------ Batch processing.
6608 //
6609 void wxGrid::EndBatch()
6610 {
6611 if ( m_batchCount > 0 )
6612 {
6613 m_batchCount--;
6614 if ( !m_batchCount )
6615 {
6616 CalcDimensions();
6617 m_rowLabelWin->Refresh();
6618 m_colLabelWin->Refresh();
6619 m_cornerLabelWin->Refresh();
6620 m_gridWin->Refresh();
6621 }
6622 }
6623 }
6624
6625 // Use this, rather than wxWindow::Refresh(), to force an immediate
6626 // repainting of the grid. Has no effect if you are already inside a
6627 // BeginBatch / EndBatch block.
6628 //
6629 void wxGrid::ForceRefresh()
6630 {
6631 BeginBatch();
6632 EndBatch();
6633 }
6634
6635
6636 //
6637 // ------ Edit control functions
6638 //
6639
6640
6641 void wxGrid::EnableEditing( bool edit )
6642 {
6643 // TODO: improve this ?
6644 //
6645 if ( edit != m_editable )
6646 {
6647 if(!edit) EnableCellEditControl(edit);
6648 m_editable = edit;
6649 }
6650 }
6651
6652
6653 void wxGrid::EnableCellEditControl( bool enable )
6654 {
6655 if (! m_editable)
6656 return;
6657
6658 if ( m_currentCellCoords == wxGridNoCellCoords )
6659 SetCurrentCell( 0, 0 );
6660
6661 if ( enable != m_cellEditCtrlEnabled )
6662 {
6663 if ( enable )
6664 {
6665 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
6666 return;
6667
6668 // this should be checked by the caller!
6669 wxASSERT_MSG( CanEnableCellControl(),
6670 _T("can't enable editing for this cell!") );
6671
6672 // do it before ShowCellEditControl()
6673 m_cellEditCtrlEnabled = enable;
6674
6675 ShowCellEditControl();
6676 }
6677 else
6678 {
6679 //FIXME:add veto support
6680 SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
6681
6682 HideCellEditControl();
6683 SaveEditControlValue();
6684
6685 // do it after HideCellEditControl()
6686 m_cellEditCtrlEnabled = enable;
6687 }
6688 }
6689 }
6690
6691 bool wxGrid::IsCurrentCellReadOnly() const
6692 {
6693 // const_cast
6694 wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
6695 bool readonly = attr->IsReadOnly();
6696 attr->DecRef();
6697
6698 return readonly;
6699 }
6700
6701 bool wxGrid::CanEnableCellControl() const
6702 {
6703 return m_editable && !IsCurrentCellReadOnly();
6704 }
6705
6706 bool wxGrid::IsCellEditControlEnabled() const
6707 {
6708 // the cell edit control might be disable for all cells or just for the
6709 // current one if it's read only
6710 return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
6711 }
6712
6713 bool wxGrid::IsCellEditControlShown() const
6714 {
6715 bool isShown = FALSE;
6716
6717 if ( m_cellEditCtrlEnabled )
6718 {
6719 int row = m_currentCellCoords.GetRow();
6720 int col = m_currentCellCoords.GetCol();
6721 wxGridCellAttr* attr = GetCellAttr(row, col);
6722 wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
6723 attr->DecRef();
6724
6725 if ( editor )
6726 {
6727 if ( editor->IsCreated() )
6728 {
6729 isShown = editor->GetControl()->IsShown();
6730 }
6731
6732 editor->DecRef();
6733 }
6734 }
6735
6736 return isShown;
6737 }
6738
6739 void wxGrid::ShowCellEditControl()
6740 {
6741 if ( IsCellEditControlEnabled() )
6742 {
6743 if ( !IsVisible( m_currentCellCoords ) )
6744 {
6745 m_cellEditCtrlEnabled = FALSE;
6746 return;
6747 }
6748 else
6749 {
6750 wxRect rect = CellToRect( m_currentCellCoords );
6751 int row = m_currentCellCoords.GetRow();
6752 int col = m_currentCellCoords.GetCol();
6753
6754 // convert to scrolled coords
6755 //
6756 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
6757
6758 // done in PaintBackground()
6759 #if 0
6760 // erase the highlight and the cell contents because the editor
6761 // might not cover the entire cell
6762 wxClientDC dc( m_gridWin );
6763 PrepareDC( dc );
6764 dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
6765 dc.SetPen(*wxTRANSPARENT_PEN);
6766 dc.DrawRectangle(rect);
6767 #endif // 0
6768
6769 // cell is shifted by one pixel
6770 rect.x--;
6771 rect.y--;
6772
6773 wxGridCellAttr* attr = GetCellAttr(row, col);
6774 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6775 if ( !editor->IsCreated() )
6776 {
6777 editor->Create(m_gridWin, -1,
6778 new wxGridCellEditorEvtHandler(this, editor));
6779
6780 wxGridEditorCreatedEvent evt(GetId(),
6781 wxEVT_GRID_EDITOR_CREATED,
6782 this,
6783 row,
6784 col,
6785 editor->GetControl());
6786 GetEventHandler()->ProcessEvent(evt);
6787 }
6788
6789 editor->Show( TRUE, attr );
6790
6791 editor->SetSize( rect );
6792
6793 editor->BeginEdit(row, col, this);
6794
6795 editor->DecRef();
6796 attr->DecRef();
6797 }
6798 }
6799 }
6800
6801
6802 void wxGrid::HideCellEditControl()
6803 {
6804 if ( IsCellEditControlEnabled() )
6805 {
6806 int row = m_currentCellCoords.GetRow();
6807 int col = m_currentCellCoords.GetCol();
6808
6809 wxGridCellAttr* attr = GetCellAttr(row, col);
6810 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6811 editor->Show( FALSE );
6812 editor->DecRef();
6813 attr->DecRef();
6814 m_gridWin->SetFocus();
6815 wxRect rect( CellToRect( row, col ) );
6816 m_gridWin->Refresh( FALSE, &rect );
6817 }
6818 }
6819
6820
6821 void wxGrid::SaveEditControlValue()
6822 {
6823 if ( IsCellEditControlEnabled() )
6824 {
6825 int row = m_currentCellCoords.GetRow();
6826 int col = m_currentCellCoords.GetCol();
6827
6828 wxString oldval = GetCellValue(row,col);
6829
6830 wxGridCellAttr* attr = GetCellAttr(row, col);
6831 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6832 bool changed = editor->EndEdit(row, col, this);
6833
6834 editor->DecRef();
6835 attr->DecRef();
6836
6837 if (changed)
6838 {
6839 if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
6840 m_currentCellCoords.GetRow(),
6841 m_currentCellCoords.GetCol() ) < 0 ) {
6842
6843 // Event has been vetoed, set the data back.
6844 SetCellValue(row,col,oldval);
6845 }
6846 }
6847 }
6848 }
6849
6850
6851 //
6852 // ------ Grid location functions
6853 // Note that all of these functions work with the logical coordinates of
6854 // grid cells and labels so you will need to convert from device
6855 // coordinates for mouse events etc.
6856 //
6857
6858 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
6859 {
6860 int row = YToRow(y);
6861 int col = XToCol(x);
6862
6863 if ( row == -1 || col == -1 )
6864 {
6865 coords = wxGridNoCellCoords;
6866 }
6867 else
6868 {
6869 coords.Set( row, col );
6870 }
6871 }
6872
6873
6874 int wxGrid::YToRow( int y )
6875 {
6876 int i;
6877
6878 for ( i = 0; i < m_numRows; i++ )
6879 {
6880 if ( y < GetRowBottom(i) )
6881 return i;
6882 }
6883
6884 return -1;
6885 }
6886
6887
6888 int wxGrid::XToCol( int x )
6889 {
6890 int i;
6891
6892 for ( i = 0; i < m_numCols; i++ )
6893 {
6894 if ( x < GetColRight(i) )
6895 return i;
6896 }
6897
6898 return -1;
6899 }
6900
6901
6902 // return the row number that that the y coord is near the edge of, or
6903 // -1 if not near an edge
6904 //
6905 int wxGrid::YToEdgeOfRow( int y )
6906 {
6907 int i, d;
6908
6909 for ( i = 0; i < m_numRows; i++ )
6910 {
6911 if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
6912 {
6913 d = abs( y - GetRowBottom(i) );
6914 if ( d < WXGRID_LABEL_EDGE_ZONE )
6915 return i;
6916 }
6917 }
6918
6919 return -1;
6920 }
6921
6922
6923 // return the col number that that the x coord is near the edge of, or
6924 // -1 if not near an edge
6925 //
6926 int wxGrid::XToEdgeOfCol( int x )
6927 {
6928 int i, d;
6929
6930 for ( i = 0; i < m_numCols; i++ )
6931 {
6932 if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
6933 {
6934 d = abs( x - GetColRight(i) );
6935 if ( d < WXGRID_LABEL_EDGE_ZONE )
6936 return i;
6937 }
6938 }
6939
6940 return -1;
6941 }
6942
6943
6944 wxRect wxGrid::CellToRect( int row, int col )
6945 {
6946 wxRect rect( -1, -1, -1, -1 );
6947
6948 if ( row >= 0 && row < m_numRows &&
6949 col >= 0 && col < m_numCols )
6950 {
6951 rect.x = GetColLeft(col);
6952 rect.y = GetRowTop(row);
6953 rect.width = GetColWidth(col);
6954 rect.height = GetRowHeight(row);
6955 }
6956
6957 // if grid lines are enabled, then the area of the cell is a bit smaller
6958 if (m_gridLinesEnabled) {
6959 rect.width -= 1;
6960 rect.height -= 1;
6961 }
6962 return rect;
6963 }
6964
6965
6966 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
6967 {
6968 // get the cell rectangle in logical coords
6969 //
6970 wxRect r( CellToRect( row, col ) );
6971
6972 // convert to device coords
6973 //
6974 int left, top, right, bottom;
6975 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6976 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6977
6978 // check against the client area of the grid window
6979 //
6980 int cw, ch;
6981 m_gridWin->GetClientSize( &cw, &ch );
6982
6983 if ( wholeCellVisible )
6984 {
6985 // is the cell wholly visible ?
6986 //
6987 return ( left >= 0 && right <= cw &&
6988 top >= 0 && bottom <= ch );
6989 }
6990 else
6991 {
6992 // is the cell partly visible ?
6993 //
6994 return ( ((left >=0 && left < cw) || (right > 0 && right <= cw)) &&
6995 ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
6996 }
6997 }
6998
6999
7000 // make the specified cell location visible by doing a minimal amount
7001 // of scrolling
7002 //
7003 void wxGrid::MakeCellVisible( int row, int col )
7004 {
7005
7006 int i;
7007 int xpos = -1, ypos = -1;
7008
7009 if ( row >= 0 && row < m_numRows &&
7010 col >= 0 && col < m_numCols )
7011 {
7012 // get the cell rectangle in logical coords
7013 //
7014 wxRect r( CellToRect( row, col ) );
7015
7016 // convert to device coords
7017 //
7018 int left, top, right, bottom;
7019 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
7020 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
7021
7022 int cw, ch;
7023 m_gridWin->GetClientSize( &cw, &ch );
7024
7025 if ( top < 0 )
7026 {
7027 ypos = r.GetTop();
7028 }
7029 else if ( bottom > ch )
7030 {
7031 int h = r.GetHeight();
7032 ypos = r.GetTop();
7033 for ( i = row-1; i >= 0; i-- )
7034 {
7035 int rowHeight = GetRowHeight(i);
7036 if ( h + rowHeight > ch )
7037 break;
7038
7039 h += rowHeight;
7040 ypos -= rowHeight;
7041 }
7042
7043 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7044 // have rounding errors (this is important, because if we do, we
7045 // might not scroll at all and some cells won't be redrawn)
7046 //
7047 // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7048 // scroll unit...
7049 ypos += GRID_SCROLL_LINE_Y;
7050 }
7051
7052 if ( left < 0 )
7053 {
7054 xpos = r.GetLeft();
7055 }
7056 else if ( right > cw )
7057 {
7058 int w = r.GetWidth();
7059 xpos = r.GetLeft();
7060 for ( i = col-1; i >= 0; i-- )
7061 {
7062 int colWidth = GetColWidth(i);
7063 if ( w + colWidth > cw )
7064 break;
7065
7066 w += colWidth;
7067 xpos -= colWidth;
7068 }
7069
7070 // see comment for ypos above
7071 xpos += GRID_SCROLL_LINE_X;
7072 }
7073
7074 if ( xpos != -1 || ypos != -1 )
7075 {
7076 if ( xpos != -1 )
7077 xpos /= GRID_SCROLL_LINE_X;
7078 if ( ypos != -1 )
7079 ypos /= GRID_SCROLL_LINE_Y;
7080 Scroll( xpos, ypos );
7081 AdjustScrollbars();
7082 }
7083 }
7084 }
7085
7086
7087 //
7088 // ------ Grid cursor movement functions
7089 //
7090
7091 bool wxGrid::MoveCursorUp( bool expandSelection )
7092 {
7093 if ( m_currentCellCoords != wxGridNoCellCoords &&
7094 m_currentCellCoords.GetRow() >= 0 )
7095 {
7096 if ( expandSelection)
7097 {
7098 if ( m_selectingKeyboard == wxGridNoCellCoords )
7099 m_selectingKeyboard = m_currentCellCoords;
7100 if ( m_selectingKeyboard.GetRow() > 0 )
7101 {
7102 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
7103 MakeCellVisible( m_selectingKeyboard.GetRow(),
7104 m_selectingKeyboard.GetCol() );
7105 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7106 }
7107 }
7108 else if ( m_currentCellCoords.GetRow() > 0 )
7109 {
7110 ClearSelection();
7111 MakeCellVisible( m_currentCellCoords.GetRow() - 1,
7112 m_currentCellCoords.GetCol() );
7113 SetCurrentCell( m_currentCellCoords.GetRow() - 1,
7114 m_currentCellCoords.GetCol() );
7115 }
7116 else
7117 return FALSE;
7118 return TRUE;
7119 }
7120
7121 return FALSE;
7122 }
7123
7124
7125 bool wxGrid::MoveCursorDown( bool expandSelection )
7126 {
7127 if ( m_currentCellCoords != wxGridNoCellCoords &&
7128 m_currentCellCoords.GetRow() < m_numRows )
7129 {
7130 if ( expandSelection )
7131 {
7132 if ( m_selectingKeyboard == wxGridNoCellCoords )
7133 m_selectingKeyboard = m_currentCellCoords;
7134 if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
7135 {
7136 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
7137 MakeCellVisible( m_selectingKeyboard.GetRow(),
7138 m_selectingKeyboard.GetCol() );
7139 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7140 }
7141 }
7142 else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
7143 {
7144 ClearSelection();
7145 MakeCellVisible( m_currentCellCoords.GetRow() + 1,
7146 m_currentCellCoords.GetCol() );
7147 SetCurrentCell( m_currentCellCoords.GetRow() + 1,
7148 m_currentCellCoords.GetCol() );
7149 }
7150 else
7151 return FALSE;
7152 return TRUE;
7153 }
7154
7155 return FALSE;
7156 }
7157
7158
7159 bool wxGrid::MoveCursorLeft( bool expandSelection )
7160 {
7161 if ( m_currentCellCoords != wxGridNoCellCoords &&
7162 m_currentCellCoords.GetCol() >= 0 )
7163 {
7164 if ( expandSelection )
7165 {
7166 if ( m_selectingKeyboard == wxGridNoCellCoords )
7167 m_selectingKeyboard = m_currentCellCoords;
7168 if ( m_selectingKeyboard.GetCol() > 0 )
7169 {
7170 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
7171 MakeCellVisible( m_selectingKeyboard.GetRow(),
7172 m_selectingKeyboard.GetCol() );
7173 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7174 }
7175 }
7176 else if ( m_currentCellCoords.GetCol() > 0 )
7177 {
7178 ClearSelection();
7179 MakeCellVisible( m_currentCellCoords.GetRow(),
7180 m_currentCellCoords.GetCol() - 1 );
7181 SetCurrentCell( m_currentCellCoords.GetRow(),
7182 m_currentCellCoords.GetCol() - 1 );
7183 }
7184 else
7185 return FALSE;
7186 return TRUE;
7187 }
7188
7189 return FALSE;
7190 }
7191
7192
7193 bool wxGrid::MoveCursorRight( bool expandSelection )
7194 {
7195 if ( m_currentCellCoords != wxGridNoCellCoords &&
7196 m_currentCellCoords.GetCol() < m_numCols )
7197 {
7198 if ( expandSelection )
7199 {
7200 if ( m_selectingKeyboard == wxGridNoCellCoords )
7201 m_selectingKeyboard = m_currentCellCoords;
7202 if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
7203 {
7204 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
7205 MakeCellVisible( m_selectingKeyboard.GetRow(),
7206 m_selectingKeyboard.GetCol() );
7207 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7208 }
7209 }
7210 else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
7211 {
7212 ClearSelection();
7213 MakeCellVisible( m_currentCellCoords.GetRow(),
7214 m_currentCellCoords.GetCol() + 1 );
7215 SetCurrentCell( m_currentCellCoords.GetRow(),
7216 m_currentCellCoords.GetCol() + 1 );
7217 }
7218 else
7219 return FALSE;
7220 return TRUE;
7221 }
7222
7223 return FALSE;
7224 }
7225
7226
7227 bool wxGrid::MovePageUp()
7228 {
7229 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
7230
7231 int row = m_currentCellCoords.GetRow();
7232 if ( row > 0 )
7233 {
7234 int cw, ch;
7235 m_gridWin->GetClientSize( &cw, &ch );
7236
7237 int y = GetRowTop(row);
7238 int newRow = YToRow( y - ch + 1 );
7239 if ( newRow == -1 )
7240 {
7241 newRow = 0;
7242 }
7243 else if ( newRow == row )
7244 {
7245 newRow = row - 1;
7246 }
7247
7248 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
7249 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
7250
7251 return TRUE;
7252 }
7253
7254 return FALSE;
7255 }
7256
7257 bool wxGrid::MovePageDown()
7258 {
7259 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
7260
7261 int row = m_currentCellCoords.GetRow();
7262 if ( row < m_numRows )
7263 {
7264 int cw, ch;
7265 m_gridWin->GetClientSize( &cw, &ch );
7266
7267 int y = GetRowTop(row);
7268 int newRow = YToRow( y + ch );
7269 if ( newRow == -1 )
7270 {
7271 newRow = m_numRows - 1;
7272 }
7273 else if ( newRow == row )
7274 {
7275 newRow = row + 1;
7276 }
7277
7278 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
7279 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
7280
7281 return TRUE;
7282 }
7283
7284 return FALSE;
7285 }
7286
7287 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
7288 {
7289 if ( m_table &&
7290 m_currentCellCoords != wxGridNoCellCoords &&
7291 m_currentCellCoords.GetRow() > 0 )
7292 {
7293 int row = m_currentCellCoords.GetRow();
7294 int col = m_currentCellCoords.GetCol();
7295
7296 if ( m_table->IsEmptyCell(row, col) )
7297 {
7298 // starting in an empty cell: find the next block of
7299 // non-empty cells
7300 //
7301 while ( row > 0 )
7302 {
7303 row-- ;
7304 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7305 }
7306 }
7307 else if ( m_table->IsEmptyCell(row-1, col) )
7308 {
7309 // starting at the top of a block: find the next block
7310 //
7311 row--;
7312 while ( row > 0 )
7313 {
7314 row-- ;
7315 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7316 }
7317 }
7318 else
7319 {
7320 // starting within a block: find the top of the block
7321 //
7322 while ( row > 0 )
7323 {
7324 row-- ;
7325 if ( m_table->IsEmptyCell(row, col) )
7326 {
7327 row++ ;
7328 break;
7329 }
7330 }
7331 }
7332
7333 MakeCellVisible( row, col );
7334 if ( expandSelection )
7335 {
7336 m_selectingKeyboard = wxGridCellCoords( row, col );
7337 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7338 }
7339 else
7340 {
7341 ClearSelection();
7342 SetCurrentCell( row, col );
7343 }
7344 return TRUE;
7345 }
7346
7347 return FALSE;
7348 }
7349
7350 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
7351 {
7352 if ( m_table &&
7353 m_currentCellCoords != wxGridNoCellCoords &&
7354 m_currentCellCoords.GetRow() < m_numRows-1 )
7355 {
7356 int row = m_currentCellCoords.GetRow();
7357 int col = m_currentCellCoords.GetCol();
7358
7359 if ( m_table->IsEmptyCell(row, col) )
7360 {
7361 // starting in an empty cell: find the next block of
7362 // non-empty cells
7363 //
7364 while ( row < m_numRows-1 )
7365 {
7366 row++ ;
7367 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7368 }
7369 }
7370 else if ( m_table->IsEmptyCell(row+1, col) )
7371 {
7372 // starting at the bottom of a block: find the next block
7373 //
7374 row++;
7375 while ( row < m_numRows-1 )
7376 {
7377 row++ ;
7378 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7379 }
7380 }
7381 else
7382 {
7383 // starting within a block: find the bottom of the block
7384 //
7385 while ( row < m_numRows-1 )
7386 {
7387 row++ ;
7388 if ( m_table->IsEmptyCell(row, col) )
7389 {
7390 row-- ;
7391 break;
7392 }
7393 }
7394 }
7395
7396 MakeCellVisible( row, col );
7397 if ( expandSelection )
7398 {
7399 m_selectingKeyboard = wxGridCellCoords( row, col );
7400 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7401 }
7402 else
7403 {
7404 ClearSelection();
7405 SetCurrentCell( row, col );
7406 }
7407
7408 return TRUE;
7409 }
7410
7411 return FALSE;
7412 }
7413
7414 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
7415 {
7416 if ( m_table &&
7417 m_currentCellCoords != wxGridNoCellCoords &&
7418 m_currentCellCoords.GetCol() > 0 )
7419 {
7420 int row = m_currentCellCoords.GetRow();
7421 int col = m_currentCellCoords.GetCol();
7422
7423 if ( m_table->IsEmptyCell(row, col) )
7424 {
7425 // starting in an empty cell: find the next block of
7426 // non-empty cells
7427 //
7428 while ( col > 0 )
7429 {
7430 col-- ;
7431 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7432 }
7433 }
7434 else if ( m_table->IsEmptyCell(row, col-1) )
7435 {
7436 // starting at the left of a block: find the next block
7437 //
7438 col--;
7439 while ( col > 0 )
7440 {
7441 col-- ;
7442 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7443 }
7444 }
7445 else
7446 {
7447 // starting within a block: find the left of the block
7448 //
7449 while ( col > 0 )
7450 {
7451 col-- ;
7452 if ( m_table->IsEmptyCell(row, col) )
7453 {
7454 col++ ;
7455 break;
7456 }
7457 }
7458 }
7459
7460 MakeCellVisible( row, col );
7461 if ( expandSelection )
7462 {
7463 m_selectingKeyboard = wxGridCellCoords( row, col );
7464 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7465 }
7466 else
7467 {
7468 ClearSelection();
7469 SetCurrentCell( row, col );
7470 }
7471
7472 return TRUE;
7473 }
7474
7475 return FALSE;
7476 }
7477
7478 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
7479 {
7480 if ( m_table &&
7481 m_currentCellCoords != wxGridNoCellCoords &&
7482 m_currentCellCoords.GetCol() < m_numCols-1 )
7483 {
7484 int row = m_currentCellCoords.GetRow();
7485 int col = m_currentCellCoords.GetCol();
7486
7487 if ( m_table->IsEmptyCell(row, col) )
7488 {
7489 // starting in an empty cell: find the next block of
7490 // non-empty cells
7491 //
7492 while ( col < m_numCols-1 )
7493 {
7494 col++ ;
7495 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7496 }
7497 }
7498 else if ( m_table->IsEmptyCell(row, col+1) )
7499 {
7500 // starting at the right of a block: find the next block
7501 //
7502 col++;
7503 while ( col < m_numCols-1 )
7504 {
7505 col++ ;
7506 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7507 }
7508 }
7509 else
7510 {
7511 // starting within a block: find the right of the block
7512 //
7513 while ( col < m_numCols-1 )
7514 {
7515 col++ ;
7516 if ( m_table->IsEmptyCell(row, col) )
7517 {
7518 col-- ;
7519 break;
7520 }
7521 }
7522 }
7523
7524 MakeCellVisible( row, col );
7525 if ( expandSelection )
7526 {
7527 m_selectingKeyboard = wxGridCellCoords( row, col );
7528 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7529 }
7530 else
7531 {
7532 ClearSelection();
7533 SetCurrentCell( row, col );
7534 }
7535
7536 return TRUE;
7537 }
7538
7539 return FALSE;
7540 }
7541
7542
7543
7544 //
7545 // ------ Label values and formatting
7546 //
7547
7548 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
7549 {
7550 *horiz = m_rowLabelHorizAlign;
7551 *vert = m_rowLabelVertAlign;
7552 }
7553
7554 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
7555 {
7556 *horiz = m_colLabelHorizAlign;
7557 *vert = m_colLabelVertAlign;
7558 }
7559
7560 wxString wxGrid::GetRowLabelValue( int row )
7561 {
7562 if ( m_table )
7563 {
7564 return m_table->GetRowLabelValue( row );
7565 }
7566 else
7567 {
7568 wxString s;
7569 s << row;
7570 return s;
7571 }
7572 }
7573
7574 wxString wxGrid::GetColLabelValue( int col )
7575 {
7576 if ( m_table )
7577 {
7578 return m_table->GetColLabelValue( col );
7579 }
7580 else
7581 {
7582 wxString s;
7583 s << col;
7584 return s;
7585 }
7586 }
7587
7588
7589 void wxGrid::SetRowLabelSize( int width )
7590 {
7591 width = wxMax( width, 0 );
7592 if ( width != m_rowLabelWidth )
7593 {
7594 if ( width == 0 )
7595 {
7596 m_rowLabelWin->Show( FALSE );
7597 m_cornerLabelWin->Show( FALSE );
7598 }
7599 else if ( m_rowLabelWidth == 0 )
7600 {
7601 m_rowLabelWin->Show( TRUE );
7602 if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
7603 }
7604
7605 m_rowLabelWidth = width;
7606 CalcWindowSizes();
7607 Refresh( TRUE );
7608 }
7609 }
7610
7611
7612 void wxGrid::SetColLabelSize( int height )
7613 {
7614 height = wxMax( height, 0 );
7615 if ( height != m_colLabelHeight )
7616 {
7617 if ( height == 0 )
7618 {
7619 m_colLabelWin->Show( FALSE );
7620 m_cornerLabelWin->Show( FALSE );
7621 }
7622 else if ( m_colLabelHeight == 0 )
7623 {
7624 m_colLabelWin->Show( TRUE );
7625 if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
7626 }
7627
7628 m_colLabelHeight = height;
7629 CalcWindowSizes();
7630 Refresh( TRUE );
7631 }
7632 }
7633
7634
7635 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
7636 {
7637 if ( m_labelBackgroundColour != colour )
7638 {
7639 m_labelBackgroundColour = colour;
7640 m_rowLabelWin->SetBackgroundColour( colour );
7641 m_colLabelWin->SetBackgroundColour( colour );
7642 m_cornerLabelWin->SetBackgroundColour( colour );
7643
7644 if ( !GetBatchCount() )
7645 {
7646 m_rowLabelWin->Refresh();
7647 m_colLabelWin->Refresh();
7648 m_cornerLabelWin->Refresh();
7649 }
7650 }
7651 }
7652
7653 void wxGrid::SetLabelTextColour( const wxColour& colour )
7654 {
7655 if ( m_labelTextColour != colour )
7656 {
7657 m_labelTextColour = colour;
7658 if ( !GetBatchCount() )
7659 {
7660 m_rowLabelWin->Refresh();
7661 m_colLabelWin->Refresh();
7662 }
7663 }
7664 }
7665
7666 void wxGrid::SetLabelFont( const wxFont& font )
7667 {
7668 m_labelFont = font;
7669 if ( !GetBatchCount() )
7670 {
7671 m_rowLabelWin->Refresh();
7672 m_colLabelWin->Refresh();
7673 }
7674 }
7675
7676 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
7677 {
7678 // allow old (incorrect) defs to be used
7679 switch ( horiz )
7680 {
7681 case wxLEFT: horiz = wxALIGN_LEFT; break;
7682 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
7683 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7684 }
7685
7686 switch ( vert )
7687 {
7688 case wxTOP: vert = wxALIGN_TOP; break;
7689 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7690 case wxCENTRE: vert = wxALIGN_CENTRE; break;
7691 }
7692
7693 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7694 {
7695 m_rowLabelHorizAlign = horiz;
7696 }
7697
7698 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7699 {
7700 m_rowLabelVertAlign = vert;
7701 }
7702
7703 if ( !GetBatchCount() )
7704 {
7705 m_rowLabelWin->Refresh();
7706 }
7707 }
7708
7709 void wxGrid::SetColLabelAlignment( int horiz, int vert )
7710 {
7711 // allow old (incorrect) defs to be used
7712 switch ( horiz )
7713 {
7714 case wxLEFT: horiz = wxALIGN_LEFT; break;
7715 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
7716 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7717 }
7718
7719 switch ( vert )
7720 {
7721 case wxTOP: vert = wxALIGN_TOP; break;
7722 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7723 case wxCENTRE: vert = wxALIGN_CENTRE; break;
7724 }
7725
7726 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7727 {
7728 m_colLabelHorizAlign = horiz;
7729 }
7730
7731 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7732 {
7733 m_colLabelVertAlign = vert;
7734 }
7735
7736 if ( !GetBatchCount() )
7737 {
7738 m_colLabelWin->Refresh();
7739 }
7740 }
7741
7742 void wxGrid::SetRowLabelValue( int row, const wxString& s )
7743 {
7744 if ( m_table )
7745 {
7746 m_table->SetRowLabelValue( row, s );
7747 if ( !GetBatchCount() )
7748 {
7749 wxRect rect = CellToRect( row, 0);
7750 if ( rect.height > 0 )
7751 {
7752 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
7753 rect.x = 0;
7754 rect.width = m_rowLabelWidth;
7755 m_rowLabelWin->Refresh( TRUE, &rect );
7756 }
7757 }
7758 }
7759 }
7760
7761 void wxGrid::SetColLabelValue( int col, const wxString& s )
7762 {
7763 if ( m_table )
7764 {
7765 m_table->SetColLabelValue( col, s );
7766 if ( !GetBatchCount() )
7767 {
7768 wxRect rect = CellToRect( 0, col );
7769 if ( rect.width > 0 )
7770 {
7771 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
7772 rect.y = 0;
7773 rect.height = m_colLabelHeight;
7774 m_colLabelWin->Refresh( TRUE, &rect );
7775 }
7776 }
7777 }
7778 }
7779
7780 void wxGrid::SetGridLineColour( const wxColour& colour )
7781 {
7782 if ( m_gridLineColour != colour )
7783 {
7784 m_gridLineColour = colour;
7785
7786 wxClientDC dc( m_gridWin );
7787 PrepareDC( dc );
7788 DrawAllGridLines( dc, wxRegion() );
7789 }
7790 }
7791
7792
7793 void wxGrid::SetCellHighlightColour( const wxColour& colour )
7794 {
7795 if ( m_cellHighlightColour != colour )
7796 {
7797 m_cellHighlightColour = colour;
7798
7799 wxClientDC dc( m_gridWin );
7800 PrepareDC( dc );
7801 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
7802 DrawCellHighlight(dc, attr);
7803 attr->DecRef();
7804 }
7805 }
7806
7807 void wxGrid::SetCellHighlightPenWidth(int width)
7808 {
7809 if (m_cellHighlightPenWidth != width) {
7810 m_cellHighlightPenWidth = width;
7811
7812 // Just redrawing the cell highlight is not enough since that won't
7813 // make any visible change if the the thickness is getting smaller.
7814 int row = m_currentCellCoords.GetRow();
7815 int col = m_currentCellCoords.GetCol();
7816 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7817 return;
7818 wxRect rect = CellToRect(row, col);
7819 m_gridWin->Refresh(TRUE, &rect);
7820 }
7821 }
7822
7823 void wxGrid::SetCellHighlightROPenWidth(int width)
7824 {
7825 if (m_cellHighlightROPenWidth != width) {
7826 m_cellHighlightROPenWidth = width;
7827
7828 // Just redrawing the cell highlight is not enough since that won't
7829 // make any visible change if the the thickness is getting smaller.
7830 int row = m_currentCellCoords.GetRow();
7831 int col = m_currentCellCoords.GetCol();
7832 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7833 return;
7834 wxRect rect = CellToRect(row, col);
7835 m_gridWin->Refresh(TRUE, &rect);
7836 }
7837 }
7838
7839 void wxGrid::EnableGridLines( bool enable )
7840 {
7841 if ( enable != m_gridLinesEnabled )
7842 {
7843 m_gridLinesEnabled = enable;
7844
7845 if ( !GetBatchCount() )
7846 {
7847 if ( enable )
7848 {
7849 wxClientDC dc( m_gridWin );
7850 PrepareDC( dc );
7851 DrawAllGridLines( dc, wxRegion() );
7852 }
7853 else
7854 {
7855 m_gridWin->Refresh();
7856 }
7857 }
7858 }
7859 }
7860
7861
7862 int wxGrid::GetDefaultRowSize()
7863 {
7864 return m_defaultRowHeight;
7865 }
7866
7867 int wxGrid::GetRowSize( int row )
7868 {
7869 wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
7870
7871 return GetRowHeight(row);
7872 }
7873
7874 int wxGrid::GetDefaultColSize()
7875 {
7876 return m_defaultColWidth;
7877 }
7878
7879 int wxGrid::GetColSize( int col )
7880 {
7881 wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
7882
7883 return GetColWidth(col);
7884 }
7885
7886 // ============================================================================
7887 // access to the grid attributes: each of them has a default value in the grid
7888 // itself and may be overidden on a per-cell basis
7889 // ============================================================================
7890
7891 // ----------------------------------------------------------------------------
7892 // setting default attributes
7893 // ----------------------------------------------------------------------------
7894
7895 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
7896 {
7897 m_defaultCellAttr->SetBackgroundColour(col);
7898 #ifdef __WXGTK__
7899 m_gridWin->SetBackgroundColour(col);
7900 #endif
7901 }
7902
7903 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
7904 {
7905 m_defaultCellAttr->SetTextColour(col);
7906 }
7907
7908 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
7909 {
7910 m_defaultCellAttr->SetAlignment(horiz, vert);
7911 }
7912
7913 void wxGrid::SetDefaultCellFont( const wxFont& font )
7914 {
7915 m_defaultCellAttr->SetFont(font);
7916 }
7917
7918 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
7919 {
7920 m_defaultCellAttr->SetRenderer(renderer);
7921 }
7922
7923 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
7924 {
7925 m_defaultCellAttr->SetEditor(editor);
7926 }
7927
7928 // ----------------------------------------------------------------------------
7929 // access to the default attrbiutes
7930 // ----------------------------------------------------------------------------
7931
7932 wxColour wxGrid::GetDefaultCellBackgroundColour()
7933 {
7934 return m_defaultCellAttr->GetBackgroundColour();
7935 }
7936
7937 wxColour wxGrid::GetDefaultCellTextColour()
7938 {
7939 return m_defaultCellAttr->GetTextColour();
7940 }
7941
7942 wxFont wxGrid::GetDefaultCellFont()
7943 {
7944 return m_defaultCellAttr->GetFont();
7945 }
7946
7947 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
7948 {
7949 m_defaultCellAttr->GetAlignment(horiz, vert);
7950 }
7951
7952 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
7953 {
7954 return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
7955 }
7956
7957 wxGridCellEditor *wxGrid::GetDefaultEditor() const
7958 {
7959 return m_defaultCellAttr->GetEditor(NULL,0,0);
7960 }
7961
7962 // ----------------------------------------------------------------------------
7963 // access to cell attributes
7964 // ----------------------------------------------------------------------------
7965
7966 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
7967 {
7968 wxGridCellAttr *attr = GetCellAttr(row, col);
7969 wxColour colour = attr->GetBackgroundColour();
7970 attr->DecRef();
7971 return colour;
7972 }
7973
7974 wxColour wxGrid::GetCellTextColour( int row, int col )
7975 {
7976 wxGridCellAttr *attr = GetCellAttr(row, col);
7977 wxColour colour = attr->GetTextColour();
7978 attr->DecRef();
7979 return colour;
7980 }
7981
7982 wxFont wxGrid::GetCellFont( int row, int col )
7983 {
7984 wxGridCellAttr *attr = GetCellAttr(row, col);
7985 wxFont font = attr->GetFont();
7986 attr->DecRef();
7987 return font;
7988 }
7989
7990 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
7991 {
7992 wxGridCellAttr *attr = GetCellAttr(row, col);
7993 attr->GetAlignment(horiz, vert);
7994 attr->DecRef();
7995 }
7996
7997 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
7998 {
7999 wxGridCellAttr* attr = GetCellAttr(row, col);
8000 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8001 attr->DecRef();
8002
8003 return renderer;
8004 }
8005
8006 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
8007 {
8008 wxGridCellAttr* attr = GetCellAttr(row, col);
8009 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8010 attr->DecRef();
8011
8012 return editor;
8013 }
8014
8015 bool wxGrid::IsReadOnly(int row, int col) const
8016 {
8017 wxGridCellAttr* attr = GetCellAttr(row, col);
8018 bool isReadOnly = attr->IsReadOnly();
8019 attr->DecRef();
8020 return isReadOnly;
8021 }
8022
8023 // ----------------------------------------------------------------------------
8024 // attribute support: cache, automatic provider creation, ...
8025 // ----------------------------------------------------------------------------
8026
8027 bool wxGrid::CanHaveAttributes()
8028 {
8029 if ( !m_table )
8030 {
8031 return FALSE;
8032 }
8033
8034 return m_table->CanHaveAttributes();
8035 }
8036
8037 void wxGrid::ClearAttrCache()
8038 {
8039 if ( m_attrCache.row != -1 )
8040 {
8041 wxSafeDecRef(m_attrCache.attr);
8042 m_attrCache.attr = NULL;
8043 m_attrCache.row = -1;
8044 }
8045 }
8046
8047 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
8048 {
8049 wxGrid *self = (wxGrid *)this; // const_cast
8050
8051 self->ClearAttrCache();
8052 self->m_attrCache.row = row;
8053 self->m_attrCache.col = col;
8054 self->m_attrCache.attr = attr;
8055 wxSafeIncRef(attr);
8056 }
8057
8058 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
8059 {
8060 if ( row == m_attrCache.row && col == m_attrCache.col )
8061 {
8062 *attr = m_attrCache.attr;
8063 wxSafeIncRef(m_attrCache.attr);
8064
8065 #ifdef DEBUG_ATTR_CACHE
8066 gs_nAttrCacheHits++;
8067 #endif
8068
8069 return TRUE;
8070 }
8071 else
8072 {
8073 #ifdef DEBUG_ATTR_CACHE
8074 gs_nAttrCacheMisses++;
8075 #endif
8076 return FALSE;
8077 }
8078 }
8079
8080 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
8081 {
8082 wxGridCellAttr *attr;
8083 if ( !LookupAttr(row, col, &attr) )
8084 {
8085 attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any) : (wxGridCellAttr *)NULL;
8086 CacheAttr(row, col, attr);
8087 }
8088 if (attr)
8089 {
8090 attr->SetDefAttr(m_defaultCellAttr);
8091 }
8092 else
8093 {
8094 attr = m_defaultCellAttr;
8095 attr->IncRef();
8096 }
8097
8098 return attr;
8099 }
8100
8101 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
8102 {
8103 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8104 wxASSERT_MSG( m_table,
8105 _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
8106
8107 attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell );
8108 if ( !attr )
8109 {
8110 attr = new wxGridCellAttr;
8111
8112 // artificially inc the ref count to match DecRef() in caller
8113 attr->IncRef();
8114 m_table->SetAttr(attr, row, col);
8115 }
8116 attr->SetDefAttr(m_defaultCellAttr);
8117 return attr;
8118 }
8119
8120 // ----------------------------------------------------------------------------
8121 // setting column attributes (wrappers around SetColAttr)
8122 // ----------------------------------------------------------------------------
8123
8124 void wxGrid::SetColFormatBool(int col)
8125 {
8126 SetColFormatCustom(col, wxGRID_VALUE_BOOL);
8127 }
8128
8129 void wxGrid::SetColFormatNumber(int col)
8130 {
8131 SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
8132 }
8133
8134 void wxGrid::SetColFormatFloat(int col, int width, int precision)
8135 {
8136 wxString typeName = wxGRID_VALUE_FLOAT;
8137 if ( (width != -1) || (precision != -1) )
8138 {
8139 typeName << _T(':') << width << _T(',') << precision;
8140 }
8141
8142 SetColFormatCustom(col, typeName);
8143 }
8144
8145 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
8146 {
8147 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8148
8149 attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
8150 if(!attr)
8151 attr = new wxGridCellAttr;
8152 wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
8153 attr->SetRenderer(renderer);
8154
8155 SetColAttr(col, attr);
8156
8157 }
8158
8159 // ----------------------------------------------------------------------------
8160 // setting cell attributes: this is forwarded to the table
8161 // ----------------------------------------------------------------------------
8162
8163 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
8164 {
8165 if ( CanHaveAttributes() )
8166 {
8167 m_table->SetRowAttr(attr, row);
8168 ClearAttrCache();
8169 }
8170 else
8171 {
8172 wxSafeDecRef(attr);
8173 }
8174 }
8175
8176 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
8177 {
8178 if ( CanHaveAttributes() )
8179 {
8180 m_table->SetColAttr(attr, col);
8181 ClearAttrCache();
8182 }
8183 else
8184 {
8185 wxSafeDecRef(attr);
8186 }
8187 }
8188
8189 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
8190 {
8191 if ( CanHaveAttributes() )
8192 {
8193 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8194 attr->SetBackgroundColour(colour);
8195 attr->DecRef();
8196 }
8197 }
8198
8199 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
8200 {
8201 if ( CanHaveAttributes() )
8202 {
8203 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8204 attr->SetTextColour(colour);
8205 attr->DecRef();
8206 }
8207 }
8208
8209 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
8210 {
8211 if ( CanHaveAttributes() )
8212 {
8213 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8214 attr->SetFont(font);
8215 attr->DecRef();
8216 }
8217 }
8218
8219 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
8220 {
8221 if ( CanHaveAttributes() )
8222 {
8223 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8224 attr->SetAlignment(horiz, vert);
8225 attr->DecRef();
8226 }
8227 }
8228
8229 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
8230 {
8231 if ( CanHaveAttributes() )
8232 {
8233 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8234 attr->SetRenderer(renderer);
8235 attr->DecRef();
8236 }
8237 }
8238
8239 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
8240 {
8241 if ( CanHaveAttributes() )
8242 {
8243 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8244 attr->SetEditor(editor);
8245 attr->DecRef();
8246 }
8247 }
8248
8249 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
8250 {
8251 if ( CanHaveAttributes() )
8252 {
8253 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8254 attr->SetReadOnly(isReadOnly);
8255 attr->DecRef();
8256 }
8257 }
8258
8259 // ----------------------------------------------------------------------------
8260 // Data type registration
8261 // ----------------------------------------------------------------------------
8262
8263 void wxGrid::RegisterDataType(const wxString& typeName,
8264 wxGridCellRenderer* renderer,
8265 wxGridCellEditor* editor)
8266 {
8267 m_typeRegistry->RegisterDataType(typeName, renderer, editor);
8268 }
8269
8270
8271 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
8272 {
8273 wxString typeName = m_table->GetTypeName(row, col);
8274 return GetDefaultEditorForType(typeName);
8275 }
8276
8277 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
8278 {
8279 wxString typeName = m_table->GetTypeName(row, col);
8280 return GetDefaultRendererForType(typeName);
8281 }
8282
8283 wxGridCellEditor*
8284 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
8285 {
8286 int index = m_typeRegistry->FindOrCloneDataType(typeName);
8287 if ( index == wxNOT_FOUND )
8288 {
8289 wxFAIL_MSG(wxT("Unknown data type name"));
8290
8291 return NULL;
8292 }
8293
8294 return m_typeRegistry->GetEditor(index);
8295 }
8296
8297 wxGridCellRenderer*
8298 wxGrid::GetDefaultRendererForType(const wxString& typeName) const
8299 {
8300 int index = m_typeRegistry->FindOrCloneDataType(typeName);
8301 if ( index == wxNOT_FOUND )
8302 {
8303 wxFAIL_MSG(wxT("Unknown data type name"));
8304
8305 return NULL;
8306 }
8307
8308 return m_typeRegistry->GetRenderer(index);
8309 }
8310
8311
8312 // ----------------------------------------------------------------------------
8313 // row/col size
8314 // ----------------------------------------------------------------------------
8315
8316 void wxGrid::EnableDragRowSize( bool enable )
8317 {
8318 m_canDragRowSize = enable;
8319 }
8320
8321
8322 void wxGrid::EnableDragColSize( bool enable )
8323 {
8324 m_canDragColSize = enable;
8325 }
8326
8327 void wxGrid::EnableDragGridSize( bool enable )
8328 {
8329 m_canDragGridSize = enable;
8330 }
8331
8332
8333 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
8334 {
8335 m_defaultRowHeight = wxMax( height, WXGRID_MIN_ROW_HEIGHT );
8336
8337 if ( resizeExistingRows )
8338 {
8339 InitRowHeights();
8340 if ( !GetBatchCount() )
8341 CalcDimensions();
8342 }
8343 }
8344
8345 void wxGrid::SetRowSize( int row, int height )
8346 {
8347 wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
8348
8349 if ( m_rowHeights.IsEmpty() )
8350 {
8351 // need to really create the array
8352 InitRowHeights();
8353 }
8354
8355 int h = wxMax( 0, height );
8356 int diff = h - m_rowHeights[row];
8357
8358 m_rowHeights[row] = h;
8359 int i;
8360 for ( i = row; i < m_numRows; i++ )
8361 {
8362 m_rowBottoms[i] += diff;
8363 }
8364 if ( !GetBatchCount() )
8365 CalcDimensions();
8366 }
8367
8368 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
8369 {
8370 m_defaultColWidth = wxMax( width, WXGRID_MIN_COL_WIDTH );
8371
8372 if ( resizeExistingCols )
8373 {
8374 InitColWidths();
8375 if ( !GetBatchCount() )
8376 CalcDimensions();
8377 }
8378 }
8379
8380 void wxGrid::SetColSize( int col, int width )
8381 {
8382 wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
8383
8384 // should we check that it's bigger than GetColMinimalWidth(col) here?
8385
8386 if ( m_colWidths.IsEmpty() )
8387 {
8388 // need to really create the array
8389 InitColWidths();
8390 }
8391
8392 int w = wxMax( 0, width );
8393 int diff = w - m_colWidths[col];
8394 m_colWidths[col] = w;
8395
8396 int i;
8397 for ( i = col; i < m_numCols; i++ )
8398 {
8399 m_colRights[i] += diff;
8400 }
8401 if ( !GetBatchCount() )
8402 CalcDimensions();
8403 }
8404
8405
8406 void wxGrid::SetColMinimalWidth( int col, int width )
8407 {
8408 m_colMinWidths.Put(col, width);
8409 }
8410
8411 void wxGrid::SetRowMinimalHeight( int row, int width )
8412 {
8413 m_rowMinHeights.Put(row, width);
8414 }
8415
8416 int wxGrid::GetColMinimalWidth(int col) const
8417 {
8418 long value = m_colMinWidths.Get(col);
8419 return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_COL_WIDTH;
8420 }
8421
8422 int wxGrid::GetRowMinimalHeight(int row) const
8423 {
8424 long value = m_rowMinHeights.Get(row);
8425 return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_ROW_HEIGHT;
8426 }
8427
8428 // ----------------------------------------------------------------------------
8429 // auto sizing
8430 // ----------------------------------------------------------------------------
8431
8432 void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
8433 {
8434 wxClientDC dc(m_gridWin);
8435
8436 // init both of them to avoid compiler warnings, even if weo nly need one
8437 int row = -1,
8438 col = -1;
8439 if ( column )
8440 col = colOrRow;
8441 else
8442 row = colOrRow;
8443
8444 wxCoord extent, extentMax = 0;
8445 int max = column ? m_numRows : m_numCols;
8446 for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
8447 {
8448 if ( column )
8449 row = rowOrCol;
8450 else
8451 col = rowOrCol;
8452
8453 wxGridCellAttr* attr = GetCellAttr(row, col);
8454 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8455 if ( renderer )
8456 {
8457 wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
8458 extent = column ? size.x : size.y;
8459 if ( extent > extentMax )
8460 {
8461 extentMax = extent;
8462 }
8463
8464 renderer->DecRef();
8465 }
8466
8467 attr->DecRef();
8468 }
8469
8470 // now also compare with the column label extent
8471 wxCoord w, h;
8472 dc.SetFont( GetLabelFont() );
8473
8474 if ( column )
8475 dc.GetTextExtent( GetColLabelValue(col), &w, &h );
8476 else
8477 dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
8478
8479 extent = column ? w : h;
8480 if ( extent > extentMax )
8481 {
8482 extentMax = extent;
8483 }
8484
8485 if ( !extentMax )
8486 {
8487 // empty column - give default extent (notice that if extentMax is less
8488 // than default extent but != 0, it's ok)
8489 extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
8490 }
8491 else
8492 {
8493 if ( column )
8494 {
8495 // leave some space around text
8496 extentMax += 10;
8497 }
8498 else
8499 {
8500 extentMax += 6;
8501 }
8502 }
8503
8504 if ( column )
8505 {
8506 SetColSize(col, extentMax);
8507 if ( !GetBatchCount() )
8508 {
8509 int cw, ch, dummy;
8510 m_gridWin->GetClientSize( &cw, &ch );
8511 wxRect rect ( CellToRect( 0, col ) );
8512 rect.y = 0;
8513 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
8514 rect.width = cw - rect.x;
8515 rect.height = m_colLabelHeight;
8516 m_colLabelWin->Refresh( TRUE, &rect );
8517 }
8518 }
8519 else
8520 {
8521 SetRowSize(row, extentMax);
8522 if ( !GetBatchCount() )
8523 {
8524 int cw, ch, dummy;
8525 m_gridWin->GetClientSize( &cw, &ch );
8526 wxRect rect ( CellToRect( row, 0 ) );
8527 rect.x = 0;
8528 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
8529 rect.width = m_rowLabelWidth;
8530 rect.height = ch - rect.y;
8531 m_rowLabelWin->Refresh( TRUE, &rect );
8532 }
8533 }
8534 if ( setAsMin )
8535 {
8536 if ( column )
8537 SetColMinimalWidth(col, extentMax);
8538 else
8539 SetRowMinimalHeight(row, extentMax);
8540 }
8541 }
8542
8543 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
8544 {
8545 int width = m_rowLabelWidth;
8546
8547 if ( !calcOnly )
8548 BeginBatch();
8549
8550 for ( int col = 0; col < m_numCols; col++ )
8551 {
8552 if ( !calcOnly )
8553 {
8554 AutoSizeColumn(col, setAsMin);
8555 }
8556
8557 width += GetColWidth(col);
8558 }
8559
8560 if ( !calcOnly )
8561 EndBatch();
8562
8563 return width;
8564 }
8565
8566 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
8567 {
8568 int height = m_colLabelHeight;
8569
8570 if ( !calcOnly )
8571 BeginBatch();
8572
8573 for ( int row = 0; row < m_numRows; row++ )
8574 {
8575 if ( !calcOnly )
8576 {
8577 AutoSizeRow(row, setAsMin);
8578 }
8579
8580 height += GetRowHeight(row);
8581 }
8582
8583 if ( !calcOnly )
8584 EndBatch();
8585
8586 return height;
8587 }
8588
8589 void wxGrid::AutoSize()
8590 {
8591 BeginBatch();
8592
8593 wxSize size(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
8594
8595 // round up the size to a multiple of scroll step - this ensures that we
8596 // won't get the scrollbars if we're sized exactly to this width
8597 wxSize sizeFit(GetScrollX(size.x) * GRID_SCROLL_LINE_X,
8598 GetScrollY(size.y) * GRID_SCROLL_LINE_Y);
8599
8600 // distribute the extra space between teh columns/rows to avoid having
8601 // extra white space
8602 wxCoord diff = sizeFit.x - size.x;
8603 if ( diff )
8604 {
8605 // try to resize the columns uniformly
8606 wxCoord diffPerCol = diff / m_numCols;
8607 if ( diffPerCol )
8608 {
8609 for ( int col = 0; col < m_numCols; col++ )
8610 {
8611 SetColSize(col, GetColWidth(col) + diffPerCol);
8612 }
8613 }
8614
8615 // add remaining amount to the last columns
8616 diff -= diffPerCol * m_numCols;
8617 if ( diff )
8618 {
8619 for ( int col = m_numCols - 1; col >= m_numCols - diff; col-- )
8620 {
8621 SetColSize(col, GetColWidth(col) + 1);
8622 }
8623 }
8624 }
8625
8626 // same for rows
8627 diff = sizeFit.y - size.y;
8628 if ( diff )
8629 {
8630 // try to resize the columns uniformly
8631 wxCoord diffPerRow = diff / m_numRows;
8632 if ( diffPerRow )
8633 {
8634 for ( int row = 0; row < m_numRows; row++ )
8635 {
8636 SetRowSize(row, GetRowHeight(row) + diffPerRow);
8637 }
8638 }
8639
8640 // add remaining amount to the last rows
8641 diff -= diffPerRow * m_numRows;
8642 if ( diff )
8643 {
8644 for ( int row = m_numRows - 1; row >= m_numRows - diff; row-- )
8645 {
8646 SetRowSize(row, GetRowHeight(row) + 1);
8647 }
8648 }
8649 }
8650
8651 EndBatch();
8652
8653 SetClientSize(sizeFit);
8654 }
8655
8656 wxSize wxGrid::DoGetBestSize() const
8657 {
8658 // don't set sizes, only calculate them
8659 wxGrid *self = (wxGrid *)this; // const_cast
8660
8661 return wxSize(self->SetOrCalcColumnSizes(TRUE),
8662 self->SetOrCalcRowSizes(TRUE));
8663 }
8664
8665 void wxGrid::Fit()
8666 {
8667 AutoSize();
8668 }
8669
8670
8671 wxPen& wxGrid::GetDividerPen() const
8672 {
8673 return wxNullPen;
8674 }
8675
8676 // ----------------------------------------------------------------------------
8677 // cell value accessor functions
8678 // ----------------------------------------------------------------------------
8679
8680 void wxGrid::SetCellValue( int row, int col, const wxString& s )
8681 {
8682 if ( m_table )
8683 {
8684 m_table->SetValue( row, col, s );
8685 if ( !GetBatchCount() )
8686 {
8687 wxClientDC dc( m_gridWin );
8688 PrepareDC( dc );
8689 DrawCell( dc, wxGridCellCoords(row, col) );
8690 }
8691
8692 if ( m_currentCellCoords.GetRow() == row &&
8693 m_currentCellCoords.GetCol() == col &&
8694 IsCellEditControlShown())
8695 // Note: If we are using IsCellEditControlEnabled,
8696 // this interacts badly with calling SetCellValue from
8697 // an EVT_GRID_CELL_CHANGE handler.
8698 {
8699 HideCellEditControl();
8700 ShowCellEditControl(); // will reread data from table
8701 }
8702 }
8703 }
8704
8705
8706 //
8707 // ------ Block, row and col selection
8708 //
8709
8710 void wxGrid::SelectRow( int row, bool addToSelected )
8711 {
8712 if ( IsSelection() && !addToSelected )
8713 ClearSelection();
8714
8715 m_selection->SelectRow( row, FALSE, addToSelected );
8716 }
8717
8718
8719 void wxGrid::SelectCol( int col, bool addToSelected )
8720 {
8721 if ( IsSelection() && !addToSelected )
8722 ClearSelection();
8723
8724 m_selection->SelectCol( col, FALSE, addToSelected );
8725 }
8726
8727
8728 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
8729 bool addToSelected )
8730 {
8731 if ( IsSelection() && !addToSelected )
8732 ClearSelection();
8733
8734 m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
8735 FALSE, addToSelected );
8736 }
8737
8738
8739 void wxGrid::SelectAll()
8740 {
8741 if ( m_numRows > 0 && m_numCols > 0 )
8742 m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
8743 }
8744
8745 //
8746 // ------ Cell, row and col deselection
8747 //
8748
8749 void wxGrid::DeselectRow( int row )
8750 {
8751 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
8752 {
8753 if ( m_selection->IsInSelection(row, 0 ) )
8754 m_selection->ToggleCellSelection( row, 0);
8755 }
8756 else
8757 {
8758 int nCols = GetNumberCols();
8759 for ( int i = 0; i < nCols ; i++ )
8760 {
8761 if ( m_selection->IsInSelection(row, i ) )
8762 m_selection->ToggleCellSelection( row, i);
8763 }
8764 }
8765 }
8766
8767 void wxGrid::DeselectCol( int col )
8768 {
8769 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
8770 {
8771 if ( m_selection->IsInSelection(0, col ) )
8772 m_selection->ToggleCellSelection( 0, col);
8773 }
8774 else
8775 {
8776 int nRows = GetNumberRows();
8777 for ( int i = 0; i < nRows ; i++ )
8778 {
8779 if ( m_selection->IsInSelection(i, col ) )
8780 m_selection->ToggleCellSelection(i, col);
8781 }
8782 }
8783 }
8784
8785 void wxGrid::DeselectCell( int row, int col )
8786 {
8787 if ( m_selection->IsInSelection(row, col) )
8788 m_selection->ToggleCellSelection(row, col);
8789 }
8790
8791 bool wxGrid::IsSelection()
8792 {
8793 return ( m_selection->IsSelection() ||
8794 ( m_selectingTopLeft != wxGridNoCellCoords &&
8795 m_selectingBottomRight != wxGridNoCellCoords ) );
8796 }
8797
8798 bool wxGrid::IsInSelection( int row, int col )
8799 {
8800 return ( m_selection->IsInSelection( row, col ) ||
8801 ( row >= m_selectingTopLeft.GetRow() &&
8802 col >= m_selectingTopLeft.GetCol() &&
8803 row <= m_selectingBottomRight.GetRow() &&
8804 col <= m_selectingBottomRight.GetCol() ) );
8805 }
8806
8807 void wxGrid::ClearSelection()
8808 {
8809 m_selectingTopLeft = wxGridNoCellCoords;
8810 m_selectingBottomRight = wxGridNoCellCoords;
8811 m_selection->ClearSelection();
8812 }
8813
8814
8815 // This function returns the rectangle that encloses the given block
8816 // in device coords clipped to the client size of the grid window.
8817 //
8818 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
8819 const wxGridCellCoords &bottomRight )
8820 {
8821 wxRect rect( wxGridNoCellRect );
8822 wxRect cellRect;
8823
8824 cellRect = CellToRect( topLeft );
8825 if ( cellRect != wxGridNoCellRect )
8826 {
8827 rect = cellRect;
8828 }
8829 else
8830 {
8831 rect = wxRect( 0, 0, 0, 0 );
8832 }
8833
8834 cellRect = CellToRect( bottomRight );
8835 if ( cellRect != wxGridNoCellRect )
8836 {
8837 rect += cellRect;
8838 }
8839 else
8840 {
8841 return wxGridNoCellRect;
8842 }
8843
8844 // convert to scrolled coords
8845 //
8846 int left, top, right, bottom;
8847 CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
8848 CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
8849
8850 int cw, ch;
8851 m_gridWin->GetClientSize( &cw, &ch );
8852
8853 if (right < 0 || bottom < 0 || left > cw || top > ch)
8854 return wxRect( 0, 0, 0, 0);
8855
8856 rect.SetLeft( wxMax(0, left) );
8857 rect.SetTop( wxMax(0, top) );
8858 rect.SetRight( wxMin(cw, right) );
8859 rect.SetBottom( wxMin(ch, bottom) );
8860
8861 return rect;
8862 }
8863
8864
8865
8866 //
8867 // ------ Grid event classes
8868 //
8869
8870 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
8871
8872 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
8873 int row, int col, int x, int y, bool sel,
8874 bool control, bool shift, bool alt, bool meta )
8875 : wxNotifyEvent( type, id )
8876 {
8877 m_row = row;
8878 m_col = col;
8879 m_x = x;
8880 m_y = y;
8881 m_selecting = sel;
8882 m_control = control;
8883 m_shift = shift;
8884 m_alt = alt;
8885 m_meta = meta;
8886
8887 SetEventObject(obj);
8888 }
8889
8890
8891 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
8892
8893 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
8894 int rowOrCol, int x, int y,
8895 bool control, bool shift, bool alt, bool meta )
8896 : wxNotifyEvent( type, id )
8897 {
8898 m_rowOrCol = rowOrCol;
8899 m_x = x;
8900 m_y = y;
8901 m_control = control;
8902 m_shift = shift;
8903 m_alt = alt;
8904 m_meta = meta;
8905
8906 SetEventObject(obj);
8907 }
8908
8909
8910 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
8911
8912 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8913 const wxGridCellCoords& topLeft,
8914 const wxGridCellCoords& bottomRight,
8915 bool sel, bool control,
8916 bool shift, bool alt, bool meta )
8917 : wxNotifyEvent( type, id )
8918 {
8919 m_topLeft = topLeft;
8920 m_bottomRight = bottomRight;
8921 m_selecting = sel;
8922 m_control = control;
8923 m_shift = shift;
8924 m_alt = alt;
8925 m_meta = meta;
8926
8927 SetEventObject(obj);
8928 }
8929
8930
8931 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
8932
8933 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
8934 wxObject* obj, int row,
8935 int col, wxControl* ctrl)
8936 : wxCommandEvent(type, id)
8937 {
8938 SetEventObject(obj);
8939 m_row = row;
8940 m_col = col;
8941 m_ctrl = ctrl;
8942 }
8943
8944
8945 #endif // !wxUSE_NEW_GRID/wxUSE_NEW_GRID
8946
8947 #endif // wxUSE_GRID
8948
wxWidgets (Impactor)