src/common/wincmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/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) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/string.h"
  29     #include "wx/log.h"
  30     #include "wx/intl.h"
  31     #include "wx/frame.h"
  32     #include "wx/window.h"
  33     #include "wx/control.h"
  34     #include "wx/checkbox.h"
  35     #include "wx/radiobut.h"
  36     #include "wx/statbox.h"
  37     #include "wx/textctrl.h"
  38     #include "wx/settings.h"
  39     #include "wx/dialog.h"
  40     #include "wx/msgdlg.h"
  41     #include "wx/statusbr.h"
  42     #include "wx/toolbar.h"
  43     #include "wx/dcclient.h"
  44     #include "wx/scrolbar.h"
  45     #include "wx/layout.h"
  46     #include "wx/sizer.h"
  47     #include "wx/menu.h"
  48 #endif //WX_PRECOMP
  49
  50 #if wxUSE_DRAG_AND_DROP
  51     #include "wx/dnd.h"
  52 #endif // wxUSE_DRAG_AND_DROP
  53
  54 #if wxUSE_ACCESSIBILITY
  55     #include "wx/access.h"
  56 #endif
  57
  58 #if wxUSE_HELP
  59     #include "wx/cshelp.h"
  60 #endif // wxUSE_HELP
  61
  62 #if wxUSE_TOOLTIPS
  63     #include "wx/tooltip.h"
  64 #endif // wxUSE_TOOLTIPS
  65
  66 #if wxUSE_CARET
  67     #include "wx/caret.h"
  68 #endif // wxUSE_CARET
  69
  70 #if wxUSE_SYSTEM_OPTIONS
  71     #include "wx/sysopt.h"
  72 #endif
  73
  74 // For reporting compile- and runtime version of GTK+ in the ctrl+alt+mclick dialog.
  75 // The gtk includes don't pull any other headers in, at least not on my system - MR
  76 #ifdef __WXGTK__
  77     #ifdef __WXGTK20__
  78         #include <gtk/gtkversion.h>
  79     #else
  80         #include <gtk/gtkfeatures.h>
  81     #endif
  82 #endif
  83
  84 #include "wx/platinfo.h"
  85
  86 // Windows List
  87 WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows;
  88
  89 // globals
  90 #if wxUSE_MENUS
  91 wxMenu *wxCurrentPopupMenu = NULL;
  92 #endif // wxUSE_MENUS
  93
  94 // ----------------------------------------------------------------------------
  95 // static data
  96 // ----------------------------------------------------------------------------
  97
  98
  99 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
 100
 101 // ----------------------------------------------------------------------------
 102 // event table
 103 // ----------------------------------------------------------------------------
 104
 105 BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
 106     EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
 107     EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
 108     EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
 109
 110 #if wxUSE_HELP
 111     EVT_HELP(wxID_ANY, wxWindowBase::OnHelp)
 112 #endif // wxUSE_HELP
 113
 114 END_EVENT_TABLE()
 115
 116 // ============================================================================
 117 // implementation of the common functionality of the wxWindow class
 118 // ============================================================================
 119
 120 // ----------------------------------------------------------------------------
 121 // initialization
 122 // ----------------------------------------------------------------------------
 123
 124 // the default initialization
 125 wxWindowBase::wxWindowBase()
 126 {
 127     // no window yet, no parent nor children
 128     m_parent = (wxWindow *)NULL;
 129     m_windowId = wxID_ANY;
 130
 131     // no constraints on the minimal window size
 132     m_minWidth =
 133     m_maxWidth = wxDefaultCoord;
 134     m_minHeight =
 135     m_maxHeight = wxDefaultCoord;
 136
 137     // invalidiated cache value
 138     m_bestSizeCache = wxDefaultSize;
 139
 140     // window are created enabled and visible by default
 141     m_isShown =
 142     m_isEnabled = true;
 143
 144     // the default event handler is just this window
 145     m_eventHandler = this;
 146
 147 #if wxUSE_VALIDATORS
 148     // no validator
 149     m_windowValidator = (wxValidator *) NULL;
 150 #endif // wxUSE_VALIDATORS
 151
 152     // the colours/fonts are default for now, so leave m_font,
 153     // m_backgroundColour and m_foregroundColour uninitialized and set those
 154     m_hasBgCol =
 155     m_hasFgCol =
 156     m_hasFont = false;
 157     m_inheritBgCol =
 158     m_inheritFgCol =
 159     m_inheritFont = false;
 160
 161     // no style bits
 162     m_exStyle =
 163     m_windowStyle = 0;
 164
 165     m_backgroundStyle = wxBG_STYLE_SYSTEM;
 166
 167 #if wxUSE_CONSTRAINTS
 168     // no constraints whatsoever
 169     m_constraints = (wxLayoutConstraints *) NULL;
 170     m_constraintsInvolvedIn = (wxWindowList *) NULL;
 171 #endif // wxUSE_CONSTRAINTS
 172
 173     m_windowSizer = (wxSizer *) NULL;
 174     m_containingSizer = (wxSizer *) NULL;
 175     m_autoLayout = false;
 176
 177 #if wxUSE_DRAG_AND_DROP
 178     m_dropTarget = (wxDropTarget *)NULL;
 179 #endif // wxUSE_DRAG_AND_DROP
 180
 181 #if wxUSE_TOOLTIPS
 182     m_tooltip = (wxToolTip *)NULL;
 183 #endif // wxUSE_TOOLTIPS
 184
 185 #if wxUSE_CARET
 186     m_caret = (wxCaret *)NULL;
 187 #endif // wxUSE_CARET
 188
 189 #if wxUSE_PALETTE
 190     m_hasCustomPalette = false;
 191 #endif // wxUSE_PALETTE
 192
 193 #if wxUSE_ACCESSIBILITY
 194     m_accessible = NULL;
 195 #endif
 196
 197     m_virtualSize = wxDefaultSize;
 198
 199     m_scrollHelper = (wxScrollHelper *) NULL;
 200
 201     m_windowVariant = wxWINDOW_VARIANT_NORMAL;
 202 #if wxUSE_SYSTEM_OPTIONS
 203     if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT) )
 204     {
 205        m_windowVariant = (wxWindowVariant) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT ) ;
 206     }
 207 #endif
 208
 209     // Whether we're using the current theme for this window (wxGTK only for now)
 210     m_themeEnabled = false;
 211
 212     // VZ: this one shouldn't exist...
 213     m_isBeingDeleted = false;
 214
 215     m_freezeCount = 0;
 216 }
 217
 218 // common part of window creation process
 219 bool wxWindowBase::CreateBase(wxWindowBase *parent,
 220                               wxWindowID id,
 221                               const wxPoint& WXUNUSED(pos),
 222                               const wxSize& WXUNUSED(size),
 223                               long style,
 224                               const wxValidator& wxVALIDATOR_PARAM(validator),
 225                               const wxString& name)
 226 {
 227 #if wxUSE_STATBOX
 228     // wxGTK doesn't allow to create controls with static box as the parent so
 229     // this will result in a crash when the program is ported to wxGTK so warn
 230     // the user about it
 231
 232     // if you get this assert, the correct solution is to create the controls
 233     // as siblings of the static box
 234     wxASSERT_MSG( !parent || !wxDynamicCast(parent, wxStaticBox),
 235                   _T("wxStaticBox can't be used as a window parent!") );
 236 #endif // wxUSE_STATBOX
 237
 238     // ids are limited to 16 bits under MSW so if you care about portability,
 239     // it's not a good idea to use ids out of this range (and negative ids are
 240     // reserved for wxWidgets own usage)
 241     wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767) ||
 242                   (id >= wxID_AUTO_LOWEST && id <= wxID_AUTO_HIGHEST),
 243                   _T("invalid id value") );
 244
 245     // generate a new id if the user doesn't care about it
 246     if ( id == wxID_ANY )
 247     {
 248         m_windowId = NewControlId();
 249     }
 250     else // valid id specified
 251     {
 252         m_windowId = id;
 253     }
 254
 255     // don't use SetWindowStyleFlag() here, this function should only be called
 256     // to change the flag after creation as it tries to reflect the changes in
 257     // flags by updating the window dynamically and we don't need this here
 258     m_windowStyle = style;
 259
 260     SetName(name);
 261     SetParent(parent);
 262
 263 #if wxUSE_VALIDATORS
 264     SetValidator(validator);
 265 #endif // wxUSE_VALIDATORS
 266
 267     // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
 268     // have it too - like this it's possible to set it only in the top level
 269     // dialog/frame and all children will inherit it by defult
 270     if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
 271     {
 272         SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY);
 273     }
 274
 275     return true;
 276 }
 277
 278 bool wxWindowBase::ToggleWindowStyle(int flag)
 279 {
 280     wxASSERT_MSG( flag, _T("flags with 0 value can't be toggled") );
 281
 282     bool rc;
 283     long style = GetWindowStyleFlag();
 284     if ( style & flag )
 285     {
 286         style &= ~flag;
 287         rc = false;
 288     }
 289     else // currently off
 290     {
 291         style |= flag;
 292         rc = true;
 293     }
 294
 295     SetWindowStyleFlag(style);
 296
 297     return rc;
 298 }
 299
 300 // ----------------------------------------------------------------------------
 301 // destruction
 302 // ----------------------------------------------------------------------------
 303
 304 // common clean up
 305 wxWindowBase::~wxWindowBase()
 306 {
 307     wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
 308
 309     // FIXME if these 2 cases result from programming errors in the user code
 310     //       we should probably assert here instead of silently fixing them
 311
 312     // Just in case the window has been Closed, but we're then deleting
 313     // immediately: don't leave dangling pointers.
 314     wxPendingDelete.DeleteObject(this);
 315
 316     // Just in case we've loaded a top-level window via LoadNativeDialog but
 317     // we weren't a dialog class
 318     wxTopLevelWindows.DeleteObject((wxWindow*)this);
 319
 320 #if wxUSE_MENUS
 321     // The associated popup menu can still be alive, disassociate from it in
 322     // this case
 323     if ( wxCurrentPopupMenu && wxCurrentPopupMenu->GetInvokingWindow() == this )
 324         wxCurrentPopupMenu->SetInvokingWindow(NULL);
 325 #endif // wxUSE_MENUS
 326
 327     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 328
 329     // notify the parent about this window destruction
 330     if ( m_parent )
 331         m_parent->RemoveChild(this);
 332
 333 #if wxUSE_CARET
 334     delete m_caret;
 335 #endif // wxUSE_CARET
 336
 337 #if wxUSE_VALIDATORS
 338     delete m_windowValidator;
 339 #endif // wxUSE_VALIDATORS
 340
 341 #if wxUSE_CONSTRAINTS
 342     // Have to delete constraints/sizer FIRST otherwise sizers may try to look
 343     // at deleted windows as they delete themselves.
 344     DeleteRelatedConstraints();
 345
 346     if ( m_constraints )
 347     {
 348         // This removes any dangling pointers to this window in other windows'
 349         // constraintsInvolvedIn lists.
 350         UnsetConstraints(m_constraints);
 351         delete m_constraints;
 352         m_constraints = NULL;
 353     }
 354 #endif // wxUSE_CONSTRAINTS
 355
 356     if ( m_containingSizer )
 357         m_containingSizer->Detach( (wxWindow*)this );
 358
 359     delete m_windowSizer;
 360
 361 #if wxUSE_DRAG_AND_DROP
 362     delete m_dropTarget;
 363 #endif // wxUSE_DRAG_AND_DROP
 364
 365 #if wxUSE_TOOLTIPS
 366     delete m_tooltip;
 367 #endif // wxUSE_TOOLTIPS
 368
 369 #if wxUSE_ACCESSIBILITY
 370     delete m_accessible;
 371 #endif
 372
 373 #if wxUSE_HELP
 374     // NB: this has to be called unconditionally, because we don't know
 375     //     whether this window has associated help text or not
 376     wxHelpProvider *helpProvider = wxHelpProvider::Get();
 377     if ( helpProvider )
 378         helpProvider->RemoveHelp(this);
 379 #endif
 380 }
 381
 382 void wxWindowBase::SendDestroyEvent()
 383 {
 384     wxWindowDestroyEvent event;
 385     event.SetEventObject(this);
 386     event.SetId(GetId());
 387     GetEventHandler()->ProcessEvent(event);
 388 }
 389
 390 bool wxWindowBase::Destroy()
 391 {
 392     delete this;
 393
 394     return true;
 395 }
 396
 397 bool wxWindowBase::Close(bool force)
 398 {
 399     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
 400     event.SetEventObject(this);
 401     event.SetCanVeto(!force);
 402
 403     // return false if window wasn't closed because the application vetoed the
 404     // close event
 405     return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
 406 }
 407
 408 bool wxWindowBase::DestroyChildren()
 409 {
 410     wxWindowList::compatibility_iterator node;
 411     for ( ;; )
 412     {
 413         // we iterate until the list becomes empty
 414         node = GetChildren().GetFirst();
 415         if ( !node )
 416             break;
 417
 418         wxWindow *child = node->GetData();
 419
 420         // note that we really want to call delete and not ->Destroy() here
 421         // because we want to delete the child immediately, before we are
 422         // deleted, and delayed deletion would result in problems as our (top
 423         // level) child could outlive its parent
 424         delete child;
 425
 426         wxASSERT_MSG( !GetChildren().Find(child),
 427                       wxT("child didn't remove itself using RemoveChild()") );
 428     }
 429
 430     return true;
 431 }
 432
 433 // ----------------------------------------------------------------------------
 434 // size/position related methods
 435 // ----------------------------------------------------------------------------
 436
 437 // centre the window with respect to its parent in either (or both) directions
 438 void wxWindowBase::DoCentre(int dir)
 439 {
 440     wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(),
 441                  _T("this method only implements centering child windows") );
 442
 443     SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir));
 444 }
 445
 446 // fits the window around the children
 447 void wxWindowBase::Fit()
 448 {
 449     if ( !GetChildren().empty() )
 450     {
 451         SetSize(GetBestSize());
 452     }
 453     //else: do nothing if we have no children
 454 }
 455
 456 // fits virtual size (ie. scrolled area etc.) around children
 457 void wxWindowBase::FitInside()
 458 {
 459     if ( GetChildren().GetCount() > 0 )
 460     {
 461         SetVirtualSize( GetBestVirtualSize() );
 462     }
 463 }
 464
 465 // On Mac, scrollbars are explicitly children.
 466 #ifdef __WXMAC__
 467 static bool wxHasRealChildren(const wxWindowBase* win)
 468 {
 469     int realChildCount = 0;
 470
 471     for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
 472           node;
 473           node = node->GetNext() )
 474     {
 475         wxWindow *win = node->GetData();
 476         if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar)))
 477             realChildCount ++;
 478     }
 479     return (realChildCount > 0);
 480 }
 481 #endif
 482
 483 void wxWindowBase::InvalidateBestSize()
 484 {
 485     m_bestSizeCache = wxDefaultSize;
 486
 487     // parent's best size calculation may depend on its children's
 488     // as long as child window we are in is not top level window itself
 489     // (because the TLW size is never resized automatically)
 490     // so let's invalidate it as well to be safe:
 491     if (m_parent && !IsTopLevel())
 492         m_parent->InvalidateBestSize();
 493 }
 494
 495 // return the size best suited for the current window
 496 wxSize wxWindowBase::DoGetBestSize() const
 497 {
 498     wxSize best;
 499
 500     if ( m_windowSizer )
 501     {
 502         best = m_windowSizer->GetMinSize();
 503     }
 504 #if wxUSE_CONSTRAINTS
 505     else if ( m_constraints )
 506     {
 507         wxConstCast(this, wxWindowBase)->SatisfyConstraints();
 508
 509         // our minimal acceptable size is such that all our windows fit inside
 510         int maxX = 0,
 511             maxY = 0;
 512
 513         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 514               node;
 515               node = node->GetNext() )
 516         {
 517             wxLayoutConstraints *c = node->GetData()->GetConstraints();
 518             if ( !c )
 519             {
 520                 // it's not normal that we have an unconstrained child, but
 521                 // what can we do about it?
 522                 continue;
 523             }
 524
 525             int x = c->right.GetValue(),
 526                 y = c->bottom.GetValue();
 527
 528             if ( x > maxX )
 529                 maxX = x;
 530
 531             if ( y > maxY )
 532                 maxY = y;
 533
 534             // TODO: we must calculate the overlaps somehow, otherwise we
 535             //       will never return a size bigger than the current one :-(
 536         }
 537
 538         best = wxSize(maxX, maxY);
 539     }
 540 #endif // wxUSE_CONSTRAINTS
 541     else if ( !GetChildren().empty()
 542 #ifdef __WXMAC__
 543               && wxHasRealChildren(this)
 544 #endif
 545               )
 546     {
 547         // our minimal acceptable size is such that all our visible child
 548         // 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                     || !win->IsShown()
 559 #if wxUSE_STATUSBAR
 560                         || wxDynamicCast(win, wxStatusBar)
 561 #endif // wxUSE_STATUSBAR
 562                )
 563             {
 564                 // dialogs and frames lie in different top level windows -
 565                 // don't deal with them here; as for the status bars, they
 566                 // don't lie in the client area at all
 567                 continue;
 568             }
 569
 570             int wx, wy, ww, wh;
 571             win->GetPosition(&wx, &wy);
 572
 573             // if the window hadn't been positioned yet, assume that it is in
 574             // the origin
 575             if ( wx == wxDefaultCoord )
 576                 wx = 0;
 577             if ( wy == wxDefaultCoord )
 578                 wy = 0;
 579
 580             win->GetSize(&ww, &wh);
 581             if ( wx + ww > maxX )
 582                 maxX = wx + ww;
 583             if ( wy + wh > maxY )
 584                 maxY = wy + wh;
 585         }
 586
 587         best = wxSize(maxX, maxY);
 588     }
 589     else // ! has children
 590     {
 591         // for a generic window there is no natural best size so, if the
 592         // minimal size is not set, use the current size but take care to
 593         // remember it as minimal size for the next time because our best size
 594         // should be constant: otherwise we could get into a situation when the
 595         // window is initially at some size, then expanded to a larger size and
 596         // then, when the containing window is shrunk back (because our initial
 597         // best size had been used for computing the parent min size), we can't
 598         // be shrunk back any more because our best size is now bigger
 599         wxSize size = GetMinSize();
 600         if ( !size.IsFullySpecified() )
 601         {
 602             size.SetDefaults(GetSize());
 603             wxConstCast(this, wxWindowBase)->SetMinSize(size);
 604         }
 605
 606         // return as-is, unadjusted by the client size difference.
 607         return size;
 608     }
 609
 610     // Add any difference between size and client size
 611     wxSize diff = GetSize() - GetClientSize();
 612     best.x += wxMax(0, diff.x);
 613     best.y += wxMax(0, diff.y);
 614
 615     return best;
 616 }
 617
 618 // helper of GetWindowBorderSize(): as many ports don't implement support for
 619 // wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded
 620 // fallbacks in this case
 621 static int wxGetMetricOrDefault(wxSystemMetric what)
 622 {
 623     int rc = wxSystemSettings::GetMetric(what);
 624     if ( rc == -1 )
 625     {
 626         switch ( what )
 627         {
 628             case wxSYS_BORDER_X:
 629             case wxSYS_BORDER_Y:
 630                 // 2D border is by default 1 pixel wide
 631                 rc = 1;
 632                 break;
 633
 634             case wxSYS_EDGE_X:
 635             case wxSYS_EDGE_Y:
 636                 // 3D borders are by default 2 pixels
 637                 rc = 2;
 638                 break;
 639
 640             default:
 641                 wxFAIL_MSG( _T("unexpected wxGetMetricOrDefault() argument") );
 642                 rc = 0;
 643         }
 644     }
 645
 646     return rc;
 647 }
 648
 649 wxSize wxWindowBase::GetWindowBorderSize() const
 650 {
 651     wxSize size;
 652
 653     switch ( GetBorder() )
 654     {
 655         case wxBORDER_NONE:
 656             // nothing to do, size is already (0, 0)
 657             break;
 658
 659         case wxBORDER_SIMPLE:
 660         case wxBORDER_STATIC:
 661             size.x = wxGetMetricOrDefault(wxSYS_BORDER_X);
 662             size.y = wxGetMetricOrDefault(wxSYS_BORDER_Y);
 663             break;
 664
 665         case wxBORDER_SUNKEN:
 666         case wxBORDER_RAISED:
 667             size.x = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X),
 668                            wxGetMetricOrDefault(wxSYS_BORDER_X));
 669             size.y = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y),
 670                            wxGetMetricOrDefault(wxSYS_BORDER_Y));
 671             break;
 672
 673         case wxBORDER_DOUBLE:
 674             size.x = wxGetMetricOrDefault(wxSYS_EDGE_X) +
 675                         wxGetMetricOrDefault(wxSYS_BORDER_X);
 676             size.y = wxGetMetricOrDefault(wxSYS_EDGE_Y) +
 677                         wxGetMetricOrDefault(wxSYS_BORDER_Y);
 678             break;
 679
 680         default:
 681             wxFAIL_MSG(_T("Unknown border style."));
 682             break;
 683     }
 684
 685     // we have borders on both sides
 686     return size*2;
 687 }
 688
 689 wxSize wxWindowBase::GetEffectiveMinSize() const
 690 {
 691     // merge the best size with the min size, giving priority to the min size
 692     wxSize min = GetMinSize();
 693     if (min.x == wxDefaultCoord || min.y == wxDefaultCoord)
 694     {
 695         wxSize best = GetBestSize();
 696         if (min.x == wxDefaultCoord) min.x =  best.x;
 697         if (min.y == wxDefaultCoord) min.y =  best.y;
 698     }
 699     return min;
 700 }
 701
 702
 703 void wxWindowBase::SetInitialSize(const wxSize& size)
 704 {
 705     // Set the min size to the size passed in.  This will usually either be
 706     // wxDefaultSize or the size passed to this window's ctor/Create function.
 707     SetMinSize(size);
 708
 709     // Merge the size with the best size if needed
 710     wxSize best = GetEffectiveMinSize();
 711
 712     // If the current size doesn't match then change it
 713     if (GetSize() != best)
 714         SetSize(best);
 715 }
 716
 717
 718 // by default the origin is not shifted
 719 wxPoint wxWindowBase::GetClientAreaOrigin() const
 720 {
 721     return wxPoint(0,0);
 722 }
 723
 724 wxSize wxWindowBase::ClientToWindowSize(const wxSize& size) const
 725 {
 726     const wxSize diff(GetSize() - GetClientSize());
 727
 728     return wxSize(size.x == -1 ? -1 : size.x + diff.x,
 729                   size.y == -1 ? -1 : size.y + diff.y);
 730 }
 731
 732 wxSize wxWindowBase::WindowToClientSize(const wxSize& size) const
 733 {
 734     const wxSize diff(GetSize() - GetClientSize());
 735
 736     return wxSize(size.x == -1 ? -1 : size.x - diff.x,
 737                   size.y == -1 ? -1 : size.y - diff.y);
 738 }
 739
 740 void wxWindowBase::SetWindowVariant( wxWindowVariant variant )
 741 {
 742     if ( m_windowVariant != variant )
 743     {
 744         m_windowVariant = variant;
 745
 746         DoSetWindowVariant(variant);
 747     }
 748 }
 749
 750 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant )
 751 {
 752     // adjust the font height to correspond to our new variant (notice that
 753     // we're only called if something really changed)
 754     wxFont font = GetFont();
 755     int size = font.GetPointSize();
 756     switch ( variant )
 757     {
 758         case wxWINDOW_VARIANT_NORMAL:
 759             break;
 760
 761         case wxWINDOW_VARIANT_SMALL:
 762             size *= 3;
 763             size /= 4;
 764             break;
 765
 766         case wxWINDOW_VARIANT_MINI:
 767             size *= 2;
 768             size /= 3;
 769             break;
 770
 771         case wxWINDOW_VARIANT_LARGE:
 772             size *= 5;
 773             size /= 4;
 774             break;
 775
 776         default:
 777             wxFAIL_MSG(_T("unexpected window variant"));
 778             break;
 779     }
 780
 781     font.SetPointSize(size);
 782     SetFont(font);
 783 }
 784
 785 void wxWindowBase::DoSetSizeHints( int minW, int minH,
 786                                    int maxW, int maxH,
 787                                    int WXUNUSED(incW), int WXUNUSED(incH) )
 788 {
 789     wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
 790                     (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
 791                  _T("min width/height must be less than max width/height!") );
 792
 793     m_minWidth = minW;
 794     m_maxWidth = maxW;
 795     m_minHeight = minH;
 796     m_maxHeight = maxH;
 797 }
 798
 799
 800 #if WXWIN_COMPATIBILITY_2_8
 801 void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW), int WXUNUSED(minH),
 802                                        int WXUNUSED(maxW), int WXUNUSED(maxH))
 803 {
 804 }
 805
 806 void wxWindowBase::SetVirtualSizeHints(const wxSize& WXUNUSED(minsize),
 807                                        const wxSize& WXUNUSED(maxsize))
 808 {
 809 }
 810 #endif // WXWIN_COMPATIBILITY_2_8
 811
 812 void wxWindowBase::DoSetVirtualSize( int x, int y )
 813 {
 814     m_virtualSize = wxSize(x, y);
 815 }
 816
 817 wxSize wxWindowBase::DoGetVirtualSize() const
 818 {
 819     // we should use the entire client area so if it is greater than our
 820     // virtual size, expand it to fit (otherwise if the window is big enough we
 821     // wouldn't be using parts of it)
 822     wxSize size = GetClientSize();
 823     if ( m_virtualSize.x > size.x )
 824         size.x = m_virtualSize.x;
 825
 826     if ( m_virtualSize.y >= size.y )
 827         size.y = m_virtualSize.y;
 828
 829     return size;
 830 }
 831
 832 void wxWindowBase::DoGetScreenPosition(int *x, int *y) const
 833 {
 834     // screen position is the same as (0, 0) in client coords for non TLWs (and
 835     // TLWs override this method)
 836     if ( x )
 837         *x = 0;
 838     if ( y )
 839         *y = 0;
 840
 841     ClientToScreen(x, y);
 842 }
 843
 844 // ----------------------------------------------------------------------------
 845 // show/hide/enable/disable the window
 846 // ----------------------------------------------------------------------------
 847
 848 bool wxWindowBase::Show(bool show)
 849 {
 850     if ( show != m_isShown )
 851     {
 852         m_isShown = show;
 853
 854         return true;
 855     }
 856     else
 857     {
 858         return false;
 859     }
 860 }
 861
 862 bool wxWindowBase::IsEnabled() const
 863 {
 864     return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled());
 865 }
 866
 867 void wxWindowBase::NotifyWindowOnEnableChange(bool enabled)
 868 {
 869 #ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
 870     DoEnable(enabled);
 871 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
 872
 873     OnEnabled(enabled);
 874
 875     // If we are top-level then the logic doesn't apply - otherwise
 876     // showing a modal dialog would result in total greying out (and ungreying
 877     // out later) of everything which would be really ugly
 878     if ( IsTopLevel() )
 879         return;
 880
 881     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 882           node;
 883           node = node->GetNext() )
 884     {
 885         wxWindowBase * const child = node->GetData();
 886         if ( !child->IsTopLevel() && child->IsThisEnabled() )
 887             child->NotifyWindowOnEnableChange(enabled);
 888     }
 889 }
 890
 891 bool wxWindowBase::Enable(bool enable)
 892 {
 893     if ( enable == IsThisEnabled() )
 894         return false;
 895
 896     m_isEnabled = enable;
 897
 898 #ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT
 899     DoEnable(enable);
 900 #else // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
 901     wxWindowBase * const parent = GetParent();
 902     if( !IsTopLevel() && parent && !parent->IsEnabled() )
 903     {
 904         return true;
 905     }
 906 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
 907
 908     NotifyWindowOnEnableChange(enable);
 909
 910     return true;
 911 }
 912
 913 bool wxWindowBase::IsShownOnScreen() const
 914 {
 915     // A window is shown on screen if it itself is shown and so are all its
 916     // parents. But if a window is toplevel one, then its always visible on
 917     // screen if IsShown() returns true, even if it has a hidden parent.
 918     return IsShown() &&
 919            (IsTopLevel() || GetParent() == NULL || GetParent()->IsShownOnScreen());
 920 }
 921
 922 // ----------------------------------------------------------------------------
 923 // RTTI
 924 // ----------------------------------------------------------------------------
 925
 926 bool wxWindowBase::IsTopLevel() const
 927 {
 928     return false;
 929 }
 930
 931 // ----------------------------------------------------------------------------
 932 // Freeze/Thaw
 933 // ----------------------------------------------------------------------------
 934
 935 void wxWindowBase::Freeze()
 936 {
 937     if ( !m_freezeCount++ )
 938     {
 939         // physically freeze this window:
 940         DoFreeze();
 941
 942         // and recursively freeze all children:
 943         for ( wxWindowList::iterator i = GetChildren().begin();
 944               i != GetChildren().end(); ++i )
 945         {
 946             wxWindow *child = *i;
 947             if ( child->IsTopLevel() )
 948                 continue;
 949
 950             child->Freeze();
 951         }
 952     }
 953 }
 954
 955 void wxWindowBase::Thaw()
 956 {
 957     wxASSERT_MSG( m_freezeCount, "Thaw() without matching Freeze()" );
 958
 959     if ( !--m_freezeCount )
 960     {
 961         // recursively thaw all children:
 962         for ( wxWindowList::iterator i = GetChildren().begin();
 963               i != GetChildren().end(); ++i )
 964         {
 965             wxWindow *child = *i;
 966             if ( child->IsTopLevel() )
 967                 continue;
 968
 969             child->Thaw();
 970         }
 971
 972         // physically thaw this window:
 973         DoThaw();
 974     }
 975 }
 976
 977 // ----------------------------------------------------------------------------
 978 // reparenting the window
 979 // ----------------------------------------------------------------------------
 980
 981 void wxWindowBase::AddChild(wxWindowBase *child)
 982 {
 983     wxCHECK_RET( child, wxT("can't add a NULL child") );
 984
 985     // this should never happen and it will lead to a crash later if it does
 986     // because RemoveChild() will remove only one node from the children list
 987     // and the other(s) one(s) will be left with dangling pointers in them
 988     wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), _T("AddChild() called twice") );
 989
 990     GetChildren().Append((wxWindow*)child);
 991     child->SetParent(this);
 992
 993     // adding a child while frozen will assert when thawn, so freeze it as if
 994     // it had been already present when we were frozen
 995     if ( IsFrozen() && !child->IsTopLevel() )
 996         child->Freeze();
 997 }
 998
 999 void wxWindowBase::RemoveChild(wxWindowBase *child)
