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 licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  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     #include "wx/dcclient.h"
  48 #endif //WX_PRECOMP
  49
  50 #if wxUSE_CONSTRAINTS
  51     #include "wx/layout.h"
  52 #endif // wxUSE_CONSTRAINTS
  53
  54 #include "wx/sizer.h"
  55
  56 #if wxUSE_DRAG_AND_DROP
  57     #include "wx/dnd.h"
  58 #endif // wxUSE_DRAG_AND_DROP
  59
  60 #if wxUSE_ACCESSIBILITY
  61     #include "wx/access.h"
  62 #endif
  63
  64 #if wxUSE_HELP
  65     #include "wx/cshelp.h"
  66 #endif // wxUSE_HELP
  67
  68 #if wxUSE_TOOLTIPS
  69     #include "wx/tooltip.h"
  70 #endif // wxUSE_TOOLTIPS
  71
  72 #if wxUSE_CARET
  73     #include "wx/caret.h"
  74 #endif // wxUSE_CARET
  75
  76 // ----------------------------------------------------------------------------
  77 // static data
  78 // ----------------------------------------------------------------------------
  79
  80 #if defined(__WXPM__)
  81 int wxWindowBase::ms_lastControlId = 2000;
  82 #else
  83 int wxWindowBase::ms_lastControlId = -200;
  84 #endif
  85
  86 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
  87
  88 // ----------------------------------------------------------------------------
  89 // event table
  90 // ----------------------------------------------------------------------------
  91
  92 BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
  93     EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
  94     EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
  95     EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
  96
  97 #if wxUSE_HELP
  98     EVT_HELP(-1, wxWindowBase::OnHelp)
  99 #endif // wxUSE_HELP
 100
 101 END_EVENT_TABLE()
 102
 103 // ============================================================================
 104 // implementation of the common functionality of the wxWindow class
 105 // ============================================================================
 106
 107 // ----------------------------------------------------------------------------
 108 // initialization
 109 // ----------------------------------------------------------------------------
 110
 111 // the default initialization
 112 void wxWindowBase::InitBase()
 113 {
 114     // no window yet, no parent nor children
 115     m_parent = (wxWindow *)NULL;
 116     m_windowId = -1;
 117
 118     // no constraints on the minimal window size
 119     m_minWidth =
 120     m_minHeight =
 121     m_maxWidth =
 122     m_maxHeight = -1;
 123
 124     // window is created enabled but it's not visible yet
 125     m_isShown = FALSE;
 126     m_isEnabled = TRUE;
 127
 128     // the default event handler is just this window
 129     m_eventHandler = this;
 130
 131 #if wxUSE_VALIDATORS
 132     // no validator
 133     m_windowValidator = (wxValidator *) NULL;
 134 #endif // wxUSE_VALIDATORS
 135
 136     // use the system default colours
 137     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
 138     m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
 139
 140     // don't set the font here for wxMSW as we don't call WM_SETFONT here and
 141     // so the font is *not* really set - but calls to SetFont() later won't do
 142     // anything because m_font appears to be already set!
 143 #ifndef __WXMSW__
 144     m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 145 #endif // __WXMSW__
 146
 147     // the colours/fonts are default for now
 148     m_hasBgCol =
 149     m_hasFgCol =
 150     m_hasFont = FALSE;
 151
 152     m_isBeingDeleted = FALSE;
 153
 154     // no style bits
 155     m_exStyle =
 156     m_windowStyle = 0;
 157
 158 #if wxUSE_CONSTRAINTS
 159     // no constraints whatsoever
 160     m_constraints = (wxLayoutConstraints *) NULL;
 161     m_constraintsInvolvedIn = (wxWindowList *) NULL;
 162 #endif // wxUSE_CONSTRAINTS
 163
 164     m_windowSizer = (wxSizer *) NULL;
 165     m_containingSizer = (wxSizer *) NULL;
 166     m_autoLayout = FALSE;
 167
 168 #if wxUSE_DRAG_AND_DROP
 169     m_dropTarget = (wxDropTarget *)NULL;
 170 #endif // wxUSE_DRAG_AND_DROP
 171
 172 #if wxUSE_TOOLTIPS
 173     m_tooltip = (wxToolTip *)NULL;
 174 #endif // wxUSE_TOOLTIPS
 175
 176 #if wxUSE_CARET
 177     m_caret = (wxCaret *)NULL;
 178 #endif // wxUSE_CARET
 179
 180 #if wxUSE_PALETTE
 181     m_hasCustomPalette = FALSE;
 182 #endif // wxUSE_PALETTE
 183
 184 #if wxUSE_ACCESSIBILITY
 185     m_accessible = NULL;
 186 #endif
 187
 188     m_virtualSize = wxDefaultSize;
 189
 190     m_minVirtualWidth =
 191     m_minVirtualHeight =
 192     m_maxVirtualWidth =
 193     m_maxVirtualHeight = -1;
 194
 195     // Whether we're using the current theme for this window (wxGTK only for now)
 196     m_themeEnabled = FALSE;
 197 }
 198
 199 // common part of window creation process
 200 bool wxWindowBase::CreateBase(wxWindowBase *parent,
 201                               wxWindowID id,
 202                               const wxPoint& WXUNUSED(pos),
 203                               const wxSize& WXUNUSED(size),
 204                               long style,
 205                               const wxValidator& validator,
 206                               const wxString& name)
 207 {
 208 #if wxUSE_STATBOX
 209     // wxGTK doesn't allow to create controls with static box as the parent so
 210     // this will result in a crash when the program is ported to wxGTK so warn
 211     // the user about it
 212
 213     // if you get this assert, the correct solution is to create the controls
 214     // as siblings of the static box
 215     wxASSERT_MSG( !parent || !wxDynamicCast(parent, wxStaticBox),
 216                   _T("wxStaticBox can't be used as a window parent!") );
 217 #endif // wxUSE_STATBOX
 218
 219     // ids are limited to 16 bits under MSW so if you care about portability,
 220     // it's not a good idea to use ids out of this range (and negative ids are
 221     // reserved for wxWindows own usage)
 222     wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767),
 223                   _T("invalid id value") );
 224
 225     // generate a new id if the user doesn't care about it
 226     m_windowId = id == wxID_ANY ? NewControlId() : id;
 227
 228     SetName(name);
 229     SetWindowStyleFlag(style);
 230     SetParent(parent);
 231
 232 #if wxUSE_VALIDATORS
 233     SetValidator(validator);
 234 #endif // wxUSE_VALIDATORS
 235
 236     // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
 237     // have it too - like this it's possible to set it only in the top level
 238     // dialog/frame and all children will inherit it by defult
 239     if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
 240     {
 241         SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY);
 242     }
 243
 244     return TRUE;
 245 }
 246
 247 // ----------------------------------------------------------------------------
 248 // destruction
 249 // ----------------------------------------------------------------------------
 250
 251 // common clean up
 252 wxWindowBase::~wxWindowBase()
 253 {
 254     wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
 255
 256     // FIXME if these 2 cases result from programming errors in the user code
 257     //       we should probably assert here instead of silently fixing them
 258
 259     // Just in case the window has been Closed, but we're then deleting
 260     // immediately: don't leave dangling pointers.
 261     wxPendingDelete.DeleteObject(this);
 262
 263     // Just in case we've loaded a top-level window via LoadNativeDialog but
 264     // we weren't a dialog class
 265     wxTopLevelWindows.DeleteObject((wxWindow*)this);
 266
 267     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 268
 269 #if wxUSE_CARET
 270     if ( m_caret )
 271         delete m_caret;
 272 #endif // wxUSE_CARET
 273
 274 #if wxUSE_VALIDATORS
 275     if ( m_windowValidator )
 276         delete m_windowValidator;
 277 #endif // wxUSE_VALIDATORS
 278
 279 #if wxUSE_CONSTRAINTS
 280     // Have to delete constraints/sizer FIRST otherwise sizers may try to look
 281     // at deleted windows as they delete themselves.
 282     DeleteRelatedConstraints();
 283
 284     if ( m_constraints )
 285     {
 286         // This removes any dangling pointers to this window in other windows'
 287         // constraintsInvolvedIn lists.
 288         UnsetConstraints(m_constraints);
 289         delete m_constraints;
 290         m_constraints = NULL;
 291     }
 292
 293 #endif // wxUSE_CONSTRAINTS
 294
 295     if ( m_containingSizer )
 296         m_containingSizer->Detach( (wxWindow*)this );
 297
 298     if ( m_windowSizer )
 299         delete m_windowSizer;
 300
 301 #if wxUSE_DRAG_AND_DROP
 302     if ( m_dropTarget )
 303         delete m_dropTarget;
 304 #endif // wxUSE_DRAG_AND_DROP
 305
 306 #if wxUSE_TOOLTIPS
 307     if ( m_tooltip )
 308         delete m_tooltip;
 309 #endif // wxUSE_TOOLTIPS
 310
 311 #if wxUSE_ACCESSIBILITY
 312     if ( m_accessible )
 313         delete m_accessible;
 314 #endif
 315
 316     // reset the dangling pointer our parent window may keep to us
 317     if ( m_parent && m_parent->GetDefaultItem() == this )
 318     {
 319         m_parent->SetDefaultItem(NULL);
 320     }
 321 }
 322
 323 bool wxWindowBase::Destroy()
 324 {
 325     delete this;
 326
 327     return TRUE;
 328 }
 329
 330 bool wxWindowBase::Close(bool force)
 331 {
 332     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
 333     event.SetEventObject(this);
 334 #if WXWIN_COMPATIBILITY
 335     event.SetForce(force);
 336 #endif // WXWIN_COMPATIBILITY
 337     event.SetCanVeto(!force);
 338
 339     // return FALSE if window wasn't closed because the application vetoed the
 340     // close event
 341     return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
 342 }
 343
 344 bool wxWindowBase::DestroyChildren()
 345 {
 346     wxWindowList::compatibility_iterator node;
 347     for ( ;; )
 348     {
 349         // we iterate until the list becomes empty
 350         node = GetChildren().GetFirst();
 351         if ( !node )
 352             break;
 353
 354         wxWindow *child = node->GetData();
 355
 356         wxASSERT_MSG( child, wxT("children list contains empty nodes") );
 357
 358         child->Show(FALSE);
 359         delete child;
 360
 361         wxASSERT_MSG( !GetChildren().Find(child),
 362                       wxT("child didn't remove itself using RemoveChild()") );
 363     }
 364
 365     return TRUE;
 366 }
 367
 368 // ----------------------------------------------------------------------------
 369 // size/position related methods
 370 // ----------------------------------------------------------------------------
 371
 372 // centre the window with respect to its parent in either (or both) directions
 373 void wxWindowBase::Centre(int direction)
 374 {
 375     // the position/size of the parent window or of the entire screen
 376     wxPoint posParent;
 377     int widthParent, heightParent;
 378
 379     wxWindow *parent = NULL;
 380
 381     if ( !(direction & wxCENTRE_ON_SCREEN) )
 382     {
 383         // find the parent to centre this window on: it should be the
 384         // immediate parent for the controls but the top level parent for the
 385         // top level windows (like dialogs)
 386         parent = GetParent();
 387         if ( IsTopLevel() )
 388         {
 389             while ( parent && !parent->IsTopLevel() )
 390             {
 391                 parent = parent->GetParent();
 392             }
 393         }
 394
 395         // there is no wxTopLevelWindow under wxMotif yet
 396 #ifndef __WXMOTIF__
 397         // we shouldn't center the dialog on the iconized window: under
 398         // Windows, for example, this places it completely off the screen
 399         if ( parent )
 400         {
 401             wxTopLevelWindow *winTop = wxDynamicCast(parent, wxTopLevelWindow);
 402             if ( winTop && winTop->IsIconized() )
 403             {
 404                 parent = NULL;
 405             }
 406         }
 407 #endif // __WXMOTIF__
 408
 409         // did we find the parent?
 410         if ( !parent )
 411         {
 412             // no other choice
 413             direction |= wxCENTRE_ON_SCREEN;
 414         }
 415     }
 416
 417     if ( direction & wxCENTRE_ON_SCREEN )
 418     {
 419         // centre with respect to the whole screen
 420         wxDisplaySize(&widthParent, &heightParent);
 421     }
 422     else
 423     {
 424         if ( IsTopLevel() )
 425         {
 426             // centre on the parent
 427             parent->GetSize(&widthParent, &heightParent);
 428
 429             // adjust to the parents position
 430             posParent = parent->GetPosition();
 431         }
 432         else
 433         {
 434             // centre inside the parents client rectangle
 435             parent->GetClientSize(&widthParent, &heightParent);
 436         }
 437     }
 438
 439     int width, height;
 440     GetSize(&width, &height);
 441
 442     int xNew = -1,
 443         yNew = -1;
 444
 445     if ( direction & wxHORIZONTAL )
 446         xNew = (widthParent - width)/2;
 447
 448     if ( direction & wxVERTICAL )
 449         yNew = (heightParent - height)/2;
 450
 451     xNew += posParent.x;
 452     yNew += posParent.y;
 453
 454     // Base size of the visible dimensions of the display
 455     // to take into account the taskbar
 456     wxRect rect = wxGetClientDisplayRect();
 457     wxSize size (rect.width,rect.height);
 458
 459     // NB: in wxMSW, negative position may not neccessary mean "out of screen",
 460     //     but it may mean that the window is placed on other than the main
 461     //     display. Therefore we only make sure centered window is on the main display
 462     //     if the parent is at least partially present here.
 463     if (posParent.x + widthParent >= 0)  // if parent is (partially) on the main display
 464     {
 465         if (xNew < 0)
 466             xNew = 0;
 467         else if (xNew+width > size.x)
 468             xNew = size.x-width-1;
 469     }
 470     if (posParent.y + heightParent >= 0)  // if parent is (partially) on the main display
 471     {
 472         if (yNew+height > size.y)
 473             yNew = size.y-height-1;
 474
 475         // Make certain that the title bar is initially visible
 476         // always, even if this would push the bottom of the
 477         // dialog of the visible area of the display
 478         if (yNew < 0)
 479             yNew = 0;
 480     }
 481
 482     // move the window to this position (keeping the old size but using
 483     // SetSize() and not Move() to allow xNew and/or yNew to be -1)
 484     SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
 485 }
 486
 487 // fits the window around the children
 488 void wxWindowBase::Fit()
 489 {
 490     if ( GetChildren().GetCount() > 0 )
 491     {
 492         SetClientSize(DoGetBestSize());
 493     }
 494     //else: do nothing if we have no children
 495 }
 496
 497 // fits virtual size (ie. scrolled area etc.) around children
 498 void wxWindowBase::FitInside()
 499 {
 500     if ( GetChildren().GetCount() > 0 )
 501     {
 502         SetVirtualSize( GetBestVirtualSize() );
 503     }
 504 }
 505
 506 // return the size best suited for the current window
 507 wxSize wxWindowBase::DoGetBestSize() const
 508 {
 509     if ( m_windowSizer )
 510     {
 511         return m_windowSizer->GetMinSize();
 512     }
 513 #if wxUSE_CONSTRAINTS
 514     else if ( m_constraints )
 515     {
 516         wxConstCast(this, wxWindowBase)->SatisfyConstraints();
 517
 518         // our minimal acceptable size is such that all our windows fit inside
 519         int maxX = 0,
 520             maxY = 0;
 521
 522         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 523               node;
 524               node = node->GetNext() )
 525         {
 526             wxLayoutConstraints *c = node->GetData()->GetConstraints();
 527             if ( !c )
 528             {
 529                 // it's not normal that we have an unconstrained child, but
 530                 // what can we do about it?
 531                 continue;
 532             }
 533
 534             int x = c->right.GetValue(),
 535                 y = c->bottom.GetValue();
 536
 537             if ( x > maxX )
 538                 maxX = x;
 539
 540             if ( y > maxY )
 541                 maxY = y;
 542
 543             // TODO: we must calculate the overlaps somehow, otherwise we
 544             //       will never return a size bigger than the current one :-(
 545         }
 546
 547         return wxSize(maxX, maxY);
 548     }
 549 #endif // wxUSE_CONSTRAINTS
 550     else if ( GetChildren().GetCount() > 0 )
 551     {
 552         // our minimal acceptable size is such that all our windows fit inside
 553         int maxX = 0,
 554             maxY = 0;
 555
 556         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 557               node;
 558               node = node->GetNext() )
 559         {
 560             wxWindow *win = node->GetData();
 561             if ( win->IsTopLevel()
 562 #if wxUSE_STATUSBAR
 563                     || wxDynamicCast(win, wxStatusBar)
 564 #endif // wxUSE_STATUSBAR
 565                )
 566             {
 567                 // dialogs and frames lie in different top level windows -
 568                 // don't deal with them here; as for the status bars, they
 569                 // don't lie in the client area at all
 570                 continue;
 571             }
 572
 573             int wx, wy, ww, wh;
 574             win->GetPosition(&wx, &wy);
 575
 576             // if the window hadn't been positioned yet, assume that it is in
 577             // the origin
 578             if ( wx == -1 )
 579                 wx = 0;
 580             if ( wy == -1 )
 581                 wy = 0;
 582
 583             win->GetSize(&ww, &wh);
 584             if ( wx + ww > maxX )
 585                 maxX = wx + ww;
 586             if ( wy + wh > maxY )
 587                 maxY = wy + wh;
 588         }
 589
 590         // for compatibility with the old versions and because it really looks
 591         // slightly more pretty like this, add a pad
 592         maxX += 7;
 593         maxY += 14;
 594
 595         return wxSize(maxX, maxY);
 596     }
 597     else
 598     {
 599         // for a generic window there is no natural best size - just use the
 600         // current one
 601         return GetSize();
 602     }
 603 }
 604
 605 // by default the origin is not shifted
 606 wxPoint wxWindowBase::GetClientAreaOrigin() const
 607 {
 608     return wxPoint(0, 0);
 609 }
 610
 611 // set the min/max size of the window
 612 void wxWindowBase::SetSizeHints(int minW, int minH,
 613                                 int maxW, int maxH,
 614                                 int WXUNUSED(incW), int WXUNUSED(incH))
 615 {
 616     // setting min width greater than max width leads to infinite loops under
 617     // X11 and generally doesn't make any sense, so don't allow it
 618     wxCHECK_RET( (minW == -1 || maxW == -1 || minW <= maxW) &&
 619                     (minH == -1 || maxH == -1 || minH <= maxH),
 620                  _T("min width/height must be less than max width/height!") );
 621
 622     m_minWidth = minW;
 623     m_maxWidth = maxW;
 624     m_minHeight = minH;
 625     m_maxHeight = maxH;
 626 }
 627
 628 void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
 629                                         int maxW, int maxH )
 630 {
 631     m_minVirtualWidth = minW;
 632     m_maxVirtualWidth = maxW;
 633     m_minVirtualHeight = minH;
 634     m_maxVirtualHeight = maxH;
 635 }
 636
 637 void wxWindowBase::DoSetVirtualSize( int x, int y )
 638 {
 639     if ( m_minVirtualWidth != -1 && m_minVirtualWidth > x )
 640         x = m_minVirtualWidth;
 641     if ( m_maxVirtualWidth != -1 && m_maxVirtualWidth < x )
 642         x = m_maxVirtualWidth;
 643     if ( m_minVirtualHeight != -1 && m_minVirtualHeight > y )
 644         y = m_minVirtualHeight;
 645     if ( m_maxVirtualHeight != -1 && m_maxVirtualHeight < y )
 646         y = m_maxVirtualHeight;
 647
 648     m_virtualSize = wxSize(x, y);
 649 }
 650
 651 wxSize wxWindowBase::DoGetVirtualSize() const
 652 {
 653     wxSize  s( GetClientSize() );
 654
 655     return wxSize( wxMax( m_virtualSize.GetWidth(), s.GetWidth() ),
 656                    wxMax( m_virtualSize.GetHeight(), s.GetHeight() ) );
 657 }
 658
 659 // ----------------------------------------------------------------------------
 660 // show/hide/enable/disable the window
 661 // ----------------------------------------------------------------------------
 662
 663 bool wxWindowBase::Show(bool show)
 664 {
 665     if ( show != m_isShown )
 666     {
 667         m_isShown = show;
 668
 669         return TRUE;
 670     }
 671     else
 672     {
 673         return FALSE;
 674     }
 675 }
 676
 677 bool wxWindowBase::Enable(bool enable)
 678 {
 679     if ( enable != m_isEnabled )
 680     {
 681         m_isEnabled = enable;
 682
 683         return TRUE;
 684     }
 685     else
 686     {
 687         return FALSE;
 688     }
 689 }
 690 // ----------------------------------------------------------------------------
 691 // RTTI
 692 // ----------------------------------------------------------------------------
 693
 694 bool wxWindowBase::IsTopLevel() const
 695 {
 696     return FALSE;
 697 }
 698
 699 // ----------------------------------------------------------------------------
 700 // reparenting the window
 701 // ----------------------------------------------------------------------------
 702
 703 void wxWindowBase::AddChild(wxWindowBase *child)
 704 {
 705     wxCHECK_RET( child, wxT("can't add a NULL child") );
 706
 707     // this should never happen and it will lead to a crash later if it does
 708     // because RemoveChild() will remove only one node from the children list
 709     // and the other(s) one(s) will be left with dangling pointers in them
 710     wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), _T("AddChild() called twice") );
 711
 712     GetChildren().Append((wxWindow*)child);
 713     child->SetParent(this);
 714 }
 715
 716 void wxWindowBase::RemoveChild(wxWindowBase *child)
 717 {
 718     wxCHECK_RET( child, wxT("can't remove a NULL child") );
 719
 720     GetChildren().DeleteObject((wxWindow *)child);
 721     child->SetParent(NULL);
 722 }
 723
 724 bool wxWindowBase::Reparent(wxWindowBase *newParent)
 725 {
 726     wxWindow *oldParent = GetParent();
 727     if ( newParent == oldParent )
 728     {
 729         // nothing done
 730         return FALSE;
 731     }
 732
 733     // unlink this window from the existing parent.
 734     if ( oldParent )
 735     {
 736         oldParent->RemoveChild(this);
 737     }
 738     else
 739     {
 740         wxTopLevelWindows.DeleteObject((wxWindow *)this);
 741     }
 742
 743     // add it to the new one
 744     if ( newParent )
 745     {
 746         newParent->AddChild(this);
 747     }
 748     else
 749     {
 750         wxTopLevelWindows.Append((wxWindow *)this);
 751     }
 752
 753     return TRUE;
 754 }
 755
 756 // ----------------------------------------------------------------------------
 757 // event handler stuff
 758 // ----------------------------------------------------------------------------
 759
 760 void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
 761 {
 762     wxEvtHandler *handlerOld = GetEventHandler();
 763
 764     handler->SetNextHandler(handlerOld);
 765
 766     if ( handlerOld )
 767         GetEventHandler()->SetPreviousHandler(handler);
 768
 769     SetEventHandler(handler);
 770 }
 771
 772 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
 773 {
 774     wxEvtHandler *handlerA = GetEventHandler();
 775     if ( handlerA )
 776     {
 777         wxEvtHandler *handlerB = handlerA->GetNextHandler();
 778         handlerA->SetNextHandler((wxEvtHandler *)NULL);
 779
 780         if ( handlerB )
 781             handlerB->SetPreviousHandler((wxEvtHandler *)NULL);
 782         SetEventHandler(handlerB);
 783
 784         if ( deleteHandler )
 785         {
 786             delete handlerA;
 787             handlerA = (wxEvtHandler *)NULL;
 788         }
 789     }
 790
 791     return handlerA;
 792 }
 793
 794 bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
 795 {
 796     wxCHECK_MSG( handler, FALSE, _T("RemoveEventHandler(NULL) called") );
 797
 798     wxEvtHandler *handlerPrev = NULL,
 799                  *handlerCur = GetEventHandler();
 800     while ( handlerCur )
 801     {
 802         wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
 803
 804         if ( handlerCur == handler )
 805         {
 806             if ( handlerPrev )
 807             {
 808                 handlerPrev->SetNextHandler(handlerNext);
 809             }
 810             else
 811             {
 812                 SetEventHandler(handlerNext);
 813             }
 814
 815             if ( handlerNext )
 816             {
 817                 handlerNext->SetPreviousHandler ( handlerPrev );
 818             }
 819             handler->SetNextHandler(NULL);
 820
 821             return TRUE;
 822         }
 823
 824         handlerPrev = handlerCur;
 825         handlerCur = handlerNext;
 826     }
 827
 828     wxFAIL_MSG( _T("where has the event handler gone?") );
 829
 830     return FALSE;
 831 }
 832
 833 // ----------------------------------------------------------------------------
 834 // cursors, fonts &c
 835 // ----------------------------------------------------------------------------
 836
 837 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
 838 {
 839     if ( !colour.Ok() || (colour == m_backgroundColour) )
 840         return FALSE;
 841
 842     m_backgroundColour = colour;
 843
 844     m_hasBgCol = TRUE;
 845
 846     return TRUE;
 847 }
 848
 849 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
 850 {
 851     if ( !colour.Ok() || (colour == m_foregroundColour) )
 852         return FALSE;
 853
 854     m_foregroundColour = colour;
 855
 856     m_hasFgCol = TRUE;
 857
 858     return TRUE;
 859 }
 860
 861 bool wxWindowBase::SetCursor(const wxCursor& cursor)
 862 {
 863     // setting an invalid cursor is ok, it means that we don't have any special
 864     // cursor
 865     if ( m_cursor == cursor )
 866     {
 867         // no change
 868         return FALSE;
 869     }
 870
 871     m_cursor = cursor;
 872
 873     return TRUE;
 874 }
 875
 876 bool wxWindowBase::SetFont(const wxFont& font)
 877 {
 878     // don't try to set invalid font, always fall back to the default
 879     const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT;
 880
 881     if ( fontOk == m_font )
 882     {
 883         // no change
 884         return FALSE;
 885     }
 886
 887     m_font = fontOk;
 888
 889     m_hasFont = TRUE;
 890
 891     return TRUE;
 892 }
 893
 894 #if wxUSE_PALETTE
 895
 896 void wxWindowBase::SetPalette(const wxPalette& pal)
 897 {
 898     m_hasCustomPalette = TRUE;
 899     m_palette = pal;
 900
 901     // VZ: can anyone explain me what do we do here?
 902     wxWindowDC d((wxWindow *) this);
 903     d.SetPalette(pal);
 904 }
 905
 906 wxWindow *wxWindowBase::GetAncestorWithCustomPalette() const
 907 {
 908     wxWindow *win = (wxWindow *)this;
 909     while ( win && !win->HasCustomPalette() )
 910     {
 911         win = win->GetParent();
 912     }
 913
 914     return win;
 915 }
 916
 917 #endif // wxUSE_PALETTE
 918
 919 #if wxUSE_CARET
 920 void wxWindowBase::SetCaret(wxCaret *caret)
 921 {
 922     if ( m_caret )
 923     {
 924         delete m_caret;
 925     }
 926
 927     m_caret = caret;
 928
 929     if ( m_caret )
 930     {
 931         wxASSERT_MSG( m_caret->GetWindow() == this,
 932                       wxT("caret should be created associated to this window") );
 933     }
 934 }
 935 #endif // wxUSE_CARET
 936
 937 #if wxUSE_VALIDATORS
 938 // ----------------------------------------------------------------------------
 939 // validators
 940 // ----------------------------------------------------------------------------
 941
 942 void wxWindowBase::SetValidator(const wxValidator& validator)
 943 {
 944     if ( m_windowValidator )
 945         delete m_windowValidator;
 946
 947     m_windowValidator = (wxValidator *)validator.Clone();
 948
 949     if ( m_windowValidator )
 950         m_windowValidator->SetWindow(this) ;
 951 }
 952 #endif // wxUSE_VALIDATORS
 953
 954 // ----------------------------------------------------------------------------
 955 // update region stuff
 956 // ----------------------------------------------------------------------------
 957
 958 wxRect wxWindowBase::GetUpdateClientRect() const
 959 {
 960     wxRegion rgnUpdate = GetUpdateRegion();
 961     rgnUpdate.Intersect(GetClientRect());
 962     wxRect rectUpdate = rgnUpdate.GetBox();
 963     wxPoint ptOrigin = GetClientAreaOrigin();
 964     rectUpdate.x -= ptOrigin.x;
 965     rectUpdate.y -= ptOrigin.y;
 966
 967     return rectUpdate;
 968 }
 969
 970 bool wxWindowBase::IsExposed(int x, int y) const
 971 {
 972     return m_updateRegion.Contains(x, y) != wxOutRegion;
 973 }
 974
 975 bool wxWindowBase::IsExposed(int x, int y, int w, int h) const
 976 {
 977     return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
 978 }
 979
 980 void wxWindowBase::ClearBackground()
 981 {
 982     // wxGTK uses its own version, no need to add never used code
 983 #ifndef __WXGTK__
 984     wxClientDC dc((wxWindow *)this);
 985     wxBrush brush(GetBackgroundColour(), wxSOLID);
 986     dc.SetBackground(brush);
 987     dc.Clear();
 988 #endif // __WXGTK__
 989 }
 990
 991 // ----------------------------------------------------------------------------
 992 // find child window by id or name
 993 // ----------------------------------------------------------------------------
 994
 995 wxWindow *wxWindowBase::FindWindow( long id )
 996 {
 997     if ( id == m_windowId )
 998         return (wxWindow *)this;
 999
1000     wxWindowBase *res = (wxWindow *)NULL;
1001     wxWindowList::compatibility_iterator node;
1002     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
1003     {
1004         wxWindowBase *child = node->GetData();
1005         res = child->FindWindow( id );
1006     }
1007
1008     return (wxWindow *)res;
1009 }
1010
1011 wxWindow *wxWindowBase::FindWindow( const wxString& name )
1012 {
1013     if ( name == m_windowName )
1014         return (wxWindow *)this;
1015
1016     wxWindowBase *res = (wxWindow *)NULL;
1017     wxWindowList::compatibility_iterator node;
1018     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
1019     {
1020         wxWindow *child = node->GetData();
1021         res = child->FindWindow(name);
1022     }
1023
1024     return (wxWindow *)res;
1025 }
1026
1027
1028 // find any window by id or name or label: If parent is non-NULL, look through
1029 // children for a label or title matching the specified string. If NULL, look
1030 // through all top-level windows.
1031 //
1032 // to avoid duplicating code we reuse the same helper function but with
1033 // different comparators
1034
1035 typedef bool (*wxFindWindowCmp)(const wxWindow *win,
1036                                 const wxString& label, long id);
1037
1038 static
1039 bool wxFindWindowCmpLabels(const wxWindow *win, const wxString& label,
1040                            long WXUNUSED(id))
1041 {
1042     return win->GetLabel() == label;
1043 }
1044
1045 static
1046 bool wxFindWindowCmpNames(const wxWindow *win, const wxString& label,
1047                           long WXUNUSED(id))
1048 {
1049     return win->GetName() == label;
1050 }
1051
1052 static
1053 bool wxFindWindowCmpIds(const wxWindow *win, const wxString& WXUNUSED(label),
1054                         long id)
1055 {
1056     return win->GetId() == id;
1057 }
1058
1059 // recursive helper for the FindWindowByXXX() functions
1060 static
1061 wxWindow *wxFindWindowRecursively(const wxWindow *parent,
1062                                   const wxString& label,
1063                                   long id,
1064                                   wxFindWindowCmp cmp)
1065 {
1066     if ( parent )
1067     {
1068         // see if this is the one we're looking for
1069         if ( (*cmp)(parent, label, id) )
1070             return (wxWindow *)parent;
1071
1072         // It wasn't, so check all its children
1073         for ( wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();
1074               node;
1075               node = node->GetNext() )
1076         {
1077             // recursively check each child
1078             wxWindow *win = (wxWindow *)node->GetData();
1079             wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1080             if (retwin)
1081                 return retwin;
1082         }
1083     }
1084
1085     // Not found
1086     return NULL;
1087 }
1088
1089 // helper for FindWindowByXXX()
1090 static
1091 wxWindow *wxFindWindowHelper(const wxWindow *parent,
1092                              const wxString& label,
1093                              long id,
1094                              wxFindWindowCmp cmp)
1095 {
1096     if ( parent )
1097     {
1098         // just check parent and all its children
1099         return wxFindWindowRecursively(parent, label, id, cmp);
1100     }
1101
1102     // start at very top of wx's windows
1103     for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
1104           node;
1105           node = node->GetNext() )
1106     {
1107         // recursively check each window & its children
1108         wxWindow *win = node->GetData();
1109         wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1110         if (retwin)
1111             return retwin;
1112     }
1113
1114     return NULL;
1115 }
1116
1117 /* static */
1118 wxWindow *
1119 wxWindowBase::FindWindowByLabel(const wxString& title, const wxWindow *parent)
1120 {
1121     return wxFindWindowHelper(parent, title, 0, wxFindWindowCmpLabels);
1122 }
1123
1124 /* static */
1125 wxWindow *
1126 wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent)
1127 {
1128     wxWindow *win = wxFindWindowHelper(parent, title, 0, wxFindWindowCmpNames);
1129
1130     if ( !win )
1131     {
1132         // fall back to the label
1133         win = FindWindowByLabel(title, parent);
1134     }
1135
1136     return win;
1137 }
1138
1139 /* static */
1140 wxWindow *
1141 wxWindowBase::FindWindowById( long id, const wxWindow* parent )
1142 {
1143     return wxFindWindowHelper(parent, _T(""), id, wxFindWindowCmpIds);
1144 }
1145
1146 // ----------------------------------------------------------------------------
1147 // dialog oriented functions
1148 // ----------------------------------------------------------------------------
1149
1150 void wxWindowBase::MakeModal(bool modal)
1151 {
1152     // Disable all other windows
1153     if ( IsTopLevel() )
1154     {
1155         wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
1156         while (node)
1157         {
1158             wxWindow *win = node->GetData();
1159             if (win != this)
1160                 win->Enable(!modal);
1161
1162             node = node->GetNext();
1163         }
1164     }
1165 }
1166
1167 bool wxWindowBase::Validate()
1168 {
1169 #if wxUSE_VALIDATORS
1170     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1171
1172     wxWindowList::compatibility_iterator 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->Validate((wxWindow *)this) )
1178         {
1179             return FALSE;
1180         }
1181
1182         if ( recurse && !child->Validate() )
1183         {
1184             return FALSE;
1185         }
1186     }
1187 #endif // wxUSE_VALIDATORS
1188
1189     return TRUE;
1190 }
1191
1192 bool wxWindowBase::TransferDataToWindow()
1193 {
1194 #if wxUSE_VALIDATORS
1195     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1196
1197     wxWindowList::compatibility_iterator node;
1198     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1199     {
1200         wxWindowBase *child = node->GetData();
1201         wxValidator *validator = child->GetValidator();
1202         if ( validator && !validator->TransferToWindow() )
1203         {
1204             wxLogWarning(_("Could not transfer data to window"));
1205 #if wxUSE_LOG
1206             wxLog::FlushActive();
1207 #endif // wxUSE_LOG
1208
1209             return FALSE;
1210         }
1211
1212         if ( recurse )
1213         {
1214             if ( !child->TransferDataToWindow() )
1215             {
1216                 // warning already given
1217                 return FALSE;
1218             }
1219         }
1220     }
1221 #endif // wxUSE_VALIDATORS
1222
1223     return TRUE;
1224 }
1225
1226 bool wxWindowBase::TransferDataFromWindow()
1227 {
1228 #if wxUSE_VALIDATORS
1229     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1230
1231     wxWindowList::compatibility_iterator node;
1232     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1233     {
1234         wxWindow *child = node->GetData();
1235         wxValidator *validator = child->GetValidator();
1236         if ( validator && !validator->TransferFromWindow() )
1237         {
1238             // nop warning here because the application is supposed to give
1239             // one itself - we don't know here what might have gone wrongly
1240
1241             return FALSE;
1242         }
1243
1244         if ( recurse )
1245         {
1246             if ( !child->TransferDataFromWindow() )
1247             {
1248                 // warning already given
1249                 return FALSE;
1250             }
1251         }
1252     }
1253 #endif // wxUSE_VALIDATORS
1254
1255     return TRUE;
1256 }
1257
1258 void wxWindowBase::InitDialog()
1259 {
1260     wxInitDialogEvent event(GetId());
1261     event.SetEventObject( this );
1262     GetEventHandler()->ProcessEvent(event);
1263 }
1264
1265 // ----------------------------------------------------------------------------
1266 // context-sensitive help support
1267 // ----------------------------------------------------------------------------
1268
1269 #if wxUSE_HELP
1270
1271 // associate this help text with this window
1272 void wxWindowBase::SetHelpText(const wxString& text)
1273 {
1274     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1275     if ( helpProvider )
1276     {
1277         helpProvider->AddHelp(this, text);
1278     }
1279 }
1280
1281 // associate this help text with all windows with the same id as this
1282 // one
1283 void wxWindowBase::SetHelpTextForId(const wxString& text)
1284 {
1285     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1286     if ( helpProvider )
1287     {
1288         helpProvider->AddHelp(GetId(), text);
1289     }
1290 }
1291
1292 // get the help string associated with this window (may be empty)
1293 wxString wxWindowBase::GetHelpText() const
1294 {
1295     wxString text;
1296     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1297     if ( helpProvider )
1298     {
1299         text = helpProvider->GetHelp(this);
1300     }
1301
1302     return text;
1303 }
1304
1305 // show help for this window
1306 void wxWindowBase::OnHelp(wxHelpEvent& event)
1307 {
1308     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1309     if ( helpProvider )
1310     {
1311         if ( helpProvider->ShowHelp(this) )
1312         {
1313             // skip the event.Skip() below
1314             return;
1315         }
1316     }
1317
1318     event.Skip();
1319 }
1320
1321 #endif // wxUSE_HELP
1322
1323 // ----------------------------------------------------------------------------
1324 // tooltipsroot.Replace("\\", "/");
1325 // ----------------------------------------------------------------------------
1326
1327 #if wxUSE_TOOLTIPS
1328
1329 void wxWindowBase::SetToolTip( const wxString &tip )
1330 {
1331     // don't create the new tooltip if we already have one
1332     if ( m_tooltip )
1333     {
1334         m_tooltip->SetTip( tip );
1335     }
1336     else
1337     {
1338         SetToolTip( new wxToolTip( tip ) );
1339     }
1340
1341     // setting empty tooltip text does not remove the tooltip any more - use
1342     // SetToolTip((wxToolTip *)NULL) for this
1343 }
1344
1345 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
1346 {
1347     if ( m_tooltip )
1348         delete m_tooltip;
1349
1350     m_tooltip = tooltip;
1351 }
1352
1353 #endif // wxUSE_TOOLTIPS
1354
1355 // ----------------------------------------------------------------------------
1356 // constraints and sizers
1357 // ----------------------------------------------------------------------------
1358
1359 #if wxUSE_CONSTRAINTS
1360
1361 void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
1362 {
1363     if ( m_constraints )
1364     {
1365         UnsetConstraints(m_constraints);
1366         delete m_constraints;
1367     }
1368     m_constraints = constraints;
1369     if ( m_constraints )
1370     {
1371         // Make sure other windows know they're part of a 'meaningful relationship'
1372         if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
1373             m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
1374         if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
1375             m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
1376         if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
1377             m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
1378         if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
1379             m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
1380         if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
1381             m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
1382         if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
1383             m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
1384         if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
1385             m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
1386         if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
1387             m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
1388     }
1389 }
1390
1391 // This removes any dangling pointers to this window in other windows'
1392 // constraintsInvolvedIn lists.
1393 void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
1394 {
1395     if ( c )
1396     {
1397         if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1398             c->left.GetOtherWindow()->RemoveConstraintReference(this);
1399         if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1400             c->top.GetOtherWindow()->RemoveConstraintReference(this);
1401         if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
1402             c->right.GetOtherWindow()->RemoveConstraintReference(this);
1403         if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
1404             c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
1405         if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
1406             c->width.GetOtherWindow()->RemoveConstraintReference(this);
1407         if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
1408             c->height.GetOtherWindow()->RemoveConstraintReference(this);
1409         if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
1410             c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
1411         if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
1412             c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
1413     }
1414 }
1415
1416 // Back-pointer to other windows we're involved with, so if we delete this
1417 // window, we must delete any constraints we're involved with.
1418 void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
1419 {
1420     if ( !m_constraintsInvolvedIn )
1421         m_constraintsInvolvedIn = new wxWindowList;
1422     if ( !m_constraintsInvolvedIn->Find((wxWindow *)otherWin) )
1423         m_constraintsInvolvedIn->Append((wxWindow *)otherWin);
1424 }
1425
1426 // REMOVE back-pointer to other windows we're involved with.
1427 void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
1428 {
1429     if ( m_constraintsInvolvedIn )
1430         m_constraintsInvolvedIn->DeleteObject((wxWindow *)otherWin);
1431 }
1432
1433 // Reset any constraints that mention this window
1434 void wxWindowBase::DeleteRelatedConstraints()
1435 {
1436     if ( m_constraintsInvolvedIn )
1437     {
1438         wxWindowList::compatibility_iterator node = m_constraintsInvolvedIn->GetFirst();
1439         while (node)
1440         {
1441             wxWindow *win = node->GetData();
1442             wxLayoutConstraints *constr = win->GetConstraints();
1443
1444             // Reset any constraints involving this window
1445             if ( constr )
1446             {
1447                 constr->left.ResetIfWin(this);
1448                 constr->top.ResetIfWin(this);
1449                 constr->right.ResetIfWin(this);
1450                 constr->bottom.ResetIfWin(this);
1451                 constr->width.ResetIfWin(this);
1452                 constr->height.ResetIfWin(this);
1453                 constr->centreX.ResetIfWin(this);
1454                 constr->centreY.ResetIfWin(this);
1455             }
1456
1457             wxWindowList::compatibility_iterator next = node->GetNext();
1458             m_constraintsInvolvedIn->Erase(node);
1459             node = next;
1460         }
1461
1462         delete m_constraintsInvolvedIn;
1463         m_constraintsInvolvedIn = (wxWindowList *) NULL;
1464     }
1465 }
1466
1467 #endif // wxUSE_CONSTRAINTS
1468
1469 void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld)
1470 {
1471     if ( deleteOld )
1472         delete m_windowSizer;
1473
1474     m_windowSizer = sizer;
1475
1476     SetAutoLayout( sizer != NULL );
1477 }
1478
1479 void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld)
1480 {
1481     SetSizer( sizer, deleteOld );
1482     sizer->SetSizeHints( (wxWindow*) this );
1483 }
1484
1485 #if wxUSE_CONSTRAINTS
1486
1487 void wxWindowBase::SatisfyConstraints()
1488 {
1489     wxLayoutConstraints *constr = GetConstraints();
1490     bool wasOk = constr && constr->AreSatisfied();
1491
1492     ResetConstraints();   // Mark all constraints as unevaluated
1493
1494     int noChanges = 1;
1495
1496     // if we're a top level panel (i.e. our parent is frame/dialog), our
1497     // own constraints will never be satisfied any more unless we do it
1498     // here
1499     if ( wasOk )
1500     {
1501         while ( noChanges > 0 )
1502         {
1503             LayoutPhase1(&noChanges);
1504         }
1505     }
1506
1507     LayoutPhase2(&noChanges);
1508 }
1509
1510 #endif // wxUSE_CONSTRAINTS
1511
1512 bool wxWindowBase::Layout()
1513 {
1514     // If there is a sizer, use it instead of the constraints
1515     if ( GetSizer() )
1516     {
1517         int w, h;
1518         GetVirtualSize(&w, &h);
1519         GetSizer()->SetDimension( 0, 0, w, h );
1520     }
1521 #if wxUSE_CONSTRAINTS
1522     else
1523     {
1524         SatisfyConstraints(); // Find the right constraints values
1525         SetConstraintSizes(); // Recursively set the real window sizes
1526     }
1527 #endif
1528
1529     return TRUE;
1530 }
1531
1532 #if wxUSE_CONSTRAINTS
1533
1534 // first phase of the constraints evaluation: set our own constraints
1535 bool wxWindowBase::LayoutPhase1(int *noChanges)
1536 {
1537     wxLayoutConstraints *constr = GetConstraints();
1538
1539     return !constr || constr->SatisfyConstraints(this, noChanges);
1540 }
1541
1542 // second phase: set the constraints for our children
1543 bool wxWindowBase::LayoutPhase2(int *noChanges)
1544 {
1545     *noChanges = 0;
1546
1547     // Layout children
1548     DoPhase(1);
1549
1550     // Layout grand children
1551     DoPhase(2);
1552
1553     return TRUE;
1554 }
1555
1556 // Do a phase of evaluating child constraints
1557 bool wxWindowBase::DoPhase(int phase)
1558 {
1559     // the list containing the children for which the constraints are already
1560     // set correctly
1561     wxWindowList succeeded;
1562
1563     // the max number of iterations we loop before concluding that we can't set
1564     // the constraints
1565     static const int maxIterations = 500;
1566
1567     for ( int noIterations = 0; noIterations < maxIterations; noIterations++ )
1568     {
1569         int noChanges = 0;
1570
1571         // loop over all children setting their constraints
1572         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1573               node;
1574               node = node->GetNext() )
1575         {
1576             wxWindow *child = node->GetData();
1577             if ( child->IsTopLevel() )
1578             {
1579                 // top level children are not inside our client area
1580                 continue;
1581             }
1582
1583             if ( !child->GetConstraints() || succeeded.Find(child) )
1584             {
1585                 // this one is either already ok or nothing we can do about it
1586                 continue;
1587             }
1588
1589             int tempNoChanges = 0;
1590             bool success = phase == 1 ? child->LayoutPhase1(&tempNoChanges)
1591                                       : child->LayoutPhase2(&tempNoChanges);
1592             noChanges += tempNoChanges;
1593
1594             if ( success )
1595             {
1596                 succeeded.Append(child);
1597             }
1598         }
1599
1600         if ( !noChanges )
1601         {
1602             // constraints are set
1603             break;
1604         }
1605     }
1606
1607     return TRUE;
1608 }
1609
1610 void wxWindowBase::ResetConstraints()
1611 {
1612     wxLayoutConstraints *constr = GetConstraints();
1613     if ( constr )
1614     {
1615         constr->left.SetDone(FALSE);
1616         constr->top.SetDone(FALSE);
1617         constr->right.SetDone(FALSE);
1618         constr->bottom.SetDone(FALSE);
1619         constr->width.SetDone(FALSE);
1620         constr->height.SetDone(FALSE);
1621         constr->centreX.SetDone(FALSE);
1622         constr->centreY.SetDone(FALSE);
1623     }
1624
1625     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1626     while (node)
1627     {
1628         wxWindow *win = node->GetData();
1629         if ( !win->IsTopLevel() )
1630             win->ResetConstraints();
1631         node = node->GetNext();
1632     }
1633 }
1634
1635 // Need to distinguish between setting the 'fake' size for windows and sizers,
1636 // and setting the real values.
1637 void wxWindowBase::SetConstraintSizes(bool recurse)
1638 {
1639     wxLayoutConstraints *constr = GetConstraints();
1640     if ( constr && constr->AreSatisfied() )
1641     {
1642         int x = constr->left.GetValue();
1643         int y = constr->top.GetValue();
1644         int w = constr->width.GetValue();
1645         int h = constr->height.GetValue();
1646
1647         if ( (constr->width.GetRelationship() != wxAsIs ) ||
1648              (constr->height.GetRelationship() != wxAsIs) )
1649         {
1650             SetSize(x, y, w, h);
1651         }
1652         else
1653         {
1654             // If we don't want to resize this window, just move it...
1655             Move(x, y);
1656         }
1657     }
1658     else if ( constr )
1659     {
1660         wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1661                    GetClassInfo()->GetClassName(),
1662                    GetName().c_str());
1663     }
1664
1665     if ( recurse )
1666     {
1667         wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1668         while (node)
1669         {
1670             wxWindow *win = node->GetData();
1671             if ( !win->IsTopLevel() && win->GetConstraints() )
1672                 win->SetConstraintSizes();
1673             node = node->GetNext();
1674         }
1675     }
1676 }
1677
1678 // Only set the size/position of the constraint (if any)
1679 void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
1680 {
1681     wxLayoutConstraints *constr = GetConstraints();
1682     if ( constr )
1683     {
1684         if ( x != -1 )
1685         {
1686             constr->left.SetValue(x);
1687             constr->left.SetDone(TRUE);
1688         }
1689         if ( y != -1 )
1690         {
1691             constr->top.SetValue(y);
1692             constr->top.SetDone(TRUE);
1693         }
1694         if ( w != -1 )
1695         {
1696             constr->width.SetValue(w);
1697             constr->width.SetDone(TRUE);
1698         }
1699         if ( h != -1 )
1700         {
1701             constr->height.SetValue(h);
1702             constr->height.SetDone(TRUE);
1703         }
1704     }
1705 }
1706
1707 void wxWindowBase::MoveConstraint(int x, int y)
1708 {
1709     wxLayoutConstraints *constr = GetConstraints();
1710     if ( constr )
1711     {
1712         if ( x != -1 )
1713         {
1714             constr->left.SetValue(x);
1715             constr->left.SetDone(TRUE);
1716         }
1717         if ( y != -1 )
1718         {
1719             constr->top.SetValue(y);
1720             constr->top.SetDone(TRUE);
1721         }
1722     }
1723 }
1724
1725 void wxWindowBase::GetSizeConstraint(int *w, int *h) const
1726 {
1727     wxLayoutConstraints *constr = GetConstraints();
1728     if ( constr )
1729     {
1730         *w = constr->width.GetValue();
1731         *h = constr->height.GetValue();
1732     }
1733     else
1734         GetSize(w, h);
1735 }
1736
1737 void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
1738 {
1739     wxLayoutConstraints *constr = GetConstraints();
1740     if ( constr )
1741     {
1742         *w = constr->width.GetValue();
1743         *h = constr->height.GetValue();
1744     }
1745     else
1746         GetClientSize(w, h);
1747 }
1748
1749 void wxWindowBase::GetPositionConstraint(int *x, int *y) const
1750 {
1751     wxLayoutConstraints *constr = GetConstraints();
1752     if ( constr )
1753     {
1754         *x = constr->left.GetValue();
1755         *y = constr->top.GetValue();
1756     }
1757     else
1758         GetPosition(x, y);
1759 }
1760
1761 #endif // wxUSE_CONSTRAINTS
1762
1763 void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const
1764 {
1765     // don't do it for the dialogs/frames - they float independently of their
1766     // parent
1767     if ( !IsTopLevel() )
1768     {
1769         wxWindow *parent = GetParent();
1770         if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
1771         {
1772             wxPoint pt(parent->GetClientAreaOrigin());
1773             x += pt.x;
1774             y += pt.y;
1775         }
1776     }
1777 }
1778
1779 // ----------------------------------------------------------------------------
1780 // do Update UI processing for child controls
1781 // ----------------------------------------------------------------------------
1782
1783 void wxWindowBase::UpdateWindowUI(long flags)
1784 {
1785     wxUpdateUIEvent event(GetId());
1786     event.m_eventObject = this;
1787
1788     if ( GetEventHandler()->ProcessEvent(event) )
1789     {
1790         DoUpdateWindowUI(event);
1791     }
1792
1793     if (flags & wxUPDATE_UI_RECURSE)
1794     {
1795         wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1796         while (node)
1797         {
1798             wxWindow* child = (wxWindow*) node->GetData();
1799             child->UpdateWindowUI(flags);
1800             node = node->GetNext();
1801         }
1802     }
1803 }
1804
1805 // do the window-specific processing after processing the update event
1806 // TODO: take specific knowledge out of this function and
1807 // put in each control's base class. Unfortunately we don't
1808 // yet have base implementation files for wxCheckBox and wxRadioButton.
1809 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
1810 {
1811     if ( event.GetSetEnabled() )
1812         Enable(event.GetEnabled());
1813
1814 #if wxUSE_CONTROLS
1815     if ( event.GetSetText() )
1816     {
1817         wxControl *control = wxDynamicCastThis(wxControl);
1818         if ( control )
1819         {
1820             if ( event.GetText() != control->GetLabel() )
1821                 control->SetLabel(event.GetText());
1822         }
1823 #if wxUSE_CHECKBOX
1824         wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
1825         if ( checkbox )
1826         {
1827             if ( event.GetSetChecked() )
1828                 checkbox->SetValue(event.GetChecked());
1829         }
1830 #endif // wxUSE_CHECKBOX
1831
1832 #if wxUSE_RADIOBTN
1833         wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
1834         if ( radiobtn )
1835         {
1836             if ( event.GetSetChecked() )
1837                 radiobtn->SetValue(event.GetChecked());
1838         }
1839 #endif // wxUSE_RADIOBTN
1840     }
1841 #endif
1842 }
1843
1844 #if 0
1845 // call internal idle recursively
1846 // may be obsolete (wait until OnIdle scheme stabilises)
1847 void wxWindowBase::ProcessInternalIdle()
1848 {
1849     OnInternalIdle();
1850
1851     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1852     while (node)
1853     {
1854         wxWindow *child = node->GetData();
1855         child->ProcessInternalIdle();
1856         node = node->GetNext();
1857     }
1858 }
1859 #endif
1860
1861 // ----------------------------------------------------------------------------
1862 // dialog units translations
1863 // ----------------------------------------------------------------------------
1864
1865 wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
1866 {
1867     int charWidth = GetCharWidth();
1868     int charHeight = GetCharHeight();
1869     wxPoint pt2(-1, -1);
1870     if (pt.x != -1)
1871         pt2.x = (int) ((pt.x * 4) / charWidth) ;
1872     if (pt.y != -1)
1873         pt2.y = (int) ((pt.y * 8) / charHeight) ;
1874
1875     return pt2;
1876 }
1877
1878 wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
1879 {
1880     int charWidth = GetCharWidth();
1881     int charHeight = GetCharHeight();
1882     wxPoint pt2(-1, -1);
1883     if (pt.x != -1)
1884         pt2.x = (int) ((pt.x * charWidth) / 4) ;
1885     if (pt.y != -1)
1886         pt2.y = (int) ((pt.y * charHeight) / 8) ;
1887
1888     return pt2;
1889 }
1890
1891 // ----------------------------------------------------------------------------
1892 // event handlers
1893 // ----------------------------------------------------------------------------
1894
1895 // propagate the colour change event to the subwindows
1896 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
1897 {
1898     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1899     while ( node )
1900     {
1901         // Only propagate to non-top-level windows
1902         wxWindow *win = node->GetData();
1903         if ( !win->IsTopLevel() )
1904         {
1905             wxSysColourChangedEvent event2;
1906             event.m_eventObject = win;
1907             win->GetEventHandler()->ProcessEvent(event2);
1908         }
1909
1910         node = node->GetNext();
1911     }
1912 }
1913
1914 // the default action is to populate dialog with data when it's created,
1915 // and nudge the UI into displaying itself correctly in case
1916 // we've turned the wxUpdateUIEvents frequency down low.
1917 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
1918 {
1919     TransferDataToWindow();
1920
1921     // Update the UI at this point
1922     UpdateWindowUI(wxUPDATE_UI_RECURSE);
1923 }
1924
1925 // process Ctrl-Alt-mclick
1926 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
1927 {
1928 #if wxUSE_MSGDLG
1929     if ( event.ControlDown() && event.AltDown() )
1930     {
1931         // don't translate these strings
1932         wxString port;
1933
1934 #ifdef __WXUNIVERSAL__
1935         port = _T("Univ/");
1936 #endif // __WXUNIVERSAL__
1937
1938         switch ( wxGetOsVersion() )
1939         {
1940             case wxMOTIF_X:     port += _T("Motif"); break;
1941             case wxMAC:
1942             case wxMAC_DARWIN:  port += _T("Mac"); break;
1943             case wxBEOS:        port += _T("BeOS"); break;
1944             case wxGTK:
1945             case wxGTK_WIN32:
1946             case wxGTK_OS2:
1947             case wxGTK_BEOS:    port += _T("GTK"); break;
1948             case wxWINDOWS:
1949             case wxPENWINDOWS:
1950             case wxWINDOWS_NT:
1951             case wxWIN32S:
1952             case wxWIN95:
1953             case wxWIN386:      port += _T("MS Windows"); break;
1954             case wxMGL_UNIX:
1955             case wxMGL_X:
1956             case wxMGL_WIN32:
1957             case wxMGL_OS2:     port += _T("MGL"); break;
1958             case wxWINDOWS_OS2:
1959             case wxOS2_PM:      port += _T("OS/2"); break;
1960             default:            port += _T("unknown"); break;
1961         }
1962
1963         wxMessageBox(wxString::Format(
1964                                       _T(
1965                                         "       wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n   Copyright (c) 1995-2002 wxWindows team"
1966                                         ),
1967                                       port.c_str(),
1968                                       wxMAJOR_VERSION,
1969                                       wxMINOR_VERSION,
1970                                       wxRELEASE_NUMBER,
1971 #if wxUSE_UNICODE
1972                                       L" (Unicode)",
1973 #else
1974                                       "",
1975 #endif
1976                                       __TDATE__,
1977                                       __TTIME__
1978                                      ),
1979                      _T("wxWindows information"),
1980                      wxICON_INFORMATION | wxOK,
1981                      (wxWindow *)this);
1982     }
1983     else
1984 #endif // wxUSE_MSGDLG
1985     {
1986         event.Skip();
1987     }
1988 }
1989
1990 // ----------------------------------------------------------------------------
1991 // accessibility
1992 // ----------------------------------------------------------------------------
1993
1994 #if wxUSE_ACCESSIBILITY
1995 void wxWindowBase::SetAccessible(wxAccessible* accessible)
1996 {
1997     if (m_accessible && (accessible != m_accessible))
1998         delete m_accessible;
1999     m_accessible = accessible;
2000     if (m_accessible)
2001         m_accessible->SetWindow((wxWindow*) this);
2002 }
2003
2004 // Returns the accessible object, creating if necessary.
2005 wxAccessible* wxWindowBase::GetOrCreateAccessible()
2006 {
2007     if (!m_accessible)
2008         m_accessible = CreateAccessible();
2009     return m_accessible;
2010 }
2011
2012 // Override to create a specific accessible object.
2013 wxAccessible* wxWindowBase::CreateAccessible()
2014 {
2015     return new wxWindowAccessible((wxWindow*) this);
2016 }
2017
2018 #endif
2019
2020 #if !wxUSE_STL
2021 // ----------------------------------------------------------------------------
2022 // list classes implementation
2023 // ----------------------------------------------------------------------------
2024
2025 void wxWindowListNode::DeleteData()
2026 {
2027     delete (wxWindow *)GetData();
2028 }
2029 #endif
2030
2031 // ----------------------------------------------------------------------------
2032 // borders
2033 // ----------------------------------------------------------------------------
2034
2035 wxBorder wxWindowBase::GetBorder(long flags) const
2036 {
2037     wxBorder border = (wxBorder)(flags & wxBORDER_MASK);
2038     if ( border == wxBORDER_DEFAULT )
2039     {
2040         border = GetDefaultBorder();
2041     }
2042
2043     return border;
2044 }
2045
2046 wxBorder wxWindowBase::GetDefaultBorder() const
2047 {
2048     return wxBORDER_NONE;
2049 }
2050
2051 // ----------------------------------------------------------------------------
2052 // hit testing
2053 // ----------------------------------------------------------------------------
2054
2055 wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
2056 {
2057     // here we just check if the point is inside the window or not
2058
2059     // check the top and left border first
2060     bool outside = x < 0 || y < 0;
2061     if ( !outside )
2062     {
2063         // check the right and bottom borders too
2064         wxSize size = GetSize();
2065         outside = x >= size.x || y >= size.y;
2066     }
2067
2068     return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE;
2069 }
2070
2071 // ----------------------------------------------------------------------------
2072 // mouse capture
2073 // ----------------------------------------------------------------------------
2074
2075 struct WXDLLEXPORT wxWindowNext
2076 {
2077     wxWindow *win;
2078     wxWindowNext *next;
2079 } *wxWindowBase::ms_winCaptureNext = NULL;
2080
2081 void wxWindowBase::CaptureMouse()
2082 {
2083     wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this);
2084
2085     wxWindow *winOld = GetCapture();
2086     if ( winOld )
2087     {
2088         ((wxWindowBase*) winOld)->DoReleaseMouse();
2089
2090         // save it on stack
2091         wxWindowNext *item = new wxWindowNext;
2092         item->win = winOld;
2093         item->next = ms_winCaptureNext;
2094         ms_winCaptureNext = item;
2095     }
2096     //else: no mouse capture to save
2097
2098     DoCaptureMouse();
2099 }
2100
2101 void wxWindowBase::ReleaseMouse()
2102 {
2103     wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this);
2104
2105     wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
2106
2107     DoReleaseMouse();
2108
2109     if ( ms_winCaptureNext )
2110     {
2111         ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse();
2112
2113         wxWindowNext *item = ms_winCaptureNext;
2114         ms_winCaptureNext = item->next;
2115         delete item;
2116     }
2117     //else: stack is empty, no previous capture
2118
2119     wxLogTrace(_T("mousecapture"),
2120                _T("After ReleaseMouse() mouse is captured by %p"),
2121                GetCapture());
2122 }
2123
2124 #if wxUSE_HOTKEY
2125
2126 bool
2127 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId),
2128                              int WXUNUSED(modifiers),
2129                              int WXUNUSED(keycode))
2130 {
2131     // not implemented
2132     return false;
2133 }
2134
2135 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId))
2136 {
2137     // not implemented
2138     return false;
2139 }
2140
2141 #endif // wxUSE_HOTKEY
2142
2143 void wxWindowBase::SendDestroyEvent()
2144 {
2145     wxWindowDestroyEvent event;
2146     event.SetEventObject(this);
2147     event.SetId(GetId());
2148     GetEventHandler()->ProcessEvent(event);
2149 }
2150
2151 // ----------------------------------------------------------------------------
2152 // event processing
2153 // ----------------------------------------------------------------------------
2154
2155 #if wxUSE_VALIDATORS
2156
2157 bool wxWindowBase::TryValidator(wxEvent& event)
2158 {
2159     // Can only use the validator of the window which
2160     // is receiving the event
2161     if ( event.GetEventObject() == this )
2162     {
2163         wxValidator *validator = GetValidator();
2164         if ( validator && validator->ProcessEvent(event) )
2165         {
2166             return TRUE;
2167         }
2168     }
2169
2170     return FALSE;
2171 }
2172
2173 #endif // wxUSE_VALIDATORS
2174
2175 bool wxWindowBase::TryParent(wxEvent& event)
2176 {
2177     // carry on up the parent-child hierarchy if the propgation count hasn't
2178     // reached zero yet
2179     if ( event.ShouldPropagate() )
2180     {
2181         // honour the requests to stop propagation at this window: this is
2182         // used by the dialogs, for example, to prevent processing the events
2183         // from the dialog controls in the parent frame which rarely, if ever,
2184         // makes sense
2185         if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS) )
2186         {
2187             wxWindow *parent = GetParent();
2188             if ( parent && !parent->IsBeingDeleted() )
2189             {
2190                 wxPropagateOnce propagateOnce(event);
2191
2192                 return parent->GetEventHandler()->ProcessEvent(event);
2193             }
2194         }
2195     }
2196
2197     return wxEvtHandler::TryParent(event);
2198 }
2199
2200 // ----------------------------------------------------------------------------
2201 // global functions
2202 // ----------------------------------------------------------------------------
2203
2204 wxWindow* wxGetTopLevelParent(wxWindow *win)
2205 {
2206     while ( win && !win->IsTopLevel() )
2207          win = win->GetParent();
2208
2209     return win;
2210 }
2211
2212 #if wxUSE_ACCESSIBILITY
2213 // ----------------------------------------------------------------------------
2214 // accessible object for windows
2215 // ----------------------------------------------------------------------------
2216
2217 // Can return either a child object, or an integer
2218 // representing the child element, starting from 1.
2219 wxAccStatus wxWindowAccessible::HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject)
2220 {
2221     wxASSERT( GetWindow() != NULL );
2222     if (!GetWindow())
2223         return wxACC_FAIL;
2224
2225     return wxACC_NOT_IMPLEMENTED;
2226 }
2227
2228 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
2229 wxAccStatus wxWindowAccessible::GetLocation(wxRect& rect, int elementId)
2230 {
2231     wxASSERT( GetWindow() != NULL );
2232     if (!GetWindow())
2233         return wxACC_FAIL;
2234
2235     wxWindow* win = NULL;
2236     if (elementId == 0)
2237     {
2238         win = GetWindow();
2239     }
2240     else
2241     {
2242         if (elementId <= (int) GetWindow()->GetChildren().GetCount())
2243         {
2244             win = GetWindow()->GetChildren().Item(elementId-1)->GetData();
2245         }
2246         else
2247             return wxACC_FAIL;
2248     }
2249     if (win)
2250     {
2251         rect = win->GetRect();
2252         if (win->GetParent() && !win->IsKindOf(CLASSINFO(wxTopLevelWindow)))
2253             rect.SetPosition(win->GetParent()->ClientToScreen(rect.GetPosition()));
2254         return wxACC_OK;
2255     }
2256
2257     return wxACC_NOT_IMPLEMENTED;
2258 }
2259
2260 // Navigates from fromId to toId/toObject.
2261 wxAccStatus wxWindowAccessible::Navigate(wxNavDir navDir, int fromId,
2262                              int* toId, wxAccessible** toObject)
2263 {
2264     wxASSERT( GetWindow() != NULL );
2265     if (!GetWindow())
2266         return wxACC_FAIL;
2267
2268     switch (navDir)
2269     {
2270     case wxNAVDIR_FIRSTCHILD:
2271         {
2272             if (GetWindow()->GetChildren().GetCount() == 0)
2273                 return wxACC_FALSE;
2274             wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetFirst()->GetData();
2275             *toObject = childWindow->GetOrCreateAccessible();
2276
2277             return wxACC_OK;
2278         }
2279     case wxNAVDIR_LASTCHILD:
2280         {
2281             if (GetWindow()->GetChildren().GetCount() == 0)
2282                 return wxACC_FALSE;
2283             wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetLast()->GetData();
2284             *toObject = childWindow->GetOrCreateAccessible();
2285
2286             return wxACC_OK;
2287         }
2288     case wxNAVDIR_RIGHT:
2289     case wxNAVDIR_DOWN:
2290     case wxNAVDIR_NEXT:
2291         {
2292             wxWindowList::compatibility_iterator node =
2293                 wxWindowList::compatibility_iterator();
2294             if (fromId == 0)
2295             {
2296                 // Can't navigate to sibling of this window
2297                 // if we're a top-level window.
2298                 if (!GetWindow()->GetParent())
2299                     return wxACC_NOT_IMPLEMENTED;
2300
2301                 node = GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2302             }
2303             else
2304             {
2305                 if (fromId <= (int) GetWindow()->GetChildren().GetCount())
2306                     node = GetWindow()->GetChildren().Item(fromId-1);
2307             }
2308
2309             if (node && node->GetNext())
2310             {
2311                 wxWindow* nextWindow = node->GetNext()->GetData();
2312                 *toObject = nextWindow->GetOrCreateAccessible();
2313                 return wxACC_OK;
2314             }
2315             else
2316                 return wxACC_FALSE;
2317         }
2318     case wxNAVDIR_LEFT:
2319     case wxNAVDIR_UP:
2320     case wxNAVDIR_PREVIOUS:
2321         {
2322             wxWindowList::compatibility_iterator node =
2323                 wxWindowList::compatibility_iterator();
2324             if (fromId == 0)
2325             {
2326                 // Can't navigate to sibling of this window
2327                 // if we're a top-level window.
2328                 if (!GetWindow()->GetParent())
2329                     return wxACC_NOT_IMPLEMENTED;
2330
2331                 node = GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2332             }
2333             else
2334             {
2335                 if (fromId <= (int) GetWindow()->GetChildren().GetCount())
2336                     node = GetWindow()->GetChildren().Item(fromId-1);
2337             }
2338
2339             if (node && node->GetPrevious())
2340             {
2341                 wxWindow* previousWindow = node->GetPrevious()->GetData();
2342                 *toObject = previousWindow->GetOrCreateAccessible();
2343                 return wxACC_OK;
2344             }
2345             else
2346                 return wxACC_FALSE;
2347         }
2348     }
2349
2350     return wxACC_NOT_IMPLEMENTED;
2351 }
2352
2353 // Gets the name of the specified object.
2354 wxAccStatus wxWindowAccessible::GetName(int childId, wxString* name)
2355 {
2356     wxASSERT( GetWindow() != NULL );
2357     if (!GetWindow())
2358         return wxACC_FAIL;
2359
2360     wxString title;
2361
2362     // If a child, leave wxWindows to call the function on the actual
2363     // child object.
2364     if (childId > 0)
2365         return wxACC_NOT_IMPLEMENTED;
2366
2367     // This will eventually be replaced by specialised
2368     // accessible classes, one for each kind of wxWindows
2369     // control or window.
2370     if (GetWindow()->IsKindOf(CLASSINFO(wxButton)))
2371         title = ((wxButton*) GetWindow())->GetLabel();
2372     else
2373         title = GetWindow()->GetName();
2374
2375     if (!title.IsEmpty())
2376     {
2377         *name = title;
2378         return wxACC_OK;
2379     }
2380     else
2381         return wxACC_NOT_IMPLEMENTED;
2382 }
2383
2384 // Gets the number of children.
2385 wxAccStatus wxWindowAccessible::GetChildCount(int* childId)
2386 {
2387     wxASSERT( GetWindow() != NULL );
2388     if (!GetWindow())
2389         return wxACC_FAIL;
2390
2391     *childId = (int) GetWindow()->GetChildren().GetCount();
2392     return wxACC_OK;
2393 }
2394
2395 // Gets the specified child (starting from 1).
2396 // If *child is NULL and return value is wxACC_OK,
2397 // this means that the child is a simple element and
2398 // not an accessible object.
2399 wxAccStatus wxWindowAccessible::GetChild(int childId, wxAccessible** child)
2400 {
2401     wxASSERT( GetWindow() != NULL );
2402     if (!GetWindow())
2403         return wxACC_FAIL;
2404
2405     if (childId == 0)
2406     {
2407         *child = this;
2408         return wxACC_OK;
2409     }
2410
2411     if (childId > (int) GetWindow()->GetChildren().GetCount())
2412         return wxACC_FAIL;
2413
2414     wxWindow* childWindow = GetWindow()->GetChildren().Item(childId-1)->GetData();
2415     *child = childWindow->GetOrCreateAccessible();
2416     if (*child)
2417         return wxACC_OK;
2418     else
2419         return wxACC_FAIL;
2420 }
2421
2422 // Gets the parent, or NULL.
2423 wxAccStatus wxWindowAccessible::GetParent(wxAccessible** parent)
2424 {
2425     wxASSERT( GetWindow() != NULL );
2426     if (!GetWindow())
2427         return wxACC_FAIL;
2428
2429     wxWindow* parentWindow = GetWindow()->GetParent();
2430     if (!parentWindow)
2431     {
2432         *parent = NULL;
2433         return wxACC_OK;
2434     }
2435     else
2436     {
2437         *parent = parentWindow->GetOrCreateAccessible();
2438         if (*parent)
2439             return wxACC_OK;
2440         else
2441             return wxACC_FAIL;
2442     }
2443 }
2444
2445 // Performs the default action. childId is 0 (the action for this object)
2446 // or > 0 (the action for a child).
2447 // Return wxACC_NOT_SUPPORTED if there is no default action for this
2448 // window (e.g. an edit control).
2449 wxAccStatus wxWindowAccessible::DoDefaultAction(int childId)
2450 {
2451     wxASSERT( GetWindow() != NULL );
2452     if (!GetWindow())
2453         return wxACC_FAIL;
2454
2455     return wxACC_NOT_IMPLEMENTED;
2456 }
2457
2458 // Gets the default action for this object (0) or > 0 (the action for a child).
2459 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
2460 // string if there is no action.
2461 // The retrieved string describes the action that is performed on an object,
2462 // not what the object does as a result. For example, a toolbar button that prints
2463 // a document has a default action of "Press" rather than "Prints the current document."
2464 wxAccStatus wxWindowAccessible::GetDefaultAction(int childId, wxString* actionName)
2465 {
2466     wxASSERT( GetWindow() != NULL );
2467     if (!GetWindow())
2468         return wxACC_FAIL;
2469
2470     return wxACC_NOT_IMPLEMENTED;
2471 }
2472
2473 // Returns the description for this object or a child.
2474 wxAccStatus wxWindowAccessible::GetDescription(int childId, wxString* description)
2475 {
2476     wxASSERT( GetWindow() != NULL );
2477     if (!GetWindow())
2478         return wxACC_FAIL;
2479
2480     wxString ht(GetWindow()->GetHelpText());
2481     if (!ht.IsEmpty())
2482     {
2483         *description = ht;
2484         return wxACC_OK;
2485     }
2486     return wxACC_NOT_IMPLEMENTED;
2487 }
2488
2489 // Returns help text for this object or a child, similar to tooltip text.
2490 wxAccStatus wxWindowAccessible::GetHelpText(int childId, wxString* helpText)
2491 {
2492     wxASSERT( GetWindow() != NULL );
2493     if (!GetWindow())
2494         return wxACC_FAIL;
2495
2496     wxString ht(GetWindow()->GetHelpText());
2497     if (!ht.IsEmpty())
2498     {
2499         *helpText = ht;
2500         return wxACC_OK;
2501     }
2502     return wxACC_NOT_IMPLEMENTED;
2503 }
2504
2505 // Returns the keyboard shortcut for this object or child.
2506 // Return e.g. ALT+K
2507 wxAccStatus wxWindowAccessible::GetKeyboardShortcut(int childId, wxString* shortcut)
2508 {
2509     wxASSERT( GetWindow() != NULL );
2510     if (!GetWindow())
2511         return wxACC_FAIL;
2512
2513     return wxACC_NOT_IMPLEMENTED;
2514 }
2515
2516 // Returns a role constant.
2517 wxAccStatus wxWindowAccessible::GetRole(int childId, wxAccRole* role)
2518 {
2519     wxASSERT( GetWindow() != NULL );
2520     if (!GetWindow())
2521         return wxACC_FAIL;
2522
2523     // If a child, leave wxWindows to call the function on the actual
2524     // child object.
2525     if (childId > 0)
2526         return wxACC_NOT_IMPLEMENTED;
2527
2528     if (GetWindow()->IsKindOf(CLASSINFO(wxControl)))
2529         return wxACC_NOT_IMPLEMENTED;
2530 #if wxUSE_STATUSBAR
2531     if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar)))
2532         return wxACC_NOT_IMPLEMENTED;
2533 #endif
2534 #if wxUSE_TOOLBAR
2535     if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar)))
2536         return wxACC_NOT_IMPLEMENTED;
2537 #endif
2538
2539     //*role = wxROLE_SYSTEM_CLIENT;
2540     *role = wxROLE_SYSTEM_CLIENT;
2541     return wxACC_OK;
2542
2543     return wxACC_NOT_IMPLEMENTED;
2544 }
2545
2546 // Returns a state constant.
2547 wxAccStatus wxWindowAccessible::GetState(int childId, long* state)
2548 {
2549     wxASSERT( GetWindow() != NULL );
2550     if (!GetWindow())
2551         return wxACC_FAIL;
2552
2553     // If a child, leave wxWindows to call the function on the actual
2554     // child object.
2555     if (childId > 0)
2556         return wxACC_NOT_IMPLEMENTED;
2557
2558     if (GetWindow()->IsKindOf(CLASSINFO(wxControl)))
2559         return wxACC_NOT_IMPLEMENTED;
2560
2561 #if wxUSE_STATUSBAR
2562     if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar)))
2563         return wxACC_NOT_IMPLEMENTED;
2564 #endif
2565 #if wxUSE_TOOLBAR
2566     if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar)))
2567         return wxACC_NOT_IMPLEMENTED;
2568 #endif
2569
2570     *state = 0;
2571     return wxACC_OK;
2572
2573     return wxACC_NOT_IMPLEMENTED;
2574 }
2575
2576 // Returns a localized string representing the value for the object
2577 // or child.
2578 wxAccStatus wxWindowAccessible::GetValue(int childId, wxString* strValue)
2579 {
2580     wxASSERT( GetWindow() != NULL );
2581     if (!GetWindow())
2582         return wxACC_FAIL;
2583
2584     return wxACC_NOT_IMPLEMENTED;
2585 }
2586
2587 // Selects the object or child.
2588 wxAccStatus wxWindowAccessible::Select(int childId, wxAccSelectionFlags selectFlags)
2589 {
2590     wxASSERT( GetWindow() != NULL );
2591     if (!GetWindow())
2592         return wxACC_FAIL;
2593
2594     return wxACC_NOT_IMPLEMENTED;
2595 }
2596
2597 // Gets the window with the keyboard focus.
2598 // If childId is 0 and child is NULL, no object in
2599 // this subhierarchy has the focus.
2600 // If this object has the focus, child should be 'this'.
2601 wxAccStatus wxWindowAccessible::GetFocus(int* childId, wxAccessible** child)
2602 {
2603     wxASSERT( GetWindow() != NULL );
2604     if (!GetWindow())
2605         return wxACC_FAIL;
2606
2607     return wxACC_NOT_IMPLEMENTED;
2608 }
2609
2610 // Gets a variant representing the selected children
2611 // of this object.
2612 // Acceptable values:
2613 // - a null variant (IsNull() returns TRUE)
2614 // - a list variant (GetType() == wxT("list")
2615 // - an integer representing the selected child element,
2616 //   or 0 if this object is selected (GetType() == wxT("long")
2617 // - a "void*" pointer to a wxAccessible child object
2618 wxAccStatus wxWindowAccessible::GetSelections(wxVariant* selections)
2619 {
2620     wxASSERT( GetWindow() != NULL );
2621     if (!GetWindow())
2622         return wxACC_FAIL;
2623
2624     return wxACC_NOT_IMPLEMENTED;
2625 }
2626
2627 #endif // wxUSE_ACCESSIBILITY