]> git.saurik.com Git - wxWidgets.git/blob - src/common/layout.cpp
controls can now be put in the toolbars (MSW only so far, preliminary version)
[wxWidgets.git] / src / common / layout.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: layout.cpp
3 // Purpose: Constraint layout system classes
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // =============================================================================
13 // declarations
14 // =============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "layout.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/defs.h"
33 #endif
34
35 #if wxUSE_CONSTRAINTS
36
37 #ifndef WX_PRECOMP
38 #include "wx/window.h"
39 #include "wx/utils.h"
40 #include "wx/dialog.h"
41 #include "wx/msgdlg.h"
42 #include "wx/intl.h"
43 #endif
44
45 #include "wx/layout.h"
46
47 #if !USE_SHARED_LIBRARY
48 IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
49 IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
50 #endif
51
52
53 wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
54 {
55 myEdge = wxTop;
56 relationship = wxUnconstrained;
57 margin = 0;
58 value = 0;
59 percent = 0;
60 otherEdge = wxTop;
61 done = FALSE;
62 otherWin = (wxWindowBase *) NULL;
63 }
64
65 wxIndividualLayoutConstraint::~wxIndividualLayoutConstraint()
66 {
67 }
68
69 void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val, int marg)
70 {
71 relationship = rel;
72 otherWin = otherW;
73 otherEdge = otherE;
74 value = val;
75 margin = marg;
76 }
77
78 void wxIndividualLayoutConstraint::LeftOf(wxWindowBase *sibling, int marg)
79 {
80 Set(wxLeftOf, sibling, wxLeft, 0, marg);
81 }
82
83 void wxIndividualLayoutConstraint::RightOf(wxWindowBase *sibling, int marg)
84 {
85 Set(wxRightOf, sibling, wxRight, 0, marg);
86 }
87
88 void wxIndividualLayoutConstraint::Above(wxWindowBase *sibling, int marg)
89 {
90 Set(wxAbove, sibling, wxTop, 0, marg);
91 }
92
93 void wxIndividualLayoutConstraint::Below(wxWindowBase *sibling, int marg)
94 {
95 Set(wxBelow, sibling, wxBottom, 0, marg);
96 }
97
98 //
99 // 'Same edge' alignment
100 //
101 void wxIndividualLayoutConstraint::SameAs(wxWindowBase *otherW, wxEdge edge, int marg)
102 {
103 Set(wxPercentOf, otherW, edge, 0, marg);
104 percent = 100;
105 }
106
107 // The edge is a percentage of the other window's edge
108 void wxIndividualLayoutConstraint::PercentOf(wxWindowBase *otherW, wxEdge wh, int per)
109 {
110 otherWin = otherW;
111 relationship = wxPercentOf;
112 percent = per;
113
114 otherEdge = wh;
115 }
116
117 //
118 // Edge has absolute value
119 //
120 void wxIndividualLayoutConstraint::Absolute(int val)
121 {
122 value = val; relationship = wxAbsolute;
123 }
124
125 // Reset constraint if it mentions otherWin
126 bool wxIndividualLayoutConstraint::ResetIfWin(wxWindowBase *otherW)
127 {
128 if (otherW == otherWin)
129 {
130 myEdge = wxTop;
131 relationship = wxAsIs;
132 margin = 0;
133 value = 0;
134 percent = 0;
135 otherEdge = wxTop;
136 otherWin = (wxWindowBase *) NULL;
137 return TRUE;
138 }
139 else
140 return FALSE;
141 }
142
143 // Try to satisfy constraint
144 bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win)
145 {
146 if (relationship == wxAbsolute)
147 {
148 done = TRUE;
149 return TRUE;
150 }
151
152 switch (myEdge)
153 {
154 case wxLeft:
155 {
156 switch (relationship)
157 {
158 case wxLeftOf:
159 {
160 // We can know this edge if: otherWin is win's
161 // parent, or otherWin has a satisfied constraint,
162 // or otherWin has no constraint.
163 int edgePos = GetEdge(otherEdge, win, otherWin);
164 if (edgePos != -1)
165 {
166 value = edgePos - margin;
167 done = TRUE;
168 return TRUE;
169 }
170 else
171 return FALSE;
172 }
173 case wxRightOf:
174 {
175 int edgePos = GetEdge(otherEdge, win, otherWin);
176 if (edgePos != -1)
177 {
178 value = edgePos + margin;
179 done = TRUE;
180 return TRUE;
181 }
182 else
183 return FALSE;
184 }
185 case wxPercentOf:
186 {
187 int edgePos = GetEdge(otherEdge, win, otherWin);
188 if (edgePos != -1)
189 {
190 value = (int)(edgePos*(((float)percent)*0.01) + margin);
191 done = TRUE;
192 return TRUE;
193 }
194 else
195 return FALSE;
196 }
197 case wxUnconstrained:
198 {
199 // We know the left-hand edge position if we know
200 // the right-hand edge and we know the width; OR if
201 // we know the centre and the width.
202 if (constraints->right.GetDone() && constraints->width.GetDone())
203 {
204 value = (constraints->right.GetValue() - constraints->width.GetValue() + margin);
205 done = TRUE;
206 return TRUE;
207 }
208 else if (constraints->centreX.GetDone() && constraints->width.GetDone())
209 {
210 value = (int)(constraints->centreX.GetValue() - (constraints->width.GetValue()/2) + margin);
211 done = TRUE;
212 return TRUE;
213 }
214 else
215 return FALSE;
216 }
217 case wxAsIs:
218 {
219 int y;
220 win->GetPosition(&value, &y);
221 done = TRUE;
222 return TRUE;
223 }
224 default:
225 break;
226 }
227 break;
228 }
229 case wxRight:
230 {
231 switch (relationship)
232 {
233 case wxLeftOf:
234 {
235 // We can know this edge if: otherWin is win's
236 // parent, or otherWin has a satisfied constraint,
237 // or otherWin has no constraint.
238 int edgePos = GetEdge(otherEdge, win, otherWin);
239 if (edgePos != -1)
240 {
241 value = edgePos - margin;
242 done = TRUE;
243 return TRUE;
244 }
245 else
246 return FALSE;
247 }
248 case wxRightOf:
249 {
250 int edgePos = GetEdge(otherEdge, win, otherWin);
251 if (edgePos != -1)
252 {
253 value = edgePos + margin;
254 done = TRUE;
255 return TRUE;
256 }
257 else
258 return FALSE;
259 }
260 case wxPercentOf:
261 {
262 int edgePos = GetEdge(otherEdge, win, otherWin);
263 if (edgePos != -1)
264 {
265 value = (int)(edgePos*(((float)percent)*0.01) - margin);
266 done = TRUE;
267 return TRUE;
268 }
269 else
270 return FALSE;
271 }
272 case wxUnconstrained:
273 {
274 // We know the right-hand edge position if we know the
275 // left-hand edge and we know the width, OR if we know the
276 // centre edge and the width.
277 if (constraints->left.GetDone() && constraints->width.GetDone())
278 {
279 value = (constraints->left.GetValue() + constraints->width.GetValue() - margin);
280 done = TRUE;
281 return TRUE;
282 }
283 else if (constraints->centreX.GetDone() && constraints->width.GetDone())
284 {
285 value = (int)(constraints->centreX.GetValue() + (constraints->width.GetValue()/2) - margin);
286 done = TRUE;
287 return TRUE;
288 }
289 else
290 return FALSE;
291 }
292 case wxAsIs:
293 {
294 int x, y;
295 int w, h;
296 win->GetSize(&w, &h);
297 win->GetPosition(&x, &y);
298 value = x + w;
299 done = TRUE;
300 return TRUE;
301 }
302 default:
303 break;
304 }
305 break;
306 }
307 case wxTop:
308 {
309 switch (relationship)
310 {
311 case wxAbove:
312 {
313 // We can know this edge if: otherWin is win's
314 // parent, or otherWin has a satisfied constraint,
315 // or otherWin has no constraint.
316 int edgePos = GetEdge(otherEdge, win, otherWin);
317 if (edgePos != -1)
318 {
319 value = edgePos - margin;
320 done = TRUE;
321 return TRUE;
322 }
323 else
324 return FALSE;
325 }
326 case wxBelow:
327 {
328 int edgePos = GetEdge(otherEdge, win, otherWin);
329 if (edgePos != -1)
330 {
331 value = edgePos + margin;
332 done = TRUE;
333 return TRUE;
334 }
335 else
336 return FALSE;
337 }
338 case wxPercentOf:
339 {
340 int edgePos = GetEdge(otherEdge, win, otherWin);
341 if (edgePos != -1)
342 {
343 value = (int)(edgePos*(((float)percent)*0.01) + margin);
344 done = TRUE;
345 return TRUE;
346 }
347 else
348 return FALSE;
349 }
350 case wxUnconstrained:
351 {
352 // We know the top edge position if we know the bottom edge
353 // and we know the height; OR if we know the centre edge and
354 // the height.
355 if (constraints->bottom.GetDone() && constraints->height.GetDone())
356 {
357 value = (constraints->bottom.GetValue() - constraints->height.GetValue() + margin);
358 done = TRUE;
359 return TRUE;
360 }
361 else if (constraints->centreY.GetDone() && constraints->height.GetDone())
362 {
363 value = (constraints->centreY.GetValue() - (constraints->height.GetValue()/2) + margin);
364 done = TRUE;
365 return TRUE;
366 }
367 else
368 return FALSE;
369 }
370 case wxAsIs:
371 {
372 int x;
373 win->GetPosition(&x, &value);
374 done = TRUE;
375 return TRUE;
376 }
377 default:
378 break;
379 }
380 break;
381 }
382 case wxBottom:
383 {
384 switch (relationship)
385 {
386 case wxAbove:
387 {
388 // We can know this edge if: otherWin is win's parent,
389 // or otherWin has a satisfied constraint, or
390 // otherWin has no constraint.
391 int edgePos = GetEdge(otherEdge, win, otherWin);
392 if (edgePos != -1)
393 {
394 value = edgePos + margin;
395 done = TRUE;
396 return TRUE;
397 }
398 else
399 return FALSE;
400 }
401 case wxBelow:
402 {
403 int edgePos = GetEdge(otherEdge, win, otherWin);
404 if (edgePos != -1)
405 {
406 value = edgePos - margin;
407 done = TRUE;
408 return TRUE;
409 }
410 else
411 return FALSE;
412 }
413 case wxPercentOf:
414 {
415 int edgePos = GetEdge(otherEdge, win, otherWin);
416 if (edgePos != -1)
417 {
418 value = (int)(edgePos*(((float)percent)*0.01) - margin);
419 done = TRUE;
420 return TRUE;
421 }
422 else
423 return FALSE;
424 }
425 case wxUnconstrained:
426 {
427 // We know the bottom edge position if we know the top edge
428 // and we know the height; OR if we know the centre edge and
429 // the height.
430 if (constraints->top.GetDone() && constraints->height.GetDone())
431 {
432 value = (constraints->top.GetValue() + constraints->height.GetValue() - margin);
433 done = TRUE;
434 return TRUE;
435 }
436 else if (constraints->centreY.GetDone() && constraints->height.GetDone())
437 {
438 value = (constraints->centreY.GetValue() + (constraints->height.GetValue()/2) - margin);
439 done = TRUE;
440 return TRUE;
441 }
442 else
443 return FALSE;
444 }
445 case wxAsIs:
446 {
447 int x, y;
448 int w, h;
449 win->GetSize(&w, &h);
450 win->GetPosition(&x, &y);
451 value = h + y;
452 done = TRUE;
453 return TRUE;
454 }
455 default:
456 break;
457 }
458 break;
459 }
460 case wxCentreX:
461 {
462 switch (relationship)
463 {
464 case wxLeftOf:
465 {
466 // We can know this edge if: otherWin is win's parent, or
467 // otherWin has a satisfied constraint, or otherWin has no
468 // constraint.
469 int edgePos = GetEdge(otherEdge, win, otherWin);
470 if (edgePos != -1)
471 {
472 value = edgePos - margin;
473 done = TRUE;
474 return TRUE;
475 }
476 else
477 return FALSE;
478 }
479 case wxRightOf:
480 {
481 int edgePos = GetEdge(otherEdge, win, otherWin);
482 if (edgePos != -1)
483 {
484 value = edgePos + margin;
485 done = TRUE;
486 return TRUE;
487 }
488 else
489 return FALSE;
490 }
491 case wxPercentOf:
492 {
493 int edgePos = GetEdge(otherEdge, win, otherWin);
494 if (edgePos != -1)
495 {
496 value = (int)(edgePos*(((float)percent)*0.01) + margin);
497 done = TRUE;
498 return TRUE;
499 }
500 else
501 return FALSE;
502 }
503 case wxUnconstrained:
504 {
505 // We know the centre position if we know
506 // the left-hand edge and we know the width, OR
507 // the right-hand edge and the width
508 if (constraints->left.GetDone() && constraints->width.GetDone())
509 {
510 value = (int)(constraints->left.GetValue() + (constraints->width.GetValue()/2) + margin);
511 done = TRUE;
512 return TRUE;
513 }
514 else if (constraints->right.GetDone() && constraints->width.GetDone())
515 {
516 value = (int)(constraints->left.GetValue() - (constraints->width.GetValue()/2) + margin);
517 done = TRUE;
518 return TRUE;
519 }
520 else
521 return FALSE;
522 }
523 default:
524 break;
525 }
526 break;
527 }
528 case wxCentreY:
529 {
530 switch (relationship)
531 {
532 case wxAbove:
533 {
534 // We can know this edge if: otherWin is win's parent,
535 // or otherWin has a satisfied constraint, or otherWin
536 // has no constraint.
537 int edgePos = GetEdge(otherEdge, win, otherWin);
538 if (edgePos != -1)
539 {
540 value = edgePos - margin;
541 done = TRUE;
542 return TRUE;
543 }
544 else
545 return FALSE;
546 }
547 case wxBelow:
548 {
549 int edgePos = GetEdge(otherEdge, win, otherWin);
550 if (edgePos != -1)
551 {
552 value = edgePos + margin;
553 done = TRUE;
554 return TRUE;
555 }
556 else
557 return FALSE;
558 }
559 case wxPercentOf:
560 {
561 int edgePos = GetEdge(otherEdge, win, otherWin);
562 if (edgePos != -1)
563 {
564 value = (int)(edgePos*(((float)percent)*0.01) + margin);
565 done = TRUE;
566 return TRUE;
567 }
568 else
569 return FALSE;
570 }
571 case wxUnconstrained:
572 {
573 // We know the centre position if we know
574 // the top edge and we know the height, OR
575 // the bottom edge and the height.
576 if (constraints->bottom.GetDone() && constraints->height.GetDone())
577 {
578 value = (int)(constraints->bottom.GetValue() - (constraints->height.GetValue()/2) + margin);
579 done = TRUE;
580 return TRUE;
581 }
582 else if (constraints->top.GetDone() && constraints->height.GetDone())
583 {
584 value = (int)(constraints->top.GetValue() + (constraints->height.GetValue()/2) + margin);
585 done = TRUE;
586 return TRUE;
587 }
588 else
589 return FALSE;
590 }
591 default:
592 break;
593 }
594 break;
595 }
596 case wxWidth:
597 {
598 switch (relationship)
599 {
600 case wxPercentOf:
601 {
602 int edgePos = GetEdge(otherEdge, win, otherWin);
603 if (edgePos != -1)
604 {
605 value = (int)(edgePos*(((float)percent)*0.01));
606 done = TRUE;
607 return TRUE;
608 }
609 else
610 return FALSE;
611 }
612 case wxAsIs:
613 {
614 if (win)
615 {
616 int h;
617 win->GetSize(&value, &h);
618 done = TRUE;
619 return TRUE;
620 }
621 else return FALSE;
622 }
623 case wxUnconstrained:
624 {
625 // We know the width if we know the left edge and the right edge, OR
626 // if we know the left edge and the centre, OR
627 // if we know the right edge and the centre
628 if (constraints->left.GetDone() && constraints->right.GetDone())
629 {
630 value = constraints->right.GetValue() - constraints->left.GetValue();
631 done = TRUE;
632 return TRUE;
633 }
634 else if (constraints->centreX.GetDone() && constraints->left.GetDone())
635 {
636 value = (int)(2*(constraints->centreX.GetValue() - constraints->left.GetValue()));
637 done = TRUE;
638 return TRUE;
639 }
640 else if (constraints->centreX.GetDone() && constraints->right.GetDone())
641 {
642 value = (int)(2*(constraints->right.GetValue() - constraints->centreX.GetValue()));
643 done = TRUE;
644 return TRUE;
645 }
646 else
647 return FALSE;
648 }
649 default:
650 break;
651 }
652 break;
653 }
654 case wxHeight:
655 {
656 switch (relationship)
657 {
658 case wxPercentOf:
659 {
660 int edgePos = GetEdge(otherEdge, win, otherWin);
661 if (edgePos != -1)
662 {
663 value = (int)(edgePos*(((float)percent)*0.01));
664 done = TRUE;
665 return TRUE;
666 }
667 else
668 return FALSE;
669 }
670 case wxAsIs:
671 {
672 if (win)
673 {
674 int w;
675 win->GetSize(&w, &value);
676 done = TRUE;
677 return TRUE;
678 }
679 else return FALSE;
680 }
681 case wxUnconstrained:
682 {
683 // We know the height if we know the top edge and the bottom edge, OR
684 // if we know the top edge and the centre, OR
685 // if we know the bottom edge and the centre
686 if (constraints->top.GetDone() && constraints->bottom.GetDone())
687 {
688 value = constraints->bottom.GetValue() - constraints->top.GetValue();
689 done = TRUE;
690 return TRUE;
691 }
692 else if (constraints->top.GetDone() && constraints->centreY.GetDone())
693 {
694 value = (int)(2*(constraints->centreY.GetValue() - constraints->top.GetValue()));
695 done = TRUE;
696 return TRUE;
697 }
698 else if (constraints->bottom.GetDone() && constraints->centreY.GetDone())
699 {
700 value = (int)(2*(constraints->bottom.GetValue() - constraints->centreY.GetValue()));
701 done = TRUE;
702 return TRUE;
703 }
704 else
705 return FALSE;
706 }
707 default:
708 break;
709 }
710 break;
711 }
712 default:
713 break;
714 }
715 return FALSE;
716 }
717
718 // Get the value of this edge or dimension, or if this is not determinable, -1.
719 int wxIndividualLayoutConstraint::GetEdge(wxEdge which,
720 wxWindowBase *thisWin,
721 wxWindowBase *other) const
722 {
723 // If the edge or dimension belongs to the parent, then we know the
724 // dimension is obtainable immediately. E.g. a wxExpandSizer may contain a
725 // button (but the button's true parent is a panel, not the sizer)
726 if (other->GetChildren().Find(thisWin))
727 {
728 switch (which)
729 {
730 case wxLeft:
731 {
732 return 0;
733 }
734 case wxTop:
735 {
736 return 0;
737 }
738 case wxRight:
739 {
740 int w, h;
741 other->GetClientSizeConstraint(&w, &h);
742 return w;
743 }
744 case wxBottom:
745 {
746 int w, h;
747 other->GetClientSizeConstraint(&w, &h);
748 return h;
749 }
750 case wxWidth:
751 {
752 int w, h;
753 other->GetClientSizeConstraint(&w, &h);
754 return w;
755 }
756 case wxHeight:
757 {
758 int w, h;
759 other->GetClientSizeConstraint(&w, &h);
760 return h;
761 }
762 case wxCentreX:
763 case wxCentreY:
764 {
765 int w, h;
766 other->GetClientSizeConstraint(&w, &h);
767 if (which == wxCentreX)
768 return (int)(w/2);
769 else
770 return (int)(h/2);
771 }
772 default:
773 return -1;
774 }
775 }
776 switch (which)
777 {
778 case wxLeft:
779 {
780 wxLayoutConstraints *constr = other->GetConstraints();
781 // If no constraints, it means the window is not dependent
782 // on anything, and therefore we know its value immediately
783 if (constr)
784 {
785 if (constr->left.GetDone())
786 return constr->left.GetValue();
787 else
788 return -1;
789 }
790 else
791 {
792 int x, y;
793 other->GetPosition(&x, &y);
794 return x;
795 }
796 }
797 case wxTop:
798 {
799 wxLayoutConstraints *constr = other->GetConstraints();
800 // If no constraints, it means the window is not dependent
801 // on anything, and therefore we know its value immediately
802 if (constr)
803 {
804 if (constr->top.GetDone())
805 return constr->top.GetValue();
806 else
807 return -1;
808 }
809 else
810 {
811 int x, y;
812 other->GetPosition(&x, &y);
813 return y;
814 }
815 }
816 case wxRight:
817 {
818 wxLayoutConstraints *constr = other->GetConstraints();
819 // If no constraints, it means the window is not dependent
820 // on anything, and therefore we know its value immediately
821 if (constr)
822 {
823 if (constr->right.GetDone())
824 return constr->right.GetValue();
825 else
826 return -1;
827 }
828 else
829 {
830 int x, y, w, h;
831 other->GetPosition(&x, &y);
832 other->GetSize(&w, &h);
833 return (int)(x + w);
834 }
835 }
836 case wxBottom:
837 {
838 wxLayoutConstraints *constr = other->GetConstraints();
839 // If no constraints, it means the window is not dependent
840 // on anything, and therefore we know its value immediately
841 if (constr)
842 {
843 if (constr->bottom.GetDone())
844 return constr->bottom.GetValue();
845 else
846 return -1;
847 }
848 else
849 {
850 int x, y, w, h;
851 other->GetPosition(&x, &y);
852 other->GetSize(&w, &h);
853 return (int)(y + h);
854 }
855 }
856 case wxWidth:
857 {
858 wxLayoutConstraints *constr = other->GetConstraints();
859 // If no constraints, it means the window is not dependent
860 // on anything, and therefore we know its value immediately
861 if (constr)
862 {
863 if (constr->width.GetDone())
864 return constr->width.GetValue();
865 else
866 return -1;
867 }
868 else
869 {
870 int w, h;
871 other->GetSize(&w, &h);
872 return w;
873 }
874 }
875 case wxHeight:
876 {
877 wxLayoutConstraints *constr = other->GetConstraints();
878 // If no constraints, it means the window is not dependent
879 // on anything, and therefore we know its value immediately
880 if (constr)
881 {
882 if (constr->height.GetDone())
883 return constr->height.GetValue();
884 else
885 return -1;
886 }
887 else
888 {
889 int w, h;
890 other->GetSize(&w, &h);
891 return h;
892 }
893 }
894 case wxCentreX:
895 {
896 wxLayoutConstraints *constr = other->GetConstraints();
897 // If no constraints, it means the window is not dependent
898 // on anything, and therefore we know its value immediately
899 if (constr)
900 {
901 if (constr->centreX.GetDone())
902 return constr->centreX.GetValue();
903 else
904 return -1;
905 }
906 else
907 {
908 int x, y, w, h;
909 other->GetPosition(&x, &y);
910 other->GetSize(&w, &h);
911 return (int)(x + (w/2));
912 }
913 }
914 case wxCentreY:
915 {
916 wxLayoutConstraints *constr = other->GetConstraints();
917 // If no constraints, it means the window is not dependent
918 // on anything, and therefore we know its value immediately
919 if (constr)
920 {
921 if (constr->centreY.GetDone())
922 return constr->centreY.GetValue();
923 else
924 return -1;
925 }
926 else
927 {
928 int x, y, w, h;
929 other->GetPosition(&x, &y);
930 other->GetSize(&w, &h);
931 return (int)(y + (h/2));
932 }
933 }
934 default:
935 break;
936 }
937 return -1;
938 }
939
940 wxLayoutConstraints::wxLayoutConstraints()
941 {
942 left.SetEdge(wxLeft);
943 top.SetEdge(wxTop);
944 right.SetEdge(wxRight);
945 bottom.SetEdge(wxBottom);
946 centreX.SetEdge(wxCentreX);
947 centreY.SetEdge(wxCentreY);
948 width.SetEdge(wxWidth);
949 height.SetEdge(wxHeight);
950 }
951
952 wxLayoutConstraints::~wxLayoutConstraints()
953 {
954 }
955
956 bool wxLayoutConstraints::SatisfyConstraints(wxWindowBase *win, int *nChanges)
957 {
958 int noChanges = 0;
959
960 bool done = width.GetDone();
961 bool newDone = (done ? TRUE : width.SatisfyConstraint(this, win));
962 if (newDone != done)
963 noChanges ++;
964
965 done = height.GetDone();
966 newDone = (done ? TRUE : height.SatisfyConstraint(this, win));
967 if (newDone != done)
968 noChanges ++;
969
970 done = left.GetDone();
971 newDone = (done ? TRUE : left.SatisfyConstraint(this, win));
972 if (newDone != done)
973 noChanges ++;
974
975 done = top.GetDone();
976 newDone = (done ? TRUE : top.SatisfyConstraint(this, win));
977 if (newDone != done)
978 noChanges ++;
979
980 done = right.GetDone();
981 newDone = (done ? TRUE : right.SatisfyConstraint(this, win));
982 if (newDone != done)
983 noChanges ++;
984
985 done = bottom.GetDone();
986 newDone = (done ? TRUE : bottom.SatisfyConstraint(this, win));
987 if (newDone != done)
988 noChanges ++;
989
990 done = centreX.GetDone();
991 newDone = (done ? TRUE : centreX.SatisfyConstraint(this, win));
992 if (newDone != done)
993 noChanges ++;
994
995 done = centreY.GetDone();
996 newDone = (done ? TRUE : centreY.SatisfyConstraint(this, win));
997 if (newDone != done)
998 noChanges ++;
999
1000 *nChanges = noChanges;
1001
1002 return AreSatisfied();
1003 }
1004
1005 /*
1006 * Main constrained layout algorithm. Look at all the child
1007 * windows, and their constraints (if any).
1008 * The idea is to keep iterating through the constraints
1009 * until all left, right, bottom and top edges, and widths and heights,
1010 * are known (or no change occurs and we've failed to resolve all
1011 * constraints).
1012 *
1013 * If the user has not specified a dimension or edge, it will be
1014 * be calculated from the other known values. E.g. If we know
1015 * the right hand edge and the left hand edge, we now know the width.
1016 * The snag here is that this means we must specify absolute dimensions
1017 * twice (in constructor and in constraint), if we wish to use the
1018 * constraint notation to just set the position, for example.
1019 * Otherwise, if we only set ONE edge and no dimension, it would never
1020 * find the other edge.
1021 *
1022 * Algorithm:
1023
1024 Mark all constraints as not done.
1025
1026 iterations = 0;
1027 until no change or iterations >= max iterations
1028 For each child:
1029 {
1030 Calculate all constraints
1031 }
1032 iterations ++;
1033
1034 For each child
1035 Set each calculated position and size
1036
1037 */
1038
1039 #if WXWIN_COMPATIBILITY
1040 bool wxOldDoLayout(wxWindowBase *win)
1041 {
1042 // Make sure this isn't called recursively from below
1043 static wxList doneSoFar;
1044
1045 if (doneSoFar.Member(win))
1046 return TRUE;
1047
1048 doneSoFar.Append(win);
1049
1050 wxNode *node = win->GetChildren().First();
1051 while (node)
1052 {
1053 wxWindowBase *child = (wxWindowBase *)node->Data();
1054 wxLayoutConstraints *constr = child->GetConstraints();
1055 if (constr)
1056 {
1057 constr->left.SetDone(FALSE);
1058 constr->top.SetDone(FALSE);
1059 constr->right.SetDone(FALSE);
1060 constr->bottom.SetDone(FALSE);
1061 constr->width.SetDone(FALSE);
1062 constr->height.SetDone(FALSE);
1063 constr->centreX.SetDone(FALSE);
1064 constr->centreY.SetDone(FALSE);
1065 }
1066 node = node->Next();
1067 }
1068 int noIterations = 0;
1069 int maxIterations = 500;
1070 int noChanges = 1;
1071
1072 while ((noChanges > 0) && (noIterations < maxIterations))
1073 {
1074 noChanges = 0;
1075 wxNode *node = win->GetChildren().First();
1076 while (node)
1077 {
1078 wxWindowBase *child = (wxWindowBase *)node->Data();
1079 wxLayoutConstraints *constr = child->GetConstraints();
1080 if (constr)
1081 {
1082 int tempNoChanges = 0;
1083 (void)constr->SatisfyConstraints(child, &tempNoChanges);
1084 noChanges += tempNoChanges;
1085 }
1086 node = node->Next();
1087 }
1088 noIterations ++;
1089 }
1090 /*
1091 // Would be nice to have a test here to see _which_ constraint(s)
1092 // failed, so we can print a specific diagnostic message.
1093 if (noFailures > 0)
1094 {
1095 wxDebugMsg(_("wxWindowBase::Layout() failed.\n"));
1096 }
1097 */
1098 // Now set the sizes and positions of the children, and
1099 // recursively call Layout().
1100 node = win->GetChildren().First();
1101 while (node)
1102 {
1103 wxWindowBase *child = (wxWindowBase *)node->Data();
1104 wxLayoutConstraints *constr = child->GetConstraints();
1105 if (constr && constr->left.GetDone() && constr->right.GetDone() &&
1106 constr->width.GetDone() && constr->height.GetDone())
1107 {
1108 int x = constr->left.GetValue();
1109 int y = constr->top.GetValue();
1110 int w = constr->width.GetValue();
1111 int h = constr->height.GetValue();
1112
1113 // If we don't want to resize this window, just move it...
1114 if ((constr->width.GetRelationship() != wxAsIs) ||
1115 (constr->height.GetRelationship() != wxAsIs))
1116 {
1117 // _Should_ call Layout() recursively.
1118 child->SetSize(x, y, w, h);
1119 }
1120 else
1121 {
1122 child->Move(x, y);
1123 }
1124 }
1125 else
1126 child->Layout();
1127 node = node->Next();
1128 }
1129 doneSoFar.DeleteObject(win);
1130
1131 return TRUE;
1132 }
1133 #endif // WXWIN_COMPATIBILITY
1134
1135 #endif // wxUSE_CONSTRAINTS