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