don't crash when trying to dump struct members which are NULL pointers

[wxWidgets.git] / src / msw / window.cpp

diff --git a/src/msw/window.cpp b/src/msw/window.cpp
index d20cd3d9e6a3ec9245b9f323ed72fd48e70dba48..a17b0401d29e15b79db3bf669dff18bf5d3f0346 100644 (file)
--- a/src/msw/window.cpp
+++ b/src/msw/window.cpp
@@ -53,6 +53,9 @@
     #include "wx/ownerdrw.h"
 #endif
 
     #include "wx/ownerdrw.h"
 #endif
 

+#include "wx/module.h"
+#include "wx/sysopt.h"
+

 #if wxUSE_DRAG_AND_DROP
     #include "wx/dnd.h"
 #endif
 #if wxUSE_DRAG_AND_DROP
     #include "wx/dnd.h"
 #endif


@@ -95,7 +98,7 @@
 
 #include <string.h>
 
 
 #include <string.h>
 

-#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
+#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)

     #include <shellapi.h>
     #include <mmsystem.h>
 #endif
     #include <shellapi.h>
     #include <mmsystem.h>
 #endif


@@ -104,7 +107,7 @@
     #include <windowsx.h>
 #endif
 
     #include <windowsx.h>
 #endif
 

-#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
+#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)

     #ifdef __WIN95__
         #include <commctrl.h>
     #endif
     #ifdef __WIN95__
         #include <commctrl.h>
     #endif


@@ -112,51 +115,15 @@
     #include "wx/msw/gnuwin32/extra.h"
 #endif
 
     #include "wx/msw/gnuwin32/extra.h"
 #endif
 

-#if defined(__GNUG__)

 #include "wx/msw/missing.h"
 #include "wx/msw/missing.h"

-#endif

 
 #if defined(__WXWINCE__)
 
 #if defined(__WXWINCE__)

-#include "wx/msw/wince/missing.h"
+    #include "wx/msw/wince/missing.h"

 #endif
 
 #endif
 

-// ----------------------------------------------------------------------------
-// standard constants not available with all compilers/headers
-// ----------------------------------------------------------------------------
-
-// This didn't appear in mingw until 2.95.2
-#ifndef SIF_TRACKPOS
-#define SIF_TRACKPOS 16
-#endif
-
-#if wxUSE_MOUSEWHEEL
-    #ifndef WM_MOUSEWHEEL
-        #define WM_MOUSEWHEEL           0x020A
-    #endif
-    #ifndef WHEEL_DELTA
-        #define WHEEL_DELTA             120
-    #endif
-    #ifndef SPI_GETWHEELSCROLLLINES
-        #define SPI_GETWHEELSCROLLLINES 104
-    #endif
-#endif // wxUSE_MOUSEWHEEL
-
-#ifndef VK_OEM_1
-    #define VK_OEM_1        0xBA
-    #define VK_OEM_2        0xBF
-    #define VK_OEM_3        0xC0
-    #define VK_OEM_4        0xDB
-    #define VK_OEM_5        0xDC
-    #define VK_OEM_6        0xDD
-    #define VK_OEM_7        0xDE
-#endif
-
-#ifndef VK_OEM_COMMA
-    #define VK_OEM_PLUS     0xBB
-    #define VK_OEM_COMMA    0xBC
-    #define VK_OEM_MINUS    0xBD
-    #define VK_OEM_PERIOD   0xBE
-#endif
+#if defined(TME_LEAVE) && defined(WM_MOUSELEAVE)
+    #define HAVE_TRACKMOUSEEVENT
+#endif // everything needed for TrackMouseEvent()

 
 // ---------------------------------------------------------------------------
 // global variables
 
 // ---------------------------------------------------------------------------
 // global variables


@@ -166,11 +133,15 @@
 wxMenu *wxCurrentPopupMenu = NULL;
 #endif // wxUSE_MENUS_NATIVE
 
 wxMenu *wxCurrentPopupMenu = NULL;
 #endif // wxUSE_MENUS_NATIVE
 

+#ifdef __WXWINCE__
+extern       wxChar *wxCanvasClassName;
+#else

 extern const wxChar *wxCanvasClassName;
 extern const wxChar *wxCanvasClassName;

+#endif

 
 // true if we had already created the std colour map, used by
 // wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)
 
 // true if we had already created the std colour map, used by
 // wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)

-static bool gs_hasStdCmap = FALSE;
+static bool gs_hasStdCmap = false;

 
 // ---------------------------------------------------------------------------
 // private functions
 
 // ---------------------------------------------------------------------------
 // private functions


@@ -189,11 +160,6 @@ void wxRemoveHandleAssociation(wxWindowMSW *win);
 extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
 
 extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
 

-// this magical function is used to translate VK_APPS key presses to right
-// mouse clicks
-static void TranslateKbdEventToMouse(wxWindowMSW *win,
-                                     int *x, int *y, WPARAM *flags);
-

 // get the text metrics for the current font
 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
 
 // get the text metrics for the current font
 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
 


@@ -218,6 +184,8 @@ static inline void wxBringWindowToTop(HWND hwnd)
     }
 }
 
     }
 }
 

+#ifndef __WXWINCE__
+

 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
 static void EnsureParentHasControlParentStyle(wxWindow *parent)
 {
 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
 static void EnsureParentHasControlParentStyle(wxWindow *parent)
 {


@@ -234,7 +202,6 @@ static void EnsureParentHasControlParentStyle(wxWindow *parent)
        but if the parent doesn't have it, it wouldn't recurse inside it later
        on and so wouldn't have a chance of getting back to this window neither.
      */
        but if the parent doesn't have it, it wouldn't recurse inside it later
        on and so wouldn't have a chance of getting back to this window neither.
      */

-#ifndef __WXWINCE__

     while ( parent && !parent->IsTopLevel() )
     {
         LONG exStyle = ::GetWindowLong(GetHwndOf(parent), GWL_EXSTYLE);
     while ( parent && !parent->IsTopLevel() )
     {
         LONG exStyle = ::GetWindowLong(GetHwndOf(parent), GWL_EXSTYLE);


@@ -247,9 +214,10 @@ static void EnsureParentHasControlParentStyle(wxWindow *parent)
 
         parent = parent->GetParent();
     }
 
         parent = parent->GetParent();
     }

-#endif // !__WXWINCE__

 }
 
 }
 

+#endif // !__WXWINCE__
+

 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------


@@ -296,21 +264,21 @@ wxBEGIN_FLAGS( wxWindowStyle )
     wxFLAGS_MEMBER(wxBORDER_RAISED)
     wxFLAGS_MEMBER(wxBORDER_STATIC)
     wxFLAGS_MEMBER(wxBORDER_NONE)
     wxFLAGS_MEMBER(wxBORDER_RAISED)
     wxFLAGS_MEMBER(wxBORDER_STATIC)
     wxFLAGS_MEMBER(wxBORDER_NONE)

-    
+

     // old style border flags
     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
     wxFLAGS_MEMBER(wxRAISED_BORDER)
     wxFLAGS_MEMBER(wxSTATIC_BORDER)
     // old style border flags
     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
     wxFLAGS_MEMBER(wxRAISED_BORDER)
     wxFLAGS_MEMBER(wxSTATIC_BORDER)

-    wxFLAGS_MEMBER(wxNO_BORDER)
+    wxFLAGS_MEMBER(wxBORDER)

 
     // standard window styles
     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
     wxFLAGS_MEMBER(wxWANTS_CHARS)
 
     // standard window styles
     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
     wxFLAGS_MEMBER(wxWANTS_CHARS)

-    wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE)
+    wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)

     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
     wxFLAGS_MEMBER(wxVSCROLL)
     wxFLAGS_MEMBER(wxHSCROLL)
     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
     wxFLAGS_MEMBER(wxVSCROLL)
     wxFLAGS_MEMBER(wxHSCROLL)


@@ -318,16 +286,16 @@ wxBEGIN_FLAGS( wxWindowStyle )
 wxEND_FLAGS( wxWindowStyle )
 
 wxBEGIN_PROPERTIES_TABLE(wxWindow)
 wxEND_FLAGS( wxWindowStyle )
 
 wxBEGIN_PROPERTIES_TABLE(wxWindow)

-       wxEVENT_PROPERTY( Close , wxEVT_CLOSE_WINDOW , wxCloseEvent)
-       wxEVENT_PROPERTY( Create , wxEVT_CREATE , wxWindowCreateEvent )
-       wxEVENT_PROPERTY( Destroy , wxEVT_DESTROY , wxWindowDestroyEvent )
+    wxEVENT_PROPERTY( Close , wxEVT_CLOSE_WINDOW , wxCloseEvent)
+    wxEVENT_PROPERTY( Create , wxEVT_CREATE , wxWindowCreateEvent )
+    wxEVENT_PROPERTY( Destroy , wxEVT_DESTROY , wxWindowDestroyEvent )

     // Always constructor Properties first
 
     // Always constructor Properties first
 

