]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/wrapsizer.cpp | |
3 | // Purpose: provides wxWrapSizer class for layout | |
4 | // Author: Arne Steinarson | |
5 | // Created: 2008-05-08 | |
6 | // RCS-ID: $Id$ | |
7 | // Copyright: (c) Arne Steinarson | |
8 | // Licence: wxWindows licence | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | // ============================================================================ | |
12 | // declarations | |
13 | // ============================================================================ | |
14 | ||
15 | // ---------------------------------------------------------------------------- | |
16 | // headers | |
17 | // ---------------------------------------------------------------------------- | |
18 | ||
19 | // For compilers that support precompilation, includes "wx.h". | |
20 | #include "wx/wxprec.h" | |
21 | ||
22 | #ifdef __BORLANDC__ | |
23 | #pragma hdrstop | |
24 | #endif | |
25 | ||
26 | #include "wx/wrapsizer.h" | |
27 | #include "wx/vector.h" | |
28 | ||
29 | namespace | |
30 | { | |
31 | ||
32 | // ---------------------------------------------------------------------------- | |
33 | // helper local classes | |
34 | // ---------------------------------------------------------------------------- | |
35 | ||
36 | // This object changes the item proportion to INT_MAX in its ctor and restores | |
37 | // it back in the dtor. | |
38 | class wxPropChanger : public wxObject | |
39 | { | |
40 | public: | |
41 | wxPropChanger(wxSizer& sizer, wxSizerItem& item) | |
42 | : m_sizer(sizer), | |
43 | m_item(item), | |
44 | m_propOld(item.GetProportion()) | |
45 | { | |
46 | // ensure that this item expands more than all the other ones | |
47 | item.SetProportion(INT_MAX); | |
48 | } | |
49 | ||
50 | ~wxPropChanger() | |
51 | { | |
52 | // check if the sizer still has this item, it could have been removed | |
53 | if ( m_sizer.GetChildren().Find(&m_item) ) | |
54 | m_item.SetProportion(m_propOld); | |
55 | } | |
56 | ||
57 | private: | |
58 | wxSizer& m_sizer; | |
59 | wxSizerItem& m_item; | |
60 | const int m_propOld; | |
61 | ||
62 | wxDECLARE_NO_COPY_CLASS(wxPropChanger); | |
63 | }; | |
64 | ||
65 | } // anonymous namespace | |
66 | ||
67 | // ============================================================================ | |
68 | // wxWrapSizer implementation | |
69 | // ============================================================================ | |
70 | ||
71 | IMPLEMENT_DYNAMIC_CLASS(wxWrapSizer, wxBoxSizer) | |
72 | ||
73 | wxWrapSizer::wxWrapSizer(int orient, int flags) | |
74 | : wxBoxSizer(orient), | |
75 | m_flags(flags), | |
76 | m_dirInform(0), | |
77 | m_availSize(-1), | |
78 | m_availableOtherDir(0), | |
79 | m_lastUsed(true), | |
80 | m_minSizeMinor(0), | |
81 | m_maxSizeMajor(0), | |
82 | m_minItemMajor(INT_MAX), | |
83 | m_rows(orient ^ wxBOTH) | |
84 | { | |
85 | } | |
86 | ||
87 | wxWrapSizer::~wxWrapSizer() | |
88 | { | |
89 | ClearRows(); | |
90 | } | |
91 | ||
92 | void wxWrapSizer::ClearRows() | |
93 | { | |
94 | // all elements of the row sizers are also elements of this one (we | |
95 | // directly add pointers to elements of our own m_children list to the row | |
96 | // sizers in RecalcSizes()), so we need to detach them from the row sizer | |
97 | // to avoid double deletion | |
98 | wxSizerItemList& rows = m_rows.GetChildren(); | |
99 | for ( wxSizerItemList::iterator i = rows.begin(), | |
100 | end = rows.end(); | |
101 | i != end; | |
102 | ++i ) | |
103 | { | |
104 | wxSizerItem * const item = *i; | |
105 | wxSizer * const row = item->GetSizer(); | |
106 | if ( !row ) | |
107 | { | |
108 | wxFAIL_MSG( "all elements of m_rows must be sizers" ); | |
109 | continue; | |
110 | } | |
111 | ||
112 | row->GetChildren().clear(); | |
113 | ||
114 | wxPropChanger * const | |
115 | propChanger = static_cast<wxPropChanger *>(item->GetUserData()); | |
116 | if ( propChanger ) | |
117 | { | |
118 | // this deletes propChanger and so restores the old proportion | |
119 | item->SetUserData(NULL); | |
120 | } | |
121 | } | |
122 | } | |
123 | ||
124 | wxSizer *wxWrapSizer::GetRowSizer(size_t n) | |
125 | { | |
126 | const wxSizerItemList& rows = m_rows.GetChildren(); | |
127 | if ( n < rows.size() ) | |
128 | return rows[n]->GetSizer(); | |
129 | ||
130 | wxSizer * const sizer = new wxBoxSizer(GetOrientation()); | |
131 | m_rows.Add(sizer, wxSizerFlags().Expand()); | |
132 | return sizer; | |
133 | } | |
134 | ||
135 | bool wxWrapSizer::InformFirstDirection(int direction, | |
136 | int size, | |
137 | int availableOtherDir) | |
138 | { | |
139 | if ( !direction ) | |
140 | return false; | |
141 | ||
142 | // Store the values for later use | |
143 | m_availSize = size; | |
144 | m_availableOtherDir = availableOtherDir + | |
145 | (direction == wxHORIZONTAL ? m_minSize.y | |
146 | : m_minSize.x); | |
147 | m_dirInform = direction; | |
148 | m_lastUsed = false; | |
149 | return true; | |
150 | } | |
151 | ||
152 | ||
153 | void wxWrapSizer::AdjustLastRowItemProp(size_t n, wxSizerItem *itemLast) | |
154 | { | |
155 | if ( !itemLast || !(m_flags & wxEXTEND_LAST_ON_EACH_LINE) ) | |
156 | { | |
157 | // nothing to do | |
158 | return; | |
159 | } | |
160 | ||
161 | wxSizerItem * const item = m_rows.GetItem(n); | |
162 | wxCHECK_RET( item, "invalid sizer item" ); | |
163 | ||
164 | // store the item we modified and its original proportion | |
165 | item->SetUserData(new wxPropChanger(*this, *itemLast)); | |
166 | } | |
167 | ||
168 | wxSize wxWrapSizer::CalcMin() | |
169 | { | |
170 | if ( m_children.empty() ) | |
171 | return wxSize(); | |
172 | ||
173 | // We come here to calculate min size in two different situations: | |
174 | // 1 - Immediately after InformFirstDirection, then we find a min size that | |
175 | // uses one dimension maximally and the other direction minimally. | |
176 | // 2 - Ordinary case, get a sensible min size value using the current line | |
177 | // layout, trying to maintain the possibility to re-arrange lines by | |
178 | // sizing | |
179 | ||
180 | if ( !m_lastUsed ) | |
181 | { | |
182 | // Case 1 above: InformFirstDirection() has just been called | |
183 | m_lastUsed = true; | |
184 | ||
185 | // There are two different algorithms for finding a useful min size for | |
186 | // a wrap sizer, depending on whether the first reported size component | |
187 | // is the opposite as our own orientation (the simpler case) or the same | |
188 | // one (more complicated). | |
189 | if ( m_dirInform == m_orient ) | |
190 | CalcMinFromMajor(m_availSize); | |
191 | else | |
192 | CalcMinFromMinor(m_availSize); | |
193 | } | |
194 | else // Case 2 above: not immediately after InformFirstDirection() | |
195 | { | |
196 | if ( m_availSize > 0 ) | |
197 | { | |
198 | wxSize szAvail; // Keep track of boundary so we don't overflow | |
199 | if ( m_dirInform == m_orient ) | |
200 | szAvail = SizeFromMajorMinor(m_availSize, m_availableOtherDir); | |
201 | else | |
202 | szAvail = SizeFromMajorMinor(m_availableOtherDir, m_availSize); | |
203 | ||
204 | CalcMinFittingSize(szAvail); | |
205 | } | |
206 | else // Initial calculation, before we have size available to us | |
207 | { | |
208 | CalcMaxSingleItemSize(); | |
209 | } | |
210 | } | |
211 | ||
212 | return m_minSize; | |
213 | } | |
214 | ||
215 | void wxWrapSizer::CalcMinFittingSize(const wxSize& szBoundary) | |
216 | { | |
217 | // Min size based on current line layout. It is important to | |
218 | // provide a smaller size when possible to allow for resizing with | |
219 | // the help of re-arranging the lines. | |
220 | wxSize sizeMin = SizeFromMajorMinor(m_maxSizeMajor, m_minSizeMinor); | |
221 | if ( m_minSizeMinor < SizeInMinorDir(m_size) && | |
222 | m_maxSizeMajor < SizeInMajorDir(m_size) ) | |
223 | { | |
224 | m_minSize = sizeMin; | |
225 | } | |
226 | else | |
227 | { | |
228 | // Try making it a bit more narrow | |
229 | bool done = false; | |
230 | if ( m_minItemMajor != INT_MAX && m_maxSizeMajor > 0 ) | |
231 | { | |
232 | // We try to present a lower min value by removing an item in | |
233 | // the major direction (and preserving current minor min size). | |
234 | CalcMinFromMajor(m_maxSizeMajor - m_minItemMajor); | |
235 | if ( m_minSize.x <= szBoundary.x && m_minSize.y <= szBoundary.y ) | |
236 | { | |
237 | SizeInMinorDir(m_minSize) = SizeInMinorDir(sizeMin); | |
238 | done = true; | |
239 | } | |
240 | } | |
241 | ||
242 | if ( !done ) | |
243 | { | |
244 | // If failed finding little smaller area, go back to what we had | |
245 | m_minSize = sizeMin; | |
246 | } | |
247 | } | |
248 | } | |
249 | ||
250 | void wxWrapSizer::CalcMaxSingleItemSize() | |
251 | { | |
252 | // Find max item size in each direction | |
253 | int maxMajor = 0; // Widest item | |
254 | int maxMinor = 0; // Line height | |
255 | for ( wxSizerItemList::const_iterator i = m_children.begin(); | |
256 | i != m_children.end(); | |
257 | ++i ) | |
258 | { | |
259 | wxSizerItem * const item = *i; | |
260 | if ( item->IsShown() ) | |
261 | { | |
262 | wxSize sz = item->CalcMin(); | |
263 | if ( SizeInMajorDir(sz) > maxMajor ) | |
264 | maxMajor = SizeInMajorDir(sz); | |
265 | if ( SizeInMinorDir(sz) > maxMinor ) | |
266 | maxMinor = SizeInMinorDir(sz); | |
267 | } | |
268 | } | |
269 | ||
270 | // This is, of course, not our real minimal size but if we return more | |
271 | // than this it would be impossible to shrink us to one row/column so | |
272 | // we have to pretend that this is all we need for now. | |
273 | m_minSize = SizeFromMajorMinor(maxMajor, maxMinor); | |
274 | } | |
275 | ||
276 | void wxWrapSizer::CalcMinFromMajor(int totMajor) | |
277 | { | |
278 | // Algorithm for calculating min size: (assuming horizontal orientation) | |
279 | // This is the simpler case (known major size) | |
280 | // X: Given, totMajor | |
281 | // Y: Based on X, calculate how many lines needed | |
282 | ||
283 | int maxTotalMajor = 0; // max of rowTotalMajor over all rows | |
284 | int minorSum = 0; // sum of sizes of all rows in minor direction | |
285 | int maxRowMinor = 0; // max of item minor sizes in this row | |
286 | int rowTotalMajor = 0; // sum of major sizes of items in this row | |
287 | ||
288 | // pack the items in each row until we reach totMajor, then start a new row | |
289 | for ( wxSizerItemList::const_iterator i = m_children.begin(); | |
290 | i != m_children.end(); | |
291 | ++i ) | |
292 | { | |
293 | wxSizerItem * const item = *i; | |
294 | if ( !item->IsShown() ) | |
295 | continue; | |
296 | ||
297 | wxSize minItemSize = item->CalcMin(); | |
298 | const int itemMajor = SizeInMajorDir(minItemSize); | |
299 | const int itemMinor = SizeInMinorDir(minItemSize); | |
300 | ||
301 | // check if this is the first item in a new row: if so, we have to put | |
302 | // it in it, whether it fits or not, as it would never fit better | |
303 | // anyhow | |
304 | // | |
305 | // otherwise check if we have enough space left for this item here | |
306 | if ( !rowTotalMajor || rowTotalMajor + itemMajor <= totMajor ) | |
307 | { | |
308 | // continue this row | |
309 | rowTotalMajor += itemMajor; | |
310 | if ( itemMinor > maxRowMinor ) | |
311 | maxRowMinor = itemMinor; | |
312 | } | |
313 | else // start a new row | |
314 | { | |
315 | // minor size of the row is the max of minor sizes of its items | |
316 | minorSum += maxRowMinor; | |
317 | if ( rowTotalMajor > maxTotalMajor ) | |
318 | maxTotalMajor = rowTotalMajor; | |
319 | maxRowMinor = itemMinor; | |
320 | rowTotalMajor = itemMajor; | |
321 | } | |
322 | } | |
323 | ||
324 | // account for the last (unfinished) row too | |
325 | minorSum += maxRowMinor; | |
326 | if ( rowTotalMajor > maxTotalMajor ) | |
327 | maxTotalMajor = rowTotalMajor; | |
328 | ||
329 | m_minSize = SizeFromMajorMinor(maxTotalMajor, minorSum); | |
330 | } | |
331 | ||
332 | // Helper struct for CalcMinFromMinor | |
333 | struct wxWrapLine | |
334 | { | |
335 | wxWrapLine() : m_first(NULL), m_width(0) { } | |
336 | wxSizerItem *m_first; | |
337 | int m_width; // Width of line | |
338 | }; | |
339 | ||
340 | void wxWrapSizer::CalcMinFromMinor(int totMinor) | |
341 | { | |
342 | // Algorithm for calculating min size: | |
343 | // This is the more complex case (known minor size) | |
344 | ||
345 | // First step, find total sum of all items in primary direction | |
346 | // and max item size in secondary direction, that gives initial | |
347 | // estimate of the minimum number of lines. | |
348 | ||
349 | int totMajor = 0; // Sum of widths | |
350 | int maxMinor = 0; // Line height | |
351 | int maxMajor = 0; // Widest item | |
352 | int itemCount = 0; | |
353 | wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); | |
354 | wxSize sz; | |
355 | while (node) | |
356 | { | |
357 | wxSizerItem *item = node->GetData(); | |
358 | if ( item->IsShown() ) | |
359 | { | |
360 | sz = item->CalcMin(); | |
361 | totMajor += SizeInMajorDir(sz); | |
362 | if ( SizeInMinorDir(sz)>maxMinor ) | |
363 | maxMinor = SizeInMinorDir(sz); | |
364 | if ( SizeInMajorDir(sz)>maxMinor ) | |
365 | maxMajor = SizeInMajorDir(sz); | |
366 | itemCount++; | |
367 | } | |
368 | node = node->GetNext(); | |
369 | } | |
370 | ||
371 | // The trivial case | |
372 | if ( !itemCount || totMajor==0 || maxMinor==0 ) | |
373 | { | |
374 | m_minSize = wxSize(0,0); | |
375 | return; | |
376 | } | |
377 | ||
378 | // First attempt, use lines of average size: | |
379 | int nrLines = totMinor / maxMinor; // Rounding down is right here | |
380 | if ( nrLines<=1 ) | |
381 | { | |
382 | // Another simple case, everything fits on one line | |
383 | m_minSize = SizeFromMajorMinor(totMajor,maxMinor); | |
384 | return; | |
385 | } | |
386 | ||
387 | int lineSize = totMajor / nrLines; | |
388 | if ( lineSize<maxMajor ) // At least as wide as the widest element | |
389 | lineSize = maxMajor; | |
390 | ||
391 | // The algorithm is as follows (horz case): | |
392 | // 1 - Vertical (minor) size is known. | |
393 | // 2 - We have a reasonable estimated width from above | |
394 | // 3 - Loop | |
395 | // 3a - Do layout with suggested width | |
396 | // 3b - See how much we spill over in minor dir | |
397 | // 3c - If no spill, we're done | |
398 | // 3d - Otherwise increase width by known smallest item | |
399 | // and redo loop | |
400 | ||
401 | // First algo step: put items on lines of known max width | |
402 | wxVector<wxWrapLine*> lines; | |
403 | ||
404 | int sumMinor; // Sum of all minor sizes (height of all lines) | |
405 | ||
406 | // While we still have items 'spilling over' extend the tested line width | |
407 | for ( ;; ) | |
408 | { | |
409 | wxWrapLine *line = new wxWrapLine; | |
410 | lines.push_back( line ); | |
411 | ||
412 | int tailSize = 0; // Width of what exceeds nrLines | |
413 | maxMinor = 0; | |
414 | sumMinor = 0; | |
415 | for ( node=m_children.GetFirst(); node; node=node->GetNext() ) | |
416 | { | |
417 | wxSizerItem *item = node->GetData(); | |
418 | if ( item->IsShown() ) | |
419 | { | |
420 | sz = item->GetMinSizeWithBorder(); | |
421 | if ( line->m_width+SizeInMajorDir(sz)>lineSize ) | |
422 | { | |
423 | line = new wxWrapLine; | |
424 | lines.push_back(line); | |
425 | sumMinor += maxMinor; | |
426 | maxMinor = 0; | |
427 | } | |
428 | line->m_width += SizeInMajorDir(sz); | |
429 | if ( line->m_width && !line->m_first ) | |
430 | line->m_first = item; | |
431 | if ( SizeInMinorDir(sz)>maxMinor ) | |
432 | maxMinor = SizeInMinorDir(sz); | |
433 | if ( sumMinor+maxMinor>totMinor ) | |
434 | { | |
435 | // Keep track of widest tail item | |
436 | if ( SizeInMajorDir(sz)>tailSize ) | |
437 | tailSize = SizeInMajorDir(sz); | |
438 | } | |
439 | } | |
440 | } | |
441 | ||
442 | if ( tailSize ) | |
443 | { | |
444 | // Now look how much we need to extend our size | |
445 | // We know we must have at least one more line than nrLines | |
446 | // (otherwise no tail size). | |
447 | int bestExtSize = 0; // Minimum extension width for current tailSize | |
448 | for ( int ix=0; ix<nrLines; ix++ ) | |
449 | { | |
450 | // Take what is not used on this line, see how much extension we get | |
451 | // by adding first item on next line. | |
452 | int size = lineSize-lines[ix]->m_width; // Left over at end of this line | |
453 | int extSize = GetSizeInMajorDir(lines[ix+1]->m_first->GetMinSizeWithBorder()) - size; | |
454 | if ( (extSize>=tailSize && (extSize<bestExtSize || bestExtSize<tailSize)) || | |
455 | (extSize>bestExtSize && bestExtSize<tailSize) ) | |
456 | bestExtSize = extSize; | |
457 | } | |
458 | // Have an extension size, ready to redo line layout | |
459 | lineSize += bestExtSize; | |
460 | } | |
461 | ||
462 | // Clear helper items | |
463 | for ( wxVector<wxWrapLine*>::iterator it=lines.begin(); it<lines.end(); ++it ) | |
464 | delete *it; | |
465 | lines.clear(); | |
466 | ||
467 | // No spill over? | |
468 | if ( !tailSize ) | |
469 | break; | |
470 | } | |
471 | ||
472 | // Now have min size in the opposite direction | |
473 | m_minSize = SizeFromMajorMinor(lineSize,sumMinor); | |
474 | } | |
475 | ||
476 | void wxWrapSizer::FinishRow(size_t n, | |
477 | int rowMajor, int rowMinor, | |
478 | wxSizerItem *itemLast) | |
479 | { | |
480 | // Account for the finished row size. | |
481 | m_minSizeMinor += rowMinor; | |
482 | if ( rowMajor > m_maxSizeMajor ) | |
483 | m_maxSizeMajor = rowMajor; | |
484 | ||
485 | // And adjust proportion of its last item if necessary. | |
486 | AdjustLastRowItemProp(n, itemLast); | |
487 | } | |
488 | ||
489 | void wxWrapSizer::RecalcSizes() | |
490 | { | |
491 | // First restore any proportions we may have changed and remove the old rows | |
492 | ClearRows(); | |
493 | ||
494 | if ( m_children.empty() ) | |
495 | return; | |
496 | ||
497 | // Put all our items into as many row box sizers as needed. | |
498 | const int majorSize = SizeInMajorDir(m_size); // max size of each row | |
499 | int rowTotalMajor = 0; // running row major size | |
500 | int maxRowMinor = 0; | |
501 | ||
502 | m_minSizeMinor = 0; | |
503 | m_minItemMajor = INT_MAX; | |
504 | m_maxSizeMajor = 0; | |
505 | ||
506 | // We need at least one row | |
507 | size_t nRow = 0; | |
508 | wxSizer *sizer = GetRowSizer(nRow); | |
509 | ||
510 | wxSizerItem *itemLast = NULL, // last item processed in this row | |
511 | *itemSpace = NULL; // spacer which we delayed adding | |
512 | ||
513 | // Now put our child items into child sizers instead | |
514 | for ( wxSizerItemList::iterator i = m_children.begin(); | |
515 | i != m_children.end(); | |
516 | ++i ) | |
517 | { | |
518 | wxSizerItem * const item = *i; | |
519 | if ( !item->IsShown() ) | |
520 | continue; | |
521 | ||
522 | wxSize minItemSize = item->GetMinSizeWithBorder(); | |
523 | const int itemMajor = SizeInMajorDir(minItemSize); | |
524 | const int itemMinor = SizeInMinorDir(minItemSize); | |
525 | if ( itemMajor > 0 && itemMajor < m_minItemMajor ) | |
526 | m_minItemMajor = itemMajor; | |
527 | ||
528 | // Is there more space on this line? Notice that if this is the first | |
529 | // item we add it unconditionally as it wouldn't fit in the next line | |
530 | // any better than in this one. | |
531 | if ( !rowTotalMajor || rowTotalMajor + itemMajor <= majorSize ) | |
532 | { | |
533 | // There is enough space here | |
534 | rowTotalMajor += itemMajor; | |
535 | if ( itemMinor > maxRowMinor ) | |
536 | maxRowMinor = itemMinor; | |
537 | } | |
538 | else // Start a new row | |
539 | { | |
540 | FinishRow(nRow, rowTotalMajor, maxRowMinor, itemLast); | |
541 | ||
542 | rowTotalMajor = itemMajor; | |
543 | maxRowMinor = itemMinor; | |
544 | ||
545 | // Get a new empty sizer to insert into | |
546 | sizer = GetRowSizer(++nRow); | |
547 | ||
548 | itemLast = | |
549 | itemSpace = NULL; | |
550 | } | |
551 | ||
552 | // Only remove first/last spaces if that flag is set | |
553 | if ( (m_flags & wxREMOVE_LEADING_SPACES) && IsSpaceItem(item) ) | |
554 | { | |
555 | // Remember space only if we have a first item | |
556 | if ( itemLast ) | |
557 | itemSpace = item; | |
558 | } | |
559 | else // not a space | |
560 | { | |
561 | if ( itemLast && itemSpace ) | |
562 | { | |
563 | // We had a spacer after a real item and now that we add | |
564 | // another real item to the same row we need to add the spacer | |
565 | // between them two. | |
566 | sizer->Add(itemSpace); | |
567 | } | |
568 | ||
569 | // Notice that we reuse a pointer to our own sizer item here, so we | |
570 | // must remember to remove it by calling ClearRows() to avoid | |
571 | // double deletion later | |
572 | sizer->Add(item); | |
573 | ||
574 | itemLast = item; | |
575 | itemSpace = NULL; | |
576 | } | |
577 | ||
578 | // If item is a window, it now has a pointer to the child sizer, | |
579 | // which is wrong. Set it to point to us. | |
580 | if ( wxWindow *win = item->GetWindow() ) | |
581 | win->SetContainingSizer(this); | |
582 | } | |
583 | ||
584 | FinishRow(nRow, rowTotalMajor, maxRowMinor, itemLast); | |
585 | ||
586 | // Now do layout on row sizer | |
587 | m_rows.SetDimension(m_position, m_size); | |
588 | } | |
589 | ||
590 |