Make it compile

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

diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp
index 57a451efd581bc2d8de8add1fdd5d6d7e492b5a3..1c256cbdb760f24bd67ee5e89984f4c9d46636a6 100644 (file)
--- a/src/common/wincmn.cpp
+++ b/src/common/wincmn.cpp
@@ -38,6 +38,7 @@
     #include "wx/settings.h"
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
     #include "wx/settings.h"
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"

+    #include "wx/msgout.h"

     #include "wx/statusbr.h"
     #include "wx/toolbar.h"
     #include "wx/dcclient.h"
     #include "wx/statusbr.h"
     #include "wx/toolbar.h"
     #include "wx/dcclient.h"


@@ -71,17 +72,12 @@
     #include "wx/sysopt.h"
 #endif
 
     #include "wx/sysopt.h"
 #endif
 

-// For reporting compile- and runtime version of GTK+ in the ctrl+alt+mclick dialog.
-// The gtk includes don't pull any other headers in, at least not on my system - MR
-#ifdef __WXGTK__
-    #ifdef __WXGTK20__
-        #include <gtk/gtkversion.h>
-    #else
-        #include <gtk/gtkfeatures.h>
-    #endif
-#endif
-

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

+#include "wx/private/window.h"
+
+#ifdef __WXMSW__
+    #include "wx/msw/wrapwin.h"
+#endif

 
 // Windows List
 WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows;
 
 // Windows List
 WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows;


@@ -111,6 +107,7 @@ BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
     EVT_HELP(wxID_ANY, wxWindowBase::OnHelp)
 #endif // wxUSE_HELP
 
     EVT_HELP(wxID_ANY, wxWindowBase::OnHelp)
 #endif // wxUSE_HELP
 

+    EVT_SIZE(wxWindowBase::InternalOnSize)

 END_EVENT_TABLE()
 
 // ============================================================================
 END_EVENT_TABLE()
 
 // ============================================================================


@@ -162,7 +159,7 @@ wxWindowBase::wxWindowBase()
     m_exStyle =
     m_windowStyle = 0;
 
     m_exStyle =
     m_windowStyle = 0;
 

-    m_backgroundStyle = wxBG_STYLE_SYSTEM;
+    m_backgroundStyle = wxBG_STYLE_ERASE;

 
 #if wxUSE_CONSTRAINTS
     // no constraints whatsoever
 
 #if wxUSE_CONSTRAINTS
     // no constraints whatsoever


@@ -209,7 +206,9 @@ wxWindowBase::wxWindowBase()
     // Whether we're using the current theme for this window (wxGTK only for now)
     m_themeEnabled = false;
 
     // Whether we're using the current theme for this window (wxGTK only for now)
     m_themeEnabled = false;
 

-    // VZ: this one shouldn't exist...
+    // This is set to true by SendDestroyEvent() which should be called by the
+    // most derived class to ensure that the destruction event is sent as soon
+    // as possible to allow its handlers to still see the undestroyed window

     m_isBeingDeleted = false;
 
     m_freezeCount = 0;
     m_isBeingDeleted = false;
 
     m_freezeCount = 0;


@@ -219,28 +218,16 @@ wxWindowBase::wxWindowBase()
 bool wxWindowBase::CreateBase(wxWindowBase *parent,
                               wxWindowID id,
                               const wxPoint& WXUNUSED(pos),
 bool wxWindowBase::CreateBase(wxWindowBase *parent,
                               wxWindowID id,
                               const wxPoint& WXUNUSED(pos),

-                              const wxSize& WXUNUSED(size),
+                              const wxSize& size,

                               long style,
                               long style,

-                              const wxValidator& wxVALIDATOR_PARAM(validator),

                               const wxString& name)
 {
                               const wxString& name)
 {

-#if wxUSE_STATBOX
-    // wxGTK doesn't allow to create controls with static box as the parent so
-    // this will result in a crash when the program is ported to wxGTK so warn
-    // the user about it
-
-    // if you get this assert, the correct solution is to create the controls
-    // as siblings of the static box
-    wxASSERT_MSG( !parent || !wxDynamicCast(parent, wxStaticBox),
-                  _T("wxStaticBox can't be used as a window parent!") );
-#endif // wxUSE_STATBOX
-

     // 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) ||
                   (id >= wxID_AUTO_LOWEST && id <= wxID_AUTO_HIGHEST),
     // 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) ||
                   (id >= wxID_AUTO_LOWEST && id <= wxID_AUTO_HIGHEST),

-                  _T("invalid id value") );
+                  wxT("invalid id value") );

 
     // generate a new id if the user doesn't care about it
     if ( id == wxID_ANY )
 
     // generate a new id if the user doesn't care about it
     if ( id == wxID_ANY )


@@ -257,9 +244,32 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
     // flags by updating the window dynamically and we don't need this here
     m_windowStyle = style;
 
     // flags by updating the window dynamically and we don't need this here
     m_windowStyle = style;
 

+    // assume the user doesn't want this window to shrink beneath its initial
+    // size, this worked like this in wxWidgets 2.8 and before and generally
+    // often makes sense for child windows (for top level ones it definitely
+    // does not as the user should be able to resize the window)
+    //
+    // note that we can't use IsTopLevel() from ctor
+    if ( size != wxDefaultSize && !wxTopLevelWindows.Find((wxWindow *)this) )
+        SetMinSize(size);
+

     SetName(name);
     SetParent(parent);
 
     SetName(name);
     SetParent(parent);
 