-    wxREADONLY_PROPERTY( Parent,wxWindow*, GetParent,  , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
-       wxPROPERTY( Id,wxWindowID, SetId, GetId, -1, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
-       wxPROPERTY( Position,wxPoint, SetPosition , GetPosition, wxPoint(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
-       wxPROPERTY( Size,wxSize, SetSize, GetSize, wxSize(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
-    wxPROPERTY( WindowStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
+    wxREADONLY_PROPERTY( Parent,wxWindow*, GetParent, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY( Id,wxWindowID, SetId, GetId, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
+    wxPROPERTY( Position,wxPoint, SetPosition , GetPosition, wxDefaultPosition , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
+    wxPROPERTY( Size,wxSize, SetSize, GetSize, wxDefaultSize , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
+    wxPROPERTY( WindowStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style

 
     // Then all relations of the object graph
 
 
     // Then all relations of the object graph
 


@@ -335,23 +303,23 @@ wxBEGIN_PROPERTIES_TABLE(wxWindow)
 
    // and finally all other properties
 
 
    // and finally all other properties
 

-       wxPROPERTY( ExtraStyle , long , SetExtraStyle , GetExtraStyle , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
-       wxPROPERTY( BackgroundColour , wxColour , SetBackgroundColour , GetBackgroundColour , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
-       wxPROPERTY( ForegroundColour , wxColour , SetForegroundColour , GetForegroundColour , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
-       wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
-       wxPROPERTY( Shown , bool , Show , IsShown , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY( ExtraStyle , long , SetExtraStyle , GetExtraStyle , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
+    wxPROPERTY( BackgroundColour , wxColour , SetBackgroundColour , GetBackgroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
+    wxPROPERTY( ForegroundColour , wxColour , SetForegroundColour , GetForegroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
+    wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY( Shown , bool , Show , IsShown , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))

 #if 0
     // possible property candidates (not in xrc) or not valid in all subclasses
 #if 0
     // possible property candidates (not in xrc) or not valid in all subclasses

-       wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxT("") )
-       wxPROPERTY( Font , wxFont , SetFont , GetWindowFont  , )
-       wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxT("") )
-       // MaxHeight, Width , MinHeight , Width
-       // TODO switch label to control and title to toplevels
+    wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxEmptyString )
+    wxPROPERTY( Font , wxFont , SetFont , GetWindowFont  , )
+    wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxEmptyString )
+    // MaxHeight, Width , MinHeight , Width
+    // TODO switch label to control and title to toplevels

 
 

-       wxPROPERTY( ThemeEnabled , bool , SetThemeEnabled , GetThemeEnabled , )
-       //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
-       // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
-       wxPROPERTY( AutoLayout , bool , SetAutoLayout , GetAutoLayout , )
+    wxPROPERTY( ThemeEnabled , bool , SetThemeEnabled , GetThemeEnabled , )
+    //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
+    // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
+    wxPROPERTY( AutoLayout , bool , SetAutoLayout , GetAutoLayout , )

 
 
 
 
 
 


@@ -369,9 +337,11 @@ wxCONSTRUCTOR_DUMMY(wxWindow)
 #endif // __WXUNIVERSAL__/__WXMSW__
 
 BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
 #endif // __WXUNIVERSAL__/__WXMSW__
 
 BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)

-    EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)

     EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
     EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)

+    EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
+#ifdef __WXWINCE__

     EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
     EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)

+#endif

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


@@ -453,7 +423,7 @@ wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
 // Default command handler
 bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 {
 // Default command handler
 bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 {

-    return FALSE;
+    return false;

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


@@ -462,28 +432,21 @@ bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 
 void wxWindowMSW::Init()
 {
 
 void wxWindowMSW::Init()
 {

-    // generic
-    InitBase();
-

     // MSW specific
     // MSW specific

-    m_isBeingDeleted = FALSE;
+    m_isBeingDeleted = false;

     m_oldWndProc = NULL;
     m_oldWndProc = NULL;

-    m_mouseInWindow = FALSE;
-    m_lastKeydownProcessed = FALSE;
+    m_mouseInWindow = false;
+    m_lastKeydownProcessed = false;

 
     m_childrenDisabled = NULL;
 
     m_childrenDisabled = NULL;

-
-    // wxWnd
-    m_hMenu = 0;
+    m_frozenness = 0;

 
     m_hWnd = 0;
 
     m_hWnd = 0;

+    m_hDWP = 0;

 
     m_xThumbSize = 0;
     m_yThumbSize = 0;
 
 
     m_xThumbSize = 0;
     m_yThumbSize = 0;
 

-    // as all windows are created with WS_VISIBLE style...
-    m_isShown = TRUE;
-

 #if wxUSE_MOUSEEVENT_HACK
     m_lastMouseX =
     m_lastMouseY = -1;
 #if wxUSE_MOUSEEVENT_HACK
     m_lastMouseX =
     m_lastMouseY = -1;


@@ -494,7 +457,7 @@ void wxWindowMSW::Init()
 // Destructor
 wxWindowMSW::~wxWindowMSW()
 {
 // Destructor
 wxWindowMSW::~wxWindowMSW()
 {

-    m_isBeingDeleted = TRUE;
+    m_isBeingDeleted = true;

 
 #ifndef __WXUNIVERSAL__
     // VS: make sure there's no wxFrame with last focus set to us:
 
 #ifndef __WXUNIVERSAL__
     // VS: make sure there's no wxFrame with last focus set to us:


@@ -541,10 +504,10 @@ bool wxWindowMSW::Create(wxWindow *parent,
                          long style,
                          const wxString& name)
 {
                          long style,
                          const wxString& name)
 {

-    wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
+    wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );

 
     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 
     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )

-        return FALSE;
+        return false;

 
     parent->AddChild(this);
 
 
     parent->AddChild(this);
 


@@ -560,19 +523,17 @@ bool wxWindowMSW::Create(wxWindow *parent,
     msflags &= ~WS_BORDER;
 #endif // wxUniversal
 
     msflags &= ~WS_BORDER;
 #endif // wxUniversal
 

-    // all windows are created visible by default except popup ones (which are
-    // like the wxTopLevelWindows in this aspect)
-    if ( style & wxPOPUP_WINDOW )
-    {
-        msflags &= ~WS_VISIBLE;
-        m_isShown = FALSE;
-    }
-    else
+    if ( IsShown() )

     {
         msflags |= WS_VISIBLE;
     }
 
     {
         msflags |= WS_VISIBLE;
     }
 

-    return MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exstyle);
+    if ( !MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exstyle) )
+        return false;
+
+    InheritAttributes();
+
+    return true;

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


@@ -623,7 +584,7 @@ void wxWindowMSW::SetFocusFromKbd()
 }
 
 // Get the window with the focus
 }
 
 // Get the window with the focus

-wxWindow *wxWindowBase::FindFocus()
+wxWindow *wxWindowBase::DoFindFocus()

 {
     HWND hWnd = ::GetFocus();
     if ( hWnd )
 {
     HWND hWnd = ::GetFocus();
     if ( hWnd )


@@ -637,7 +598,7 @@ wxWindow *wxWindowBase::FindFocus()
 bool wxWindowMSW::Enable(bool enable)
 {
     if ( !wxWindowBase::Enable(enable) )
 bool wxWindowMSW::Enable(bool enable)
 {
     if ( !wxWindowBase::Enable(enable) )

-        return FALSE;
+        return false;

 
     HWND hWnd = GetHwnd();
     if ( hWnd )
 
     HWND hWnd = GetHwnd();
     if ( hWnd )


@@ -647,7 +608,7 @@ bool wxWindowMSW::Enable(bool enable)
     // showing a modal dialog would result in total greying out (and ungreying
     // out later) of everything which would be really ugly
     if ( IsTopLevel() )
     // showing a modal dialog would result in total greying out (and ungreying
     // out later) of everything which would be really ugly
     if ( IsTopLevel() )

-        return TRUE;
+        return true;

 
     // when the parent is disabled, all of its children should be disabled as
     // well but when it is enabled back, only those of the children which
 
     // when the parent is disabled, all of its children should be disabled as
     // well but when it is enabled back, only those of the children which


@@ -696,13 +657,13 @@ bool wxWindowMSW::Enable(bool enable)
         m_childrenDisabled = NULL;
     }
 
         m_childrenDisabled = NULL;
     }
 

-    return TRUE;
+    return true;

 }
 
 bool wxWindowMSW::Show(bool show)
 {
     if ( !wxWindowBase::Show(show) )
 }
 
 bool wxWindowMSW::Show(bool show)
 {
     if ( !wxWindowBase::Show(show) )

-        return FALSE;
+        return false;

 
     HWND hWnd = GetHwnd();
     int cshow = show ? SW_SHOW : SW_HIDE;
 
     HWND hWnd = GetHwnd();
     int cshow = show ? SW_SHOW : SW_HIDE;


@@ -713,7 +674,7 @@ bool wxWindowMSW::Show(bool show)
         wxBringWindowToTop(hWnd);
     }
 
         wxBringWindowToTop(hWnd);
     }
 

-    return TRUE;
+    return true;

 }
 
 // Raise the window to the top of the Z order
 }
 
 // Raise the window to the top of the Z order


@@ -767,7 +728,7 @@ bool wxWindowMSW::SetFont(const wxFont& font)
     if ( !wxWindowBase::SetFont(font) )
     {
         // nothing to do
     if ( !wxWindowBase::SetFont(font) )
     {
         // nothing to do

-        return FALSE;
+        return false;

     }
 
     HWND hWnd = GetHwnd();
     }
 
     HWND hWnd = GetHwnd();


@@ -780,14 +741,14 @@ bool wxWindowMSW::SetFont(const wxFont& font)
         ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     }
 
         ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
     }
 

-    return TRUE;
+    return true;

 }
 bool wxWindowMSW::SetCursor(const wxCursor& cursor)
 {
     if ( !wxWindowBase::SetCursor(cursor) )
     {
         // no change
 }
 bool wxWindowMSW::SetCursor(const wxCursor& cursor)
 {
     if ( !wxWindowBase::SetCursor(cursor) )
     {
         // no change

-        return FALSE;
+        return false;

     }
 
     if ( m_cursor.Ok() )
     }
 
     if ( m_cursor.Ok() )


@@ -804,7 +765,7 @@ bool wxWindowMSW::SetCursor(const wxCursor& cursor)
             ::SetCursor(GetHcursorOf(m_cursor));
     }
 
             ::SetCursor(GetHcursorOf(m_cursor));
     }
 

-    return TRUE;
+    return true;

 }
 
 void wxWindowMSW::WarpPointer (int x, int y)
 }
 
 void wxWindowMSW::WarpPointer (int x, int y)


@@ -821,12 +782,6 @@ void wxWindowMSW::WarpPointer (int x, int y)
 // scrolling stuff
 // ---------------------------------------------------------------------------
 
 // scrolling stuff
 // ---------------------------------------------------------------------------
 

-// convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
-static inline int wxDirToWinStyle(int orient)
-{
-    return orient == wxHORIZONTAL ? SB_HORZ : SB_VERT;
-}
-

 inline int GetScrollPosition(HWND hWnd, int wOrient)
 {
 #ifdef __WXMICROWIN__
 inline int GetScrollPosition(HWND hWnd, int wOrient)
 {
 #ifdef __WXMICROWIN__


@@ -952,11 +907,12 @@ void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
     else
     {
         pr = NULL;
     else
     {
         pr = NULL;

+

     }
 
 #ifdef __WXWINCE__
     // FIXME: is this the exact equivalent of the line below?
     }
 
 #ifdef __WXWINCE__
     // FIXME: is this the exact equivalent of the line below?

-    ::ScrollWindowEx(GetHwnd(), dx, dy, pr, pr, 0, 0, SW_ERASE|SW_INVALIDATE);
+    ::ScrollWindowEx(GetHwnd(), dx, dy, pr, pr, 0, 0, SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);

 #else
     ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
 #endif
 #else
     ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
 #endif


@@ -1015,19 +971,19 @@ void wxWindowMSW::SubclassWin(WXHWND hWnd)
 
     wxAssociateWinWithHandle(hwnd, this);
 
 
     wxAssociateWinWithHandle(hwnd, this);
 

-    m_oldWndProc = (WXFARPROC)::GetWindowLong((HWND)hWnd, GWL_WNDPROC);
+    m_oldWndProc = (WXFARPROC)wxGetWindowProc((HWND)hWnd);

 
     // we don't need to subclass the window of our own class (in the Windows
     // sense of the word)
 
     // we don't need to subclass the window of our own class (in the Windows
     // sense of the word)

-       if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )
+    if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )

     {
     {

-        ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
+        wxSetWindowProc(hwnd, wxWndProc);

     }
     else
     {
         // don't bother restoring it neither: this also makes it easy to
     }
     else
     {
         // don't bother restoring it neither: this also makes it easy to

-        // implement IsOfStandardClass() method which returns TRUE for the
-        // standard controls and FALSE for the wxWindows own windows as it can
+        // implement IsOfStandardClass() method which returns true for the
+        // standard controls and false for the wxWidgets own windows as it can

         // simply check m_oldWndProc
         m_oldWndProc = NULL;
     }
         // simply check m_oldWndProc
         m_oldWndProc = NULL;
     }


@@ -1041,7 +997,7 @@ void wxWindowMSW::UnsubclassWin()
     HWND hwnd = GetHwnd();
     if ( hwnd )
     {
     HWND hwnd = GetHwnd();
     if ( hwnd )
     {

-        m_hWnd = 0;
+        SetHWND(0);

 
         wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
 
 
         wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
 


@@ -1049,7 +1005,7 @@ void wxWindowMSW::UnsubclassWin()
         {
             if ( !wxCheckWindowWndProc((WXHWND)hwnd, m_oldWndProc) )
             {
         {
             if ( !wxCheckWindowWndProc((WXHWND)hwnd, m_oldWndProc) )
             {

-                ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) m_oldWndProc);
+                wxSetWindowProc(hwnd, (WNDPROC)m_oldWndProc);

             }
 
             m_oldWndProc = NULL;
             }
 
             m_oldWndProc = NULL;


@@ -1057,6 +1013,27 @@ void wxWindowMSW::UnsubclassWin()
     }
 }
 
     }
 }
 

+void wxWindowMSW::AssociateHandle(WXWidget handle)
+{
+    if ( m_hWnd )
+    {
+      if ( !::DestroyWindow(GetHwnd()) )
+        wxLogLastError(wxT("DestroyWindow"));
+    }
+
+    WXHWND wxhwnd = (WXHWND)handle;
+
+    SetHWND(wxhwnd);
+    SubclassWin(wxhwnd);
+}
+
+void wxWindowMSW::DissociateHandle()
+{
+    // this also calls SetHWND(0) for us
+    UnsubclassWin();
+}
+
+

 bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
 {
     // Unicows note: the code below works, but only because WNDCLASS contains
 bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
 {
     // Unicows note: the code below works, but only because WNDCLASS contains


@@ -1066,33 +1043,35 @@ bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
     // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
     // versions that keep track of fake<->real wnd proc mapping.
 
     // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
     // versions that keep track of fake<->real wnd proc mapping.
 

-       // On WinCE (at least), the wndproc comparison doesn't work,
-       // so have to use something like this.
+    // On WinCE (at least), the wndproc comparison doesn't work,
+    // so have to use something like this.

 #ifdef __WXWINCE__
 #ifdef __WXWINCE__

-       extern const wxChar *wxCanvasClassName;
-       extern const wxChar *wxCanvasClassNameNR;
-       extern const wxChar *wxMDIFrameClassName;
-       extern const wxChar *wxMDIFrameClassNameNoRedraw;
-       extern const wxChar *wxMDIChildFrameClassName;
-       extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
-       wxString str(wxGetWindowClass(hWnd));
-       if (str == wxCanvasClassName ||
-               str == wxCanvasClassNameNR ||
-               str == wxMDIFrameClassName ||
-               str == wxMDIFrameClassNameNoRedraw ||
-               str == wxMDIChildFrameClassName ||
-               str == wxMDIChildFrameClassNameNoRedraw ||
-               str == _T("wxTLWHiddenParent"))
-               return TRUE; // Effectively means don't subclass
-       else
-               return FALSE;
+    wxUnusedVar(wndProc);
+
+    extern       wxChar *wxCanvasClassName;
+    extern       wxChar *wxCanvasClassNameNR;
+    extern const wxChar *wxMDIFrameClassName;
+    extern const wxChar *wxMDIFrameClassNameNoRedraw;
+    extern const wxChar *wxMDIChildFrameClassName;
+    extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
+    wxString str(wxGetWindowClass(hWnd));
+    if (str == wxCanvasClassName ||
+        str == wxCanvasClassNameNR ||
+        str == wxMDIFrameClassName ||
+        str == wxMDIFrameClassNameNoRedraw ||
+        str == wxMDIChildFrameClassName ||
+        str == wxMDIChildFrameClassNameNoRedraw ||
+        str == _T("wxTLWHiddenParent"))
+        return true; // Effectively means don't subclass
+    else
+        return false;

 #else
     WNDCLASS cls;
     if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd), &cls) )
     {
         wxLogLastError(_T("GetClassInfo"));
 
 #else
     WNDCLASS cls;
     if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd), &cls) )
     {
         wxLogLastError(_T("GetClassInfo"));
 

-        return FALSE;
+        return false;

     }
 
     return wndProc == (WXFARPROC)cls.lpfnWndProc;
     }
 
     return wndProc == (WXFARPROC)cls.lpfnWndProc;


@@ -1143,7 +1122,7 @@ void wxWindowMSW::SetWindowStyleFlag(long flags)
 
         ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyleReal);
 
 
         ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyleReal);
 

-        // we must call SetWindowPos() to flash the cached extended style and
+        // we must call SetWindowPos() to flush the cached extended style and

         // also to make the change to wxSTAY_ON_TOP style take effect: just
         // setting the style simply doesn't work
         if ( !::SetWindowPos(GetHwnd(),
         // also to make the change to wxSTAY_ON_TOP style take effect: just
         // setting the style simply doesn't work
         if ( !::SetWindowPos(GetHwnd(),


@@ -1159,14 +1138,26 @@ void wxWindowMSW::SetWindowStyleFlag(long flags)
 
 WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
 {
 
 WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
 {

-    // translate the style
-    WXDWORD style = WS_CHILD | WS_VISIBLE;
+    // translate common wxWidgets styles to Windows ones
+
+    // most of windows are child ones, those which are not (such as
+    // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
+    WXDWORD style = WS_CHILD;

 
 

-    if ( flags & wxCLIP_CHILDREN )
+    // using this flag results in very significant reduction in flicker,
+    // especially with controls inside the static boxes (as the interior of the
+    // box is not redrawn twice).but sometimes results in redraw problems, so
+    // optionally allow the old code to continue to use it provided a special
+    // system option is turned on
+    if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
+            || (flags & wxCLIP_CHILDREN) )

         style |= WS_CLIPCHILDREN;
 
         style |= WS_CLIPCHILDREN;
 

-    if ( flags & wxCLIP_SIBLINGS )
-        style |= WS_CLIPSIBLINGS;
+    // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
+    // don't support overlapping windows and it only makes sense for them and,
+    // presumably, gives the system some extra work (to manage more clipping
+    // regions), so avoid it alltogether
+

 
     if ( flags & wxVSCROLL )
         style |= WS_VSCROLL;
 
     if ( flags & wxVSCROLL )
         style |= WS_VSCROLL;


@@ -1257,6 +1248,7 @@ bool wxWindowMSW::IsMouseInWindow() const
 
 void wxWindowMSW::OnInternalIdle()
 {
 
 void wxWindowMSW::OnInternalIdle()
 {

+#ifndef HAVE_TRACKMOUSEEVENT

     // Check if we need to send a LEAVE event
     if ( m_mouseInWindow )
     {
     // Check if we need to send a LEAVE event
     if ( m_mouseInWindow )
     {


@@ -1264,42 +1256,10 @@ void wxWindowMSW::OnInternalIdle()
         // or doesn't have mouse capture
         if ( !IsMouseInWindow() )
         {
         // or doesn't have mouse capture
         if ( !IsMouseInWindow() )
         {

-            // Generate a LEAVE event
-            m_mouseInWindow = FALSE;
-
-            // Unfortunately the mouse button and keyboard state may have
-            // changed by the time the OnInternalIdle function is called, so 'state'
-            // may be meaningless.
-            int state = 0;
-            if ( wxIsShiftDown() )
-                state |= MK_SHIFT;
-            if ( wxIsCtrlDown() )
-                state |= MK_CONTROL;
-            if ( GetKeyState( VK_LBUTTON ) )
-                state |= MK_LBUTTON;
-            if ( GetKeyState( VK_MBUTTON ) )
-                state |= MK_MBUTTON;
-            if ( GetKeyState( VK_RBUTTON ) )
-                state |= MK_RBUTTON;
-
-            POINT pt;
-            if ( !::GetCursorPos(&pt) )
-            {
-                wxLogLastError(_T("GetCursorPos"));
-            }
-
-            // we need to have client coordinates here for symmetry with
-            // wxEVT_ENTER_WINDOW
-            RECT rect = wxGetWindowRect(GetHwnd());
-            pt.x -= rect.left;
-            pt.y -= rect.top;
-
-            wxMouseEvent event2(wxEVT_LEAVE_WINDOW);
-            InitMouseEvent(event2, pt.x, pt.y, state);
-
-            (void)GetEventHandler()->ProcessEvent(event2);
+            GenerateMouseLeave();

         }
     }
         }
     }

+#endif // !HAVE_TRACKMOUSEEVENT

 
     if (wxUpdateUIEvent::CanUpdate(this))
         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
 
     if (wxUpdateUIEvent::CanUpdate(this))
         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);


@@ -1309,7 +1269,7 @@ void wxWindowMSW::OnInternalIdle()
 bool wxWindowMSW::Reparent(wxWindowBase *parent)
 {
     if ( !wxWindowBase::Reparent(parent) )
 bool wxWindowMSW::Reparent(wxWindowBase *parent)
 {
     if ( !wxWindowBase::Reparent(parent) )

-        return FALSE;
+        return false;

 
     HWND hWndChild = GetHwnd();
     HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
 
     HWND hWndChild = GetHwnd();
     HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;


@@ -1323,7 +1283,7 @@ bool wxWindowMSW::Reparent(wxWindowBase *parent)
     }
 #endif // !__WXWINCE__
 
     }
 #endif // !__WXWINCE__
 

-    return TRUE;
+    return true;

 }
 
 static inline void SendSetRedraw(HWND hwnd, bool on)
 }
 
 static inline void SendSetRedraw(HWND hwnd, bool on)


@@ -1335,16 +1295,28 @@ static inline void SendSetRedraw(HWND hwnd, bool on)
 
 void wxWindowMSW::Freeze()
 {
 
 void wxWindowMSW::Freeze()
 {

-    SendSetRedraw(GetHwnd(), FALSE);
+    if ( !m_frozenness++ )
+    {
+        if ( IsShown() )
+            SendSetRedraw(GetHwnd(), false);
+    }

 }
 
 void wxWindowMSW::Thaw()
 {
 }
 
 void wxWindowMSW::Thaw()
 {

-    SendSetRedraw(GetHwnd(), TRUE);
+    wxASSERT_MSG( m_frozenness > 0, _T("Thaw() without matching Freeze()") );
+
+    if ( !--m_frozenness )
+    {
+        if ( IsShown() )
+        {
+            SendSetRedraw(GetHwnd(), true);

 
 

-    // we need to refresh everything or otherwise he invalidated area is not
-    // repainted
-    Refresh();
+            // we need to refresh everything or otherwise the invalidated area
+            // is not going to be repainted
+            Refresh();
+        }
+    }

 }
 
 void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
 }
 
 void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)


@@ -1352,18 +1324,27 @@ void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
     HWND hWnd = GetHwnd();
     if ( hWnd )
     {
     HWND hWnd = GetHwnd();
     if ( hWnd )
     {

+        RECT mswRect;
+        const RECT *pRect;

         if ( rect )
         {
         if ( rect )
         {

-            RECT mswRect;

             mswRect.left = rect->x;
             mswRect.top = rect->y;
             mswRect.right = rect->x + rect->width;
             mswRect.bottom = rect->y + rect->height;
 
             mswRect.left = rect->x;
             mswRect.top = rect->y;
             mswRect.right = rect->x + rect->width;
             mswRect.bottom = rect->y + rect->height;
 

-            ::InvalidateRect(hWnd, &mswRect, eraseBack);
+            pRect = &mswRect;

         }
         else
         }
         else

-            ::InvalidateRect(hWnd, NULL, eraseBack);
+        {
+            pRect = NULL;
+        }
+
+        UINT flags = RDW_INVALIDATE | RDW_ALLCHILDREN;
+        if ( eraseBack )
+            flags |= RDW_ERASE;
+
+        ::RedrawWindow(hWnd, pRect, NULL, flags);

     }
 }
 
     }
 }
 


@@ -1408,6 +1389,8 @@ void wxWindowMSW::DragAcceptFiles(bool accept)
     HWND hWnd = GetHwnd();
     if ( hWnd )
         ::DragAcceptFiles(hWnd, (BOOL)accept);
     HWND hWnd = GetHwnd();
     if ( hWnd )
         ::DragAcceptFiles(hWnd, (BOOL)accept);

+#else
+    wxUnusedVar(accept);

 #endif
 }
 
 #endif
 }
 


@@ -1533,9 +1516,32 @@ void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
         width = 0;
     if (height < 0)
         height = 0;
         width = 0;
     if (height < 0)
         height = 0;

-    if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
+
+    // if our parent had prepared a defer window handle for us, use it (unless
+    // we are a top level window)
+    wxWindowMSW *parent = GetParent();
+    HDWP hdwp = parent && !IsTopLevel() ? (HDWP)parent->m_hDWP : NULL;
+    if ( hdwp )
+    {
+        hdwp = ::DeferWindowPos(hdwp, GetHwnd(), NULL,
+                            x, y, width, height,
+                            SWP_NOZORDER);
+        if ( !hdwp )
+        {
+            wxLogLastError(_T("DeferWindowPos"));
+        }
+
+        // hdwp must be updated as it may have been changed
+        parent->m_hDWP = (WXHANDLE)hdwp;
+    }
+
+    // otherwise (or if deferring failed) move the window in place immediately
+    if ( !hdwp )

     {
     {

-        wxLogLastError(wxT("MoveWindow"));
+        if ( !::MoveWindow(GetHwnd(), x, y, width, height, IsShown()) )
+        {
+            wxLogLastError(wxT("MoveWindow"));
+        }

     }
 }
 
     }
 }
 


