To avoid error message, do not even try to set focus on MSW popup window that doesn...

[wxWidgets.git] / src / common / wincmn.cpp

diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp
index 9d0b6f45822f2f2e8f49f91cdec5a2e47c9ab8c1..6eac63e1a929196e12349ec74dd2c74baf0694c0 100644 (file)
--- a/src/common/wincmn.cpp
+++ b/src/common/wincmn.cpp
@@ -44,6 +44,7 @@
     #include "wx/scrolbar.h"
     #include "wx/layout.h"
     #include "wx/sizer.h"
     #include "wx/scrolbar.h"
     #include "wx/layout.h"
     #include "wx/sizer.h"

+    #include "wx/menu.h"

 #endif //WX_PRECOMP
 
 #if wxUSE_DRAG_AND_DROP
 #endif //WX_PRECOMP
 
 #if wxUSE_DRAG_AND_DROP


@@ -78,9 +79,6 @@
     #else
         #include <gtk/gtkfeatures.h>
     #endif
     #else
         #include <gtk/gtkfeatures.h>
     #endif

-    extern const unsigned int gtk_major_version;
-    extern const unsigned int gtk_minor_version;
-    extern const unsigned int gtk_micro_version;

 #endif
 
 #include "wx/platinfo.h"
 #endif
 
 #include "wx/platinfo.h"


@@ -88,17 +86,15 @@
 // Windows List
 WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows;
 
 // Windows List
 WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows;
 

+// globals
+#if wxUSE_MENUS
+wxMenu *wxCurrentPopupMenu = NULL;
+#endif // wxUSE_MENUS
+

 // ----------------------------------------------------------------------------
 // static data
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // static data
 // ----------------------------------------------------------------------------
 

-#if defined(__WXPALMOS__)
-int wxWindowBase::ms_lastControlId = 32767;
-#elif defined(__WXPM__)
-int wxWindowBase::ms_lastControlId = 2000;
-#else
-int wxWindowBase::ms_lastControlId = -200;
-#endif

 
 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
 


@@ -200,10 +196,7 @@ wxWindowBase::wxWindowBase()
 
     m_virtualSize = wxDefaultSize;
 
 
     m_virtualSize = wxDefaultSize;
 

-    m_minVirtualWidth =
-    m_maxVirtualWidth = wxDefaultCoord;
-    m_minVirtualHeight =
-    m_maxVirtualHeight = wxDefaultCoord;
+    m_scrollHelper = (wxScrollHelper *) NULL;

 
     m_windowVariant = wxWINDOW_VARIANT_NORMAL;
 #if wxUSE_SYSTEM_OPTIONS
 
     m_windowVariant = wxWINDOW_VARIANT_NORMAL;
 #if wxUSE_SYSTEM_OPTIONS


@@ -218,6 +211,8 @@ wxWindowBase::wxWindowBase()
 
     // VZ: this one shouldn't exist...
     m_isBeingDeleted = false;
 
     // VZ: this one shouldn't exist...
     m_isBeingDeleted = false;

+
+    m_freezeCount = 0;

 }
 
 // common part of window creation process
 }
 
 // common part of window creation process


@@ -243,14 +238,26 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
     // ids are limited to 16 bits under MSW so if you care about portability,
     // it's not a good idea to use ids out of this range (and negative ids are
     // reserved for wxWidgets own usage)
     // ids are limited to 16 bits under MSW so if you care about portability,
     // it's not a good idea to use ids out of this range (and negative ids are
     // reserved for wxWidgets own usage)

-    wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767),
+    wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767) ||
+                  (id >= wxID_AUTO_LOWEST && id <= wxID_AUTO_HIGHEST),

                   _T("invalid id value") );
 
     // generate a new id if the user doesn't care about it
                   _T("invalid id value") );
 
     // generate a new id if the user doesn't care about it

-    m_windowId = id == wxID_ANY ? NewControlId() : id;
+    if ( id == wxID_ANY )
+    {
+        m_windowId = NewControlId();
+    }
+    else // valid id specified
+    {
+        m_windowId = id;
+    }
+
+    // don't use SetWindowStyleFlag() here, this function should only be called
+    // to change the flag after creation as it tries to reflect the changes in
+    // flags by updating the window dynamically and we don't need this here
+    m_windowStyle = style;

 
     SetName(name);
 
     SetName(name);

-    SetWindowStyleFlag(style);

     SetParent(parent);
 
 #if wxUSE_VALIDATORS
     SetParent(parent);
 
 #if wxUSE_VALIDATORS


@@ -268,6 +275,28 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
     return true;
 }
 
     return true;
 }
 

+bool wxWindowBase::ToggleWindowStyle(int flag)
+{
+    wxASSERT_MSG( flag, _T("flags with 0 value can't be toggled") );
+
+    bool rc;
+    long style = GetWindowStyleFlag();
+    if ( style & flag )
+    {
+        style &= ~flag;
+        rc = false;
+    }
+    else // currently off
+    {
+        style |= flag;
+        rc = true;
+    }
+
+    SetWindowStyleFlag(style);
+
+    return rc;
+}
+

 // ----------------------------------------------------------------------------
 // destruction
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // destruction
 // ----------------------------------------------------------------------------


@@ -288,13 +317,18 @@ wxWindowBase::~wxWindowBase()
     // we weren't a dialog class
     wxTopLevelWindows.DeleteObject((wxWindow*)this);
 
     // we weren't a dialog class
     wxTopLevelWindows.DeleteObject((wxWindow*)this);
 

+#if wxUSE_MENUS
+    // The associated popup menu can still be alive, disassociate from it in
+    // this case
+    if ( wxCurrentPopupMenu && wxCurrentPopupMenu->GetInvokingWindow() == this )
+        wxCurrentPopupMenu->SetInvokingWindow(NULL);
+#endif // wxUSE_MENUS
+

     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 
     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 

