]> git.saurik.com Git - wxWidgets.git/blob - src/generic/gridsel.cpp
Tweaks for demos on MacOSX
[wxWidgets.git] / src / generic / gridsel.cpp
1 ///////////////////////////////////////////////////////////////////////////
2 // Name: generic/gridsel.cpp
3 // Purpose: wxGridSelection
4 // Author: Stefan Neis
5 // Modified by:
6 // Created: 20/02/1999
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Neis (Stefan.Neis@t-online.de)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx/wx.h".
21 #include "wx/wxprec.h"
22
23 #include "wx/defs.h"
24
25 #ifdef __BORLANDC__
26 #pragma hdrstop
27 #endif
28
29 #if wxUSE_GRID
30
31 #include "wx/generic/gridsel.h"
32
33
34 // Some explanation for the members of the class:
35 // m_cellSelection stores individual selected cells
36 // -- this is only used if m_selectionMode == wxGridSelectCells
37 // m_blockSelectionTopLeft and m_blockSelectionBottomRight
38 // store the upper left and lower right corner of selected Blocks
39 // m_rowSelection and m_colSelection store individual selected
40 // rows and columns; maybe those are superfluous and should be
41 // treated as blocks?
42
43 wxGridSelection::wxGridSelection( wxGrid * grid,
44 wxGrid::wxGridSelectionModes sel )
45 {
46 m_grid = grid;
47 m_selectionMode = sel;
48 }
49
50 bool wxGridSelection::IsSelection()
51 {
52 return ( m_cellSelection.GetCount() || m_blockSelectionTopLeft.GetCount() ||
53 m_rowSelection.GetCount() || m_colSelection.GetCount() );
54 }
55
56 bool wxGridSelection::IsInSelection( int row, int col )
57 {
58 size_t count;
59
60 // First check whether the given cell is individually selected
61 // (if m_selectionMode is wxGridSelectCells).
62 if ( m_selectionMode == wxGrid::wxGridSelectCells )
63 {
64 count = m_cellSelection.GetCount();
65 for ( size_t n = 0; n < count; n++ )
66 {
67 wxGridCellCoords& coords = m_cellSelection[n];
68 if ( row == coords.GetRow() && col == coords.GetCol() )
69 return true;
70 }
71 }
72
73 // Now check whether the given cell is
74 // contained in one of the selected blocks.
75 count = m_blockSelectionTopLeft.GetCount();
76 for ( size_t n = 0; n < count; n++ )
77 {
78 wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
79 wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
80 if ( BlockContainsCell(coords1.GetRow(), coords1.GetCol(),
81 coords2.GetRow(), coords2.GetCol(),
82 row, col ) )
83 return true;
84 }
85
86 // Now check whether the given cell is
87 // contained in one of the selected rows
88 // (unless we are in column selection mode).
89 if ( m_selectionMode != wxGrid::wxGridSelectColumns )
90 {
91 count = m_rowSelection.GetCount();
92 for ( size_t n = 0; n < count; n++ )
93 {
94 if ( row == m_rowSelection[n] )
95 return true;
96 }
97 }
98
99 // Now check whether the given cell is
100 // contained in one of the selected columns
101 // (unless we are in row selection mode).
102 if ( m_selectionMode != wxGrid::wxGridSelectRows )
103 {
104 count = m_colSelection.GetCount();
105 for ( size_t n = 0; n < count; n++ )
106 {
107 if ( col == m_colSelection[n] )
108 return true;
109 }
110 }
111
112 return false;
113 }
114
115 // Change the selection mode
116 void wxGridSelection::SetSelectionMode( wxGrid::wxGridSelectionModes selmode )
117 {
118 // if selection mode is unchanged return immediately
119 if (selmode == m_selectionMode)
120 return;
121
122 if ( m_selectionMode != wxGrid::wxGridSelectCells )
123 {
124 // if changing form row to column selection
125 // or vice versa, clear the selection.
126 if ( selmode != wxGrid::wxGridSelectCells )
127 ClearSelection();
128
129 m_selectionMode = selmode;
130 }
131 else
132 {
133 // if changing from cell selection to something else,
134 // promote selected cells/blocks to whole rows/columns.
135 size_t n;
136 while ( ( n = m_cellSelection.GetCount() ) > 0 )
137 {
138 n--;
139 wxGridCellCoords& coords = m_cellSelection[n];
140 int row = coords.GetRow();
141 int col = coords.GetCol();
142 m_cellSelection.RemoveAt(n);
143 if (selmode == wxGrid::wxGridSelectRows)
144 SelectRow( row );
145 else // selmode == wxGridSelectColumns)
146 SelectCol( col );
147 }
148
149 // Note that m_blockSelectionTopLeft's size may be changing!
150 for (n = 0; n < m_blockSelectionTopLeft.GetCount(); n++)
151 {
152 wxGridCellCoords& coords = m_blockSelectionTopLeft[n];
153 int topRow = coords.GetRow();
154 int leftCol = coords.GetCol();
155 coords = m_blockSelectionBottomRight[n];
156 int bottomRow = coords.GetRow();
157 int rightCol = coords.GetCol();
158
159 if (selmode == wxGrid::wxGridSelectRows)
160 {
161 if (leftCol != 0 || rightCol != m_grid->GetNumberCols() - 1 )
162 {
163 m_blockSelectionTopLeft.RemoveAt(n);
164 m_blockSelectionBottomRight.RemoveAt(n);
165 SelectBlock( topRow, 0,
166 bottomRow, m_grid->GetNumberCols() - 1,
167 false, false, false, false, false );
168 }
169 }
170 else // selmode == wxGridSelectColumns)
171 {
172 if (topRow != 0 || bottomRow != m_grid->GetNumberRows() - 1 )
173 {
174 m_blockSelectionTopLeft.RemoveAt(n);
175 m_blockSelectionBottomRight.RemoveAt(n);
176 SelectBlock( 0, leftCol,
177 m_grid->GetNumberRows() - 1, rightCol,
178 false, false, false, false, false );
179 }
180 }
181 }
182
183 m_selectionMode = selmode;
184 }
185 }
186
187 void wxGridSelection::SelectRow( int row,
188 bool ControlDown, bool ShiftDown,
189 bool AltDown, bool MetaDown )
190 {
191 if ( m_selectionMode == wxGrid::wxGridSelectColumns )
192 return;
193
194 size_t count, n;
195
196 // Remove single cells contained in newly selected block.
197 if ( m_selectionMode == wxGrid::wxGridSelectCells )
198 {
199 count = m_cellSelection.GetCount();
200 for ( n = 0; n < count; n++ )
201 {
202 wxGridCellCoords& coords = m_cellSelection[n];
203 if ( BlockContainsCell( row, 0, row, m_grid->GetNumberCols() - 1,
204 coords.GetRow(), coords.GetCol() ) )
205 {
206 m_cellSelection.RemoveAt(n);
207 n--;
208 count--;
209 }
210 }
211 }
212
213 // Simplify list of selected blocks (if possible)
214 count = m_blockSelectionTopLeft.GetCount();
215 bool done = false;
216
217 for ( n = 0; n < count; n++ )
218 {
219 wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
220 wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
221
222 // Remove block if it is a subset of the row
223 if ( coords1.GetRow() == row && row == coords2.GetRow() )
224 {
225 m_blockSelectionTopLeft.RemoveAt(n);
226 m_blockSelectionBottomRight.RemoveAt(n);
227 n--;
228 count--;
229 }
230 else if ( coords1.GetCol() == 0 &&
231 coords2.GetCol() == m_grid->GetNumberCols() - 1 )
232 {
233 // silently return, if row is contained in block
234 if ( coords1.GetRow() <= row && row <= coords2.GetRow() )
235 return;
236 // expand block, if it touched row
237 else if ( coords1.GetRow() == row + 1)
238 {
239 coords1.SetRow(row);
240 done = true;
241 }
242 else if ( coords2.GetRow() == row - 1)
243 {
244 coords2.SetRow(row);
245 done = true;
246 }
247 }
248 }
249
250 // Unless we successfully handled the row,
251 // check whether row is already selected.
252 if ( !done )
253 {
254 count = m_rowSelection.GetCount();
255 for ( n = 0; n < count; n++ )
256 {
257 if ( row == m_rowSelection[n] )
258 return;
259 }
260
261 // Add row to selection
262 m_rowSelection.Add(row);
263 }
264
265 // Update View:
266 if ( !m_grid->GetBatchCount() )
267 {
268 wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
269 wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
270 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
271 }
272
273 // Send Event
274 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
275 wxEVT_GRID_RANGE_SELECT,
276 m_grid,
277 wxGridCellCoords( row, 0 ),
278 wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ),
279 true,
280 ControlDown, ShiftDown,
281 AltDown, MetaDown );
282
283 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
284 }
285
286 void wxGridSelection::SelectCol( int col,
287 bool ControlDown, bool ShiftDown,
288 bool AltDown, bool MetaDown )
289 {
290 if ( m_selectionMode == wxGrid::wxGridSelectRows )
291 return;
292 size_t count, n;
293
294 // Remove single cells contained in newly selected block.
295 if ( m_selectionMode == wxGrid::wxGridSelectCells )
296 {
297 count = m_cellSelection.GetCount();
298 for ( n = 0; n < count; n++ )
299 {
300 wxGridCellCoords& coords = m_cellSelection[n];
301 if ( BlockContainsCell( 0, col, m_grid->GetNumberRows() - 1, col,
302 coords.GetRow(), coords.GetCol() ) )
303 {
304 m_cellSelection.RemoveAt(n);
305 n--;
306 count--;
307 }
308 }
309 }
310
311 // Simplify list of selected blocks (if possible)
312 count = m_blockSelectionTopLeft.GetCount();
313 bool done = false;
314 for ( n = 0; n < count; n++ )
315 {
316 wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
317 wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
318
319 // Remove block if it is a subset of the column
320 if ( coords1.GetCol() == col && col == coords2.GetCol() )
321 {
322 m_blockSelectionTopLeft.RemoveAt(n);
323 m_blockSelectionBottomRight.RemoveAt(n);
324 n--;
325 count--;
326 }
327 else if ( coords1.GetRow() == 0 &&
328 coords2.GetRow() == m_grid->GetNumberRows() - 1 )
329 {
330 // silently return, if row is contained in block
331 if ( coords1.GetCol() <= col && col <= coords2.GetCol() )
332 return;
333 // expand block, if it touched col
334 else if ( coords1.GetCol() == col + 1)
335 {
336 coords1.SetCol(col);
337 done = true;
338 }
339 else if ( coords2.GetCol() == col - 1)
340 {
341 coords2.SetCol(col);
342 done = true;
343 }
344 }
345 }
346
347 // Unless we successfully handled the column,
348 // Check whether col is already selected.
349 if ( !done )
350 {
351 count = m_colSelection.GetCount();
352 for ( n = 0; n < count; n++ )
353 {
354 if ( col == m_colSelection[n] )
355 return;
356 }
357
358 // Add col to selection
359 m_colSelection.Add(col);
360 }
361
362 // Update View:
363 if ( !m_grid->GetBatchCount() )
364 {
365 wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
366 wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
367 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
368 }
369
370 // Send Event
371 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
372 wxEVT_GRID_RANGE_SELECT,
373 m_grid,
374 wxGridCellCoords( 0, col ),
375 wxGridCellCoords( m_grid->GetNumberRows() - 1, col ),
376 true,
377 ControlDown, ShiftDown,
378 AltDown, MetaDown );
379
380 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
381 }
382
383 void wxGridSelection::SelectBlock( int topRow, int leftCol,
384 int bottomRow, int rightCol,
385 bool ControlDown, bool ShiftDown,
386 bool AltDown, bool MetaDown,
387 bool sendEvent )
388 {
389 // Fix the coordinates of the block if needed.
390 if ( m_selectionMode == wxGrid::wxGridSelectRows )
391 {
392 leftCol = 0;
393 rightCol = m_grid->GetNumberCols() - 1;
394 }
395 else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
396 {
397 topRow = 0;
398 bottomRow = m_grid->GetNumberRows() - 1;
399 }
400
401 if ( topRow > bottomRow )
402 {
403 int temp = topRow;
404 topRow = bottomRow;
405 bottomRow = temp;
406 }
407
408 if ( leftCol > rightCol )
409 {
410 int temp = leftCol;
411 leftCol = rightCol;
412 rightCol = temp;
413 }
414
415 // Handle single cell selection in SelectCell.
416 // (MB: added check for selection mode here to prevent
417 // crashes if, for example, we are select rows and the
418 // grid only has 1 col)
419 if ( m_selectionMode == wxGrid::wxGridSelectCells &&
420 topRow == bottomRow && leftCol == rightCol )
421 {
422 SelectCell( topRow, leftCol, ControlDown, ShiftDown,
423 AltDown, MetaDown, sendEvent );
424 }
425
426 size_t count, n;
427
428 // Remove single cells contained in newly selected block.
429 if ( m_selectionMode == wxGrid::wxGridSelectCells )
430 {
431 count = m_cellSelection.GetCount();
432 for ( n = 0; n < count; n++ )
433 {
434 wxGridCellCoords& coords = m_cellSelection[n];
435 if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol,
436 coords.GetRow(), coords.GetCol() ) )
437 {
438 m_cellSelection.RemoveAt(n);
439 n--;
440 count--;
441 }
442 }
443 }
444
445 // If a block containing the selection is already selected, return,
446 // if a block contained in the selection is found, remove it.
447
448 count = m_blockSelectionTopLeft.GetCount();
449 for ( n = 0; n < count; n++ )
450 {
451 wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
452 wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
453
454 switch ( BlockContain( coords1.GetRow(), coords1.GetCol(),
455 coords2.GetRow(), coords2.GetCol(),
456 topRow, leftCol, bottomRow, rightCol ) )
457 {
458 case 1:
459 return;
460
461 case -1:
462 m_blockSelectionTopLeft.RemoveAt(n);
463 m_blockSelectionBottomRight.RemoveAt(n);
464 n--;
465 count--;
466 break;
467
468 default:
469 break;
470 }
471 }
472
473 // If a row containing the selection is already selected, return,
474 // if a row contained in newly selected block is found, remove it.
475 if ( m_selectionMode != wxGrid::wxGridSelectColumns )
476 {
477 count = m_rowSelection.GetCount();
478 for ( n = 0; n < count; n++ )
479 {
480 switch ( BlockContain( m_rowSelection[n], 0,
481 m_rowSelection[n], m_grid->GetNumberCols() - 1,
482 topRow, leftCol, bottomRow, rightCol ) )
483 {
484 case 1:
485 return;
486
487 case -1:
488 m_rowSelection.RemoveAt(n);
489 n--;
490 count--;
491 break;
492
493 default:
494 break;
495 }
496 }
497 }
498
499 if ( m_selectionMode != wxGrid::wxGridSelectRows )
500 {
501 count = m_colSelection.GetCount();
502 for ( n = 0; n < count; n++ )
503 {
504 switch ( BlockContain( 0, m_colSelection[n],
505 m_grid->GetNumberRows() - 1, m_colSelection[n],
506 topRow, leftCol, bottomRow, rightCol ) )
507 {
508 case 1:
509 return;
510
511 case -1:
512 m_colSelection.RemoveAt(n);
513 n--;
514 count--;
515 break;
516
517 default:
518 break;
519 }
520 }
521 }
522
523 m_blockSelectionTopLeft.Add( wxGridCellCoords( topRow, leftCol ) );
524 m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) );
525
526 // Update View:
527 if ( !m_grid->GetBatchCount() )
528 {
529 wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( topRow, leftCol ),
530 wxGridCellCoords( bottomRow, rightCol ) );
531 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
532 }
533
534 // Send Event, if not disabled.
535 if ( sendEvent )
536 {
537 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
538 wxEVT_GRID_RANGE_SELECT,
539 m_grid,
540 wxGridCellCoords( topRow, leftCol ),
541 wxGridCellCoords( bottomRow, rightCol ),
542 true,
543 ControlDown, ShiftDown,
544 AltDown, MetaDown );
545 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
546 }
547 }
548
549 void wxGridSelection::SelectCell( int row, int col,
550 bool ControlDown, bool ShiftDown,
551 bool AltDown, bool MetaDown,
552 bool sendEvent )
553 {
554 if ( m_selectionMode == wxGrid::wxGridSelectRows )
555 {
556 SelectBlock(row, 0, row, m_grid->GetNumberCols() - 1,
557 ControlDown, ShiftDown, AltDown, MetaDown, sendEvent);
558
559 return;
560 }
561 else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
562 {
563 SelectBlock(0, col, m_grid->GetNumberRows() - 1, col,
564 ControlDown, ShiftDown, AltDown, MetaDown, sendEvent);
565
566 return;
567 }
568 else if ( IsInSelection ( row, col ) )
569 return;
570
571 m_cellSelection.Add( wxGridCellCoords( row, col ) );
572
573 // Update View:
574 if ( !m_grid->GetBatchCount() )
575 {
576 wxRect r = m_grid->BlockToDeviceRect(
577 wxGridCellCoords( row, col ),
578 wxGridCellCoords( row, col ) );
579 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
580 }
581
582 // Send event
583 if (sendEvent)
584 {
585 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
586 wxEVT_GRID_RANGE_SELECT,
587 m_grid,
588 wxGridCellCoords( row, col ),
589 wxGridCellCoords( row, col ),
590 true,
591 ControlDown, ShiftDown,
592 AltDown, MetaDown );
593 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
594 }
595 }
596
597 void wxGridSelection::ToggleCellSelection( int row, int col,
598 bool ControlDown, bool ShiftDown,
599 bool AltDown, bool MetaDown )
600 {
601 // if the cell is not selected, select it
602 if ( !IsInSelection ( row, col ) )
603 {
604 SelectCell( row, col, ControlDown, ShiftDown, AltDown, MetaDown );
605
606 return;
607 }
608
609 // otherwise deselect it. This can be simple or more or
610 // less difficult, depending on how the cell is selected.
611 size_t count, n;
612
613 // The simplest case: The cell is contained in m_cellSelection
614 // Then it can't be contained in rows/cols/block (since those
615 // would remove the cell from m_cellSelection on creation), so
616 // we just have to remove it from m_cellSelection.
617
618 if ( m_selectionMode == wxGrid::wxGridSelectCells )
619 {
620 count = m_cellSelection.GetCount();
621 for ( n = 0; n < count; n++ )
622 {
623 const wxGridCellCoords& sel = m_cellSelection[n];
624 if ( row == sel.GetRow() && col == sel.GetCol() )
625 {
626 wxGridCellCoords coords = m_cellSelection[n];
627 m_cellSelection.RemoveAt(n);
628 if ( !m_grid->GetBatchCount() )
629 {
630 wxRect r = m_grid->BlockToDeviceRect( coords, coords );
631 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
632 }
633
634 // Send event
635 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
636 wxEVT_GRID_RANGE_SELECT,
637 m_grid,
638 wxGridCellCoords( row, col ),
639 wxGridCellCoords( row, col ),
640 false,
641 ControlDown, ShiftDown,
642 AltDown, MetaDown );
643 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
644
645 return;
646 }
647 }
648 }
649
650 // The most difficult case: The cell is member of one or even several
651 // blocks. Split each such block in up to 4 new parts, that don't
652 // contain the cell to be selected, like this:
653 // |---------------------------|
654 // | |
655 // | part 1 |
656 // | |
657 // |---------------------------|
658 // | part 3 |x| part 4 |
659 // |---------------------------|
660 // | |
661 // | part 2 |
662 // | |
663 // |---------------------------|
664 // (The x marks the newly deselected cell).
665 // Note: in row selection mode, we only need part1 and part2;
666 // in column selection mode, we only need part 3 and part4,
667 // which are expanded to whole columns automatically!
668
669 count = m_blockSelectionTopLeft.GetCount();
670 for ( n = 0; n < count; n++ )
671 {
672 wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
673 wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
674 int topRow = coords1.GetRow();
675 int leftCol = coords1.GetCol();
676 int bottomRow = coords2.GetRow();
677 int rightCol = coords2.GetCol();
678
679 if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol, row, col ) )
680 {
681 // remove the block
682 m_blockSelectionTopLeft.RemoveAt(n);
683 m_blockSelectionBottomRight.RemoveAt(n);
684 n--;
685 count--;
686
687 // add up to 4 smaller blocks and set update region
688 if ( m_selectionMode != wxGrid::wxGridSelectColumns )
689 {
690 if ( topRow < row )
691 SelectBlock( topRow, leftCol, row - 1, rightCol,
692 false, false, false, false, false );
693 if ( bottomRow > row )
694 SelectBlock( row + 1, leftCol, bottomRow, rightCol,
695 false, false, false, false, false );
696 }
697
698 if ( m_selectionMode != wxGrid::wxGridSelectRows )
699 {
700 if ( leftCol < col )
701 SelectBlock( row, leftCol, row, col - 1,
702 false, false, false, false, false );
703 if ( rightCol > col )
704 SelectBlock( row, col + 1, row, rightCol,
705 false, false, false, false, false );
706 }
707 }
708 }
709
710 // remove a cell from a row, adding up to two new blocks
711 if ( m_selectionMode != wxGrid::wxGridSelectColumns )
712 {
713 count = m_rowSelection.GetCount();
714 for ( n = 0; n < count; n++ )
715 {
716 if ( m_rowSelection[n] == row )
717 {
718 m_rowSelection.RemoveAt(n);
719 n--;
720 count--;
721
722 if (m_selectionMode == wxGrid::wxGridSelectCells)
723 {
724 if ( col > 0 )
725 SelectBlock( row, 0, row, col - 1,
726 false, false, false, false, false );
727 if ( col < m_grid->GetNumberCols() - 1 )
728 SelectBlock( row, col + 1,
729 row, m_grid->GetNumberCols() - 1,
730 false, false, false, false, false );
731 }
732 }
733 }
734 }
735
736 // remove a cell from a column, adding up to two new blocks
737 if ( m_selectionMode != wxGrid::wxGridSelectRows )
738 {
739 count = m_colSelection.GetCount();
740 for ( n = 0; n < count; n++ )
741 {
742 if ( m_colSelection[n] == col )
743 {
744 m_colSelection.RemoveAt(n);
745 n--;
746 count--;
747
748 if (m_selectionMode == wxGrid::wxGridSelectCells)
749 {
750 if ( row > 0 )
751 SelectBlock( 0, col, row - 1, col,
752 false, false, false, false, false );
753 if ( row < m_grid->GetNumberRows() - 1 )
754 SelectBlock( row + 1, col,
755 m_grid->GetNumberRows() - 1, col,
756 false, false, false, false, false );
757 }
758 }
759 }
760 }
761
762 // Refresh the screen and send the event; according to m_selectionMode,
763 // we need to either update only the cell, or the whole row/column.
764 wxRect r;
765 switch (m_selectionMode)
766 {
767 case wxGrid::wxGridSelectCells:
768 {
769 if ( !m_grid->GetBatchCount() )
770 {
771 r = m_grid->BlockToDeviceRect(
772 wxGridCellCoords( row, col ),
773 wxGridCellCoords( row, col ) );
774 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
775 }
776
777 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
778 wxEVT_GRID_RANGE_SELECT,
779 m_grid,
780 wxGridCellCoords( row, col ),
781 wxGridCellCoords( row, col ),
782 false,
783 ControlDown, ShiftDown,
784 AltDown, MetaDown );
785 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
786 }
787 break;
788
789 case wxGrid::wxGridSelectRows:
790 {
791 if ( !m_grid->GetBatchCount() )
792 {
793 r = m_grid->BlockToDeviceRect(
794 wxGridCellCoords( row, 0 ),
795 wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
796 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
797 }
798
799 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
800 wxEVT_GRID_RANGE_SELECT,
801 m_grid,
802 wxGridCellCoords( row, 0 ),
803 wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ),
804 false,
805 ControlDown, ShiftDown,
806 AltDown, MetaDown );
807 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
808 }
809 break;
810
811 case wxGrid::wxGridSelectColumns:
812 {
813 if ( !m_grid->GetBatchCount() )
814 {
815 r = m_grid->BlockToDeviceRect(
816 wxGridCellCoords( 0, col ),
817 wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
818 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
819 }
820
821 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
822 wxEVT_GRID_RANGE_SELECT,
823 m_grid,
824 wxGridCellCoords( 0, col ),
825 wxGridCellCoords( m_grid->GetNumberRows() - 1, col ),
826 false,
827 ControlDown, ShiftDown,
828 AltDown, MetaDown );
829 m_grid->GetEventHandler()->ProcessEvent( gridEvt );
830 }
831 break;
832
833 default:
834 break;
835 }
836 }
837
838 void wxGridSelection::ClearSelection()
839 {
840 size_t n;
841 wxRect r;
842 wxGridCellCoords coords1, coords2;
843
844 // deselect all individual cells and update the screen
845 if ( m_selectionMode == wxGrid::wxGridSelectCells )
846 {
847 while ( ( n = m_cellSelection.GetCount() ) > 0)
848 {
849 n--;
850 coords1 = m_cellSelection[n];
851 m_cellSelection.RemoveAt(n);
852 if ( !m_grid->GetBatchCount() )
853 {
854 r = m_grid->BlockToDeviceRect( coords1, coords1 );
855 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
856
857 #ifdef __WXMAC__
858 ((wxWindow *)m_grid->m_gridWin)->Update();
859 #endif
860 }
861 }
862 }
863
864 // deselect all blocks and update the screen
865 while ( ( n = m_blockSelectionTopLeft.GetCount() ) > 0)
866 {
867 n--;
868 coords1 = m_blockSelectionTopLeft[n];
869 coords2 = m_blockSelectionBottomRight[n];
870 m_blockSelectionTopLeft.RemoveAt(n);
871 m_blockSelectionBottomRight.RemoveAt(n);
872 if ( !m_grid->GetBatchCount() )
873 {
874 r = m_grid->BlockToDeviceRect( coords1, coords2 );
875 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
876
877 #ifdef __WXMAC__
878 ((wxWindow *)m_grid->m_gridWin)->Update();
879 #endif
880 }
881 }
882
883 // deselect all rows and update the screen
884 if ( m_selectionMode != wxGrid::wxGridSelectColumns )
885 {
886 while ( ( n = m_rowSelection.GetCount() ) > 0)
887 {
888 n--;
889 int row = m_rowSelection[n];
890 m_rowSelection.RemoveAt(n);
891 if ( !m_grid->GetBatchCount() )
892 {
893 r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
894 wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
895 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
896
897 #ifdef __WXMAC__
898 ((wxWindow *)m_grid->m_gridWin)->Update();
899 #endif
900 }
901 }
902 }
903
904 // deselect all columns and update the screen
905 if ( m_selectionMode != wxGrid::wxGridSelectRows )
906 {
907 while ( ( n = m_colSelection.GetCount() ) > 0)
908 {
909 n--;
910 int col = m_colSelection[n];
911 m_colSelection.RemoveAt(n);
912 if ( !m_grid->GetBatchCount() )
913 {
914 r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
915 wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
916 ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
917
918 #ifdef __WXMAC__
919 ((wxWindow *)m_grid->m_gridWin)->Update();
920 #endif
921 }
922 }
923 }
924
925 // One deselection event, indicating deselection of _all_ cells.
926 // (No finer grained events for each of the smaller regions
927 // deselected above!)
928 wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
929 wxEVT_GRID_RANGE_SELECT,
930 m_grid,
931 wxGridCellCoords( 0, 0 ),
932 wxGridCellCoords(
933 m_grid->GetNumberRows() - 1,
934 m_grid->GetNumberCols() - 1 ),
935 false );
936
937 m_grid->GetEventHandler()->ProcessEvent(gridEvt);
938 }
939
940
941 void wxGridSelection::UpdateRows( size_t pos, int numRows )
942 {
943 size_t count = m_cellSelection.GetCount();
944 size_t n;
945 for ( n = 0; n < count; n++ )
946 {
947 wxGridCellCoords& coords = m_cellSelection[n];
948 wxCoord row = coords.GetRow();
949 if ((size_t)row >= pos)
950 {
951 if (numRows > 0)
952 {
953 // If rows inserted, increase row counter where necessary
954 coords.SetRow(row + numRows);
955 }
956 else if (numRows < 0)
957 {
958 // If rows deleted ...
959 if ((size_t)row >= pos - numRows)
960 {
961 // ...either decrement row counter (if row still exists)...
962 coords.SetRow(row + numRows);
963 }
964 else
965 {
966 // ...or remove the attribute
967 m_cellSelection.RemoveAt(n);
968 n--;
969 count--;
970 }
971 }
972 }
973 }
974
975 count = m_blockSelectionTopLeft.GetCount();
976 for ( n = 0; n < count; n++ )
977 {
978 wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
979 wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
980 wxCoord row1 = coords1.GetRow();
981 wxCoord row2 = coords2.GetRow();
982
983 if ((size_t)row2 >= pos)
984 {
985 if (numRows > 0)
986 {
987 // If rows inserted, increase row counter where necessary
988 coords2.SetRow( row2 + numRows );
989 if ((size_t)row1 >= pos)
990 coords1.SetRow( row1 + numRows );
991 }
992 else if (numRows < 0)
993 {
994 // If rows deleted ...
995 if ((size_t)row2 >= pos - numRows)
996 {
997 // ...either decrement row counter (if row still exists)...
998 coords2.SetRow( row2 + numRows );
999 if ((size_t)row1 >= pos)
1000 coords1.SetRow( wxMax(row1 + numRows, (int)pos) );
1001
1002 }
1003 else
1004 {
1005 if ((size_t)row1 >= pos)
1006 {
1007 // ...or remove the attribute
1008 m_blockSelectionTopLeft.RemoveAt(n);
1009 m_blockSelectionBottomRight.RemoveAt(n);
1010 n--;
1011 count--;
1012 }
1013 else
1014 coords2.SetRow( pos );
1015 }
1016 }
1017 }
1018 }
1019
1020 count = m_rowSelection.GetCount();
1021 for ( n = 0; n < count; n++ )
1022 {
1023 int rowOrCol_ = m_rowSelection[n];
1024
1025 if ((size_t) rowOrCol_ >= pos)
1026 {
1027 if ( numRows > 0 )
1028 {
1029 m_rowSelection[n] += numRows;
1030 }
1031 else if ( numRows < 0 )
1032 {
1033 if ((size_t)rowOrCol_ >= (pos - numRows))
1034 m_rowSelection[n] += numRows;
1035 else
1036 {
1037 m_rowSelection.RemoveAt( n );
1038 n--;
1039 count--;
1040 }
1041 }
1042 }
1043 }
1044 // No need to touch selected columns, unless we removed _all_
1045 // rows, in this case, we remove all columns from the selection.
1046
1047 if ( !m_grid->GetNumberRows() )
1048 m_colSelection.Clear();
1049 }
1050
1051
1052 void wxGridSelection::UpdateCols( size_t pos, int numCols )
1053 {
1054 size_t count = m_cellSelection.GetCount();
1055 size_t n;
1056
1057 for ( n = 0; n < count; n++ )
1058 {
1059 wxGridCellCoords& coords = m_cellSelection[n];
1060 wxCoord col = coords.GetCol();
1061 if ((size_t)col >= pos)
1062 {
1063 if (numCols > 0)
1064 {
1065 // If rows inserted, increase row counter where necessary
1066 coords.SetCol(col + numCols);
1067 }
1068 else if (numCols < 0)
1069 {
1070 // If rows deleted ...
1071 if ((size_t)col >= pos - numCols)
1072 {
1073 // ...either decrement row counter (if row still exists)...
1074 coords.SetCol(col + numCols);
1075 }
1076 else
1077 {
1078 // ...or remove the attribute
1079 m_cellSelection.RemoveAt(n);
1080 n--;
1081 count--;
1082 }
1083 }
1084 }
1085 }
1086
1087 count = m_blockSelectionTopLeft.GetCount();
1088 for ( n = 0; n < count; n++ )
1089 {
1090 wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
1091 wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
1092 wxCoord col1 = coords1.GetCol();
1093 wxCoord col2 = coords2.GetCol();
1094
1095 if ((size_t)col2 >= pos)
1096 {
1097 if (numCols > 0)
1098 {
1099 // If rows inserted, increase row counter where necessary
1100 coords2.SetCol(col2 + numCols);
1101 if ((size_t)col1 >= pos)
1102 coords1.SetCol(col1 + numCols);
1103 }
1104 else if (numCols < 0)
1105 {
1106 // If cols deleted ...
1107 if ((size_t)col2 >= pos - numCols)
1108 {
1109 // ...either decrement col counter (if col still exists)...
1110 coords2.SetCol(col2 + numCols);
1111 if ( (size_t) col1 >= pos)
1112 coords1.SetCol( wxMax(col1 + numCols, (int)pos) );
1113
1114 }
1115 else
1116 {
1117 if ((size_t)col1 >= pos)
1118 {
1119 // ...or remove the attribute
1120 m_blockSelectionTopLeft.RemoveAt(n);
1121 m_blockSelectionBottomRight.RemoveAt(n);
1122 n--;
1123 count--;
1124 }
1125 else
1126 coords2.SetCol(pos);
1127 }
1128 }
1129 }
1130 }
1131
1132 count = m_colSelection.GetCount();
1133 for ( n = 0; n < count; n++ )
1134 {
1135 int rowOrCol = m_colSelection[n];
1136
1137 if ((size_t)rowOrCol >= pos)
1138 {
1139 if ( numCols > 0 )
1140 m_colSelection[n] += numCols;
1141 else if ( numCols < 0 )
1142 {
1143 if ((size_t)rowOrCol >= (pos - numCols))
1144 m_colSelection[n] += numCols;
1145 else
1146 {
1147 m_colSelection.RemoveAt( n );
1148 n--;
1149 count--;
1150 }
1151 }
1152 }
1153 }
1154
1155 // No need to touch selected rows, unless we removed _all_
1156 // columns, in this case, we remove all rows from the selection.
1157 if ( !m_grid->GetNumberCols() )
1158 m_rowSelection.Clear();
1159 }
1160
1161 int wxGridSelection::BlockContain( int topRow1, int leftCol1,
1162 int bottomRow1, int rightCol1,
1163 int topRow2, int leftCol2,
1164 int bottomRow2, int rightCol2 )
1165 // returns 1, if Block1 contains Block2,
1166 // -1, if Block2 contains Block1,
1167 // 0, otherwise
1168 {
1169 if ( topRow1 <= topRow2 && bottomRow2 <= bottomRow1 &&
1170 leftCol1 <= leftCol2 && rightCol2 <= rightCol1 )
1171 return 1;
1172 else if ( topRow2 <= topRow1 && bottomRow1 <= bottomRow2 &&
1173 leftCol2 <= leftCol1 && rightCol1 <= rightCol2 )
1174 return -1;
1175
1176 return 0;
1177 }
1178
1179 #endif