@@ -1562,15 +1568,15 @@ void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
         return;
     }
 
         return;
     }
 

-    if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+    if ( x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )

         x = currentX;
         x = currentX;

-    if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+    if ( y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )

         y = currentY;
 
     AdjustForParentClientOrigin(x, y, sizeFlags);
 
         y = currentY;
 
     AdjustForParentClientOrigin(x, y, sizeFlags);
 

-    wxSize size(-1, -1);
-    if ( width == -1 )
+    wxSize size = wxDefaultSize;
+    if ( width == wxDefaultCoord )

     {
         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
         {
     {
         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
         {


@@ -1584,11 +1590,11 @@ void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
         }
     }
 
         }
     }
 

-    if ( height == -1 )
+    if ( height == wxDefaultCoord )

     {
         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
         {
     {
         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
         {

-            if ( size.x == -1 )
+            if ( size.x == wxDefaultCoord )

             {
                 size = DoGetBestSize();
             }
             {
                 size = DoGetBestSize();
             }


@@ -1626,8 +1632,8 @@ void wxWindowMSW::DoSetClientSize(int width, int height)
         ::GetClientRect(GetHwnd(), &rectClient);
 
         // if the size is already ok, stop here (rectClient.left = top = 0)
         ::GetClientRect(GetHwnd(), &rectClient);
 
         // if the size is already ok, stop here (rectClient.left = top = 0)

-        if ( (rectClient.right == width || width == -1) &&
-             (rectClient.bottom == height || height == -1) )
+        if ( (rectClient.right == width || width == wxDefaultCoord) &&
+             (rectClient.bottom == height || height == wxDefaultCoord) )

         {
             break;
         }
         {
             break;
         }


@@ -1663,13 +1669,6 @@ void wxWindowMSW::DoSetClientSize(int width, int height)
     }
 }
 
     }
 }
 

-// For implementation purposes - sometimes decorations make the client area
-// smaller
-wxPoint wxWindowMSW::GetClientAreaOrigin() const
-{
-    return wxPoint(0, 0);
-}
-

 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------


@@ -1695,31 +1694,22 @@ void wxWindowMSW::GetTextExtent(const wxString& string,
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const
 {
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const
 {

-    const wxFont *fontToUse = theFont;
-    if ( !fontToUse )
-        fontToUse = &m_font;
+    wxASSERT_MSG( !theFont || theFont->Ok(),
+                    _T("invalid font in GetTextExtent()") );

 
 

-    HWND hWnd = GetHwnd();
-    HDC dc = ::GetDC(hWnd);
+    wxFont fontToUse;
+    if (theFont)
+        fontToUse = *theFont;
+    else
+        fontToUse = GetFont();

 
 

-    HFONT fnt = 0;
-    HFONT hfontOld = 0;
-    if ( fontToUse && fontToUse->Ok() )
-    {
-        fnt = (HFONT)((wxFont *)fontToUse)->GetResourceHandle(); // const_cast
-        if ( fnt )
-            hfontOld = (HFONT)SelectObject(dc,fnt);
-    }
+    WindowHDC hdc(GetHwnd());
+    SelectInHDC selectFont(hdc, GetHfontOf(fontToUse));

 
     SIZE sizeRect;
     TEXTMETRIC tm;
 
     SIZE sizeRect;
     TEXTMETRIC tm;

-    GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
-    GetTextMetrics(dc, &tm);
-
-    if ( fontToUse && fnt && hfontOld )
-        SelectObject(dc, hfontOld);
-
-    ReleaseDC(hWnd, dc);
+    GetTextExtentPoint(hdc, string, string.length(), &sizeRect);
+    GetTextMetrics(hdc, &tm);

 
     if ( x )
         *x = sizeRect.cx;
 
     if ( x )
         *x = sizeRect.cx;


@@ -1749,7 +1739,7 @@ static void wxYieldForCommandsOnly()
     MSG msg;
     while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE) )
     {
     MSG msg;
     while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE) )
     {

-        if ( msg.message != WM_QUIT )
+        if ( msg.message == WM_QUIT )

         {
             // if we retrieved a WM_QUIT, insert back into the message queue.
             ::PostQuitMessage(0);
         {
             // if we retrieved a WM_QUIT, insert back into the message queue.
             ::PostQuitMessage(0);


@@ -1769,6 +1759,12 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
     menu->SetInvokingWindow(this);
     menu->UpdateUI();
 
     menu->SetInvokingWindow(this);
     menu->UpdateUI();
 

+    if ( x == wxDefaultCoord && y == wxDefaultCoord )
+    {
+        wxPoint mouse = ScreenToClient(wxGetMousePosition());
+        x = mouse.x; y = mouse.y;
+    }
+

     HWND hWnd = GetHwnd();
     HMENU hMenu = GetHmenuOf(menu);
     POINT point;
     HWND hWnd = GetHwnd();
     HMENU hMenu = GetHmenuOf(menu);
     POINT point;


@@ -1776,9 +1772,10 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
     point.y = y;
     ::ClientToScreen(hWnd, &point);
     wxCurrentPopupMenu = menu;
     point.y = y;
     ::ClientToScreen(hWnd, &point);
     wxCurrentPopupMenu = menu;

+#if defined(__WXWINCE__)

     UINT flags = 0;
     UINT flags = 0;

-#if !defined(__WXWINCE__)
-    flags = TPM_RIGHTBUTTON;
+#else
+    UINT flags = TPM_RIGHTBUTTON;

 #endif
     ::TrackPopupMenu(hMenu, flags, point.x, point.y, 0, hWnd, NULL);
 
 #endif
     ::TrackPopupMenu(hMenu, flags, point.x, point.y, 0, hWnd, NULL);
 


@@ -1795,7 +1792,7 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
 
     menu->SetInvokingWindow(NULL);
 
 
     menu->SetInvokingWindow(NULL);
 

-    return TRUE;
+    return true;

 }
 
 #endif // wxUSE_MENUS_NATIVE
 }
 
 #endif // wxUSE_MENUS_NATIVE


@@ -1804,7 +1801,7 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
 // pre/post message processing
 // ===========================================================================
 
 // pre/post message processing
 // ===========================================================================
 

-long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+WXLRESULT wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)

 {
     if ( m_oldWndProc )
         return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
 {
     if ( m_oldWndProc )
         return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);


@@ -1823,7 +1820,6 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
 
         // here we try to do all the job which ::IsDialogMessage() usually does
         // internally
 
         // here we try to do all the job which ::IsDialogMessage() usually does
         // internally

-#if 1

         if ( msg->message == WM_KEYDOWN )
         {
             bool bCtrlDown = wxIsCtrlDown();
         if ( msg->message == WM_KEYDOWN )
         {
             bool bCtrlDown = wxIsCtrlDown();


@@ -1846,39 +1842,70 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                 }
             }
 
                 }
             }
 

-            bool bForward = TRUE,
-                 bWindowChange = FALSE;
+            bool bForward = true,
+                 bWindowChange = false,
+                 bFromTab = false;

 
             // should we process this message specially?
 
             // should we process this message specially?

-            bool bProcess = TRUE;
+            bool bProcess = true;

             switch ( msg->wParam )
             {
                 case VK_TAB:
             switch ( msg->wParam )
             {
                 case VK_TAB:

-                    // assume that nobody wants Shift-TAB for himself - if we
-                    // don't do it there is no easy way for a control to grab
-                    // TABs but still let Shift-TAB work as navugation key
-                    if ( (lDlgCode & DLGC_WANTTAB) && !bShiftDown ) {
-                        bProcess = FALSE;
+                    if ( lDlgCode & DLGC_WANTTAB ) {
+                        bProcess = false;

                     }
                     else {
                         // Ctrl-Tab cycles thru notebook pages
                         bWindowChange = bCtrlDown;
                         bForward = !bShiftDown;
                     }
                     else {
                         // Ctrl-Tab cycles thru notebook pages
                         bWindowChange = bCtrlDown;
                         bForward = !bShiftDown;

+                        bFromTab = true;

                     }
                     break;
 
                 case VK_UP:
                 case VK_LEFT:
                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
                     }
                     break;
 
                 case VK_UP:
                 case VK_LEFT:
                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )

-                        bProcess = FALSE;
+                        bProcess = false;

                     else
                     else

-                        bForward = FALSE;
+                        bForward = false;

                     break;
 
                 case VK_DOWN:
                 case VK_RIGHT:
                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
                     break;
 
                 case VK_DOWN:
                 case VK_RIGHT:
                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )

-                        bProcess = FALSE;
+                        bProcess = false;
+                    break;
+
+                case VK_ESCAPE:
+                    {
+#if wxUSE_BUTTON
+                        wxButton *btn = wxDynamicCast(FindWindow(wxID_CANCEL),wxButton);
+
+                        // our own wxLogDialog should react to Esc
+                        // without Cancel button but this is a private class
+                        // so let's try recognize it by content
+    #if wxUSE_LOG_DIALOG
+                        if ( !btn &&
+                             wxDynamicCast(this,wxDialog) &&
+                             FindWindow(wxID_MORE) &&
+                             FindWindow(wxID_OK) &&
+                             !FindWindow(wxID_CANCEL) &&
+                             GetTitle().MakeLower().StartsWith(wxTheApp->GetAppName().c_str())
+                             )
+                            btn = wxDynamicCast(FindWindow(wxID_OK),wxButton);
+    #endif // wxUSE_LOG_DIALOG
+                        if ( btn && btn->IsEnabled() )
+                        {
+                            // if we do have a cancel button, do press it
+                            btn->MSWCommand(BN_CLICKED, 0 /* unused */);
+
+                            // we consumed the message
+                            return true;
+                        }
+#endif // wxUSE_BUTTON
+
+                        bProcess = false;
+                    }

                     break;
 
                 case VK_RETURN:
                     break;
 
                 case VK_RETURN:


@@ -1888,7 +1915,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                             // control wants to process Enter itself, don't
                             // call IsDialogMessage() which would interpret
                             // it
                             // control wants to process Enter itself, don't
                             // call IsDialogMessage() which would interpret
                             // it

-                            return FALSE;
+                            return false;

                         }
                         else if ( lDlgCode & DLGC_BUTTON )
                         {
                         }
                         else if ( lDlgCode & DLGC_BUTTON )
                         {


@@ -1904,10 +1931,10 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                     btn->MSWCommand(BN_CLICKED, 0 /* unused */);
                             }
 
                                     btn->MSWCommand(BN_CLICKED, 0 /* unused */);
                             }
 

-                            bProcess = FALSE;
+                            bProcess = false;

                         }
                         // FIXME: this should be handled by
                         }
                         // FIXME: this should be handled by

-                        //        wxNavigationKeyEvent handler and not here!!
+                        //        wxNavigationKeyEvent handler and not here!

                         else
                         {
 #if wxUSE_BUTTON
                         else
                         {
 #if wxUSE_BUTTON


@@ -1918,11 +1945,11 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                 // if we do have a default button, do press it
                                 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
 
                                 // if we do have a default button, do press it
                                 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
 

-                                return TRUE;
+                                return true;

                             }
                             else // no default button
                             }
                             else // no default button

-                            {

 #endif // wxUSE_BUTTON
 #endif // wxUSE_BUTTON

+                            {

                                 // this is a quick and dirty test for a text
                                 // control
                                 if ( !(lDlgCode & DLGC_HASSETSEL) )
                                 // this is a quick and dirty test for a text
                                 // control
                                 if ( !(lDlgCode & DLGC_HASSETSEL) )


@@ -1931,13 +1958,13 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                     // need it for itself and don't let
                                     // ::IsDialogMessage() have it as it can
                                     // eat the Enter events sometimes
                                     // need it for itself and don't let
                                     // ::IsDialogMessage() have it as it can
                                     // eat the Enter events sometimes

-                                    return FALSE;
+                                    return false;

                                 }
                                 else if (!IsTopLevel())
                                 {
                                     // if not a top level window, let parent
                                     // handle it
                                 }
                                 else if (!IsTopLevel())
                                 {
                                     // if not a top level window, let parent
                                     // handle it

-                                    return FALSE;
+                                    return false;

                                 }
                                 //else: treat Enter as TAB: pass to the next
                                 //      control as this is the best thing to do
                                 }
                                 //else: treat Enter as TAB: pass to the next
                                 //      control as this is the best thing to do


@@ -1948,7 +1975,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                     break;
 
                 default:
                     break;
 
                 default:

-                    bProcess = FALSE;
+                    bProcess = false;

             }
 
             if ( bProcess )
             }
 
             if ( bProcess )


@@ -1956,46 +1983,17 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                 wxNavigationKeyEvent event;
                 event.SetDirection(bForward);
                 event.SetWindowChange(bWindowChange);
                 wxNavigationKeyEvent event;
                 event.SetDirection(bForward);
                 event.SetWindowChange(bWindowChange);

+                event.SetFromTab(bFromTab);

                 event.SetEventObject(this);
 
                 if ( GetEventHandler()->ProcessEvent(event) )
                 {
                 event.SetEventObject(this);
 
                 if ( GetEventHandler()->ProcessEvent(event) )
                 {

-                    return TRUE;
+                    return true;

                 }
             }
         }
                 }
             }
         }

-#else // 0
-        // let ::IsDialogMessage() do almost everything and handle just the
-        // things it doesn't here: Ctrl-TAB for switching notebook pages
-        if ( msg->message == WM_KEYDOWN )
-        {
-            // don't process system keys here
-            if ( !(HIWORD(msg->lParam) & KF_ALTDOWN) )
-            {
-                if ( (msg->wParam == VK_TAB) && wxIsCtrlDown() )
-                {
-                    // find the first notebook parent and change its page
-                    wxWindow *win = this;
-                    wxNotebook *nbook = NULL;
-                    while ( win && !nbook )
-                    {
-                        nbook = wxDynamicCast(win, wxNotebook);
-                        win = win->GetParent();
-                    }

 
 

-                    if ( nbook )
-                    {
-                        bool forward = !wxIsShiftDown();
-
-                        nbook->AdvanceSelection(forward);
-                    }
-                }
-            }
-        }
-#endif // 1/0
-
-        // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
-        // shouldn't let IsDialogMessage() get it as it _always_ eats the
+        // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the

         // message even when there is no cancel button and when the message is
         // needed by the control itself: in particular, it prevents the tree in
         // place edit control from being closed with Escape in a dialog
         // message even when there is no cancel button and when the message is
         // needed by the control itself: in particular, it prevents the tree in
         // place edit control from being closed with Escape in a dialog


@@ -2007,7 +2005,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
             // then
 
             // assume we can call it by default
             // then
 
             // assume we can call it by default

-            bool canSafelyCallIsDlgMsg = TRUE;
+            bool canSafelyCallIsDlgMsg = true;

 
             HWND hwndFocus = ::GetFocus();
 
 
             HWND hwndFocus = ::GetFocus();
 


@@ -2025,7 +2023,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
             if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
             {
                 // passimistic by default
             if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
             {
                 // passimistic by default

-                canSafelyCallIsDlgMsg = FALSE;
+                canSafelyCallIsDlgMsg = false;

                 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
                       node;
                       node = node->GetNext() )
                 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
                       node;
                       node = node->GetNext() )


@@ -2036,7 +2034,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                 WS_EX_CONTROLPARENT) )
                     {
                         // it shouldn't hang...
                                 WS_EX_CONTROLPARENT) )
                     {
                         // it shouldn't hang...

-                        canSafelyCallIsDlgMsg = TRUE;
+                        canSafelyCallIsDlgMsg = true;

 
                         break;
                     }
 
                         break;
                     }


@@ -2056,7 +2054,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                             !::IsWindowVisible(hwndFocus) )
                     {
                         // it would enter an infinite loop if we do this!
                             !::IsWindowVisible(hwndFocus) )
                     {
                         // it would enter an infinite loop if we do this!

-                        canSafelyCallIsDlgMsg = FALSE;
+                        canSafelyCallIsDlgMsg = false;

 
                         break;
                     }
 
                         break;
                     }


@@ -2077,7 +2075,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
             if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
             {
                 // IsDialogMessage() did something...
             if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
             {
                 // IsDialogMessage() did something...

-                return TRUE;
+                return true;

             }
         }
     }
             }
         }
     }


@@ -2093,7 +2091,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
     }
 #endif // wxUSE_TOOLTIPS
 
     }
 #endif // wxUSE_TOOLTIPS
 

-    return FALSE;
+    return false;

 }
 
 bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
 }
 
 bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)


@@ -2102,14 +2100,14 @@ bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
     return m_acceleratorTable.Translate(this, pMsg);
 #else
     (void) pMsg;
     return m_acceleratorTable.Translate(this, pMsg);
 #else
     (void) pMsg;

-    return FALSE;
+    return false;

 #endif // wxUSE_ACCEL
 }
 
 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
 {
     // preprocess all messages by default
 #endif // wxUSE_ACCEL
 }
 
 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
 {
     // preprocess all messages by default

-    return TRUE;
+    return true;

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


@@ -2141,13 +2139,10 @@ void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
 }
 
 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
 }
 
 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,