-    // reset the dangling pointer our parent window may keep to us
+    // notify the parent about this window destruction

     if ( m_parent )
     if ( m_parent )

-    {

         m_parent->RemoveChild(this);
         m_parent->RemoveChild(this);

-    }

 
 #if wxUSE_CARET
     delete m_caret;
 
 #if wxUSE_CARET
     delete m_caret;


@@ -335,6 +369,28 @@ wxWindowBase::~wxWindowBase()
 #if wxUSE_ACCESSIBILITY
     delete m_accessible;
 #endif
 #if wxUSE_ACCESSIBILITY
     delete m_accessible;
 #endif

+
+#if wxUSE_HELP
+    // NB: this has to be called unconditionally, because we don't know
+    //     whether this window has associated help text or not
+    wxHelpProvider *helpProvider = wxHelpProvider::Get();
+    if ( helpProvider )
+        helpProvider->RemoveHelp(this);
+#endif
+}
+
+bool wxWindowBase::IsBeingDeleted() const
+{
+    return m_isBeingDeleted ||
+            (!IsTopLevel() && m_parent && m_parent->IsBeingDeleted());
+}
+
+void wxWindowBase::SendDestroyEvent()
+{
+    wxWindowDestroyEvent event;
+    event.SetEventObject(this);
+    event.SetId(GetId());
+    GetEventHandler()->ProcessEvent(event);

 }
 
 bool wxWindowBase::Destroy()
 }
 
 bool wxWindowBase::Destroy()


@@ -352,7 +408,7 @@ bool wxWindowBase::Close(bool force)
 
     // return false if window wasn't closed because the application vetoed the
     // close event
 
     // return false if window wasn't closed because the application vetoed the
     // close event

-    return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
+    return HandleWindowEvent(event) && !event.GetVeto();

 }
 
 bool wxWindowBase::DestroyChildren()
 }
 
 bool wxWindowBase::DestroyChildren()


@@ -449,7 +505,7 @@ wxSize wxWindowBase::DoGetBestSize() const
 
     if ( m_windowSizer )
     {
 
     if ( m_windowSizer )
     {

-        best = GetWindowSizeForVirtualSize(m_windowSizer->GetMinSize());
+        best = m_windowSizer->GetMinSize();

     }
 #if wxUSE_CONSTRAINTS
     else if ( m_constraints )
     }
 #if wxUSE_CONSTRAINTS
     else if ( m_constraints )


@@ -565,8 +621,79 @@ wxSize wxWindowBase::DoGetBestSize() const
     return best;
 }
 
     return best;
 }
 

+// helper of GetWindowBorderSize(): as many ports don't implement support for
+// wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded
+// fallbacks in this case
+static int wxGetMetricOrDefault(wxSystemMetric what, const wxWindowBase* win)
+{
+    int rc = wxSystemSettings::GetMetric(
+        what, static_cast<wxWindow*>(const_cast<wxWindowBase*>(win)));
+    if ( rc == -1 )
+    {
+        switch ( what )
+        {
+            case wxSYS_BORDER_X:
+            case wxSYS_BORDER_Y:
+                // 2D border is by default 1 pixel wide
+                rc = 1;
+                break;
+
+            case wxSYS_EDGE_X:
+            case wxSYS_EDGE_Y:
+                // 3D borders are by default 2 pixels
+                rc = 2;
+                break;
+
+            default:
+                wxFAIL_MSG( _T("unexpected wxGetMetricOrDefault() argument") );
+                rc = 0;
+        }
+    }
+
+    return rc;
+}

 
 

-wxSize wxWindowBase::GetBestFittingSize() const
+wxSize wxWindowBase::GetWindowBorderSize() const
+{
+    wxSize size;
+
+    switch ( GetBorder() )
+    {
+        case wxBORDER_NONE:
+            // nothing to do, size is already (0, 0)
+            break;
+
+        case wxBORDER_SIMPLE:
+        case wxBORDER_STATIC:
+            size.x = wxGetMetricOrDefault(wxSYS_BORDER_X, this);
+            size.y = wxGetMetricOrDefault(wxSYS_BORDER_Y, this);
+            break;
+
+        case wxBORDER_SUNKEN:
+        case wxBORDER_RAISED:
+            size.x = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X, this),
+                           wxGetMetricOrDefault(wxSYS_BORDER_X, this));
+            size.y = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y, this),
+                           wxGetMetricOrDefault(wxSYS_BORDER_Y, this));
+            break;
+
+        case wxBORDER_DOUBLE:
+            size.x = wxGetMetricOrDefault(wxSYS_EDGE_X, this) +
+                        wxGetMetricOrDefault(wxSYS_BORDER_X, this);
+            size.y = wxGetMetricOrDefault(wxSYS_EDGE_Y, this) +
+                        wxGetMetricOrDefault(wxSYS_BORDER_Y, this);
+            break;
+
+        default:
+            wxFAIL_MSG(_T("Unknown border style."));
+            break;
+    }
+
+    // we have borders on both sides
+    return size*2;
+}
+
+wxSize wxWindowBase::GetEffectiveMinSize() const

 {
     // merge the best size with the min size, giving priority to the min size
     wxSize min = GetMinSize();
 {
     // merge the best size with the min size, giving priority to the min size
     wxSize min = GetMinSize();


@@ -580,14 +707,14 @@ wxSize wxWindowBase::GetBestFittingSize() const
 }
 
 
 }
 
 