+    return true;
+}
+
+bool wxWindowBase::CreateBase(wxWindowBase *parent,
+                              wxWindowID id,
+                              const wxPoint& pos,
+                              const wxSize& size,
+                              long style,
+                              const wxValidator& wxVALIDATOR_PARAM(validator),
+                              const wxString& name)
+{
+    if ( !CreateBase(parent, id, pos, size, style, name) )
+        return false;
+

 #if wxUSE_VALIDATORS
     SetValidator(validator);
 #endif // wxUSE_VALIDATORS
 #if wxUSE_VALIDATORS
     SetValidator(validator);
 #endif // wxUSE_VALIDATORS


@@ -277,7 +287,7 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
 
 bool wxWindowBase::ToggleWindowStyle(int flag)
 {
 
 bool wxWindowBase::ToggleWindowStyle(int flag)
 {

-    wxASSERT_MSG( flag, _T("flags with 0 value can't be toggled") );
+    wxASSERT_MSG( flag, wxT("flags with 0 value can't be toggled") );

 
     bool rc;
     long style = GetWindowStyleFlag();
 
     bool rc;
     long style = GetWindowStyleFlag();


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

+    // Any additional event handlers should be popped before the window is
+    // deleted as otherwise the last handler will be left with a dangling
+    // pointer to this window result in a difficult to diagnose crash later on.
+    wxASSERT_MSG( GetEventHandler() == this,
+                    wxT("any pushed event handlers must have been removed") );
+

 #if wxUSE_MENUS
     // The associated popup menu can still be alive, disassociate from it in
     // this case
 #if wxUSE_MENUS
     // The associated popup menu can still be alive, disassociate from it in
     // this case


@@ -348,8 +364,7 @@ wxWindowBase::~wxWindowBase()
         // This removes any dangling pointers to this window in other windows'
         // constraintsInvolvedIn lists.
         UnsetConstraints(m_constraints);
         // This removes any dangling pointers to this window in other windows'
         // constraintsInvolvedIn lists.
         UnsetConstraints(m_constraints);

-        delete m_constraints;
-        m_constraints = NULL;
+        wxDELETE(m_constraints);

     }
 #endif // wxUSE_CONSTRAINTS
 
     }
 #endif // wxUSE_CONSTRAINTS
 


@@ -387,6 +402,16 @@ bool wxWindowBase::IsBeingDeleted() const
 
 void wxWindowBase::SendDestroyEvent()
 {
 
 void wxWindowBase::SendDestroyEvent()
 {

+    if ( m_isBeingDeleted )
+    {
+        // we could have been already called from a more derived class dtor,
+        // e.g. ~wxTLW calls us and so does ~wxWindow and the latter call
+        // should be simply ignored
+        return;
+    }
+
+    m_isBeingDeleted = true;
+

     wxWindowDestroyEvent event;
     event.SetEventObject(this);
     event.SetId(GetId());
     wxWindowDestroyEvent event;
     event.SetEventObject(this);
     event.SetId(GetId());


@@ -395,6 +420,8 @@ void wxWindowBase::SendDestroyEvent()
 
 bool wxWindowBase::Destroy()
 {
 
 bool wxWindowBase::Destroy()
 {

+    SendDestroyEvent();
+

     delete this;
 
     return true;
     delete this;
 
     return true;


@@ -423,11 +450,11 @@ bool wxWindowBase::DestroyChildren()
 
         wxWindow *child = node->GetData();
 
 
         wxWindow *child = node->GetData();
 

-        // note that we really want to call delete and not ->Destroy() here
-        // because we want to delete the child immediately, before we are
-        // deleted, and delayed deletion would result in problems as our (top
-        // level) child could outlive its parent
-        delete child;
+        // note that we really want to delete it immediately so don't call the
+        // possible overridden Destroy() version which might not delete the
+        // child immediately resulting in problems with our (top level) child
+        // outliving its parent
+        child->wxWindowBase::Destroy();

 
         wxASSERT_MSG( !GetChildren().Find(child),
                       wxT("child didn't remove itself using RemoveChild()") );
 
         wxASSERT_MSG( !GetChildren().Find(child),
                       wxT("child didn't remove itself using RemoveChild()") );


@@ -444,7 +471,7 @@ bool wxWindowBase::DestroyChildren()
 void wxWindowBase::DoCentre(int dir)
 {
     wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(),
 void wxWindowBase::DoCentre(int dir)
 {
     wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(),

-                 _T("this method only implements centering child windows") );
+                 wxT("this method only implements centering child windows") );

 
     SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir));
 }
 
     SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir));
 }


@@ -469,7 +496,7 @@ void wxWindowBase::FitInside()
 }
 
 // On Mac, scrollbars are explicitly children.
 }
 
 // On Mac, scrollbars are explicitly children.

-#ifdef __WXMAC__
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)

 static bool wxHasRealChildren(const wxWindowBase* win)
 {
     int realChildCount = 0;
 static bool wxHasRealChildren(const wxWindowBase* win)
 {
     int realChildCount = 0;


@@ -479,7 +506,11 @@ static bool wxHasRealChildren(const wxWindowBase* win)
           node = node->GetNext() )
     {
         wxWindow *win = node->GetData();
           node = node->GetNext() )
     {
         wxWindow *win = node->GetData();

-        if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar)))
+        if ( !win->IsTopLevel() && win->IsShown()
+#if wxUSE_SCROLLBAR
+            && !win->IsKindOf(CLASSINFO(wxScrollBar))
+#endif
+            )

             realChildCount ++;
     }
     return (realChildCount > 0);
             realChildCount ++;
     }
     return (realChildCount > 0);