-                              WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
+                                 WXHDC *hdc, WXHWND *hwnd)

 {
 {

-#ifndef __WXMICROWIN__
-    *nCtlColor = CTLCOLOR_BTN;

     *hwnd = (WXHWND)lParam;
     *hdc = (WXHDC)wParam;
     *hwnd = (WXHWND)lParam;
     *hdc = (WXHDC)wParam;

-#endif

 }
 
 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
 }
 
 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,


@@ -2159,7 +2154,7 @@ void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------

-// Main wxWindows window proc and the window proc for wxWindow
+// Main wxWidgets window proc and the window proc for wxWindow

 // ---------------------------------------------------------------------------
 
 // Hook for new window just as it's being created, when the window isn't yet
 // ---------------------------------------------------------------------------
 
 // Hook for new window just as it's being created, when the window isn't yet


@@ -2210,17 +2205,16 @@ LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM w
     return rc;
 }
 
     return rc;
 }
 

-long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+WXLRESULT wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)

 {
     // did we process the message?
 {
     // did we process the message?

-    bool processed = FALSE;
+    bool processed = false;

 
     // the return value
     union
     {
         bool        allow;
 
     // the return value
     union
     {
         bool        allow;

-        long        result;
-        WXHICON     hIcon;
+        WXLRESULT   result;

         WXHBRUSH    hBrush;
     } rc;
 
         WXHBRUSH    hBrush;
     } rc;
 


@@ -2242,13 +2236,17 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             break;
 
         case WM_DESTROY:
             break;
 
         case WM_DESTROY:

-            // never set processed to TRUE and *always* pass WM_DESTROY to
+            // never set processed to true and *always* pass WM_DESTROY to

             // DefWindowProc() as Windows may do some internal cleanup when
             // processing it and failing to pass the message along may cause
             // memory and resource leaks!
             (void)HandleDestroy();
             break;
 
             // DefWindowProc() as Windows may do some internal cleanup when
             // processing it and failing to pass the message along may cause
             // memory and resource leaks!
             (void)HandleDestroy();
             break;
 

+        case WM_SIZE:
+            processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
+            break;
+

         case WM_MOVE:
             processed = HandleMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
             break;
         case WM_MOVE:
             processed = HandleMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
             break;


@@ -2271,37 +2269,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 }
             }
             break;
                 }
             }
             break;

-#endif
-
-        case WM_SIZE:
-            switch ( wParam )
-            {
-                case SIZE_MAXHIDE:
-                case SIZE_MAXSHOW:
-                    // we're not interested in these messages at all
-                    break;
-
-                case SIZE_MINIMIZED:
-                    // we shouldn't send sizev events for these messages as the
-                    // client size may be negative which breaks existing code
-                    //
-                    // OTOH we might send another (wxMinimizedEvent?) one or
-                    // add an additional parameter to wxSizeEvent if this is
-                    // useful to anybody
-                    break;
-
-                default:
-                    wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
-                    // fall through nevertheless
-
-                case SIZE_MAXIMIZED:
-                case SIZE_RESTORED:
-                    processed = HandleSize(LOWORD(lParam), HIWORD(lParam),
-                                           wParam);
-            }
-            break;

 
 

-#if !defined(__WXWINCE__)

         case WM_SIZING:
             {
                 LPRECT pRect = (LPRECT)lParam;
         case WM_SIZING:
             {
                 LPRECT pRect = (LPRECT)lParam;


@@ -2319,10 +2287,11 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 }
             }
             break;
                 }
             }
             break;

-#endif
+#endif // !__WXWINCE__

 
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
         case WM_ACTIVATEAPP:
 
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
         case WM_ACTIVATEAPP:

+            // This implicitly sends a wxEVT_ACTIVATE_APP event

             wxTheApp->SetActive(wParam != 0, FindFocus());
             break;
 #endif
             wxTheApp->SetActive(wParam != 0, FindFocus());
             break;
 #endif


@@ -2360,33 +2329,38 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 break;
             }
 
                 break;
             }
 

-#ifndef __WXWINCE__
-        case WM_PRINT:
+#ifdef WM_PRINT
+        case WM_PRINTCLIENT:
+            if ( GetParent() &&
+                  GetParent()->MSWPrintChild((wxWindow *)this, wParam, lParam) )

             {
             {

-                // Don't call the wx handlers in this case
-                if ( wxIsKindOf(this, wxListCtrl) )
-                    break;
+                processed = true;
+            }
+            break;

 
 

+        case WM_PRINT:
+            {

                 if ( lParam & PRF_ERASEBKGND )
                     HandleEraseBkgnd((WXHDC)(HDC)wParam);
 
                 wxPaintDCEx dc((wxWindow *)this, (WXHDC)wParam);
                 if ( lParam & PRF_ERASEBKGND )
                     HandleEraseBkgnd((WXHDC)(HDC)wParam);
 
                 wxPaintDCEx dc((wxWindow *)this, (WXHDC)wParam);

+

                 processed = HandlePaint();
             }
             break;
                 processed = HandlePaint();
             }
             break;

-#endif
+#endif // WM_PRINT

 
         case WM_CLOSE:
 #ifdef __WXUNIVERSAL__
             // Universal uses its own wxFrame/wxDialog, so we don't receive
             // close events unless we have this.
             Close();
 
         case WM_CLOSE:
 #ifdef __WXUNIVERSAL__
             // Universal uses its own wxFrame/wxDialog, so we don't receive
             // close events unless we have this.
             Close();

-            processed = TRUE;
+            processed = true;

             rc.result = TRUE;
 #else
             // don't let the DefWindowProc() destroy our window - we'll do it
             // ourselves in ~wxWindow
             rc.result = TRUE;
 #else
             // don't let the DefWindowProc() destroy our window - we'll do it
             // ourselves in ~wxWindow

-            processed = TRUE;
+            processed = true;

             rc.result = TRUE;
 #endif
             break;
             rc.result = TRUE;
 #endif
             break;


@@ -2401,6 +2375,21 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                                         wParam);
             break;
 
                                         wParam);
             break;
 

+#ifdef HAVE_TRACKMOUSEEVENT
+        case WM_MOUSELEAVE:
+            // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
+            if ( m_mouseInWindow )
+            {
+                GenerateMouseLeave();
+            }
+
+            // always pass processed back as false, this allows the window
+            // manager to process the message too.  This is needed to
+            // ensure windows XP themes work properly as the mouse moves
+            // over widgets like buttons. So don't set processed to true here.
+            break;
+#endif // HAVE_TRACKMOUSEEVENT
+

 #if wxUSE_MOUSEWHEEL
         case WM_MOUSEWHEEL:
             processed = HandleMouseWheel(wParam, lParam);
 #if wxUSE_MOUSEWHEEL
         case WM_MOUSEWHEEL:
             processed = HandleMouseWheel(wParam, lParam);


@@ -2426,7 +2415,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 {
                     if (!win->IsEnabled())
                     {
                 {
                     if (!win->IsEnabled())
                     {

-                        processed = TRUE;
+                        processed = true;

                         break;
                     }
 
                         break;
                     }
 


@@ -2458,19 +2447,23 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                     // this should never happen
                     wxCHECK_MSG( win, 0,
                                  _T("FindWindowForMouseEvent() returned NULL") );
                     // this should never happen
                     wxCHECK_MSG( win, 0,
                                  _T("FindWindowForMouseEvent() returned NULL") );

+                }
+
+                processed = win->HandleMouseEvent(message, x, y, wParam);

 
 

+                // if the app didn't eat the event, handle it in the default
+                // way, that is by giving this window the focus
+                if ( !processed )
+                {

                     // for the standard classes their WndProc sets the focus to
                     // them anyhow and doing it from here results in some weird
                     // for the standard classes their WndProc sets the focus to
                     // them anyhow and doing it from here results in some weird

-                    // problems, but for our windows we want them to acquire
-                    // focus when clicked
+                    // problems, so don't do it for them (unnecessary anyhow)

                     if ( !win->IsOfStandardClass() )
                     {
                         if ( message == WM_LBUTTONDOWN && win->AcceptsFocus() )
                             win->SetFocus();
                     }
                 }
                     if ( !win->IsOfStandardClass() )
                     {
                         if ( message == WM_LBUTTONDOWN && win->AcceptsFocus() )
                             win->SetFocus();
                     }
                 }

-
-                processed = win->HandleMouseEvent(message, x, y, wParam);

             }
             break;
 
             }
             break;
 


@@ -2490,10 +2483,6 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             break;
 #endif // __WXMICROWIN__
 
             break;
 #endif // __WXMICROWIN__
 

-        case WM_SYSCOMMAND:
-            processed = HandleSysCommand(wParam, lParam);
-            break;
-

         case WM_COMMAND:
             {
                 WORD id, cmd;
         case WM_COMMAND:
             {
                 WORD id, cmd;


@@ -2508,7 +2497,20 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             processed = HandleNotify((int)wParam, lParam, &rc.result);
             break;
 
             processed = HandleNotify((int)wParam, lParam, &rc.result);
             break;
 

-            // for these messages we must return TRUE if process the message
+        // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
+        // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
+        // apparently doesn't always behave properly and needs some help
+#if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
+        case WM_NOTIFYFORMAT:
+            if ( lParam == NF_QUERY )
+            {
+                processed = true;
+                rc.result = NFR_UNICODE;
+            }
+            break;
+#endif // wxUSE_UNICODE_MSLU
+
+            // for these messages we must return true if process the message

 #ifdef WM_DRAWITEM
         case WM_DRAWITEM:
         case WM_MEASUREITEM:
 #ifdef WM_DRAWITEM
         case WM_DRAWITEM:
         case WM_MEASUREITEM:


@@ -2545,7 +2547,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                                  DLGC_WANTALLKEYS;
                 }
 
                                  DLGC_WANTALLKEYS;
                 }
 

-                processed = TRUE;
+                processed = true;

             }
             //else: get the dlg code from the DefWindowProc()
             break;
             }
             //else: get the dlg code from the DefWindowProc()
             break;


@@ -2557,7 +2559,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
             if ( m_lastKeydownProcessed )
             {
             m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
             if ( m_lastKeydownProcessed )
             {

-                processed = TRUE;
+                processed = true;

             }
 
             if ( !processed )
             }
 
             if ( !processed )


@@ -2572,7 +2574,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                     case VK_CAPITAL:
                     case VK_NUMLOCK:
                     case VK_SCROLL:
                     case VK_CAPITAL:
                     case VK_NUMLOCK:
                     case VK_SCROLL:

-                        processed = TRUE;
+                        processed = true;

                         break;
 
                     // avoid duplicate messages to OnChar for these ASCII keys:
                         break;
 
                     // avoid duplicate messages to OnChar for these ASCII keys:


@@ -2598,23 +2600,17 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                     case VK_OEM_COMMA:
                     case VK_OEM_MINUS:
                     case VK_OEM_PERIOD:
                     case VK_OEM_COMMA:
                     case VK_OEM_MINUS:
                     case VK_OEM_PERIOD:

-                        // but set processed to FALSE, not TRUE to still pass them
+                        // but set processed to false, not true to still pass them

                         // to the control's default window proc - otherwise
                         // built-in keyboard handling won't work
                         // to the control's default window proc - otherwise
                         // built-in keyboard handling won't work

-                        processed = FALSE;
+                        processed = false;

                         break;
 
 #ifdef VK_APPS
                     // special case of VK_APPS: treat it the same as right mouse
                     // click because both usually pop up a context menu
                     case VK_APPS:
                         break;
 
 #ifdef VK_APPS
                     // special case of VK_APPS: treat it the same as right mouse
                     // click because both usually pop up a context menu
                     case VK_APPS:

-                        {
-                            WPARAM flags;
-                            int x, y;
-
-                            TranslateKbdEventToMouse(this, &x, &y, &flags);
-                            processed = HandleMouseEvent(WM_RBUTTONDOWN, x, y, flags);
-                        }
+                        processed = HandleMouseEvent(WM_RBUTTONDOWN, -1, -1, 0);

                         break;
 #endif // VK_APPS
 
                         break;
 #endif // VK_APPS
 


@@ -2624,7 +2620,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 }
             }
             if (message == WM_SYSKEYDOWN)  // Let Windows still handle the SYSKEYs
                 }
             }
             if (message == WM_SYSKEYDOWN)  // Let Windows still handle the SYSKEYs

-                processed = FALSE;
+                processed = false;

             break;
 
         case WM_SYSKEYUP:
             break;
 
         case WM_SYSKEYUP:


@@ -2633,11 +2629,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             // special case of VK_APPS: treat it the same as right mouse button
             if ( wParam == VK_APPS )
             {
             // special case of VK_APPS: treat it the same as right mouse button
             if ( wParam == VK_APPS )
             {

-                WPARAM flags;
-                int x, y;
-
-                TranslateKbdEventToMouse(this, &x, &y, &flags);
-                processed = HandleMouseEvent(WM_RBUTTONUP, x, y, flags);
+                processed = HandleMouseEvent(WM_RBUTTONUP, -1, -1, 0);

             }
             else
 #endif // VK_APPS
             }
             else
 #endif // VK_APPS


@@ -2653,12 +2645,12 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 // The key was handled in the EVT_KEY_DOWN and handling
                 // a key in an EVT_KEY_DOWN handler is meant, by
                 // design, to prevent EVT_CHARs from happening
                 // The key was handled in the EVT_KEY_DOWN and handling
                 // a key in an EVT_KEY_DOWN handler is meant, by
                 // design, to prevent EVT_CHARs from happening

-                m_lastKeydownProcessed = FALSE;
-                processed = TRUE;
+                m_lastKeydownProcessed = false;
+                processed = true;

             }
             else
             {
             }
             else
             {

-                processed = HandleChar((WORD)wParam, lParam, TRUE);
+                processed = HandleChar((WORD)wParam, lParam, true);

             }
             break;
 
             }
             break;
 


@@ -2682,7 +2674,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             break;
 
         // CTLCOLOR messages are sent by children to query the parent for their
             break;
 
         // CTLCOLOR messages are sent by children to query the parent for their

-        // colors#ifndef __WXMICROWIN__
+        // colors

 #ifndef __WXMICROWIN__
         case WM_CTLCOLORMSGBOX:
         case WM_CTLCOLOREDIT:
 #ifndef __WXMICROWIN__
         case WM_CTLCOLORMSGBOX:
         case WM_CTLCOLOREDIT:


@@ -2692,18 +2684,11 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
         case WM_CTLCOLORSCROLLBAR:
         case WM_CTLCOLORSTATIC:
             {
         case WM_CTLCOLORSCROLLBAR:
         case WM_CTLCOLORSTATIC:
             {

-                WXWORD nCtlColor;

                 WXHDC hdc;
                 WXHWND hwnd;
                 WXHDC hdc;
                 WXHWND hwnd;

-                UnpackCtlColor(wParam, lParam, &nCtlColor, &hdc, &hwnd);
-
-                processed = HandleCtlColor(&rc.hBrush,
-                                           (WXHDC)hdc,
-                                           (WXHWND)hwnd,
-                                           nCtlColor,
-                                           message,
-                                           wParam,
-                                           lParam);
+                UnpackCtlColor(wParam, lParam, &hdc, &hwnd);
+
+                processed = HandleCtlColor(&rc.hBrush, (WXHDC)hdc, (WXHWND)hwnd);

             }
             break;
 #endif // !__WXMICROWIN__
             }
             break;
 #endif // !__WXMICROWIN__


@@ -2790,7 +2775,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
                 LPARAM dwObjId = (LPARAM) (DWORD) lParam;
 
                 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
                 LPARAM dwObjId = (LPARAM) (DWORD) lParam;
 

-                if (dwObjId == OBJID_CLIENT && GetOrCreateAccessible())
+                if (dwObjId == (LPARAM)OBJID_CLIENT && GetOrCreateAccessible())

                 {
                     return LresultFromObject(IID_IAccessible, wParam, (IUnknown*) GetAccessible()->GetIAccessible());
                 }
                 {
                     return LresultFromObject(IID_IAccessible, wParam, (IUnknown*) GetAccessible()->GetIAccessible());
                 }


@@ -2809,13 +2794,13 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 {
 #endif
                     wxWindowMSW* subjectOfHelp = this;
                 {
 #endif
                     wxWindowMSW* subjectOfHelp = this;

-                    bool eventProcessed = FALSE;
+                    bool eventProcessed = false;

                     while (subjectOfHelp && !eventProcessed)
                     {
                         wxHelpEvent helpEvent(wxEVT_HELP,
                                               subjectOfHelp->GetId(),
 #ifdef __WXWINCE__
                     while (subjectOfHelp && !eventProcessed)
                     {
                         wxHelpEvent helpEvent(wxEVT_HELP,
                                               subjectOfHelp->GetId(),
 #ifdef __WXWINCE__

-                                              wxPoint(0, 0)
+                                              wxPoint(0,0)

 #else
                                               wxPoint(info->MousePos.x, info->MousePos.y)
 #endif
 #else
                                               wxPoint(info->MousePos.x, info->MousePos.y)
 #endif


@@ -2840,7 +2825,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                     processed = GetEventHandler()->ProcessEvent(helpEvent);
 
                 }
                     processed = GetEventHandler()->ProcessEvent(helpEvent);
 
                 }

-                //else: processed is already FALSE
+                //else: processed is already false

 #endif
             }
             break;
 #endif
             }
             break;


@@ -2854,7 +2839,20 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
 
                 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
                 wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
 
                 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);

-                processed = GetEventHandler()->ProcessEvent(evtCtx);
+
+                // we could have got an event from our child, reflect it back
+                // to it if this is the case
+                wxWindowMSW *win = NULL;
+                if ( (WXHWND)wParam != m_hWnd )
+                {
+                    win = FindItemByHWND((WXHWND)wParam);
+                }
+
+                if ( !win )
+                    win = this;
+
+                evtCtx.SetEventObject(win);
+                processed = win->GetEventHandler()->ProcessEvent(evtCtx);

             }
             break;
 #endif
             }
             break;
 #endif


