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