@@ -545,7 +576,7 @@ wxSize wxWindowBase::DoGetBestSize() const
     }
 #endif // wxUSE_CONSTRAINTS
     else if ( !GetChildren().empty()
     }
 #endif // wxUSE_CONSTRAINTS
     else if ( !GetChildren().empty()

-#ifdef __WXMAC__
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)

               && wxHasRealChildren(this)
 #endif
               )
               && wxHasRealChildren(this)
 #endif
               )


@@ -594,19 +625,14 @@ wxSize wxWindowBase::DoGetBestSize() const
     }
     else // ! has children
     {
     }
     else // ! has children
     {

-        // for a generic window there is no natural best size so, if the
-        // minimal size is not set, use the current size but take care to
-        // remember it as minimal size for the next time because our best size
-        // should be constant: otherwise we could get into a situation when the
-        // window is initially at some size, then expanded to a larger size and
-        // then, when the containing window is shrunk back (because our initial
-        // best size had been used for computing the parent min size), we can't
-        // be shrunk back any more because our best size is now bigger

         wxSize size = GetMinSize();
         if ( !size.IsFullySpecified() )
         {
         wxSize size = GetMinSize();
         if ( !size.IsFullySpecified() )
         {

-            size.SetDefaults(GetSize());
-            wxConstCast(this, wxWindowBase)->SetMinSize(size);
+            // if the window doesn't define its best size we assume that it can
+            // be arbitrarily small -- usually this is not the case, of course,
+            // but we have no way to know what the limit is, it should really
+            // override DoGetBestClientSize() itself to tell us
+            size.SetDefaults(wxSize(1, 1));

         }
 
         // return as-is, unadjusted by the client size difference.
         }
 
         // return as-is, unadjusted by the client size difference.


@@ -645,7 +671,7 @@ static int wxGetMetricOrDefault(wxSystemMetric what, const wxWindowBase* win)
                 break;
 
             default:
                 break;
 
             default:

-                wxFAIL_MSG( _T("unexpected wxGetMetricOrDefault() argument") );
+                wxFAIL_MSG( wxT("unexpected wxGetMetricOrDefault() argument") );

                 rc = 0;
         }
     }
                 rc = 0;
         }
     }


@@ -685,7 +711,7 @@ wxSize wxWindowBase::GetWindowBorderSize() const
             break;
 
         default:
             break;
 
         default:

-            wxFAIL_MSG(_T("Unknown border style."));
+            wxFAIL_MSG(wxT("Unknown border style."));

             break;
     }
 
             break;
     }
 


@@ -697,15 +723,59 @@ 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();

+

     if (min.x == wxDefaultCoord || min.y == wxDefaultCoord)
     {
         wxSize best = GetBestSize();
         if (min.x == wxDefaultCoord) min.x =  best.x;
         if (min.y == wxDefaultCoord) min.y =  best.y;
     }
     if (min.x == wxDefaultCoord || min.y == wxDefaultCoord)
     {
         wxSize best = GetBestSize();
         if (min.x == wxDefaultCoord) min.x =  best.x;
         if (min.y == wxDefaultCoord) min.y =  best.y;
     }

+

     return min;
 }
 
     return min;
 }
 

+wxSize wxWindowBase::DoGetBorderSize() const
+{
+    // there is one case in which we can implement it for all ports easily
+    if ( GetBorder() == wxBORDER_NONE )
+        return wxSize(0, 0);
+
+    // otherwise use the difference between the real size and the client size
+    // as a fallback: notice that this is incorrect in general as client size
+    // also doesn't take the scrollbars into account
+    return GetSize() - GetClientSize();
+}
+
+wxSize wxWindowBase::GetBestSize() const
+{
+    if ( !m_windowSizer && m_bestSizeCache.IsFullySpecified() )
+        return m_bestSizeCache;
+
+    // call DoGetBestClientSize() first, if a derived class overrides it wants
+    // it to be used
+    wxSize size = DoGetBestClientSize();
+    if ( size != wxDefaultSize )
+    {
+        size += DoGetBorderSize();
+
+        CacheBestSize(size);
+        return size;
+    }
+
+    return DoGetBestSize();
+}
+
+void wxWindowBase::SetMinSize(const wxSize& minSize)
+{
+    m_minWidth = minSize.x;
+    m_minHeight = minSize.y;
+}
+
+void wxWindowBase::SetMaxSize(const wxSize& maxSize)
+{
+    m_maxWidth = maxSize.x;
+    m_maxHeight = maxSize.y;
+}

 
 void wxWindowBase::SetInitialSize(const wxSize& size)
 {
 
 void wxWindowBase::SetInitialSize(const wxSize& size)
 {


@@ -781,7 +851,7 @@ void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant )
             break;
 
         default:
             break;
 
         default:

-            wxFAIL_MSG(_T("unexpected window variant"));
+            wxFAIL_MSG(wxT("unexpected window variant"));

             break;
     }
 
             break;
     }
 


@@ -795,7 +865,7 @@ void wxWindowBase::DoSetSizeHints( int minW, int minH,
 {
     wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
                     (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= 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!") );
+                 wxT("min width/height must be less than max width/height!") );

 
     m_minWidth = minW;
     m_maxWidth = maxW;
 
     m_minWidth = minW;
     m_maxWidth = maxW;


@@ -865,6 +935,20 @@ void wxWindowBase::SendSizeEventToParent(int flags)
         parent->SendSizeEvent(flags);
 }
 
         parent->SendSizeEvent(flags);
 }
 

+bool wxWindowBase::HasScrollbar(int orient) const
+{
+    // if scrolling in the given direction is disabled, we can't have the
+    // corresponding scrollbar no matter what
+    if ( !CanScroll(orient) )
+        return false;
+
+    const wxSize sizeVirt = GetVirtualSize();
+    const wxSize sizeClient = GetClientSize();
+
+    return orient == wxHORIZONTAL ? sizeVirt.x > sizeClient.x
+                                  : sizeVirt.y > sizeClient.y;
+}
+

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