@@ -2868,7 +2866,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 if ( i != wxNOT_FOUND )
                 {
                     rc.result = MAKELRESULT(i, MNC_EXECUTE);
                 if ( i != wxNOT_FOUND )
                 {
                     rc.result = MAKELRESULT(i, MNC_EXECUTE);

-                    processed = TRUE;
+                    processed = true;

                 }
             }
             break;
                 }
             }
             break;


@@ -2894,7 +2892,7 @@ wxWinHashTable *wxWinHandleHash = NULL;
 
 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
 {
 
 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
 {

-    return wxWinHandleHash->Get((long)hWnd);
+    return (wxWindow*)wxWinHandleHash->Get((long)hWnd);

 }
 
 void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
 }
 
 void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)


@@ -2939,15 +2937,15 @@ bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
                                            int& x, int& y,
                                            int& w, int& h) const
 {
                                            int& x, int& y,
                                            int& w, int& h) const
 {

+    // yes, those are just some arbitrary hardcoded numbers

     static const int DEFAULT_Y = 200;
     static const int DEFAULT_Y = 200;

-    static const int DEFAULT_H = 250;

 
 

-    bool nonDefault = FALSE;
+    bool nonDefault = false;

 
 

-    if ( pos.x == -1 )
+    if ( pos.x == wxDefaultCoord )

     {
     {

-        // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
-        // just as well set it to CW_USEDEFAULT as well
+        // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
+        // can just as well set it to CW_USEDEFAULT as well

         x =
         y = CW_USEDEFAULT;
     }
         x =
         y = CW_USEDEFAULT;
     }


@@ -2957,15 +2955,15 @@ bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
         // neither because it is not handled as a special value by Windows then
         // and so we have to choose some default value for it
         x = pos.x;
         // neither because it is not handled as a special value by Windows then
         // and so we have to choose some default value for it
         x = pos.x;

-        y = pos.y == -1 ? DEFAULT_Y : pos.y;
+        y = pos.y == wxDefaultCoord ? DEFAULT_Y : pos.y;

 
 

-        nonDefault = TRUE;
+        nonDefault = true;

     }
 
     /*
       NB: there used to be some code here which set the initial size of the
           window to the client size of the parent if no explicit size was
     }
 
     /*
       NB: there used to be some code here which set the initial size of the
           window to the client size of the parent if no explicit size was

-          specified. This was wrong because wxWindows programs often assume
+          specified. This was wrong because wxWidgets programs often assume

           that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
           it. To see why, you should understand that Windows sends WM_SIZE from
           inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
           that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
           it. To see why, you should understand that Windows sends WM_SIZE from
           inside ::CreateWindow() anyhow. However, ::CreateWindow() is called


@@ -2974,24 +2972,51 @@ bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
           event goes to some base class OnSize() instead). So the WM_SIZE we
           rely on is the one sent when the parent frame resizes its children
           but here is the problem: if the child already has just the right
           event goes to some base class OnSize() instead). So the WM_SIZE we
           rely on is the one sent when the parent frame resizes its children
           but here is the problem: if the child already has just the right

-          size, nothing will happen as both wxWindows and Windows check for
+          size, nothing will happen as both wxWidgets and Windows check for

           this and ignore any attempts to change the window size to the size it
           already has - so no WM_SIZE would be sent.
      */
           this and ignore any attempts to change the window size to the size it
           already has - so no WM_SIZE would be sent.
      */

-    if ( size.x == -1 )
-    {
-        // as above, h is not used at all in this case anyhow
-        w =
+
+
+    // we don't use CW_USEDEFAULT here for several reasons:
+    //
+    //  1. it results in huge frames on modern screens (1000*800 is not
+    //     uncommon on my 1280*1024 screen) which is way too big for a half
+    //     empty frame of most of wxWidgets samples for example)
+    //
+    //  2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
+    //     the default is for whatever reason 8*8 which breaks client <->
+    //     window size calculations (it would be nice if it didn't, but it
+    //     does and the simplest way to fix it seemed to change the broken
+    //     default size anyhow)
+    //
+    //  3. there is just no advantage in doing it: with x and y it is
+    //     possible that [future versions of] Windows position the new top
+    //     level window in some smart way which we can't do, but we can
+    //     guess a reasonably good size for a new window just as well
+    //     ourselves
+
+    // However, on PocketPC devices, we must use the default
+    // size if possible.
+#ifdef _WIN32_WCE
+    if (size.x == wxDefaultCoord)
+        w = CW_USEDEFAULT;
+    else
+        w = size.x;
+    if (size.y == wxDefaultCoord)

         h = CW_USEDEFAULT;
         h = CW_USEDEFAULT;

-    }

     else
     else

+        h = size.y;
+#else
+    if ( size.x == wxDefaultCoord || size.y == wxDefaultCoord)

     {
     {

-        // and, again as above, we can't set the height to CW_USEDEFAULT here
-        w = size.x;
-        h = size.y == -1 ? DEFAULT_H  : size.y;
-
-        nonDefault = TRUE;
+        nonDefault = true;

     }
     }

+    w = WidthDefault(size.x);
+    h = HeightDefault(size.y);
+#endif
+
+    AdjustForParentClientOrigin(x, y);

 
     return nonDefault;
 }
 
     return nonDefault;
 }


@@ -3020,7 +3045,7 @@ bool wxWindowMSW::MSWCreate(const wxChar *wclass,
     // which is the same but without CS_[HV]REDRAW class styles so using it
     // ensures that the window is not fully repainted on each resize
     wxString className(wclass);
     // which is the same but without CS_[HV]REDRAW class styles so using it
     // ensures that the window is not fully repainted on each resize
     wxString className(wclass);

-    if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE )
+    if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )

     {
         className += wxT("NR");
     }
     {
         className += wxT("NR");
     }


@@ -3028,50 +3053,29 @@ bool wxWindowMSW::MSWCreate(const wxChar *wclass,
     // do create the window
     wxWindowCreationHook hook(this);
 
     // do create the window
     wxWindowCreationHook hook(this);
 

-#ifdef __WXWINCE__
-    if (extendedStyle == 0)
-    {
-        m_hWnd = (WXHWND)::CreateWindow
-            (
-            className,
-            title ? title : wxEmptyString,
-            style,
-            x, y, w, h,
-            (HWND)MSWGetParent(),
-            (HMENU)controlId,
-            wxGetInstance(),
-            NULL                        // no extra data
-            );
-    }
-    else
-#endif
-    {
-        m_hWnd = (WXHWND)::CreateWindowEx
-            (
-            extendedStyle,
-            className,
-            title ? title : wxEmptyString,
-            style,
-            x, y, w, h,
-            (HWND)MSWGetParent(),
-            (HMENU)controlId,
-            wxGetInstance(),
-            NULL                        // no extra data
-            );
-    }
+    m_hWnd = (WXHWND)::CreateWindowEx
+                       (
+                        extendedStyle,
+                        className,
+                        title ? title : m_windowName.c_str(),
+                        style,
+                        x, y, w, h,
+                        (HWND)MSWGetParent(),
+                        (HMENU)controlId,
+                        wxGetInstance(),
+                        NULL                        // no extra data
+                       );

 
     if ( !m_hWnd )
     {
 
     if ( !m_hWnd )
     {

-        wxLogSysError(_("Can't create window of class %s"), wclass);
+        wxLogSysError(_("Can't create window of class %s"), className.c_str());

 
 

-        return FALSE;
+        return false;

     }
 
     SubclassWin(m_hWnd);
 
     }
 
     SubclassWin(m_hWnd);
 

-    SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
-
-    return TRUE;
+    return true;

 }
 
 // ===========================================================================
 }
 
 // ===========================================================================


@@ -3111,7 +3115,7 @@ bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
         wxWindow *child = node->GetData();
         if ( child->MSWOnNotify(idCtrl, lParam, result) )
         {
         wxWindow *child = node->GetData();
         if ( child->MSWOnNotify(idCtrl, lParam, result) )
         {

-            return TRUE;
+            return true;

         }
 
         node = node->GetNext();
         }
 
         node = node->GetNext();


@@ -3121,7 +3125,7 @@ bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
     // by default, handle it ourselves
     return MSWOnNotify(idCtrl, lParam, result);
 #else // __WXMICROWIN__
     // by default, handle it ourselves
     return MSWOnNotify(idCtrl, lParam, result);
 #else // __WXMICROWIN__

-    return FALSE;
+    return false;

 #endif
 }
 
 #endif
 }
 


@@ -3137,59 +3141,71 @@ bool wxWindowMSW::HandleTooltipNotify(WXUINT code,
     // we need to handle it as well, otherwise no tooltips will be shown in
     // this case
 #ifndef __WXWINCE__
     // we need to handle it as well, otherwise no tooltips will be shown in
     // this case
 #ifndef __WXWINCE__

-    if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW) || ttip.empty() )
+    if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW)
+            || ttip.empty() )

     {
         // not a tooltip message or no tooltip to show anyhow
     {
         // not a tooltip message or no tooltip to show anyhow

-        return FALSE;
+        return false;

     }
 #endif
 
     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
 
     }
 #endif
 
     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
 

+    // We don't want to use the szText buffer because it has a limit of 80
+    // bytes and this is not enough, especially for Unicode build where it
+    // limits the tooltip string length to only 40 characters
+    //
+    // The best would be, of course, to not impose any length limitations at
+    // all but then the buffer would have to be dynamic and someone would have
+    // to free it and we don't have the tooltip owner object here any more, so
+    // for now use our own static buffer with a higher fixed max length.
+    //
+    // Note that using a static buffer should not be a problem as only a single
+    // tooltip can be shown at the same time anyhow.

 #if !wxUSE_UNICODE
 #if !wxUSE_UNICODE

-    if ( code == (WXUINT) TTN_NEEDTEXTA )
-    {
-        // we pass just the pointer as we store the string internally anyhow
-        ttText->lpszText = (char *)ttip.c_str();
-    }
-    else // TTN_NEEDTEXTW
-#endif // !Unicode
+    if ( code == (WXUINT) TTN_NEEDTEXTW )

     {
     {

-#if wxUSE_UNICODE
-        // in Unicode mode this is just what we need
-        ttText->lpszText = (wxChar *)ttip.c_str();
-#else // !Unicode
-/*
-        MultiByteToWideChar(CP_ACP, 0, ttip, ttip.length()+1,
-                            (wchar_t *)ttText->szText,
-                            sizeof(ttText->szText) / sizeof(wchar_t));
-*/
-        // Fix by dimitrishortcut: see patch 771772
-
-        // FIXME: szText has a max of 80 bytes, so limit the tooltip string
-        // length accordingly. Ideally lpszText should be used, but who
-        // would be responsible for freeing the buffer?
-
-        // Maximum length of a tip is 39 characters. 39 is 80/2 minus 1 byte
-        // needed for NULL character.
-        size_t tipLength = wxMin(ttip.Len(), 39);
+        // We need to convert tooltip from multi byte to Unicode on the fly.
+        static wchar_t buf[513];

 
 

-        // Convert to WideChar without adding the NULL character. The NULL
-        // character is added afterwards (Could have used ttip.Left(tipLength)
-        // and a cchMultiByte parameter of tipLength+1, but this is more
-        //efficient.
-        ::MultiByteToWideChar(CP_ACP, 0, ttip, tipLength,
-                             (wchar_t *)ttText->szText,
-                             sizeof(ttText->szText) / sizeof(wchar_t));
+        // Truncate tooltip length if needed as otherwise we might not have
+        // enough space for it in the buffer and MultiByteToWideChar() would
+        // return an error
+        size_t tipLength = wxMin(ttip.Len(), WXSIZEOF(buf) - 1);

 
 

-        // Add the NULL character.
-        ttText->szText[tipLength*2+0] = '\0';
-        ttText->szText[tipLength*2+1] = '\0';
+        // Convert to WideChar without adding the NULL character. The NULL
+        // character is added afterwards (this is more efficient).
+        int len = ::MultiByteToWideChar
+                    (
+                        CP_ACP,
+                        0,                      // no flags
+                        ttip,
+                        tipLength,
+                        buf,
+                        WXSIZEOF(buf) - 1
+                    );
+
+        if ( !len )
+        {
+            wxLogLastError(_T("MultiByteToWideChar()"));
+        }

 
 

-#endif // Unicode/!Unicode
+        buf[len] = L'\0';
+        ttText->lpszText = (LPSTR) buf;
+    }
+    else // TTN_NEEDTEXTA
+#endif // !wxUSE_UNICODE
+    {
+        // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
+        // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
+        // to copy the string we have into the buffer
+        static wxChar buf[513];
+        wxStrncpy(buf, ttip.c_str(), WXSIZEOF(buf) - 1);
+        buf[WXSIZEOF(buf) - 1] = _T('\0');
+        ttText->lpszText = buf;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 #endif // wxUSE_TOOLTIPS
 }
 
 #endif // wxUSE_TOOLTIPS


@@ -3205,12 +3221,14 @@ bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
         if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
         {
             // processed
         if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
         {
             // processed

-            return TRUE;
+            return true;

         }
     }
         }
     }

+#else
+    wxUnusedVar(lParam);

 #endif // wxUSE_TOOLTIPS
 
 #endif // wxUSE_TOOLTIPS
 

-    return FALSE;
+    return false;

 }
 
 #endif // __WIN95__
 }
 
 #endif // __WIN95__


@@ -3221,10 +3239,10 @@ bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
 
 bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
 {
 
 bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
 {

-#ifndef __WXWINCE__
-    wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
+#ifdef ENDSESSION_LOGOFF
+    wxCloseEvent event(wxEVT_QUERY_END_SESSION, wxID_ANY);

     event.SetEventObject(wxTheApp);
     event.SetEventObject(wxTheApp);

-    event.SetCanVeto(TRUE);
+    event.SetCanVeto(true);

     event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
 
     bool rc = wxTheApp->ProcessEvent(event);
     event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
 
     bool rc = wxTheApp->ProcessEvent(event);


@@ -3238,29 +3256,33 @@ bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
 
     return rc;
 #else
 
     return rc;
 #else

-    return FALSE;
+    wxUnusedVar(logOff);
+    wxUnusedVar(mayEnd);
+    return false;

 #endif
 }
 
 bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
 {
 #endif
 }
 
 bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
 {

-#ifndef __WXWINCE__
+#ifdef ENDSESSION_LOGOFF

     // do nothing if the session isn't ending
     if ( !endSession )
     // do nothing if the session isn't ending
     if ( !endSession )

-        return FALSE;
+        return false;

 
     // only send once
     if ( (this != wxTheApp->GetTopWindow()) )
 
     // only send once
     if ( (this != wxTheApp->GetTopWindow()) )

-        return FALSE;
+        return false;

 
 

-    wxCloseEvent event(wxEVT_END_SESSION, -1);
+    wxCloseEvent event(wxEVT_END_SESSION, wxID_ANY);

     event.SetEventObject(wxTheApp);
     event.SetEventObject(wxTheApp);

-    event.SetCanVeto(FALSE);
+    event.SetCanVeto(false);

     event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
 
     return wxTheApp->ProcessEvent(event);
 #else
     event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
 
     return wxTheApp->ProcessEvent(event);
 #else

-    return FALSE;
+    wxUnusedVar(endSession);
+    wxUnusedVar(logOff);
+    return false;

 #endif
 }
 
 #endif
 }
 


@@ -3276,15 +3298,17 @@ bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate)
 #ifndef __WXWINCE__
     if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
         EnsureParentHasControlParentStyle(GetParent());
 #ifndef __WXWINCE__
     if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
         EnsureParentHasControlParentStyle(GetParent());

+#else
+    wxUnusedVar(cs);

 #endif // !__WXWINCE__
 
     // TODO: should generate this event from WM_NCCREATE
     wxWindowCreateEvent event((wxWindow *)this);
     (void)GetEventHandler()->ProcessEvent(event);
 
 #endif // !__WXWINCE__
 
     // TODO: should generate this event from WM_NCCREATE
     wxWindowCreateEvent event((wxWindow *)this);
     (void)GetEventHandler()->ProcessEvent(event);
 

-    *mayCreate = TRUE;
+    *mayCreate = true;

 
 

-    return TRUE;
+    return true;

 }
 
 bool wxWindowMSW::HandleDestroy()
 }
 
 bool wxWindowMSW::HandleDestroy()


@@ -3303,7 +3327,7 @@ bool wxWindowMSW::HandleDestroy()
 #endif // wxUSE_DRAG_AND_DROP
 
     // WM_DESTROY handled
 #endif // wxUSE_DRAG_AND_DROP
 
     // WM_DESTROY handled

-    return TRUE;
+    return true;

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


