src/common/wincmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        common/window.cpp
   3 // Purpose:     common (to all ports) wxWindow functions
   4 // Author:      Julian Smart, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     13/07/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWindows team
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "windowbase.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/string.h"
  33     #include "wx/log.h"
  34     #include "wx/intl.h"
  35     #include "wx/frame.h"
  36     #include "wx/defs.h"
  37     #include "wx/window.h"
  38     #include "wx/control.h"
  39     #include "wx/checkbox.h"
  40     #include "wx/radiobut.h"
  41     #include "wx/textctrl.h"
  42     #include "wx/settings.h"
  43     #include "wx/dialog.h"
  44     #include "wx/msgdlg.h"
  45     #include "wx/statusbr.h"
  46 #endif //WX_PRECOMP
  47
  48 #if wxUSE_CONSTRAINTS
  49     #include "wx/layout.h"
  50 #endif // wxUSE_CONSTRAINTS
  51
  52 #include "wx/sizer.h"
  53
  54 #if wxUSE_DRAG_AND_DROP
  55     #include "wx/dnd.h"
  56 #endif // wxUSE_DRAG_AND_DROP
  57
  58 #if wxUSE_HELP
  59     #include "wx/cshelp.h"
  60 #endif // wxUSE_HELP
  61
  62 #if wxUSE_TOOLTIPS
  63     #include "wx/tooltip.h"
  64 #endif // wxUSE_TOOLTIPS
  65
  66 #if wxUSE_CARET
  67     #include "wx/caret.h"
  68 #endif // wxUSE_CARET
  69
  70 // ----------------------------------------------------------------------------
  71 // static data
  72 // ----------------------------------------------------------------------------
  73
  74 int wxWindowBase::ms_lastControlId = -200;
  75
  76 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
  77
  78 // ----------------------------------------------------------------------------
  79 // event table
  80 // ----------------------------------------------------------------------------
  81
  82 BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
  83     EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
  84     EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
  85     EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
  86
  87 #if wxUSE_HELP
  88     EVT_HELP(-1, wxWindowBase::OnHelp)
  89 #endif // wxUSE_HELP
  90
  91 END_EVENT_TABLE()
  92
  93 // ============================================================================
  94 // implementation of the common functionality of the wxWindow class
  95 // ============================================================================
  96
  97 // ----------------------------------------------------------------------------
  98 // initialization
  99 // ----------------------------------------------------------------------------
 100
 101 // the default initialization
 102 void wxWindowBase::InitBase()
 103 {
 104     // no window yet, no parent nor children
 105     m_parent = (wxWindow *)NULL;
 106     m_windowId = -1;
 107     m_children.DeleteContents( FALSE ); // don't auto delete node data
 108
 109     // no constraints on the minimal window size
 110     m_minWidth =
 111     m_minHeight =
 112     m_maxWidth =
 113     m_maxHeight = -1;
 114
 115     // window is created enabled but it's not visible yet
 116     m_isShown = FALSE;
 117     m_isEnabled = TRUE;
 118
 119     // the default event handler is just this window
 120     m_eventHandler = this;
 121
 122 #if wxUSE_VALIDATORS
 123     // no validator
 124     m_windowValidator = (wxValidator *) NULL;
 125 #endif // wxUSE_VALIDATORS
 126
 127     // use the system default colours
 128     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
 129     m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
 130
 131     // don't set the font here for wxMSW as we don't call WM_SETFONT here and
 132     // so the font is *not* really set - but calls to SetFont() later won't do
 133     // anything because m_font appears to be already set!
 134 #ifndef __WXMSW__
 135     m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 136 #endif // __WXMSW__
 137
 138     // the colours/fonts are default for now
 139     m_hasBgCol =
 140     m_hasFgCol =
 141     m_hasFont = FALSE;
 142
 143     // no style bits
 144     m_exStyle =
 145     m_windowStyle = 0;
 146
 147     // an optimization for the event processing: checking this flag is much
 148     // faster than using IsKindOf(CLASSINFO(wxWindow))
 149     m_isWindow = TRUE;
 150
 151 #if wxUSE_CONSTRAINTS
 152     // no constraints whatsoever
 153     m_constraints = (wxLayoutConstraints *) NULL;
 154     m_constraintsInvolvedIn = (wxWindowList *) NULL;
 155 #endif // wxUSE_CONSTRAINTS
 156
 157     m_windowSizer = (wxSizer *) NULL;
 158     m_containingSizer = (wxSizer *) NULL;
 159     m_autoLayout = FALSE;
 160
 161 #if wxUSE_DRAG_AND_DROP
 162     m_dropTarget = (wxDropTarget *)NULL;
 163 #endif // wxUSE_DRAG_AND_DROP
 164
 165 #if wxUSE_TOOLTIPS
 166     m_tooltip = (wxToolTip *)NULL;
 167 #endif // wxUSE_TOOLTIPS
 168
 169 #if wxUSE_CARET
 170     m_caret = (wxCaret *)NULL;
 171 #endif // wxUSE_CARET
 172
 173 #if wxUSE_PALETTE
 174     m_hasCustomPalette = FALSE;
 175 #endif // wxUSE_PALETTE
 176
 177     m_virtualSize = wxDefaultSize;
 178
 179     m_minVirtualWidth =
 180     m_minVirtualHeight =
 181     m_maxVirtualWidth =
 182     m_maxVirtualHeight = -1;
 183
 184     // Whether we're using the current theme for this window (wxGTK only for now)
 185     m_themeEnabled = FALSE;
 186 }
 187
 188 // common part of window creation process
 189 bool wxWindowBase::CreateBase(wxWindowBase *parent,
 190                               wxWindowID id,
 191                               const wxPoint& WXUNUSED(pos),
 192                               const wxSize& WXUNUSED(size),
 193                               long style,
 194                               const wxValidator& validator,
 195                               const wxString& name)
 196 {
 197     // m_isWindow is set to TRUE in wxWindowBase::Init() as well as many other
 198     // member variables - check that it has been called (will catch the case
 199     // when a new ctor is added which doesn't call InitWindow)
 200     wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") );
 201
 202     // generate a new id if the user doesn't care about it
 203     m_windowId = id == -1 ? NewControlId() : id;
 204
 205     SetName(name);
 206     SetWindowStyleFlag(style);
 207     SetParent(parent);
 208
 209 #if wxUSE_VALIDATORS
 210     SetValidator(validator);
 211 #endif // wxUSE_VALIDATORS
 212
 213     // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
 214     // have it too - like this it's possible to set it only in the top level
 215     // dialog/frame and all children will inherit it by defult
 216     if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
 217     {
 218         SetExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY);
 219     }
 220
 221     return TRUE;
 222 }
 223
 224 // ----------------------------------------------------------------------------
 225 // destruction
 226 // ----------------------------------------------------------------------------
 227
 228 // common clean up
 229 wxWindowBase::~wxWindowBase()
 230 {
 231     wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
 232
 233     // FIXME if these 2 cases result from programming errors in the user code
 234     //       we should probably assert here instead of silently fixing them
 235
 236     // Just in case the window has been Closed, but we're then deleting
 237     // immediately: don't leave dangling pointers.
 238     wxPendingDelete.DeleteObject(this);
 239
 240     // Just in case we've loaded a top-level window via LoadNativeDialog but
 241     // we weren't a dialog class
 242     wxTopLevelWindows.DeleteObject(this);
 243
 244     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 245
 246 #if wxUSE_CARET
 247     if ( m_caret )
 248         delete m_caret;
 249 #endif // wxUSE_CARET
 250
 251 #if wxUSE_VALIDATORS
 252     if ( m_windowValidator )
 253         delete m_windowValidator;
 254 #endif // wxUSE_VALIDATORS
 255
 256 #if wxUSE_CONSTRAINTS
 257     // Have to delete constraints/sizer FIRST otherwise sizers may try to look
 258     // at deleted windows as they delete themselves.
 259     DeleteRelatedConstraints();
 260
 261     if ( m_constraints )
 262     {
 263         // This removes any dangling pointers to this window in other windows'
 264         // constraintsInvolvedIn lists.
 265         UnsetConstraints(m_constraints);
 266         delete m_constraints;
 267         m_constraints = NULL;
 268     }
 269
 270 #endif // wxUSE_CONSTRAINTS
 271
 272     if ( m_containingSizer )
 273         m_containingSizer->Remove((wxWindow*)this);
 274
 275     if ( m_windowSizer )
 276         delete m_windowSizer;
 277
 278 #if wxUSE_DRAG_AND_DROP
 279     if ( m_dropTarget )
 280         delete m_dropTarget;
 281 #endif // wxUSE_DRAG_AND_DROP
 282
 283 #if wxUSE_TOOLTIPS
 284     if ( m_tooltip )
 285         delete m_tooltip;
 286 #endif // wxUSE_TOOLTIPS
 287
 288     // reset the dangling pointer our parent window may keep to us
 289     if ( m_parent && m_parent->GetDefaultItem() == this )
 290     {
 291         m_parent->SetDefaultItem(NULL);
 292     }
 293 }
 294
 295 bool wxWindowBase::Destroy()
 296 {
 297     delete this;
 298
 299     return TRUE;
 300 }
 301
 302 bool wxWindowBase::Close(bool force)
 303 {
 304     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
 305     event.SetEventObject(this);
 306 #if WXWIN_COMPATIBILITY
 307     event.SetForce(force);
 308 #endif // WXWIN_COMPATIBILITY
 309     event.SetCanVeto(!force);
 310
 311     // return FALSE if window wasn't closed because the application vetoed the
 312     // close event
 313     return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
 314 }
 315
 316 bool wxWindowBase::DestroyChildren()
 317 {
 318     wxWindowList::Node *node;
 319     for ( ;; )
 320     {
 321         // we iterate until the list becomes empty
 322         node = GetChildren().GetFirst();
 323         if ( !node )
 324             break;
 325
 326         wxWindow *child = node->GetData();
 327
 328         wxASSERT_MSG( child, wxT("children list contains empty nodes") );
 329
 330         child->Show(FALSE);
 331         delete child;
 332
 333         wxASSERT_MSG( !GetChildren().Find(child),
 334                       wxT("child didn't remove itself using RemoveChild()") );
 335     }
 336
 337     return TRUE;
 338 }
 339
 340 // ----------------------------------------------------------------------------
 341 // size/position related methods
 342 // ----------------------------------------------------------------------------
 343
 344 // centre the window with respect to its parent in either (or both) directions
 345 void wxWindowBase::Centre(int direction)
 346 {
 347     // the position/size of the parent window or of the entire screen
 348     wxPoint posParent;
 349     int widthParent, heightParent;
 350
 351     wxWindow *parent = NULL;
 352
 353     if ( !(direction & wxCENTRE_ON_SCREEN) )
 354     {
 355         // find the parent to centre this window on: it should be the
 356         // immediate parent for the controls but the top level parent for the
 357         // top level windows (like dialogs)
 358         parent = GetParent();
 359         if ( IsTopLevel() )
 360         {
 361             while ( parent && !parent->IsTopLevel() )
 362             {
 363                 parent = parent->GetParent();
 364             }
 365         }
 366
 367         // there is no wxTopLevelWindow under wxMotif yet
 368 #ifndef __WXMOTIF__
 369         // we shouldn't center the dialog on the iconized window: under
 370         // Windows, for example, this places it completely off the screen
 371         if ( parent )
 372         {
 373             wxTopLevelWindow *winTop = wxDynamicCast(parent, wxTopLevelWindow);
 374             if ( winTop && winTop->IsIconized() )
 375             {
 376                 parent = NULL;
 377             }
 378         }
 379 #endif // __WXMOTIF__
 380
 381         // did we find the parent?
 382         if ( !parent )
 383         {
 384             // no other choice
 385             direction |= wxCENTRE_ON_SCREEN;
 386         }
 387     }
 388
 389     if ( direction & wxCENTRE_ON_SCREEN )
 390     {
 391         // centre with respect to the whole screen
 392         wxDisplaySize(&widthParent, &heightParent);
 393     }
 394     else
 395     {
 396         if ( IsTopLevel() )
 397         {
 398             // centre on the parent
 399             parent->GetSize(&widthParent, &heightParent);
 400
 401             // adjust to the parents position
 402             posParent = parent->GetPosition();
 403         }
 404         else
 405         {
 406             // centre inside the parents client rectangle
 407             parent->GetClientSize(&widthParent, &heightParent);
 408         }
 409     }
 410
 411     int width, height;
 412     GetSize(&width, &height);
 413
 414     int xNew = -1,
 415         yNew = -1;
 416
 417     if ( direction & wxHORIZONTAL )
 418         xNew = (widthParent - width)/2;
 419
 420     if ( direction & wxVERTICAL )
 421         yNew = (heightParent - height)/2;
 422
 423     xNew += posParent.x;
 424     yNew += posParent.y;
 425
 426     // Base size of the visible dimensions of the display
 427     // to take into account the taskbar
 428     wxRect rect = wxGetClientDisplayRect();
 429     wxSize size (rect.width,rect.height);
 430
 431     // NB: in wxMSW, negative position may not neccessary mean "out of screen",
 432     //     but it may mean that the window is placed on other than the main
 433     //     display. Therefore we only make sure centered window is on the main display
 434     //     if the parent is at least partially present here.
 435     if (posParent.x + widthParent >= 0)  // if parent is (partially) on the main display
 436     {
 437         if (xNew < 0)
 438             xNew = 0;
 439         else if (xNew+width > size.x)
 440             xNew = size.x-width-1;
 441     }
 442     if (posParent.y + heightParent >= 0)  // if parent is (partially) on the main display
 443     {
 444         if (yNew+height > size.y)
 445             yNew = size.y-height-1;
 446
 447         // Make certain that the title bar is initially visible
 448         // always, even if this would push the bottom of the
 449         // dialog of the visible area of the display
 450         if (yNew < 0)
 451             yNew = 0;
 452     }
 453
 454     // move the window to this position (keeping the old size but using
 455     // SetSize() and not Move() to allow xNew and/or yNew to be -1)
 456     SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
 457 }
 458
 459 // fits the window around the children
 460 void wxWindowBase::Fit()
 461 {
 462     if ( GetChildren().GetCount() > 0 )
 463     {
 464         SetClientSize(DoGetBestSize());
 465     }
 466     //else: do nothing if we have no children
 467 }
 468
 469 // return the size best suited for the current window
 470 wxSize wxWindowBase::DoGetBestSize() const
 471 {
 472     if ( m_windowSizer )
 473     {
 474         return m_windowSizer->GetMinSize();
 475     }
 476 #if wxUSE_CONSTRAINTS
 477     else if ( m_constraints )
 478     {
 479         wxConstCast(this, wxWindowBase)->SatisfyConstraints();
 480
 481         // our minimal acceptable size is such that all our windows fit inside
 482         int maxX = 0,
 483             maxY = 0;
 484
 485         for ( wxWindowList::Node *node = GetChildren().GetFirst();
 486               node;
 487               node = node->GetNext() )
 488         {
 489             wxLayoutConstraints *c = node->GetData()->GetConstraints();
 490             if ( !c )
 491             {
 492                 // it's not normal that we have an unconstrained child, but
 493                 // what can we do about it?
 494                 continue;
 495             }
 496
 497             int x = c->right.GetValue(),
 498                 y = c->bottom.GetValue();
 499
 500             if ( x > maxX )
 501                 maxX = x;
 502
 503             if ( y > maxY )
 504                 maxY = y;
 505
 506             // TODO: we must calculate the overlaps somehow, otherwise we
 507             //       will never return a size bigger than the current one :-(
 508         }
 509
 510         return wxSize(maxX, maxY);
 511     }
 512 #endif // wxUSE_CONSTRAINTS
 513     else if ( GetChildren().GetCount() > 0 )
 514     {
 515         // our minimal acceptable size is such that all our windows fit inside
 516         int maxX = 0,
 517             maxY = 0;
 518
 519         for ( wxWindowList::Node *node = GetChildren().GetFirst();
 520               node;
 521               node = node->GetNext() )
 522         {
 523             wxWindow *win = node->GetData();
 524             if ( win->IsTopLevel()
 525 #if wxUSE_STATUSBAR
 526                     || wxDynamicCast(win, wxStatusBar)
 527 #endif // wxUSE_STATUSBAR
 528                )
 529             {
 530                 // dialogs and frames lie in different top level windows -
 531                 // don't deal with them here; as for the status bars, they
 532                 // don't lie in the client area at all
 533                 continue;
 534             }
 535
 536             int wx, wy, ww, wh;
 537             win->GetPosition(&wx, &wy);
 538
 539             // if the window hadn't been positioned yet, assume that it is in
 540             // the origin
 541             if ( wx == -1 )
 542                 wx = 0;
 543             if ( wy == -1 )
 544                 wy = 0;
 545
 546             win->GetSize(&ww, &wh);
 547             if ( wx + ww > maxX )
 548                 maxX = wx + ww;
 549             if ( wy + wh > maxY )
 550                 maxY = wy + wh;
 551         }
 552
 553         // for compatibility with the old versions and because it really looks
 554         // slightly more pretty like this, add a pad
 555         maxX += 7;
 556         maxY += 14;
 557
 558         return wxSize(maxX, maxY);
 559     }
 560     else
 561     {
 562         // for a generic window there is no natural best size - just use the
 563         // current one
 564         return GetSize();
 565     }
 566 }
 567
 568 // by default the origin is not shifted
 569 wxPoint wxWindowBase::GetClientAreaOrigin() const
 570 {
 571     return wxPoint(0, 0);
 572 }
 573
 574 // set the min/max size of the window
 575 void wxWindowBase::SetSizeHints(int minW, int minH,
 576                                 int maxW, int maxH,
 577                                 int WXUNUSED(incW), int WXUNUSED(incH))
 578 {
 579     m_minWidth = minW;
 580     m_maxWidth = maxW;
 581     m_minHeight = minH;
 582     m_maxHeight = maxH;
 583 }
 584
 585 void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
 586                                         int maxW, int maxH )
 587 {
 588     m_minVirtualWidth = minW;
 589     m_maxVirtualWidth = maxW;
 590     m_minVirtualHeight = minH;
 591     m_maxVirtualHeight = maxH;
 592
 593     SetVirtualSize( GetClientSize() );
 594 }
 595
 596 void wxWindowBase::DoSetVirtualSize( int x, int y )
 597 {
 598     if ( m_minVirtualWidth != -1 && m_minVirtualWidth > x )
 599         x = m_minVirtualWidth;
 600     if ( m_maxVirtualWidth != -1 && m_maxVirtualWidth < x )
 601         x = m_maxVirtualWidth;
 602     if ( m_minVirtualHeight != -1 && m_minVirtualHeight > y )
 603         y = m_minVirtualHeight;
 604     if ( m_maxVirtualHeight != -1 && m_maxVirtualHeight < y )
 605         y = m_maxVirtualHeight;
 606
 607     m_virtualSize = wxSize(x, y);
 608 }
 609
 610 wxSize wxWindowBase::DoGetVirtualSize() const
 611 {
 612     wxSize  s( GetClientSize() );
 613
 614     if( m_virtualSize.GetWidth() != -1 )
 615         s.SetWidth( m_virtualSize.GetWidth() );
 616     if( m_virtualSize.GetHeight() != -1 )
 617         s.SetHeight( m_virtualSize.GetHeight() );
 618
 619     return s;
 620 }
 621
 622 // ----------------------------------------------------------------------------
 623 // show/hide/enable/disable the window
 624 // ----------------------------------------------------------------------------
 625
 626 bool wxWindowBase::Show(bool show)
 627 {
 628     if ( show != m_isShown )
 629     {
 630         m_isShown = show;
 631
 632         return TRUE;
 633     }
 634     else
 635     {
 636         return FALSE;
 637     }
 638 }
 639
 640 bool wxWindowBase::Enable(bool enable)
 641 {
 642     if ( enable != m_isEnabled )
 643     {
 644         m_isEnabled = enable;
 645
 646         return TRUE;
 647     }
 648     else
 649     {
 650         return FALSE;
 651     }
 652 }
 653 // ----------------------------------------------------------------------------
 654 // RTTI
 655 // ----------------------------------------------------------------------------
 656
 657 bool wxWindowBase::IsTopLevel() const
 658 {
 659     return FALSE;
 660 }
 661
 662 // ----------------------------------------------------------------------------
 663 // reparenting the window
 664 // ----------------------------------------------------------------------------
 665
 666 void wxWindowBase::AddChild(wxWindowBase *child)
 667 {
 668     wxCHECK_RET( child, wxT("can't add a NULL child") );
 669
 670     // this should never happen and it will lead to a crash later if it does
 671     // because RemoveChild() will remove only one node from the children list
 672     // and the other(s) one(s) will be left with dangling pointers in them
 673     wxASSERT_MSG( !GetChildren().Find(child), _T("AddChild() called twice") );
 674
 675     GetChildren().Append(child);
 676     child->SetParent(this);
 677 }
 678
 679 void wxWindowBase::RemoveChild(wxWindowBase *child)
 680 {
 681     wxCHECK_RET( child, wxT("can't remove a NULL child") );
 682
 683     GetChildren().DeleteObject(child);
 684     child->SetParent((wxWindow *)NULL);
 685 }
 686
 687 bool wxWindowBase::Reparent(wxWindowBase *newParent)
 688 {
 689     wxWindow *oldParent = GetParent();
 690     if ( newParent == oldParent )
 691     {
 692         // nothing done
 693         return FALSE;
 694     }
 695
 696     // unlink this window from the existing parent.
 697     if ( oldParent )
 698     {
 699         oldParent->RemoveChild(this);
 700     }
 701     else
 702     {
 703         wxTopLevelWindows.DeleteObject(this);
 704     }
 705
 706     // add it to the new one
 707     if ( newParent )
 708     {
 709         newParent->AddChild(this);
 710     }
 711     else
 712     {
 713         wxTopLevelWindows.Append(this);
 714     }
 715
 716     return TRUE;
 717 }
 718
 719 // ----------------------------------------------------------------------------
 720 // event handler stuff
 721 // ----------------------------------------------------------------------------
 722
 723 void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
 724 {
 725     handler->SetNextHandler(GetEventHandler());
 726     SetEventHandler(handler);
 727 }
 728
 729 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
 730 {
 731     wxEvtHandler *handlerA = GetEventHandler();
 732     if ( handlerA )
 733     {
 734         wxEvtHandler *handlerB = handlerA->GetNextHandler();
 735         handlerA->SetNextHandler((wxEvtHandler *)NULL);
 736         SetEventHandler(handlerB);
 737         if ( deleteHandler )
 738         {
 739             delete handlerA;
 740             handlerA = (wxEvtHandler *)NULL;
 741         }
 742     }
 743
 744     return handlerA;
 745 }
 746
 747 bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
 748 {
 749     wxCHECK_MSG( handler, FALSE, _T("RemoveEventHandler(NULL) called") );
 750
 751     wxEvtHandler *handlerPrev = NULL,
 752                  *handlerCur = GetEventHandler();
 753     while ( handlerCur )
 754     {
 755         wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
 756
 757         if ( handlerCur == handler )
 758         {
 759             if ( handlerPrev )
 760             {
 761                 handlerPrev->SetNextHandler(handlerNext);
 762             }
 763             else
 764             {
 765                 SetEventHandler(handlerNext);
 766             }
 767
 768             handler->SetNextHandler(NULL);
 769
 770             return TRUE;
 771         }
 772
 773         handlerPrev = handlerCur;
 774         handlerCur = handlerNext;
 775     }
 776
 777     wxFAIL_MSG( _T("where has the event handler gone?") );
 778
 779     return FALSE;
 780 }
 781
 782 // ----------------------------------------------------------------------------
 783 // cursors, fonts &c
 784 // ----------------------------------------------------------------------------
 785
 786 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
 787 {
 788     if ( !colour.Ok() || (colour == m_backgroundColour) )
 789         return FALSE;
 790
 791     m_backgroundColour = colour;
 792
 793     m_hasBgCol = TRUE;
 794
 795     return TRUE;
 796 }
 797
 798 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
 799 {
 800     if ( !colour.Ok() || (colour == m_foregroundColour) )
 801         return FALSE;
 802
 803     m_foregroundColour = colour;
 804
 805     m_hasFgCol = TRUE;
 806
 807     return TRUE;
 808 }
 809
 810 bool wxWindowBase::SetCursor(const wxCursor& cursor)
 811 {
 812     // setting an invalid cursor is ok, it means that we don't have any special
 813     // cursor
 814     if ( m_cursor == cursor )
 815     {
 816         // no change
 817         return FALSE;
 818     }
 819
 820     m_cursor = cursor;
 821
 822     return TRUE;
 823 }
 824
 825 bool wxWindowBase::SetFont(const wxFont& font)
 826 {
 827     // don't try to set invalid font, always fall back to the default
 828     const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT;
 829
 830     if ( fontOk == m_font )
 831     {
 832         // no change
 833         return FALSE;
 834     }
 835
 836     m_font = fontOk;
 837
 838     m_hasFont = TRUE;
 839
 840     return TRUE;
 841 }
 842
 843 #if wxUSE_PALETTE
 844
 845 void wxWindowBase::SetPalette(const wxPalette& pal)
 846 {
 847     m_hasCustomPalette = TRUE;
 848     m_palette = pal;
 849
 850     // VZ: can anyone explain me what do we do here?
 851     wxWindowDC d((wxWindow *) this);
 852     d.SetPalette(pal);
 853 }
 854
 855 wxWindow *wxWindowBase::GetAncestorWithCustomPalette() const
 856 {
 857     wxWindow *win = (wxWindow *)this;
 858     while ( win && !win->HasCustomPalette() )
 859     {
 860         win = win->GetParent();
 861     }
 862
 863     return win;
 864 }
 865
 866 #endif // wxUSE_PALETTE
 867
 868 #if wxUSE_CARET
 869 void wxWindowBase::SetCaret(wxCaret *caret)
 870 {
 871     if ( m_caret )
 872     {
 873         delete m_caret;
 874     }
 875
 876     m_caret = caret;
 877
 878     if ( m_caret )
 879     {
 880         wxASSERT_MSG( m_caret->GetWindow() == this,
 881                       wxT("caret should be created associated to this window") );
 882     }
 883 }
 884 #endif // wxUSE_CARET
 885
 886 #if wxUSE_VALIDATORS
 887 // ----------------------------------------------------------------------------
 888 // validators
 889 // ----------------------------------------------------------------------------
 890
 891 void wxWindowBase::SetValidator(const wxValidator& validator)
 892 {
 893     if ( m_windowValidator )
 894         delete m_windowValidator;
 895
 896     m_windowValidator = (wxValidator *)validator.Clone();
 897
 898     if ( m_windowValidator )
 899         m_windowValidator->SetWindow(this) ;
 900 }
 901 #endif // wxUSE_VALIDATORS
 902
 903 // ----------------------------------------------------------------------------
 904 // update region stuff
 905 // ----------------------------------------------------------------------------
 906
 907 wxRect wxWindowBase::GetUpdateClientRect() const
 908 {
 909     wxRegion rgnUpdate = GetUpdateRegion();
 910     rgnUpdate.Intersect(GetClientRect());
 911     wxRect rectUpdate = rgnUpdate.GetBox();
 912     wxPoint ptOrigin = GetClientAreaOrigin();
 913     rectUpdate.x -= ptOrigin.x;
 914     rectUpdate.y -= ptOrigin.y;
 915
 916     return rectUpdate;
 917 }
 918
 919 bool wxWindowBase::IsExposed(int x, int y) const
 920 {
 921     return m_updateRegion.Contains(x, y) != wxOutRegion;
 922 }
 923
 924 bool wxWindowBase::IsExposed(int x, int y, int w, int h) const
 925 {
 926     return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
 927 }
 928
 929 // ----------------------------------------------------------------------------
 930 // find child window by id or name
 931 // ----------------------------------------------------------------------------
 932
 933 wxWindow *wxWindowBase::FindWindow( long id )
 934 {
 935     if ( id == m_windowId )
 936         return (wxWindow *)this;
 937
 938     wxWindowBase *res = (wxWindow *)NULL;
 939     wxWindowList::Node *node;
 940     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
 941     {
 942         wxWindowBase *child = node->GetData();
 943         res = child->FindWindow( id );
 944     }
 945
 946     return (wxWindow *)res;
 947 }
 948
 949 wxWindow *wxWindowBase::FindWindow( const wxString& name )
 950 {
 951     if ( name == m_windowName )
 952         return (wxWindow *)this;
 953
 954     wxWindowBase *res = (wxWindow *)NULL;
 955     wxWindowList::Node *node;
 956     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
 957     {
 958         wxWindow *child = node->GetData();
 959         res = child->FindWindow(name);
 960     }
 961
 962     return (wxWindow *)res;
 963 }
 964
 965
 966 // find any window by id or name or label: If parent is non-NULL, look through
 967 // children for a label or title matching the specified string. If NULL, look
 968 // through all top-level windows.
 969 //
 970 // to avoid duplicating code we reuse the same helper function but with
 971 // different comparators
 972
 973 typedef bool (*wxFindWindowCmp)(const wxWindow *win,
 974                                 const wxString& label, long id);
 975
 976 static
 977 bool wxFindWindowCmpLabels(const wxWindow *win, const wxString& label,
 978                            long WXUNUSED(id))
 979 {
 980     return win->GetLabel() == label;
 981 }
 982
 983 static
 984 bool wxFindWindowCmpNames(const wxWindow *win, const wxString& label,
 985                           long WXUNUSED(id))
 986 {
 987     return win->GetName() == label;
 988 }
 989
 990 static
 991 bool wxFindWindowCmpIds(const wxWindow *win, const wxString& WXUNUSED(label),
 992                         long id)
 993 {
 994     return win->GetId() == id;
 995 }
 996
 997 // recursive helper for the FindWindowByXXX() functions
 998 static
 999 wxWindow *wxFindWindowRecursively(const wxWindow *parent,
1000                                   const wxString& label,
1001                                   long id,
1002                                   wxFindWindowCmp cmp)
1003 {
1004     if ( parent )
1005     {
1006         // see if this is the one we're looking for
1007         if ( (*cmp)(parent, label, id) )
1008             return (wxWindow *)parent;
1009
1010         // It wasn't, so check all its children
1011         for ( wxWindowList::Node * node = parent->GetChildren().GetFirst();
1012               node;
1013               node = node->GetNext() )
1014         {
1015             // recursively check each child
1016             wxWindow *win = (wxWindow *)node->GetData();
1017             wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1018             if (retwin)
1019                 return retwin;
1020         }
1021     }
1022
1023     // Not found
1024     return NULL;
1025 }
1026
1027 // helper for FindWindowByXXX()
1028 static
1029 wxWindow *wxFindWindowHelper(const wxWindow *parent,
1030                              const wxString& label,
1031                              long id,
1032                              wxFindWindowCmp cmp)
1033 {
1034     if ( parent )
1035     {
1036         // just check parent and all its children
1037         return wxFindWindowRecursively(parent, label, id, cmp);
1038     }
1039
1040     // start at very top of wx's windows
1041     for ( wxWindowList::Node * node = wxTopLevelWindows.GetFirst();
1042           node;
1043           node = node->GetNext() )
1044     {
1045         // recursively check each window & its children
1046         wxWindow *win = node->GetData();
1047         wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1048         if (retwin)
1049             return retwin;
1050     }
1051
1052     return NULL;
1053 }
1054
1055 /* static */
1056 wxWindow *
1057 wxWindowBase::FindWindowByLabel(const wxString& title, const wxWindow *parent)
1058 {
1059     return wxFindWindowHelper(parent, title, 0, wxFindWindowCmpLabels);
1060 }
1061
1062 /* static */
1063 wxWindow *
1064 wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent)
1065 {
1066     wxWindow *win = wxFindWindowHelper(parent, title, 0, wxFindWindowCmpNames);
1067
1068     if ( !win )
1069     {
1070         // fall back to the label
1071         win = FindWindowByLabel(title, parent);
1072     }
1073
1074     return win;
1075 }
1076
1077 /* static */
1078 wxWindow *
1079 wxWindowBase::FindWindowById( long id, const wxWindow* parent )
1080 {
1081     return wxFindWindowHelper(parent, _T(""), id, wxFindWindowCmpIds);
1082 }
1083
1084 // ----------------------------------------------------------------------------
1085 // dialog oriented functions
1086 // ----------------------------------------------------------------------------
1087
1088 void wxWindowBase::MakeModal(bool modal)
1089 {
1090     // Disable all other windows
1091     if ( IsTopLevel() )
1092     {
1093         wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
1094         while (node)
1095         {
1096             wxWindow *win = node->GetData();
1097             if (win != this)
1098                 win->Enable(!modal);
1099
1100             node = node->GetNext();
1101         }
1102     }
1103 }
1104
1105 bool wxWindowBase::Validate()
1106 {
1107 #if wxUSE_VALIDATORS
1108     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1109
1110     wxWindowList::Node *node;
1111     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1112     {
1113         wxWindowBase *child = node->GetData();
1114         wxValidator *validator = child->GetValidator();
1115         if ( validator && !validator->Validate((wxWindow *)this) )
1116         {
1117             return FALSE;
1118         }
1119
1120         if ( recurse && !child->Validate() )
1121         {
1122             return FALSE;
1123         }
1124     }
1125 #endif // wxUSE_VALIDATORS
1126
1127     return TRUE;
1128 }
1129
1130 bool wxWindowBase::TransferDataToWindow()
1131 {
1132 #if wxUSE_VALIDATORS
1133     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1134
1135     wxWindowList::Node *node;
1136     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1137     {
1138         wxWindowBase *child = node->GetData();
1139         wxValidator *validator = child->GetValidator();
1140         if ( validator && !validator->TransferToWindow() )
1141         {
1142             wxLogWarning(_("Could not transfer data to window"));
1143             wxLog::FlushActive();
1144
1145             return FALSE;
1146         }
1147
1148         if ( recurse )
1149         {
1150             if ( !child->TransferDataToWindow() )
1151             {
1152                 // warning already given
1153                 return FALSE;
1154             }
1155         }
1156     }
1157 #endif // wxUSE_VALIDATORS
1158
1159     return TRUE;
1160 }
1161
1162 bool wxWindowBase::TransferDataFromWindow()
1163 {
1164 #if wxUSE_VALIDATORS
1165     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1166
1167     wxWindowList::Node *node;
1168     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1169     {
1170         wxWindow *child = node->GetData();
1171         wxValidator *validator = child->GetValidator();
1172         if ( validator && !validator->TransferFromWindow() )
1173         {
1174             // nop warning here because the application is supposed to give
1175             // one itself - we don't know here what might have gone wrongly
1176
1177             return FALSE;
1178         }
1179
1180         if ( recurse )
1181         {
1182             if ( !child->TransferDataFromWindow() )
1183             {
1184                 // warning already given
1185                 return FALSE;
1186             }
1187         }
1188     }
1189 #endif // wxUSE_VALIDATORS
1190
1191     return TRUE;
1192 }
1193
1194 void wxWindowBase::InitDialog()
1195 {
1196     wxInitDialogEvent event(GetId());
1197     event.SetEventObject( this );
1198     GetEventHandler()->ProcessEvent(event);
1199 }
1200
1201 // ----------------------------------------------------------------------------
1202 // context-sensitive help support
1203 // ----------------------------------------------------------------------------
1204
1205 #if wxUSE_HELP
1206
1207 // associate this help text with this window
1208 void wxWindowBase::SetHelpText(const wxString& text)
1209 {
1210     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1211     if ( helpProvider )
1212     {
1213         helpProvider->AddHelp(this, text);
1214     }
1215 }
1216
1217 // associate this help text with all windows with the same id as this
1218 // one
1219 void wxWindowBase::SetHelpTextForId(const wxString& text)
1220 {
1221     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1222     if ( helpProvider )
1223     {
1224         helpProvider->AddHelp(GetId(), text);
1225     }
1226 }
1227
1228 // get the help string associated with this window (may be empty)
1229 wxString wxWindowBase::GetHelpText() const
1230 {
1231     wxString text;
1232     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1233     if ( helpProvider )
1234     {
1235         text = helpProvider->GetHelp(this);
1236     }
1237
1238     return text;
1239 }
1240
1241 // show help for this window
1242 void wxWindowBase::OnHelp(wxHelpEvent& event)
1243 {
1244     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1245     if ( helpProvider )
1246     {
1247         if ( helpProvider->ShowHelp(this) )
1248         {
1249             // skip the event.Skip() below
1250             return;
1251         }
1252     }
1253
1254     event.Skip();
1255 }
1256
1257 #endif // wxUSE_HELP
1258
1259 // ----------------------------------------------------------------------------
1260 // tooltipsroot.Replace("\\", "/");
1261 // ----------------------------------------------------------------------------
1262
1263 #if wxUSE_TOOLTIPS
1264
1265 void wxWindowBase::SetToolTip( const wxString &tip )
1266 {
1267     // don't create the new tooltip if we already have one
1268     if ( m_tooltip )
1269     {
1270         m_tooltip->SetTip( tip );
1271     }
1272     else
1273     {
1274         SetToolTip( new wxToolTip( tip ) );
1275     }
1276
1277     // setting empty tooltip text does not remove the tooltip any more - use
1278     // SetToolTip((wxToolTip *)NULL) for this
1279 }
1280
1281 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
1282 {
1283     if ( m_tooltip )
1284         delete m_tooltip;
1285
1286     m_tooltip = tooltip;
1287 }
1288
1289 #endif // wxUSE_TOOLTIPS
1290
1291 // ----------------------------------------------------------------------------
1292 // constraints and sizers
1293 // ----------------------------------------------------------------------------
1294
1295 #if wxUSE_CONSTRAINTS
1296
1297 void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
1298 {
1299     if ( m_constraints )
1300     {
1301         UnsetConstraints(m_constraints);
1302         delete m_constraints;
1303     }
1304     m_constraints = constraints;
1305     if ( m_constraints )
1306     {
1307         // Make sure other windows know they're part of a 'meaningful relationship'
1308         if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
1309             m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
1310         if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
1311             m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
1312         if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
1313             m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
1314         if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
1315             m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
1316         if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
1317             m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
1318         if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
1319             m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
1320         if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
1321             m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
1322         if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
1323             m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
1324     }
1325 }
1326
1327 // This removes any dangling pointers to this window in other windows'
1328 // constraintsInvolvedIn lists.
1329 void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
1330 {
1331     if ( c )
1332     {
1333         if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1334             c->left.GetOtherWindow()->RemoveConstraintReference(this);
1335         if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1336             c->top.GetOtherWindow()->RemoveConstraintReference(this);
1337         if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
1338             c->right.GetOtherWindow()->RemoveConstraintReference(this);
1339         if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
1340             c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
1341         if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
1342             c->width.GetOtherWindow()->RemoveConstraintReference(this);
1343         if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
1344             c->height.GetOtherWindow()->RemoveConstraintReference(this);
1345         if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
1346             c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
1347         if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
1348             c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
1349     }
1350 }
1351
1352 // Back-pointer to other windows we're involved with, so if we delete this
1353 // window, we must delete any constraints we're involved with.
1354 void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
1355 {
1356     if ( !m_constraintsInvolvedIn )
1357         m_constraintsInvolvedIn = new wxWindowList;
1358     if ( !m_constraintsInvolvedIn->Find(otherWin) )
1359         m_constraintsInvolvedIn->Append(otherWin);
1360 }
1361
1362 // REMOVE back-pointer to other windows we're involved with.
1363 void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
1364 {
1365     if ( m_constraintsInvolvedIn )
1366         m_constraintsInvolvedIn->DeleteObject(otherWin);
1367 }
1368
1369 // Reset any constraints that mention this window
1370 void wxWindowBase::DeleteRelatedConstraints()
1371 {
1372     if ( m_constraintsInvolvedIn )
1373     {
1374         wxWindowList::Node *node = m_constraintsInvolvedIn->GetFirst();
1375         while (node)
1376         {
1377             wxWindow *win = node->GetData();
1378             wxLayoutConstraints *constr = win->GetConstraints();
1379
1380             // Reset any constraints involving this window
1381             if ( constr )
1382             {
1383                 constr->left.ResetIfWin(this);
1384                 constr->top.ResetIfWin(this);
1385                 constr->right.ResetIfWin(this);
1386                 constr->bottom.ResetIfWin(this);
1387                 constr->width.ResetIfWin(this);
1388                 constr->height.ResetIfWin(this);
1389                 constr->centreX.ResetIfWin(this);
1390                 constr->centreY.ResetIfWin(this);
1391             }
1392
1393             wxWindowList::Node *next = node->GetNext();
1394             delete node;
1395             node = next;
1396         }
1397
1398         delete m_constraintsInvolvedIn;
1399         m_constraintsInvolvedIn = (wxWindowList *) NULL;
1400     }
1401 }
1402
1403 #endif // wxUSE_CONSTRAINTS
1404
1405 void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld)
1406 {
1407     if ( deleteOld )
1408         delete m_windowSizer;
1409
1410     m_windowSizer = sizer;
1411
1412     SetAutoLayout( sizer != NULL );
1413 }
1414
1415 void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld)
1416 {
1417     SetSizer( sizer, deleteOld );
1418     sizer->SetSizeHints( (wxWindow*) this );
1419 }
1420
1421 #if wxUSE_CONSTRAINTS
1422
1423 void wxWindowBase::SatisfyConstraints()
1424 {
1425     wxLayoutConstraints *constr = GetConstraints();
1426     bool wasOk = constr && constr->AreSatisfied();
1427
1428     ResetConstraints();   // Mark all constraints as unevaluated
1429
1430     int noChanges = 1;
1431
1432     // if we're a top level panel (i.e. our parent is frame/dialog), our
1433     // own constraints will never be satisfied any more unless we do it
1434     // here
1435     if ( wasOk )
1436     {
1437         while ( noChanges > 0 )
1438         {
1439             LayoutPhase1(&noChanges);
1440         }
1441     }
1442
1443     LayoutPhase2(&noChanges);
1444 }
1445
1446 #endif // wxUSE_CONSTRAINTS
1447
1448 bool wxWindowBase::Layout()
1449 {
1450     // If there is a sizer, use it instead of the constraints
1451     if ( GetSizer() )
1452     {
1453         int w, h;
1454         GetVirtualSize(&w, &h);
1455         GetSizer()->SetDimension( 0, 0, w, h );
1456     }
1457 #if wxUSE_CONSTRAINTS
1458     else
1459     {
1460         SatisfyConstraints(); // Find the right constraints values
1461         SetConstraintSizes(); // Recursively set the real window sizes
1462     }
1463 #endif
1464
1465     return TRUE;
1466 }
1467
1468 #if wxUSE_CONSTRAINTS
1469
1470 // first phase of the constraints evaluation: set our own constraints
1471 bool wxWindowBase::LayoutPhase1(int *noChanges)
1472 {
1473     wxLayoutConstraints *constr = GetConstraints();
1474
1475     return !constr || constr->SatisfyConstraints(this, noChanges);
1476 }
1477
1478 // second phase: set the constraints for our children
1479 bool wxWindowBase::LayoutPhase2(int *noChanges)
1480 {
1481     *noChanges = 0;
1482
1483     // Layout children
1484     DoPhase(1);
1485
1486     // Layout grand children
1487     DoPhase(2);
1488
1489     return TRUE;
1490 }
1491
1492 // Do a phase of evaluating child constraints
1493 bool wxWindowBase::DoPhase(int phase)
1494 {
1495     // the list containing the children for which the constraints are already
1496     // set correctly
1497     wxWindowList succeeded;
1498
1499     // the max number of iterations we loop before concluding that we can't set
1500     // the constraints
1501     static const int maxIterations = 500;
1502
1503     for ( int noIterations = 0; noIterations < maxIterations; noIterations++ )
1504     {
1505         int noChanges = 0;
1506
1507         // loop over all children setting their constraints
1508         for ( wxWindowList::Node *node = GetChildren().GetFirst();
1509               node;
1510               node = node->GetNext() )
1511         {
1512             wxWindow *child = node->GetData();
1513             if ( child->IsTopLevel() )
1514             {
1515                 // top level children are not inside our client area
1516                 continue;
1517             }
1518
1519             if ( !child->GetConstraints() || succeeded.Find(child) )
1520             {
1521                 // this one is either already ok or nothing we can do about it
1522                 continue;
1523             }
1524
1525             int tempNoChanges = 0;
1526             bool success = phase == 1 ? child->LayoutPhase1(&tempNoChanges)
1527                                       : child->LayoutPhase2(&tempNoChanges);
1528             noChanges += tempNoChanges;
1529
1530             if ( success )
1531             {
1532                 succeeded.Append(child);
1533             }
1534         }
1535
1536         if ( !noChanges )
1537         {
1538             // constraints are set
1539             break;
1540         }
1541     }
1542
1543     return TRUE;
1544 }
1545
1546 void wxWindowBase::ResetConstraints()
1547 {
1548     wxLayoutConstraints *constr = GetConstraints();
1549     if ( constr )
1550     {
1551         constr->left.SetDone(FALSE);
1552         constr->top.SetDone(FALSE);
1553         constr->right.SetDone(FALSE);
1554         constr->bottom.SetDone(FALSE);
1555         constr->width.SetDone(FALSE);
1556         constr->height.SetDone(FALSE);
1557         constr->centreX.SetDone(FALSE);
1558         constr->centreY.SetDone(FALSE);
1559     }
1560
1561     wxWindowList::Node *node = GetChildren().GetFirst();
1562     while (node)
1563     {
1564         wxWindow *win = node->GetData();
1565         if ( !win->IsTopLevel() )
1566             win->ResetConstraints();
1567         node = node->GetNext();
1568     }
1569 }
1570
1571 // Need to distinguish between setting the 'fake' size for windows and sizers,
1572 // and setting the real values.
1573 void wxWindowBase::SetConstraintSizes(bool recurse)
1574 {
1575     wxLayoutConstraints *constr = GetConstraints();
1576     if ( constr && constr->AreSatisfied() )
1577     {
1578         int x = constr->left.GetValue();
1579         int y = constr->top.GetValue();
1580         int w = constr->width.GetValue();
1581         int h = constr->height.GetValue();
1582
1583         if ( (constr->width.GetRelationship() != wxAsIs ) ||
1584              (constr->height.GetRelationship() != wxAsIs) )
1585         {
1586             SetSize(x, y, w, h);
1587         }
1588         else
1589         {
1590             // If we don't want to resize this window, just move it...
1591             Move(x, y);
1592         }
1593     }
1594     else if ( constr )
1595     {
1596         wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1597                    GetClassInfo()->GetClassName(),
1598                    GetName().c_str());
1599     }
1600
1601     if ( recurse )
1602     {
1603         wxWindowList::Node *node = GetChildren().GetFirst();
1604         while (node)
1605         {
1606             wxWindow *win = node->GetData();
1607             if ( !win->IsTopLevel() && win->GetConstraints() )
1608                 win->SetConstraintSizes();
1609             node = node->GetNext();
1610         }
1611     }
1612 }
1613
1614 // Only set the size/position of the constraint (if any)
1615 void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
1616 {
1617     wxLayoutConstraints *constr = GetConstraints();
1618     if ( constr )
1619     {
1620         if ( x != -1 )
1621         {
1622             constr->left.SetValue(x);
1623             constr->left.SetDone(TRUE);
1624         }
1625         if ( y != -1 )
1626         {
1627             constr->top.SetValue(y);
1628             constr->top.SetDone(TRUE);
1629         }
1630         if ( w != -1 )
1631         {
1632             constr->width.SetValue(w);
1633             constr->width.SetDone(TRUE);
1634         }
1635         if ( h != -1 )
1636         {
1637             constr->height.SetValue(h);
1638             constr->height.SetDone(TRUE);
1639         }
1640     }
1641 }
1642
1643 void wxWindowBase::MoveConstraint(int x, int y)
1644 {
1645     wxLayoutConstraints *constr = GetConstraints();
1646     if ( constr )
1647     {
1648         if ( x != -1 )
1649         {
1650             constr->left.SetValue(x);
1651             constr->left.SetDone(TRUE);
1652         }
1653         if ( y != -1 )
1654         {
1655             constr->top.SetValue(y);
1656             constr->top.SetDone(TRUE);
1657         }
1658     }
1659 }
1660
1661 void wxWindowBase::GetSizeConstraint(int *w, int *h) const
1662 {
1663     wxLayoutConstraints *constr = GetConstraints();
1664     if ( constr )
1665     {
1666         *w = constr->width.GetValue();
1667         *h = constr->height.GetValue();
1668     }
1669     else
1670         GetSize(w, h);
1671 }
1672
1673 void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
1674 {
1675     wxLayoutConstraints *constr = GetConstraints();
1676     if ( constr )
1677     {
1678         *w = constr->width.GetValue();
1679         *h = constr->height.GetValue();
1680     }
1681     else
1682         GetClientSize(w, h);
1683 }
1684
1685 void wxWindowBase::GetPositionConstraint(int *x, int *y) const
1686 {
1687     wxLayoutConstraints *constr = GetConstraints();
1688     if ( constr )
1689     {
1690         *x = constr->left.GetValue();
1691         *y = constr->top.GetValue();
1692     }
1693     else
1694         GetPosition(x, y);
1695 }
1696
1697 #endif // wxUSE_CONSTRAINTS
1698
1699 void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const
1700 {
1701     // don't do it for the dialogs/frames - they float independently of their
1702     // parent
1703     if ( !IsTopLevel() )
1704     {
1705         wxWindow *parent = GetParent();
1706         if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
1707         {
1708             wxPoint pt(parent->GetClientAreaOrigin());
1709             x += pt.x;
1710             y += pt.y;
1711         }
1712     }
1713 }
1714
1715 // ----------------------------------------------------------------------------
1716 // do Update UI processing for child controls
1717 // ----------------------------------------------------------------------------
1718
1719 // TODO: should this be implemented for the child window rather
1720 // than the parent? Then you can override it e.g. for wxCheckBox
1721 // to do the Right Thing rather than having to assume a fixed number
1722 // of control classes.
1723 void wxWindowBase::UpdateWindowUI()
1724 {
1725 #if wxUSE_CONTROLS
1726     wxUpdateUIEvent event(GetId());
1727     event.m_eventObject = this;
1728
1729     if ( GetEventHandler()->ProcessEvent(event) )
1730     {
1731         if ( event.GetSetEnabled() )
1732             Enable(event.GetEnabled());
1733
1734         if ( event.GetSetText() )
1735         {
1736             wxControl *control = wxDynamicCastThis(wxControl);
1737             if ( control )
1738             {
1739 #if wxUSE_TEXTCTRL
1740                 wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl);
1741                 if ( text )
1742                     text->SetValue(event.GetText());
1743                 else
1744 #endif // wxUSE_TEXTCTRL
1745                     control->SetLabel(event.GetText());
1746             }
1747         }
1748
1749 #if wxUSE_CHECKBOX
1750         wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
1751         if ( checkbox )
1752         {
1753             if ( event.GetSetChecked() )
1754                 checkbox->SetValue(event.GetChecked());
1755         }
1756 #endif // wxUSE_CHECKBOX
1757
1758 #if wxUSE_RADIOBTN
1759         wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
1760         if ( radiobtn )
1761         {
1762             if ( event.GetSetChecked() )
1763                 radiobtn->SetValue(event.GetChecked());
1764         }
1765 #endif // wxUSE_RADIOBTN
1766     }
1767 #endif // wxUSE_CONTROLS
1768 }
1769
1770 // ----------------------------------------------------------------------------
1771 // dialog units translations
1772 // ----------------------------------------------------------------------------
1773
1774 wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
1775 {
1776     int charWidth = GetCharWidth();
1777     int charHeight = GetCharHeight();
1778     wxPoint pt2(-1, -1);
1779     if (pt.x != -1)
1780         pt2.x = (int) ((pt.x * 4) / charWidth) ;
1781     if (pt.y != -1)
1782         pt2.y = (int) ((pt.y * 8) / charHeight) ;
1783
1784     return pt2;
1785 }
1786
1787 wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
1788 {
1789     int charWidth = GetCharWidth();
1790     int charHeight = GetCharHeight();
1791     wxPoint pt2(-1, -1);
1792     if (pt.x != -1)
1793         pt2.x = (int) ((pt.x * charWidth) / 4) ;
1794     if (pt.y != -1)
1795         pt2.y = (int) ((pt.y * charHeight) / 8) ;
1796
1797     return pt2;
1798 }
1799
1800 // ----------------------------------------------------------------------------
1801 // event handlers
1802 // ----------------------------------------------------------------------------
1803
1804 // propagate the colour change event to the subwindows
1805 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
1806 {
1807     wxWindowList::Node *node = GetChildren().GetFirst();
1808     while ( node )
1809     {
1810         // Only propagate to non-top-level windows
1811         wxWindow *win = node->GetData();
1812         if ( !win->IsTopLevel() )
1813         {
1814             wxSysColourChangedEvent event2;
1815             event.m_eventObject = win;
1816             win->GetEventHandler()->ProcessEvent(event2);
1817         }
1818
1819         node = node->GetNext();
1820     }
1821 }
1822
1823 // the default action is to populate dialog with data when it's created
1824 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
1825 {
1826     TransferDataToWindow();
1827 }
1828
1829 // process Ctrl-Alt-mclick
1830 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
1831 {
1832 #if wxUSE_MSGDLG
1833     if ( event.ControlDown() && event.AltDown() )
1834     {
1835         // don't translate these strings
1836         wxString port;
1837
1838 #ifdef __WXUNIVERSAL__
1839         port = _T("Univ/");
1840 #endif // __WXUNIVERSAL__
1841
1842         switch ( wxGetOsVersion() )
1843         {
1844             case wxMOTIF_X:     port = _T("Motif"); break;
1845             case wxMAC:
1846             case wxMAC_DARWIN:  port = _T("Mac"); break;
1847             case wxBEOS:        port = _T("BeOS"); break;
1848             case wxGTK:
1849             case wxGTK_WIN32:
1850             case wxGTK_OS2:
1851             case wxGTK_BEOS:    port = _T("GTK"); break;
1852             case wxWINDOWS:
1853             case wxPENWINDOWS:
1854             case wxWINDOWS_NT:
1855             case wxWIN32S:
1856             case wxWIN95:
1857             case wxWIN386:      port = _T("MS Windows"); break;
1858             case wxMGL_UNIX:
1859             case wxMGL_X:
1860             case wxMGL_WIN32:
1861             case wxMGL_OS2:     port = _T("MGL"); break;
1862             case wxWINDOWS_OS2:
1863             case wxOS2_PM:      port = _T("OS/2"); break;
1864             default:            port = _T("unknown"); break;
1865         }
1866
1867         wxMessageBox(wxString::Format(
1868                                       _T(
1869                                         "       wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n   Copyright (c) 1995-2002 wxWindows team"
1870                                         ),
1871                                       port.c_str(),
1872                                       wxMAJOR_VERSION,
1873                                       wxMINOR_VERSION,
1874                                       wxRELEASE_NUMBER,
1875 #if wxUSE_UNICODE
1876                                       L" (Unicode)",
1877 #else
1878                                       "",
1879 #endif
1880                                       __TDATE__,
1881                                       __TTIME__
1882                                      ),
1883                      _T("wxWindows information"),
1884                      wxICON_INFORMATION | wxOK,
1885                      (wxWindow *)this);
1886     }
1887     else
1888 #endif // wxUSE_MSGDLG
1889     {
1890         event.Skip();
1891     }
1892 }
1893
1894 // ----------------------------------------------------------------------------
1895 // list classes implementation
1896 // ----------------------------------------------------------------------------
1897
1898 void wxWindowListNode::DeleteData()
1899 {
1900     delete (wxWindow *)GetData();
1901 }
1902
1903 // ----------------------------------------------------------------------------
1904 // borders
1905 // ----------------------------------------------------------------------------
1906
1907 wxBorder wxWindowBase::GetBorder() const
1908 {
1909     wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK);
1910     if ( border == wxBORDER_DEFAULT )
1911     {
1912         border = GetDefaultBorder();
1913     }
1914
1915     return border;
1916 }
1917
1918 wxBorder wxWindowBase::GetDefaultBorder() const
1919 {
1920     return wxBORDER_NONE;
1921 }
1922
1923 // ----------------------------------------------------------------------------
1924 // hit testing
1925 // ----------------------------------------------------------------------------
1926
1927 wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
1928 {
1929     // here we just check if the point is inside the window or not
1930
1931     // check the top and left border first
1932     bool outside = x < 0 || y < 0;
1933     if ( !outside )
1934     {
1935         // check the right and bottom borders too
1936         wxSize size = GetSize();
1937         outside = x >= size.x || y >= size.y;
1938     }
1939
1940     return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE;
1941 }
1942
1943 // ----------------------------------------------------------------------------
1944 // mouse capture
1945 // ----------------------------------------------------------------------------
1946
1947 struct WXDLLEXPORT wxWindowNext
1948 {
1949     wxWindow *win;
1950     wxWindowNext *next;
1951 } *wxWindowBase::ms_winCaptureNext = NULL;
1952
1953 void wxWindowBase::CaptureMouse()
1954 {
1955     wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this);
1956
1957     wxWindow *winOld = GetCapture();
1958     if ( winOld )
1959     {
1960         ((wxWindowBase*) winOld)->DoReleaseMouse();
1961
1962         // save it on stack
1963         wxWindowNext *item = new wxWindowNext;
1964         item->win = winOld;
1965         item->next = ms_winCaptureNext;
1966         ms_winCaptureNext = item;
1967     }
1968     //else: no mouse capture to save
1969
1970     DoCaptureMouse();
1971 }
1972
1973 void wxWindowBase::ReleaseMouse()
1974 {
1975     wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this);
1976
1977     wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
1978
1979     DoReleaseMouse();
1980
1981     if ( ms_winCaptureNext )
1982     {
1983         ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse();
1984
1985         wxWindowNext *item = ms_winCaptureNext;
1986         ms_winCaptureNext = item->next;
1987         delete item;
1988     }
1989     //else: stack is empty, no previous capture
1990
1991     wxLogTrace(_T("mousecapture"),
1992                _T("After ReleaseMouse() mouse is captured by %p"),
1993                GetCapture());
1994 }
1995
1996 // ----------------------------------------------------------------------------
1997 // global functions
1998 // ----------------------------------------------------------------------------
1999
2000 wxWindow* wxGetTopLevelParent(wxWindow *win)
2001 {
2002     while ( win && !win->IsTopLevel() )
2003          win = win->GetParent();
2004
2005     return win;
2006 }
2007
2008 // vi:sts=4:sw=4:et