@@ -1009,7 +1093,7 @@ void wxWindowBase::AddChild(wxWindowBase *child)
     // this should never happen and it will lead to a crash later if it does
     // because RemoveChild() will remove only one node from the children list
     // and the other(s) one(s) will be left with dangling pointers in them
     // this should never happen and it will lead to a crash later if it does
     // because RemoveChild() will remove only one node from the children list
     // and the other(s) one(s) will be left with dangling pointers in them

-    wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), _T("AddChild() called twice") );
+    wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), wxT("AddChild() called twice") );

 
     GetChildren().Append((wxWindow*)child);
     child->SetParent(this);
 
     GetChildren().Append((wxWindow*)child);
     child->SetParent(this);


@@ -1082,83 +1166,134 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent)
 // event handler stuff
 // ----------------------------------------------------------------------------
 
 // event handler stuff
 // ----------------------------------------------------------------------------
 

-void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
+void wxWindowBase::SetEventHandler(wxEvtHandler *handler)
+{
+    wxCHECK_RET(handler != NULL, "SetEventHandler(NULL) called");
+
+    m_eventHandler = handler;
+}
+
+void wxWindowBase::SetNextHandler(wxEvtHandler *WXUNUSED(handler))
+{
+    // disable wxEvtHandler chain mechanism for wxWindows:
+    // wxWindow uses its own stack mechanism which doesn't mix well with wxEvtHandler's one
+
+    wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
+}
+void wxWindowBase::SetPreviousHandler(wxEvtHandler *WXUNUSED(handler))
+{
+    // we can't simply wxFAIL here as in SetNextHandler: in fact the last
+    // handler of our stack when is destroyed will be Unlink()ed and thus
+    // will call this function to update the pointer of this window...
+
+    //wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
+}
+
+void wxWindowBase::PushEventHandler(wxEvtHandler *handlerToPush)

 {
 {

+    wxCHECK_RET( handlerToPush != NULL, "PushEventHandler(NULL) called" );
+
+    // the new handler is going to be part of the wxWindow stack of event handlers:
+    // it can't be part also of an event handler double-linked chain:
+    wxASSERT_MSG(handlerToPush->IsUnlinked(),
+        "The handler being pushed in the wxWindow stack shouldn't be part of "
+        "a wxEvtHandler chain; call Unlink() on it first");
+

     wxEvtHandler *handlerOld = GetEventHandler();
     wxEvtHandler *handlerOld = GetEventHandler();

+    wxCHECK_RET( handlerOld, "an old event handler is NULL?" );

 
 

-    handler->SetNextHandler(handlerOld);
+    // now use wxEvtHandler double-linked list to implement a stack:
+    handlerToPush->SetNextHandler(handlerOld);

 
 

-    if ( handlerOld )
-        GetEventHandler()->SetPreviousHandler(handler);
+    if (handlerOld != this)
+        handlerOld->SetPreviousHandler(handlerToPush);

 
 

-    SetEventHandler(handler);
+    SetEventHandler(handlerToPush);
+
+#if wxDEBUG_LEVEL
+    // final checks of the operations done above:
+    wxASSERT_MSG( handlerToPush->GetPreviousHandler() == NULL,
+        "the first handler of the wxWindow stack should "
+        "have no previous handlers set" );
+    wxASSERT_MSG( handlerToPush->GetNextHandler() != NULL,
+        "the first handler of the wxWindow stack should "
+        "have non-NULL next handler" );
+
+    wxEvtHandler* pLast = handlerToPush;
+    while ( pLast && pLast != this )
+        pLast = pLast->GetNextHandler();
+    wxASSERT_MSG( pLast->GetNextHandler() == NULL,
+        "the last handler of the wxWindow stack should "
+        "have this window as next handler" );
+#endif // wxDEBUG_LEVEL

 }
 
 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
 {
 }
 
 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
 {

-    wxEvtHandler *handlerA = GetEventHandler();
-    if ( handlerA )
-    {
-        wxEvtHandler *handlerB = handlerA->GetNextHandler();
-        handlerA->SetNextHandler(NULL);
+    // we need to pop the wxWindow stack, i.e. we need to remove the first handler

 
 

-        if ( handlerB )
-            handlerB->SetPreviousHandler(NULL);
-        SetEventHandler(handlerB);
+    wxEvtHandler *firstHandler = GetEventHandler();
+    wxCHECK_MSG( firstHandler != NULL, NULL, "wxWindow cannot have a NULL event handler" );
+    wxCHECK_MSG( firstHandler != this, NULL, "cannot pop the wxWindow itself" );
+    wxCHECK_MSG( firstHandler->GetPreviousHandler() == NULL, NULL,
+        "the first handler of the wxWindow stack should have no previous handlers set" );

 
 

-        if ( deleteHandler )
-        {
-            delete handlerA;
-            handlerA = NULL;
-        }
+    wxEvtHandler *secondHandler = firstHandler->GetNextHandler();
+    wxCHECK_MSG( secondHandler != NULL, NULL,
+        "the first handler of the wxWindow stack should have non-NULL next handler" );
+
+    firstHandler->SetNextHandler(NULL);
+    secondHandler->SetPreviousHandler(NULL);
+
+    // now firstHandler is completely unlinked; set secondHandler as the new window event handler
+    SetEventHandler(secondHandler);
+
+    if ( deleteHandler )
+    {
+        wxDELETE(firstHandler);

     }
 
     }
 

-    return handlerA;
+    return firstHandler;

 }
 
 }
 

-bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
+bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handlerToRemove)

 {
 {

-    wxCHECK_MSG( handler, false, _T("RemoveEventHandler(NULL) called") );
+    wxCHECK_MSG( handlerToRemove != NULL, false, "RemoveEventHandler(NULL) called" );
+    wxCHECK_MSG( handlerToRemove != this, false, "Cannot remove the window itself" );
+
+    if (handlerToRemove == GetEventHandler())
+    {
+        // removing the first event handler is equivalent to "popping" the stack
+        PopEventHandler(false);
+        return true;
+    }

 
 

-    wxEvtHandler *handlerPrev = NULL,
-                 *handlerCur = GetEventHandler();
-    while ( handlerCur )
+    // NOTE: the wxWindow event handler list is always terminated with "this" handler
+    wxEvtHandler *handlerCur = GetEventHandler()->GetNextHandler();
+    while ( handlerCur != this && handlerCur )

     {
         wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
 
     {
         wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
 

-        if ( handlerCur == handler )
+        if ( handlerCur == handlerToRemove )

         {
         {

-            if ( handlerPrev )
-            {
-                handlerPrev->SetNextHandler(handlerNext);
-            }
-            else
-            {
-                SetEventHandler(handlerNext);
-            }
-
-            if ( handlerNext )
-            {
-                handlerNext->SetPreviousHandler ( handlerPrev );
-            }
-
-            handler->SetNextHandler(NULL);
-            handler->SetPreviousHandler(NULL);
+            handlerCur->Unlink();

 
 

+            wxASSERT_MSG( handlerCur != GetEventHandler(),
+                        "the case Remove == Pop should was already handled" );

             return true;
         }
 
             return true;
         }
 

-        handlerPrev = handlerCur;

         handlerCur = handlerNext;
     }
 
         handlerCur = handlerNext;
     }
 

-    wxFAIL_MSG( _T("where has the event handler gone?") );
+    wxFAIL_MSG( wxT("where has the event handler gone?") );

 
     return false;
 }
 
 bool wxWindowBase::HandleWindowEvent(wxEvent& event) const
 {
 
     return false;
 }
 
 bool wxWindowBase::HandleWindowEvent(wxEvent& event) const
 {

+    // SafelyProcessEvent() will handle exceptions nicely

     return GetEventHandler()->SafelyProcessEvent(event);
 }
 
     return GetEventHandler()->SafelyProcessEvent(event);
 }
 


@@ -1224,13 +1359,13 @@ wxColour wxWindowBase::GetBackgroundColour() const
 {
     if ( !m_backgroundColour.IsOk() )
     {
 {
     if ( !m_backgroundColour.IsOk() )
     {

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

 
         // get our default background colour
         wxColour colBg = GetDefaultAttributes().colBg;
 
         // we must return some valid colour to avoid redoing this every time
 
         // get our default background colour
         wxColour colBg = GetDefaultAttributes().colBg;
 
         // we must return some valid colour to avoid redoing this every time

-        // and also to avoid surprizing the applications written for older
+        // and also to avoid surprising the applications written for older

         // wxWidgets versions where GetBackgroundColour() always returned
         // something -- so give them something even if it doesn't make sense
         // for this window (e.g. it has a themed background)
         // wxWidgets versions where GetBackgroundColour() always returned
         // something -- so give them something even if it doesn't make sense
         // for this window (e.g. it has a themed background)


@@ -1265,8 +1400,6 @@ bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
         return false;
 
     m_hasBgCol = colour.IsOk();
         return false;
 
     m_hasBgCol = colour.IsOk();

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

 
     m_inheritBgCol = m_hasBgCol;
     m_backgroundColour = colour;
 
     m_inheritBgCol = m_hasBgCol;
     m_backgroundColour = colour;


@@ -1306,7 +1439,7 @@ wxFont wxWindowBase::GetFont() const
     // logic is the same as in GetBackgroundColour()
     if ( !m_font.IsOk() )
     {
     // logic is the same as in GetBackgroundColour()
     if ( !m_font.IsOk() )
     {

-        wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") );
+        wxASSERT_MSG( !m_hasFont, wxT("we have invalid explicit font?") );

 
         wxFont font = GetDefaultAttributes().font;
         if ( !font.IsOk() )
 
         wxFont font = GetDefaultAttributes().font;
         if ( !font.IsOk() )


@@ -1797,6 +1930,11 @@ void wxWindowBase::OnHelp(wxHelpEvent& event)
 
 #if wxUSE_TOOLTIPS
 
 
 #if wxUSE_TOOLTIPS
 

+wxString wxWindowBase::GetToolTipText() const
+{
+    return m_tooltip ? m_tooltip->GetTip() : wxString();
+}
+

 void wxWindowBase::SetToolTip( const wxString &tip )
 {
     // don't create the new tooltip if we already have one
 void wxWindowBase::SetToolTip( const wxString &tip )
 {
     // don't create the new tooltip if we already have one


@@ -1933,8 +2071,7 @@ void wxWindowBase::DeleteRelatedConstraints()
             node = next;
         }
 
             node = next;
         }
 

-        delete m_constraintsInvolvedIn;
-        m_constraintsInvolvedIn = NULL;
+        wxDELETE(m_constraintsInvolvedIn);

     }
 }
 
     }
 }
 


@@ -1976,7 +2113,7 @@ void wxWindowBase::SetContainingSizer(wxSizer* sizer)
     // associated wxSizerItem we're going to dereference a dangling
     // pointer; so try to detect this as early as possible
     wxASSERT_MSG( !sizer || m_containingSizer != sizer,
     // associated wxSizerItem we're going to dereference a dangling
     // pointer; so try to detect this as early as possible
     wxASSERT_MSG( !sizer || m_containingSizer != sizer,

-                  _T("Adding a window to the same sizer twice?") );
+                  wxT("Adding a window to the same sizer twice?") );

 
     m_containingSizer = sizer;
 }
 
     m_containingSizer = sizer;
 }