@@ -3324,6 +3348,13 @@ bool wxWindowMSW::HandleActivate(int state,
 
 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
 {
 
 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
 {

+    // Strangly enough, some controls get set focus events when they are being
+    // deleted, even if they already had focus before.
+    if ( m_isBeingDeleted )
+    {
+        return false;
+    }
+

     // notify the parent keeping track of focus for the kbd navigation
     // purposes that we got it
     wxChildFocusEvent eventFocus((wxWindow *)this);
     // notify the parent keeping track of focus for the kbd navigation
     // purposes that we got it
     wxChildFocusEvent eventFocus((wxWindow *)this);


@@ -3342,7 +3373,7 @@ bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
     // after the control gets to process it from EN_FOCUS handler
     if ( wxDynamicCastThis(wxTextCtrl) )
     {
     // after the control gets to process it from EN_FOCUS handler
     if ( wxDynamicCastThis(wxTextCtrl) )
     {

-        return FALSE;
+        return false;

     }
 #endif // wxUSE_TEXTCTRL
 
     }
 #endif // wxUSE_TEXTCTRL
 


@@ -3371,7 +3402,7 @@ bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
     wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
     if ( ctrl )
     {
     wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
     if ( ctrl )
     {

-        return FALSE;
+        return false;

     }
 #endif
 
     }
 #endif
 


@@ -3379,7 +3410,7 @@ bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
     // only cause problems if the event handler tries to access the object.
     if ( m_isBeingDeleted )
     {
     // only cause problems if the event handler tries to access the object.
     if ( m_isBeingDeleted )
     {

-        return FALSE;
+        return false;

     }
 
     wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
     }
 
     wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);


@@ -3398,7 +3429,7 @@ bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
 bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
 {
     wxShowEvent event(GetId(), show);
 bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
 {
     wxShowEvent event(GetId(), show);

-    event.m_eventObject = this;
+    event.SetEventObject(this);

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


@@ -3406,7 +3437,7 @@ bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
 bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
 {
     wxInitDialogEvent event(GetId());
 bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
 {
     wxInitDialogEvent event(GetId());

-    event.m_eventObject = this;
+    event.SetEventObject(this);

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


@@ -3414,7 +3445,8 @@ bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
 {
 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
 {
 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)

-    return FALSE;
+    wxUnusedVar(wParam);
+    return false;

 #else // __WXMICROWIN__
     HDROP hFilesInfo = (HDROP) wParam;
 
 #else // __WXMICROWIN__
     HDROP hFilesInfo = (HDROP) wParam;
 


@@ -3440,7 +3472,7 @@ bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
     DragFinish (hFilesInfo);
 
     wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
     DragFinish (hFilesInfo);
 
     wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);

-    event.m_eventObject = this;
+    event.SetEventObject(this);

 
     POINT dropPoint;
     DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
 
     POINT dropPoint;
     DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);


@@ -3467,7 +3499,7 @@ bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
 
     if ( nHitTest != HTCLIENT )
     {
 
     if ( nHitTest != HTCLIENT )
     {

-        return FALSE;
+        return false;

     }
 
     HCURSOR hcursor = 0;
     }
 
     HCURSOR hcursor = 0;


@@ -3528,12 +3560,12 @@ bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
         ::SetCursor(hcursor);
 
         // cursor set, stop here
         ::SetCursor(hcursor);
 
         // cursor set, stop here

-        return TRUE;
+        return true;

     }
 #endif // __WXMICROWIN__
 
     // pass up the window chain
     }
 #endif // __WXMICROWIN__
 
     // pass up the window chain

-    return FALSE;
+    return false;

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


@@ -3560,7 +3592,8 @@ wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
     {
         wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
 
     {
         wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
 

-        wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
+        wxCHECK_MSG( pMenuItem && pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)),
+                         false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );

 
         // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
         // the DC from being released
 
         // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
         // the DC from being released


@@ -3588,7 +3621,13 @@ wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
 #else // !wxUSE_OWNER_DRAWN
     // we may still have owner-drawn buttons internally because we have to make
     // them owner-drawn to support colour change
 #else // !wxUSE_OWNER_DRAWN
     // we may still have owner-drawn buttons internally because we have to make
     // them owner-drawn to support colour change

-    wxControl *item = wxDynamicCast(FindItem(id), wxButton);
+    wxControl *item =
+#                     if wxUSE_BUTTON
+                         wxDynamicCast(FindItem(id), wxButton)
+#                     else
+                         NULL
+#                     endif
+                    ;

 #endif // USE_OWNER_DRAWN
 
     if ( item )
 #endif // USE_OWNER_DRAWN
 
     if ( item )


@@ -3598,13 +3637,11 @@ wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
 
 #endif // wxUSE_CONTROLS
 
 
 #endif // wxUSE_CONTROLS
 

-    return FALSE;
+    return false;

 }
 
 bool
 }
 
 bool

-wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
-                              WXMEASUREITEMSTRUCT *
-                                  WXUNUSED_UNLESS_ODRAWN(itemStruct))
+wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)

 {
 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
     // is it a menu item?
 {
 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
     // is it a menu item?


@@ -3613,10 +3650,16 @@ wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
     {
         wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
 
     {
         wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
 

-        wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
+        wxCHECK_MSG( pMenuItem && pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)),
+                        false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
+
+        size_t w, h;
+        bool rc = pMenuItem->OnMeasureItem(&w, &h);

 
 

-        return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
-                                        &pMeasureStruct->itemHeight);
+        pMeasureStruct->itemWidth = w;
+        pMeasureStruct->itemHeight = h;
+
+        return rc;

     }
 
     wxControl *item = wxDynamicCast(FindItem(id), wxControl);
     }
 
     wxControl *item = wxDynamicCast(FindItem(id), wxControl);


@@ -3624,9 +3667,12 @@ wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
     {
         return item->MSWOnMeasure(itemStruct);
     }
     {
         return item->MSWOnMeasure(itemStruct);
     }

-#endif // wxUSE_OWNER_DRAWN
+#else
+    wxUnusedVar(id);
+    wxUnusedVar(itemStruct);
+#endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE

 
 

-    return FALSE;
+    return false;

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


@@ -3642,7 +3688,7 @@ bool wxWindowMSW::HandleSysColorChange()
 
     // always let the system carry on the default processing to allow the
     // native controls to react to the colours update
 
     // always let the system carry on the default processing to allow the
     // native controls to react to the colours update

-    return FALSE;
+    return false;

 }
 
 bool wxWindowMSW::HandleDisplayChange()
 }
 
 bool wxWindowMSW::HandleDisplayChange()


@@ -3653,50 +3699,24 @@ bool wxWindowMSW::HandleDisplayChange()
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 

-bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
-                              WXHDC pDC,
-                              WXHWND pWnd,
-                              WXUINT nCtlColor,
-                              WXUINT message,
-                              WXWPARAM wParam,
-                              WXLPARAM lParam)
-{

 #ifndef __WXMICROWIN__
 #ifndef __WXMICROWIN__

-    WXHBRUSH hBrush = 0;

 
 

-#ifdef __WXWINCE__
-    if (FALSE)
-#else
-    if ( nCtlColor == CTLCOLOR_DLG )
-#endif
-    {
-        hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
-    }
+bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush, WXHDC pDC, WXHWND pWnd)
+{

 #if wxUSE_CONTROLS
 #if wxUSE_CONTROLS

+    wxWindow *item = FindItemByHWND(pWnd, true);
+    if ( item )
+        *brush = item->MSWControlColor(pDC);

     else
     else

-    {
-        wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
-        if ( item )
-            hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
-    }

 #endif // wxUSE_CONTROLS
 #endif // wxUSE_CONTROLS

+        *brush = NULL;

 
 

-    if ( hBrush )
-        *brush = hBrush;
-
-    return hBrush != 0;
-#else // __WXMICROWIN__
-    return FALSE;
-#endif
+    return *brush != NULL;

 }
 
 }
 

-// Define for each class of dialog and control
-WXHBRUSH wxWindowMSW::OnCtlColor(WXHDC WXUNUSED(hDC),
-                                 WXHWND WXUNUSED(hWnd),
-                                 WXUINT WXUNUSED(nCtlColor),
-                                 WXUINT WXUNUSED(message),
-                                 WXWPARAM WXUNUSED(wParam),
-                                 WXLPARAM WXUNUSED(lParam))
+#endif // __WXMICROWIN__
+
+WXHBRUSH wxWindowMSW::MSWControlColor(WXHDC WXUNUSED(hDC))

 {
     return (WXHBRUSH)0;
 }
 {
     return (WXHBRUSH)0;
 }


@@ -3731,7 +3751,7 @@ bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
 
             // now check for the need to redraw
             if (result > 0)
 
             // now check for the need to redraw
             if (result > 0)

-                InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
+                ::InvalidateRect((HWND) hWndPalChange, NULL, TRUE);

         }
 
     }
         }
 
     }


