]> git.saurik.com Git - wxWidgets.git/blob - src/generic/grid.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added sqltypes.h (for Cygwin b20), some other Cygwin fixes.
[wxWidgets.git] / src / generic / grid.cpp
1 ////////////////////////////////////////////////////////////////////////////
2 // Name: 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 // For compilers that support precompilation, includes "wx/wx.h".
13 #include "wx/wxprec.h"
14
15 #include "wx/defs.h"
16
17 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
18 #include "gridg.cpp"
19 #else
20
21 #ifdef __GNUG__
22 #pragma implementation "grid.h"
23 #endif
24
25
26 #ifdef __BORLANDC__
27 #pragma hdrstop
28 #endif
29
30 #ifndef WX_PRECOMP
31 #include "wx/utils.h"
32 #include "wx/dcclient.h"
33 #include "wx/settings.h"
34 #include "wx/log.h"
35 #endif
36
37 #include "wx/generic/grid.h"
38
39
40 //////////////////////////////////////////////////////////////////////
41
42 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
43 wxRect wxGridNoCellRect( -1, -1, -1, -1 );
44
45
46
47 //////////////////////////////////////////////////////////////////////
48 //
49 // Abstract base class for grid data (the model)
50 //
51 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
52
53
54 wxGridTableBase::wxGridTableBase()
55 : wxObject()
56 {
57 m_view = (wxGrid *) NULL;
58 }
59
60 wxGridTableBase::~wxGridTableBase()
61 {
62 }
63
64
65 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
66 {
67 wxLogWarning( "Called grid table class function InsertRows(pos=%d, N=%d)\n"
68 "but your derived table class does not override this function",
69 pos, numRows );
70
71 return FALSE;
72 }
73
74 bool wxGridTableBase::AppendRows( size_t numRows )
75 {
76 wxLogWarning( "Called grid table class function AppendRows(N=%d)\n"
77 "but your derived table class does not override this function",
78 numRows );
79
80 return FALSE;
81 }
82
83 bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
84 {
85 wxLogWarning( "Called grid table class function DeleteRows(pos=%d, N=%d)\n"
86 "but your derived table class does not override this function",
87 pos, numRows );
88
89 return FALSE;
90 }
91
92 bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
93 {
94 wxLogWarning( "Called grid table class function InsertCols(pos=%d, N=%d)\n"
95 "but your derived table class does not override this function",
96 pos, numCols );
97
98 return FALSE;
99 }
100
101 bool wxGridTableBase::AppendCols( size_t numCols )
102 {
103 wxLogWarning( "Called grid table class function AppendCols(N=%d)\n"
104 "but your derived table class does not override this function",
105 numCols );
106
107 return FALSE;
108 }
109
110 bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
111 {
112 wxLogWarning( "Called grid table class function DeleteCols(pos=%d, N=%d)\n"
113 "but your derived table class does not override this function",
114 pos, numCols );
115
116 return FALSE;
117 }
118
119
120 wxString wxGridTableBase::GetRowLabelValue( int row )
121 {
122 wxString s;
123 s << row;
124 return s;
125 }
126
127 wxString wxGridTableBase::GetColLabelValue( int col )
128 {
129 // default col labels are:
130 // cols 0 to 25 : A-Z
131 // cols 26 to 675 : AA-ZZ
132 // etc.
133
134 wxString s;
135 unsigned int i, n;
136 for ( n = 1; ; n++ )
137 {
138 s += ('A' + (char)( col%26 ));
139 col = col/26 - 1;
140 if ( col < 0 ) break;
141 }
142
143 // reverse the string...
144 wxString s2;
145 for ( i = 0; i < n; i++ )
146 {
147 s2 += s[n-i-1];
148 }
149
150 return s2;
151 }
152
153
154
155 //////////////////////////////////////////////////////////////////////
156 //
157 // Message class for the grid table to send requests and notifications
158 // to the grid view
159 //
160
161 wxGridTableMessage::wxGridTableMessage()
162 {
163 m_table = (wxGridTableBase *) NULL;
164 m_id = -1;
165 m_comInt1 = -1;
166 m_comInt2 = -1;
167 }
168
169 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
170 int commandInt1, int commandInt2 )
171 {
172 m_table = table;
173 m_id = id;
174 m_comInt1 = commandInt1;
175 m_comInt2 = commandInt2;
176 }
177
178
179
180 //////////////////////////////////////////////////////////////////////
181 //
182 // A basic grid table for string data. An object of this class will
183 // created by wxGrid if you don't specify an alternative table class.
184 //
185
186
187 // this is a magic incantation which must be done!
188 #include <wx/arrimpl.cpp>
189
190 WX_DEFINE_OBJARRAY(wxGridStringArray)
191
192 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
193
194 wxGridStringTable::wxGridStringTable()
195 : wxGridTableBase()
196 {
197 }
198
199 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
200 : wxGridTableBase()
201 {
202 int row, col;
203
204 m_data.Alloc( numRows );
205
206 wxArrayString sa;
207 sa.Alloc( numCols );
208 for ( col = 0; col < numCols; col++ )
209 {
210 sa.Add( wxEmptyString );
211 }
212
213 for ( row = 0; row < numRows; row++ )
214 {
215 m_data.Add( sa );
216 }
217 }
218
219 wxGridStringTable::~wxGridStringTable()
220 {
221 }
222
223 long wxGridStringTable::GetNumberRows()
224 {
225 return m_data.GetCount();
226 }
227
228 long wxGridStringTable::GetNumberCols()
229 {
230 if ( m_data.GetCount() > 0 )
231 return m_data[0].GetCount();
232 else
233 return 0;
234 }
235
236 wxString wxGridStringTable::GetValue( int row, int col )
237 {
238 // TODO: bounds checking
239 //
240 return m_data[row][col];
241 }
242
243 void wxGridStringTable::SetValue( int row, int col, const wxString& s )
244 {
245 // TODO: bounds checking
246 //
247 m_data[row][col] = s;
248 }
249
250 bool wxGridStringTable::IsEmptyCell( int row, int col )
251 {
252 // TODO: bounds checking
253 //
254 return (m_data[row][col] == wxEmptyString);
255 }
256
257
258 void wxGridStringTable::Clear()
259 {
260 int row, col;
261 int numRows, numCols;
262
263 numRows = m_data.GetCount();
264 if ( numRows > 0 )
265 {
266 numCols = m_data[0].GetCount();
267
268 for ( row = 0; row < numRows; row++ )
269 {
270 for ( col = 0; col < numCols; col++ )
271 {
272 m_data[row][col] = wxEmptyString;
273 }
274 }
275 }
276 }
277
278
279 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
280 {
281 size_t row, col;
282
283 size_t curNumRows = m_data.GetCount();
284 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
285
286 if ( pos >= curNumRows )
287 {
288 return AppendRows( numRows );
289 }
290
291 wxArrayString sa;
292 sa.Alloc( curNumCols );
293 for ( col = 0; col < curNumCols; col++ )
294 {
295 sa.Add( wxEmptyString );
296 }
297
298 for ( row = pos; row < pos + numRows; row++ )
299 {
300 m_data.Insert( sa, row );
301 }
302
303 if ( GetView() )
304 {
305 wxGridTableMessage msg( this,
306 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
307 pos,
308 numRows );
309
310 GetView()->ProcessTableMessage( msg );
311 }
312
313 return TRUE;
314 }
315
316 bool wxGridStringTable::AppendRows( size_t numRows )
317 {
318 size_t row, col;
319
320 size_t curNumRows = m_data.GetCount();
321 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
322
323 wxArrayString sa;
324 if ( curNumCols > 0 )
325 {
326 sa.Alloc( curNumCols );
327 for ( col = 0; col < curNumCols; col++ )
328 {
329 sa.Add( wxEmptyString );
330 }
331 }
332
333 for ( row = 0; row < numRows; row++ )
334 {
335 m_data.Add( sa );
336 }
337
338 if ( GetView() )
339 {
340 wxGridTableMessage msg( this,
341 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
342 numRows );
343
344 GetView()->ProcessTableMessage( msg );
345 }
346
347 return TRUE;
348 }
349
350 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
351 {
352 size_t n;
353
354 size_t curNumRows = m_data.GetCount();
355
356 if ( pos >= curNumRows )
357 {
358 wxLogError( "Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
359 "Pos value is invalid for present table with %d rows",
360 pos, numRows, curNumRows );
361 return FALSE;
362 }
363
364 if ( numRows > curNumRows - pos )
365 {
366 numRows = curNumRows - pos;
367 }
368
369 if ( numRows >= curNumRows )
370 {
371 m_data.Empty(); // don't release memory just yet
372 }
373 else
374 {
375 for ( n = 0; n < numRows; n++ )
376 {
377 m_data.Remove( pos );
378 }
379 }
380
381 if ( GetView() )
382 {
383 wxGridTableMessage msg( this,
384 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
385 pos,
386 numRows );
387
388 GetView()->ProcessTableMessage( msg );
389 }
390
391 return TRUE;
392 }
393
394 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
395 {
396 size_t row, col;
397
398 size_t curNumRows = m_data.GetCount();
399 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
400
401 if ( pos >= curNumCols )
402 {
403 return AppendCols( numCols );
404 }
405
406 for ( row = 0; row < curNumRows; row++ )
407 {
408 for ( col = pos; col < pos + numCols; col++ )
409 {
410 m_data[row].Insert( wxEmptyString, col );
411 }
412 }
413
414 if ( GetView() )
415 {
416 wxGridTableMessage msg( this,
417 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
418 pos,
419 numCols );
420
421 GetView()->ProcessTableMessage( msg );
422 }
423
424 return TRUE;
425 }
426
427 bool wxGridStringTable::AppendCols( size_t numCols )
428 {
429 size_t row, n;
430
431 size_t curNumRows = m_data.GetCount();
432 if ( !curNumRows )
433 {
434 // TODO: something better than this ?
435 //
436 wxLogError( "Unable to append cols to a grid table with no rows.\n"
437 "Call AppendRows() first" );
438 return FALSE;
439 }
440
441 for ( row = 0; row < curNumRows; row++ )
442 {
443 for ( n = 0; n < numCols; n++ )
444 {
445 m_data[row].Add( wxEmptyString );
446 }
447 }
448
449 if ( GetView() )
450 {
451 wxGridTableMessage msg( this,
452 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
453 numCols );
454
455 GetView()->ProcessTableMessage( msg );
456 }
457
458 return TRUE;
459 }
460
461 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
462 {
463 size_t row, n;
464
465 size_t curNumRows = m_data.GetCount();
466 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
467
468 if ( pos >= curNumCols )
469 {
470 wxLogError( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
471 "Pos value is invalid for present table with %d cols",
472 pos, numCols, curNumCols );
473 return FALSE;
474 }
475
476 if ( numCols > curNumCols - pos )
477 {
478 numCols = curNumCols - pos;
479 }
480
481 for ( row = 0; row < curNumRows; row++ )
482 {
483 if ( numCols >= curNumCols )
484 {
485 m_data[row].Clear();
486 }
487 else
488 {
489 for ( n = 0; n < numCols; n++ )
490 {
491 m_data[row].Remove( pos );
492 }
493 }
494 }
495
496 if ( GetView() )
497 {
498 wxGridTableMessage msg( this,
499 wxGRIDTABLE_NOTIFY_COLS_DELETED,
500 pos,
501 numCols );
502
503 GetView()->ProcessTableMessage( msg );
504 }
505
506 return TRUE;
507 }
508
509 wxString wxGridStringTable::GetRowLabelValue( int row )
510 {
511 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
512 {
513 // using default label
514 //
515 return wxGridTableBase::GetRowLabelValue( row );
516 }
517 else
518 {
519 return m_rowLabels[ row ];
520 }
521 }
522
523 wxString wxGridStringTable::GetColLabelValue( int col )
524 {
525 if ( col > (int)(m_colLabels.GetCount()) - 1 )
526 {
527 // using default label
528 //
529 return wxGridTableBase::GetColLabelValue( col );
530 }
531 else
532 {
533 return m_colLabels[ col ];
534 }
535 }
536
537 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
538 {
539 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
540 {
541 int n = m_rowLabels.GetCount();
542 int i;
543 for ( i = n; i <= row; i++ )
544 {
545 m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
546 }
547 }
548
549 m_rowLabels[row] = value;
550 }
551
552 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
553 {
554 if ( col > (int)(m_colLabels.GetCount()) - 1 )
555 {
556 int n = m_colLabels.GetCount();
557 int i;
558 for ( i = n; i <= col; i++ )
559 {
560 m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
561 }
562 }
563
564 m_colLabels[col] = value;
565 }
566
567
568
569
570 //////////////////////////////////////////////////////////////////////
571
572 IMPLEMENT_DYNAMIC_CLASS( wxGridTextCtrl, wxTextCtrl )
573
574 BEGIN_EVENT_TABLE( wxGridTextCtrl, wxTextCtrl )
575 EVT_KEY_DOWN( wxGridTextCtrl::OnKeyDown )
576 END_EVENT_TABLE()
577
578
579 wxGridTextCtrl::wxGridTextCtrl( wxWindow *par,
580 bool isCellControl,
581 wxWindowID id,
582 const wxString& value,
583 const wxPoint& pos,
584 const wxSize& size,
585 long style )
586 : wxTextCtrl( par, id, value, pos, size, style )
587 {
588 m_isCellControl = isCellControl;
589 }
590
591
592 void wxGridTextCtrl::OnKeyDown( wxKeyEvent& ev )
593 {
594 switch ( ev.KeyCode() )
595 {
596 case WXK_ESCAPE:
597 ((wxGrid *)GetParent())->SetEditControlValue( startValue );
598 SetInsertionPointEnd();
599 break;
600
601 case WXK_UP:
602 case WXK_DOWN:
603 case WXK_LEFT:
604 case WXK_RIGHT:
605 case WXK_RETURN:
606 if ( m_isCellControl )
607 {
608 // send the event to the parent grid, skipping the
609 // event if nothing happens
610 //
611 ev.Skip( !GetParent()->ProcessEvent( ev ) );
612 }
613 else
614 {
615 // default text control response within the top edit
616 // control
617 //
618 ev.Skip();
619 }
620 break;
621
622 case WXK_HOME:
623 case WXK_END:
624 if ( m_isCellControl )
625 {
626 // send the event to the parent grid, skipping the
627 // event if nothing happens
628 //
629 ev.Skip( !GetParent()->ProcessEvent( ev ) );
630 }
631 else
632 {
633 // default text control response within the top edit
634 // control
635 //
636 ev.Skip();
637 }
638 break;
639
640 default:
641 ev.Skip();
642 }
643 }
644
645 void wxGridTextCtrl::SetStartValue( const wxString& s )
646 {
647 startValue = s;
648 wxTextCtrl::SetValue( s.c_str() );
649 }
650
651
652 //////////////////////////////////////////////////////////////////////
653
654 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxPanel )
655
656
657 BEGIN_EVENT_TABLE( wxGrid, wxPanel )
658 EVT_PAINT( wxGrid::OnPaint )
659 EVT_SIZE( wxGrid::OnSize )
660 EVT_MOUSE_EVENTS( wxGrid::OnMouse )
661 EVT_KEY_DOWN( wxGrid::OnKeyDown )
662 EVT_TEXT( wxGRID_CELLCTRL, wxGrid::OnText )
663 EVT_TEXT( wxGRID_TOPCTRL, wxGrid::OnText )
664 EVT_COMMAND_SCROLL( wxGRID_HORIZSCROLL, wxGrid::OnGridScroll)
665 EVT_COMMAND_SCROLL( wxGRID_VERTSCROLL, wxGrid::OnGridScroll)
666 END_EVENT_TABLE()
667
668
669 wxGrid::~wxGrid()
670 {
671 delete m_table;
672 }
673
674
675 //
676 // ----- internal init and update functions
677 //
678
679 void wxGrid::Create()
680 {
681 m_table = (wxGridTableBase *) NULL;
682 m_topEditCtrl = (wxWindow *) NULL;
683 m_cellEditCtrl = (wxWindow *) NULL;
684 m_horizScrollBar = (wxScrollBar *) NULL;
685 m_vertScrollBar = (wxScrollBar *) NULL;
686
687 m_numRows = 0;
688 m_numCols = 0;
689 m_created = FALSE;
690 }
691
692 void wxGrid::Init()
693 {
694 int i;
695
696 m_left = 0;
697 m_top = 0;
698
699 // TODO: perhaps have a style flag for control panel
700 //
701 m_topEditCtrlEnabled = FALSE;
702 m_topEditCtrl = new wxGridTextCtrl( this,
703 FALSE,
704 wxGRID_TOPCTRL,
705 "",
706 wxPoint(10, 10),
707 wxSize(WXGRID_DEFAULT_TOPEDIT_WIDTH,
708 WXGRID_DEFAULT_TOPEDIT_HEIGHT),
709 wxTE_MULTILINE );
710 m_topEditCtrl->Show( FALSE );
711
712 if ( m_numRows <= 0 )
713 m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
714
715 if ( m_numCols <= 0 )
716 m_numCols = WXGRID_DEFAULT_NUMBER_COLS;
717
718 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
719 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
720
721 // default labels are pale grey with black text
722 //
723 m_labelBackgroundColour = wxColour( 192, 192, 192 );
724 m_labelTextColour = wxColour( 0, 0, 0 );
725
726 // TODO: something better than this ?
727 //
728 m_labelFont = this->GetFont();
729 m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
730
731 m_rowLabelHorizAlign = wxLEFT;
732 m_rowLabelVertAlign = wxCENTRE;
733
734 m_colLabelHorizAlign = wxCENTRE;
735 m_colLabelVertAlign = wxTOP;
736
737 m_defaultRowHeight = WXGRID_DEFAULT_ROW_HEIGHT;
738 m_defaultColWidth = WXGRID_DEFAULT_COL_WIDTH;
739
740 m_rowHeights.Alloc( m_numRows );
741 m_rowBottoms.Alloc( m_numRows );
742 for ( i = 0; i < m_numRows; i++ )
743 {
744 m_rowHeights.Add( m_defaultRowHeight );
745 m_rowBottoms.Add( 0 ); // set by CalcDimensions()
746 }
747
748 m_colWidths.Alloc( m_numCols );
749 m_colRights.Alloc( m_numRows );
750 for ( i = 0; i < m_numCols; i++ )
751 {
752 m_colWidths.Add( m_defaultColWidth );
753 m_colRights.Add( 0 ); // set by CalcDimensions()
754 }
755
756 // TODO: improve this ?
757 //
758 m_defaultCellFont = this->GetFont();
759
760 m_gridLineColour = wxColour( 0, 0, 255 );
761 m_gridLinesEnabled = TRUE;
762
763 m_scrollBarWidth = WXGRID_DEFAULT_SCROLLBAR_WIDTH;
764
765 m_horizScrollBar = new wxScrollBar( this,
766 wxGRID_HORIZSCROLL,
767 wxPoint(0, 0),
768 wxSize(10, 10),
769 wxHORIZONTAL);
770
771 m_vertScrollBar = new wxScrollBar( this,
772 wxGRID_VERTSCROLL,
773 wxPoint(0, 0),
774 wxSize(10, 10),
775 wxVERTICAL);
776 m_scrollPosX = 0;
777 m_scrollPosY = 0;
778 m_wholeColsVisible = 0;
779 m_wholeRowsVisible = 0;
780
781 m_firstPaint = TRUE;
782 m_inOnKeyDown = FALSE;
783 m_batchCount = 0;
784
785 m_cursorMode = WXGRID_CURSOR_DEFAULT;
786 m_dragLastPos = -1;
787 m_dragRowOrCol = -1;
788 m_isDragging = FALSE;
789
790 m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
791 m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
792
793 m_currentCellCoords = wxGridNoCellCoords;
794 m_currentCellHighlighted = FALSE;
795
796 m_selectedTopLeft = wxGridNoCellCoords;
797 m_selectedBottomRight = wxGridNoCellCoords;
798
799 m_editable = TRUE; // default for whole grid
800
801 // TODO: extend this to other types of controls
802 //
803 m_cellEditCtrl = new wxGridTextCtrl( this,
804 TRUE,
805 wxGRID_CELLCTRL,
806 "",
807 wxPoint(1,1),
808 wxSize(1,1),
809 wxNO_BORDER
810 #ifdef __WXMSW__
811 | wxTE_MULTILINE | wxTE_NO_VSCROLL
812 #endif
813 );
814
815 m_cellEditCtrl->Show( FALSE );
816 m_cellEditCtrlEnabled = TRUE;
817 m_editCtrlType = wxGRID_TEXTCTRL;
818
819 // Not really needed here, it gets called by OnSize()
820 //
821 // CalcDimensions();
822 }
823
824
825 void wxGrid::CalcDimensions()
826 {
827 int i;
828
829 if ( IsTopEditControlEnabled() )
830 {
831 int ctrlW, ctrlH;
832 m_topEditCtrl->GetSize( &ctrlW, &ctrlH );
833
834 m_top = ctrlH + 20;
835 }
836 else
837 {
838 m_top = 0;
839 }
840
841 int bottom = m_top + m_colLabelHeight;
842 for ( i = m_scrollPosY; i < m_numRows; i++ )
843 {
844 bottom += m_rowHeights[i];
845 m_rowBottoms[i] = bottom;
846 }
847
848 int right = m_left + m_rowLabelWidth;
849 for ( i = m_scrollPosX; i < m_numCols; i++ )
850 {
851 right += m_colWidths[i];
852 m_colRights[i] = right;
853 }
854
855 // adjust the scroll bars
856 //
857
858 int cw, ch;
859 GetClientSize(&cw, &ch);
860
861 // begin by assuming that we don't need either scroll bar
862 //
863 int vertScrollBarWidth = 0;
864 int horizScrollBarHeight = 0;
865
866 // Each scroll bar needs to eventually know if the other one is
867 // required in deciding whether or not it is also required - hence
868 // this loop. A bit inelegant but simple and it works.
869 //
870 int check;
871 for ( check = 0; check < 2; check++ )
872 {
873 if ( m_numRows > 0 &&
874 m_rowBottoms[m_numRows-1] + horizScrollBarHeight > ch )
875 {
876 vertScrollBarWidth = m_scrollBarWidth;
877
878 m_wholeRowsVisible = 0;
879 for ( i = m_scrollPosY; i < m_numRows; i++ )
880 {
881 // A partial row doesn't count, we still have to scroll to
882 // see the rest of it
883 if ( m_rowBottoms[i] + horizScrollBarHeight > ch ) break;
884
885 m_wholeRowsVisible++ ;
886 }
887 }
888 else
889 {
890 m_wholeRowsVisible = m_numRows - m_scrollPosY;
891 if ( m_scrollPosY )
892 {
893 vertScrollBarWidth = m_scrollBarWidth;
894 }
895 }
896
897
898 if ( m_numCols &&
899 m_colRights[m_numCols-1] + vertScrollBarWidth > cw)
900 {
901 horizScrollBarHeight = m_scrollBarWidth;
902
903 m_wholeColsVisible = 0;
904 for ( i = m_scrollPosX; i < m_numCols; i++ )
905 {
906 // A partial col doesn't count, we still have to scroll to
907 // see the rest of it
908 if ( m_colRights[i] + vertScrollBarWidth > cw ) break;
909
910 m_wholeColsVisible++ ;
911 }
912 }
913 else
914 {
915 // we can see the right-most column
916 //
917 m_wholeColsVisible = m_numCols - m_scrollPosX;
918 if ( m_scrollPosX )
919 {
920 horizScrollBarHeight = m_scrollBarWidth;
921 }
922 }
923 }
924
925
926 if ( m_vertScrollBar )
927 {
928 if ( !vertScrollBarWidth )
929 {
930 m_vertScrollBar->Show(FALSE);
931 }
932 else
933 {
934 m_vertScrollBar->Show(TRUE);
935 m_vertScrollBar->SetScrollbar(
936 m_scrollPosY,
937 wxMax(m_wholeRowsVisible, 1),
938 (m_wholeRowsVisible == 0 ? 1 : m_numRows),
939 wxMax(m_wholeRowsVisible, 1) );
940
941 m_vertScrollBar->SetSize( cw - m_scrollBarWidth,
942 m_top,
943 m_scrollBarWidth,
944 ch - m_top - horizScrollBarHeight);
945 }
946 }
947
948 if ( m_horizScrollBar )
949 {
950 if ( !horizScrollBarHeight )
951 {
952 m_horizScrollBar->Show(FALSE);
953 }
954 else
955 {
956 m_horizScrollBar->Show(TRUE);
957
958 m_horizScrollBar->SetScrollbar(
959 m_scrollPosX,
960 wxMax(m_wholeColsVisible, 1),
961 (m_wholeColsVisible == 0) ? 1 : m_numCols,
962 wxMax(m_wholeColsVisible, 1) );
963
964 m_horizScrollBar->SetSize( m_left,
965 ch - m_scrollBarWidth,
966 cw - m_left - vertScrollBarWidth,
967 m_scrollBarWidth );
968 }
969 }
970
971 m_bottom = m_right = 0;
972 if ( m_numRows > 0 )
973 {
974 m_bottom = wxMin( m_rowBottoms[m_numRows-1],
975 ch - horizScrollBarHeight );
976 }
977 if ( m_numCols > 0 )
978 {
979 m_right = wxMin( m_colRights[m_numCols-1],
980 cw - vertScrollBarWidth );
981 }
982 }
983
984
985 bool wxGrid::IsOnScreen()
986 {
987 int cw, ch;
988 GetClientSize( &cw, &ch );
989 return ( cw > 10 );
990 }
991
992
993 // this is called when the grid table sends a message to say that it
994 // has been redimensioned
995 //
996 bool wxGrid::Redimension( wxGridTableMessage& msg )
997 {
998 int i;
999
1000 switch ( msg.GetId() )
1001 {
1002 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
1003 {
1004 size_t pos = msg.GetCommandInt();
1005 int numRows = msg.GetCommandInt2();
1006 for ( i = 0; i < numRows; i++ )
1007 {
1008 m_rowHeights.Insert( m_defaultRowHeight, pos );
1009 m_rowBottoms.Insert( 0, pos );
1010 }
1011 m_numRows += numRows;
1012 CalcDimensions();
1013 }
1014 return TRUE;
1015
1016 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
1017 {
1018 int numRows = msg.GetCommandInt();
1019 for ( i = 0; i < numRows; i++ )
1020 {
1021 m_rowHeights.Add( m_defaultRowHeight );
1022 m_rowBottoms.Add( 0 );
1023 }
1024 m_numRows += numRows;
1025 CalcDimensions();
1026 }
1027 return TRUE;
1028
1029 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
1030 {
1031 size_t pos = msg.GetCommandInt();
1032 int numRows = msg.GetCommandInt2();
1033 for ( i = 0; i < numRows; i++ )
1034 {
1035 m_rowHeights.Remove( pos );
1036 m_rowBottoms.Remove( pos );
1037 }
1038 m_numRows -= numRows;
1039
1040 // TODO: improve these adjustments...
1041 //
1042 if ( m_scrollPosY >= m_numRows )
1043 m_scrollPosY = 0;
1044
1045 if ( !m_numRows )
1046 {
1047 m_numCols = 0;
1048 m_colWidths.Clear();
1049 m_colRights.Clear();
1050 m_currentCellCoords = wxGridNoCellCoords;
1051 }
1052 else if ( m_currentCellCoords.GetRow() >= m_numRows )
1053 {
1054 m_currentCellCoords.Set( 0, 0 );
1055 }
1056 CalcDimensions();
1057 }
1058 return TRUE;
1059
1060 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
1061 {
1062 size_t pos = msg.GetCommandInt();
1063 int numCols = msg.GetCommandInt2();
1064 for ( i = 0; i < numCols; i++ )
1065 {
1066 m_colWidths.Insert( m_defaultColWidth, pos );
1067 m_colRights.Insert( 0, pos );
1068 }
1069 m_numCols += numCols;
1070 CalcDimensions();
1071 }
1072 return TRUE;
1073
1074 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
1075 {
1076 int numCols = msg.GetCommandInt();
1077 for ( i = 0; i < numCols; i++ )
1078 {
1079 m_colWidths.Add( m_defaultColWidth );
1080 m_colRights.Add( 0 );
1081 }
1082 m_numCols += numCols;
1083 CalcDimensions();
1084 }
1085 return TRUE;
1086
1087 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
1088 {
1089 size_t pos = msg.GetCommandInt();
1090 int numCols = msg.GetCommandInt2();
1091 for ( i = 0; i < numCols; i++ )
1092 {
1093 m_colWidths.Remove( pos );
1094 m_colRights.Remove( pos );
1095 }
1096 m_numCols -= numCols;
1097 //
1098 // TODO: improve these adjustments...
1099 //
1100 if ( m_scrollPosX >= m_numCols )
1101 m_scrollPosX = 0;
1102
1103 if ( !m_numCols )
1104 {
1105 #if 0 // leave the row alone here so that AppendCols will work subsequently
1106 m_numRows = 0;
1107 m_rowHeights.Clear();
1108 m_rowBottoms.Clear();
1109 #endif
1110 m_currentCellCoords = wxGridNoCellCoords;
1111 }
1112 else if ( m_currentCellCoords.GetCol() >= m_numCols )
1113 {
1114 m_currentCellCoords.Set( 0, 0 );
1115 }
1116 CalcDimensions();
1117 }
1118 return TRUE;
1119 }
1120
1121 return FALSE;
1122 }
1123
1124
1125 //
1126 // ----- event handlers
1127 //
1128
1129 // Generate a grid event based on a mouse event and
1130 // return the result of ProcessEvent()
1131 //
1132 bool wxGrid::SendEvent( const wxEventType type,
1133 int row, int col,
1134 wxMouseEvent& mouseEv )
1135 {
1136 if ( type == EVT_GRID_ROW_SIZE ||
1137 type == EVT_GRID_COL_SIZE )
1138 {
1139 int rowOrCol = (row == -1 ? col : row);
1140
1141 wxGridSizeEvent gridEvt( GetId(),
1142 type,
1143 this,
1144 rowOrCol,
1145 mouseEv.GetX(), mouseEv.GetY(),
1146 mouseEv.ControlDown(),
1147 mouseEv.ShiftDown(),
1148 mouseEv.AltDown(),
1149 mouseEv.MetaDown() );
1150
1151 return GetEventHandler()->ProcessEvent(gridEvt);
1152 }
1153 else if ( type == EVT_GRID_RANGE_SELECT )
1154 {
1155 wxGridRangeSelectEvent gridEvt( GetId(),
1156 type,
1157 this,
1158 m_selectedTopLeft,
1159 m_selectedBottomRight,
1160 mouseEv.ControlDown(),
1161 mouseEv.ShiftDown(),
1162 mouseEv.AltDown(),
1163 mouseEv.MetaDown() );
1164
1165 return GetEventHandler()->ProcessEvent(gridEvt);
1166 }
1167 else
1168 {
1169 wxGridEvent gridEvt( GetId(),
1170 type,
1171 this,
1172 row, col,
1173 mouseEv.GetX(), mouseEv.GetY(),
1174 mouseEv.ControlDown(),
1175 mouseEv.ShiftDown(),
1176 mouseEv.AltDown(),
1177 mouseEv.MetaDown() );
1178
1179 return GetEventHandler()->ProcessEvent(gridEvt);
1180 }
1181 }
1182
1183
1184 // Generate a grid event of specified type and return the result
1185 // of ProcessEvent().
1186 //
1187 bool wxGrid::SendEvent( const wxEventType type,
1188 int row, int col )
1189 {
1190 if ( type == EVT_GRID_ROW_SIZE ||
1191 type == EVT_GRID_COL_SIZE )
1192 {
1193 int rowOrCol = (row == -1 ? col : row);
1194
1195 wxGridSizeEvent gridEvt( GetId(),
1196 type,
1197 this,
1198 rowOrCol );
1199
1200 return GetEventHandler()->ProcessEvent(gridEvt);
1201 }
1202 else
1203 {
1204 wxGridEvent gridEvt( GetId(),
1205 type,
1206 this,
1207 row, col );
1208
1209 return GetEventHandler()->ProcessEvent(gridEvt);
1210 }
1211 }
1212
1213
1214 void wxGrid::OnPaint( wxPaintEvent& ev )
1215 {
1216 wxPaintDC dc( this );
1217
1218 if ( !m_batchCount )
1219 {
1220 // define a clipping region to avoid painting over the scroll bars
1221 //
1222 int vs = 0;
1223 if ( m_vertScrollBar && m_vertScrollBar->IsShown() )
1224 vs = m_scrollBarWidth;
1225
1226 int hs = 0;
1227 if ( m_horizScrollBar && m_horizScrollBar->IsShown() )
1228 hs = m_scrollBarWidth;
1229
1230 int cw, ch;
1231 GetClientSize( &cw, &ch );
1232 dc.SetClippingRegion( 0, 0, cw - vs, ch - hs );
1233
1234 HideCurrentCellHighlight( dc );
1235
1236 DrawLabelAreas( dc );
1237 DrawColLabels( dc );
1238 DrawRowLabels( dc );
1239 DrawCellArea( dc );
1240 DrawGridLines( dc );
1241 DrawCells( dc );
1242
1243 // TODO: something more elegant than this...
1244 //
1245 if ( m_firstPaint )
1246 {
1247 if ( m_currentCellCoords == wxGridNoCellCoords )
1248 m_currentCellCoords.Set(0, 0);
1249
1250 SetEditControlValue();
1251 ShowCellEditControl();
1252 m_firstPaint = FALSE;
1253 }
1254
1255 ShowCurrentCellHighlight( dc );
1256
1257 dc.DestroyClippingRegion();
1258 }
1259 }
1260
1261
1262 void wxGrid::OnSize( wxSizeEvent& ev )
1263 {
1264 CalcDimensions();
1265 }
1266
1267
1268 void wxGrid::OnMouse( wxMouseEvent& ev )
1269 {
1270 int x = ev.GetX();
1271 int y = ev.GetY();
1272 int row, col;
1273
1274 // ------------------------------------------------------------
1275 //
1276 // Mouse dragging
1277 //
1278 if ( ev.Dragging() )
1279 {
1280 m_isDragging = TRUE;
1281
1282 if ( ev.LeftIsDown() )
1283 {
1284 switch( m_cursorMode )
1285 {
1286 case WXGRID_CURSOR_SELECT_CELL:
1287 {
1288 wxGridCellCoords cellCoords;
1289 XYToCell( x, y, cellCoords );
1290 if ( cellCoords != wxGridNoCellCoords )
1291 {
1292 if ( !IsSelection() )
1293 {
1294 SelectBlock( cellCoords, cellCoords );
1295 }
1296 else if ( !IsInSelection( cellCoords ) )
1297 {
1298 SelectBlock( m_currentCellCoords, cellCoords );
1299 }
1300 }
1301 }
1302 break;
1303
1304 case WXGRID_CURSOR_RESIZE_ROW:
1305 {
1306 wxClientDC dc(this);
1307 dc.SetLogicalFunction(wxXOR);
1308 if ( m_dragLastPos >= 0 )
1309 {
1310 dc.DrawLine( m_left, m_dragLastPos,
1311 m_right, m_dragLastPos );
1312 }
1313 dc.DrawLine( m_left, ev.GetY(),
1314 m_right, ev.GetY());
1315
1316 m_dragLastPos = ev.GetY();
1317 }
1318 break;
1319
1320 case WXGRID_CURSOR_RESIZE_COL:
1321 {
1322 wxClientDC dc(this);
1323 dc.SetLogicalFunction(wxINVERT);
1324 if ( m_dragLastPos >= 0 )
1325 {
1326 dc.DrawLine( m_dragLastPos, m_top,
1327 m_dragLastPos, m_bottom );
1328 }
1329 dc.DrawLine( ev.GetX(), m_top,
1330 ev.GetX(), m_bottom );
1331
1332 m_dragLastPos = ev.GetX();
1333 }
1334 break;
1335
1336 case WXGRID_CURSOR_SELECT_ROW:
1337 {
1338 if ( (row = YToRow( y )) >= 0 &&
1339 !IsInSelection( row, 0 ) )
1340 {
1341 SelectRow( row, TRUE );
1342 }
1343 }
1344 break;
1345
1346 case WXGRID_CURSOR_SELECT_COL:
1347 {
1348 if ( (col = XToCol( x )) >= 0 &&
1349 !IsInSelection( 0, col ) )
1350 {
1351 SelectCol( col, TRUE );
1352 }
1353 }
1354 break;
1355 }
1356 }
1357 return;
1358 }
1359
1360 m_isDragging = FALSE;
1361
1362 // ------------------------------------------------------------
1363 //
1364 // Left mouse button down
1365 //
1366 if ( ev.LeftDown() )
1367 {
1368 row = -1;
1369 col = -1;
1370 wxGridCellCoords cellCoords;
1371
1372 switch( XYToArea( x, y ) )
1373 {
1374 case WXGRID_ROWLABEL:
1375 {
1376 // don't send a label click event for a hit on the
1377 // edge of the row label - this is probably the user
1378 // wanting to resize the row
1379 //
1380 if ( YToEdgeOfRow(y) < 0 )
1381 {
1382 row = YToRow(y);
1383 if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
1384 {
1385 SelectRow( row, ev.ShiftDown() );
1386 m_cursorMode = WXGRID_CURSOR_SELECT_ROW;
1387 }
1388 }
1389 }
1390 break;
1391
1392 case WXGRID_COLLABEL:
1393 {
1394 // don't send a label click event for a hit on the
1395 // edge of the col label - this is probably the user
1396 // wanting to resize the col
1397 //
1398 if ( XToEdgeOfCol(x) < 0 )
1399 {
1400 col = XToCol(x);
1401 if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
1402 {
1403 SelectCol( col, ev.ShiftDown() );
1404 m_cursorMode = WXGRID_CURSOR_SELECT_COL;
1405 }
1406 }
1407 }
1408 break;
1409
1410 case WXGRID_CORNERLABEL:
1411 {
1412 // leave both row and col as -1
1413 //
1414 if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
1415 {
1416 SelectAll();
1417 }
1418 }
1419 break;
1420
1421 case WXGRID_CELL:
1422 {
1423 XYToCell( x, y, cellCoords );
1424 if ( !SendEvent( EVT_GRID_CELL_LEFT_CLICK,
1425 cellCoords.GetRow(),
1426 cellCoords.GetCol(),
1427 ev ) )
1428 {
1429 MakeCellVisible( cellCoords );
1430 SelectCell( cellCoords );
1431 }
1432 }
1433 break;
1434
1435 default:
1436 #if 0
1437 wxLogMessage( "outside grid area" );
1438 #endif
1439 break;
1440 }
1441 }
1442 // ------------------------------------------------------------
1443 //
1444 // Left mouse button double click
1445 //
1446 else if ( ev.LeftDClick() )
1447 {
1448 row = -1;
1449 col = -1;
1450 wxGridCellCoords cellCoords;
1451
1452 switch( XYToArea( x, y ) )
1453 {
1454 case WXGRID_ROWLABEL:
1455 {
1456 // don't send a label click event for a hit on the
1457 // edge of the row label - this is probably the user
1458 // wanting to resize the row
1459 //
1460 if ( YToEdgeOfRow(y) < 0 )
1461 {
1462 row = YToRow(y);
1463 SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
1464 }
1465 }
1466 break;
1467
1468 case WXGRID_COLLABEL:
1469 {
1470 // don't send a label click event for a hit on the
1471 // edge of the col label - this is probably the user
1472 // wanting to resize the col
1473 //
1474 if ( XToEdgeOfCol(x) < 0 )
1475 {
1476 col = XToCol(x);
1477 SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
1478 }
1479 }
1480 break;
1481
1482 case WXGRID_CORNERLABEL:
1483 {
1484 // leave both row and col as -1
1485 //
1486 SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
1487 }
1488 break;
1489
1490 case WXGRID_CELL:
1491 {
1492 XYToCell( x, y, cellCoords );
1493 SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
1494 cellCoords.GetRow(),
1495 cellCoords.GetCol(),
1496 ev );
1497 }
1498 break;
1499
1500 default:
1501 #if 0
1502 wxLogMessage( "outside grid area" );
1503 #endif
1504 break;
1505 }
1506 }
1507 // ------------------------------------------------------------
1508 //
1509 // Left mouse button released
1510 //
1511 else if ( ev.LeftUp() )
1512 {
1513 switch ( m_cursorMode )
1514 {
1515 case WXGRID_CURSOR_RESIZE_ROW:
1516 {
1517 if ( m_dragLastPos >= 0 )
1518 {
1519 // erase the last line and resize the row
1520 //
1521 wxClientDC dc( this );
1522 dc.SetLogicalFunction( wxINVERT );
1523 dc.DrawLine( m_left, m_dragLastPos,
1524 m_right, m_dragLastPos );
1525 HideCellEditControl();
1526 int top = m_top + m_colLabelHeight;
1527 if ( m_dragRowOrCol > 0 )
1528 top = m_rowBottoms[m_dragRowOrCol-1];
1529 m_rowHeights[m_dragRowOrCol] = wxMax( ev.GetY() - top,
1530 WXGRID_MIN_ROW_HEIGHT );
1531 CalcDimensions();
1532 ShowCellEditControl();
1533 Refresh();
1534
1535 // Note: we are ending the event *after* doing
1536 // default processing in this case
1537 //
1538 SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, ev );
1539 }
1540 }
1541 break;
1542
1543 case WXGRID_CURSOR_RESIZE_COL:
1544 {
1545 if ( m_dragLastPos >= 0 )
1546 {
1547 // erase the last line and resize the col
1548 //
1549 wxClientDC dc( this );
1550 dc.SetLogicalFunction( wxINVERT );
1551 dc.DrawLine( m_left, m_dragLastPos,
1552 m_right, m_dragLastPos );
1553 HideCellEditControl();
1554 int left = m_left + m_rowLabelWidth;
1555 if ( m_dragRowOrCol > 0 )
1556 left = m_colRights[m_dragRowOrCol-1];
1557 m_colWidths[m_dragRowOrCol] = wxMax( ev.GetX() - left,
1558 WXGRID_MIN_COL_WIDTH );
1559 CalcDimensions();
1560 ShowCellEditControl();
1561 Refresh();
1562
1563 // Note: we are ending the event *after* doing
1564 // default processing in this case
1565 //
1566 SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, ev );
1567 }
1568 }
1569 break;
1570
1571 case WXGRID_CURSOR_SELECT_CELL:
1572 {
1573 if ( IsSelection() )
1574 {
1575 // Note: we are ending the event *after* doing
1576 // default processing in this case
1577 //
1578 SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, ev );
1579 }
1580 }
1581 break;
1582 }
1583
1584 m_dragLastPos = -1;
1585 }
1586 // ------------------------------------------------------------
1587 //
1588 // Right mouse button down
1589 //
1590 else if ( ev.RightDown() )
1591 {
1592 row = -1;
1593 col = -1;
1594 wxGridCellCoords cellCoords;
1595
1596 switch( XYToArea( x, y ) )
1597 {
1598
1599 case WXGRID_ROWLABEL:
1600 {
1601 row = YToRow(y);
1602 if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
1603 {
1604 // TODO: default processing ?
1605 }
1606 }
1607 break;
1608
1609 case WXGRID_COLLABEL:
1610 {
1611 col = XToCol(x);
1612 if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
1613 {
1614 // TODO: default processing ?
1615 }
1616 }
1617 break;
1618
1619 case WXGRID_CORNERLABEL:
1620 {
1621 // leave both row and col as -1
1622 //
1623 if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
1624 {
1625 // TODO: default processing ?
1626 }
1627 }
1628 break;
1629
1630 case WXGRID_CELL:
1631 {
1632 XYToCell( x, y, cellCoords );
1633 if ( !SendEvent( EVT_GRID_CELL_RIGHT_CLICK,
1634 cellCoords.GetRow(),
1635 cellCoords.GetCol(),
1636 ev ) )
1637 {
1638 // TODO: default processing ?
1639 }
1640 }
1641 break;
1642
1643 default:
1644 #if 0
1645 wxLogMessage( "outside grid area" );
1646 #endif
1647 break;
1648 }
1649 }
1650 // ------------------------------------------------------------
1651 //
1652 // Right mouse button double click
1653 //
1654 else if ( ev.RightDClick() )
1655 {
1656 row = -1;
1657 col = -1;
1658 wxGridCellCoords cellCoords;
1659
1660 switch( XYToArea( x, y ) )
1661 {
1662
1663 case WXGRID_ROWLABEL:
1664 {
1665 row = YToRow(y);
1666 SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
1667 }
1668 break;
1669
1670 case WXGRID_COLLABEL:
1671 {
1672 col = XToCol(x);
1673 SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
1674 }
1675 break;
1676
1677 case WXGRID_CORNERLABEL:
1678 {
1679 // leave both row and col as -1
1680 //
1681 SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
1682 }
1683 break;
1684
1685 case WXGRID_CELL:
1686 {
1687 XYToCell( x, y, cellCoords );
1688 SendEvent( EVT_GRID_CELL_RIGHT_DCLICK,
1689 cellCoords.GetRow(),
1690 cellCoords.GetCol(),
1691 ev );
1692 }
1693 break;
1694
1695 default:
1696 #if 0
1697 wxLogMessage( "outside grid area" );
1698 #endif
1699 break;
1700 }
1701 }
1702 // ------------------------------------------------------------
1703 //
1704 // No buttons down and mouse moving
1705 //
1706 else if ( ev.Moving() )
1707 {
1708 switch( XYToArea( x, y ) )
1709 {
1710 case WXGRID_ROWLABEL:
1711 {
1712 m_dragRowOrCol = YToEdgeOfRow( y );
1713 if ( m_dragRowOrCol >= 0 )
1714 {
1715 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
1716 {
1717 m_cursorMode = WXGRID_CURSOR_RESIZE_ROW;
1718 SetCursor( m_rowResizeCursor );
1719 }
1720 }
1721 else
1722 {
1723 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
1724 {
1725 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
1726 SetCursor( *wxSTANDARD_CURSOR );
1727 }
1728 }
1729 }
1730 break;
1731
1732 case WXGRID_COLLABEL:
1733 {
1734 m_dragRowOrCol = XToEdgeOfCol( x );
1735 if ( m_dragRowOrCol >= 0 )
1736 {
1737 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
1738 {
1739 m_cursorMode = WXGRID_CURSOR_RESIZE_COL;
1740 SetCursor( m_colResizeCursor );
1741 }
1742 }
1743 else
1744 {
1745 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
1746 {
1747 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
1748 SetCursor( *wxSTANDARD_CURSOR );
1749 }
1750 }
1751 }
1752 break;
1753
1754 default:
1755 {
1756 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
1757 {
1758 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
1759 SetCursor( *wxSTANDARD_CURSOR );
1760 }
1761 }
1762 break;
1763 }
1764 }
1765 }
1766
1767
1768 void wxGrid::OnKeyDown( wxKeyEvent& ev )
1769 {
1770 if ( m_inOnKeyDown )
1771 {
1772 // shouldn't be here - we are going round in circles...
1773 //
1774 wxLogFatalError( "wxGrid::OnKeyDown called while alread active" );
1775 }
1776
1777 m_inOnKeyDown = TRUE;
1778
1779 // propagate the event up and see if it gets processed
1780 //
1781 wxWindow *parent = GetParent();
1782 wxKeyEvent keyEvt( ev );
1783 keyEvt.SetEventObject( parent );
1784
1785 if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
1786 {
1787 // try local handlers
1788 //
1789 switch ( ev.KeyCode() )
1790 {
1791 case WXK_UP:
1792 if ( ev.ControlDown() )
1793 {
1794 MoveCursorUpBlock();
1795 }
1796 else
1797 {
1798 MoveCursorUp();
1799 }
1800 break;
1801
1802 case WXK_DOWN:
1803 if ( ev.ControlDown() )
1804 {
1805 MoveCursorDownBlock();
1806 }
1807 else
1808 {
1809 MoveCursorDown();
1810 }
1811 break;
1812
1813 case WXK_LEFT:
1814 if ( ev.ControlDown() )
1815 {
1816 MoveCursorLeftBlock();
1817 }
1818 else
1819 {
1820 MoveCursorLeft();
1821 }
1822 break;
1823
1824 case WXK_RIGHT:
1825 if ( ev.ControlDown() )
1826 {
1827 MoveCursorRightBlock();
1828 }
1829 else
1830 {
1831 MoveCursorRight();
1832 }
1833 break;
1834
1835 case WXK_RETURN:
1836 MoveCursorDown();
1837 break;
1838
1839 case WXK_HOME:
1840 if ( ev.ControlDown() )
1841 {
1842 MakeCellVisible( 0, 0 );
1843 SelectCell( 0, 0 );
1844 }
1845 else
1846 {
1847 ev.Skip();
1848 }
1849 break;
1850
1851 case WXK_END:
1852 if ( ev.ControlDown() )
1853 {
1854 MakeCellVisible( m_numRows-1, m_numCols-1 );
1855 SelectCell( m_numRows-1, m_numCols-1 );
1856 }
1857 else
1858 {
1859 ev.Skip();
1860 }
1861 break;
1862
1863 case WXK_PRIOR:
1864 MovePageUp();
1865 break;
1866
1867 case WXK_NEXT:
1868 MovePageDown();
1869 break;
1870
1871 default:
1872 // now try the cell edit control
1873 //
1874 if ( IsCellEditControlEnabled() )
1875 {
1876 ev.SetEventObject( m_cellEditCtrl );
1877 m_cellEditCtrl->GetEventHandler()->ProcessEvent( ev );
1878 }
1879 break;
1880 }
1881 }
1882
1883 m_inOnKeyDown = FALSE;
1884 }
1885
1886
1887 // Text updated in an edit control - either a text control or a
1888 // combo box
1889 //
1890 void wxGrid::OnText( wxKeyEvent& ev )
1891 {
1892 if ( !m_inOnText )
1893 {
1894 m_inOnText = TRUE;
1895 wxWindow *ctrl = (wxWindow *)ev.GetEventObject();
1896
1897 if ( ctrl == m_cellEditCtrl &&
1898 IsTopEditControlEnabled() )
1899 {
1900 // set the value of the top edit control
1901 //
1902 switch ( m_editCtrlType )
1903 {
1904 case wxGRID_TEXTCTRL:
1905 ((wxTextCtrl *)m_topEditCtrl)->
1906 SetValue(((wxTextCtrl *)ctrl)->GetValue());
1907 break;
1908
1909 case wxGRID_COMBOBOX:
1910 ((wxComboBox *)m_topEditCtrl)->
1911 SetValue(((wxComboBox *)ctrl)->GetValue());
1912 break;
1913 }
1914 }
1915 else if ( ctrl == m_topEditCtrl &&
1916 IsCellEditControlEnabled() )
1917 {
1918 switch ( m_editCtrlType )
1919 {
1920 case wxGRID_TEXTCTRL:
1921 ((wxTextCtrl *)m_cellEditCtrl)->
1922 SetValue(((wxTextCtrl *)ctrl)->GetValue());
1923 break;
1924
1925 case wxGRID_COMBOBOX:
1926 ((wxComboBox *)m_cellEditCtrl)->
1927 SetValue(((wxComboBox *)ctrl)->GetValue());
1928 break;
1929 }
1930 }
1931 }
1932
1933 m_inOnText = FALSE;
1934 }
1935
1936 void wxGrid::OnGridScroll( wxScrollEvent& ev )
1937 {
1938 // propagate the event up and see if it gets processed
1939 //
1940 wxWindow *parent = GetParent();
1941 wxScrollEvent scrollEvt( ev );
1942 if (parent->GetEventHandler()->ProcessEvent( scrollEvt )) return;
1943
1944 HideCellEditControl();
1945
1946 if ( ev.GetEventObject() == m_horizScrollBar )
1947 {
1948 if ( ev.GetPosition() != m_scrollPosX )
1949 {
1950 SetHorizontalScrollPos( ev.GetPosition() );
1951 }
1952 }
1953 else
1954 {
1955 if ( ev.GetPosition() != m_scrollPosY )
1956 {
1957 SetVerticalScrollPos( ev.GetPosition() );
1958 }
1959 }
1960
1961 ShowCellEditControl();
1962 }
1963
1964
1965 void wxGrid::SelectCell( const wxGridCellCoords& coords )
1966 {
1967 wxClientDC dc( this );
1968
1969 if ( m_currentCellCoords != wxGridNoCellCoords )
1970 {
1971 HideCurrentCellHighlight( dc );
1972 HideCellEditControl();
1973 SaveEditControlValue();
1974 }
1975
1976 m_currentCellCoords = coords;
1977
1978 SetEditControlValue();
1979 if ( IsOnScreen() )
1980 {
1981 ShowCellEditControl();
1982 ShowCurrentCellHighlight( dc );
1983 }
1984
1985 if ( IsSelection() )
1986 {
1987 ClearSelection();
1988 if ( !GetBatchCount() ) Refresh();
1989 }
1990 }
1991
1992
1993 void wxGrid::ShowCellEditControl()
1994 {
1995 wxRect rect;
1996
1997 if ( IsCellEditControlEnabled() )
1998 {
1999 if ( !IsVisible( m_currentCellCoords ) )
2000 {
2001 return;
2002 }
2003 else
2004 {
2005 rect = CellToRect( m_currentCellCoords );
2006
2007 m_cellEditCtrl->SetSize( rect );
2008 m_cellEditCtrl->Show( TRUE );
2009
2010 switch ( m_editCtrlType )
2011 {
2012 case wxGRID_TEXTCTRL:
2013 ((wxTextCtrl *) m_cellEditCtrl)->SetInsertionPointEnd();
2014 break;
2015
2016 case wxGRID_CHECKBOX:
2017 // TODO: anything ???
2018 //
2019 break;
2020
2021 case wxGRID_CHOICE:
2022 // TODO: anything ???
2023 //
2024 break;
2025
2026 case wxGRID_COMBOBOX:
2027 // TODO: anything ???
2028 //
2029 break;
2030 }
2031
2032 m_cellEditCtrl->SetFocus();
2033 }
2034 }
2035 }
2036
2037
2038 void wxGrid::HideCellEditControl()
2039 {
2040 if ( IsCellEditControlEnabled() )
2041 {
2042 m_cellEditCtrl->Show( FALSE );
2043 }
2044 }
2045
2046 void wxGrid::SetEditControlValue( const wxString& value )
2047 {
2048 if ( m_table )
2049 {
2050 wxString s;
2051 if ( !value )
2052 s = GetCellValue(m_currentCellCoords);
2053 else
2054 s = value;
2055
2056 if ( IsTopEditControlEnabled() )
2057 {
2058 switch ( m_editCtrlType )
2059 {
2060 case wxGRID_TEXTCTRL:
2061 ((wxGridTextCtrl *)m_topEditCtrl)->SetStartValue(s);
2062 break;
2063
2064 case wxGRID_CHECKBOX:
2065 // TODO: implement this
2066 //
2067 break;
2068
2069 case wxGRID_CHOICE:
2070 // TODO: implement this
2071 //
2072 break;
2073
2074 case wxGRID_COMBOBOX:
2075 // TODO: implement this
2076 //
2077 break;
2078 }
2079 }
2080
2081 if ( IsCellEditControlEnabled() )
2082 {
2083 switch ( m_editCtrlType )
2084 {
2085 case wxGRID_TEXTCTRL:
2086 ((wxGridTextCtrl *)m_cellEditCtrl)->SetStartValue(s);
2087 break;
2088
2089 case wxGRID_CHECKBOX:
2090 // TODO: implement this
2091 //
2092 break;
2093
2094 case wxGRID_CHOICE:
2095 // TODO: implement this
2096 //
2097 break;
2098
2099 case wxGRID_COMBOBOX:
2100 // TODO: implement this
2101 //
2102 break;
2103 }
2104 }
2105 }
2106 }
2107
2108 void wxGrid::SaveEditControlValue()
2109 {
2110 if ( m_table )
2111 {
2112 wxWindow *ctrl = (wxWindow *)NULL;
2113
2114 if ( IsCellEditControlEnabled() )
2115 {
2116 ctrl = m_cellEditCtrl;
2117 }
2118 else if ( IsTopEditControlEnabled() )
2119 {
2120 ctrl = m_topEditCtrl;
2121 }
2122 else
2123 {
2124 return;
2125 }
2126
2127 bool valueChanged = FALSE;
2128
2129 switch ( m_editCtrlType )
2130 {
2131 case wxGRID_TEXTCTRL:
2132 valueChanged = (((wxGridTextCtrl *)ctrl)->GetValue() !=
2133 ((wxGridTextCtrl *)ctrl)->GetStartValue());
2134 SetCellValue( m_currentCellCoords,
2135 ((wxTextCtrl *) ctrl)->GetValue() );
2136 break;
2137
2138 case wxGRID_CHECKBOX:
2139 // TODO: implement this
2140 //
2141 break;
2142
2143 case wxGRID_CHOICE:
2144 // TODO: implement this
2145 //
2146 break;
2147
2148 case wxGRID_COMBOBOX:
2149 // TODO: implement this
2150 //
2151 break;
2152 }
2153
2154 if ( valueChanged )
2155 {
2156 SendEvent( EVT_GRID_CELL_CHANGE,
2157 m_currentCellCoords.GetRow(),
2158 m_currentCellCoords.GetCol() );
2159 }
2160 }
2161 }
2162
2163
2164 int wxGrid::XYToArea( int x, int y )
2165 {
2166 if ( x > m_left && x < m_right &&
2167 y > m_top && y < m_bottom )
2168 {
2169 if ( y < m_top + m_colLabelHeight )
2170 {
2171 if ( x > m_left + m_rowLabelWidth )
2172 {
2173 return WXGRID_COLLABEL;
2174 }
2175 else
2176 {
2177 return WXGRID_CORNERLABEL;
2178 }
2179 }
2180 else if ( x <= m_left + m_rowLabelWidth )
2181 {
2182 return WXGRID_ROWLABEL;
2183 }
2184 else
2185 {
2186 return WXGRID_CELL;
2187 }
2188 }
2189
2190 return WXGRID_NOAREA;
2191 }
2192
2193
2194 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
2195 {
2196 coords.SetRow( YToRow(y) );
2197 coords.SetCol( XToCol(x) );
2198 }
2199
2200
2201 int wxGrid::YToRow( int y )
2202 {
2203 int i;
2204
2205 if ( y > m_top + m_colLabelHeight )
2206 {
2207 for ( i = m_scrollPosY; i < m_numRows; i++ )
2208 {
2209 if ( y < m_rowBottoms[i] )
2210 {
2211 return i;
2212 }
2213 }
2214 }
2215
2216 return -1;
2217 }
2218
2219
2220 int wxGrid::XToCol( int x )
2221 {
2222 int i;
2223
2224 if ( x > m_left + m_rowLabelWidth )
2225 {
2226 for ( i = m_scrollPosX; i < m_numCols; i++ )
2227 {
2228 if ( x < m_colRights[i] )
2229 {
2230 return i;
2231 }
2232 }
2233 }
2234
2235 return -1;
2236 }
2237
2238
2239 // return the row number that that the y coord is near the edge of, or
2240 // -1 if not near an edge
2241 //
2242 int wxGrid::YToEdgeOfRow( int y )
2243 {
2244 int i, d;
2245
2246 if ( y > m_top + m_colLabelHeight )
2247 {
2248 for ( i = m_scrollPosY; i < m_numRows; i++ )
2249 {
2250 if ( m_rowHeights[i] > WXGRID_LABEL_EDGE_ZONE )
2251 {
2252 d = abs( y - m_rowBottoms[i] );
2253 {
2254 if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
2255 }
2256 }
2257 }
2258 }
2259
2260 return -1;
2261
2262 }
2263
2264
2265 // return the col number that that the x coord is near the edge of, or
2266 // -1 if not near an edge
2267 //
2268 int wxGrid::XToEdgeOfCol( int x )
2269 {
2270 int i, d;
2271
2272 if ( x > m_left + m_rowLabelWidth )
2273 {
2274 for ( i = m_scrollPosX; i < m_numCols; i++ )
2275 {
2276 if ( m_colWidths[i] > WXGRID_LABEL_EDGE_ZONE )
2277 {
2278 d = abs( x - m_colRights[i] );
2279 {
2280 if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
2281 }
2282 }
2283 }
2284 }
2285
2286 return -1;
2287
2288 }
2289
2290
2291 wxRect wxGrid::CellToRect( int row, int col )
2292 {
2293 wxRect rect( -1, -1, -1, -1 );
2294
2295 if ( row >= m_scrollPosY && col >= m_scrollPosX )
2296 {
2297 rect.x = m_colRights[col] - m_colWidths[col];
2298 rect.y = m_rowBottoms[row] - m_rowHeights[row];
2299 rect.width = m_colWidths[col];
2300 rect.height = m_rowHeights[ row ];
2301 }
2302
2303 return rect;
2304 }
2305
2306
2307 bool wxGrid::MoveCursorUp()
2308 {
2309 if ( m_currentCellCoords != wxGridNoCellCoords &&
2310 m_currentCellCoords.GetRow() > 0 )
2311 {
2312 SelectCell( m_currentCellCoords.GetRow() - 1,
2313 m_currentCellCoords.GetCol() );
2314
2315 if ( !IsVisible( m_currentCellCoords ) )
2316 MakeCellVisible( m_currentCellCoords );
2317
2318 return TRUE;
2319 }
2320
2321 return FALSE;
2322 }
2323
2324 bool wxGrid::MoveCursorDown()
2325 {
2326 // TODO: allow for scrolling
2327 //
2328 if ( m_currentCellCoords != wxGridNoCellCoords &&
2329 m_currentCellCoords.GetRow() < m_numRows-1 )
2330 {
2331 SelectCell( m_currentCellCoords.GetRow() + 1,
2332 m_currentCellCoords.GetCol() );
2333
2334 if ( !IsVisible( m_currentCellCoords ) )
2335 MakeCellVisible( m_currentCellCoords );
2336
2337 return TRUE;
2338 }
2339
2340 return FALSE;
2341 }
2342
2343 bool wxGrid::MoveCursorLeft()
2344 {
2345 if ( m_currentCellCoords != wxGridNoCellCoords &&
2346 m_currentCellCoords.GetCol() > 0 )
2347 {
2348 SelectCell( m_currentCellCoords.GetRow(),
2349 m_currentCellCoords.GetCol() - 1 );
2350
2351 if ( !IsVisible( m_currentCellCoords ) )
2352 MakeCellVisible( m_currentCellCoords );
2353
2354 return TRUE;
2355 }
2356
2357 return FALSE;
2358 }
2359
2360 bool wxGrid::MoveCursorRight()
2361 {
2362 if ( m_currentCellCoords != wxGridNoCellCoords &&
2363 m_currentCellCoords.GetCol() < m_numCols - 1 )
2364 {
2365 SelectCell( m_currentCellCoords.GetRow(),
2366 m_currentCellCoords.GetCol() + 1 );
2367
2368 if ( !IsVisible( m_currentCellCoords ) )
2369 MakeCellVisible( m_currentCellCoords );
2370
2371 return TRUE;
2372 }
2373
2374 return FALSE;
2375 }
2376
2377 bool wxGrid::MovePageUp()
2378 {
2379 if ( m_currentCellCoords != wxGridNoCellCoords &&
2380 m_scrollPosY > 0 )
2381 {
2382 int row = m_currentCellCoords.GetRow();
2383 int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
2384 while ( row > 0 )
2385 {
2386 if ( y + m_rowHeights[row-1] > m_bottom ) break;
2387 y += m_rowHeights[ --row ];
2388 }
2389 SetVerticalScrollPos( row );
2390
2391 SelectCell( row, m_currentCellCoords.GetCol() );
2392 return TRUE;
2393 }
2394
2395 return FALSE;
2396 }
2397
2398 bool wxGrid::MovePageDown()
2399 {
2400 if ( m_currentCellCoords != wxGridNoCellCoords &&
2401 m_scrollPosY + m_wholeRowsVisible < m_numRows )
2402 {
2403 if ( m_wholeRowsVisible > 0 )
2404 {
2405 SetVerticalScrollPos( m_scrollPosY + m_wholeRowsVisible );
2406 }
2407 else if ( m_scrollPosY < m_numRows - 1 )
2408 {
2409 SetVerticalScrollPos( m_scrollPosY + 1 );
2410 }
2411 else
2412 {
2413 return FALSE;
2414 }
2415
2416 // m_scrollPosY will have been updated
2417 //
2418 SelectCell( m_scrollPosY, m_currentCellCoords.GetCol() );
2419 return TRUE;
2420 }
2421
2422 return FALSE;
2423 }
2424
2425 bool wxGrid::MoveCursorUpBlock()
2426 {
2427 if ( m_table &&
2428 m_currentCellCoords != wxGridNoCellCoords &&
2429 m_currentCellCoords.GetRow() > 0 )
2430 {
2431 int row = m_currentCellCoords.GetRow();
2432 int col = m_currentCellCoords.GetCol();
2433
2434 if ( m_table->IsEmptyCell(row, col) )
2435 {
2436 // starting in an empty cell: find the next block of
2437 // non-empty cells
2438 //
2439 while ( row > 0 )
2440 {
2441 row-- ;
2442 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2443 }
2444 }
2445 else if ( m_table->IsEmptyCell(row-1, col) )
2446 {
2447 // starting at the top of a block: find the next block
2448 //
2449 row--;
2450 while ( row > 0 )
2451 {
2452 row-- ;
2453 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2454 }
2455 }
2456 else
2457 {
2458 // starting within a block: find the top of the block
2459 //
2460 while ( row > 0 )
2461 {
2462 row-- ;
2463 if ( m_table->IsEmptyCell(row, col) )
2464 {
2465 row++ ;
2466 break;
2467 }
2468 }
2469 }
2470
2471 SelectCell( row, col );
2472
2473 if ( !IsVisible( m_currentCellCoords ) )
2474 MakeCellVisible( m_currentCellCoords );
2475
2476 return TRUE;
2477 }
2478
2479 return FALSE;
2480 }
2481
2482 bool wxGrid::MoveCursorDownBlock()
2483 {
2484 if ( m_table &&
2485 m_currentCellCoords != wxGridNoCellCoords &&
2486 m_currentCellCoords.GetRow() < m_numRows-1 )
2487 {
2488 int row = m_currentCellCoords.GetRow();
2489 int col = m_currentCellCoords.GetCol();
2490
2491 if ( m_table->IsEmptyCell(row, col) )
2492 {
2493 // starting in an empty cell: find the next block of
2494 // non-empty cells
2495 //
2496 while ( row < m_numRows-1 )
2497 {
2498 row++ ;
2499 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2500 }
2501 }
2502 else if ( m_table->IsEmptyCell(row+1, col) )
2503 {
2504 // starting at the bottom of a block: find the next block
2505 //
2506 row++;
2507 while ( row < m_numRows-1 )
2508 {
2509 row++ ;
2510 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2511 }
2512 }
2513 else
2514 {
2515 // starting within a block: find the bottom of the block
2516 //
2517 while ( row < m_numRows-1 )
2518 {
2519 row++ ;
2520 if ( m_table->IsEmptyCell(row, col) )
2521 {
2522 row-- ;
2523 break;
2524 }
2525 }
2526 }
2527
2528 SelectCell( row, col );
2529
2530 if ( !IsVisible( m_currentCellCoords ) )
2531 MakeCellVisible( m_currentCellCoords );
2532
2533 return TRUE;
2534 }
2535
2536 return FALSE;
2537 }
2538
2539 bool wxGrid::MoveCursorLeftBlock()
2540 {
2541 if ( m_table &&
2542 m_currentCellCoords != wxGridNoCellCoords &&
2543 m_currentCellCoords.GetCol() > 0 )
2544 {
2545 int row = m_currentCellCoords.GetRow();
2546 int col = m_currentCellCoords.GetCol();
2547
2548 if ( m_table->IsEmptyCell(row, col) )
2549 {
2550 // starting in an empty cell: find the next block of
2551 // non-empty cells
2552 //
2553 while ( col > 0 )
2554 {
2555 col-- ;
2556 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2557 }
2558 }
2559 else if ( m_table->IsEmptyCell(row, col-1) )
2560 {
2561 // starting at the left of a block: find the next block
2562 //
2563 col--;
2564 while ( col > 0 )
2565 {
2566 col-- ;
2567 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2568 }
2569 }
2570 else
2571 {
2572 // starting within a block: find the left of the block
2573 //
2574 while ( col > 0 )
2575 {
2576 col-- ;
2577 if ( m_table->IsEmptyCell(row, col) )
2578 {
2579 col++ ;
2580 break;
2581 }
2582 }
2583 }
2584
2585 SelectCell( row, col );
2586
2587 if ( !IsVisible( m_currentCellCoords ) )
2588 MakeCellVisible( m_currentCellCoords );
2589
2590 return TRUE;
2591 }
2592
2593 return FALSE;
2594 }
2595
2596 bool wxGrid::MoveCursorRightBlock()
2597 {
2598 if ( m_table &&
2599 m_currentCellCoords != wxGridNoCellCoords &&
2600 m_currentCellCoords.GetCol() < m_numCols-1 )
2601 {
2602 int row = m_currentCellCoords.GetRow();
2603 int col = m_currentCellCoords.GetCol();
2604
2605 if ( m_table->IsEmptyCell(row, col) )
2606 {
2607 // starting in an empty cell: find the next block of
2608 // non-empty cells
2609 //
2610 while ( col < m_numCols-1 )
2611 {
2612 col++ ;
2613 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2614 }
2615 }
2616 else if ( m_table->IsEmptyCell(row, col+1) )
2617 {
2618 // starting at the right of a block: find the next block
2619 //
2620 col++;
2621 while ( col < m_numCols-1 )
2622 {
2623 col++ ;
2624 if ( !(m_table->IsEmptyCell(row, col)) ) break;
2625 }
2626 }
2627 else
2628 {
2629 // starting within a block: find the right of the block
2630 //
2631 while ( col < m_numCols-1 )
2632 {
2633 col++ ;
2634 if ( m_table->IsEmptyCell(row, col) )
2635 {
2636 col-- ;
2637 break;
2638 }
2639 }
2640 }
2641
2642 SelectCell( row, col );
2643
2644 if ( !IsVisible( m_currentCellCoords ) )
2645 MakeCellVisible( m_currentCellCoords );
2646
2647 return TRUE;
2648 }
2649
2650 return FALSE;
2651 }
2652
2653
2654
2655 //
2656 // ----- grid drawing functions
2657 //
2658
2659 void wxGrid::DrawLabelAreas( wxDC& dc )
2660 {
2661 int cw, ch;
2662 GetClientSize(&cw, &ch);
2663
2664 dc.SetPen(*wxTRANSPARENT_PEN);
2665 dc.SetBrush( wxBrush(GetLabelBackgroundColour(), wxSOLID) );
2666
2667 dc.DrawRectangle( m_left, m_top,
2668 cw - m_left, m_colLabelHeight );
2669
2670 dc.DrawRectangle( m_left, m_top,
2671 m_rowLabelWidth, ch - m_top );
2672 }
2673
2674
2675 void wxGrid::DrawColLabels( wxDC& dc )
2676 {
2677 int cw, ch;
2678 GetClientSize(&cw, &ch);
2679
2680 if (m_colLabelHeight == 0) return;
2681
2682 DrawColLabelBorders( dc );
2683
2684 wxRect rect;
2685 rect.y = m_top + 1;
2686 rect.height = m_colLabelHeight - 1;
2687
2688 int labelLeft = m_left + m_rowLabelWidth;
2689 int i;
2690
2691 for ( i = m_scrollPosX; i < m_numCols; i++ )
2692 {
2693 if ( labelLeft > cw) break;
2694
2695 rect.x = 1 + labelLeft;
2696 rect.width = m_colWidths[i];
2697 DrawColLabel( dc, rect, i );
2698
2699 labelLeft += m_colWidths[i];
2700 }
2701 }
2702
2703
2704 void wxGrid::DrawColLabelBorders( wxDC& dc )
2705 {
2706 if ( m_colLabelHeight <= 0 ) return;
2707
2708 int i;
2709 int cw, ch;
2710 GetClientSize( &cw, &ch );
2711
2712 dc.SetPen( *wxBLACK_PEN );
2713
2714 // horizontal lines
2715 //
2716 dc.DrawLine( m_left, m_top, cw, m_top );
2717
2718 dc.DrawLine( m_left, m_top + m_colLabelHeight,
2719 cw, m_top + m_colLabelHeight );
2720
2721 // vertical lines
2722 //
2723 int colLeft = m_left + m_rowLabelWidth;
2724 for ( i = m_scrollPosX; i <= m_numCols; i++ )
2725 {
2726 if (colLeft > cw) break;
2727
2728 dc.DrawLine( colLeft, m_top,
2729 colLeft, m_top + m_colLabelHeight);
2730
2731 if ( i < m_numCols ) colLeft += m_colWidths[i];
2732 }
2733
2734 // Draw white highlights for a 3d effect
2735 //
2736 dc.SetPen( *wxWHITE_PEN );
2737
2738 colLeft = m_left + m_rowLabelWidth;
2739 for ( i = m_scrollPosX; i < m_numCols; i++ )
2740 {
2741 if (colLeft > cw) break;
2742
2743 dc.DrawLine(colLeft + 1, m_top + 1,
2744 colLeft + m_colWidths[i], m_top + 1);
2745
2746 dc.DrawLine(colLeft + 1, m_top + 1,
2747 colLeft + 1, m_top + m_colLabelHeight);
2748
2749 colLeft += m_colWidths[i];
2750 }
2751 }
2752
2753
2754 void wxGrid::DrawColLabel( wxDC& dc, const wxRect& rect, int col )
2755 {
2756 wxRect rect2;
2757 rect2 = rect;
2758 rect2.x += 3;
2759 rect2.y += 2;
2760 rect2.width -= 5;
2761 rect2.height -= 4;
2762
2763 dc.SetBackgroundMode( wxTRANSPARENT );
2764 dc.SetTextBackground( GetLabelBackgroundColour() );
2765 dc.SetTextForeground( GetLabelTextColour() );
2766 dc.SetFont( GetLabelFont() );
2767
2768 int hAlign, vAlign;
2769 GetColLabelAlignment( &hAlign, &vAlign );
2770 DrawTextRectangle( dc, GetColLabelValue( col ), rect2, hAlign, vAlign );
2771 }
2772
2773
2774 void wxGrid::DrawRowLabels( wxDC& dc )
2775 {
2776 int cw, ch;
2777 GetClientSize(&cw, &ch);
2778
2779 if (m_rowLabelWidth == 0) return;
2780
2781 DrawRowLabelBorders( dc );
2782
2783 wxRect rect;
2784 rect.x = m_left + 1;
2785 rect.width = m_rowLabelWidth - 1;
2786
2787 int labelTop = m_top + m_colLabelHeight;
2788 int i;
2789
2790 for ( i = m_scrollPosY; i < m_numRows; i++ )
2791 {
2792 if ( labelTop > ch ) break;
2793
2794 rect.y = 1 + labelTop;
2795 rect.height = m_rowHeights[i];
2796 DrawRowLabel( dc, rect, i );
2797
2798 labelTop += m_rowHeights[i];
2799 }
2800 }
2801
2802
2803 void wxGrid::DrawRowLabelBorders( wxDC& dc )
2804 {
2805 if ( m_rowLabelWidth <= 0 ) return;
2806
2807 int i;
2808 int cw, ch;
2809 GetClientSize( &cw, &ch );
2810
2811 dc.SetPen( *wxBLACK_PEN );
2812
2813 // vertical lines
2814 //
2815 dc.DrawLine( m_left, m_top, m_left, ch );
2816
2817 dc.DrawLine( m_left + m_rowLabelWidth, m_top,
2818 m_left + m_rowLabelWidth, ch );
2819
2820 // horizontal lines
2821 //
2822 int rowTop = m_top + m_colLabelHeight;
2823 for ( i = m_scrollPosY; i <= m_numRows; i++ )
2824 {
2825 if ( rowTop > ch ) break;
2826
2827 dc.DrawLine( m_left, rowTop,
2828 m_left + m_rowLabelWidth, rowTop );
2829
2830 if ( i < m_numRows ) rowTop += m_rowHeights[i];
2831 }
2832
2833 // Draw white highlights for a 3d effect
2834 //
2835 dc.SetPen( *wxWHITE_PEN );
2836
2837 rowTop = m_top + m_colLabelHeight;
2838 for ( i = m_scrollPosY; i < m_numRows; i++ )
2839 {
2840 if ( rowTop > ch ) break;
2841
2842 dc.DrawLine( m_left + 1, rowTop + 1,
2843 m_left + m_rowLabelWidth, rowTop + 1 );
2844
2845 dc.DrawLine( m_left + 1, rowTop + 1,
2846 m_left + 1, rowTop + m_rowHeights[i] );
2847
2848 rowTop += m_rowHeights[i];
2849 }
2850 }
2851
2852
2853 void wxGrid::DrawRowLabel( wxDC& dc, const wxRect& rect, int row )
2854 {
2855 wxRect rect2;
2856 rect2 = rect;
2857 rect2.x += 3;
2858 rect2.y += 2;
2859 rect2.width -= 5;
2860 rect2.height -= 4;
2861
2862 dc.SetBackgroundMode( wxTRANSPARENT );
2863 dc.SetTextBackground( GetLabelBackgroundColour() );
2864 dc.SetTextForeground( GetLabelTextColour() );
2865 dc.SetFont( GetLabelFont() );
2866
2867 int hAlign, vAlign;
2868 GetRowLabelAlignment( &hAlign, &vAlign );
2869 DrawTextRectangle( dc, GetRowLabelValue( row ), rect2, hAlign, vAlign );
2870 }
2871
2872
2873 void wxGrid::DrawCellArea( wxDC& dc )
2874 {
2875 int cw, ch;
2876 GetClientSize(&cw, &ch);
2877
2878 dc.SetPen( *wxTRANSPARENT_PEN );
2879 dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
2880
2881 int left = m_left + m_rowLabelWidth + 1;
2882 int top = m_top + m_colLabelHeight + 1;
2883
2884 dc.DrawRectangle( left, top, cw - left, ch - top );
2885 }
2886
2887
2888 void wxGrid::DrawGridLines( wxDC& dc )
2889 {
2890 if ( !m_gridLinesEnabled || !m_numRows || !m_numCols ) return;
2891
2892 int i;
2893 int cw, ch;
2894 GetClientSize(&cw, &ch);
2895
2896 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
2897
2898 // horizontal grid lines
2899 //
2900 int rowTop = m_top + m_colLabelHeight + m_rowHeights[m_scrollPosY];
2901 for ( i = m_scrollPosY + 1; i <= m_numRows; i++ )
2902 {
2903 if ( rowTop > ch ) break;
2904
2905 dc.DrawLine( m_left + m_rowLabelWidth + 1, rowTop,
2906 m_right, rowTop);
2907
2908 if ( i < m_numRows ) rowTop += m_rowHeights[i];
2909 }
2910
2911
2912 // vertical grid lines
2913 //
2914 int colLeft = m_left + m_rowLabelWidth + m_colWidths[m_scrollPosX];
2915 for ( i = m_scrollPosX + 1; i <= m_numCols; i++ )
2916 {
2917 if ( colLeft > cw ) break;
2918
2919 dc.DrawLine( colLeft, m_top + m_colLabelHeight + 1,
2920 colLeft, m_bottom );
2921
2922 if ( i < m_numCols ) colLeft += m_colWidths[i];
2923 }
2924 }
2925
2926
2927 void wxGrid::DrawCells( wxDC& dc )
2928 {
2929 if ( !m_numRows || !m_numCols ) return;
2930
2931 int row, col;
2932
2933 int cw, ch;
2934 GetClientSize( &cw, &ch );
2935
2936 wxRect rect;
2937
2938 if ( m_table )
2939 {
2940 rect.y = m_top + m_colLabelHeight;
2941 for ( row = m_scrollPosY; row < m_numRows; row++ )
2942 {
2943 if ( rect.y > ch ) break;
2944
2945 rect.height = m_rowHeights[ row ];
2946 rect.x = m_left + m_rowLabelWidth;
2947
2948 for ( col = m_scrollPosX; col < m_numCols; col++ )
2949 {
2950 if ( rect.x > cw ) break;
2951
2952 rect.width = m_colWidths[col];
2953 DrawCellBackground( dc, rect, row, col );
2954 DrawCellValue( dc, rect, row, col );
2955 rect.x += rect.width;
2956 }
2957 rect.y += rect.height;
2958 }
2959 }
2960 }
2961
2962
2963 void wxGrid::DrawCellBackground( wxDC& dc, const wxRect& rect, int row, int col )
2964 {
2965 wxRect rect2;
2966 rect2 = rect;
2967 rect2.x += 1;
2968 rect2.y += 1;
2969 rect2.width -= 2;
2970 rect2.height -= 2;
2971
2972 dc.SetBackgroundMode( wxSOLID );
2973
2974 if ( IsInSelection( row, col ) )
2975 {
2976 // TODO: improve this
2977 //
2978 dc.SetBrush( *wxBLACK_BRUSH );
2979 }
2980 else
2981 {
2982 dc.SetBrush( wxBrush(GetCellBackgroundColour(row, col), wxSOLID) );
2983 }
2984 dc.SetPen( *wxTRANSPARENT_PEN );
2985 dc.DrawRectangle( rect2 );
2986 }
2987
2988
2989 void wxGrid::DrawCellValue( wxDC& dc, const wxRect& rect, int row, int col )
2990 {
2991 wxRect rect2;
2992 rect2 = rect;
2993 rect2.x += 3;
2994 rect2.y += 2;
2995 rect2.width -= 5;
2996 rect2.height -= 4;
2997
2998 dc.SetBackgroundMode( wxTRANSPARENT );
2999
3000 if ( IsInSelection( row, col ) )
3001 {
3002 // TODO: improve this
3003 //
3004 dc.SetTextBackground( wxColour(0, 0, 0) );
3005 dc.SetTextForeground( wxColour(255, 255, 255) );
3006 }
3007 else
3008 {
3009 dc.SetTextBackground( GetCellBackgroundColour(row, col) );
3010 dc.SetTextForeground( GetCellTextColour(row, col) );
3011 }
3012 dc.SetFont( GetCellFont(row, col) );
3013
3014 int hAlign, vAlign;
3015 GetCellAlignment( row, col, &hAlign, &vAlign );
3016 DrawTextRectangle( dc, GetCellValue( row, col ), rect2, hAlign, vAlign );
3017 }
3018
3019
3020 void wxGrid::DrawCellHighlight( wxDC& dc, int row, int col )
3021 {
3022 // TODO: bounds checking on row, col ?
3023 //
3024
3025 if ( row >= m_scrollPosY && col >= m_scrollPosX )
3026 {
3027 long x, y;
3028
3029 int cw, ch;
3030 GetClientSize( &cw, &ch );
3031
3032 x = m_colRights[col] - m_colWidths[col];
3033 if ( x >= cw ) return;
3034
3035 y = m_rowBottoms[row] - m_rowHeights[row];
3036 if ( y >= ch ) return;
3037
3038 dc.SetLogicalFunction( wxXOR );
3039 dc.SetPen( wxPen(GetCellHighlightColour(), 2, wxSOLID) );
3040 dc.SetBrush( *wxTRANSPARENT_BRUSH );
3041
3042 dc.DrawRectangle( x, y,
3043 m_colWidths[col] + 2,
3044 m_rowHeights[row] + 2 );
3045
3046 dc.SetLogicalFunction( wxCOPY );
3047 }
3048 }
3049
3050
3051 // This function is handy when you just want to update one or a few
3052 // cells. For example, it is used by SetCellValue()
3053 //
3054 void wxGrid::DrawCell( int row, int col )
3055 {
3056 if ( !GetBatchCount() )
3057 {
3058 if ( !IsVisible( wxGridCellCoords(row, col) ) ) return;
3059
3060 int cw, ch;
3061 GetClientSize( &cw, &ch );
3062
3063 wxRect rect( CellToRect( row, col ) );
3064
3065 if ( m_table )
3066 {
3067 wxClientDC dc( this );
3068 DrawCellBackground( dc, rect, row, col );
3069 DrawCellValue( dc, rect, row, col );
3070 }
3071 }
3072 }
3073
3074
3075 // this is just to make other code more obvious
3076 //
3077 void wxGrid::HideCurrentCellHighlight( wxDC& dc )
3078 {
3079 if ( m_currentCellHighlighted &&
3080 m_currentCellCoords != wxGridNoCellCoords )
3081 {
3082 DrawCellHighlight( dc, m_currentCellCoords );
3083 m_currentCellHighlighted = FALSE;
3084 }
3085 }
3086
3087
3088 // this is just to make other code more obvious
3089 //
3090 void wxGrid::ShowCurrentCellHighlight( wxDC& dc )
3091 {
3092 if ( !m_currentCellHighlighted &&
3093 m_currentCellCoords != wxGridNoCellCoords )
3094 {
3095 DrawCellHighlight( dc, m_currentCellCoords );
3096 m_currentCellHighlighted = TRUE;
3097 }
3098 }
3099
3100
3101 void wxGrid::DrawTextRectangle( wxDC& dc,
3102 const wxString& value,
3103 const wxRect& rect,
3104 int horizAlign,
3105 int vertAlign )
3106 {
3107 long textWidth, textHeight;
3108 long lineWidth, lineHeight;
3109 wxArrayString lines;
3110
3111 // see if we are already clipping
3112 //
3113 wxRect clipRect;
3114 dc.GetClippingBox( clipRect );
3115
3116 bool alreadyClipping = TRUE;
3117 wxRect intersectRect;
3118
3119 if ( clipRect.x == 0 && clipRect.y == 0 &&
3120 clipRect.width == 0 && clipRect.height == 0)
3121 {
3122 alreadyClipping = FALSE;
3123 intersectRect = rect;
3124 }
3125 else
3126 {
3127 // Find the intersection of the clipping rectangle and our
3128 // rectangle
3129 //
3130 wxRegion region( rect );
3131 region.Intersect( clipRect );
3132 if ( region.IsEmpty() )
3133 {
3134 // nothing to do
3135 //
3136 return;
3137 }
3138 intersectRect = region.GetBox();
3139 }
3140
3141 if ( alreadyClipping ) dc.DestroyClippingRegion();
3142
3143 dc.SetClippingRegion( intersectRect );
3144
3145 StringToLines( value, lines );
3146 if ( lines.GetCount() )
3147 {
3148 GetTextBoxSize( dc, lines, &textWidth, &textHeight );
3149 dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
3150
3151 float x, y;
3152 switch ( horizAlign )
3153 {
3154 case wxRIGHT:
3155 x = rect.x + (rect.width - textWidth - 1.0);
3156 break;
3157
3158 case wxCENTRE:
3159 x = rect.x + ((rect.width - textWidth)/2.0);
3160 break;
3161
3162 case wxLEFT:
3163 default:
3164 x = rect.x + 1.0;
3165 break;
3166 }
3167
3168 switch ( vertAlign )
3169 {
3170 case wxBOTTOM:
3171 y = rect.y + (rect.height - textHeight - 1);
3172 break;
3173
3174 case wxCENTRE:
3175 y = rect.y + ((rect.height - textHeight)/2.0);
3176 break;
3177
3178 case wxTOP:
3179 default:
3180 y = rect.y + 1.0;
3181 break;
3182 }
3183
3184 for ( size_t i = 0; i < lines.GetCount(); i++ )
3185 {
3186 dc.DrawText( lines[i], (long)x, (long)y );
3187 y += lineHeight;
3188 }
3189 }
3190
3191 dc.DestroyClippingRegion();
3192 if (alreadyClipping) dc.SetClippingRegion( clipRect );
3193 }
3194
3195
3196 // Split multi line text up into an array of strings. Any existing
3197 // contents of the string array are preserved.
3198 //
3199 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
3200 {
3201 // TODO: this won't work for WXMAC ? (lines end with '\r')
3202 // => use wxTextFile functions then (VZ)
3203 int startPos = 0;
3204 int pos;
3205 while ( startPos < (int)value.Length() )
3206 {
3207 pos = value.Mid(startPos).Find( '\n' );
3208 if ( pos < 0 )
3209 {
3210 break;
3211 }
3212 else if ( pos == 0 )
3213 {
3214 lines.Add( wxEmptyString );
3215 }
3216 else
3217 {
3218 if ( value[startPos+pos-1] == '\r' )
3219 {
3220 lines.Add( value.Mid(startPos, pos-1) );
3221 }
3222 else
3223 {
3224 lines.Add( value.Mid(startPos, pos) );
3225 }
3226 }
3227 startPos += pos+1;
3228 }
3229 if ( startPos < (int)value.Length() )
3230 {
3231 lines.Add( value.Mid( startPos ) );
3232 }
3233 }
3234
3235
3236 void wxGrid::GetTextBoxSize( wxDC& dc,
3237 wxArrayString& lines,
3238 long *width, long *height )
3239 {
3240 long w = 0;
3241 long h = 0;
3242 long lineW, lineH;
3243
3244 size_t i;
3245 for ( i = 0; i < lines.GetCount(); i++ )
3246 {
3247 dc.GetTextExtent( lines[i], &lineW, &lineH );
3248 w = wxMax( w, lineW );
3249 h += lineH;
3250 }
3251
3252 *width = w;
3253 *height = h;
3254 }
3255
3256
3257 //
3258 // ------ functions to get/send data (see also public functions)
3259 //
3260
3261 bool wxGrid::GetModelValues()
3262 {
3263 if ( m_table )
3264 {
3265 // all we need to do is repaint the grid
3266 //
3267 Refresh();
3268 return TRUE;
3269 }
3270
3271 return FALSE;
3272 }
3273
3274
3275 bool wxGrid::SetModelValues()
3276 {
3277 int row, col;
3278
3279 if ( m_table )
3280 {
3281 for ( row = m_scrollPosY; row < m_numRows; row++ )
3282 {
3283 for ( col = m_scrollPosX; col < m_numCols; col++ )
3284 {
3285 m_table->SetValue( row, col, GetCellValue(row, col) );
3286 }
3287 }
3288
3289 return TRUE;
3290 }
3291
3292 return FALSE;
3293 }
3294
3295
3296 //
3297 // ------ public functions
3298 //
3299
3300 bool wxGrid::CreateGrid( int numRows, int numCols )
3301 {
3302 if ( m_created )
3303 {
3304 wxLogError( "wxGrid::CreateGrid(numRows, numCols) called more than once" );
3305 return FALSE;
3306 }
3307 else
3308 {
3309 m_numRows = numRows;
3310 m_numCols = numCols;
3311
3312 m_table = new wxGridStringTable( m_numRows, m_numCols );
3313 m_table->SetView( this );
3314 Init();
3315 m_created = TRUE;
3316 }
3317
3318 return m_created;
3319 }
3320
3321
3322 // The behaviour of this function depends on the grid table class
3323 // Clear() function. For the default wxGridStringTable class the
3324 // behavious is to replace all cell contents with wxEmptyString but
3325 // not to change the number of rows or cols.
3326 //
3327 void wxGrid::ClearGrid()
3328 {
3329 if ( m_table )
3330 {
3331 m_table->Clear();
3332 SetEditControlValue();
3333 if ( !GetBatchCount() ) Refresh();
3334 }
3335 }
3336
3337
3338 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
3339 {
3340 // TODO: something with updateLabels flag
3341
3342 if ( !m_created )
3343 {
3344 wxLogError( "Called wxGrid::InsertRows() before calling CreateGrid()" );
3345 return FALSE;
3346 }
3347
3348 if ( m_table )
3349 {
3350 bool ok = m_table->InsertRows( pos, numRows );
3351
3352 // the table will have sent the results of the insert row
3353 // operation to this view object as a grid table message
3354 //
3355 if ( ok )
3356 {
3357 if ( m_numCols == 0 )
3358 {
3359 m_table->AppendCols( WXGRID_DEFAULT_NUMBER_COLS );
3360 //
3361 // TODO: perhaps instead of appending the default number of cols
3362 // we should remember what the last non-zero number of cols was ?
3363 //
3364 }
3365
3366 if ( m_currentCellCoords == wxGridNoCellCoords )
3367 {
3368 // if we have just inserted cols into an empty grid the current
3369 // cell will be undefined...
3370 //
3371 SelectCell( 0, 0 );
3372 }
3373
3374 if ( !GetBatchCount() ) Refresh();
3375 }
3376
3377 SetEditControlValue();
3378 return ok;
3379 }
3380 else
3381 {
3382 return FALSE;
3383 }
3384 }
3385
3386 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
3387 {
3388 // TODO: something with updateLabels flag
3389
3390 if ( !m_created )
3391 {
3392 wxLogError( "Called wxGrid::AppendRows() before calling CreateGrid()" );
3393 return FALSE;
3394 }
3395
3396 if ( m_table && m_table->AppendRows( numRows ) )
3397 {
3398 if ( m_currentCellCoords == wxGridNoCellCoords )
3399 {
3400 // if we have just inserted cols into an empty grid the current
3401 // cell will be undefined...
3402 //
3403 SelectCell( 0, 0 );
3404 }
3405
3406 // the table will have sent the results of the append row
3407 // operation to this view object as a grid table message
3408 //
3409 if ( !GetBatchCount() ) Refresh();
3410 return TRUE;
3411 }
3412 else
3413 {
3414 return FALSE;
3415 }
3416 }
3417
3418 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
3419 {
3420 // TODO: something with updateLabels flag
3421
3422 if ( !m_created )
3423 {
3424 wxLogError( "Called wxGrid::DeleteRows() before calling CreateGrid()" );
3425 return FALSE;
3426 }
3427
3428 if ( m_table && m_table->DeleteRows( pos, numRows ) )
3429 {
3430 // the table will have sent the results of the delete row
3431 // operation to this view object as a grid table message
3432 //
3433 if ( m_numRows > 0 )
3434 SetEditControlValue();
3435 else
3436 HideCellEditControl();
3437
3438 if ( !GetBatchCount() ) Refresh();
3439 return TRUE;
3440 }
3441 else
3442 {
3443 return FALSE;
3444 }
3445 }
3446
3447 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
3448 {
3449 // TODO: something with updateLabels flag
3450
3451 if ( !m_created )
3452 {
3453 wxLogError( "Called wxGrid::InsertCols() before calling CreateGrid()" );
3454 return FALSE;
3455 }
3456
3457 if ( m_table )
3458 {
3459 HideCellEditControl();
3460 bool ok = m_table->InsertCols( pos, numCols );
3461
3462 // the table will have sent the results of the insert col
3463 // operation to this view object as a grid table message
3464 //
3465 if ( ok )
3466 {
3467 if ( m_currentCellCoords == wxGridNoCellCoords )
3468 {
3469 // if we have just inserted cols into an empty grid the current
3470 // cell will be undefined...
3471 //
3472 SelectCell( 0, 0 );
3473 }
3474
3475 if ( !GetBatchCount() ) Refresh();
3476 }
3477
3478 SetEditControlValue();
3479 return ok;
3480 }
3481 else
3482 {
3483 return FALSE;
3484 }
3485 }
3486
3487 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
3488 {
3489 // TODO: something with updateLabels flag
3490
3491 if ( !m_created )
3492 {
3493 wxLogError( "Called wxGrid::AppendCols() before calling CreateGrid()" );
3494 return FALSE;
3495 }
3496
3497 if ( m_table && m_table->AppendCols( numCols ) )
3498 {
3499 // the table will have sent the results of the append col
3500 // operation to this view object as a grid table message
3501 //
3502 if ( m_currentCellCoords == wxGridNoCellCoords )
3503 {
3504 // if we have just inserted cols into an empty grid the current
3505 // cell will be undefined...
3506 //
3507 SelectCell( 0, 0 );
3508 }
3509 if ( !GetBatchCount() ) Refresh();
3510 return TRUE;
3511 }
3512 else
3513 {
3514 return FALSE;
3515 }
3516 }
3517
3518 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
3519 {
3520 // TODO: something with updateLabels flag
3521
3522 if ( !m_created )
3523 {
3524 wxLogError( "Called wxGrid::DeleteCols() before calling CreateGrid()" );
3525 return FALSE;
3526 }
3527
3528 if ( m_table && m_table->DeleteCols( pos, numCols ) )
3529 {
3530 // the table will have sent the results of the delete col
3531 // operation to this view object as a grid table message
3532 //
3533 if ( m_numCols > 0 )
3534 SetEditControlValue();
3535 else
3536 HideCellEditControl();
3537
3538 if ( !GetBatchCount() ) Refresh();
3539 return TRUE;
3540 }
3541 else
3542 {
3543 return FALSE;
3544 }
3545 }
3546
3547
3548
3549
3550 // ------ control panel and cell edit control
3551 //
3552
3553 void wxGrid::EnableEditing( bool edit )
3554 {
3555 // TODO: improve this ?
3556 //
3557 if ( edit != m_editable )
3558 {
3559 m_editable = edit;
3560 if ( !m_editable ) HideCellEditControl();
3561 m_topEditCtrlEnabled = m_editable;
3562 m_cellEditCtrlEnabled = m_editable;
3563 if ( !m_editable ) ShowCellEditControl();
3564 }
3565 }
3566
3567
3568 void wxGrid::EnableTopEditControl( bool enable )
3569 {
3570 if ( enable != m_topEditCtrlEnabled )
3571 {
3572 HideCellEditControl();
3573 m_topEditCtrlEnabled = enable;
3574 CalcDimensions();
3575 m_topEditCtrl->Show( enable );
3576
3577 if ( m_currentCellCoords != wxGridNoCellCoords )
3578 SetEditControlValue();
3579
3580 ShowCellEditControl();
3581 if ( !GetBatchCount() ) Refresh();
3582 }
3583 }
3584
3585 void wxGrid::EnableCellEditControl( bool enable )
3586 {
3587 if ( m_cellEditCtrl &&
3588 enable != m_cellEditCtrlEnabled )
3589 {
3590 HideCellEditControl();
3591 SaveEditControlValue();
3592
3593 m_cellEditCtrlEnabled = enable;
3594
3595 SetEditControlValue();
3596 ShowCellEditControl();
3597 }
3598 }
3599
3600
3601 //
3602 // ------ grid formatting functions
3603 //
3604
3605 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
3606 {
3607 *horiz = m_rowLabelHorizAlign;
3608 *vert = m_rowLabelVertAlign;
3609 }
3610
3611 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
3612 {
3613 *horiz = m_colLabelHorizAlign;
3614 *vert = m_colLabelVertAlign;
3615 }
3616
3617 wxString wxGrid::GetRowLabelValue( int row )
3618 {
3619 if ( m_table )
3620 {
3621 return m_table->GetRowLabelValue( row );
3622 }
3623 else
3624 {
3625 wxString s;
3626 s << row;
3627 return s;
3628 }
3629 }
3630
3631 wxString wxGrid::GetColLabelValue( int col )
3632 {
3633 if ( m_table )
3634 {
3635 return m_table->GetColLabelValue( col );
3636 }
3637 else
3638 {
3639 wxString s;
3640 s << col;
3641 return s;
3642 }
3643 }
3644
3645 void wxGrid::SetRowLabelSize( int width )
3646 {
3647 m_rowLabelWidth = wxMax( 0, width );
3648 CalcDimensions();
3649 ShowCellEditControl();
3650 if ( !GetBatchCount() ) Refresh();
3651 }
3652
3653 void wxGrid::SetColLabelSize( int height )
3654 {
3655 m_colLabelHeight = wxMax( 0, height );
3656 CalcDimensions();
3657 ShowCellEditControl();
3658 if ( !GetBatchCount() ) Refresh();
3659 }
3660
3661 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
3662 {
3663 m_labelBackgroundColour = colour;
3664 if ( !GetBatchCount() ) Refresh();
3665 }
3666
3667 void wxGrid::SetLabelTextColour( const wxColour& colour )
3668 {
3669 m_labelTextColour = colour;
3670 if ( !GetBatchCount() ) Refresh();
3671 }
3672
3673 void wxGrid::SetLabelFont( const wxFont& font )
3674 {
3675 m_labelFont = font;
3676 if ( !GetBatchCount() ) Refresh();
3677 }
3678
3679 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
3680 {
3681 if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
3682 {
3683 m_rowLabelHorizAlign = horiz;
3684 }
3685
3686 if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
3687 {
3688 m_rowLabelVertAlign = vert;
3689 }
3690
3691 if ( !GetBatchCount() ) Refresh();
3692 }
3693
3694 void wxGrid::SetColLabelAlignment( int horiz, int vert )
3695 {
3696 if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
3697 {
3698 m_colLabelHorizAlign = horiz;
3699 }
3700
3701 if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
3702 {
3703 m_colLabelVertAlign = vert;
3704 }
3705
3706 if ( !GetBatchCount() ) Refresh();
3707 }
3708
3709 void wxGrid::SetRowLabelValue( int row, const wxString& s )
3710 {
3711 if ( m_table )
3712 {
3713 m_table->SetRowLabelValue( row, s );
3714 if ( !GetBatchCount() ) Refresh();
3715 }
3716 }
3717
3718 void wxGrid::SetColLabelValue( int col, const wxString& s )
3719 {
3720 if ( m_table )
3721 {
3722 m_table->SetColLabelValue( col, s );
3723 if ( !GetBatchCount() ) Refresh();
3724 }
3725 }
3726
3727 void wxGrid::SetGridLineColour( const wxColour& colour )
3728 {
3729 m_gridLineColour = colour;
3730
3731 wxClientDC dc( this );
3732 DrawGridLines( dc );
3733 }
3734
3735 void wxGrid::EnableGridLines( bool enable )
3736 {
3737 if ( enable != m_gridLinesEnabled )
3738 {
3739 m_gridLinesEnabled = enable;
3740 if ( !GetBatchCount() ) Refresh();
3741 }
3742 }
3743
3744
3745 int wxGrid::GetDefaultRowSize()
3746 {
3747 return m_defaultRowHeight;
3748 }
3749
3750 int wxGrid::GetRowSize( int row )
3751 {
3752 if ( row >= 0 && row < m_numRows )
3753 return m_rowHeights[row];
3754 else
3755 return 0; // TODO: log an error here
3756 }
3757
3758 int wxGrid::GetDefaultColSize()
3759 {
3760 return m_defaultColWidth;
3761 }
3762
3763 int wxGrid::GetColSize( int col )
3764 {
3765 if ( col >= 0 && col < m_numCols )
3766 return m_colWidths[col];
3767 else
3768 return 0; // TODO: log an error here
3769 }
3770
3771 wxColour wxGrid::GetDefaultCellBackgroundColour()
3772 {
3773 // TODO: replace this temp test code
3774 //
3775 return wxColour( 255, 255, 255 );
3776 }
3777
3778 wxColour wxGrid::GetCellBackgroundColour( int row, int col )
3779 {
3780 // TODO: replace this temp test code
3781 //
3782 return wxColour( 255, 255, 255 );
3783 }
3784
3785 wxColour wxGrid::GetDefaultCellTextColour()
3786 {
3787 // TODO: replace this temp test code
3788 //
3789 return wxColour( 0, 0, 0 );
3790 }
3791
3792 wxColour wxGrid::GetCellTextColour( int row, int col )
3793 {
3794 // TODO: replace this temp test code
3795 //
3796 return wxColour( 0, 0, 0 );
3797 }
3798
3799
3800 wxColour wxGrid::GetCellHighlightColour()
3801 {
3802 // TODO: replace this temp test code
3803 //
3804 return wxColour( 0, 0, 0 );
3805 }
3806
3807
3808 wxFont wxGrid::GetDefaultCellFont()
3809 {
3810 return m_defaultCellFont;
3811 }
3812
3813 wxFont wxGrid::GetCellFont( int row, int col )
3814 {
3815 // TODO: replace this temp test code
3816 //
3817 return m_defaultCellFont;
3818 }
3819
3820 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
3821 {
3822 // TODO: replace this temp test code
3823 //
3824 *horiz = wxLEFT;
3825 *vert = wxTOP;
3826 }
3827
3828 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
3829 {
3830 // TODO: replace this temp test code
3831 //
3832 *horiz = wxLEFT;
3833 *vert = wxTOP;
3834 }
3835
3836 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
3837 {
3838 m_defaultRowHeight = wxMax( height, WXGRID_MIN_ROW_HEIGHT );
3839
3840 if ( resizeExistingRows )
3841 {
3842 // TODO: what do we do about events here ?
3843 // Generate an event for each resize ?
3844 //
3845 int row;
3846 for ( row = 0; row < m_numRows; row++ )
3847 {
3848 m_rowHeights[row] = m_defaultRowHeight;
3849 }
3850 CalcDimensions();
3851 if ( !GetBatchCount() ) Refresh();
3852 }
3853 }
3854
3855 void wxGrid::SetRowSize( int row, int height )
3856 {
3857 if ( row >= 0 && row < m_numRows )
3858 {
3859 m_rowHeights[row] = wxMax( 0, height );
3860 CalcDimensions();
3861 if ( !GetBatchCount() ) Refresh();
3862
3863 // Note: we are ending the event *after* doing
3864 // default processing in this case
3865 //
3866 SendEvent( EVT_GRID_ROW_SIZE,
3867 row, -1 );
3868 }
3869 else
3870 {
3871 // TODO: log an error here
3872 }
3873 }
3874
3875 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
3876 {
3877 m_defaultColWidth = wxMax( width, WXGRID_MIN_COL_WIDTH );
3878
3879 if ( resizeExistingCols )
3880 {
3881 // TODO: what do we do about events here ?
3882 // Generate an event for each resize ?
3883 //
3884 int col;
3885 for ( col = 0; col < m_numCols; col++ )
3886 {
3887 m_colWidths[col] = m_defaultColWidth;
3888 }
3889 CalcDimensions();
3890 if ( !GetBatchCount() ) Refresh();
3891 }
3892 }
3893
3894 void wxGrid::SetColSize( int col, int width )
3895 {
3896 if ( col >= 0 && col < m_numCols )
3897 {
3898 m_colWidths[col] = wxMax( 0, width );
3899 CalcDimensions();
3900 if ( !GetBatchCount() ) Refresh();
3901
3902 // Note: we are ending the event *after* doing
3903 // default processing in this case
3904 //
3905 SendEvent( EVT_GRID_COL_SIZE,
3906 -1, col );
3907 }
3908 else
3909 {
3910 // TODO: log an error here
3911 }
3912 }
3913
3914 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& )
3915 {
3916 // TODO: everything !!!
3917 //
3918 }
3919
3920 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& )
3921 {
3922 // TODO: everything !!!
3923 //
3924 }
3925
3926 void wxGrid::SetDefaultCellTextColour( const wxColour& )
3927 {
3928 // TODO: everything !!!
3929 //
3930 }
3931
3932 void wxGrid::SetCellTextColour( int row, int col, const wxColour& )
3933 {
3934 // TODO: everything !!!
3935 //
3936 }
3937
3938 void wxGrid::SetCellHighlightColour( const wxColour& )
3939 {
3940 // TODO: everything !!!
3941 //
3942 }
3943
3944 void wxGrid::SetDefaultCellFont( const wxFont& )
3945 {
3946 // TODO: everything !!!
3947 //
3948 }
3949
3950 void wxGrid::SetCellFont( int row, int col, const wxFont& )
3951 {
3952 // TODO: everything !!!
3953 //
3954 }
3955
3956 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
3957 {
3958 // TODO: everything !!!
3959 //
3960 }
3961
3962 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
3963 {
3964 // TODO: everything !!!
3965 //
3966 }
3967
3968
3969 //
3970 // ------ cell value accessor functions
3971 //
3972
3973 void wxGrid::SetCellValue( int row, int col, const wxString& s )
3974 {
3975 if ( m_table )
3976 {
3977 m_table->SetValue( row, col, s.c_str() );
3978 DrawCell( row, col );
3979 if ( m_currentCellCoords.GetRow() == row &&
3980 m_currentCellCoords.GetCol() == col )
3981 {
3982 SetEditControlValue( s );
3983 }
3984 }
3985 }
3986
3987
3988
3989 //
3990 // ------ interaction with data model
3991 //
3992 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
3993 {
3994 switch ( msg.GetId() )
3995 {
3996 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
3997 return GetModelValues();
3998
3999 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
4000 return SetModelValues();
4001
4002 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4003 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4004 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4005 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4006 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4007 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4008 return Redimension( msg );
4009
4010 default:
4011 return FALSE;
4012 }
4013 }
4014
4015
4016 //
4017 // ------ Grid location functions
4018 //
4019 // (see also inline functions in grid.h)
4020
4021
4022 // check to see if a cell location is wholly visible
4023 //
4024 bool wxGrid::IsVisible( const wxGridCellCoords& coords )
4025 {
4026 return ( coords.GetRow() >= m_scrollPosY &&
4027 coords.GetRow() < m_scrollPosY + m_wholeRowsVisible &&
4028 coords.GetCol() >= m_scrollPosX &&
4029 coords.GetCol() < m_scrollPosX + m_wholeColsVisible );
4030 }
4031
4032
4033 // make the specified cell location visible by doing a minimal amount
4034 // of scrolling
4035 //
4036 void wxGrid::MakeCellVisible( int row, int col )
4037 {
4038 int lastX = m_scrollPosX;
4039 int lastY = m_scrollPosY;
4040
4041 if ( row >= 0 && row < m_numRows &&
4042 col >= 0 && col < m_numCols )
4043 {
4044 if ( row < m_scrollPosY )
4045 {
4046 SetVerticalScrollPos( row );
4047 }
4048 else if ( row >= m_scrollPosY + m_wholeRowsVisible )
4049 {
4050 int i;
4051 int h = m_rowBottoms[row];
4052 for ( i = m_scrollPosY; i < m_numRows && h > m_bottom; i++ )
4053 {
4054 h -= m_rowHeights[i];
4055 }
4056 SetVerticalScrollPos( i );
4057 }
4058
4059 if ( col < m_scrollPosX )
4060 {
4061 SetHorizontalScrollPos( col );
4062 }
4063 else if ( col >= m_scrollPosX + m_wholeColsVisible )
4064 {
4065 int i;
4066 int w = m_colRights[col];
4067 for ( i = m_scrollPosX; i < m_numCols && w > m_right; i++ )
4068 {
4069 w -= m_colWidths[i];
4070 }
4071 SetHorizontalScrollPos( i );
4072 }
4073
4074 if ( m_scrollPosX != lastX || m_scrollPosY != lastY )
4075 {
4076 // The cell was not visible before but not it is
4077 //
4078 ShowCellEditControl();
4079 }
4080 }
4081 else
4082 {
4083 // TODO: log an error
4084 }
4085 }
4086
4087
4088 void wxGrid::SetVerticalScrollPos( int topMostRow )
4089 {
4090 if ( m_vertScrollBar && topMostRow != m_scrollPosY )
4091 {
4092 m_scrollPosY = topMostRow;
4093
4094 CalcDimensions();
4095 Refresh();
4096 }
4097 }
4098
4099
4100 void wxGrid::SetHorizontalScrollPos( int leftMostCol )
4101 {
4102 if ( m_horizScrollBar && leftMostCol != m_scrollPosX )
4103 {
4104 m_scrollPosX = leftMostCol;
4105
4106 CalcDimensions();
4107 Refresh();
4108 }
4109 }
4110
4111
4112 //
4113 // ------ block, row and col selection
4114 //
4115
4116 void wxGrid::SelectRow( int row, bool addToSelected )
4117 {
4118 if ( IsSelection() && addToSelected )
4119 {
4120 if ( m_selectedTopLeft.GetRow() > row )
4121 m_selectedTopLeft.SetRow( row );
4122
4123 m_selectedTopLeft.SetCol( 0 );
4124
4125 if ( m_selectedBottomRight.GetRow() < row )
4126 m_selectedBottomRight.SetRow( row );
4127
4128 m_selectedBottomRight.SetCol( m_numCols - 1 );
4129 }
4130 else
4131 {
4132 ClearSelection();
4133 m_selectedTopLeft.Set( row, 0 );
4134 m_selectedBottomRight.Set( row, m_numCols-1 );
4135 }
4136
4137 if ( !GetBatchCount() )
4138 {
4139 wxRect rect( SelectionToRect() );
4140 if ( rect != wxGridNoCellRect ) Refresh( TRUE, &rect );
4141 }
4142
4143 wxGridRangeSelectEvent gridEvt( GetId(),
4144 EVT_GRID_RANGE_SELECT,
4145 this,
4146 m_selectedTopLeft,
4147 m_selectedBottomRight );
4148
4149 GetEventHandler()->ProcessEvent(gridEvt);
4150 }
4151
4152
4153 void wxGrid::SelectCol( int col, bool addToSelected )
4154 {
4155 if ( addToSelected && m_selectedTopLeft != wxGridNoCellCoords )
4156 {
4157 if ( m_selectedTopLeft.GetCol() > col )
4158 m_selectedTopLeft.SetCol( col );
4159
4160 m_selectedTopLeft.SetRow( 0 );
4161
4162 if ( m_selectedBottomRight.GetCol() < col )
4163 m_selectedBottomRight.SetCol( col );
4164
4165 m_selectedBottomRight.SetRow( m_numRows - 1 );
4166 }
4167 else
4168 {
4169 ClearSelection();
4170 m_selectedTopLeft.Set( 0, col );
4171 m_selectedBottomRight.Set( m_numRows-1, col );
4172 }
4173
4174 if ( !GetBatchCount() )
4175 {
4176 wxRect rect( SelectionToRect() );
4177 if ( rect != wxGridNoCellRect ) Refresh( TRUE, &rect );
4178 }
4179
4180 wxGridRangeSelectEvent gridEvt( GetId(),
4181 EVT_GRID_RANGE_SELECT,
4182 this,
4183 m_selectedTopLeft,
4184 m_selectedBottomRight );
4185
4186 GetEventHandler()->ProcessEvent(gridEvt);
4187 }
4188
4189
4190 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
4191 {
4192 int temp;
4193
4194 if ( topRow > bottomRow )
4195 {
4196 temp = topRow;
4197 topRow = bottomRow;
4198 bottomRow = temp;
4199 }
4200
4201 if ( leftCol > rightCol )
4202 {
4203 temp = leftCol;
4204 leftCol = rightCol;
4205 rightCol = temp;
4206 }
4207
4208 m_selectedTopLeft.Set( topRow, leftCol );
4209 m_selectedBottomRight.Set( bottomRow, rightCol );
4210
4211 if ( !GetBatchCount() )
4212 {
4213 wxRect rect( SelectionToRect() );
4214 if ( rect != wxGridNoCellRect ) Refresh( TRUE, &rect );
4215 }
4216
4217 // only generate an event if the block is not being selected by
4218 // dragging the mouse (in which case the event will be generated in
4219 // OnMouse) }
4220 if ( !m_isDragging )
4221 {
4222 wxGridRangeSelectEvent gridEvt( GetId(),
4223 EVT_GRID_RANGE_SELECT,
4224 this,
4225 m_selectedTopLeft,
4226 m_selectedBottomRight );
4227
4228 GetEventHandler()->ProcessEvent(gridEvt);
4229 }
4230 }
4231
4232 void wxGrid::SelectAll()
4233 {
4234 m_selectedTopLeft.Set( 0, 0 );
4235 m_selectedBottomRight.Set( m_numRows-1, m_numCols-1 );
4236
4237 if ( !GetBatchCount() ) Refresh();
4238 }
4239
4240
4241 void wxGrid::ClearSelection()
4242 {
4243 if ( IsSelection() )
4244 {
4245 wxRect rect( SelectionToRect() );
4246 if ( rect != wxGridNoCellRect )
4247 {
4248 Refresh( TRUE, &rect );
4249 }
4250
4251 m_selectedTopLeft = wxGridNoCellCoords;
4252 m_selectedBottomRight = wxGridNoCellCoords;
4253 }
4254 }
4255
4256
4257 wxRect wxGrid::SelectionToRect()
4258 {
4259 wxRect rect;
4260 wxRect cellRect;
4261
4262 if ( IsSelection() )
4263 {
4264 cellRect = CellToRect( m_selectedTopLeft );
4265 if ( cellRect != wxGridNoCellRect )
4266 {
4267 rect = cellRect;
4268 }
4269 else
4270 {
4271 rect = wxRect( m_left, m_top, 0, 0 );
4272 }
4273
4274 cellRect = CellToRect( m_selectedBottomRight );
4275 if ( cellRect != wxGridNoCellRect )
4276 {
4277 rect += cellRect;
4278 }
4279 else
4280 {
4281 return wxGridNoCellRect;
4282 }
4283 }
4284
4285 return rect;
4286 }
4287
4288
4289
4290
4291 //
4292 // ------ Grid event classes
4293 //
4294
4295 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
4296
4297 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
4298 int row, int col, int x, int y,
4299 bool control, bool shift, bool alt, bool meta )
4300 : wxNotifyEvent( type, id )
4301 {
4302 m_row = row;
4303 m_col = col;
4304 m_x = x;
4305 m_y = y;
4306 m_control = control;
4307 m_shift = shift;
4308 m_alt = alt;
4309 m_meta = meta;
4310
4311 SetEventObject(obj);
4312 }
4313
4314
4315 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxEvent )
4316
4317 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
4318 int rowOrCol, int x, int y,
4319 bool control, bool shift, bool alt, bool meta )
4320 : wxNotifyEvent( type, id )
4321 {
4322 m_rowOrCol = rowOrCol;
4323 m_x = x;
4324 m_y = y;
4325 m_control = control;
4326 m_shift = shift;
4327 m_alt = alt;
4328 m_meta = meta;
4329
4330 SetEventObject(obj);
4331 }
4332
4333
4334 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
4335
4336 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
4337 const wxGridCellCoords& topLeft,
4338 const wxGridCellCoords& bottomRight,
4339 bool control, bool shift, bool alt, bool meta )
4340 : wxNotifyEvent( type, id )
4341 {
4342 m_topLeft = topLeft;
4343 m_bottomRight = bottomRight;
4344 m_control = control;
4345 m_shift = shift;
4346 m_alt = alt;
4347 m_meta = meta;
4348
4349 SetEventObject(obj);
4350 }
4351
4352
4353 #endif // ifndef wxUSE_NEW_GRID
4354
wxWidgets (Impactor)