@@ -2028,6 +2165,14 @@ bool wxWindowBase::Layout()
     return true;
 }
 
     return true;
 }
 

+void wxWindowBase::InternalOnSize(wxSizeEvent& event)
+{
+    if ( GetAutoLayout() )
+        Layout();
+
+    event.Skip();
+}
+

 #if wxUSE_CONSTRAINTS
 
 // first phase of the constraints evaluation: set our own constraints
 #if wxUSE_CONSTRAINTS
 
 // first phase of the constraints evaluation: set our own constraints


@@ -2146,7 +2291,9 @@ void wxWindowBase::SetConstraintSizes(bool recurse)
         if ( (constr->width.GetRelationship() != wxAsIs ) ||
              (constr->height.GetRelationship() != wxAsIs) )
         {
         if ( (constr->width.GetRelationship() != wxAsIs ) ||
              (constr->height.GetRelationship() != wxAsIs) )
         {

-            SetSize(x, y, w, h);
+            // We really shouldn't set negative sizes for the windows so make
+            // them at least of 1*1 size
+            SetSize(x, y, w > 0 ? w : 1, h > 0 ? h : 1);

         }
         else
         {
         }
         else
         {


@@ -2315,28 +2462,57 @@ void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
 // dialog units translations
 // ----------------------------------------------------------------------------
 
 // dialog units translations
 // ----------------------------------------------------------------------------
 

-wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
+// Windows' computes dialog units using average character width over upper-
+// and lower-case ASCII alphabet and not using the average character width
+// metadata stored in the font; see
+// http://support.microsoft.com/default.aspx/kb/145994 for detailed discussion.
+// It's important that we perform the conversion in identical way, because
+// dialog units natively exist only on Windows and Windows HIG is expressed
+// using them.
+wxSize wxWindowBase::GetDlgUnitBase() const
+{
+    const wxWindow *parent = wxGetTopLevelParent((wxWindow*)this);
+
+    if ( !parent->m_font.IsOk() )
+    {
+        // Default GUI font is used. This is the most common case, so
+        // cache the results.
+        static wxSize s_defFontSize;
+        if ( s_defFontSize.x == 0 )
+            s_defFontSize = wxPrivate::GetAverageASCIILetterSize(*parent);
+        return s_defFontSize;
+    }
+    else
+    {
+        // Custom font, we always need to compute the result
+        return wxPrivate::GetAverageASCIILetterSize(*parent);
+    }
+}
+
+wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt) const

 {
 {

-    int charWidth = GetCharWidth();
-    int charHeight = GetCharHeight();
+    const wxSize base = GetDlgUnitBase();
+
+    // NB: wxMulDivInt32() is used, because it correctly rounds the result
+

     wxPoint pt2 = wxDefaultPosition;
     if (pt.x != wxDefaultCoord)
     wxPoint pt2 = wxDefaultPosition;
     if (pt.x != wxDefaultCoord)

-        pt2.x = (int) ((pt.x * 4) / charWidth);
+        pt2.x = wxMulDivInt32(pt.x, 4, base.x);

     if (pt.y != wxDefaultCoord)
     if (pt.y != wxDefaultCoord)

-        pt2.y = (int) ((pt.y * 8) / charHeight);
+        pt2.y = wxMulDivInt32(pt.y, 8, base.y);

 
     return pt2;
 }
 
 
     return pt2;
 }
 

-wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
+wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt) const

 {
 {

-    int charWidth = GetCharWidth();
-    int charHeight = GetCharHeight();
+    const wxSize base = GetDlgUnitBase();
+

     wxPoint pt2 = wxDefaultPosition;
     if (pt.x != wxDefaultCoord)
     wxPoint pt2 = wxDefaultPosition;
     if (pt.x != wxDefaultCoord)

-        pt2.x = (int) ((pt.x * charWidth) / 4);
+        pt2.x = wxMulDivInt32(pt.x, base.x, 4);

     if (pt.y != wxDefaultCoord)
     if (pt.y != wxDefaultCoord)

-        pt2.y = (int) ((pt.y * charHeight) / 8);
+        pt2.y = wxMulDivInt32(pt.y, base.y, 8);

 
     return pt2;
 }
 
     return pt2;
 }


@@ -2346,7 +2522,7 @@ wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
 // ----------------------------------------------------------------------------
 
 // propagate the colour change event to the subwindows
 // ----------------------------------------------------------------------------
 
 // propagate the colour change event to the subwindows