@@ -3761,7 +3781,7 @@ bool wxWindowMSW::HandleQueryNewPalette()
     while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
     if (win->HasCustomPalette()) {
         /* realize the palette to see whether redrawing is needed */
     while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
     if (win->HasCustomPalette()) {
         /* realize the palette to see whether redrawing is needed */

-        HDC hdc = GetDC((HWND) GetHWND());
+        HDC hdc = ::GetDC((HWND) GetHWND());

         win->m_palette.SetHPALETTE( (WXHPALETTE)
              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
 
         win->m_palette.SetHPALETTE( (WXHPALETTE)
              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
 


@@ -3792,7 +3812,7 @@ void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
     if ( IsTopLevel() )
     {
         // FIXME-MT
     if ( IsTopLevel() )
     {
         // FIXME-MT

-        gs_hasStdCmap = FALSE;
+        gs_hasStdCmap = false;

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


@@ -3810,20 +3830,6 @@ void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
 
         node = node->GetNext();
     }
 
         node = node->GetNext();
     }

-
-    // update the colours we use if they were not set explicitly by the user:
-    // this must be done or OnCtlColor() would continue to use the old colours
-    if ( !m_hasFgCol )
-    {
-        m_foregroundColour = wxSystemSettings::
-                                GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
-    }
-
-    if ( !m_hasBgCol )
-    {
-        m_backgroundColour = wxSystemSettings::
-                                GetSystemColour(wxSYS_COLOUR_BTNFACE);
-    }

 }
 
 extern wxCOLORMAP *wxGetStdColourMap()
 }
 
 extern wxCOLORMAP *wxGetStdColourMap()


@@ -3833,7 +3839,7 @@ extern wxCOLORMAP *wxGetStdColourMap()
 
     if ( !gs_hasStdCmap )
     {
 
     if ( !gs_hasStdCmap )
     {

-        static bool s_coloursInit = FALSE;
+        static bool s_coloursInit = false;

 
         if ( !s_coloursInit )
         {
 
         if ( !s_coloursInit )
         {


@@ -3871,10 +3877,10 @@ extern wxCOLORMAP *wxGetStdColourMap()
                 //s_stdColours[5] = RGB(255,000,255);     // magenta
             }
 
                 //s_stdColours[5] = RGB(255,000,255);     // magenta
             }
 

-            s_coloursInit = TRUE;
+            s_coloursInit = true;

         }
 
         }
 

-        gs_hasStdCmap = TRUE;
+        gs_hasStdCmap = true;

 
         // create the colour map
 #define INIT_CMAP_ENTRY(col) \
 
         // create the colour map
 #define INIT_CMAP_ENTRY(col) \


@@ -3898,9 +3904,6 @@ extern wxCOLORMAP *wxGetStdColourMap()
 
 bool wxWindowMSW::HandlePaint()
 {
 
 bool wxWindowMSW::HandlePaint()
 {

-//    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
-//        return FALSE;
-

     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
     if ( !hRegion )
         wxLogLastError(wxT("CreateRectRgn"));
     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
     if ( !hRegion )
         wxLogLastError(wxT("CreateRectRgn"));


@@ -3940,33 +3943,6 @@ void wxWindowMSW::OnPaint(wxPaintEvent& event)
 
 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
 {
 
 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
 {

-    // Prevents flicker when dragging
-    if ( ::IsIconic(GetHwnd()) )
-        return TRUE;
-
-#if 0
-    if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
-    {
-        return FALSE;
-    }
-
-    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
-    {
-        if (wxUxThemeEngine::Get())
-        {
-            WXHTHEME hTheme = wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L"TAB");
-            if (hTheme)
-            {
-                WXURECT rect;
-                ::GetClientRect((HWND) GetHWND(), (RECT*) & rect);
-                wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme, hdc, 10 /* TABP_BODY */, 0, &rect, &rect);
-                wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme);
-                return TRUE;
-            }
-        }
-    }
-#endif
-

     wxDCTemp dc(hdc);
 
     dc.SetHDC(hdc);
     wxDCTemp dc(hdc);
 
     dc.SetHDC(hdc);


@@ -3987,28 +3963,112 @@ bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
 
 void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
 {
 
 void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
 {

-    RECT rect;
-    ::GetClientRect(GetHwnd(), &rect);
+    // standard non top level controls (i.e. except the dialogs) always erase
+    // their background themselves in HandleCtlColor() or have some control-
+    // specific ways to set the colours (common controls)
+    if ( IsOfStandardClass() && !IsTopLevel() )
+    {
+        event.Skip();
+        return;
+    }
+
+    if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM )
+    {
+        // don't skip the event here, custom background means that the app
+        // is drawing it itself in its OnPaint(), so don't draw it at all
+        // now to avoid flicker
+        return;
+    }
+

 
 

-    COLORREF ref = PALETTERGB(m_backgroundColour.Red(),
-                              m_backgroundColour.Green(),
-                              m_backgroundColour.Blue());
-    HBRUSH hBrush = ::CreateSolidBrush(ref);
+    // do default background painting
+    if ( !DoEraseBackground(*event.GetDC()) )
+    {
+        // let the system paint the background
+        event.Skip();
+    }
+}
+
+bool wxWindowMSW::DoEraseBackground(wxDC& dc)
+{
+    HBRUSH hBrush = (HBRUSH)MSWGetBgBrush(dc.GetHDC());

     if ( !hBrush )
     if ( !hBrush )

-        wxLogLastError(wxT("CreateSolidBrush"));
+        return false;

 
 

-    HDC hdc = (HDC)event.GetDC()->GetHDC();
+    RECT rc;
+    ::GetClientRect(GetHwnd(), &rc);
+    ::FillRect(GetHdcOf(dc), &rc, hBrush);

 
 

-#ifndef __WXWINCE__
-    int mode = ::SetMapMode(hdc, MM_TEXT);
-#endif
+    return true;
+}
+
+WXHBRUSH wxWindowMSW::MSWGetSolidBgBrushForChild(wxWindow *child)
+{
+    wxColour col = MSWGetBgColourForChild(child);
+    if ( col.Ok() )
+    {
+        // draw children with the same colour as the parent
+        wxBrush *brush = wxTheBrushList->FindOrCreateBrush(col, wxSOLID);

 
 

-    ::FillRect(hdc, &rect, hBrush);
-    ::DeleteObject(hBrush);
+        return (WXHBRUSH)brush->GetResourceHandle();
+    }

 
 

-#ifndef __WXWINCE__
-    ::SetMapMode(hdc, mode);
-#endif
+    return 0;
+}
+
+wxColour wxWindowMSW::MSWGetBgColourForChild(wxWindow *child)
+{
+    if ( m_hasBgCol )
+    {
+        // our background colour applies to:
+        //  1. this window itself, always
+        //  2. all children unless the colour is "not inheritable"
+        //  3. immediate transparent children which should show the same
+        //     background as we do, but not for transparent grandchildren
+        //     which use the background of their immediate parent instead
+        if ( m_inheritBgCol ||
+                child == this ||
+                    (child->HasTransparentBackground() &&
+                        child->GetParent() == this) )
+        {
+            return GetBackgroundColour();
+        }
+    }
+
+    return wxNullColour;
+}
+
+WXHBRUSH wxWindowMSW::MSWGetBgBrushForSelf(wxWindow *parent, WXHDC hDC)
+{
+    return parent->MSWGetBgBrushForChild(hDC, (wxWindow *)this);
+}
+
+WXHBRUSH wxWindowMSW::MSWGetBgBrush(WXHDC hDC)
+{
+    for ( wxWindow *win = (wxWindow *)this; win; win = win->GetParent() )
+    {
+        WXHBRUSH hBrush = MSWGetBgBrushForSelf(win, hDC);
+        if ( hBrush )
+            return hBrush;
+
+        // background is not inherited beyond the windows which have their own
+        // fixed background such as top level windows and notebooks and for
+        // windows for which a custom colour had been explicitly set with
+        // SetOwnBackgroundColour() and so shouldn't affect its children
+        if ( win->ProvidesBackground() ||
+                (win->UseBgCol() && !win->InheritsBackgroundColour()) )
+            break;
+    }
+
+    return 0;
+}
+
+bool
+wxWindowMSW::MSWPrintChild(wxWindow * WXUNUSED(win),
+                           WXWPARAM WXUNUSED(wParam),
+                           WXLPARAM WXUNUSED(lParam))
+{
+    return false;

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


@@ -4033,7 +4093,8 @@ bool wxWindowMSW::HandleMaximize()
 
 bool wxWindowMSW::HandleMove(int x, int y)
 {
 
 bool wxWindowMSW::HandleMove(int x, int y)
 {

-    wxMoveEvent event(wxPoint(x, y), m_windowId);
+    wxPoint point(x,y);
+    wxMoveEvent event(point, m_windowId);

     event.SetEventObject(this);
 
     return GetEventHandler()->ProcessEvent(event);
     event.SetEventObject(this);
 
     return GetEventHandler()->ProcessEvent(event);


@@ -4050,16 +4111,69 @@ bool wxWindowMSW::HandleMoving(wxRect& rect)
     return rc;
 }
 
     return rc;
 }
 

-bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
-                             WXUINT WXUNUSED(flag))
+bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h), WXUINT wParam)

 {
 {

-    // don't use w and h parameters as they specify the client size while
-    // according to the docs EVT_SIZE handler is supposed to receive the total
-    // size
-    wxSizeEvent event(GetSize(), m_windowId);
-    event.SetEventObject(this);
+    // when we resize this window, its children are probably going to be
+    // repositioned as well, prepare to use DeferWindowPos() for them
+    const int numChildren = GetChildren().GetCount();
+    if ( numChildren > 1 )
+    {
+        m_hDWP = (WXHANDLE)::BeginDeferWindowPos(numChildren);
+        if ( !m_hDWP )
+        {
+            wxLogLastError(_T("BeginDeferWindowPos"));
+        }
+    }

 
 

-    return GetEventHandler()->ProcessEvent(event);
+    // update this window size
+    bool processed = false;
+    switch ( wParam )
+    {
+        default:
+            wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
+            // fall through nevertheless
+
+        case SIZE_MAXHIDE:
+        case SIZE_MAXSHOW:
+            // we're not interested in these messages at all
+            break;
+
+        case SIZE_MINIMIZED:
+            processed = HandleMinimize();
+            break;
+
+        case SIZE_MAXIMIZED:
+            /* processed = */ HandleMaximize();
+            // fall through to send a normal size event as well
+
+        case SIZE_RESTORED:
+            // don't use w and h parameters as they specify the client size
+            // while according to the docs EVT_SIZE handler is supposed to
+            // receive the total size
+            wxSizeEvent event(GetSize(), m_windowId);
+            event.SetEventObject(this);
+
+            processed = GetEventHandler()->ProcessEvent(event);
+    }
+
+    // and finally change the positions of all child windows at once
+    if ( m_hDWP )
+    {
+        // reset m_hDWP to NULL so that child windows don't try to use our
+        // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
+        // happen anyhow normally but who knows what weird flow of control we
+        // may have depending on what the users EVT_SIZE handler does...)
+        HDWP hDWP = (HDWP)m_hDWP;
+        m_hDWP = NULL;
+
+        // do put all child controls in place at once
+        if ( !::EndDeferWindowPos(hDWP) )
+        {
+            wxLogLastError(_T("EndDeferWindowPos"));
+        }
+    }
+
+    return processed;

 }
 
 bool wxWindowMSW::HandleSizing(wxRect& rect)
 }
 
 bool wxWindowMSW::HandleSizing(wxRect& rect)


@@ -4076,39 +4190,40 @@ bool wxWindowMSW::HandleSizing(wxRect& rect)
 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
 {
 #ifdef __WXWINCE__
 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
 {
 #ifdef __WXWINCE__

-    return FALSE;
+    wxUnusedVar(mmInfo);
+    return false;

 #else
     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
 
 #else
     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
 

-    bool rc = FALSE;
+    bool rc = false;

 
     int minWidth = GetMinWidth(),
         minHeight = GetMinHeight(),
         maxWidth = GetMaxWidth(),
         maxHeight = GetMaxHeight();
 
 
     int minWidth = GetMinWidth(),
         minHeight = GetMinHeight(),
         maxWidth = GetMaxWidth(),
         maxHeight = GetMaxHeight();
 

-    if ( minWidth != -1 )
+    if ( minWidth != wxDefaultCoord )

     {
         info->ptMinTrackSize.x = minWidth;
     {
         info->ptMinTrackSize.x = minWidth;

-        rc = TRUE;
+        rc = true;

     }
 
     }
 

-    if ( minHeight != -1 )
+    if ( minHeight != wxDefaultCoord )

     {
         info->ptMinTrackSize.y = minHeight;
     {
         info->ptMinTrackSize.y = minHeight;

-        rc = TRUE;
+        rc = true;

     }
 
     }
 

-    if ( maxWidth != -1 )
+    if ( maxWidth != wxDefaultCoord )

     {
         info->ptMaxTrackSize.x = maxWidth;
     {
         info->ptMaxTrackSize.x = maxWidth;

-        rc = TRUE;
+        rc = true;

     }
 
     }
 

-    if ( maxHeight != -1 )
+    if ( maxHeight != wxDefaultCoord )

     {
         info->ptMaxTrackSize.y = maxHeight;
     {
         info->ptMaxTrackSize.y = maxHeight;

-        rc = TRUE;
+        rc = true;

     }
 
     return rc;
     }
 
     return rc;


@@ -4168,36 +4283,28 @@ bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
 
         return GetEventHandler()->ProcessEvent(event);
     }
 
         return GetEventHandler()->ProcessEvent(event);
     }

-#if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)

     else
     {
     else
     {

+#if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)

         // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
         // notifications to its parent which we want to reflect back to
         // wxSpinCtrl
         wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
         if ( spin && spin->ProcessTextCommand(cmd, id) )
         // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
         // notifications to its parent which we want to reflect back to
         // wxSpinCtrl
         wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
         if ( spin && spin->ProcessTextCommand(cmd, id) )

-            return TRUE;
-    }
+            return true;

 #endif // wxUSE_SPINCTRL
 
 #endif // wxUSE_SPINCTRL
 

-    return FALSE;
-}
-
-bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
-{
-#ifndef __WXWINCE__
-    // 4 bits are reserved
-    switch ( wParam & 0xFFFFFFF0 )
-    {
-        case SC_MAXIMIZE:
-            return HandleMaximize();
-
-        case SC_MINIMIZE:
-            return HandleMinimize();
-    }
+#if wxUSE_CHOICE && defined(__SMARTPHONE__)
+        // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
+        // notifications to its parent which we want to reflect back to
+        // wxChoice
+        wxChoice *choice = wxChoice::GetChoiceForListBox(control);
+        if ( choice && choice->MSWCommand(cmd, id) )
+            return true;

 #endif
 #endif

+    }

 
 

-    return FALSE;
+    return false;

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


@@ -4218,13 +4325,13 @@ void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
     event.m_leftDown = (flags & MK_LBUTTON) != 0;
     event.m_middleDown = (flags & MK_MBUTTON) != 0;
     event.m_rightDown = (flags & MK_RBUTTON) != 0;
     event.m_leftDown = (flags & MK_LBUTTON) != 0;
     event.m_middleDown = (flags & MK_MBUTTON) != 0;
     event.m_rightDown = (flags & MK_RBUTTON) != 0;

- //   event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
-    // Returns different negative values on WinME and WinNT,
-    // so simply test for negative value.

     event.m_altDown = ::GetKeyState(VK_MENU) < 0;
 
     event.m_altDown = ::GetKeyState(VK_MENU) < 0;
 

+#ifndef __WXWINCE__

     event.SetTimestamp(::GetMessageTime());
     event.SetTimestamp(::GetMessageTime());

-    event.m_eventObject = this;
+#endif
+
+    event.SetEventObject(this);

     event.SetId(GetId());
 
 #if wxUSE_MOUSEEVENT_HACK
     event.SetId(GetId());
 
 #if wxUSE_MOUSEEVENT_HACK


@@ -4301,7 +4408,7 @@ static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //
 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
 {
     // the mouse events take consecutive IDs from WM_MOUSEFIRST to
 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
 {
     // the mouse events take consecutive IDs from WM_MOUSEFIRST to

-    // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
+    // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST

     // from the message id and take the value in the table to get wxWin event
     // id
     static const wxEventType eventsMouse[] =
     // from the message id and take the value in the table to get wxWin event
     // id
     static const wxEventType eventsMouse[] =


@@ -4335,7 +4442,18 @@ bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
         if ( !HasCapture() || IsMouseInWindow() )
         {
             // Generate an ENTER event
         if ( !HasCapture() || IsMouseInWindow() )
         {
             // Generate an ENTER event

-            m_mouseInWindow = TRUE;
+            m_mouseInWindow = true;
+
+#ifdef HAVE_TRACKMOUSEEVENT
+            WinStruct<TRACKMOUSEEVENT> trackinfo;
+
+            trackinfo.dwFlags = TME_LEAVE;
+            trackinfo.hwndTrack = GetHwnd();
+
+            // Use the commctrl.h _TrackMouseEvent(), which will call the real
+            // TrackMouseEvent() if available or emulate it
+            _TrackMouseEvent(&trackinfo);
+#endif // HAVE_TRACKMOUSEEVENT

 
             wxMouseEvent event(wxEVT_ENTER_WINDOW);
             InitMouseEvent(event, x, y, flags);
 
             wxMouseEvent event(wxEVT_ENTER_WINDOW);
             InitMouseEvent(event, x, y, flags);


@@ -4355,7 +4473,7 @@ bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
     {
         m_lastMouseEvent = wxEVT_MOTION;
 
     {
         m_lastMouseEvent = wxEVT_MOTION;
 

-        return FALSE;
+        return false;

     }
 #endif // wxUSE_MOUSEEVENT_HACK
 
     }
 #endif // wxUSE_MOUSEEVENT_HACK
 


@@ -4391,14 +4509,49 @@ bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
     event.m_linesPerAction = s_linesPerRotation;
     return GetEventHandler()->ProcessEvent(event);
 
     event.m_linesPerAction = s_linesPerRotation;
     return GetEventHandler()->ProcessEvent(event);
 

-#else
-    (void) wParam;
-    (void) lParam;
+#else // !wxUSE_MOUSEWHEEL
+    wxUnusedVar(wParam);
+    wxUnusedVar(lParam);

 
 

-    return FALSE;
-#endif
+    return false;
+#endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL

 }
 
 }
 

+void wxWindowMSW::GenerateMouseLeave()
+{
+    m_mouseInWindow = false;
+
+    int state = 0;
+    if ( wxIsShiftDown() )
+        state |= MK_SHIFT;
+    if ( wxIsCtrlDown() )
+        state |= MK_CONTROL;
+
+    // Only the high-order bit should be tested
+    if ( GetKeyState( VK_LBUTTON ) & (1<<15) )
+        state |= MK_LBUTTON;
+    if ( GetKeyState( VK_MBUTTON ) & (1<<15) )
+        state |= MK_MBUTTON;
+    if ( GetKeyState( VK_RBUTTON ) & (1<<15) )
+        state |= MK_RBUTTON;
+
+    POINT pt;
+    if ( !::GetCursorPos(&pt) )
+    {
+        wxLogLastError(_T("GetCursorPos"));
+    }
+
+    // we need to have client coordinates here for symmetry with
+    // wxEVT_ENTER_WINDOW
+    RECT rect = wxGetWindowRect(GetHwnd());
+    pt.x -= rect.left;
+    pt.y -= rect.top;
+
+    wxMouseEvent event(wxEVT_LEAVE_WINDOW);
+    InitMouseEvent(event, pt.x, pt.y, state);
+
+    (void)GetEventHandler()->ProcessEvent(event);
+}

 
 // ---------------------------------------------------------------------------
 // keyboard handling
 
 // ---------------------------------------------------------------------------
 // keyboard handling


@@ -4417,11 +4570,16 @@ wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
     event.m_controlDown = wxIsCtrlDown();
     event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
 
     event.m_controlDown = wxIsCtrlDown();
     event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
 

-    event.m_eventObject = (wxWindow *)this; // const_cast
+    event.SetEventObject((wxWindow *)this); // const_cast

     event.m_keyCode = id;
     event.m_keyCode = id;

+#if wxUSE_UNICODE
+    event.m_uniChar = (wxChar) wParam;
+#endif

     event.m_rawCode = (wxUint32) wParam;
     event.m_rawFlags = (wxUint32) lParam;
     event.m_rawCode = (wxUint32) wParam;
     event.m_rawFlags = (wxUint32) lParam;

+#ifndef __WXWINCE__

     event.SetTimestamp(::GetMessageTime());
     event.SetTimestamp(::GetMessageTime());

+#endif

 
     // translate the position to client coords
     POINT pt;
 
     // translate the position to client coords
     POINT pt;


@@ -4437,7 +4595,7 @@ wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
     return event;
 }
 
     return event;
 }
 

-// isASCII is TRUE only when we're called from WM_CHAR handler and not from
+// isASCII is true only when we're called from WM_CHAR handler and not from

 // WM_KEYDOWN one
 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
 {
 // WM_KEYDOWN one
 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
 {


@@ -4446,7 +4604,7 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
     {
         // If 1 -> 26, translate to either special keycode or just set
         // ctrlDown.  IOW, Ctrl-C should result in keycode == 3 and
     {
         // If 1 -> 26, translate to either special keycode or just set
         // ctrlDown.  IOW, Ctrl-C should result in keycode == 3 and

-        // ControlDown() == TRUE.
+        // ControlDown() == true.

         id = wParam;
         if ( (id > 0) && (id < 27) )
         {
         id = wParam;
         if ( (id > 0) && (id < 27) )
         {


@@ -4465,19 +4623,19 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
                     break;
 
                 default:
                     break;
 
                 default:

-                    //ctrlDown = TRUE;
+                    //ctrlDown = true;

                     break;
             }
         }
     }
     else // we're called from WM_KEYDOWN
     {
                     break;
             }
         }
     }
     else // we're called from WM_KEYDOWN
     {

-        id = wxCharCodeMSWToWX(wParam);
+        id = wxCharCodeMSWToWX(wParam, lParam);

         if ( id == 0 )
         {
             // it's ASCII and will be processed here only when called from
         if ( id == 0 )
         {
             // it's ASCII and will be processed here only when called from

-            // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
-            return FALSE;
+            // WM_CHAR (i.e. when isASCII = true), don't process it now
+            return false;

         }
     }
 
         }
     }
 


@@ -4493,7 +4651,7 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
             (id >= 32 && id < 256) )
     {
         event.m_controlDown =
             (id >= 32 && id < 256) )
     {
         event.m_controlDown =

-        event.m_altDown = FALSE;
+        event.m_altDown = false;

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


@@ -4501,7 +4659,7 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
 
 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
 {
 
 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
 {

-    int id = wxCharCodeMSWToWX(wParam);
+    int id = wxCharCodeMSWToWX(wParam, lParam);

 
     if ( !id )
     {
 
     if ( !id )
     {


@@ -4514,16 +4672,16 @@ bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
         if ( GetEventHandler()->ProcessEvent(event) )
         {
         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
         if ( GetEventHandler()->ProcessEvent(event) )
         {

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

 }
 
 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
 {
 }
 
 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
 {

-    int id = wxCharCodeMSWToWX(wParam);
+    int id = wxCharCodeMSWToWX(wParam, lParam);

 
     if ( !id )
     {
 
     if ( !id )
     {


@@ -4535,10 +4693,10 @@ bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
     {
         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
         if ( GetEventHandler()->ProcessEvent(event) )
     {
         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
         if ( GetEventHandler()->ProcessEvent(event) )

-            return TRUE;
+            return true;

     }
 
     }
 

-    return FALSE;
+    return false;

 }
 
 int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
 }
 
 int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)


@@ -4579,7 +4737,7 @@ int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
                         // FIXME-UNICODE: this comparison doesn't risk to work
                         // for non ASCII accelerator characters I'm afraid, but
                         // what can we do?
                         // FIXME-UNICODE: this comparison doesn't risk to work
                         // for non ASCII accelerator characters I'm afraid, but
                         // what can we do?

-                        if ( wxToupper(*p) == chAccel )
+                        if ( (wchar_t)wxToupper(*p) == (wchar_t)chAccel )

                         {
                             return i;
                         }
                         {
                             return i;
                         }


@@ -4599,6 +4757,9 @@ int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
             wxLogLastError(_T("GetMenuItemInfo"));
         }
     }
             wxLogLastError(_T("GetMenuItemInfo"));
         }
     }

+#else
+    wxUnusedVar(chAccel);
+    wxUnusedVar(lParam);

 #endif
     return wxNOT_FOUND;
 }
 #endif
     return wxNOT_FOUND;
 }


@@ -4678,7 +4839,7 @@ bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
         default:
             wxFAIL_MSG(wxT("no such joystick event"));
 
         default:
             wxFAIL_MSG(wxT("no such joystick event"));
 

-            return FALSE;
+            return false;

     }
 
     wxJoystickEvent event(eventType, buttons, joystick, change);
     }
 
     wxJoystickEvent event(eventType, buttons, joystick, change);


@@ -4687,7 +4848,11 @@ bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
 
     return GetEventHandler()->ProcessEvent(event);
 #else
 
     return GetEventHandler()->ProcessEvent(event);
 #else

-    return FALSE;
+    wxUnusedVar(msg);
+    wxUnusedVar(x);
+    wxUnusedVar(y);
+    wxUnusedVar(flags);
+    return false;

 #endif
 }
 
 #endif
 }
 


