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