-void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
+void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))

 {
     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
     while ( node )
 {
     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
     while ( node )


@@ -2356,7 +2532,7 @@ void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
         if ( !win->IsTopLevel() )
         {
             wxSysColourChangedEvent event2;
         if ( !win->IsTopLevel() )
         {
             wxSysColourChangedEvent event2;

-            event.SetEventObject(win);
+            event2.SetEventObject(win);

             win->GetEventHandler()->ProcessEvent(event2);
         }
 
             win->GetEventHandler()->ProcessEvent(event2);
         }
 


@@ -2387,6 +2563,9 @@ bool wxWindowBase::PopupMenu(wxMenu *menu, int x, int y)
 {
     wxCHECK_MSG( menu, false, "can't popup NULL menu" );
 
 {
     wxCHECK_MSG( menu, false, "can't popup NULL menu" );
 

+    wxMenuInvokingWindowSetter
+        setInvokingWin(*menu, static_cast<wxWindow *>(this));
+

     wxCurrentPopupMenu = menu;
     const bool rc = DoPopupMenu(menu, x, y);
     wxCurrentPopupMenu = NULL;
     wxCurrentPopupMenu = menu;
     const bool rc = DoPopupMenu(menu, x, y);
     wxCurrentPopupMenu = NULL;


@@ -2450,16 +2629,20 @@ wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y)
 
 #endif // wxUSE_MENUS
 
 
 #endif // wxUSE_MENUS
 

-// methods for drawing the sizers in a visible way
-#ifdef __WXDEBUG__
+// methods for drawing the sizers in a visible way: this is currently only
+// enabled for "full debug" builds with wxDEBUG_LEVEL==2 as it doesn't work
+// that well and also because we don't want to leave it enabled in default
+// builds used for production
+#if wxDEBUG_LEVEL > 1

 
 static void DrawSizers(wxWindowBase *win);
 
 
 static void DrawSizers(wxWindowBase *win);
 

-static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill = false)
+static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill, const wxPen* pen)

 {
     wxClientDC dc((wxWindow *)win);
 {
     wxClientDC dc((wxWindow *)win);

-    dc.SetPen(*wxRED_PEN);
-    dc.SetBrush(fill ? wxBrush(*wxRED, wxBRUSHSTYLE_CROSSDIAG_HATCH) : *wxTRANSPARENT_BRUSH);
+    dc.SetPen(*pen);
+    dc.SetBrush(fill ? wxBrush(pen->GetColour(), wxBRUSHSTYLE_CROSSDIAG_HATCH) :
+                       *wxTRANSPARENT_BRUSH);

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


@@ -2474,26 +2657,29 @@ static void DrawSizer(wxWindowBase *win, wxSizer *sizer)
         wxSizerItem *item = *i;
         if ( item->IsSizer() )
         {
         wxSizerItem *item = *i;
         if ( item->IsSizer() )
         {

-            DrawBorder(win, item->GetRect().Deflate(2));
+            DrawBorder(win, item->GetRect().Deflate(2), false, wxRED_PEN);

             DrawSizer(win, item->GetSizer());
         }
         else if ( item->IsSpacer() )
         {
             DrawSizer(win, item->GetSizer());
         }
         else if ( item->IsSpacer() )
         {

-            DrawBorder(win, item->GetRect().Deflate(2), true);
+            DrawBorder(win, item->GetRect().Deflate(2), true, wxBLUE_PEN);

         }
         else if ( item->IsWindow() )
         {
             DrawSizers(item->GetWindow());
         }
         }
         else if ( item->IsWindow() )
         {
             DrawSizers(item->GetWindow());
         }

+        else
+            wxFAIL_MSG("inconsistent wxSizerItem status!");

     }
 }
 
 static void DrawSizers(wxWindowBase *win)
 {
     }
 }
 
 static void DrawSizers(wxWindowBase *win)
 {

+    DrawBorder(win, win->GetClientSize(), false, wxGREEN_PEN);
+

     wxSizer *sizer = win->GetSizer();
     if ( sizer )
     {
     wxSizer *sizer = win->GetSizer();
     if ( sizer )
     {

-        DrawBorder(win, win->GetClientSize());

         DrawSizer(win, sizer);
     }
     else // no sizer, still recurse into the children
         DrawSizer(win, sizer);
     }
     else // no sizer, still recurse into the children


@@ -2506,25 +2692,48 @@ static void DrawSizers(wxWindowBase *win)
         {
             DrawSizers(*i);
         }
         {
             DrawSizers(*i);
         }

+
+        // show all kind of sizes of this window; see the "window sizing" topic
+        // overview for more info about the various differences:
+        wxSize fullSz = win->GetSize();
+        wxSize clientSz = win->GetClientSize();
+        wxSize bestSz = win->GetBestSize();
+        wxSize minSz = win->GetMinSize();
+        wxSize maxSz = win->GetMaxSize();
+        wxSize virtualSz = win->GetVirtualSize();
+
+        wxMessageOutputDebug dbgout;
+        dbgout.Printf(
+            "%-10s => fullsz=%4d;%-4d  clientsz=%4d;%-4d  bestsz=%4d;%-4d  minsz=%4d;%-4d  maxsz=%4d;%-4d virtualsz=%4d;%-4d\n",
+            win->GetName(),
+            fullSz.x, fullSz.y,
+            clientSz.x, clientSz.y,
+            bestSz.x, bestSz.y,
+            minSz.x, minSz.y,
+            maxSz.x, maxSz.y,
+            virtualSz.x, virtualSz.y);

     }
 }
 
     }
 }
 