-void wxWindowBase::SetBestFittingSize(const wxSize& size)
+void wxWindowBase::SetInitialSize(const wxSize& size)

 {
     // Set the min size to the size passed in.  This will usually either be
     // wxDefaultSize or the size passed to this window's ctor/Create function.
     SetMinSize(size);
 
     // Merge the size with the best size if needed
 {
     // Set the min size to the size passed in.  This will usually either be
     // wxDefaultSize or the size passed to this window's ctor/Create function.
     SetMinSize(size);
 
     // Merge the size with the best size if needed

-    wxSize best = GetBestFittingSize();
+    wxSize best = GetEffectiveMinSize();

 
     // If the current size doesn't match then change it
     if (GetSize() != best)
 
     // If the current size doesn't match then change it
     if (GetSize() != best)


@@ -601,21 +728,20 @@ wxPoint wxWindowBase::GetClientAreaOrigin() const
     return wxPoint(0,0);
 }
 
     return wxPoint(0,0);
 }
 

-// set the min/max size of the window
-void wxWindowBase::DoSetSizeHints(int minW, int minH,
-                                  int maxW, int maxH,
-                                  int WXUNUSED(incW), int WXUNUSED(incH))
+wxSize wxWindowBase::ClientToWindowSize(const wxSize& size) const

 {
 {

-    // setting min width greater than max width leads to infinite loops under
-    // X11 and generally doesn't make any sense, so don't allow it
-    wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
-                    (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
-                 _T("min width/height must be less than max width/height!") );
+    const wxSize diff(GetSize() - GetClientSize());

 
 

-    m_minWidth = minW;
-    m_maxWidth = maxW;
-    m_minHeight = minH;
-    m_maxHeight = maxH;
+    return wxSize(size.x == -1 ? -1 : size.x + diff.x,
+                  size.y == -1 ? -1 : size.y + diff.y);
+}
+
+wxSize wxWindowBase::WindowToClientSize(const wxSize& size) const
+{
+    const wxSize diff(GetSize() - GetClientSize());
+
+    return wxSize(size.x == -1 ? -1 : size.x - diff.x,
+                  size.y == -1 ? -1 : size.y - diff.y);

 }
 
 void wxWindowBase::SetWindowVariant( wxWindowVariant variant )
 }
 
 void wxWindowBase::SetWindowVariant( wxWindowVariant variant )


@@ -663,26 +789,35 @@ void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant )
     SetFont(font);
 }
 
     SetFont(font);
 }
 

-void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
-                                        int maxW, int maxH )
+void wxWindowBase::DoSetSizeHints( int minW, int minH,
+                                   int maxW, int maxH,
+                                   int WXUNUSED(incW), int WXUNUSED(incH) )

 {
 {

-    m_minVirtualWidth = minW;
-    m_maxVirtualWidth = maxW;
-    m_minVirtualHeight = minH;
-    m_maxVirtualHeight = maxH;
+    wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
+                    (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
+                 _T("min width/height must be less than max width/height!") );
+
+    m_minWidth = minW;
+    m_maxWidth = maxW;
+    m_minHeight = minH;
+    m_maxHeight = maxH;

 }
 
 }
 

-void wxWindowBase::DoSetVirtualSize( int x, int y )
+
+#if WXWIN_COMPATIBILITY_2_8
+void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW), int WXUNUSED(minH),
+                                       int WXUNUSED(maxW), int WXUNUSED(maxH))

 {
 {

-    if ( m_minVirtualWidth != wxDefaultCoord && m_minVirtualWidth > x )
-        x = m_minVirtualWidth;
-    if ( m_maxVirtualWidth != wxDefaultCoord && m_maxVirtualWidth < x )
-        x = m_maxVirtualWidth;
-    if ( m_minVirtualHeight != wxDefaultCoord && m_minVirtualHeight > y )
-        y = m_minVirtualHeight;
-    if ( m_maxVirtualHeight != wxDefaultCoord && m_maxVirtualHeight < y )
-        y = m_maxVirtualHeight;
+}

 
 

+void wxWindowBase::SetVirtualSizeHints(const wxSize& WXUNUSED(minsize),
+                                       const wxSize& WXUNUSED(maxsize))
+{
+}
+#endif // WXWIN_COMPATIBILITY_2_8
+
+void wxWindowBase::DoSetVirtualSize( int x, int y )
+{

     m_virtualSize = wxSize(x, y);
 }
 
     m_virtualSize = wxSize(x, y);
 }
 


@@ -713,6 +848,23 @@ void wxWindowBase::DoGetScreenPosition(int *x, int *y) const
     ClientToScreen(x, y);
 }
 
     ClientToScreen(x, y);
 }
 

+void wxWindowBase::SendSizeEvent(int flags)
+{
+    wxSizeEvent event(GetSize(), GetId());
+    event.SetEventObject(this);
+    if ( flags & wxSEND_EVENT_POST )
+        wxPostEvent(this, event);
+    else
+        HandleWindowEvent(event);
+}
+
+void wxWindowBase::SendSizeEventToParent(int flags)
+{
+    wxWindow * const parent = GetParent();
+    if ( parent && !parent->IsBeingDeleted() )
+        parent->SendSizeEvent(flags);
+}
+

 // ----------------------------------------------------------------------------
 // show/hide/enable/disable the window
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // show/hide/enable/disable the window
 // ----------------------------------------------------------------------------


@@ -731,23 +883,64 @@ bool wxWindowBase::Show(bool show)
     }
 }
 
     }
 }
 

-bool wxWindowBase::Enable(bool enable)
+bool wxWindowBase::IsEnabled() const

 {
 {

-    if ( enable != m_isEnabled )
-    {
-        m_isEnabled = enable;
+    return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled());
+}

 
 

-        return true;
-    }
-    else
+void wxWindowBase::NotifyWindowOnEnableChange(bool enabled)
+{
+#ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
+    DoEnable(enabled);
+#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
+
+    OnEnabled(enabled);
+
+    // If we are top-level then the logic doesn't apply - otherwise
+    // showing a modal dialog would result in total greying out (and ungreying
+    // out later) of everything which would be really ugly
+    if ( IsTopLevel() )
+        return;
+
+    for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
+          node;
+          node = node->GetNext() )

     {
     {

+        wxWindowBase * const child = node->GetData();
+        if ( !child->IsTopLevel() && child->IsThisEnabled() )
+            child->NotifyWindowOnEnableChange(enabled);
+    }
+}
+
+bool wxWindowBase::Enable(bool enable)
+{
+    if ( enable == IsThisEnabled() )

         return false;
         return false;

+
+    m_isEnabled = enable;
+
+#ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT
+    DoEnable(enable);
+#else // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
+    wxWindowBase * const parent = GetParent();
+    if( !IsTopLevel() && parent && !parent->IsEnabled() )
+    {
+        return true;

     }
     }

