]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/gbsizer.cpp | |
3 | // Purpose: wxGridBagSizer: A sizer that can lay out items in a grid, | |
4 | // with items at specified cells, and with the option of row | |
5 | // and/or column spanning | |
6 | // | |
7 | // Author: Robin Dunn | |
8 | // Created: 03-Nov-2003 | |
9 | // Copyright: (c) Robin Dunn | |
10 | // Licence: wxWindows licence | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | // For compilers that support precompilation, includes "wx.h". | |
14 | #include "wx/wxprec.h" | |
15 | ||
16 | #ifdef __BORLANDC__ | |
17 | #pragma hdrstop | |
18 | #endif | |
19 | ||
20 | #include "wx/gbsizer.h" | |
21 | ||
22 | //--------------------------------------------------------------------------- | |
23 | ||
24 | IMPLEMENT_DYNAMIC_CLASS(wxGBSizerItem, wxSizerItem) | |
25 | IMPLEMENT_CLASS(wxGridBagSizer, wxFlexGridSizer) | |
26 | ||
27 | const wxGBSpan wxDefaultSpan; | |
28 | ||
29 | //--------------------------------------------------------------------------- | |
30 | // wxGBSizerItem | |
31 | //--------------------------------------------------------------------------- | |
32 | ||
33 | wxGBSizerItem::wxGBSizerItem( int width, | |
34 | int height, | |
35 | const wxGBPosition& pos, | |
36 | const wxGBSpan& span, | |
37 | int flag, | |
38 | int border, | |
39 | wxObject* userData) | |
40 | : wxSizerItem(width, height, 0, flag, border, userData), | |
41 | m_pos(pos), | |
42 | m_span(span), | |
43 | m_gbsizer(NULL) | |
44 | { | |
45 | } | |
46 | ||
47 | ||
48 | wxGBSizerItem::wxGBSizerItem( wxWindow *window, | |
49 | const wxGBPosition& pos, | |
50 | const wxGBSpan& span, | |
51 | int flag, | |
52 | int border, | |
53 | wxObject* userData ) | |
54 | : wxSizerItem(window, 0, flag, border, userData), | |
55 | m_pos(pos), | |
56 | m_span(span), | |
57 | m_gbsizer(NULL) | |
58 | { | |
59 | } | |
60 | ||
61 | ||
62 | wxGBSizerItem::wxGBSizerItem( wxSizer *sizer, | |
63 | const wxGBPosition& pos, | |
64 | const wxGBSpan& span, | |
65 | int flag, | |
66 | int border, | |
67 | wxObject* userData ) | |
68 | : wxSizerItem(sizer, 0, flag, border, userData), | |
69 | m_pos(pos), | |
70 | m_span(span), | |
71 | m_gbsizer(NULL) | |
72 | { | |
73 | } | |
74 | ||
75 | wxGBSizerItem::wxGBSizerItem() | |
76 | : wxSizerItem(), | |
77 | m_pos(-1,-1), | |
78 | m_gbsizer(NULL) | |
79 | { | |
80 | } | |
81 | ||
82 | //--------------------------------------------------------------------------- | |
83 | ||
84 | ||
85 | void wxGBSizerItem::GetPos(int& row, int& col) const | |
86 | { | |
87 | row = m_pos.GetRow(); | |
88 | col = m_pos.GetCol(); | |
89 | } | |
90 | ||
91 | void wxGBSizerItem::GetSpan(int& rowspan, int& colspan) const | |
92 | { | |
93 | rowspan = m_span.GetRowspan(); | |
94 | colspan = m_span.GetColspan(); | |
95 | } | |
96 | ||
97 | ||
98 | bool wxGBSizerItem::SetPos( const wxGBPosition& pos ) | |
99 | { | |
100 | if (m_gbsizer) | |
101 | { | |
102 | wxCHECK_MSG( !m_gbsizer->CheckForIntersection(pos, m_span, this), false, | |
103 | wxT("An item is already at that position") ); | |
104 | } | |
105 | m_pos = pos; | |
106 | return true; | |
107 | } | |
108 | ||
109 | bool wxGBSizerItem::SetSpan( const wxGBSpan& span ) | |
110 | { | |
111 | if (m_gbsizer) | |
112 | { | |
113 | wxCHECK_MSG( !m_gbsizer->CheckForIntersection(m_pos, span, this), false, | |
114 | wxT("An item is already at that position") ); | |
115 | } | |
116 | m_span = span; | |
117 | return true; | |
118 | } | |
119 | ||
120 | ||
121 | inline bool InRange(int val, int min, int max) | |
122 | { | |
123 | return (val >= min && val <= max); | |
124 | } | |
125 | ||
126 | bool wxGBSizerItem::Intersects(const wxGBSizerItem& other) | |
127 | { | |
128 | return Intersects(other.GetPos(), other.GetSpan()); | |
129 | } | |
130 | ||
131 | bool wxGBSizerItem::Intersects(const wxGBPosition& pos, const wxGBSpan& span) | |
132 | { | |
133 | ||
134 | int row, col, endrow, endcol; | |
135 | int otherrow, othercol, otherendrow, otherendcol; | |
136 | ||
137 | GetPos(row, col); | |
138 | GetEndPos(endrow, endcol); | |
139 | ||
140 | otherrow = pos.GetRow(); | |
141 | othercol = pos.GetCol(); | |
142 | otherendrow = otherrow + span.GetRowspan() - 1; | |
143 | otherendcol = othercol + span.GetColspan() - 1; | |
144 | ||
145 | // is the other item's start or end in the range of this one? | |
146 | if (( InRange(otherrow, row, endrow) && InRange(othercol, col, endcol) ) || | |
147 | ( InRange(otherendrow, row, endrow) && InRange(otherendcol, col, endcol) )) | |
148 | return true; | |
149 | ||
150 | // is this item's start or end in the range of the other one? | |
151 | if (( InRange(row, otherrow, otherendrow) && InRange(col, othercol, otherendcol) ) || | |
152 | ( InRange(endrow, otherrow, otherendrow) && InRange(endcol, othercol, otherendcol) )) | |
153 | return true; | |
154 | ||
155 | return false; | |
156 | } | |
157 | ||
158 | ||
159 | void wxGBSizerItem::GetEndPos(int& row, int& col) | |
160 | { | |
161 | row = m_pos.GetRow() + m_span.GetRowspan() - 1; | |
162 | col = m_pos.GetCol() + m_span.GetColspan() - 1; | |
163 | } | |
164 | ||
165 | ||
166 | //--------------------------------------------------------------------------- | |
167 | // wxGridBagSizer | |
168 | //--------------------------------------------------------------------------- | |
169 | ||
170 | wxGridBagSizer::wxGridBagSizer(int vgap, int hgap ) | |
171 | : wxFlexGridSizer(1, vgap, hgap), | |
172 | m_emptyCellSize(10,20) | |
173 | ||
174 | { | |
175 | } | |
176 | ||
177 | ||
178 | wxSizerItem* wxGridBagSizer::Add( wxWindow *window, | |
179 | const wxGBPosition& pos, const wxGBSpan& span, | |
180 | int flag, int border, wxObject* userData ) | |
181 | { | |
182 | wxGBSizerItem* item = new wxGBSizerItem(window, pos, span, flag, border, userData); | |
183 | if ( Add(item) ) | |
184 | return item; | |
185 | else | |
186 | { | |
187 | delete item; | |
188 | return NULL; | |
189 | } | |
190 | } | |
191 | ||
192 | wxSizerItem* wxGridBagSizer::Add( wxSizer *sizer, | |
193 | const wxGBPosition& pos, const wxGBSpan& span, | |
194 | int flag, int border, wxObject* userData ) | |
195 | { | |
196 | wxGBSizerItem* item = new wxGBSizerItem(sizer, pos, span, flag, border, userData); | |
197 | if ( Add(item) ) | |
198 | return item; | |
199 | else | |
200 | { | |
201 | delete item; | |
202 | return NULL; | |
203 | } | |
204 | } | |
205 | ||
206 | wxSizerItem* wxGridBagSizer::Add( int width, int height, | |
207 | const wxGBPosition& pos, const wxGBSpan& span, | |
208 | int flag, int border, wxObject* userData ) | |
209 | { | |
210 | wxGBSizerItem* item = new wxGBSizerItem(width, height, pos, span, flag, border, userData); | |
211 | if ( Add(item) ) | |
212 | return item; | |
213 | else | |
214 | { | |
215 | delete item; | |
216 | return NULL; | |
217 | } | |
218 | } | |
219 | ||
220 | wxSizerItem* wxGridBagSizer::Add( wxGBSizerItem *item ) | |
221 | { | |
222 | wxCHECK_MSG( !CheckForIntersection(item), NULL, | |
223 | wxT("An item is already at that position") ); | |
224 | m_children.Append(item); | |
225 | item->SetGBSizer(this); | |
226 | if ( item->GetWindow() ) | |
227 | item->GetWindow()->SetContainingSizer( this ); | |
228 | ||
229 | // extend the number of rows/columns of the underlying wxFlexGridSizer if | |
230 | // necessary | |
231 | int row, col; | |
232 | item->GetEndPos(row, col); | |
233 | row++; | |
234 | col++; | |
235 | ||
236 | if ( row > GetRows() ) | |
237 | SetRows(row); | |
238 | if ( col > GetCols() ) | |
239 | SetCols(col); | |
240 | ||
241 | return item; | |
242 | } | |
243 | ||
244 | ||
245 | ||
246 | //--------------------------------------------------------------------------- | |
247 | ||
248 | wxSize wxGridBagSizer::GetCellSize(int row, int col) const | |
249 | { | |
250 | wxCHECK_MSG( (row < m_rows) && (col < m_cols), | |
251 | wxDefaultSize, | |
252 | wxT("Invalid cell.")); | |
253 | return wxSize( m_colWidths[col], m_rowHeights[row] ); | |
254 | } | |
255 | ||
256 | ||
257 | wxGBPosition wxGridBagSizer::GetItemPosition(wxWindow *window) | |
258 | { | |
259 | wxGBPosition badpos(-1,-1); | |
260 | wxGBSizerItem* item = FindItem(window); | |
261 | wxCHECK_MSG(item, badpos, wxT("Failed to find item.")); | |
262 | return item->GetPos(); | |
263 | } | |
264 | ||
265 | ||
266 | wxGBPosition wxGridBagSizer::GetItemPosition(wxSizer *sizer) | |
267 | { | |
268 | wxGBPosition badpos(-1,-1); | |
269 | wxGBSizerItem* item = FindItem(sizer); | |
270 | wxCHECK_MSG(item, badpos, wxT("Failed to find item.")); | |
271 | return item->GetPos(); | |
272 | } | |
273 | ||
274 | ||
275 | wxGBPosition wxGridBagSizer::GetItemPosition(size_t index) | |
276 | { | |
277 | wxGBPosition badpos(-1,-1); | |
278 | wxSizerItemList::compatibility_iterator node = m_children.Item( index ); | |
279 | wxCHECK_MSG( node, badpos, wxT("Failed to find item.") ); | |
280 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
281 | return item->GetPos(); | |
282 | } | |
283 | ||
284 | ||
285 | ||
286 | bool wxGridBagSizer::SetItemPosition(wxWindow *window, const wxGBPosition& pos) | |
287 | { | |
288 | wxGBSizerItem* item = FindItem(window); | |
289 | wxCHECK_MSG(item, false, wxT("Failed to find item.")); | |
290 | return item->SetPos(pos); | |
291 | } | |
292 | ||
293 | ||
294 | bool wxGridBagSizer::SetItemPosition(wxSizer *sizer, const wxGBPosition& pos) | |
295 | { | |
296 | wxGBSizerItem* item = FindItem(sizer); | |
297 | wxCHECK_MSG(item, false, wxT("Failed to find item.")); | |
298 | return item->SetPos(pos); | |
299 | } | |
300 | ||
301 | ||
302 | bool wxGridBagSizer::SetItemPosition(size_t index, const wxGBPosition& pos) | |
303 | { | |
304 | wxSizerItemList::compatibility_iterator node = m_children.Item( index ); | |
305 | wxCHECK_MSG( node, false, wxT("Failed to find item.") ); | |
306 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
307 | return item->SetPos(pos); | |
308 | } | |
309 | ||
310 | ||
311 | ||
312 | wxGBSpan wxGridBagSizer::GetItemSpan(wxWindow *window) | |
313 | { | |
314 | wxGBSizerItem* item = FindItem(window); | |
315 | wxCHECK_MSG( item, wxGBSpan::Invalid(), wxT("Failed to find item.") ); | |
316 | return item->GetSpan(); | |
317 | } | |
318 | ||
319 | ||
320 | wxGBSpan wxGridBagSizer::GetItemSpan(wxSizer *sizer) | |
321 | { | |
322 | wxGBSizerItem* item = FindItem(sizer); | |
323 | wxCHECK_MSG( item, wxGBSpan::Invalid(), wxT("Failed to find item.") ); | |
324 | return item->GetSpan(); | |
325 | } | |
326 | ||
327 | ||
328 | wxGBSpan wxGridBagSizer::GetItemSpan(size_t index) | |
329 | { | |
330 | wxSizerItemList::compatibility_iterator node = m_children.Item( index ); | |
331 | wxCHECK_MSG( node, wxGBSpan::Invalid(), wxT("Failed to find item.") ); | |
332 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
333 | return item->GetSpan(); | |
334 | } | |
335 | ||
336 | ||
337 | ||
338 | bool wxGridBagSizer::SetItemSpan(wxWindow *window, const wxGBSpan& span) | |
339 | { | |
340 | wxGBSizerItem* item = FindItem(window); | |
341 | wxCHECK_MSG(item, false, wxT("Failed to find item.")); | |
342 | return item->SetSpan(span); | |
343 | } | |
344 | ||
345 | ||
346 | bool wxGridBagSizer::SetItemSpan(wxSizer *sizer, const wxGBSpan& span) | |
347 | { | |
348 | wxGBSizerItem* item = FindItem(sizer); | |
349 | wxCHECK_MSG(item, false, wxT("Failed to find item.")); | |
350 | return item->SetSpan(span); | |
351 | } | |
352 | ||
353 | ||
354 | bool wxGridBagSizer::SetItemSpan(size_t index, const wxGBSpan& span) | |
355 | { | |
356 | wxSizerItemList::compatibility_iterator node = m_children.Item( index ); | |
357 | wxCHECK_MSG( node, false, wxT("Failed to find item.") ); | |
358 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
359 | return item->SetSpan(span); | |
360 | } | |
361 | ||
362 | ||
363 | ||
364 | ||
365 | wxGBSizerItem* wxGridBagSizer::FindItem(wxWindow* window) | |
366 | { | |
367 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
368 | while (node) | |
369 | { | |
370 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
371 | if ( item->GetWindow() == window ) | |
372 | return item; | |
373 | node = node->GetNext(); | |
374 | } | |
375 | return NULL; | |
376 | } | |
377 | ||
378 | ||
379 | wxGBSizerItem* wxGridBagSizer::FindItem(wxSizer* sizer) | |
380 | { | |
381 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
382 | while (node) | |
383 | { | |
384 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
385 | if ( item->GetSizer() == sizer ) | |
386 | return item; | |
387 | node = node->GetNext(); | |
388 | } | |
389 | return NULL; | |
390 | } | |
391 | ||
392 | ||
393 | ||
394 | ||
395 | wxGBSizerItem* wxGridBagSizer::FindItemAtPosition(const wxGBPosition& pos) | |
396 | { | |
397 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
398 | while (node) | |
399 | { | |
400 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
401 | if ( item->Intersects(pos, wxDefaultSpan) ) | |
402 | return item; | |
403 | node = node->GetNext(); | |
404 | } | |
405 | return NULL; | |
406 | } | |
407 | ||
408 | ||
409 | ||
410 | ||
411 | wxGBSizerItem* wxGridBagSizer::FindItemAtPoint(const wxPoint& pt) | |
412 | { | |
413 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
414 | while (node) | |
415 | { | |
416 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
417 | wxRect rect(item->GetPosition(), item->GetSize()); | |
418 | rect.Inflate(m_hgap, m_vgap); | |
419 | if ( rect.Contains(pt) ) | |
420 | return item; | |
421 | node = node->GetNext(); | |
422 | } | |
423 | return NULL; | |
424 | } | |
425 | ||
426 | ||
427 | ||
428 | ||
429 | wxGBSizerItem* wxGridBagSizer::FindItemWithData(const wxObject* userData) | |
430 | { | |
431 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
432 | while (node) | |
433 | { | |
434 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
435 | if ( item->GetUserData() == userData ) | |
436 | return item; | |
437 | node = node->GetNext(); | |
438 | } | |
439 | return NULL; | |
440 | } | |
441 | ||
442 | ||
443 | ||
444 | ||
445 | //--------------------------------------------------------------------------- | |
446 | ||
447 | // Figure out what all the min row heights and col widths are, and calculate | |
448 | // min size from that. | |
449 | wxSize wxGridBagSizer::CalcMin() | |
450 | { | |
451 | int idx; | |
452 | ||
453 | if (m_children.GetCount() == 0) | |
454 | return m_emptyCellSize; | |
455 | ||
456 | m_rowHeights.Empty(); | |
457 | m_colWidths.Empty(); | |
458 | ||
459 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
460 | while (node) | |
461 | { | |
462 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
463 | if ( item->IsShown() ) | |
464 | { | |
465 | int row, col, endrow, endcol; | |
466 | ||
467 | item->GetPos(row, col); | |
468 | item->GetEndPos(endrow, endcol); | |
469 | ||
470 | // fill heights and widths up to this item if needed | |
471 | while ( (int)m_rowHeights.GetCount() <= endrow ) | |
472 | m_rowHeights.Add(m_emptyCellSize.GetHeight()); | |
473 | while ( (int)m_colWidths.GetCount() <= endcol ) | |
474 | m_colWidths.Add(m_emptyCellSize.GetWidth()); | |
475 | ||
476 | // See if this item increases the size of its row(s) or col(s) | |
477 | wxSize size(item->CalcMin()); | |
478 | for (idx=row; idx <= endrow; idx++) | |
479 | m_rowHeights[idx] = wxMax(m_rowHeights[idx], size.GetHeight() / (endrow-row+1)); | |
480 | for (idx=col; idx <= endcol; idx++) | |
481 | m_colWidths[idx] = wxMax(m_colWidths[idx], size.GetWidth() / (endcol-col+1)); | |
482 | } | |
483 | node = node->GetNext(); | |
484 | } | |
485 | ||
486 | AdjustForOverflow(); | |
487 | AdjustForFlexDirection(); | |
488 | ||
489 | // Now traverse the heights and widths arrays calcing the totals, including gaps | |
490 | int width = 0; | |
491 | m_cols = m_colWidths.GetCount(); | |
492 | for (idx=0; idx < m_cols; idx++) | |
493 | width += m_colWidths[idx] + ( idx == m_cols-1 ? 0 : m_hgap ); | |
494 | ||
495 | int height = 0; | |
496 | m_rows = m_rowHeights.GetCount(); | |
497 | for (idx=0; idx < m_rows; idx++) | |
498 | height += m_rowHeights[idx] + ( idx == m_rows-1 ? 0 : m_vgap ); | |
499 | ||
500 | m_calculatedMinSize = wxSize(width, height); | |
501 | return m_calculatedMinSize; | |
502 | } | |
503 | ||
504 | ||
505 | ||
506 | void wxGridBagSizer::RecalcSizes() | |
507 | { | |
508 | if (m_children.GetCount() == 0) | |
509 | return; | |
510 | ||
511 | wxPoint pt( GetPosition() ); | |
512 | wxSize sz( GetSize() ); | |
513 | ||
514 | m_rows = m_rowHeights.GetCount(); | |
515 | m_cols = m_colWidths.GetCount(); | |
516 | int idx, width, height; | |
517 | ||
518 | AdjustForGrowables(sz); | |
519 | ||
520 | // Find the start positions on the window of the rows and columns | |
521 | wxArrayInt rowpos; | |
522 | rowpos.Add(0, m_rows); | |
523 | int y = pt.y; | |
524 | for (idx=0; idx < m_rows; idx++) | |
525 | { | |
526 | height = m_rowHeights[idx] + m_vgap; | |
527 | rowpos[idx] = y; | |
528 | y += height; | |
529 | } | |
530 | ||
531 | wxArrayInt colpos; | |
532 | colpos.Add(0, m_cols); | |
533 | int x = pt.x; | |
534 | for (idx=0; idx < m_cols; idx++) | |
535 | { | |
536 | width = m_colWidths[idx] + m_hgap; | |
537 | colpos[idx] = x; | |
538 | x += width; | |
539 | } | |
540 | ||
541 | ||
542 | // Now iterate the children, setting each child's dimensions | |
543 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
544 | while (node) | |
545 | { | |
546 | int row, col, endrow, endcol; | |
547 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
548 | ||
549 | if ( item->IsShown() ) | |
550 | { | |
551 | item->GetPos(row, col); | |
552 | item->GetEndPos(endrow, endcol); | |
553 | ||
554 | height = 0; | |
555 | for(idx=row; idx <= endrow; idx++) | |
556 | height += m_rowHeights[idx]; | |
557 | height += (endrow - row) * m_vgap; // add a vgap for every row spanned | |
558 | ||
559 | width = 0; | |
560 | for (idx=col; idx <= endcol; idx++) | |
561 | width += m_colWidths[idx]; | |
562 | width += (endcol - col) * m_hgap; // add a hgap for every col spanned | |
563 | ||
564 | SetItemBounds(item, colpos[col], rowpos[row], width, height); | |
565 | } | |
566 | ||
567 | node = node->GetNext(); | |
568 | } | |
569 | } | |
570 | ||
571 | ||
572 | // Sometimes CalcMin can result in some rows or cols having too much space in | |
573 | // them because as it traverses the items it makes some assumptions when | |
574 | // items span to other cells. But those assumptions can become invalid later | |
575 | // on when other items are fitted into the same rows or columns that the | |
576 | // spanning item occupies. This method tries to find those situations and | |
577 | // fixes them. | |
578 | void wxGridBagSizer::AdjustForOverflow() | |
579 | { | |
580 | int row, col; | |
581 | ||
582 | for (row=0; row<(int)m_rowHeights.GetCount(); row++) | |
583 | { | |
584 | int rowExtra=INT_MAX; | |
585 | int rowHeight = m_rowHeights[row]; | |
586 | for (col=0; col<(int)m_colWidths.GetCount(); col++) | |
587 | { | |
588 | wxGBPosition pos(row,col); | |
589 | wxGBSizerItem* item = FindItemAtPosition(pos); | |
590 | if ( !item || !item->IsShown() ) | |
591 | continue; | |
592 | ||
593 | int endrow, endcol; | |
594 | item->GetEndPos(endrow, endcol); | |
595 | ||
596 | // If the item starts in this position and doesn't span rows, then | |
597 | // just look at the whole item height | |
598 | if ( item->GetPos() == pos && endrow == row ) | |
599 | { | |
600 | int itemHeight = item->CalcMin().GetHeight(); | |
601 | rowExtra = wxMin(rowExtra, rowHeight - itemHeight); | |
602 | continue; | |
603 | } | |
604 | ||
605 | // Otherwise, only look at spanning items if they end on this row | |
606 | if ( endrow == row ) | |
607 | { | |
608 | // first deduct the portions of the item that are on prior rows | |
609 | int itemHeight = item->CalcMin().GetHeight(); | |
610 | for (int r=item->GetPos().GetRow(); r<row; r++) | |
611 | itemHeight -= (m_rowHeights[r] + GetHGap()); | |
612 | ||
613 | if ( itemHeight < 0 ) | |
614 | itemHeight = 0; | |
615 | ||
616 | // and check how much is left | |
617 | rowExtra = wxMin(rowExtra, rowHeight - itemHeight); | |
618 | } | |
619 | } | |
620 | if ( rowExtra && rowExtra != INT_MAX ) | |
621 | m_rowHeights[row] -= rowExtra; | |
622 | } | |
623 | ||
624 | // Now do the same thing for columns | |
625 | for (col=0; col<(int)m_colWidths.GetCount(); col++) | |
626 | { | |
627 | int colExtra=INT_MAX; | |
628 | int colWidth = m_colWidths[col]; | |
629 | for (row=0; row<(int)m_rowHeights.GetCount(); row++) | |
630 | { | |
631 | wxGBPosition pos(row,col); | |
632 | wxGBSizerItem* item = FindItemAtPosition(pos); | |
633 | if ( !item || !item->IsShown() ) | |
634 | continue; | |
635 | ||
636 | int endrow, endcol; | |
637 | item->GetEndPos(endrow, endcol); | |
638 | ||
639 | if ( item->GetPos() == pos && endcol == col ) | |
640 | { | |
641 | int itemWidth = item->CalcMin().GetWidth(); | |
642 | colExtra = wxMin(colExtra, colWidth - itemWidth); | |
643 | continue; | |
644 | } | |
645 | ||
646 | if ( endcol == col ) | |
647 | { | |
648 | int itemWidth = item->CalcMin().GetWidth(); | |
649 | for (int c=item->GetPos().GetCol(); c<col; c++) | |
650 | itemWidth -= (m_colWidths[c] + GetVGap()); | |
651 | ||
652 | if ( itemWidth < 0 ) | |
653 | itemWidth = 0; | |
654 | ||
655 | colExtra = wxMin(colExtra, colWidth - itemWidth); | |
656 | } | |
657 | } | |
658 | if ( colExtra && colExtra != INT_MAX ) | |
659 | m_colWidths[col] -= colExtra; | |
660 | } | |
661 | ||
662 | ||
663 | } | |
664 | ||
665 | //--------------------------------------------------------------------------- | |
666 | ||
667 | bool wxGridBagSizer::CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem) | |
668 | { | |
669 | return CheckForIntersection(item->GetPos(), item->GetSpan(), excludeItem); | |
670 | } | |
671 | ||
672 | bool wxGridBagSizer::CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem) | |
673 | { | |
674 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
675 | while (node) | |
676 | { | |
677 | wxGBSizerItem* item = (wxGBSizerItem*)node->GetData(); | |
678 | node = node->GetNext(); | |
679 | ||
680 | if ( excludeItem && item == excludeItem ) | |
681 | continue; | |
682 | ||
683 | if ( item->Intersects(pos, span) ) | |
684 | return true; | |
685 | ||
686 | } | |
687 | return false; | |
688 | } | |
689 | ||
690 | ||
691 | // Assumes a 10x10 grid, and returns the first empty cell found. This is | |
692 | // really stupid but it is only used by the Add methods that match the base | |
693 | // class virtuals, which should normally not be used anyway... | |
694 | wxGBPosition wxGridBagSizer::FindEmptyCell() | |
695 | { | |
696 | int row, col; | |
697 | ||
698 | for (row=0; row<10; row++) | |
699 | for (col=0; col<10; col++) | |
700 | { | |
701 | wxGBPosition pos(row, col); | |
702 | if ( !CheckForIntersection(pos, wxDefaultSpan) ) | |
703 | return pos; | |
704 | } | |
705 | return wxGBPosition(-1, -1); | |
706 | } | |
707 | ||
708 | ||
709 | //--------------------------------------------------------------------------- | |
710 | ||
711 | // The Add base class virtuals should not be used with this class, but | |
712 | // we'll try to make them automatically select a location for the item | |
713 | // anyway. | |
714 | ||
715 | wxSizerItem* wxGridBagSizer::Add( wxWindow *window, int, int flag, int border, wxObject* userData ) | |
716 | { | |
717 | return Add(window, FindEmptyCell(), wxDefaultSpan, flag, border, userData); | |
718 | } | |
719 | ||
720 | wxSizerItem* wxGridBagSizer::Add( wxSizer *sizer, int, int flag, int border, wxObject* userData ) | |
721 | { | |
722 | return Add(sizer, FindEmptyCell(), wxDefaultSpan, flag, border, userData); | |
723 | } | |
724 | ||
725 | wxSizerItem* wxGridBagSizer::Add( int width, int height, int, int flag, int border, wxObject* userData ) | |
726 | { | |
727 | return Add(width, height, FindEmptyCell(), wxDefaultSpan, flag, border, userData); | |
728 | } | |
729 | ||
730 | ||
731 | ||
732 | // The Insert nad Prepend base class virtuals that are not appropriate for | |
733 | // this class and should not be used. Their implementation in this class | |
734 | // simply fails. | |
735 | ||
736 | wxSizerItem* wxGridBagSizer::Add( wxSizerItem * ) | |
737 | { | |
738 | wxFAIL_MSG(wxT("Invalid Add form called.")); | |
739 | return NULL; | |
740 | } | |
741 | ||
742 | wxSizerItem* wxGridBagSizer::Prepend( wxWindow *, int, int, int, wxObject* ) | |
743 | { | |
744 | wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); | |
745 | return NULL; | |
746 | } | |
747 | ||
748 | wxSizerItem* wxGridBagSizer::Prepend( wxSizer *, int, int, int, wxObject* ) | |
749 | { | |
750 | wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); | |
751 | return NULL; | |
752 | } | |
753 | ||
754 | wxSizerItem* wxGridBagSizer::Prepend( int, int, int, int, int, wxObject* ) | |
755 | { | |
756 | wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); | |
757 | return NULL; | |
758 | } | |
759 | ||
760 | wxSizerItem* wxGridBagSizer::Prepend( wxSizerItem * ) | |
761 | { | |
762 | wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); | |
763 | return NULL; | |
764 | } | |
765 | ||
766 | ||
767 | wxSizerItem* wxGridBagSizer::Insert( size_t, wxWindow *, int, int, int, wxObject* ) | |
768 | { | |
769 | wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); | |
770 | return NULL; | |
771 | } | |
772 | ||
773 | wxSizerItem* wxGridBagSizer::Insert( size_t, wxSizer *, int, int, int, wxObject* ) | |
774 | { | |
775 | wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); | |
776 | return NULL; | |
777 | } | |
778 | ||
779 | wxSizerItem* wxGridBagSizer::Insert( size_t, int, int, int, int, int, wxObject* ) | |
780 | { | |
781 | wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); | |
782 | return NULL; | |
783 | } | |
784 | ||
785 | wxSizerItem* wxGridBagSizer::Insert( size_t, wxSizerItem * ) | |
786 | { | |
787 | wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); | |
788 | return NULL; | |
789 | } | |
790 | ||
791 | ||
792 | //--------------------------------------------------------------------------- | |
793 | //--------------------------------------------------------------------------- |