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