+#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
+
+    NotifyWindowOnEnableChange(enable);
+
+    return true;

 }
 
 }
 

-bool wxWindowBase::IsVisible() const
+bool wxWindowBase::IsShownOnScreen() const

 {
 {

-    return IsShown() && (GetParent() == NULL || GetParent()->IsVisible());
+    // A window is shown on screen if it itself is shown and so are all its
+    // parents. But if a window is toplevel one, then its always visible on
+    // screen if IsShown() returns true, even if it has a hidden parent.
+    return IsShown() &&
+           (IsTopLevel() || GetParent() == NULL || GetParent()->IsShownOnScreen());

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -759,6 +952,52 @@ bool wxWindowBase::IsTopLevel() const
     return false;
 }
 
     return false;
 }
 

+// ----------------------------------------------------------------------------
+// Freeze/Thaw
+// ----------------------------------------------------------------------------
+
+void wxWindowBase::Freeze()
+{
+    if ( !m_freezeCount++ )
+    {
+        // physically freeze this window:
+        DoFreeze();
+
+        // and recursively freeze all children:
+        for ( wxWindowList::iterator i = GetChildren().begin();
+              i != GetChildren().end(); ++i )
+        {
+            wxWindow *child = *i;
+            if ( child->IsTopLevel() )
+                continue;
+
+            child->Freeze();
+        }
+    }
+}
+
+void wxWindowBase::Thaw()
+{
+    wxASSERT_MSG( m_freezeCount, "Thaw() without matching Freeze()" );
+
+    if ( !--m_freezeCount )
+    {
+        // recursively thaw all children:
+        for ( wxWindowList::iterator i = GetChildren().begin();
+              i != GetChildren().end(); ++i )
+        {
+            wxWindow *child = *i;
+            if ( child->IsTopLevel() )
+                continue;
+
+            child->Thaw();
+        }
+
+        // physically thaw this window:
+        DoThaw();
+    }
+}
+

 // ----------------------------------------------------------------------------
 // reparenting the window
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // reparenting the window
 // ----------------------------------------------------------------------------


@@ -774,12 +1013,25 @@ void wxWindowBase::AddChild(wxWindowBase *child)
 
     GetChildren().Append((wxWindow*)child);
     child->SetParent(this);
 
     GetChildren().Append((wxWindow*)child);
     child->SetParent(this);

+
+    // adding a child while frozen will assert when thawed, so freeze it as if
+    // it had been already present when we were frozen
+    if ( IsFrozen() && !child->IsTopLevel() )
+        child->Freeze();

 }
 
 void wxWindowBase::RemoveChild(wxWindowBase *child)
 {
     wxCHECK_RET( child, wxT("can't remove a NULL child") );
 
 }
 
 void wxWindowBase::RemoveChild(wxWindowBase *child)
 {
     wxCHECK_RET( child, wxT("can't remove a NULL child") );
 

+    // removing a child while frozen may result in permanently frozen window
+    // if used e.g. from Reparent(), so thaw it
+    //
+    // NB: IsTopLevel() doesn't return true any more when a TLW child is being
+    //     removed from its ~wxWindowBase, so check for IsBeingDeleted() too
+    if ( IsFrozen() && !child->IsBeingDeleted() && !child->IsTopLevel() )
+        child->Thaw();
+

     GetChildren().DeleteObject((wxWindow *)child);
     child->SetParent(NULL);
 }
     GetChildren().DeleteObject((wxWindow *)child);
     child->SetParent(NULL);
 }


@@ -793,6 +1045,8 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent)
         return false;
     }
 
         return false;
     }
 

+    const bool oldEnabledState = IsEnabled();
+

     // unlink this window from the existing parent.
     if ( oldParent )
     {
     // unlink this window from the existing parent.
     if ( oldParent )
     {


@@ -813,6 +1067,14 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent)
         wxTopLevelWindows.Append((wxWindow *)this);
     }
 
         wxTopLevelWindows.Append((wxWindow *)this);
     }
 

+    // We need to notify window (and its subwindows) if by changing the parent
+    // we also change our enabled/disabled status.
+    const bool newEnabledState = IsEnabled();
+    if ( newEnabledState != oldEnabledState )
+    {
+        NotifyWindowOnEnableChange(newEnabledState);
+    }
+

     return true;
 }
 
     return true;
 }
 


@@ -895,6 +1157,11 @@ bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
     return false;
 }
 
     return false;
 }
 

+bool wxWindowBase::HandleWindowEvent(wxEvent& event) const
+{
+    return GetEventHandler()->SafelyProcessEvent(event);
+}
+

 // ----------------------------------------------------------------------------
 // colours, fonts &c
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // colours, fonts &c
 // ----------------------------------------------------------------------------