1000 {
1001     wxCHECK_RET( child, wxT("can't remove a NULL child") );
1002
1003     // removing a child while frozen may result in permanently frozen window
1004     // if used e.g. from Reparent(), so thaw it
1005     if ( IsFrozen() && !child->IsTopLevel() )
1006         child->Thaw();
1007
1008     GetChildren().DeleteObject((wxWindow *)child);
1009     child->SetParent(NULL);
1010 }
1011
1012 bool wxWindowBase::Reparent(wxWindowBase *newParent)
1013 {
1014     wxWindow *oldParent = GetParent();
1015     if ( newParent == oldParent )
1016     {
1017         // nothing done
1018         return false;
1019     }
1020
1021     const bool oldEnabledState = IsEnabled();
1022
1023     // unlink this window from the existing parent.
1024     if ( oldParent )
1025     {
1026         oldParent->RemoveChild(this);
1027     }
1028     else
1029     {
1030         wxTopLevelWindows.DeleteObject((wxWindow *)this);
1031     }
1032
1033     // add it to the new one
1034     if ( newParent )
1035     {
1036         newParent->AddChild(this);
1037     }
1038     else
1039     {
1040         wxTopLevelWindows.Append((wxWindow *)this);
1041     }
1042
1043     // We need to notify window (and its subwindows) if by changing the parent
1044     // we also change our enabled/disabled status.
1045     const bool newEnabledState = IsEnabled();
1046     if ( newEnabledState != oldEnabledState )
1047     {
1048         NotifyWindowOnEnableChange(newEnabledState);
1049     }
1050
1051     return true;
1052 }
1053
1054 // ----------------------------------------------------------------------------
1055 // event handler stuff
1056 // ----------------------------------------------------------------------------
1057
1058 void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
1059 {
1060     wxEvtHandler *handlerOld = GetEventHandler();
1061
1062     handler->SetNextHandler(handlerOld);
1063
1064     if ( handlerOld )
1065         GetEventHandler()->SetPreviousHandler(handler);
1066
1067     SetEventHandler(handler);
1068 }
1069
1070 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
1071 {
1072     wxEvtHandler *handlerA = GetEventHandler();
1073     if ( handlerA )
1074     {
1075         wxEvtHandler *handlerB = handlerA->GetNextHandler();
1076         handlerA->SetNextHandler((wxEvtHandler *)NULL);
1077
1078         if ( handlerB )
1079             handlerB->SetPreviousHandler((wxEvtHandler *)NULL);
1080         SetEventHandler(handlerB);
1081
1082         if ( deleteHandler )
1083         {
1084             delete handlerA;
1085             handlerA = (wxEvtHandler *)NULL;
1086         }
1087     }
1088
1089     return handlerA;
1090 }
1091
1092 bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
1093 {
1094     wxCHECK_MSG( handler, false, _T("RemoveEventHandler(NULL) called") );
1095
1096     wxEvtHandler *handlerPrev = NULL,
1097                  *handlerCur = GetEventHandler();
1098     while ( handlerCur )
1099     {
1100         wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
1101
1102         if ( handlerCur == handler )
1103         {
1104             if ( handlerPrev )
1105             {
1106                 handlerPrev->SetNextHandler(handlerNext);
1107             }
1108             else
1109             {
1110                 SetEventHandler(handlerNext);
1111             }
1112
1113             if ( handlerNext )
1114             {
1115                 handlerNext->SetPreviousHandler ( handlerPrev );
1116             }
1117
1118             handler->SetNextHandler(NULL);
1119             handler->SetPreviousHandler(NULL);
1120
1121             return true;
1122         }
1123
1124         handlerPrev = handlerCur;
1125         handlerCur = handlerNext;
1126     }
1127
1128     wxFAIL_MSG( _T("where has the event handler gone?") );
1129
1130     return false;
1131 }
1132
1133 bool wxWindowBase::HandleWindowEvent(wxEvent& event) const
1134 {
1135     return GetEventHandler()->SafelyProcessEvent(event);
1136 }
1137
1138 // ----------------------------------------------------------------------------
1139 // colours, fonts &c
1140 // ----------------------------------------------------------------------------
1141
1142 void wxWindowBase::InheritAttributes()
1143 {
1144     const wxWindowBase * const parent = GetParent();
1145     if ( !parent )
1146         return;
1147
1148     // we only inherit attributes which had been explicitly set for the parent
1149     // which ensures that this only happens if the user really wants it and
1150     // not by default which wouldn't make any sense in modern GUIs where the
1151     // controls don't all use the same fonts (nor colours)
1152     if ( parent->m_inheritFont && !m_hasFont )
1153         SetFont(parent->GetFont());
1154
1155     // in addition, there is a possibility to explicitly forbid inheriting
1156     // colours at each class level by overriding ShouldInheritColours()
1157     if ( ShouldInheritColours() )
1158     {
1159         if ( parent->m_inheritFgCol && !m_hasFgCol )
1160             SetForegroundColour(parent->GetForegroundColour());
1161
1162         // inheriting (solid) background colour is wrong as it totally breaks
1163         // any kind of themed backgrounds
1164         //
1165         // instead, the controls should use the same background as their parent
1166         // (ideally by not drawing it at all)
1167 #if 0
1168         if ( parent->m_inheritBgCol && !m_hasBgCol )
1169             SetBackgroundColour(parent->GetBackgroundColour());
1170 #endif // 0
1171     }
1172 }
1173
1174 /* static */ wxVisualAttributes
1175 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1176 {
1177     // it is important to return valid values for all attributes from here,
1178     // GetXXX() below rely on this
1179     wxVisualAttributes attrs;
1180     attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
1181     attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
1182
1183     // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
1184     // the usual background colour than wxSYS_COLOUR_BTNFACE.
1185     // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
1186     // colour on other platforms.
1187
1188 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
1189     attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1190 #else
1191     attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
1192 #endif
1193     return attrs;
1194 }
1195
1196 wxColour wxWindowBase::GetBackgroundColour() const
1197 {
1198     if ( !m_backgroundColour.IsOk() )
1199     {
1200         wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") );
1201
1202         // get our default background colour
1203         wxColour colBg = GetDefaultAttributes().colBg;
1204
1205         // we must return some valid colour to avoid redoing this every time
1206         // and also to avoid surprizing the applications written for older
1207         // wxWidgets versions where GetBackgroundColour() always returned
1208         // something -- so give them something even if it doesn't make sense
1209         // for this window (e.g. it has a themed background)
1210         if ( !colBg.Ok() )
1211             colBg = GetClassDefaultAttributes().colBg;
1212
1213         return colBg;
1214     }
1215     else
1216         return m_backgroundColour;
1217 }
1218
1219 wxColour wxWindowBase::GetForegroundColour() const
1220 {
1221     // logic is the same as above
1222     if ( !m_hasFgCol && !m_foregroundColour.Ok() )
1223     {
1224         wxColour colFg = GetDefaultAttributes().colFg;
1225
1226         if ( !colFg.IsOk() )
1227             colFg = GetClassDefaultAttributes().colFg;
1228
1229         return colFg;
1230     }
1231     else
1232         return m_foregroundColour;
1233 }
1234
1235 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
1236 {
1237     if ( colour == m_backgroundColour )
1238         return false;
1239
1240     m_hasBgCol = colour.IsOk();
1241     if ( m_backgroundStyle != wxBG_STYLE_CUSTOM )
1242         m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM;
1243
1244     m_inheritBgCol = m_hasBgCol;
1245     m_backgroundColour = colour;
1246     SetThemeEnabled( !m_hasBgCol && !m_foregroundColour.Ok() );
1247     return true;
1248 }
1249
1250 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
1251 {
1252     if (colour == m_foregroundColour )
1253         return false;
1254
1255     m_hasFgCol = colour.IsOk();
1256     m_inheritFgCol = m_hasFgCol;
1257     m_foregroundColour = colour;
1258     SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() );
1259     return true;
1260 }
1261
1262 bool wxWindowBase::SetCursor(const wxCursor& cursor)
1263 {
1264     // setting an invalid cursor is ok, it means that we don't have any special
1265     // cursor
1266     if ( m_cursor.IsSameAs(cursor) )
1267     {
1268         // no change
1269         return false;
1270     }
1271
1272     m_cursor = cursor;
1273
1274     return true;
1275 }
1276
1277 wxFont wxWindowBase::GetFont() const
1278 {
1279     // logic is the same as in GetBackgroundColour()
1280     if ( !m_font.IsOk() )
1281     {
1282         wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") );
1283
1284         wxFont font = GetDefaultAttributes().font;
1285         if ( !font.IsOk() )
1286             font = GetClassDefaultAttributes().font;
1287
1288         return font;
1289     }
1290     else
1291         return m_font;
1292 }
1293
1294 bool wxWindowBase::SetFont(const wxFont& font)
1295 {
1296     if ( font == m_font )
1297     {
1298         // no change
1299         return false;
1300     }
1301
1302     m_font = font;
1303     m_hasFont = font.IsOk();
1304     m_inheritFont = m_hasFont;
1305
1306     InvalidateBestSize();
1307
1308     return true;
1309 }
1310
1311 #if wxUSE_PALETTE
1312
1313 void wxWindowBase::SetPalette(const wxPalette& pal)
1314 {
1315     m_hasCustomPalette = true;
1316     m_palette = pal;
1317
1318     // VZ: can anyone explain me what do we do here?
1319     wxWindowDC d((wxWindow *) this);
1320     d.SetPalette(pal);
1321 }
1322
1323 wxWindow *wxWindowBase::GetAncestorWithCustomPalette() const
1324 {
1325     wxWindow *win = (wxWindow *)this;
1326     while ( win && !win->HasCustomPalette() )
1327     {
1328         win = win->GetParent();
1329     }
1330
1331     return win;
1332 }
1333
1334 #endif // wxUSE_PALETTE
1335
1336 #if wxUSE_CARET
1337 void wxWindowBase::SetCaret(wxCaret *caret)
1338 {
1339     if ( m_caret )
1340     {
1341         delete m_caret;
1342     }
1343
1344     m_caret = caret;
1345
1346     if ( m_caret )
1347     {
1348         wxASSERT_MSG( m_caret->GetWindow() == this,
1349                       wxT("caret should be created associated to this window") );
1350     }
1351 }
1352 #endif // wxUSE_CARET
1353
1354 #if wxUSE_VALIDATORS
1355 // ----------------------------------------------------------------------------
1356 // validators
1357 // ----------------------------------------------------------------------------
1358
1359 void wxWindowBase::SetValidator(const wxValidator& validator)
1360 {
1361     if ( m_windowValidator )
1362         delete m_windowValidator;
1363
1364     m_windowValidator = (wxValidator *)validator.Clone();
1365
1366     if ( m_windowValidator )
1367         m_windowValidator->SetWindow(this);
1368 }
1369 #endif // wxUSE_VALIDATORS
1370
1371 // ----------------------------------------------------------------------------
1372 // update region stuff
1373 // ----------------------------------------------------------------------------
1374
1375 wxRect wxWindowBase::GetUpdateClientRect() const
1376 {
1377     wxRegion rgnUpdate = GetUpdateRegion();
1378     rgnUpdate.Intersect(GetClientRect());
1379     wxRect rectUpdate = rgnUpdate.GetBox();
1380     wxPoint ptOrigin = GetClientAreaOrigin();
1381     rectUpdate.x -= ptOrigin.x;
1382     rectUpdate.y -= ptOrigin.y;
1383
1384     return rectUpdate;
1385 }
1386
1387 bool wxWindowBase::DoIsExposed(int x, int y) const
1388 {
1389     return m_updateRegion.Contains(x, y) != wxOutRegion;
1390 }
1391
1392 bool wxWindowBase::DoIsExposed(int x, int y, int w, int h) const
1393 {
1394     return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
1395 }
1396
1397 void wxWindowBase::ClearBackground()
1398 {
1399     // wxGTK uses its own version, no need to add never used code
1400 #ifndef __WXGTK__
1401     wxClientDC dc((wxWindow *)this);
1402     wxBrush brush(GetBackgroundColour(), wxSOLID);
1403     dc.SetBackground(brush);
1404     dc.Clear();
1405 #endif // __WXGTK__
1406 }
1407
1408 // ----------------------------------------------------------------------------
1409 // find child window by id or name
1410 // ----------------------------------------------------------------------------
1411
1412 wxWindow *wxWindowBase::FindWindow(long id) const
1413 {
1414     if ( id == m_windowId )
1415         return (wxWindow *)this;
1416
1417     wxWindowBase *res = (wxWindow *)NULL;
1418     wxWindowList::compatibility_iterator node;
1419     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
1420     {
1421         wxWindowBase *child = node->GetData();
1422         res = child->FindWindow( id );
1423     }
1424
1425     return (wxWindow *)res;
1426 }
1427
1428 wxWindow *wxWindowBase::FindWindow(const wxString& name) const
1429 {
1430     if ( name == m_windowName )
1431         return (wxWindow *)this;
1432
1433     wxWindowBase *res = (wxWindow *)NULL;
1434     wxWindowList::compatibility_iterator node;
1435     for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
1436     {
1437         wxWindow *child = node->GetData();
1438         res = child->FindWindow(name);
1439     }
1440
1441     return (wxWindow *)res;
1442 }
1443
1444
1445 // find any window by id or name or label: If parent is non-NULL, look through
1446 // children for a label or title matching the specified string. If NULL, look
1447 // through all top-level windows.
1448 //
1449 // to avoid duplicating code we reuse the same helper function but with
1450 // different comparators
1451
1452 typedef bool (*wxFindWindowCmp)(const wxWindow *win,
1453                                 const wxString& label, long id);
1454
1455 static
1456 bool wxFindWindowCmpLabels(const wxWindow *win, const wxString& label,
1457                            long WXUNUSED(id))
1458 {
1459     return win->GetLabel() == label;
1460 }
1461
1462 static
1463 bool wxFindWindowCmpNames(const wxWindow *win, const wxString& label,
1464                           long WXUNUSED(id))
1465 {
1466     return win->GetName() == label;
1467 }
1468
1469 static
1470 bool wxFindWindowCmpIds(const wxWindow *win, const wxString& WXUNUSED(label),
1471                         long id)
1472 {
1473     return win->GetId() == id;
1474 }
1475
1476 // recursive helper for the FindWindowByXXX() functions
1477 static
1478 wxWindow *wxFindWindowRecursively(const wxWindow *parent,
1479                                   const wxString& label,
1480                                   long id,
1481                                   wxFindWindowCmp cmp)
1482 {
1483     if ( parent )
1484     {
1485         // see if this is the one we're looking for
1486         if ( (*cmp)(parent, label, id) )
1487             return (wxWindow *)parent;
1488
1489         // It wasn't, so check all its children
1490         for ( wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();
1491               node;
1492               node = node->GetNext() )
1493         {
1494             // recursively check each child
1495             wxWindow *win = (wxWindow *)node->GetData();
1496             wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1497             if (retwin)
1498                 return retwin;
1499         }
1500     }
1501
1502     // Not found
1503     return NULL;
1504 }
1505
1506 // helper for FindWindowByXXX()
1507 static
1508 wxWindow *wxFindWindowHelper(const wxWindow *parent,
1509                              const wxString& label,
1510                              long id,
1511                              wxFindWindowCmp cmp)
1512 {
1513     if ( parent )
1514     {
1515         // just check parent and all its children
1516         return wxFindWindowRecursively(parent, label, id, cmp);
1517     }
1518
1519     // start at very top of wx's windows
1520     for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
1521           node;
1522           node = node->GetNext() )
1523     {
1524         // recursively check each window & its children
1525         wxWindow *win = node->GetData();
1526         wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1527         if (retwin)
1528             return retwin;
1529     }
1530
1531     return NULL;
1532 }
1533
1534 /* static */
1535 wxWindow *
1536 wxWindowBase::FindWindowByLabel(const wxString& title, const wxWindow *parent)
1537 {
1538     return wxFindWindowHelper(parent, title, 0, wxFindWindowCmpLabels);
1539 }
1540
1541 /* static */
1542 wxWindow *
1543 wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent)
1544 {
1545     wxWindow *win = wxFindWindowHelper(parent, title, 0, wxFindWindowCmpNames);
1546
1547     if ( !win )
1548     {
1549         // fall back to the label
1550         win = FindWindowByLabel(title, parent);
1551     }
1552
1553     return win;
1554 }
1555
1556 /* static */
1557 wxWindow *
1558 wxWindowBase::FindWindowById( long id, const wxWindow* parent )
1559 {
1560     return wxFindWindowHelper(parent, wxEmptyString, id, wxFindWindowCmpIds);
1561 }
1562
1563 // ----------------------------------------------------------------------------
1564 // dialog oriented functions
1565 // ----------------------------------------------------------------------------
1566
1567 void wxWindowBase::MakeModal(bool modal)
1568 {
1569     // Disable all other windows
1570     if ( IsTopLevel() )
1571     {
1572         wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
1573         while (node)
1574         {
1575             wxWindow *win = node->GetData();
1576             if (win != this)
1577                 win->Enable(!modal);
1578
1579             node = node->GetNext();
1580         }
1581     }
1582 }
1583
1584 bool wxWindowBase::Validate()
1585 {
1586 #if wxUSE_VALIDATORS
1587     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1588
1589     wxWindowList::compatibility_iterator node;
1590     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1591     {
1592         wxWindowBase *child = node->GetData();
1593         wxValidator *validator = child->GetValidator();
1594         if ( validator && !validator->Validate((wxWindow *)this) )
1595         {
1596             return false;
1597         }
1598
1599         if ( recurse && !child->Validate() )
1600         {
1601             return false;
1602         }
1603     }
1604 #endif // wxUSE_VALIDATORS
1605
1606     return true;
1607 }
1608
1609 bool wxWindowBase::TransferDataToWindow()
1610 {
1611 #if wxUSE_VALIDATORS
1612     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1613
1614     wxWindowList::compatibility_iterator node;
1615     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1616     {
1617         wxWindowBase *child = node->GetData();
1618         wxValidator *validator = child->GetValidator();
1619         if ( validator && !validator->TransferToWindow() )
1620         {
1621             wxLogWarning(_("Could not transfer data to window"));
1622 #if wxUSE_LOG
1623             wxLog::FlushActive();
1624 #endif // wxUSE_LOG
1625
1626             return false;
1627         }
1628
1629         if ( recurse )
1630         {
1631             if ( !child->TransferDataToWindow() )
1632             {
1633                 // warning already given
1634                 return false;
1635             }
1636         }
1637     }
1638 #endif // wxUSE_VALIDATORS
1639
1640     return true;
1641 }
1642
1643 bool wxWindowBase::TransferDataFromWindow()
1644 {
1645 #if wxUSE_VALIDATORS
1646     bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1647
1648     wxWindowList::compatibility_iterator node;
1649     for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1650     {
1651         wxWindow *child = node->GetData();
1652         wxValidator *validator = child->GetValidator();
1653         if ( validator && !validator->TransferFromWindow() )
1654         {
1655             // nop warning here because the application is supposed to give
1656             // one itself - we don't know here what might have gone wrongly
1657
1658             return false;
1659         }
1660
1661         if ( recurse )
1662         {
1663             if ( !child->TransferDataFromWindow() )
1664             {
1665                 // warning already given
1666                 return false;
1667             }
1668         }
1669     }
1670 #endif // wxUSE_VALIDATORS
1671
1672     return true;
1673 }
1674
1675 void wxWindowBase::InitDialog()
1676 {
1677     wxInitDialogEvent event(GetId());
1678     event.SetEventObject( this );
1679     GetEventHandler()->ProcessEvent(event);
1680 }
1681
1682 // ----------------------------------------------------------------------------
1683 // context-sensitive help support
1684 // ----------------------------------------------------------------------------
1685
1686 #if wxUSE_HELP
1687
1688 // associate this help text with this window
1689 void wxWindowBase::SetHelpText(const wxString& text)
1690 {
1691     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1692     if ( helpProvider )
1693     {
1694         helpProvider->AddHelp(this, text);
1695     }
1696 }
1697
1698 // associate this help text with all windows with the same id as this
1699 // one
1700 void wxWindowBase::SetHelpTextForId(const wxString& text)
1701 {
1702     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1703     if ( helpProvider )
1704     {
1705         helpProvider->AddHelp(GetId(), text);
1706     }
1707 }
1708
1709 // get the help string associated with this window (may be empty)
1710 // default implementation forwards calls to the help provider
1711 wxString
1712 wxWindowBase::GetHelpTextAtPoint(const wxPoint & WXUNUSED(pt),
1713                                  wxHelpEvent::Origin WXUNUSED(origin)) const
1714 {
1715     wxString text;
1716     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1717     if ( helpProvider )
1718     {
1719         text = helpProvider->GetHelp(this);
1720     }
1721
1722     return text;
1723 }
1724
1725 // show help for this window
1726 void wxWindowBase::OnHelp(wxHelpEvent& event)
1727 {
1728     wxHelpProvider *helpProvider = wxHelpProvider::Get();
1729     if ( helpProvider )
1730     {
1731         wxPoint pos = event.GetPosition();
1732         const wxHelpEvent::Origin origin = event.GetOrigin();
1733         if ( origin == wxHelpEvent::Origin_Keyboard )
1734         {
1735             // if the help event was generated from keyboard it shouldn't
1736             // appear at the mouse position (which is still the only position
1737             // associated with help event) if the mouse is far away, although
1738             // we still do use the mouse position if it's over the window
1739             // because we suppose the user looks approximately at the mouse
1740             // already and so it would be more convenient than showing tooltip
1741             // at some arbitrary position which can be quite far from it
1742             const wxRect rectClient = GetClientRect();
1743             if ( !rectClient.Contains(ScreenToClient(pos)) )
1744             {
1745                 // position help slightly under and to the right of this window
1746                 pos = ClientToScreen(wxPoint(
1747                         2*GetCharWidth(),
1748                         rectClient.height + GetCharHeight()
1749                       ));
1750             }
1751         }
1752
1753         if ( helpProvider->ShowHelpAtPoint(this, pos, origin) )
1754         {
1755             // skip the event.Skip() below
1756             return;
1757         }
1758     }
1759
1760     event.Skip();
1761 }
1762
1763 #endif // wxUSE_HELP
1764
1765 // ----------------------------------------------------------------------------
1766 // tooltips
1767 // ----------------------------------------------------------------------------
1768
1769 #if wxUSE_TOOLTIPS
1770
1771 void wxWindowBase::SetToolTip( const wxString &tip )
1772 {
1773     // don't create the new tooltip if we already have one
1774     if ( m_tooltip )
1775     {
1776         m_tooltip->SetTip( tip );
1777     }
1778     else
1779     {
1780         SetToolTip( new wxToolTip( tip ) );
1781     }
1782
1783     // setting empty tooltip text does not remove the tooltip any more - use
1784     // SetToolTip((wxToolTip *)NULL) for this
1785 }
1786
1787 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
1788 {
1789     if ( m_tooltip != tooltip )
1790     {
1791         if ( m_tooltip )
1792             delete m_tooltip;
1793
1794         m_tooltip = tooltip;
1795     }
1796 }
1797
1798 #endif // wxUSE_TOOLTIPS
1799
1800 // ----------------------------------------------------------------------------
1801 // constraints and sizers
1802 // ----------------------------------------------------------------------------
1803
1804 #if wxUSE_CONSTRAINTS
1805
1806 void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
1807 {
1808     if ( m_constraints )
1809     {
1810         UnsetConstraints(m_constraints);
1811         delete m_constraints;
1812     }
1813     m_constraints = constraints;
1814     if ( m_constraints )
1815     {
1816         // Make sure other windows know they're part of a 'meaningful relationship'
1817         if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
1818             m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
1819         if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
1820             m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
1821         if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
1822             m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
1823         if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
1824             m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
1825         if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
1826             m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
1827         if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
1828             m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
1829         if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
1830             m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
1831         if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
1832             m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
1833     }
1834 }
1835
1836 // This removes any dangling pointers to this window in other windows'
1837 // constraintsInvolvedIn lists.
1838 void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
1839 {
1840     if ( c )
1841     {
1842         if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1843             c->left.GetOtherWindow()->RemoveConstraintReference(this);
1844         if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1845             c->top.GetOtherWindow()->RemoveConstraintReference(this);
1846         if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
1847             c->right.GetOtherWindow()->RemoveConstraintReference(this);
1848         if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
1849             c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
1850         if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
1851             c->width.GetOtherWindow()->RemoveConstraintReference(this);
1852         if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
1853             c->height.GetOtherWindow()->RemoveConstraintReference(this);
1854         if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
1855             c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
1856         if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
1857             c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
1858     }
1859 }
1860
1861 // Back-pointer to other windows we're involved with, so if we delete this
1862 // window, we must delete any constraints we're involved with.
1863 void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
1864 {
1865     if ( !m_constraintsInvolvedIn )
1866         m_constraintsInvolvedIn = new wxWindowList;
1867     if ( !m_constraintsInvolvedIn->Find((wxWindow *)otherWin) )
1868         m_constraintsInvolvedIn->Append((wxWindow *)otherWin);
1869 }
1870
1871 // REMOVE back-pointer to other windows we're involved with.
1872 void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
1873 {
1874     if ( m_constraintsInvolvedIn )
1875         m_constraintsInvolvedIn->DeleteObject((wxWindow *)otherWin);
1876 }
1877
1878 // Reset any constraints that mention this window
1879 void wxWindowBase::DeleteRelatedConstraints()
1880 {
1881     if ( m_constraintsInvolvedIn )
1882     {
1883         wxWindowList::compatibility_iterator node = m_constraintsInvolvedIn->GetFirst();
1884         while (node)
1885         {
1886             wxWindow *win = node->GetData();
1887             wxLayoutConstraints *constr = win->GetConstraints();
1888
1889             // Reset any constraints involving this window
1890             if ( constr )
1891             {
1892                 constr->left.ResetIfWin(this);
1893                 constr->top.ResetIfWin(this);
1894                 constr->right.ResetIfWin(this);
1895                 constr->bottom.ResetIfWin(this);
1896                 constr->width.ResetIfWin(this);
1897                 constr->height.ResetIfWin(this);
1898                 constr->centreX.ResetIfWin(this);
1899                 constr->centreY.ResetIfWin(this);
1900             }
1901
1902             wxWindowList::compatibility_iterator next = node->GetNext();
1903             m_constraintsInvolvedIn->Erase(node);
1904             node = next;
1905         }
1906
1907         delete m_constraintsInvolvedIn;
1908         m_constraintsInvolvedIn = (wxWindowList *) NULL;
1909     }
1910 }
1911
1912 #endif // wxUSE_CONSTRAINTS
1913
1914 void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld)
1915 {
1916     if ( sizer == m_windowSizer)
1917         return;
1918
1919     if ( m_windowSizer )
1920     {
1921         m_windowSizer->SetContainingWindow(NULL);
1922
1923         if ( deleteOld )
1924             delete m_windowSizer;
1925     }
1926
1927     m_windowSizer = sizer;
1928     if ( m_windowSizer )
1929     {
1930         m_windowSizer->SetContainingWindow((wxWindow *)this);
1931     }
1932
1933     SetAutoLayout(m_windowSizer != NULL);
1934 }
1935
1936 void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld)
1937 {
1938     SetSizer( sizer, deleteOld );
1939     sizer->SetSizeHints( (wxWindow*) this );
1940 }
1941
1942
1943 void wxWindowBase::SetContainingSizer(wxSizer* sizer)
1944 {
1945     // adding a window to a sizer twice is going to result in fatal and
1946     // hard to debug problems later because when deleting the second
1947     // associated wxSizerItem we're going to dereference a dangling
1948     // pointer; so try to detect this as early as possible
1949     wxASSERT_MSG( !sizer || m_containingSizer != sizer,
1950                   _T("Adding a window to the same sizer twice?") );
1951
1952     m_containingSizer = sizer;
1953 }
1954
1955 #if wxUSE_CONSTRAINTS
1956
1957 void wxWindowBase::SatisfyConstraints()
1958 {
1959     wxLayoutConstraints *constr = GetConstraints();
1960     bool wasOk = constr && constr->AreSatisfied();
1961
1962     ResetConstraints();   // Mark all constraints as unevaluated
1963
1964     int noChanges = 1;
1965
1966     // if we're a top level panel (i.e. our parent is frame/dialog), our
1967     // own constraints will never be satisfied any more unless we do it
1968     // here
1969     if ( wasOk )
1970     {
1971         while ( noChanges > 0 )
1972         {
1973             LayoutPhase1(&noChanges);
1974         }
1975     }
1976
1977     LayoutPhase2(&noChanges);
1978 }
1979
1980 #endif // wxUSE_CONSTRAINTS
1981
1982 bool wxWindowBase::Layout()
1983 {
1984     // If there is a sizer, use it instead of the constraints
1985     if ( GetSizer() )
1986     {
1987         int w = 0, h = 0;
1988         GetVirtualSize(&w, &h);
1989         GetSizer()->SetDimension( 0, 0, w, h );
1990     }
1991 #if wxUSE_CONSTRAINTS
1992     else
1993     {
1994         SatisfyConstraints(); // Find the right constraints values
1995         SetConstraintSizes(); // Recursively set the real window sizes
1996     }
1997 #endif
1998
1999     return true;
2000 }
2001
2002 #if wxUSE_CONSTRAINTS
2003
2004 // first phase of the constraints evaluation: set our own constraints
2005 bool wxWindowBase::LayoutPhase1(int *noChanges)
2006 {
2007     wxLayoutConstraints *constr = GetConstraints();
2008
2009     return !constr || constr->SatisfyConstraints(this, noChanges);
2010 }
2011
2012 // second phase: set the constraints for our children
2013 bool wxWindowBase::LayoutPhase2(int *noChanges)
2014 {
2015     *noChanges = 0;
2016
2017     // Layout children
2018     DoPhase(1);
2019
2020     // Layout grand children
2021     DoPhase(2);
2022
2023     return true;
2024 }
2025
2026 // Do a phase of evaluating child constraints
2027 bool wxWindowBase::DoPhase(int phase)
2028 {
2029     // the list containing the children for which the constraints are already
2030     // set correctly
2031     wxWindowList succeeded;
2032
2033     // the max number of iterations we loop before concluding that we can't set
2034     // the constraints
2035     static const int maxIterations = 500;
2036
2037     for ( int noIterations = 0; noIterations < maxIterations; noIterations++ )
2038     {
2039         int noChanges = 0;
2040
2041         // loop over all children setting their constraints
2042         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2043               node;
2044               node = node->GetNext() )
2045         {
2046             wxWindow *child = node->GetData();
2047             if ( child->IsTopLevel() )
2048             {
2049                 // top level children are not inside our client area
2050                 continue;
2051             }
2052
2053             if ( !child->GetConstraints() || succeeded.Find(child) )
2054             {
2055                 // this one is either already ok or nothing we can do about it
2056                 continue;
2057             }
2058
2059             int tempNoChanges = 0;
2060             bool success = phase == 1 ? child->LayoutPhase1(&tempNoChanges)
2061                                       : child->LayoutPhase2(&tempNoChanges);
2062             noChanges += tempNoChanges;
2063
2064             if ( success )
2065             {
2066                 succeeded.Append(child);
2067             }
2068         }
2069
2070         if ( !noChanges )
2071         {
2072             // constraints are set
2073             break;
2074         }
2075     }
2076
2077     return true;
2078 }
2079
2080 void wxWindowBase::ResetConstraints()
2081 {
2082     wxLayoutConstraints *constr = GetConstraints();
2083     if ( constr )
2084     {
2085         constr->left.SetDone(false);
2086         constr->top.SetDone(false);
2087         constr->right.SetDone(false);
2088         constr->bottom.SetDone(false);
2089         constr->width.SetDone(false);
2090         constr->height.SetDone(false);
2091         constr->centreX.SetDone(false);
2092         constr->centreY.SetDone(false);
2093     }
2094
2095     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2096     while (node)
2097     {
2098         wxWindow *win = node->GetData();
2099         if ( !win->IsTopLevel() )
2100             win->ResetConstraints();
2101         node = node->GetNext();
2102     }
2103 }
2104
2105 // Need to distinguish between setting the 'fake' size for windows and sizers,
2106 // and setting the real values.
2107 void wxWindowBase::SetConstraintSizes(bool recurse)
2108 {
2109     wxLayoutConstraints *constr = GetConstraints();
2110     if ( constr && constr->AreSatisfied() )
2111     {
2112         int x = constr->left.GetValue();
2113         int y = constr->top.GetValue();
2114         int w = constr->width.GetValue();
2115         int h = constr->height.GetValue();
2116
2117         if ( (constr->width.GetRelationship() != wxAsIs ) ||
2118              (constr->height.GetRelationship() != wxAsIs) )
2119         {
2120             SetSize(x, y, w, h);
2121         }
2122         else
2123         {
2124             // If we don't want to resize this window, just move it...
2125             Move(x, y);
2126         }
2127     }
2128     else if ( constr )
2129     {
2130         wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
2131                    GetClassInfo()->GetClassName(),
2132                    GetName().c_str());
2133     }
2134
2135     if ( recurse )
2136     {
2137         wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2138         while (node)
2139         {
2140             wxWindow *win = node->GetData();
2141             if ( !win->IsTopLevel() && win->GetConstraints() )
2142                 win->SetConstraintSizes();
2143             node = node->GetNext();
2144         }
2145     }
2146 }
2147
2148 // Only set the size/position of the constraint (if any)
2149 void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
2150 {
2151     wxLayoutConstraints *constr = GetConstraints();
2152     if ( constr )
2153     {
2154         if ( x != wxDefaultCoord )
2155         {
2156             constr->left.SetValue(x);
2157             constr->left.SetDone(true);
2158         }
2159         if ( y != wxDefaultCoord )
2160         {
2161             constr->top.SetValue(y);
2162             constr->top.SetDone(true);
2163         }
2164         if ( w != wxDefaultCoord )
2165         {
2166             constr->width.SetValue(w);
2167             constr->width.SetDone(true);
2168         }
2169         if ( h != wxDefaultCoord )
2170         {
2171             constr->height.SetValue(h);
2172             constr->height.SetDone(true);
2173         }
2174     }
2175 }
2176
2177 void wxWindowBase::MoveConstraint(int x, int y)
2178 {
2179     wxLayoutConstraints *constr = GetConstraints();
2180     if ( constr )
2181     {
2182         if ( x != wxDefaultCoord )
2183         {
2184             constr->left.SetValue(x);
2185             constr->left.SetDone(true);
2186         }
2187         if ( y != wxDefaultCoord )
2188         {
2189             constr->top.SetValue(y);
2190             constr->top.SetDone(true);
2191         }
2192     }
2193 }
2194
2195 void wxWindowBase::GetSizeConstraint(int *w, int *h) const
2196 {
2197     wxLayoutConstraints *constr = GetConstraints();
2198     if ( constr )
2199     {
2200         *w = constr->width.GetValue();
2201         *h = constr->height.GetValue();
2202     }
2203     else
2204         GetSize(w, h);
2205 }
2206
2207 void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
2208 {
2209     wxLayoutConstraints *constr = GetConstraints();
2210     if ( constr )
2211     {
2212         *w = constr->width.GetValue();
2213         *h = constr->height.GetValue();
2214     }
2215     else
2216         GetClientSize(w, h);
2217 }
2218
2219 void wxWindowBase::GetPositionConstraint(int *x, int *y) const
2220 {
2221     wxLayoutConstraints *constr = GetConstraints();
2222     if ( constr )
2223     {
2224         *x = constr->left.GetValue();
2225         *y = constr->top.GetValue();
2226     }
2227     else
2228         GetPosition(x, y);
2229 }
2230
2231 #endif // wxUSE_CONSTRAINTS
2232
2233 void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const
2234 {
2235     // don't do it for the dialogs/frames - they float independently of their
2236     // parent
2237     if ( !IsTopLevel() )
2238     {
2239         wxWindow *parent = GetParent();
2240         if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
2241         {
2242             wxPoint pt(parent->GetClientAreaOrigin());
2243             x += pt.x;
2244             y += pt.y;
2245         }
2246     }
2247 }
2248
2249 // ----------------------------------------------------------------------------
2250 // Update UI processing
2251 // ----------------------------------------------------------------------------
2252
2253 void wxWindowBase::UpdateWindowUI(long flags)
2254 {
2255     wxUpdateUIEvent event(GetId());
2256     event.SetEventObject(this);
2257
2258     if ( GetEventHandler()->ProcessEvent(event) )
2259     {
2260         DoUpdateWindowUI(event);
2261     }
2262
2263     if (flags & wxUPDATE_UI_RECURSE)
2264     {
2265         wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2266         while (node)
2267         {
2268             wxWindow* child = (wxWindow*) node->GetData();
2269             child->UpdateWindowUI(flags);
2270             node = node->GetNext();
2271         }
2272     }
2273 }
2274
2275 // do the window-specific processing after processing the update event
2276 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
2277 {
2278     if ( event.GetSetEnabled() )
2279         Enable(event.GetEnabled());
2280
2281     if ( event.GetSetShown() )
2282         Show(event.GetShown());
2283 }
2284
2285 // ----------------------------------------------------------------------------
2286 // dialog units translations
2287 // ----------------------------------------------------------------------------
2288
2289 wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
2290 {
2291     int charWidth = GetCharWidth();
2292     int charHeight = GetCharHeight();
2293     wxPoint pt2 = wxDefaultPosition;
2294     if (pt.x != wxDefaultCoord)
2295         pt2.x = (int) ((pt.x * 4) / charWidth);
2296     if (pt.y != wxDefaultCoord)
2297         pt2.y = (int) ((pt.y * 8) / charHeight);
2298
2299     return pt2;
2300 }
2301
2302 wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
2303 {
2304     int charWidth = GetCharWidth();
2305     int charHeight = GetCharHeight();
2306     wxPoint pt2 = wxDefaultPosition;
2307     if (pt.x != wxDefaultCoord)
2308         pt2.x = (int) ((pt.x * charWidth) / 4);
2309     if (pt.y != wxDefaultCoord)
2310         pt2.y = (int) ((pt.y * charHeight) / 8);
2311
2312     return pt2;
2313 }
2314
2315 // ----------------------------------------------------------------------------
2316 // event handlers
2317 // ----------------------------------------------------------------------------
2318
2319 // propagate the colour change event to the subwindows
2320 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
2321 {
2322     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2323     while ( node )
2324     {
2325         // Only propagate to non-top-level windows
2326         wxWindow *win = node->GetData();
2327         if ( !win->IsTopLevel() )
2328         {
2329             wxSysColourChangedEvent event2;
2330             event.SetEventObject(win);
2331             win->GetEventHandler()->ProcessEvent(event2);
2332         }
2333
2334         node = node->GetNext();
2335     }
2336
2337     Refresh();
2338 }
2339
2340 // the default action is to populate dialog with data when it's created,
2341 // and nudge the UI into displaying itself correctly in case
2342 // we've turned the wxUpdateUIEvents frequency down low.
2343 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
2344 {
2345     TransferDataToWindow();
2346
2347     // Update the UI at this point
2348     UpdateWindowUI(wxUPDATE_UI_RECURSE);
2349 }
2350
2351 // ----------------------------------------------------------------------------
2352 // menu-related functions
2353 // ----------------------------------------------------------------------------
2354
2355 #if wxUSE_MENUS
2356
2357 bool wxWindowBase::PopupMenu(wxMenu *menu, int x, int y)
2358 {
2359     wxCHECK_MSG( menu, false, "can't popup NULL menu" );
2360
2361     wxCurrentPopupMenu = menu;
2362     const bool rc = DoPopupMenu(menu, x, y);
2363     wxCurrentPopupMenu = NULL;
2364
2365     return rc;
2366 }
2367
2368 // this is used to pass the id of the selected item from the menu event handler
2369 // to the main function itself
2370 //
2371 // it's ok to use a global here as there can be at most one popup menu shown at
2372 // any time
2373 static int gs_popupMenuSelection = wxID_NONE;
2374
2375 void wxWindowBase::InternalOnPopupMenu(wxCommandEvent& event)
2376 {
2377     // store the id in a global variable where we'll retrieve it from later
2378     gs_popupMenuSelection = event.GetId();
2379 }
2380
2381 int
2382 wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y)
2383 {
2384     gs_popupMenuSelection = wxID_NONE;
2385
2386     Connect(wxEVT_COMMAND_MENU_SELECTED,
2387             wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu),
2388             NULL,
2389             this);
2390
2391     PopupMenu(&menu, x, y);
2392
2393     Disconnect(wxEVT_COMMAND_MENU_SELECTED,
2394                wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu),
2395                NULL,
2396                this);
2397
2398     return gs_popupMenuSelection;
2399 }
2400
2401 #endif // wxUSE_MENUS
2402
2403 // methods for drawing the sizers in a visible way
2404 #ifdef __WXDEBUG__
2405
2406 static void DrawSizers(wxWindowBase *win);
2407
2408 static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill = false)
2409 {
2410     wxClientDC dc((wxWindow *)win);
2411     dc.SetPen(*wxRED_PEN);
2412     dc.SetBrush(fill ? wxBrush(*wxRED, wxCROSSDIAG_HATCH): *wxTRANSPARENT_BRUSH);
2413     dc.DrawRectangle(rect.Deflate(1, 1));
2414 }
2415
2416 static void DrawSizer(wxWindowBase *win, wxSizer *sizer)
2417 {
2418     const wxSizerItemList& items = sizer->GetChildren();
2419     for ( wxSizerItemList::const_iterator i = items.begin(),
2420                                         end = items.end();
2421           i != end;
2422           ++i )
2423     {
2424         wxSizerItem *item = *i;
2425         if ( item->IsSizer() )
2426         {
2427             DrawBorder(win, item->GetRect().Deflate(2));
2428             DrawSizer(win, item->GetSizer());
2429         }
2430         else if ( item->IsSpacer() )
2431         {
2432             DrawBorder(win, item->GetRect().Deflate(2), true);
2433         }
2434         else if ( item->IsWindow() )
2435         {
2436             DrawSizers(item->GetWindow());
2437         }
2438     }
2439 }
2440
2441 static void DrawSizers(wxWindowBase *win)
2442 {
2443     wxSizer *sizer = win->GetSizer();
2444     if ( sizer )
2445     {
2446         DrawBorder(win, win->GetClientSize());
2447         DrawSizer(win, sizer);
2448     }
2449     else // no sizer, still recurse into the children
2450     {
2451         const wxWindowList& children = win->GetChildren();
2452         for ( wxWindowList::const_iterator i = children.begin(),
2453                                          end = children.end();
2454               i != end;
2455               ++i )
2456         {
2457             DrawSizers(*i);
2458         }
2459     }
2460 }
2461
2462 #endif // __WXDEBUG__
2463
2464 // process special middle clicks
2465 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
2466 {
2467     if ( event.ControlDown() && event.AltDown() )
2468     {
2469 #ifdef __WXDEBUG__
2470         // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
2471         if ( event.ShiftDown() )
2472         {
2473             DrawSizers(this);
2474             return;
2475         }
2476 #endif // __WXDEBUG__
2477         ::wxInfoMessageBox((wxWindow*)this);
2478     }
2479     else
2480     {
2481         event.Skip();
2482     }
2483 }
2484
2485 // ----------------------------------------------------------------------------
2486 // accessibility
2487 // ----------------------------------------------------------------------------
2488
2489 #if wxUSE_ACCESSIBILITY
2490 void wxWindowBase::SetAccessible(wxAccessible* accessible)
2491 {
2492     if (m_accessible && (accessible != m_accessible))
2493         delete m_accessible;
2494     m_accessible = accessible;
2495     if (m_accessible)
2496         m_accessible->SetWindow((wxWindow*) this);
2497 }
2498
2499 // Returns the accessible object, creating if necessary.
2500 wxAccessible* wxWindowBase::GetOrCreateAccessible()
2501 {
2502     if (!m_accessible)
2503         m_accessible = CreateAccessible();
2504     return m_accessible;
2505 }
2506
2507 // Override to create a specific accessible object.
2508 wxAccessible* wxWindowBase::CreateAccessible()
2509 {
2510     return new wxWindowAccessible((wxWindow*) this);
2511 }
2512
2513 #endif
2514
2515 // ----------------------------------------------------------------------------
2516 // list classes implementation
2517 // ----------------------------------------------------------------------------
2518
2519 #if wxUSE_STL
2520
2521 #include "wx/listimpl.cpp"
2522 WX_DEFINE_LIST(wxWindowList)
2523
2524 #else // !wxUSE_STL
2525
2526 void wxWindowListNode::DeleteData()
2527 {
2528     delete (wxWindow *)GetData();
2529 }
2530
2531 #endif // wxUSE_STL/!wxUSE_STL
2532
2533 // ----------------------------------------------------------------------------
2534 // borders
2535 // ----------------------------------------------------------------------------
2536
2537 wxBorder wxWindowBase::GetBorder(long flags) const
2538 {
2539     wxBorder border = (wxBorder)(flags & wxBORDER_MASK);
2540     if ( border == wxBORDER_DEFAULT )
2541     {
2542         border = GetDefaultBorder();
2543     }
2544     else if ( border == wxBORDER_THEME )
2545     {
2546         border = GetDefaultBorderForControl();
2547     }
2548
2549     return border;
2550 }
2551
2552 wxBorder wxWindowBase::GetDefaultBorder() const
2553 {
2554     return wxBORDER_NONE;
2555 }
2556
2557 // ----------------------------------------------------------------------------
2558 // hit testing
2559 // ----------------------------------------------------------------------------
2560
2561 wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
2562 {
2563     // here we just check if the point is inside the window or not
2564
2565     // check the top and left border first
2566     bool outside = x < 0 || y < 0;
2567     if ( !outside )
2568     {
2569         // check the right and bottom borders too
2570         wxSize size = GetSize();
2571         outside = x >= size.x || y >= size.y;
2572     }
2573
2574     return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE;
2575 }
2576
2577 // ----------------------------------------------------------------------------
2578 // mouse capture
2579 // ----------------------------------------------------------------------------
2580
2581 struct WXDLLEXPORT wxWindowNext
2582 {
2583     wxWindow *win;
2584     wxWindowNext *next;
2585 } *wxWindowBase::ms_winCaptureNext = NULL;
2586 wxWindow *wxWindowBase::ms_winCaptureCurrent = NULL;
2587 bool wxWindowBase::ms_winCaptureChanging = false;
2588
2589 void wxWindowBase::CaptureMouse()
2590 {
2591     wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), wx_static_cast(void*, this));
2592
2593     wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive CaptureMouse call?") );
2594
2595     ms_winCaptureChanging = true;
2596
2597     wxWindow *winOld = GetCapture();
2598     if ( winOld )
2599     {
2600         ((wxWindowBase*) winOld)->DoReleaseMouse();
2601
2602         // save it on stack
2603         wxWindowNext *item = new wxWindowNext;
2604         item->win = winOld;
2605         item->next = ms_winCaptureNext;
2606         ms_winCaptureNext = item;
2607     }
2608     //else: no mouse capture to save
2609
2610     DoCaptureMouse();
2611     ms_winCaptureCurrent = (wxWindow*)this;
2612
2613     ms_winCaptureChanging = false;
2614 }
2615
2616 void wxWindowBase::ReleaseMouse()
2617 {
2618     wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), wx_static_cast(void*, this));
2619
2620     wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive ReleaseMouse call?") );
2621
2622     wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
2623
2624     ms_winCaptureChanging = true;
2625
2626     DoReleaseMouse();
2627     ms_winCaptureCurrent = NULL;
2628
2629     if ( ms_winCaptureNext )
2630     {
2631         ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse();
2632         ms_winCaptureCurrent = ms_winCaptureNext->win;
2633
2634         wxWindowNext *item = ms_winCaptureNext;
2635         ms_winCaptureNext = item->next;
2636         delete item;
2637     }
2638     //else: stack is empty, no previous capture
2639
2640     ms_winCaptureChanging = false;
2641
2642     wxLogTrace(_T("mousecapture"),
2643         (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"),
2644         wx_static_cast(void*, GetCapture()));
2645 }
2646
2647 static void DoNotifyWindowAboutCaptureLost(wxWindow *win)
2648 {
2649     wxMouseCaptureLostEvent event(win->GetId());
2650     event.SetEventObject(win);
2651     if ( !win->GetEventHandler()->ProcessEvent(event) )
2652     {
2653         // windows must handle this event, otherwise the app wouldn't behave
2654         // correctly if it loses capture unexpectedly; see the discussion here:
2655         // http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863
2656         // http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376
2657         wxFAIL_MSG( _T("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
2658     }
2659 }
2660
2661 /* static */
2662 void wxWindowBase::NotifyCaptureLost()
2663 {
2664     // don't do anything if capture lost was expected, i.e. resulted from
2665     // a wx call to ReleaseMouse or CaptureMouse:
2666     if ( ms_winCaptureChanging )
2667         return;
2668
2669     // if the capture was lost unexpectedly, notify every window that has
2670     // capture (on stack or current) about it and clear the stack:
2671
2672     if ( ms_winCaptureCurrent )
2673     {
2674         DoNotifyWindowAboutCaptureLost(ms_winCaptureCurrent);
2675         ms_winCaptureCurrent = NULL;
2676     }
2677
2678     while ( ms_winCaptureNext )
2679     {
2680         wxWindowNext *item = ms_winCaptureNext;
2681         ms_winCaptureNext = item->next;
2682
2683         DoNotifyWindowAboutCaptureLost(item->win);
2684
2685         delete item;
2686     }
2687 }
2688
2689 #if wxUSE_HOTKEY
2690
2691 bool
2692 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId),
2693                              int WXUNUSED(modifiers),
2694                              int WXUNUSED(keycode))
2695 {
2696     // not implemented
2697     return false;
2698 }
2699
2700 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId))
2701 {
2702     // not implemented
2703     return false;
2704 }
2705
2706 #endif // wxUSE_HOTKEY
2707
2708 // ----------------------------------------------------------------------------
2709 // event processing
2710 // ----------------------------------------------------------------------------
2711
2712 bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event))
2713 {
2714 #if wxUSE_VALIDATORS
2715     // Can only use the validator of the window which
2716     // is receiving the event
2717     if ( event.GetEventObject() == this )
2718     {
2719         wxValidator *validator = GetValidator();
2720         if ( validator && validator->ProcessEvent(event) )
2721         {
2722             return true;
2723         }
2724     }
2725 #endif // wxUSE_VALIDATORS
2726
2727     return false;
2728 }
2729
2730 bool wxWindowBase::TryParent(wxEvent& event)
2731 {
2732     // carry on up the parent-child hierarchy if the propagation count hasn't
2733     // reached zero yet
2734     if ( event.ShouldPropagate() )
2735     {
2736         // honour the requests to stop propagation at this window: this is
2737         // used by the dialogs, for example, to prevent processing the events
2738         // from the dialog controls in the parent frame which rarely, if ever,
2739         // makes sense
2740         if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS) )
2741         {
2742             wxWindow *parent = GetParent();
2743             if ( parent && !parent->IsBeingDeleted() )
2744             {
2745                 wxPropagateOnce propagateOnce(event);
2746
2747                 return parent->GetEventHandler()->ProcessEvent(event);
2748             }
2749         }
2750     }
2751
2752     return wxEvtHandler::TryParent(event);
2753 }
2754
2755 // ----------------------------------------------------------------------------
2756 // window relationships
2757 // ----------------------------------------------------------------------------
2758
2759 wxWindow *wxWindowBase::DoGetSibling(WindowOrder order) const
2760 {
2761     wxCHECK_MSG( GetParent(), NULL,
2762                     _T("GetPrev/NextSibling() don't work for TLWs!") );
2763
2764     wxWindowList& siblings = GetParent()->GetChildren();
2765     wxWindowList::compatibility_iterator i = siblings.Find((wxWindow *)this);
2766     wxCHECK_MSG( i, NULL, _T("window not a child of its parent?") );
2767
2768     if ( order == OrderBefore )
2769         i = i->GetPrevious();
2770     else // OrderAfter
2771         i = i->GetNext();
2772
2773     return i ? i->GetData() : NULL;
2774 }
2775
2776 // ----------------------------------------------------------------------------
2777 // keyboard navigation
2778 // ----------------------------------------------------------------------------
2779
2780 // Navigates in the specified direction inside this window
2781 bool wxWindowBase::DoNavigateIn(int flags)
2782 {
2783 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
2784     // native code doesn't process our wxNavigationKeyEvents anyhow
2785     wxUnusedVar(flags);
2786     return false;
2787 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
2788     wxNavigationKeyEvent eventNav;
2789     wxWindow *focused = FindFocus();
2790     eventNav.SetCurrentFocus(focused);
2791     eventNav.SetEventObject(focused);
2792     eventNav.SetFlags(flags);
2793     return GetEventHandler()->ProcessEvent(eventNav);
2794 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
2795 }
2796
2797 bool wxWindowBase::HandleAsNavigationKey(const wxKeyEvent& event)
2798 {
2799     if ( event.GetKeyCode() != WXK_TAB )
2800         return false;
2801
2802     int flags = wxNavigationKeyEvent::FromTab;
2803
2804     if ( event.ShiftDown() )
2805         flags |= wxNavigationKeyEvent::IsBackward;
2806     else
2807         flags |= wxNavigationKeyEvent::IsForward;
2808
2809     if ( event.ControlDown() )
2810         flags |= wxNavigationKeyEvent::WinChange;
2811
2812     Navigate(flags);
2813     return true;
2814 }
2815
2816 void wxWindowBase::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
2817 {
2818     // check that we're not a top level window
2819     wxCHECK_RET( GetParent(),
2820                     _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
2821
2822     // detect the special case when we have nothing to do anyhow and when the
2823     // code below wouldn't work
2824     if ( win == this )
2825         return;
2826
2827     // find the target window in the siblings list
2828     wxWindowList& siblings = GetParent()->GetChildren();
2829     wxWindowList::compatibility_iterator i = siblings.Find(win);
2830     wxCHECK_RET( i, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
2831
2832     // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
2833     // can't just move the node around
2834     wxWindow *self = (wxWindow *)this;
2835     siblings.DeleteObject(self);
2836     if ( move == OrderAfter )
2837     {
2838         i = i->GetNext();
2839     }
2840
2841     if ( i )
2842     {
2843         siblings.Insert(i, self);
2844     }
2845     else // OrderAfter and win was the last sibling
2846     {
2847         siblings.Append(self);
2848     }
2849 }
2850
2851 // ----------------------------------------------------------------------------
2852 // focus handling
2853 // ----------------------------------------------------------------------------
2854
2855 /*static*/ wxWindow* wxWindowBase::FindFocus()
2856 {
2857     wxWindowBase *win = DoFindFocus();
2858     return win ? win->GetMainWindowOfCompositeControl() : NULL;
2859 }
2860
2861 bool wxWindowBase::HasFocus() const
2862 {
2863     wxWindowBase *win = DoFindFocus();
2864     return win == this ||
2865            win == wxConstCast(this, wxWindowBase)->GetMainWindowOfCompositeControl();
2866 }
2867
2868 // ----------------------------------------------------------------------------
2869 // global functions
2870 // ----------------------------------------------------------------------------
2871
2872 wxWindow* wxGetTopLevelParent(wxWindow *win)
2873 {
2874     while ( win && !win->IsTopLevel() )
2875          win = win->GetParent();
2876
2877     return win;
2878 }
2879
2880 #if wxUSE_ACCESSIBILITY
2881 // ----------------------------------------------------------------------------
2882 // accessible object for windows
2883 // ----------------------------------------------------------------------------
2884
2885 // Can return either a child object, or an integer
2886 // representing the child element, starting from 1.
2887 wxAccStatus wxWindowAccessible::HitTest(const wxPoint& WXUNUSED(pt), int* WXUNUSED(childId), wxAccessible** WXUNUSED(childObject))
2888 {
2889     wxASSERT( GetWindow() != NULL );
2890     if (!GetWindow())
2891         return wxACC_FAIL;
2892
2893     return wxACC_NOT_IMPLEMENTED;
2894 }
2895
2896 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
2897 wxAccStatus wxWindowAccessible::GetLocation(wxRect& rect, int elementId)
2898 {
2899     wxASSERT( GetWindow() != NULL );
2900     if (!GetWindow())
2901         return wxACC_FAIL;
2902
2903     wxWindow* win = NULL;
2904     if (elementId == 0)
2905     {
2906         win = GetWindow();
2907     }
2908     else
2909     {
2910         if (elementId <= (int) GetWindow()->GetChildren().GetCount())
2911         {
2912             win = GetWindow()->GetChildren().Item(elementId-1)->GetData();
2913         }
2914         else
2915             return wxACC_FAIL;
2916     }
2917     if (win)
2918     {
2919         rect = win->GetRect();
2920         if (win->GetParent() && !win->IsKindOf(CLASSINFO(wxTopLevelWindow)))
2921             rect.SetPosition(win->GetParent()->ClientToScreen(rect.GetPosition()));
2922         return wxACC_OK;
2923     }
2924
2925     return wxACC_NOT_IMPLEMENTED;
2926 }
2927
2928 // Navigates from fromId to toId/toObject.
2929 wxAccStatus wxWindowAccessible::Navigate(wxNavDir navDir, int fromId,
2930                              int* WXUNUSED(toId), wxAccessible** toObject)
2931 {
2932     wxASSERT( GetWindow() != NULL );
2933     if (!GetWindow())
2934         return wxACC_FAIL;
2935
2936     switch (navDir)
2937     {
2938     case wxNAVDIR_FIRSTCHILD:
2939         {
2940             if (GetWindow()->GetChildren().GetCount() == 0)
2941                 return wxACC_FALSE;
2942             wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetFirst()->GetData();
2943             *toObject = childWindow->GetOrCreateAccessible();
2944
2945             return wxACC_OK;
2946         }
2947     case wxNAVDIR_LASTCHILD:
2948         {
2949             if (GetWindow()->GetChildren().GetCount() == 0)
2950                 return wxACC_FALSE;
2951             wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetLast()->GetData();
2952             *toObject = childWindow->GetOrCreateAccessible();
2953
2954             return wxACC_OK;
2955         }
2956     case wxNAVDIR_RIGHT:
2957     case wxNAVDIR_DOWN:
2958     case wxNAVDIR_NEXT:
2959         {
2960             wxWindowList::compatibility_iterator node =
2961                 wxWindowList::compatibility_iterator();
2962             if (fromId == 0)
2963             {
2964                 // Can't navigate to sibling of this window
2965                 // if we're a top-level window.
2966                 if (!GetWindow()->GetParent())
2967                     return wxACC_NOT_IMPLEMENTED;
2968
2969                 node = GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2970             }
2971             else
2972             {
2973                 if (fromId <= (int) GetWindow()->GetChildren().GetCount())
2974                     node = GetWindow()->GetChildren().Item(fromId-1);
2975             }
2976
2977             if (node && node->GetNext())
2978             {
2979                 wxWindow* nextWindow = node->GetNext()->GetData();
2980                 *toObject = nextWindow->GetOrCreateAccessible();
2981                 return wxACC_OK;
2982             }
2983             else
2984                 return wxACC_FALSE;
2985         }
2986     case wxNAVDIR_LEFT:
2987     case wxNAVDIR_UP:
2988     case wxNAVDIR_PREVIOUS:
2989         {
2990             wxWindowList::compatibility_iterator node =
2991                 wxWindowList::compatibility_iterator();
2992             if (fromId == 0)
2993             {
2994                 // Can't navigate to sibling of this window
2995                 // if we're a top-level window.
2996                 if (!GetWindow()->GetParent())
2997                     return wxACC_NOT_IMPLEMENTED;
2998
2999                 node = GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3000             }
3001             else
3002             {
3003                 if (fromId <= (int) GetWindow()->GetChildren().GetCount())
3004                     node = GetWindow()->GetChildren().Item(fromId-1);
3005             }
3006
3007             if (node && node->GetPrevious())
3008             {
3009                 wxWindow* previousWindow = node->GetPrevious()->GetData();
3010                 *toObject = previousWindow->GetOrCreateAccessible();
3011                 return wxACC_OK;
3012             }
3013             else
3014                 return wxACC_FALSE;
3015         }
3016     }
3017
3018     return wxACC_NOT_IMPLEMENTED;
3019 }
3020
3021 // Gets the name of the specified object.
3022 wxAccStatus wxWindowAccessible::GetName(int childId, wxString* name)
3023 {
3024     wxASSERT( GetWindow() != NULL );
3025     if (!GetWindow())
3026         return wxACC_FAIL;
3027
3028     wxString title;
3029
3030     // If a child, leave wxWidgets to call the function on the actual
3031     // child object.
3032     if (childId > 0)
3033         return wxACC_NOT_IMPLEMENTED;
3034
3035     // This will eventually be replaced by specialised
3036     // accessible classes, one for each kind of wxWidgets
3037     // control or window.
3038 #if wxUSE_BUTTON
3039     if (GetWindow()->IsKindOf(CLASSINFO(wxButton)))
3040         title = ((wxButton*) GetWindow())->GetLabel();
3041     else
3042 #endif
3043         title = GetWindow()->GetName();
3044
3045     if (!title.empty())
3046     {
3047         *name = title;
3048         return wxACC_OK;
3049     }
3050     else
3051         return wxACC_NOT_IMPLEMENTED;
3052 }
3053
3054 // Gets the number of children.
3055 wxAccStatus wxWindowAccessible::GetChildCount(int* childId)
3056 {
3057     wxASSERT( GetWindow() != NULL );
3058     if (!GetWindow())
3059         return wxACC_FAIL;
3060
3061     *childId = (int) GetWindow()->GetChildren().GetCount();
3062     return wxACC_OK;
3063 }
3064
3065 // Gets the specified child (starting from 1).
3066 // If *child is NULL and return value is wxACC_OK,
3067 // this means that the child is a simple element and
3068 // not an accessible object.
3069 wxAccStatus wxWindowAccessible::GetChild(int childId, wxAccessible** child)
3070 {
3071     wxASSERT( GetWindow() != NULL );
3072     if (!GetWindow())
3073         return wxACC_FAIL;
3074
3075     if (childId == 0)
3076     {
3077         *child = this;
3078         return wxACC_OK;
3079     }
3080
3081     if (childId > (int) GetWindow()->GetChildren().GetCount())
3082         return wxACC_FAIL;
3083
3084     wxWindow* childWindow = GetWindow()->GetChildren().Item(childId-1)->GetData();
3085     *child = childWindow->GetOrCreateAccessible();
3086     if (*child)
3087         return wxACC_OK;
3088     else
3089         return wxACC_FAIL;
3090 }
3091
3092 // Gets the parent, or NULL.
3093 wxAccStatus wxWindowAccessible::GetParent(wxAccessible** parent)
3094 {
3095     wxASSERT( GetWindow() != NULL );
3096     if (!GetWindow())
3097         return wxACC_FAIL;
3098
3099     wxWindow* parentWindow = GetWindow()->GetParent();
3100     if (!parentWindow)
3101     {
3102         *parent = NULL;
3103         return wxACC_OK;
3104     }
3105     else
3106     {
3107         *parent = parentWindow->GetOrCreateAccessible();
3108         if (*parent)
3109             return wxACC_OK;
3110         else
3111             return wxACC_FAIL;
3112     }
3113 }
3114
3115 // Performs the default action. childId is 0 (the action for this object)
3116 // or > 0 (the action for a child).
3117 // Return wxACC_NOT_SUPPORTED if there is no default action for this
3118 // window (e.g. an edit control).
3119 wxAccStatus wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId))
3120 {
3121     wxASSERT( GetWindow() != NULL );
3122     if (!GetWindow())
3123         return wxACC_FAIL;
3124
3125     return wxACC_NOT_IMPLEMENTED;
3126 }
3127
3128 // Gets the default action for this object (0) or > 0 (the action for a child).
3129 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
3130 // string if there is no action.
3131 // The retrieved string describes the action that is performed on an object,
3132 // not what the object does as a result. For example, a toolbar button that prints
3133 // a document has a default action of "Press" rather than "Prints the current document."
3134 wxAccStatus wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId), wxString* WXUNUSED(actionName))
3135 {
3136     wxASSERT( GetWindow() != NULL );
3137     if (!GetWindow())
3138         return wxACC_FAIL;
3139
3140     return wxACC_NOT_IMPLEMENTED;
3141 }
3142
3143 // Returns the description for this object or a child.
3144 wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString* description)
3145 {
3146     wxASSERT( GetWindow() != NULL );
3147     if (!GetWindow())
3148         return wxACC_FAIL;
3149
3150     wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard));
3151     if (!ht.empty())
3152     {
3153         *description = ht;
3154         return wxACC_OK;
3155     }
3156     return wxACC_NOT_IMPLEMENTED;
3157 }
3158
3159 // Returns help text for this object or a child, similar to tooltip text.
3160 wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* helpText)
3161 {
3162     wxASSERT( GetWindow() != NULL );
3163     if (!GetWindow())
3164         return wxACC_FAIL;
3165
3166     wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard));
3167     if (!ht.empty())
3168     {
3169         *helpText = ht;
3170         return wxACC_OK;
3171     }
3172     return wxACC_NOT_IMPLEMENTED;
3173 }
3174
3175 // Returns the keyboard shortcut for this object or child.
3176 // Return e.g. ALT+K
3177 wxAccStatus wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId), wxString* WXUNUSED(shortcut))
3178 {
3179     wxASSERT( GetWindow() != NULL );
3180     if (!GetWindow())
3181         return wxACC_FAIL;
3182
3183     return wxACC_NOT_IMPLEMENTED;
3184 }
3185
3186 // Returns a role constant.
3187 wxAccStatus wxWindowAccessible::GetRole(int childId, wxAccRole* role)
3188 {
3189     wxASSERT( GetWindow() != NULL );
3190     if (!GetWindow())
3191         return wxACC_FAIL;
3192
3193     // If a child, leave wxWidgets to call the function on the actual
3194     // child object.
3195     if (childId > 0)
3196         return wxACC_NOT_IMPLEMENTED;
3197
3198     if (GetWindow()->IsKindOf(CLASSINFO(wxControl)))
3199         return wxACC_NOT_IMPLEMENTED;
3200 #if wxUSE_STATUSBAR
3201     if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar)))
3202         return wxACC_NOT_IMPLEMENTED;
3203 #endif
3204 #if wxUSE_TOOLBAR
3205     if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar)))
3206         return wxACC_NOT_IMPLEMENTED;
3207 #endif
3208
3209     //*role = wxROLE_SYSTEM_CLIENT;
3210     *role = wxROLE_SYSTEM_CLIENT;
3211     return wxACC_OK;
3212
3213     #if 0
3214     return wxACC_NOT_IMPLEMENTED;
3215     #endif
3216 }
3217
3218 // Returns a state constant.
3219 wxAccStatus wxWindowAccessible::GetState(int childId, long* state)
3220 {
3221     wxASSERT( GetWindow() != NULL );
3222     if (!GetWindow())
3223         return wxACC_FAIL;
3224
3225     // If a child, leave wxWidgets to call the function on the actual
3226     // child object.
3227     if (childId > 0)
3228         return wxACC_NOT_IMPLEMENTED;
3229
3230     if (GetWindow()->IsKindOf(CLASSINFO(wxControl)))
3231         return wxACC_NOT_IMPLEMENTED;
3232
3233 #if wxUSE_STATUSBAR
3234     if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar)))
3235         return wxACC_NOT_IMPLEMENTED;
3236 #endif
3237 #if wxUSE_TOOLBAR
3238     if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar)))
3239         return wxACC_NOT_IMPLEMENTED;
3240 #endif
3241
3242     *state = 0;
3243     return wxACC_OK;
3244
3245     #if 0
3246     return wxACC_NOT_IMPLEMENTED;
3247     #endif
3248 }
3249
3250 // Returns a localized string representing the value for the object
3251 // or child.
3252 wxAccStatus wxWindowAccessible::GetValue(int WXUNUSED(childId), wxString* WXUNUSED(strValue))
3253 {
3254     wxASSERT( GetWindow() != NULL );
3255     if (!GetWindow())
3256         return wxACC_FAIL;
3257
3258     return wxACC_NOT_IMPLEMENTED;
3259 }
3260
3261 // Selects the object or child.
3262 wxAccStatus wxWindowAccessible::Select(int WXUNUSED(childId), wxAccSelectionFlags WXUNUSED(selectFlags))
3263 {
3264     wxASSERT( GetWindow() != NULL );
3265     if (!GetWindow())
3266         return wxACC_FAIL;
3267
3268     return wxACC_NOT_IMPLEMENTED;
3269 }
3270
3271 // Gets the window with the keyboard focus.
3272 // If childId is 0 and child is NULL, no object in
3273 // this subhierarchy has the focus.
3274 // If this object has the focus, child should be 'this'.
3275 wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible** WXUNUSED(child))
3276 {
3277     wxASSERT( GetWindow() != NULL );
3278     if (!GetWindow())
3279         return wxACC_FAIL;
3280
3281     return wxACC_NOT_IMPLEMENTED;
3282 }
3283
3284 #if wxUSE_VARIANT
3285 // Gets a variant representing the selected children
3286 // of this object.
3287 // Acceptable values:
3288 // - a null variant (IsNull() returns true)
3289 // - a list variant (GetType() == wxT("list")
3290 // - an integer representing the selected child element,
3291 //   or 0 if this object is selected (GetType() == wxT("long")
3292 // - a "void*" pointer to a wxAccessible child object
3293 wxAccStatus wxWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections))
3294 {
3295     wxASSERT( GetWindow() != NULL );
3296     if (!GetWindow())
3297         return wxACC_FAIL;
3298
3299     return wxACC_NOT_IMPLEMENTED;
3300 }
3301 #endif // wxUSE_VARIANT
3302
3303 #endif // wxUSE_ACCESSIBILITY
3304
3305 // ----------------------------------------------------------------------------
3306 // RTL support
3307 // ----------------------------------------------------------------------------
3308
3309 wxCoord
3310 wxWindowBase::AdjustForLayoutDirection(wxCoord x,
3311                                        wxCoord width,
3312                                        wxCoord widthTotal) const
3313 {
3314     if ( GetLayoutDirection() == wxLayout_RightToLeft )
3315     {
3316         x = widthTotal - x - width;
3317     }
3318
3319     return x;
3320 }
3321
3322