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