@@ -955,7 +1222,7 @@ wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 
 wxColour wxWindowBase::GetBackgroundColour() const
 {
 
 wxColour wxWindowBase::GetBackgroundColour() const
 {

-    if ( !m_backgroundColour.Ok() )
+    if ( !m_backgroundColour.IsOk() )

     {
         wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") );
 
     {
         wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") );
 


@@ -981,11 +1248,9 @@ wxColour wxWindowBase::GetForegroundColour() const
     // logic is the same as above
     if ( !m_hasFgCol && !m_foregroundColour.Ok() )
     {
     // logic is the same as above
     if ( !m_hasFgCol && !m_foregroundColour.Ok() )
     {

-        wxASSERT_MSG( !m_hasFgCol, _T("we have invalid explicit fg colour?") );
-

         wxColour colFg = GetDefaultAttributes().colFg;
 
         wxColour colFg = GetDefaultAttributes().colFg;
 

-        if ( !colFg.Ok() )
+        if ( !colFg.IsOk() )

             colFg = GetClassDefaultAttributes().colFg;
 
         return colFg;
             colFg = GetClassDefaultAttributes().colFg;
 
         return colFg;


@@ -999,7 +1264,7 @@ bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
     if ( colour == m_backgroundColour )
         return false;
 
     if ( colour == m_backgroundColour )
         return false;
 

-    m_hasBgCol = colour.Ok();
+    m_hasBgCol = colour.IsOk();

     if ( m_backgroundStyle != wxBG_STYLE_CUSTOM )
         m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM;
 
     if ( m_backgroundStyle != wxBG_STYLE_CUSTOM )
         m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM;
 


@@ -1014,7 +1279,7 @@ bool wxWindowBase::SetForegroundColour( const wxColour &colour )
     if (colour == m_foregroundColour )
         return false;
 
     if (colour == m_foregroundColour )
         return false;
 

-    m_hasFgCol = colour.Ok();
+    m_hasFgCol = colour.IsOk();

     m_inheritFgCol = m_hasFgCol;
     m_foregroundColour = colour;
     SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() );
     m_inheritFgCol = m_hasFgCol;
     m_foregroundColour = colour;
     SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() );


@@ -1025,7 +1290,7 @@ bool wxWindowBase::SetCursor(const wxCursor& cursor)
 {
     // setting an invalid cursor is ok, it means that we don't have any special
     // cursor
 {
     // setting an invalid cursor is ok, it means that we don't have any special
     // cursor

-    if ( m_cursor == cursor )
+    if ( m_cursor.IsSameAs(cursor) )

     {
         // no change
         return false;
     {
         // no change
         return false;


@@ -1039,12 +1304,12 @@ bool wxWindowBase::SetCursor(const wxCursor& cursor)
 wxFont wxWindowBase::GetFont() const
 {
     // logic is the same as in GetBackgroundColour()
 wxFont wxWindowBase::GetFont() const
 {
     // logic is the same as in GetBackgroundColour()

-    if ( !m_font.Ok() )
+    if ( !m_font.IsOk() )

     {
         wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") );
 
         wxFont font = GetDefaultAttributes().font;
     {
         wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") );
 
         wxFont font = GetDefaultAttributes().font;

-        if ( !font.Ok() )
+        if ( !font.IsOk() )

             font = GetClassDefaultAttributes().font;
 
         return font;
             font = GetClassDefaultAttributes().font;
 
         return font;


@@ -1062,7 +1327,7 @@ bool wxWindowBase::SetFont(const wxFont& font)
     }
 
     m_font = font;
     }
 
     m_font = font;

-    m_hasFont = font.Ok();
+    m_hasFont = font.IsOk();

     m_inheritFont = m_hasFont;
 
     InvalidateBestSize();
     m_inheritFont = m_hasFont;
 
     InvalidateBestSize();


@@ -1161,7 +1426,7 @@ void wxWindowBase::ClearBackground()
     // wxGTK uses its own version, no need to add never used code
 #ifndef __WXGTK__
     wxClientDC dc((wxWindow *)this);
     // wxGTK uses its own version, no need to add never used code
 #ifndef __WXGTK__
     wxClientDC dc((wxWindow *)this);

-    wxBrush brush(GetBackgroundColour(), wxSOLID);
+    wxBrush brush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID);

     dc.SetBackground(brush);
     dc.Clear();
 #endif // __WXGTK__
     dc.SetBackground(brush);
     dc.Clear();
 #endif // __WXGTK__


@@ -1457,6 +1722,7 @@ void wxWindowBase::SetHelpText(const wxString& text)
     }
 }
 
     }
 }
 

+#if WXWIN_COMPATIBILITY_2_8

 // associate this help text with all windows with the same id as this
 // one
 void wxWindowBase::SetHelpTextForId(const wxString& text)
 // associate this help text with all windows with the same id as this
 // one
 void wxWindowBase::SetHelpTextForId(const wxString& text)


@@ -1467,6 +1733,7 @@ void wxWindowBase::SetHelpTextForId(const wxString& text)
         helpProvider->AddHelp(GetId(), text);
     }
 }
         helpProvider->AddHelp(GetId(), text);
     }
 }

+#endif // WXWIN_COMPATIBILITY_2_8

 
 // get the help string associated with this window (may be empty)
 // default implementation forwards calls to the help provider
 
 // get the help string associated with this window (may be empty)
 // default implementation forwards calls to the help provider


@@ -1490,7 +1757,29 @@ void wxWindowBase::OnHelp(wxHelpEvent& event)
     wxHelpProvider *helpProvider = wxHelpProvider::Get();
     if ( helpProvider )
     {
     wxHelpProvider *helpProvider = wxHelpProvider::Get();
     if ( helpProvider )
     {

-        if ( helpProvider->ShowHelpAtPoint(this, event.GetPosition(), event.GetOrigin()) )
+        wxPoint pos = event.GetPosition();
+        const wxHelpEvent::Origin origin = event.GetOrigin();
+        if ( origin == wxHelpEvent::Origin_Keyboard )
+        {
+            // if the help event was generated from keyboard it shouldn't
+            // appear at the mouse position (which is still the only position
+            // associated with help event) if the mouse is far away, although
+            // we still do use the mouse position if it's over the window
+            // because we suppose the user looks approximately at the mouse
+            // already and so it would be more convenient than showing tooltip
+            // at some arbitrary position which can be quite far from it
+            const wxRect rectClient = GetClientRect();
+            if ( !rectClient.Contains(ScreenToClient(pos)) )
+            {
+                // position help slightly under and to the right of this window
+                pos = ClientToScreen(wxPoint(
+                        2*GetCharWidth(),
+                        rectClient.height + GetCharHeight()
+                      ));
+            }
+        }
+
+        if ( helpProvider->ShowHelpAtPoint(this, pos, origin) )

         {
             // skip the event.Skip() below
             return;
         {
             // skip the event.Skip() below
             return;


@@ -1503,7 +1792,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event)
 #endif // wxUSE_HELP
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_HELP
 
 // ----------------------------------------------------------------------------

-// tooltipsroot.Replace("\\", "/");
+// tooltips

 // ----------------------------------------------------------------------------
 
 #if wxUSE_TOOLTIPS
 // ----------------------------------------------------------------------------
 
 #if wxUSE_TOOLTIPS


@@ -1987,7 +2276,7 @@ void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) co
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// do Update UI processing for child controls
+// Update UI processing

 // ----------------------------------------------------------------------------
 
 void wxWindowBase::UpdateWindowUI(long flags)
 // ----------------------------------------------------------------------------
 
 void wxWindowBase::UpdateWindowUI(long flags)


@@ -2022,23 +2311,6 @@ void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
         Show(event.GetShown());
 }
 
         Show(event.GetShown());
 }
 

-#if 0
-// call internal idle recursively
-// may be obsolete (wait until OnIdle scheme stabilises)
-void wxWindowBase::ProcessInternalIdle()
-{
-    OnInternalIdle();
-
-    wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow *child = node->GetData();
-        child->ProcessInternalIdle();
-        node = node->GetNext();
-    }
-}
-#endif
-

 // ----------------------------------------------------------------------------
 // dialog units translations
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // dialog units translations
 // ----------------------------------------------------------------------------


