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


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