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