@@ -2105,6 +2377,58 @@ void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
     UpdateWindowUI(wxUPDATE_UI_RECURSE);
 }
 
     UpdateWindowUI(wxUPDATE_UI_RECURSE);
 }
 

+// ----------------------------------------------------------------------------
+// menu-related functions
+// ----------------------------------------------------------------------------
+
+#if wxUSE_MENUS
+
+bool wxWindowBase::PopupMenu(wxMenu *menu, int x, int y)
+{
+    wxCHECK_MSG( menu, false, "can't popup NULL menu" );
+
+    wxCurrentPopupMenu = menu;
+    const bool rc = DoPopupMenu(menu, x, y);
+    wxCurrentPopupMenu = NULL;
+
+    return rc;
+}
+
+// this is used to pass the id of the selected item from the menu event handler
+// to the main function itself
+//
+// it's ok to use a global here as there can be at most one popup menu shown at
+// any time
+static int gs_popupMenuSelection = wxID_NONE;
+
+void wxWindowBase::InternalOnPopupMenu(wxCommandEvent& event)
+{
+    // store the id in a global variable where we'll retrieve it from later
+    gs_popupMenuSelection = event.GetId();
+}
+
+int
+wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y)
+{
+    gs_popupMenuSelection = wxID_NONE;
+
+    Connect(wxEVT_COMMAND_MENU_SELECTED,
+            wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu),
+            NULL,
+            this);
+
+    PopupMenu(&menu, x, y);
+
+    Disconnect(wxEVT_COMMAND_MENU_SELECTED,
+               wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu),
+               NULL,
+               this);
+
+    return gs_popupMenuSelection;
+}
+
+#endif // wxUSE_MENUS
+

 // methods for drawing the sizers in a visible way
 #ifdef __WXDEBUG__
 
 // methods for drawing the sizers in a visible way
 #ifdef __WXDEBUG__
 


@@ -2114,7 +2438,7 @@ static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill = false)
 {
     wxClientDC dc((wxWindow *)win);
     dc.SetPen(*wxRED_PEN);
 {
     wxClientDC dc((wxWindow *)win);
     dc.SetPen(*wxRED_PEN);

-    dc.SetBrush(fill ? wxBrush(*wxRED, wxCROSSDIAG_HATCH): *wxTRANSPARENT_BRUSH);
+    dc.SetBrush(fill ? wxBrush(*wxRED, wxBRUSHSTYLE_CROSSDIAG_HATCH) : *wxTRANSPARENT_BRUSH);

     dc.DrawRectangle(rect.Deflate(1, 1));
 }
 
     dc.DrawRectangle(rect.Deflate(1, 1));
 }
 


@@ -2179,42 +2503,9 @@ void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
             return;
         }
 #endif // __WXDEBUG__
             return;
         }
 #endif // __WXDEBUG__

-
-#if wxUSE_MSGDLG
-        // don't translate these strings, they're for diagnostics purposes only
-        wxString msg;
-        msg.Printf(_T("wxWidgets Library (%s port)\n")
-                   _T("Version %d.%d.%d%s%s, compiled at %s %s%s\n")
-                   _T("Copyright (c) 1995-2006 wxWidgets team"),
-                   wxPlatformInfo().GetPortIdName().c_str(),
-                   wxMAJOR_VERSION,
-                   wxMINOR_VERSION,
-                   wxRELEASE_NUMBER,
-#if wxUSE_UNICODE
-                   L" (Unicode)",
-#else
-                   wxEmptyString,
-#endif
-#ifdef __WXDEBUG__
-                   _T(" Debug build"),
-#else
-                   wxEmptyString,
-#endif
-                   __TDATE__,
-                   __TTIME__,
-#ifdef __WXGTK__
-                   wxString::Format(_T("\nagainst GTK+ %d.%d.%d. Runtime GTK+ version: %d.%d.%d"), GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION, gtk_major_version, gtk_minor_version, gtk_micro_version).c_str()
-#else
-                   wxEmptyString
-#endif
-                   );
-
-        wxMessageBox(msg, _T("wxWidgets information"),
-                     wxICON_INFORMATION | wxOK,
-                     (wxWindow *)this);
+        ::wxInfoMessageBox((wxWindow*)this);

     }
     else
     }
     else