-#endif // __WXDEBUG__
+#endif // wxDEBUG_LEVEL

 
 // process special middle clicks
 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
 {
     if ( event.ControlDown() && event.AltDown() )
     {
 
 // process special middle clicks
 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
 {
     if ( event.ControlDown() && event.AltDown() )
     {

-#ifdef __WXDEBUG__
+#if wxDEBUG_LEVEL > 1

         // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
         if ( event.ShiftDown() )
         {
             DrawSizers(this);
         // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
         if ( event.ShiftDown() )
         {
             DrawSizers(this);

-            return;

         }
         }

+        else

 #endif // __WXDEBUG__
 #endif // __WXDEBUG__

-        ::wxInfoMessageBox((wxWindow*)this);
+        {
+            // just Ctrl-Alt-middle click shows information about wx version
+            ::wxInfoMessageBox((wxWindow*)this);
+        }

     }
     else
     {
     }
     else
     {


@@ -2638,9 +2847,9 @@ bool wxWindowBase::ms_winCaptureChanging = false;
 
 void wxWindowBase::CaptureMouse()
 {
 
 void wxWindowBase::CaptureMouse()
 {

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

 
 

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

 
     ms_winCaptureChanging = true;
 
 
     ms_winCaptureChanging = true;
 


@@ -2665,9 +2874,9 @@ void wxWindowBase::CaptureMouse()
 
 void wxWindowBase::ReleaseMouse()
 {
 
 void wxWindowBase::ReleaseMouse()
 {

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

 
 

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

 
     wxASSERT_MSG( GetCapture() == this,
                   "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" );


@@ -2692,8 +2901,8 @@ void wxWindowBase::ReleaseMouse()
 
     ms_winCaptureChanging = false;
 
 
     ms_winCaptureChanging = false;
 

-    wxLogTrace(_T("mousecapture"),
-        (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"),
+    wxLogTrace(wxT("mousecapture"),
+        (const wxChar *) wxT("After ReleaseMouse() mouse is captured by %p"),

         static_cast<void*>(GetCapture()));
 }
 
         static_cast<void*>(GetCapture()));
 }
 


@@ -2707,7 +2916,7 @@ static void DoNotifyWindowAboutCaptureLost(wxWindow *win)
         // 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
         // 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( wxT("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );

     }
 }
 
     }
 }
 


@@ -2762,7 +2971,7 @@ bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId))
 // event processing
 // ----------------------------------------------------------------------------
 
 // event processing
 // ----------------------------------------------------------------------------
 

-bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event))
+bool wxWindowBase::TryBefore(wxEvent& event)

 {
 #if wxUSE_VALIDATORS
     // Can only use the validator of the window which
 {
 #if wxUSE_VALIDATORS
     // Can only use the validator of the window which


@@ -2770,17 +2979,17 @@ bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event))
     if ( event.GetEventObject() == this )
     {
         wxValidator * const validator = GetValidator();
     if ( event.GetEventObject() == this )
     {
         wxValidator * const validator = GetValidator();

-        if ( validator && validator->ProcessEventHere(event) )
+        if ( validator && validator->ProcessEventLocally(event) )

         {
             return true;
         }
     }
 #endif // wxUSE_VALIDATORS
 
         {
             return true;
         }
     }
 #endif // wxUSE_VALIDATORS
 

-    return false;
+    return wxEvtHandler::TryBefore(event);

 }
 
 }
 

-bool wxWindowBase::TryParent(wxEvent& event)
+bool wxWindowBase::TryAfter(wxEvent& event)

 {
     // carry on up the parent-child hierarchy if the propagation count hasn't
     // reached zero yet
 {
     // carry on up the parent-child hierarchy if the propagation count hasn't
     // reached zero yet


@@ -2802,7 +3011,7 @@ bool wxWindowBase::TryParent(wxEvent& event)
         }
     }
 
         }
     }
 

-    return wxEvtHandler::TryParent(event);
+    return wxEvtHandler::TryAfter(event);

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


@@ -2812,11 +3021,11 @@ bool wxWindowBase::TryParent(wxEvent& event)
 wxWindow *wxWindowBase::DoGetSibling(WindowOrder order) const
 {
     wxCHECK_MSG( GetParent(), NULL,
 wxWindow *wxWindowBase::DoGetSibling(WindowOrder order) const
 {
     wxCHECK_MSG( GetParent(), NULL,

-                    _T("GetPrev/NextSibling() don't work for TLWs!") );
+                    wxT("GetPrev/NextSibling() don't work for TLWs!") );

 
     wxWindowList& siblings = GetParent()->GetChildren();
     wxWindowList::compatibility_iterator i = siblings.Find((wxWindow *)this);
 
     wxWindowList& siblings = GetParent()->GetChildren();
     wxWindowList::compatibility_iterator i = siblings.Find((wxWindow *)this);

-    wxCHECK_MSG( i, NULL, _T("window not a child of its parent?") );
+    wxCHECK_MSG( i, NULL, wxT("window not a child of its parent?") );

 
     if ( order == OrderBefore )
         i = i->GetPrevious();
 
     if ( order == OrderBefore )
         i = i->GetPrevious();


@@ -2870,7 +3079,7 @@ 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(),

-                    _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
+                    wxT("MoveBefore/AfterInTabOrder() don't work for TLWs!") );

 
     // detect the special case when we have nothing to do anyhow and when the
     // code below wouldn't work
 
     // detect the special case when we have nothing to do anyhow and when the
     // code below wouldn't work


@@ -2880,7 +3089,7 @@ void wxWindowBase::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
     // find the target window in the siblings list
     wxWindowList& siblings = GetParent()->GetChildren();
     wxWindowList::compatibility_iterator i = siblings.Find(win);
     // find the target window in the siblings list
     wxWindowList& siblings = GetParent()->GetChildren();
     wxWindowList::compatibility_iterator i = siblings.Find(win);

-    wxCHECK_RET( i, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
+    wxCHECK_RET( i, wxT("MoveBefore/AfterInTabOrder(): win is not a sibling") );

 
     // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
     // can't just move the node around
 
     // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
     // can't just move the node around


@@ -2948,7 +3157,7 @@ public:
 private:
     wxWindowBase * const m_win;
 
 private:
     wxWindowBase * const m_win;
 

-    DECLARE_NO_COPY_CLASS(DragAcceptFilesTarget)
+    wxDECLARE_NO_COPY_CLASS(DragAcceptFilesTarget);

 };
 
 
 };