← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to src/common/layout.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/layout.cpp
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        layout.cpp
 
3
// Purpose:     Constraint layout system classes
 
4
// Author:      Julian Smart
 
5
// Modified by:
 
6
// Created:     04/01/98
 
7
// RCS-ID:      $Id: layout.cpp,v 1.30 2005/03/12 20:57:14 RD Exp $
 
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
 
 
52
inline 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
 
 
77
wxIndividualLayoutConstraint::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
 
 
89
void 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
 
 
115
void wxIndividualLayoutConstraint::LeftOf(wxWindowBase *sibling, int marg)
 
116
{
 
117
    Set(wxLeftOf, sibling, wxLeft, 0, marg);
 
118
}
 
119
 
 
120
void wxIndividualLayoutConstraint::RightOf(wxWindowBase *sibling, int marg)
 
121
{
 
122
    Set(wxRightOf, sibling, wxRight, 0, marg);
 
123
}
 
124
 
 
125
void wxIndividualLayoutConstraint::Above(wxWindowBase *sibling, int marg)
 
126
{
 
127
    Set(wxAbove, sibling, wxTop, 0, marg);
 
128
}
 
129
 
 
130
void wxIndividualLayoutConstraint::Below(wxWindowBase *sibling, int marg)
 
131
{
 
132
    Set(wxBelow, sibling, wxBottom, 0, marg);
 
133
}
 
134
 
 
135
//
 
136
// 'Same edge' alignment
 
137
//
 
138
void 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
 
144
void wxIndividualLayoutConstraint::PercentOf(wxWindowBase *otherW, wxEdge wh, int per)
 
145
{
 
146
    Set(wxPercentOf, otherW, wh, per);
 
147
}
 
148
 
 
149
//
 
150
// Edge has absolute value
 
151
//
 
152
void wxIndividualLayoutConstraint::Absolute(int val)
 
153
{
 
154
    value = val;
 
155
    relationship = wxAbsolute;
 
156
}
 
157
 
 
158
// Reset constraint if it mentions otherWin
 
159
bool 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
 
177
bool 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.
 
752
int 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
 
 
973
wxLayoutConstraints::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
 
 
985
bool 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