-#endif // wxUSE_MSGDLG

     {
         event.Skip();
     }
     {
         event.Skip();
     }


@@ -2259,14 +2550,14 @@ wxAccessible* wxWindowBase::CreateAccessible()
 #include "wx/listimpl.cpp"
 WX_DEFINE_LIST(wxWindowList)
 
 #include "wx/listimpl.cpp"
 WX_DEFINE_LIST(wxWindowList)
 

-#else
+#else // !wxUSE_STL

 
 void wxWindowListNode::DeleteData()
 {
     delete (wxWindow *)GetData();
 }
 
 
 void wxWindowListNode::DeleteData()
 {
     delete (wxWindow *)GetData();
 }
 

-#endif
+#endif // wxUSE_STL/!wxUSE_STL

 
 // ----------------------------------------------------------------------------
 // borders
 
 // ----------------------------------------------------------------------------
 // borders


@@ -2279,6 +2570,10 @@ wxBorder wxWindowBase::GetBorder(long flags) const
     {
         border = GetDefaultBorder();
     }
     {
         border = GetDefaultBorder();
     }

+    else if ( border == wxBORDER_THEME )
+    {
+        border = GetDefaultBorderForControl();
+    }

 
     return border;
 }
 
     return border;
 }


@@ -2322,7 +2617,7 @@ bool wxWindowBase::ms_winCaptureChanging = false;
 
 void wxWindowBase::CaptureMouse()
 {
 
 void wxWindowBase::CaptureMouse()
 {

-    wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), wx_static_cast(void*, this));
+    wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), static_cast<void*>(this));

 
     wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive CaptureMouse call?") );
 
 
     wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive CaptureMouse call?") );
 


@@ -2349,11 +2644,14 @@ void wxWindowBase::CaptureMouse()
 
 void wxWindowBase::ReleaseMouse()
 {
 
 void wxWindowBase::ReleaseMouse()
 {

-    wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), wx_static_cast(void*, this));
+    wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), static_cast<void*>(this));

 
     wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive ReleaseMouse call?") );
 
 
     wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive ReleaseMouse call?") );
 

-    wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
+    wxASSERT_MSG( GetCapture() == this,
+                  "attempt to release mouse, but this window hasn't captured it" );
+    wxASSERT_MSG( ms_winCaptureCurrent == this,
+                  "attempt to release mouse, but this window hasn't captured it" );

 
     ms_winCaptureChanging = true;
 
 
     ms_winCaptureChanging = true;
 


@@ -2375,7 +2673,7 @@ void wxWindowBase::ReleaseMouse()
 
     wxLogTrace(_T("mousecapture"),
         (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"),
 
     wxLogTrace(_T("mousecapture"),
         (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"),

-        wx_static_cast(void*, GetCapture()));
+        static_cast<void*>(GetCapture()));

 }
 
 static void DoNotifyWindowAboutCaptureLost(wxWindow *win)
 }
 
 static void DoNotifyWindowAboutCaptureLost(wxWindow *win)


@@ -2384,6 +2682,10 @@ static void DoNotifyWindowAboutCaptureLost(wxWindow *win)
     event.SetEventObject(win);
     if ( !win->GetEventHandler()->ProcessEvent(event) )
     {
     event.SetEventObject(win);
     if ( !win->GetEventHandler()->ProcessEvent(event) )
     {

+        // windows must handle this event, otherwise the app wouldn't behave
+        // correctly if it loses capture unexpectedly; see the discussion here:
+        // http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863
+        // http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376

         wxFAIL_MSG( _T("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
     }
 }
         wxFAIL_MSG( _T("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
     }
 }


@@ -2435,14 +2737,6 @@ bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId))
 
 #endif // wxUSE_HOTKEY
 
 
 #endif // wxUSE_HOTKEY
 

-void wxWindowBase::SendDestroyEvent()
-{
-    wxWindowDestroyEvent event;
-    event.SetEventObject(this);
-    event.SetId(GetId());
-    GetEventHandler()->ProcessEvent(event);
-}
-

 // ----------------------------------------------------------------------------
 // event processing
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // event processing
 // ----------------------------------------------------------------------------


@@ -2454,8 +2748,8 @@ bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event))
     // is receiving the event
     if ( event.GetEventObject() == this )
     {
     // is receiving the event
     if ( event.GetEventObject() == this )
     {

-        wxValidator *validator = GetValidator();
-        if ( validator && validator->ProcessEvent(event) )
+        wxValidator * const validator = GetValidator();
+        if ( validator && validator->ProcessEventHere(event) )

         {
             return true;
         }
         {
             return true;
         }


@@ -2490,24 +2784,68 @@ bool wxWindowBase::TryParent(wxEvent& event)
     return wxEvtHandler::TryParent(event);
 }
 
     return wxEvtHandler::TryParent(event);
 }
 

+// ----------------------------------------------------------------------------
+// window relationships
+// ----------------------------------------------------------------------------
+
+wxWindow *wxWindowBase::DoGetSibling(WindowOrder order) const
+{
+    wxCHECK_MSG( GetParent(), NULL,
+                    _T("GetPrev/NextSibling() don't work for TLWs!") );
+
+    wxWindowList& siblings = GetParent()->GetChildren();
+    wxWindowList::compatibility_iterator i = siblings.Find((wxWindow *)this);
+    wxCHECK_MSG( i, NULL, _T("window not a child of its parent?") );
+
+    if ( order == OrderBefore )
+        i = i->GetPrevious();
+    else // OrderAfter
+        i = i->GetNext();
+
+    return i ? i->GetData() : NULL;
+}
+

 // ----------------------------------------------------------------------------
 // keyboard navigation
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // keyboard navigation
 // ----------------------------------------------------------------------------
 