@@ -4698,7 +4863,7 @@ bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
                               WXWORD pos, WXHWND control)
 {
 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
                               WXWORD pos, WXHWND control)
 {

-    if ( control )
+    if ( control && control != m_hWnd ) // Prevent infinite recursion

     {
         wxWindow *child = wxFindWinFromHandle(control);
         if ( child )
     {
         wxWindow *child = wxFindWinFromHandle(control);
         if ( child )


@@ -4708,32 +4873,32 @@ bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
     wxScrollWinEvent event;
     event.SetPosition(pos);
     event.SetOrientation(orientation);
     wxScrollWinEvent event;
     event.SetPosition(pos);
     event.SetOrientation(orientation);

-    event.m_eventObject = this;
+    event.SetEventObject(this);

 
     switch ( wParam )
     {
     case SB_TOP:
 
     switch ( wParam )
     {
     case SB_TOP:

-        event.m_eventType = wxEVT_SCROLLWIN_TOP;
+        event.SetEventType(wxEVT_SCROLLWIN_TOP);

         break;
 
     case SB_BOTTOM:
         break;
 
     case SB_BOTTOM:

-        event.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
+        event.SetEventType(wxEVT_SCROLLWIN_BOTTOM);

         break;
 
     case SB_LINEUP:
         break;
 
     case SB_LINEUP:

-        event.m_eventType = wxEVT_SCROLLWIN_LINEUP;
+        event.SetEventType(wxEVT_SCROLLWIN_LINEUP);

         break;
 
     case SB_LINEDOWN:
         break;
 
     case SB_LINEDOWN:

-        event.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
+        event.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);

         break;
 
     case SB_PAGEUP:
         break;
 
     case SB_PAGEUP:

-        event.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
+        event.SetEventType(wxEVT_SCROLLWIN_PAGEUP);

         break;
 
     case SB_PAGEDOWN:
         break;
 
     case SB_PAGEDOWN:

-        event.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
+        event.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);

         break;
 
     case SB_THUMBPOSITION:
         break;
 
     case SB_THUMBPOSITION:


@@ -4759,13 +4924,13 @@ bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
             event.SetPosition(scrollInfo.nTrackPos);
         }
 
             event.SetPosition(scrollInfo.nTrackPos);
         }
 

-        event.m_eventType = wParam == SB_THUMBPOSITION
+        event.SetEventType( wParam == SB_THUMBPOSITION

                                 ? wxEVT_SCROLLWIN_THUMBRELEASE
                                 ? wxEVT_SCROLLWIN_THUMBRELEASE

-                                : wxEVT_SCROLLWIN_THUMBTRACK;
+                                : wxEVT_SCROLLWIN_THUMBTRACK );

         break;
 
     default:
         break;
 
     default:

-        return FALSE;
+        return false;

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


@@ -4775,22 +4940,20 @@ bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
 // global functions
 // ===========================================================================
 
 // global functions
 // ===========================================================================
 

-void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
+void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font)

 {
     TEXTMETRIC tm;
     HDC dc = ::GetDC((HWND) wnd);
 {
     TEXTMETRIC tm;
     HDC dc = ::GetDC((HWND) wnd);

-    HFONT fnt =0;

     HFONT was = 0;
     HFONT was = 0;

-    if ( the_font )
-    {
-        //    the_font->UseResource();
-        //    the_font->RealizeResource();
-        fnt = (HFONT)((wxFont *)the_font)->GetResourceHandle(); // const_cast
-        if ( fnt )
-            was = (HFONT) SelectObject(dc,fnt);
-    }
+
+    //    the_font.UseResource();
+    //    the_font.RealizeResource();
+    HFONT fnt = (HFONT)the_font.GetResourceHandle(); // const_cast
+    if ( fnt )
+        was = (HFONT) SelectObject(dc,fnt);
+

     GetTextMetrics(dc, &tm);
     GetTextMetrics(dc, &tm);

-    if ( the_font && fnt && was )
+    if ( fnt && was )

     {
         SelectObject(dc,was);
     }
     {
         SelectObject(dc,was);
     }


@@ -4801,13 +4964,12 @@ void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
     if ( y )
         *y = tm.tmHeight + tm.tmExternalLeading;
 
     if ( y )
         *y = tm.tmHeight + tm.tmExternalLeading;
 

-    //  if ( the_font )
-    //    the_font->ReleaseResource();
+    //   the_font.ReleaseResource();

 }
 
 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
 }
 
 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.

-int wxCharCodeMSWToWX(int keySym)
+int wxCharCodeMSWToWX(int keySym, WXLPARAM lParam)

 {
     int id;
     switch (keySym)
 {
     int id;
     switch (keySym)


@@ -4816,10 +4978,9 @@ int wxCharCodeMSWToWX(int keySym)
         case VK_BACK:       id = WXK_BACK; break;
         case VK_TAB:        id = WXK_TAB; break;
         case VK_CLEAR:      id = WXK_CLEAR; break;
         case VK_BACK:       id = WXK_BACK; break;
         case VK_TAB:        id = WXK_TAB; break;
         case VK_CLEAR:      id = WXK_CLEAR; break;

-        case VK_RETURN:     id = WXK_RETURN; break;

         case VK_SHIFT:      id = WXK_SHIFT; break;
         case VK_CONTROL:    id = WXK_CONTROL; break;
         case VK_SHIFT:      id = WXK_SHIFT; break;
         case VK_CONTROL:    id = WXK_CONTROL; break;

-        case VK_MENU :      id = WXK_MENU; break;
+        case VK_MENU :      id = WXK_ALT; break;

         case VK_PAUSE:      id = WXK_PAUSE; break;
         case VK_CAPITAL:    id = WXK_CAPITAL; break;
         case VK_SPACE:      id = WXK_SPACE; break;
         case VK_PAUSE:      id = WXK_PAUSE; break;
         case VK_CAPITAL:    id = WXK_CAPITAL; break;
         case VK_SPACE:      id = WXK_SPACE; break;


@@ -4880,6 +5041,8 @@ int wxCharCodeMSWToWX(int keySym)
         case VK_NUMLOCK:    id = WXK_NUMLOCK; break;
         case VK_SCROLL:     id = WXK_SCROLL; break;
 
         case VK_NUMLOCK:    id = WXK_NUMLOCK; break;
         case VK_SCROLL:     id = WXK_SCROLL; break;
 

+        // the mapping for these keys may be incorrect on non-US keyboards so
+        // maybe we shouldn't map them to ASCII values at all

         case VK_OEM_1:      id = ';'; break;
         case VK_OEM_PLUS:   id = '+'; break;
         case VK_OEM_COMMA:  id = ','; break;
         case VK_OEM_1:      id = ';'; break;
         case VK_OEM_PLUS:   id = '+'; break;
         case VK_OEM_COMMA:  id = ','; break;


@@ -4898,6 +5061,13 @@ int wxCharCodeMSWToWX(int keySym)
         case VK_APPS:       id = WXK_WINDOWS_MENU; break;
 #endif // VK_APPS defined
 
         case VK_APPS:       id = WXK_WINDOWS_MENU; break;
 #endif // VK_APPS defined
 

+        case VK_RETURN:
+            // the same key is sent for both the "return" key on the main
+            // keyboard and the numeric keypad but we want to distinguish
+            // between them: we do this using the "extended" bit (24) of lParam
+            id = lParam & (1 << 24) ? WXK_NUMPAD_ENTER : WXK_RETURN;
+            break;
+

         default:
             id = 0;
     }
         default:
             id = 0;
     }


@@ -4905,18 +5075,19 @@ int wxCharCodeMSWToWX(int keySym)
     return id;
 }
 
     return id;
 }
 

-int wxCharCodeWXToMSW(int id, bool *isVirtual)
+WXWORD wxCharCodeWXToMSW(int id, bool *isVirtual)

 {
 {

-    *isVirtual = TRUE;
-    int keySym = 0;
+    *isVirtual = true;
+    WXWORD keySym;

     switch (id)
     {
     case WXK_CANCEL:    keySym = VK_CANCEL; break;
     case WXK_CLEAR:     keySym = VK_CLEAR; break;
     case WXK_SHIFT:     keySym = VK_SHIFT; break;
     case WXK_CONTROL:   keySym = VK_CONTROL; break;
     switch (id)
     {
     case WXK_CANCEL:    keySym = VK_CANCEL; break;
     case WXK_CLEAR:     keySym = VK_CLEAR; break;
     case WXK_SHIFT:     keySym = VK_SHIFT; break;
     case WXK_CONTROL:   keySym = VK_CONTROL; break;

-    case WXK_MENU :     keySym = VK_MENU; break;
+    case WXK_ALT:       keySym = VK_MENU; break;

     case WXK_PAUSE:     keySym = VK_PAUSE; break;
     case WXK_PAUSE:     keySym = VK_PAUSE; break;

+    case WXK_CAPITAL:   keySym = VK_CAPITAL; break;

     case WXK_PRIOR:     keySym = VK_PRIOR; break;
     case WXK_NEXT :     keySym = VK_NEXT; break;
     case WXK_END:       keySym = VK_END; break;
     case WXK_PRIOR:     keySym = VK_PRIOR; break;
     case WXK_NEXT :     keySym = VK_NEXT; break;
     case WXK_END:       keySym = VK_END; break;


@@ -4974,14 +5145,48 @@ int wxCharCodeWXToMSW(int id, bool *isVirtual)
     case WXK_SCROLL:    keySym = VK_SCROLL; break;
     default:
         {
     case WXK_SCROLL:    keySym = VK_SCROLL; break;
     default:
         {

-            *isVirtual = FALSE;
-            keySym = id;
+            *isVirtual = false;
+            keySym = (WORD)id;

             break;
         }
     }
     return keySym;
 }
 
             break;
         }
     }
     return keySym;
 }
 

+bool wxGetKeyState(wxKeyCode key)
+{
+    bool bVirtual;
+
+    wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
+        WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));
+
+//High order with GetAsyncKeyState only available on WIN32
+#ifdef __WIN32__
+    //If the requested key is a LED key, return
+    //true if the led is pressed
+    if (key == WXK_NUMLOCK ||
+        key == WXK_CAPITAL ||
+        key == WXK_SCROLL)
+    {
+#endif
+        //low order bit means LED is highlighted,
+        //high order means key is down
+        //Here, for compat with other ports we want both
+        return GetKeyState( wxCharCodeWXToMSW(key, &bVirtual) ) != 0;
+
+#ifdef __WIN32__
+    }
+    else
+    {
+        //normal key
+        //low order bit means key pressed since last call
+        //high order means key is down
+        //We want only the high order bit - the key may not be down if only low order
+        return ( GetAsyncKeyState( wxCharCodeWXToMSW(key, &bVirtual) ) & (1<<15) ) != 0;
+    }
+#endif
+}
+

 wxWindow *wxGetActiveWindow()
 {
     HWND hWnd = GetActiveWindow();
 wxWindow *wxGetActiveWindow()
 {
     HWND hWnd = GetActiveWindow();


@@ -5011,7 +5216,7 @@ extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
             // do it as well, win would be already non NULL
             if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
             {
             // do it as well, win would be already non NULL
             if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
             {

-                win = (wxWindow *)::GetWindowLong(hwnd, GWL_USERDATA);
+                win = (wxWindow *)wxGetWindowUserData(hwnd);

             }
             //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
 #endif // wxUSE_RADIOBOX
             }
             //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
 #endif // wxUSE_RADIOBOX


@@ -5084,19 +5289,20 @@ wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
     DWORD hiWord = HIWORD(lParam);
     if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
     {
     DWORD hiWord = HIWORD(lParam);
     if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
     {

-        int id = wxCharCodeMSWToWX(wParam);
+        int id = wxCharCodeMSWToWX(wParam, lParam);

         if ( id != 0 )
         {
             wxKeyEvent event(wxEVT_CHAR_HOOK);
             if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
         if ( id != 0 )
         {
             wxKeyEvent event(wxEVT_CHAR_HOOK);
             if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )

-                event.m_altDown = TRUE;
+                event.m_altDown = true;

 
 

-            event.m_eventObject = NULL;
+            event.SetEventObject(NULL);

             event.m_keyCode = id;
             event.m_shiftDown = wxIsShiftDown();
             event.m_controlDown = wxIsCtrlDown();
             event.m_keyCode = id;
             event.m_shiftDown = wxIsShiftDown();
             event.m_controlDown = wxIsCtrlDown();

+#ifndef __WXWINCE__

             event.SetTimestamp(::GetMessageTime());
             event.SetTimestamp(::GetMessageTime());

-
+#endif

             wxWindow *win = wxGetActiveWindow();
             wxEvtHandler *handler;
             if ( win )
             wxWindow *win = wxGetActiveWindow();
             wxEvtHandler *handler;
             if ( win )


@@ -5107,7 +5313,7 @@ wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
             else
             {
                 handler = wxTheApp;
             else
             {
                 handler = wxTheApp;

-                event.SetId(-1);
+                event.SetId(wxID_ANY);

             }
 
             if ( handler && handler->ProcessEvent(event) )
             }
 
             if ( handler && handler->ProcessEvent(event) )


@@ -5535,26 +5741,6 @@ const char *wxGetMessageName(int message)
 }
 #endif //__WXDEBUG__
 
 }
 #endif //__WXDEBUG__
 

-static void TranslateKbdEventToMouse(wxWindowMSW *win,
-                                     int *x, int *y, WPARAM *flags)
-{
-    // construct the key mask
-    WPARAM& fwKeys = *flags;
-
-    fwKeys = MK_RBUTTON;
-    if ( wxIsCtrlDown() )
-        fwKeys |= MK_CONTROL;
-    if ( wxIsShiftDown() )
-        fwKeys |= MK_SHIFT;
-
-    // simulate right mouse button click
-    DWORD dwPos = ::GetMessagePos();
-    *x = GET_X_LPARAM(dwPos);
-    *y = GET_Y_LPARAM(dwPos);
-
-    win->ScreenToClient(x, y);
-}
-

 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
 {
     // prepare the DC
 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
 {
     // prepare the DC


@@ -5625,6 +5811,25 @@ wxPoint wxGetMousePosition()
 
 #if wxUSE_HOTKEY
 
 
 #if wxUSE_HOTKEY
 

+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+static void WinCEUnregisterHotKey(int modifiers, int id)
+{
+    // Register hotkeys for the hardware buttons
+    HINSTANCE hCoreDll;
+    typedef BOOL (WINAPI *UnregisterFunc1Proc)(UINT, UINT);
+
+    UnregisterFunc1Proc procUnregisterFunc;
+    hCoreDll = LoadLibrary(_T("coredll.dll"));
+    if (hCoreDll)
+    {
+        procUnregisterFunc = (UnregisterFunc1Proc)GetProcAddress(hCoreDll, _T("UnregisterFunc1"));
+        if (procUnregisterFunc)
+            procUnregisterFunc(modifiers, id);
+        FreeLibrary(hCoreDll);
+    }
+}
+#endif
+

 bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
 {
     UINT win_modifiers=0;
 bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
 {
     UINT win_modifiers=0;


@@ -5637,28 +5842,40 @@ bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
     if ( modifiers & wxMOD_WIN )
         win_modifiers |= MOD_WIN;
 
     if ( modifiers & wxMOD_WIN )
         win_modifiers |= MOD_WIN;
 

+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+    // Required for PPC and Smartphone hardware buttons
+    if (keycode >= WXK_SPECIAL1 && keycode <= WXK_SPECIAL20)
+        WinCEUnregisterHotKey(win_modifiers, hotkeyId);
+#endif
+

     if ( !::RegisterHotKey(GetHwnd(), hotkeyId, win_modifiers, keycode) )
     {
         wxLogLastError(_T("RegisterHotKey"));
 
     if ( !::RegisterHotKey(GetHwnd(), hotkeyId, win_modifiers, keycode) )
     {
         wxLogLastError(_T("RegisterHotKey"));
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
 {
 }
 
 bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
 {

+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+    WinCEUnregisterHotKey(MOD_WIN, hotkeyId);
+#endif
+

     if ( !::UnregisterHotKey(GetHwnd(), hotkeyId) )
     {
         wxLogLastError(_T("UnregisterHotKey"));
 
     if ( !::UnregisterHotKey(GetHwnd(), hotkeyId) )
     {
         wxLogLastError(_T("UnregisterHotKey"));
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 }
 

+#if wxUSE_ACCEL
+

 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
 {
     int hotkeyId = wParam;
 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
 {
     int hotkeyId = wParam;


@@ -5675,5 +5892,103 @@ bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 

+#endif // wxUSE_ACCEL
+

 #endif // wxUSE_HOTKEY
 
 #endif // wxUSE_HOTKEY
 

+// Not tested under WinCE
+#ifndef __WXWINCE__
+
+// this class installs a message hook which really wakes up our idle processing
+// each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
+// sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
+// being dragged or even inside ::MessageBox()) and so don't control message
+// dispatching otherwise
+class wxIdleWakeUpModule : public wxModule
+{
+public:
+    virtual bool OnInit()
+    {
+        ms_hMsgHookProc = ::SetWindowsHookEx
+                            (
+                             WH_GETMESSAGE,
+                             &wxIdleWakeUpModule::MsgHookProc,
+                             NULL,
+                             GetCurrentThreadId()
+                            );
+
+        if ( !ms_hMsgHookProc )
+        {
+            wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    virtual void OnExit()
+    {
+        ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc);
+    }
+
+    static LRESULT CALLBACK MsgHookProc(int nCode, WPARAM wParam, LPARAM lParam)
+    {
+        MSG *msg = (MSG*)lParam;
+
+        // only process the message if it is actually going to be removed from
+        // the message queue, this prevents that the same event from being
+        // processed multiple times if now someone just called PeekMessage()
+        if ( msg->message == WM_NULL && wParam == PM_REMOVE )
+        {
+            wxTheApp->ProcessPendingEvents();
+        }
+
+        return CallNextHookEx(ms_hMsgHookProc, nCode, wParam, lParam);
+    };
+
+private:
+    static HHOOK ms_hMsgHookProc;
+
+    DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule)
+};
+
+HHOOK wxIdleWakeUpModule::ms_hMsgHookProc = 0;
+
+IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule, wxModule)
+
+#endif // __WXWINCE__
+
+#ifdef __WXWINCE__
+
+#if wxUSE_STATBOX
+static void wxAdjustZOrder(wxWindow* parent)
+{
+    if (parent->IsKindOf(CLASSINFO(wxStaticBox)))
+    {
+        // Set the z-order correctly
+        SetWindowPos((HWND) parent->GetHWND(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+    }
+
+    wxWindowList::compatibility_iterator current = parent->GetChildren().GetFirst();
+    while (current)
+    {
+        wxWindow *childWin = current->GetData();
+        wxAdjustZOrder(childWin);
+        current = current->GetNext();
+    }
+}
+#endif
+
+// We need to adjust the z-order of static boxes in WinCE, to
+// make 'contained' controls visible
+void wxWindowMSW::OnInitDialog( wxInitDialogEvent& event )
+{
+#if wxUSE_STATBOX
+    wxAdjustZOrder(this);
+#endif
+
+    event.Skip();
+}
+#endif
+