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