-// Navigates in the specified direction.
-bool wxWindowBase::Navigate(int flags)
+// Navigates in the specified direction inside this window
+bool wxWindowBase::DoNavigateIn(int flags)

 {
 {

+#ifdef wxHAS_NATIVE_TAB_TRAVERSAL
+    // native code doesn't process our wxNavigationKeyEvents anyhow
+    wxUnusedVar(flags);
+    return false;
+#else // !wxHAS_NATIVE_TAB_TRAVERSAL

     wxNavigationKeyEvent eventNav;
     wxNavigationKeyEvent eventNav;

+    wxWindow *focused = FindFocus();
+    eventNav.SetCurrentFocus(focused);
+    eventNav.SetEventObject(focused);

     eventNav.SetFlags(flags);
     eventNav.SetFlags(flags);

-    eventNav.SetEventObject(this);
-    if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
-    {
-        return true;
-    }
-    return false;
+    return GetEventHandler()->ProcessEvent(eventNav);
+#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL

 }
 
 }
 

-void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)
+bool wxWindowBase::HandleAsNavigationKey(const wxKeyEvent& event)
+{
+    if ( event.GetKeyCode() != WXK_TAB )
+        return false;
+
+    int flags = wxNavigationKeyEvent::FromTab;
+
+    if ( event.ShiftDown() )
+        flags |= wxNavigationKeyEvent::IsBackward;
+    else
+        flags |= wxNavigationKeyEvent::IsForward;
+
+    if ( event.ControlDown() )
+        flags |= wxNavigationKeyEvent::WinChange;
+
+    Navigate(flags);
+    return true;
+}
+
+void wxWindowBase::DoMoveInTabOrder(wxWindow *win, WindowOrder move)

 {
     // check that we're not a top level window
     wxCHECK_RET( GetParent(),
 {
     // check that we're not a top level window
     wxCHECK_RET( GetParent(),


@@ -2527,7 +2865,7 @@ void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)
     // can't just move the node around
     wxWindow *self = (wxWindow *)this;
     siblings.DeleteObject(self);
     // can't just move the node around
     wxWindow *self = (wxWindow *)this;
     siblings.DeleteObject(self);

-    if ( move == MoveAfter )
+    if ( move == OrderAfter )

     {
         i = i->GetNext();
     }
     {
         i = i->GetNext();
     }


@@ -2536,7 +2874,7 @@ void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)
     {
         siblings.Insert(i, self);
     }
     {
         siblings.Insert(i, self);
     }

-    else // MoveAfter and win was the last sibling
+    else // OrderAfter and win was the last sibling

     {
         siblings.Append(self);
     }
     {
         siblings.Append(self);
     }


@@ -2552,6 +2890,68 @@ void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)
     return win ? win->GetMainWindowOfCompositeControl() : NULL;
 }
 
     return win ? win->GetMainWindowOfCompositeControl() : NULL;
 }
 

+bool wxWindowBase::HasFocus() const
+{
+    wxWindowBase *win = DoFindFocus();
+    return win == this ||
+           win == wxConstCast(this, wxWindowBase)->GetMainWindowOfCompositeControl();
+}
+
+// ----------------------------------------------------------------------------
+// drag and drop
+// ----------------------------------------------------------------------------
+
+#if wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
+
+namespace
+{
+
+class DragAcceptFilesTarget : public wxFileDropTarget
+{
+public:
+    DragAcceptFilesTarget(wxWindowBase *win) : m_win(win) {}
+
+    virtual bool OnDropFiles(wxCoord x, wxCoord y,
+                             const wxArrayString& filenames)
+    {
+        wxDropFilesEvent event(wxEVT_DROP_FILES,
+                               filenames.size(),
+                               wxCArrayString(filenames).Release());
+        event.SetEventObject(m_win);
+        event.m_pos.x = x;
+        event.m_pos.y = y;
+
+        return m_win->HandleWindowEvent(event);
+    }
+
+private:
+    wxWindowBase * const m_win;
+
+    DECLARE_NO_COPY_CLASS(DragAcceptFilesTarget)
+};
+
+
+} // anonymous namespace
+
+// Generic version of DragAcceptFiles(). It works by installing a simple
+// wxFileDropTarget-to-EVT_DROP_FILES adaptor and therefore cannot be used
+// together with explicit SetDropTarget() calls.
+void wxWindowBase::DragAcceptFiles(bool accept)
+{
+    if ( accept )
+    {
+        wxASSERT_MSG( !GetDropTarget(),
+                      "cannot use DragAcceptFiles() and SetDropTarget() together" );
+        SetDropTarget(new DragAcceptFilesTarget(this));
+    }
+    else
+    {
+        SetDropTarget(NULL);
+    }
+}
+
+#endif // wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
+

 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------


@@ -2968,6 +3368,7 @@ wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible**
     return wxACC_NOT_IMPLEMENTED;
 }
 
     return wxACC_NOT_IMPLEMENTED;
 }
 

+#if wxUSE_VARIANT

 // Gets a variant representing the selected children
 // of this object.
 // Acceptable values:
 // Gets a variant representing the selected children
 // of this object.
 // Acceptable values:


@@ -2984,6 +3385,7 @@ wxAccStatus wxWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections))
 
     return wxACC_NOT_IMPLEMENTED;
 }
 
     return wxACC_NOT_IMPLEMENTED;
 }

+#endif // wxUSE_VARIANT

 
 #endif // wxUSE_ACCESSIBILITY
 
 
 #endif // wxUSE_ACCESSIBILITY
 


@@ -3004,3 +3406,4 @@ wxWindowBase::AdjustForLayoutDirection(wxCoord x,
     return x;
 }
 
     return x;
 }
 

+