]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/layout.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Compile fix
[wxWidgets.git] / src / common / layout.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/common/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// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#if wxUSE_CONSTRAINTS
28
29#include "wx/layout.h"
30
31#ifndef WX_PRECOMP
32 #include "wx/window.h"
33 #include "wx/utils.h"
34 #include "wx/dialog.h"
35 #include "wx/msgdlg.h"
36 #include "wx/intl.h"
37#endif
38
39
40IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
41IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
42
43
44inline void wxGetAsIs(wxWindowBase* win, int* w, int* h)
45{
46#if 1
47 // The old way. Works for me.
48 win->GetSize(w, h);
49#endif
50
51#if 0
52 // Vadim's change. Breaks wxPython's LayoutAnchors
53 win->GetBestSize(w, h);
54#endif
55
56#if 0
57 // Proposed compromise. Doesn't work.
58 int sw, sh, bw, bh;
59 win->GetSize(&sw, &sh);
60 win->GetBestSize(&bw, &bh);
61 if (w)
62 *w = wxMax(sw, bw);
63 if (h)
64 *h = wxMax(sh, bh);
65#endif
66}
67
68
69wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
70{
71 myEdge = wxTop;
72 relationship = wxUnconstrained;
73 margin = 0;
74 value = 0;
75 percent = 0;
76 otherEdge = wxTop;
77 done = false;
78 otherWin = (wxWindowBase *) NULL;
79}
80
81void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val, int marg)
82{
83 if (rel == wxSameAs)
84 {
85 // If Set is called by the user with wxSameAs then call SameAs to do
86 // it since it will actually use wxPercent instead.
87 SameAs(otherW, otherE, marg);
88 return;
89 }
90
91 relationship = rel;
92 otherWin = otherW;
93 otherEdge = otherE;
94
95 if ( rel == wxPercentOf )
96 {
97 percent = val;
98 }
99 else
100 {
101 value = val;
102 }
103
104 margin = marg;
105}
106
107void wxIndividualLayoutConstraint::LeftOf(wxWindowBase *sibling, int marg)
108{
109 Set(wxLeftOf, sibling, wxLeft, 0, marg);
110}
111
112void wxIndividualLayoutConstraint::RightOf(wxWindowBase *sibling, int marg)
113{
114 Set(wxRightOf, sibling, wxRight, 0, marg);
115}
116
117void wxIndividualLayoutConstraint::Above(wxWindowBase *sibling, int marg)
118{
119 Set(wxAbove, sibling, wxTop, 0, marg);
120}
121
122void wxIndividualLayoutConstraint::Below(wxWindowBase *sibling, int marg)
123{
124 Set(wxBelow, sibling, wxBottom, 0, marg);
125}
126
127//
128// 'Same edge' alignment
129//
130void wxIndividualLayoutConstraint::SameAs(wxWindowBase *otherW, wxEdge edge, int marg)
131{
132 Set(wxPercentOf, otherW, edge, 100, marg);
133}
134
135// The edge is a percentage of the other window's edge
136void wxIndividualLayoutConstraint::PercentOf(wxWindowBase *otherW, wxEdge wh, int per)
137{
138 Set(wxPercentOf, otherW, wh, per);
139}
140
141//
142// Edge has absolute value
143//
144void wxIndividualLayoutConstraint::Absolute(int val)
145{
146 value = val;
147 relationship = wxAbsolute;
148}
149
150// Reset constraint if it mentions otherWin
151bool wxIndividualLayoutConstraint::ResetIfWin(wxWindowBase *otherW)
152{
153 if (otherW == otherWin)
154 {
155 myEdge = wxTop;
156 relationship = wxAsIs;
157 margin = 0;
158 value = 0;
159 percent = 0;
160 otherEdge = wxTop;
161 otherWin = (wxWindowBase *) NULL;
162 return true;
163 }
164
165 return false;
166}
167
168// Try to satisfy constraint
169bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win)
170{
171 if (relationship == wxAbsolute)
172 {
173 done = true;
174 return true;
175 }
176
177 switch (myEdge)
178 {
179 case wxLeft:
180 {
181 switch (relationship)
182 {
183 case wxLeftOf:
184 {
185 // We can know this edge if: otherWin is win's
186 // parent, or otherWin has a satisfied constraint,
187 // or otherWin has no constraint.
188 int edgePos = GetEdge(otherEdge, win, otherWin);
189 if (edgePos != -1)
190 {
191 value = edgePos - margin;
192 done = true;
193 return true;
194 }
195 else
196 return false;
197 }
198 case wxRightOf:
199 {
200 int edgePos = GetEdge(otherEdge, win, otherWin);
201 if (edgePos != -1)
202 {
203 value = edgePos + margin;
204 done = true;
205 return true;
206 }
207 else
208 return false;
209 }
210 case wxPercentOf:
211 {
212 int edgePos = GetEdge(otherEdge, win, otherWin);
213 if (edgePos != -1)
214 {
215 value = (int)(edgePos*(((float)percent)*0.01) + margin);
216 done = true;
217 return true;
218 }
219 else
220 return false;
221 }
222 case wxUnconstrained:
223 {
224 // We know the left-hand edge position if we know
225 // the right-hand edge and we know the width; OR if
226 // we know the centre and the width.
227 if (constraints->right.GetDone() && constraints->width.GetDone())
228 {
229 value = (constraints->right.GetValue() - constraints->width.GetValue() + margin);
230 done = true;
231 return true;
232 }
233 else if (constraints->centreX.GetDone() && constraints->width.GetDone())
234 {
235 value = (int)(constraints->centreX.GetValue() - (constraints->width.GetValue()/2) + margin);
236 done = true;
237 return true;
238 }
239 else
240 return false;
241 }
242 case wxAsIs:
243 {
244 int y;
245 win->GetPosition(&value, &y);
246 done = true;
247 return true;
248 }
249 default:
250 break;
251 }
252 break;
253 }
254 case wxRight:
255 {
256 switch (relationship)
257 {
258 case wxLeftOf:
259 {
260 // We can know this edge if: otherWin is win's
261 // parent, or otherWin has a satisfied constraint,
262 // or otherWin has no constraint.
263 int edgePos = GetEdge(otherEdge, win, otherWin);
264 if (edgePos != -1)
265 {
266 value = edgePos - margin;
267 done = true;
268 return true;
269 }
270 else
271 return false;
272 }
273 case wxRightOf:
274 {
275 int edgePos = GetEdge(otherEdge, win, otherWin);
276 if (edgePos != -1)
277 {
278 value = edgePos + margin;
279 done = true;
280 return true;
281 }
282 else
283 return false;
284 }
285 case wxPercentOf:
286 {
287 int edgePos = GetEdge(otherEdge, win, otherWin);
288 if (edgePos != -1)
289 {
290 value = (int)(edgePos*(((float)percent)*0.01) - margin);
291 done = true;
292 return true;
293 }
294 else
295 return false;
296 }
297 case wxUnconstrained:
298 {
299 // We know the right-hand edge position if we know the
300 // left-hand edge and we know the width, OR if we know the
301 // centre edge and the width.
302 if (constraints->left.GetDone() && constraints->width.GetDone())
303 {
304 value = (constraints->left.GetValue() + constraints->width.GetValue() - margin);
305 done = true;
306 return true;
307 }
308 else if (constraints->centreX.GetDone() && constraints->width.GetDone())
309 {
310 value = (int)(constraints->centreX.GetValue() + (constraints->width.GetValue()/2) - margin);
311 done = true;
312 return true;
313 }
314 else
315 return false;
316 }
317 case wxAsIs:
318 {
319 int x, y;
320 int w, h;
321 wxGetAsIs(win, &w, &h);
322 win->GetPosition(&x, &y);
323 value = x + w;
324 done = true;
325 return true;
326 }
327 default:
328 break;
329 }
330 break;
331 }
332 case wxTop:
333 {
334 switch (relationship)
335 {
336 case wxAbove:
337 {
338 // We can know this edge if: otherWin is win's
339 // parent, or otherWin has a satisfied constraint,
340 // or otherWin has no constraint.
341 int edgePos = GetEdge(otherEdge, win, otherWin);
342 if (edgePos != -1)
343 {
344 value = edgePos - margin;
345 done = true;
346 return true;
347 }
348 else
349 return false;
350 }
351 case wxBelow:
352 {
353 int edgePos = GetEdge(otherEdge, win, otherWin);
354 if (edgePos != -1)
355 {
356 value = edgePos + margin;
357 done = true;
358 return true;
359 }
360 else
361 return false;
362 }
363 case wxPercentOf:
364 {
365 int edgePos = GetEdge(otherEdge, win, otherWin);
366 if (edgePos != -1)
367 {
368 value = (int)(edgePos*(((float)percent)*0.01) + margin);
369 done = true;
370 return true;
371 }
372 else
373 return false;
374 }
375 case wxUnconstrained:
376 {
377 // We know the top edge position if we know the bottom edge
378 // and we know the height; OR if we know the centre edge and
379 // the height.
380 if (constraints->bottom.GetDone() && constraints->height.GetDone())
381 {
382 value = (constraints->bottom.GetValue() - constraints->height.GetValue() + margin);
383 done = true;
384 return true;
385 }
386 else if (constraints->centreY.GetDone() && constraints->height.GetDone())
387 {
388 value = (constraints->centreY.GetValue() - (constraints->height.GetValue()/2) + margin);
389 done = true;
390 return true;
391 }
392 else
393 return false;
394 }
395 case wxAsIs:
396 {
397 int x;
398 win->GetPosition(&x, &value);
399 done = true;
400 return true;
401 }
402 default:
403 break;
404 }
405 break;
406 }
407 case wxBottom:
408 {
409 switch (relationship)
410 {
411 case wxAbove:
412 {
413 // We can know this edge if: otherWin is win's parent,
414 // or otherWin has a satisfied constraint, or
415 // otherWin has no constraint.
416 int edgePos = GetEdge(otherEdge, win, otherWin);
417 if (edgePos != -1)
418 {
419 value = edgePos + margin;
420 done = true;
421 return true;
422 }
423 else
424 return false;
425 }
426 case wxBelow:
427 {
428 int edgePos = GetEdge(otherEdge, win, otherWin);
429 if (edgePos != -1)
430 {
431 value = edgePos - margin;
432 done = true;
433 return true;
434 }
435 else
436 return false;
437 }
438 case wxPercentOf:
439 {
440 int edgePos = GetEdge(otherEdge, win, otherWin);
441 if (edgePos != -1)
442 {
443 value = (int)(edgePos*(((float)percent)*0.01) - margin);
444 done = true;
445 return true;
446 }
447 else
448 return false;
449 }
450 case wxUnconstrained:
451 {
452 // We know the bottom edge position if we know the top edge
453 // and we know the height; OR if we know the centre edge and
454 // the height.
455 if (constraints->top.GetDone() && constraints->height.GetDone())
456 {
457 value = (constraints->top.GetValue() + constraints->height.GetValue() - margin);
458 done = true;
459 return true;
460 }
461 else if (constraints->centreY.GetDone() && constraints->height.GetDone())
462 {
463 value = (constraints->centreY.GetValue() + (constraints->height.GetValue()/2) - margin);
464 done = true;
465 return true;
466 }
467 else
468 return false;
469 }
470 case wxAsIs:
471 {
472 int x, y;
473 int w, h;
474 wxGetAsIs(win, &w, &h);
475 win->GetPosition(&x, &y);
476 value = h + y;
477 done = true;
478 return true;
479 }
480 default:
481 break;
482 }
483 break;
484 }
485 case wxCentreX:
486 {
487 switch (relationship)
488 {
489 case wxLeftOf:
490 {
491 // We can know this edge if: otherWin is win's parent, or
492 // otherWin has a satisfied constraint, or otherWin has no
493 // constraint.
494 int edgePos = GetEdge(otherEdge, win, otherWin);
495 if (edgePos != -1)
496 {
497 value = edgePos - margin;
498 done = true;
499 return true;
500 }
501 else
502 return false;
503 }
504 case wxRightOf:
505 {
506 int edgePos = GetEdge(otherEdge, win, otherWin);
507 if (edgePos != -1)
508 {
509 value = edgePos + margin;
510 done = true;
511 return true;
512 }
513 else
514 return false;
515 }
516 case wxPercentOf:
517 {
518 int edgePos = GetEdge(otherEdge, win, otherWin);
519 if (edgePos != -1)
520 {
521 value = (int)(edgePos*(((float)percent)*0.01) + margin);
522 done = true;
523 return true;
524 }
525 else
526 return false;
527 }
528 case wxUnconstrained:
529 {
530 // We know the centre position if we know
531 // the left-hand edge and we know the width, OR
532 // the right-hand edge and the width
533 if (constraints->left.GetDone() && constraints->width.GetDone())
534 {
535 value = (int)(constraints->left.GetValue() + (constraints->width.GetValue()/2) + margin);
536 done = true;
537 return true;
538 }
539 else if (constraints->right.GetDone() && constraints->width.GetDone())
540 {
541 value = (int)(constraints->left.GetValue() - (constraints->width.GetValue()/2) + margin);
542 done = true;
543 return true;
544 }
545 else
546 return false;
547 }
548 default:
549 break;
550 }
551 break;
552 }
553 case wxCentreY:
554 {
555 switch (relationship)
556 {
557 case wxAbove:
558 {
559 // We can know this edge if: otherWin is win's parent,
560 // or otherWin has a satisfied constraint, or otherWin
561 // has no constraint.
562 int edgePos = GetEdge(otherEdge, win, otherWin);
563 if (edgePos != -1)
564 {
565 value = edgePos - margin;
566 done = true;
567 return true;
568 }
569 else
570 return false;
571 }
572 case wxBelow:
573 {
574 int edgePos = GetEdge(otherEdge, win, otherWin);
575 if (edgePos != -1)
576 {
577 value = edgePos + margin;
578 done = true;
579 return true;
580 }
581 else
582 return false;
583 }
584 case wxPercentOf:
585 {
586 int edgePos = GetEdge(otherEdge, win, otherWin);
587 if (edgePos != -1)
588 {
589 value = (int)(edgePos*(((float)percent)*0.01) + margin);
590 done = true;
591 return true;
592 }
593 else
594 return false;
595 }
596 case wxUnconstrained:
597 {
598 // We know the centre position if we know
599 // the top edge and we know the height, OR
600 // the bottom edge and the height.
601 if (constraints->bottom.GetDone() && constraints->height.GetDone())
602 {
603 value = (int)(constraints->bottom.GetValue() - (constraints->height.GetValue()/2) + margin);
604 done = true;
605 return true;
606 }
607 else if (constraints->top.GetDone() && constraints->height.GetDone())
608 {
609 value = (int)(constraints->top.GetValue() + (constraints->height.GetValue()/2) + margin);
610 done = true;
611 return true;
612 }
613 else
614 return false;
615 }
616 default:
617 break;
618 }
619 break;
620 }
621 case wxWidth:
622 {
623 switch (relationship)
624 {
625 case wxPercentOf:
626 {
627 int edgePos = GetEdge(otherEdge, win, otherWin);
628 if (edgePos != -1)
629 {
630 value = (int)(edgePos*(((float)percent)*0.01));
631 done = true;
632 return true;
633 }
634 else
635 return false;
636 }
637 case wxAsIs:
638 {
639 if (win)
640 {
641 int h;
642 wxGetAsIs(win, &value, &h);
643 done = true;
644 return true;
645 }
646 else return false;
647 }
648 case wxUnconstrained:
649 {
650 // We know the width if we know the left edge and the right edge, OR
651 // if we know the left edge and the centre, OR
652 // if we know the right edge and the centre
653 if (constraints->left.GetDone() && constraints->right.GetDone())
654 {
655 value = constraints->right.GetValue() - constraints->left.GetValue();
656 done = true;
657 return true;
658 }
659 else if (constraints->centreX.GetDone() && constraints->left.GetDone())
660 {
661 value = (int)(2*(constraints->centreX.GetValue() - constraints->left.GetValue()));
662 done = true;
663 return true;
664 }
665 else if (constraints->centreX.GetDone() && constraints->right.GetDone())
666 {
667 value = (int)(2*(constraints->right.GetValue() - constraints->centreX.GetValue()));
668 done = true;
669 return true;
670 }
671 else
672 return false;
673 }
674 default:
675 break;
676 }
677 break;
678 }
679 case wxHeight:
680 {
681 switch (relationship)
682 {
683 case wxPercentOf:
684 {
685 int edgePos = GetEdge(otherEdge, win, otherWin);
686 if (edgePos != -1)
687 {
688 value = (int)(edgePos*(((float)percent)*0.01));
689 done = true;
690 return true;
691 }
692 else
693 return false;
694 }
695 case wxAsIs:
696 {
697 if (win)
698 {
699 int w;
700 wxGetAsIs(win, &w, &value);
701 done = true;
702 return true;
703 }
704 else return false;
705 }
706 case wxUnconstrained:
707 {
708 // We know the height if we know the top edge and the bottom edge, OR
709 // if we know the top edge and the centre, OR
710 // if we know the bottom edge and the centre
711 if (constraints->top.GetDone() && constraints->bottom.GetDone())
712 {
713 value = constraints->bottom.GetValue() - constraints->top.GetValue();
714 done = true;
715 return true;
716 }
717 else if (constraints->top.GetDone() && constraints->centreY.GetDone())
718 {
719 value = (int)(2*(constraints->centreY.GetValue() - constraints->top.GetValue()));
720 done = true;
721 return true;
722 }
723 else if (constraints->bottom.GetDone() && constraints->centreY.GetDone())
724 {
725 value = (int)(2*(constraints->bottom.GetValue() - constraints->centreY.GetValue()));
726 done = true;
727 return true;
728 }
729 else
730 return false;
731 }
732 default:
733 break;
734 }
735 break;
736 }
737 default:
738 break;
739 }
740 return false;
741}
742
743// Get the value of this edge or dimension, or if this is not determinable, -1.
744int wxIndividualLayoutConstraint::GetEdge(wxEdge which,
745 wxWindowBase *thisWin,
746 wxWindowBase *other) const
747{
748 // If the edge or dimension belongs to the parent, then we know the
749 // dimension is obtainable immediately. E.g. a wxExpandSizer may contain a
750 // button (but the button's true parent is a panel, not the sizer)
751 if (other->GetChildren().Find((wxWindow*)thisWin))
752 {
753 switch (which)
754 {
755 case wxLeft:
756 {
757 return 0;
758 }
759 case wxTop:
760 {
761 return 0;
762 }
763 case wxRight:
764 {
765 int w, h;
766 other->GetClientSizeConstraint(&w, &h);
767 return w;
768 }
769 case wxBottom:
770 {
771 int w, h;
772 other->GetClientSizeConstraint(&w, &h);
773 return h;
774 }
775 case wxWidth:
776 {
777 int w, h;
778 other->GetClientSizeConstraint(&w, &h);
779 return w;
780 }
781 case wxHeight:
782 {
783 int w, h;
784 other->GetClientSizeConstraint(&w, &h);
785 return h;
786 }
787 case wxCentreX:
788 case wxCentreY:
789 {
790 int w, h;
791 other->GetClientSizeConstraint(&w, &h);
792 if (which == wxCentreX)
793 return (int)(w/2);
794 else
795 return (int)(h/2);
796 }
797 default:
798 return -1;
799 }
800 }
801 switch (which)
802 {
803 case wxLeft:
804 {
805 wxLayoutConstraints *constr = other->GetConstraints();
806 // If no constraints, it means the window is not dependent
807 // on anything, and therefore we know its value immediately
808 if (constr)
809 {
810 if (constr->left.GetDone())
811 return constr->left.GetValue();
812 else
813 return -1;
814 }
815 else
816 {
817 int x, y;
818 other->GetPosition(&x, &y);
819 return x;
820 }
821 }
822 case wxTop:
823 {
824 wxLayoutConstraints *constr = other->GetConstraints();
825 // If no constraints, it means the window is not dependent
826 // on anything, and therefore we know its value immediately
827 if (constr)
828 {
829 if (constr->top.GetDone())
830 return constr->top.GetValue();
831 else
832 return -1;
833 }
834 else
835 {
836 int x, y;
837 other->GetPosition(&x, &y);
838 return y;
839 }
840 }
841 case wxRight:
842 {
843 wxLayoutConstraints *constr = other->GetConstraints();
844 // If no constraints, it means the window is not dependent
845 // on anything, and therefore we know its value immediately
846 if (constr)
847 {
848 if (constr->right.GetDone())
849 return constr->right.GetValue();
850 else
851 return -1;
852 }
853 else
854 {
855 int x, y, w, h;
856 other->GetPosition(&x, &y);
857 other->GetSize(&w, &h);
858 return (int)(x + w);
859 }
860 }
861 case wxBottom:
862 {
863 wxLayoutConstraints *constr = other->GetConstraints();
864 // If no constraints, it means the window is not dependent
865 // on anything, and therefore we know its value immediately
866 if (constr)
867 {
868 if (constr->bottom.GetDone())
869 return constr->bottom.GetValue();
870 else
871 return -1;
872 }
873 else
874 {
875 int x, y, w, h;
876 other->GetPosition(&x, &y);
877 other->GetSize(&w, &h);
878 return (int)(y + h);
879 }
880 }
881 case wxWidth:
882 {
883 wxLayoutConstraints *constr = other->GetConstraints();
884 // If no constraints, it means the window is not dependent
885 // on anything, and therefore we know its value immediately
886 if (constr)
887 {
888 if (constr->width.GetDone())
889 return constr->width.GetValue();
890 else
891 return -1;
892 }
893 else
894 {
895 int w, h;
896 other->GetSize(&w, &h);
897 return w;
898 }
899 }
900 case wxHeight:
901 {
902 wxLayoutConstraints *constr = other->GetConstraints();
903 // If no constraints, it means the window is not dependent
904 // on anything, and therefore we know its value immediately
905 if (constr)
906 {
907 if (constr->height.GetDone())
908 return constr->height.GetValue();
909 else
910 return -1;
911 }
912 else
913 {
914 int w, h;
915 other->GetSize(&w, &h);
916 return h;
917 }
918 }
919 case wxCentreX:
920 {
921 wxLayoutConstraints *constr = other->GetConstraints();
922 // If no constraints, it means the window is not dependent
923 // on anything, and therefore we know its value immediately
924 if (constr)
925 {
926 if (constr->centreX.GetDone())
927 return constr->centreX.GetValue();
928 else
929 return -1;
930 }
931 else
932 {
933 int x, y, w, h;
934 other->GetPosition(&x, &y);
935 other->GetSize(&w, &h);
936 return (int)(x + (w/2));
937 }
938 }
939 case wxCentreY:
940 {
941 wxLayoutConstraints *constr = other->GetConstraints();
942 // If no constraints, it means the window is not dependent
943 // on anything, and therefore we know its value immediately
944 if (constr)
945 {
946 if (constr->centreY.GetDone())
947 return constr->centreY.GetValue();
948 else
949 return -1;
950 }
951 else
952 {
953 int x, y, w, h;
954 other->GetPosition(&x, &y);
955 other->GetSize(&w, &h);
956 return (int)(y + (h/2));
957 }
958 }
959 default:
960 break;
961 }
962 return -1;
963}
964
965wxLayoutConstraints::wxLayoutConstraints()
966{
967 left.SetEdge(wxLeft);
968 top.SetEdge(wxTop);
969 right.SetEdge(wxRight);
970 bottom.SetEdge(wxBottom);
971 centreX.SetEdge(wxCentreX);
972 centreY.SetEdge(wxCentreY);
973 width.SetEdge(wxWidth);
974 height.SetEdge(wxHeight);
975}
976
977bool wxLayoutConstraints::SatisfyConstraints(wxWindowBase *win, int *nChanges)
978{
979 int noChanges = 0;
980
981 bool done = width.GetDone();
982 bool newDone = (done ? true : width.SatisfyConstraint(this, win));
983 if (newDone != done)
984 noChanges ++;
985
986 done = height.GetDone();
987 newDone = (done ? true : height.SatisfyConstraint(this, win));
988 if (newDone != done)
989 noChanges ++;
990
991 done = left.GetDone();
992 newDone = (done ? true : left.SatisfyConstraint(this, win));
993 if (newDone != done)
994 noChanges ++;
995
996 done = top.GetDone();
997 newDone = (done ? true : top.SatisfyConstraint(this, win));
998 if (newDone != done)
999 noChanges ++;
1000
1001 done = right.GetDone();
1002 newDone = (done ? true : right.SatisfyConstraint(this, win));
1003 if (newDone != done)
1004 noChanges ++;
1005
1006 done = bottom.GetDone();
1007 newDone = (done ? true : bottom.SatisfyConstraint(this, win));
1008 if (newDone != done)
1009 noChanges ++;
1010
1011 done = centreX.GetDone();
1012 newDone = (done ? true : centreX.SatisfyConstraint(this, win));
1013 if (newDone != done)
1014 noChanges ++;
1015
1016 done = centreY.GetDone();
1017 newDone = (done ? true : centreY.SatisfyConstraint(this, win));
1018 if (newDone != done)
1019 noChanges ++;
1020
1021 *nChanges = noChanges;
1022
1023 return AreSatisfied();
1024}
1025
1026#endif // wxUSE_CONSTRAINTS
wxWidgets (Impactor)