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