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