]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/window.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
implemented ScrollLines/Pages; fixed bug in Thaw()
[wxWidgets.git] / src / msw / window.cpp
diff --git a/src/msw/window.cpp b/src/msw/window.cpp
index 184d7da24b96da2eece9c6c087d35d04126f95c0..b3a276a34a3967c3fd63985e7fbefd4eef8e4734 100644 (file)
--- a/src/msw/window.cpp
+++ b/src/msw/window.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        windows.cpp
+// Name:        src/msw/windows.cpp
 // Purpose:     wxWindow
 // Author:      Julian Smart
 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
 // Purpose:     wxWindow
 // Author:      Julian Smart
 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
@@ -47,8 +47,7 @@
     #include "wx/button.h"
     #include "wx/msgdlg.h"
     #include "wx/settings.h"
     #include "wx/button.h"
     #include "wx/msgdlg.h"
     #include "wx/settings.h"
-
-    #include <stdio.h>
+    #include "wx/statbox.h"
 #endif
 
 #if wxUSE_OWNER_DRAWN
 #endif
 
 #if wxUSE_OWNER_DRAWN
@@ -84,7 +83,7 @@
 
 #include <string.h>
 
 
 #include <string.h>
 
-#ifndef __GNUWIN32_OLD__
+#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
     #include <shellapi.h>
     #include <mmsystem.h>
 #endif
     #include <shellapi.h>
     #include <mmsystem.h>
 #endif
@@ -93,11 +92,11 @@
     #include <windowsx.h>
 #endif
 
     #include <windowsx.h>
 #endif
 
-#if !defined(__GNUWIN32_OLD__) && !defined(__TWIN32__)
+#if (!defined(__GNUWIN32_OLD__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
     #ifdef __WIN95__
         #include <commctrl.h>
     #endif
     #ifdef __WIN95__
         #include <commctrl.h>
     #endif
-#else // broken compiler
+#elif !defined(__WXMICROWIN__) // broken compiler
     #ifndef __TWIN32__
         #include "wx/msw/gnuwin32/extra.h"
     #endif
     #ifndef __TWIN32__
         #include "wx/msw/gnuwin32/extra.h"
     #endif
@@ -128,7 +127,10 @@
 // the last Windows message we got (MT-UNSAFE)
 extern MSG s_currentMsg;
 
 // the last Windows message we got (MT-UNSAFE)
 extern MSG s_currentMsg;
 
+#if wxUSE_MENUS_NATIVE
 wxMenu *wxCurrentPopupMenu = NULL;
 wxMenu *wxCurrentPopupMenu = NULL;
+#endif // wxUSE_MENUS_NATIVE
+
 extern wxList WXDLLEXPORT wxPendingDelete;
 extern const wxChar *wxCanvasClassName;
 
 extern wxList WXDLLEXPORT wxPendingDelete;
 extern const wxChar *wxCanvasClassName;
 
@@ -144,29 +146,39 @@ LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 
-void wxRemoveHandleAssociation(wxWindow *win);
-void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
+void wxRemoveHandleAssociation(wxWindowMSW *win);
+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
 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
 
 // this magical function is used to translate VK_APPS key presses to right
 // mouse clicks
-static void TranslateKbdEventToMouse(wxWindow *win, int *x, int *y, WPARAM *flags);
+static void TranslateKbdEventToMouse(wxWindowMSW *win,
+                                     int *x, int *y, WPARAM *flags);
 
 // get the text metrics for the current font
 
 // get the text metrics for the current font
-static TEXTMETRIC wxGetTextMetrics(const wxWindow *win);
+static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
+
+// check if the mouse is in the window or its child
+//static bool IsMouseInWindow(HWND hwnd);
 
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 
-IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
-
-BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
-    EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
-    EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
-    EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-    EVT_IDLE(wxWindow::OnIdle)
-    EVT_SET_FOCUS(wxWindow::OnSetFocus)
+// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
+// method
+#ifdef __WXUNIVERSAL__
+    IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW, wxWindowBase)
+#else // __WXMSW__
+    IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
+#endif // __WXUNIVERSAL__/__WXMSW__
+
+BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
+    EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
+    EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
+    EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
+    EVT_IDLE(wxWindowMSW::OnIdle)
+    EVT_SET_FOCUS(wxWindowMSW::OnSetFocus)
 END_EVENT_TABLE()
 
 // ===========================================================================
 END_EVENT_TABLE()
 
 // ===========================================================================
@@ -178,18 +190,23 @@ END_EVENT_TABLE()
 // ---------------------------------------------------------------------------
 
 // Find an item given the MS Windows id
 // ---------------------------------------------------------------------------
 
 // Find an item given the MS Windows id
-wxWindow *wxWindow::FindItem(long id) const
+wxWindow *wxWindowMSW::FindItem(long id) const
 {
 {
-    wxControl *item = wxDynamicThisCast(this, wxControl);
+#if wxUSE_CONTROLS
+    wxControl *item = wxDynamicCastThis(wxControl);
     if ( item )
     {
     if ( item )
     {
-        // i it we or one of our "internal" children?
-        if ( item->GetId() == id ||
-             (item->GetSubcontrols().Index(id) != wxNOT_FOUND) )
+        // is it we or one of our "internal" children?
+        if ( item->GetId() == id
+#ifndef __WXUNIVERSAL__
+                || (item->GetSubcontrols().Index(id) != wxNOT_FOUND)
+#endif // __WXUNIVERSAL__
+           )
         {
             return item;
         }
     }
         {
             return item;
         }
     }
+#endif // wxUSE_CONTROLS
 
     wxWindowList::Node *current = GetChildren().GetFirst();
     while (current)
 
     wxWindowList::Node *current = GetChildren().GetFirst();
     while (current)
@@ -207,7 +224,7 @@ wxWindow *wxWindow::FindItem(long id) const
 }
 
 // Find an item given the MS Windows handle
 }
 
 // Find an item given the MS Windows handle
-wxWindow *wxWindow::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
+wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
 {
     wxWindowList::Node *current = GetChildren().GetFirst();
     while (current)
 {
     wxWindowList::Node *current = GetChildren().GetFirst();
     while (current)
@@ -219,7 +236,11 @@ wxWindow *wxWindow::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
         if ( wnd )
             return wnd;
 
         if ( wnd )
             return wnd;
 
-        if ( !controlOnly || parent->IsKindOf(CLASSINFO(wxControl)) )
+        if ( !controlOnly
+#if wxUSE_CONTROLS
+                || parent->IsKindOf(CLASSINFO(wxControl))
+#endif // wxUSE_CONTROLS
+           )
         {
             wxWindow *item = current->GetData();
             if ( item->GetHWND() == hWnd )
         {
             wxWindow *item = current->GetData();
             if ( item->GetHWND() == hWnd )
@@ -237,7 +258,7 @@ wxWindow *wxWindow::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
 }
 
 // Default command handler
 }
 
 // Default command handler
-bool wxWindow::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
+bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 {
     return FALSE;
 }
 {
     return FALSE;
 }
@@ -246,14 +267,13 @@ bool wxWindow::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 // constructors and such
 // ----------------------------------------------------------------------------
 
 // constructors and such
 // ----------------------------------------------------------------------------
 
-void wxWindow::Init()
+void wxWindowMSW::Init()
 {
     // generic
     InitBase();
 
     // MSW specific
     m_doubleClickAllowed = 0;
 {
     // generic
     InitBase();
 
     // MSW specific
     m_doubleClickAllowed = 0;
-    m_winCaptured = FALSE;
 
     m_isBeingDeleted = FALSE;
     m_oldWndProc = 0;
 
     m_isBeingDeleted = FALSE;
     m_oldWndProc = 0;
@@ -283,17 +303,32 @@ void wxWindow::Init()
 }
 
 // Destructor
 }
 
 // Destructor
-wxWindow::~wxWindow()
+wxWindowMSW::~wxWindowMSW()
 {
     m_isBeingDeleted = TRUE;
 
     MSWDetachWindowMenu();
 
 {
     m_isBeingDeleted = TRUE;
 
     MSWDetachWindowMenu();
 
-    if ( m_parent )
-        m_parent->RemoveChild(this);
+    // VS: make sure there's no wxFrame with last focus set to us:
+    for (wxWindow *win = GetParent(); win; win = win->GetParent())
+    {
+        wxFrame *frame = wxDynamicCast(win, wxFrame);
+        if ( frame )
+        {
+            if ( frame->GetLastFocus() == this )
+                frame->SetLastFocus((wxWindow*)NULL);
+            break;
+        }
+    }
 
 
+    // VS: destroy children first and _then_ detach *this from its parent.
+    //     If we'd do it the other way around, children wouldn't be able
+    //     find their parent frame (see above).
     DestroyChildren();
 
     DestroyChildren();
 
+    if ( m_parent )
+        m_parent->RemoveChild(this);
+
     if ( m_hWnd )
     {
         // VZ: test temp removed to understand what really happens here
     if ( m_hWnd )
     {
         // VZ: test temp removed to understand what really happens here
@@ -309,29 +344,38 @@ wxWindow::~wxWindow()
 }
 
 // real construction (Init() must have been called before!)
 }
 
 // real construction (Init() must have been called before!)
-bool wxWindow::Create(wxWindow *parent, wxWindowID id,
-                      const wxPoint& pos,
-                      const wxSize& size,
-                      long style,
-                      const wxString& name)
+bool wxWindowMSW::Create(wxWindow *parent,
+                         wxWindowID id,
+                         const wxPoint& pos,
+                         const wxSize& size,
+                         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 wxUSE_STATBOX
+    // wxGTK doesn't allow to create controls with static box as the parent so
+    // this will result in a crash when the program is ported to wxGTK - warn
+    // about it
+    //
+    // the correct solution is to create the controls as siblings of the
+    // static box
+    wxASSERT_MSG( !wxDynamicCastThis(wxStaticBox),
+                  _T("wxStaticBox can't be used as a window parent!") );
+#endif // wxUSE_STATBOX
+
     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
         return FALSE;
 
     parent->AddChild(this);
 
     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
         return FALSE;
 
     parent->AddChild(this);
 
-    DWORD msflags = 0;
-    if ( style & wxBORDER )
-        msflags |= WS_BORDER;
-/* Not appropriate for non-frame/dialog windows, and
-   may clash with other window styles.
-    if ( style & wxTHICK_FRAME )
-        msflags |= WS_THICKFRAME;
-*/
-    //msflags |= WS_CHILD /* | WS_CLIPSIBLINGS */  | WS_VISIBLE;
-    msflags |= WS_CHILD | WS_VISIBLE;
+    // all windows are created visible
+    DWORD msflags = WS_CHILD | WS_VISIBLE;
+
+#ifdef __WXUNIVERSAL__
+    // no 3d effects, we draw them ourselves
+    WXDWORD exStyle = 0;
+#else // !wxUniversal
     if ( style & wxCLIP_CHILDREN )
         msflags |= WS_CLIPCHILDREN;
     if ( style & wxCLIP_SIBLINGS )
     if ( style & wxCLIP_CHILDREN )
         msflags |= WS_CLIPCHILDREN;
     if ( style & wxCLIP_SIBLINGS )
@@ -342,8 +386,12 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 
     // Even with extended styles, need to combine with WS_BORDER
     // for them to look right.
 
     // Even with extended styles, need to combine with WS_BORDER
     // for them to look right.
-    if ( want3D || (m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
-        (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
+    if ( want3D ||
+        (m_windowStyle & (wxBORDER |
+                          wxSIMPLE_BORDER |
+                          wxRAISED_BORDER |
+                          wxSUNKEN_BORDER |
+                          wxDOUBLE_BORDER)) )
     {
         msflags |= WS_BORDER;
     }
     {
         msflags |= WS_BORDER;
     }
@@ -355,8 +403,20 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
         m_lDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS |
                      DLGC_WANTTAB | DLGC_WANTMESSAGE;
     }
         m_lDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS |
                      DLGC_WANTTAB | DLGC_WANTMESSAGE;
     }
+#endif // wxUniversal/!wxUniversal
+
+    if ( style & wxPOPUP_WINDOW )
+    {
+        // a popup window floats on top of everything
+        exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
+
+        // it is also created hidden as other top level windows
+        msflags &= ~WS_VISIBLE;
+        m_isShown = FALSE;
+    }
 
 
-    return MSWCreate(m_windowId, parent, wxCanvasClassName, this, NULL,
+    return MSWCreate(m_windowId, parent, wxCanvasClassName,
+                     (wxWindow *)this, NULL,
                      pos.x, pos.y,
                      WidthDefault(size.x), HeightDefault(size.y),
                      msflags, NULL, exStyle);
                      pos.x, pos.y,
                      WidthDefault(size.x), HeightDefault(size.y),
                      msflags, NULL, exStyle);
@@ -366,11 +426,35 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 // basic operations
 // ---------------------------------------------------------------------------
 
 // basic operations
 // ---------------------------------------------------------------------------
 
-void wxWindow::SetFocus()
+void wxWindowMSW::SetFocus()
 {
     HWND hWnd = GetHwnd();
 {
     HWND hWnd = GetHwnd();
-    if ( hWnd )
-        ::SetFocus(hWnd);
+    wxCHECK_RET( hWnd, _T("can't set focus to invalid window") );
+
+#ifndef __WXMICROWIN__
+    ::SetLastError(0);
+#endif
+
+    if ( !::SetFocus(hWnd) )
+    {
+        // was there really an error?
+#ifndef __WXMICROWIN__
+        DWORD dwRes = ::GetLastError();
+#else
+
+        DWORD dwRes = 0;
+#endif
+        if ( dwRes )
+        {
+            wxLogApiError(_T("SetFocus"), dwRes);
+        }
+
+        // VZ: just why does this happen sometimes?? any idea?
+#if 0
+        HWND hwndFocus = ::GetFocus();
+        wxASSERT_MSG( hwndFocus == hWnd, _T("SetFocus() didn't work?") );
+#endif // 0
+    }
 }
 
 // Get the window with the focus
 }
 
 // Get the window with the focus
@@ -385,7 +469,7 @@ wxWindow *wxWindowBase::FindFocus()
     return NULL;
 }
 
     return NULL;
 }
 
-bool wxWindow::Enable(bool enable)
+bool wxWindowMSW::Enable(bool enable)
 {
     if ( !wxWindowBase::Enable(enable) )
         return FALSE;
 {
     if ( !wxWindowBase::Enable(enable) )
         return FALSE;
@@ -411,7 +495,7 @@ bool wxWindow::Enable(bool enable)
     return TRUE;
 }
 
     return TRUE;
 }
 
-bool wxWindow::Show(bool show)
+bool wxWindowMSW::Show(bool show)
 {
     if ( !wxWindowBase::Show(show) )
         return FALSE;
 {
     if ( !wxWindowBase::Show(show) )
         return FALSE;
@@ -422,55 +506,86 @@ bool wxWindow::Show(bool show)
 
     if ( show )
     {
 
     if ( show )
     {
+#ifdef __WXMICROWIN__
+        // It seems that MicroWindows brings the _parent_ of the
+        // window to the top, which can be the wrong one.
+
+        // activate (set focus to) specified window
+        ::SetFocus(hWnd);
+
+        // raise top level parent to top of z order
+        ::SetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0,
+                SWP_NOMOVE|SWP_NOSIZE);
+#else
         BringWindowToTop(hWnd);
         BringWindowToTop(hWnd);
+#endif
     }
 
     return TRUE;
 }
 
 // Raise the window to the top of the Z order
     }
 
     return TRUE;
 }
 
 // Raise the window to the top of the Z order
-void wxWindow::Raise()
+void wxWindowMSW::Raise()
 {
 {
+#ifdef __WIN16__
     ::BringWindowToTop(GetHwnd());
     ::BringWindowToTop(GetHwnd());
+#else // Win32
+#ifdef __WXMICROWIN__
+    // It seems that MicroWindows brings the _parent_ of the
+    // window to the top, which can be the wrong one.
+
+    // activate (set focus to) specified window
+    ::SetFocus(GetHwnd());
+
+    // raise top level parent to top of z order
+    ::SetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+#else
+    ::SetForegroundWindow(GetHwnd());
+#endif
+#endif
 }
 
 // Lower the window to the bottom of the Z order
 }
 
 // Lower the window to the bottom of the Z order
-void wxWindow::Lower()
+void wxWindowMSW::Lower()
 {
     ::SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0,
                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 }
 
 {
     ::SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0,
                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 }
 
-void wxWindow::SetTitle( const wxString& title)
+void wxWindowMSW::SetTitle( const wxString& title)
 {
     SetWindowText(GetHwnd(), title.c_str());
 }
 
 {
     SetWindowText(GetHwnd(), title.c_str());
 }
 
-wxString wxWindow::GetTitle() const
+wxString wxWindowMSW::GetTitle() const
 {
     return wxGetWindowText(GetHWND());
 }
 
 {
     return wxGetWindowText(GetHWND());
 }
 
-void wxWindow::CaptureMouse()
+void wxWindowMSW::CaptureMouse()
 {
     HWND hWnd = GetHwnd();
 {
     HWND hWnd = GetHwnd();
-    if ( hWnd && !m_winCaptured )
+    if ( hWnd )
     {
     {
-        SetCapture(hWnd);
-        m_winCaptured = TRUE;
+        ::SetCapture(hWnd);
     }
 }
 
     }
 }
 
-void wxWindow::ReleaseMouse()
+void wxWindowMSW::ReleaseMouse()
 {
 {
-    if ( m_winCaptured )
+    if ( !::ReleaseCapture() )
     {
     {
-        ReleaseCapture();
-        m_winCaptured = FALSE;
+        wxLogLastError(_T("ReleaseCapture"));
     }
 }
 
     }
 }
 
-bool wxWindow::SetFont(const wxFont& font)
+/* static */ wxWindow *wxWindowBase::GetCapture()
+{
+    HWND hwnd = ::GetCapture();
+    return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL;
+}
+
+bool wxWindowMSW::SetFont(const wxFont& font)
 {
     if ( !wxWindowBase::SetFont(font) )
     {
 {
     if ( !wxWindowBase::SetFont(font) )
     {
@@ -490,7 +605,7 @@ bool wxWindow::SetFont(const wxFont& font)
 
     return TRUE;
 }
 
     return TRUE;
 }
-bool wxWindow::SetCursor(const wxCursor& cursor)
+bool wxWindowMSW::SetCursor(const wxCursor& cursor)
 {
     if ( !wxWindowBase::SetCursor(cursor) )
     {
 {
     if ( !wxWindowBase::SetCursor(cursor) )
     {
@@ -516,24 +631,18 @@ bool wxWindow::SetCursor(const wxCursor& cursor)
     return TRUE;
 }
 
     return TRUE;
 }
 
-void wxWindow::WarpPointer (int x_pos, int y_pos)
+void wxWindowMSW::WarpPointer (int x, int y)
 {
 {
-    // Move the pointer to (x_pos,y_pos) coordinates. They are expressed in
-    // pixel coordinates, relatives to the canvas -- So, we first need to
-    // substract origin of the window, then convert to screen position
-
-    int x = x_pos; int y = y_pos;
-    RECT rect;
-    GetWindowRect (GetHwnd(), &rect);
+    ClientToScreen(&x, &y);
 
 
-    x += rect.left;
-    y += rect.top;
-
-    SetCursorPos (x, y);
+    if ( !::SetCursorPos(x, y) )
+    {
+        wxLogLastError(_T("SetCursorPos"));
+    }
 }
 
 #if WXWIN_COMPATIBILITY
 }
 
 #if WXWIN_COMPATIBILITY
-void wxWindow::MSWDeviceToLogical (float *x, float *y) const
+void wxWindowMSW::MSWDeviceToLogical (float *x, float *y) const
 {
 }
 #endif // WXWIN_COMPATIBILITY
 {
 }
 #endif // WXWIN_COMPATIBILITY
@@ -543,7 +652,7 @@ void wxWindow::MSWDeviceToLogical (float *x, float *y) const
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY
-void wxWindow::SetScrollRange(int orient, int range, bool refresh)
+void wxWindowMSW::SetScrollRange(int orient, int range, bool refresh)
 {
 #if defined(__WIN95__)
 
 {
 #if defined(__WIN95__)
 
@@ -589,7 +698,7 @@ void wxWindow::SetScrollRange(int orient, int range, bool refresh)
 #endif
 }
 
 #endif
 }
 
-void wxWindow::SetScrollPage(int orient, int page, bool refresh)
+void wxWindowMSW::SetScrollPage(int orient, int page, bool refresh)
 {
 #if defined(__WIN95__)
     SCROLLINFO info;
 {
 #if defined(__WIN95__)
     SCROLLINFO info;
@@ -619,7 +728,7 @@ void wxWindow::SetScrollPage(int orient, int page, bool refresh)
 #endif
 }
 
 #endif
 }
 
-int wxWindow::OldGetScrollRange(int orient) const
+int wxWindowMSW::OldGetScrollRange(int orient) const
 {
     int wOrient;
     if ( orient == wxHORIZONTAL )
 {
     int wOrient;
     if ( orient == wxHORIZONTAL )
@@ -651,7 +760,7 @@ int wxWindow::OldGetScrollRange(int orient) const
         return 0;
 }
 
         return 0;
 }
 
-int wxWindow::GetScrollPage(int orient) const
+int wxWindowMSW::GetScrollPage(int orient) const
 {
     if ( orient == wxHORIZONTAL )
         return m_xThumbSize;
 {
     if ( orient == wxHORIZONTAL )
         return m_xThumbSize;
@@ -661,7 +770,7 @@ int wxWindow::GetScrollPage(int orient) const
 
 #endif // WXWIN_COMPATIBILITY
 
 
 #endif // WXWIN_COMPATIBILITY
 
-int wxWindow::GetScrollPos(int orient) const
+int wxWindowMSW::GetScrollPos(int orient) const
 {
     int wOrient;
     if ( orient == wxHORIZONTAL )
 {
     int wOrient;
     if ( orient == wxHORIZONTAL )
@@ -671,7 +780,11 @@ int wxWindow::GetScrollPos(int orient) const
     HWND hWnd = GetHwnd();
     if ( hWnd )
     {
     HWND hWnd = GetHwnd();
     if ( hWnd )
     {
+#ifdef __WXMICROWIN__
+        return ::GetScrollPosWX(hWnd, wOrient);
+#else
         return ::GetScrollPos(hWnd, wOrient);
         return ::GetScrollPos(hWnd, wOrient);
+#endif
     }
     else
         return 0;
     }
     else
         return 0;
@@ -679,7 +792,7 @@ int wxWindow::GetScrollPos(int orient) const
 
 // This now returns the whole range, not just the number
 // of positions that we can scroll.
 
 // This now returns the whole range, not just the number
 // of positions that we can scroll.
-int wxWindow::GetScrollRange(int orient) const
+int wxWindowMSW::GetScrollRange(int orient) const
 {
     int wOrient;
     if ( orient == wxHORIZONTAL )
 {
     int wOrient;
     if ( orient == wxHORIZONTAL )
@@ -714,7 +827,7 @@ int wxWindow::GetScrollRange(int orient) const
         return 0;
 }
 
         return 0;
 }
 
-int wxWindow::GetScrollThumb(int orient) const
+int wxWindowMSW::GetScrollThumb(int orient) const
 {
     if ( orient == wxHORIZONTAL )
         return m_xThumbSize;
 {
     if ( orient == wxHORIZONTAL )
         return m_xThumbSize;
@@ -722,7 +835,7 @@ int wxWindow::GetScrollThumb(int orient) const
         return m_yThumbSize;
 }
 
         return m_yThumbSize;
 }
 
-void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
+void wxWindowMSW::SetScrollPos(int orient, int pos, bool refresh)
 {
 #if defined(__WIN95__)
     SCROLLINFO info;
 {
 #if defined(__WIN95__)
     SCROLLINFO info;
@@ -757,7 +870,7 @@ void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
 }
 
 // New function that will replace some of the above.
 }
 
 // New function that will replace some of the above.
-void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
+void wxWindowMSW::SetScrollbar(int orient, int pos, int thumbVisible,
                             int range, bool refresh)
 {
 #if defined(__WIN95__)
                             int range, bool refresh)
 {
 #if defined(__WIN95__)
@@ -813,28 +926,51 @@ void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
     }
 }
 
     }
 }
 
-void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
+void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
 {
 {
-    RECT rect2;
-    if ( rect )
+    RECT rect;
+    if ( prect )
     {
     {
-        rect2.left = rect->x;
-        rect2.top = rect->y;
-        rect2.right = rect->x + rect->width;
-        rect2.bottom = rect->y + rect->height;
+        rect.left = prect->x;
+        rect.top = prect->y;
+        rect.right = prect->x + prect->width;
+        rect.bottom = prect->y + prect->height;
     }
 
     }
 
-    if ( rect )
-        ::ScrollWindow(GetHwnd(), dx, dy, &rect2, NULL);
-    else
-        ::ScrollWindow(GetHwnd(), dx, dy, NULL, NULL);
+    ::ScrollWindow(GetHwnd(), dx, dy, prect ? &rect : NULL, NULL);
+}
+
+static void ScrollVertically(HWND hwnd, int kind, int count)
+{
+    for ( int n = 0; n < count; n++ )
+    {
+        ::SendMessage(hwnd, WM_VSCROLL, kind, 0);
+    }
+}
+
+void wxWindowMSW::ScrollLines(int lines)
+{
+    bool down = lines > 0;
+
+    ScrollVertically(GetHwnd(),
+                     down ? SB_LINEDOWN : SB_LINEUP,
+                     down ? lines : -lines);
+}
+
+void wxWindowMSW::ScrollPages(int pages)
+{
+    bool down = pages > 0;
+
+    ScrollVertically(GetHwnd(),
+                     down ? SB_PAGEDOWN : SB_PAGEUP,
+                     down ? pages : -pages);
 }
 
 // ---------------------------------------------------------------------------
 // subclassing
 // ---------------------------------------------------------------------------
 
 }
 
 // ---------------------------------------------------------------------------
 // subclassing
 // ---------------------------------------------------------------------------
 
-void wxWindow::SubclassWin(WXHWND hWnd)
+void wxWindowMSW::SubclassWin(WXHWND hWnd)
 {
     wxASSERT_MSG( !m_oldWndProc, wxT("subclassing window twice?") );
 
 {
     wxASSERT_MSG( !m_oldWndProc, wxT("subclassing window twice?") );
 
@@ -844,10 +980,13 @@ void wxWindow::SubclassWin(WXHWND hWnd)
     wxAssociateWinWithHandle(hwnd, this);
 
     m_oldWndProc = (WXFARPROC) GetWindowLong(hwnd, GWL_WNDPROC);
     wxAssociateWinWithHandle(hwnd, this);
 
     m_oldWndProc = (WXFARPROC) GetWindowLong(hwnd, GWL_WNDPROC);
+
+    wxASSERT( (WXFARPROC) m_oldWndProc != (WXFARPROC) wxWndProc );
+
     SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
 }
 
     SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
 }
 
-void wxWindow::UnsubclassWin()
+void wxWindowMSW::UnsubclassWin()
 {
     wxRemoveHandleAssociation(this);
 
 {
     wxRemoveHandleAssociation(this);
 
@@ -869,7 +1008,7 @@ void wxWindow::UnsubclassWin()
 }
 
 // Make a Windows extended style from the given wxWindows window style
 }
 
 // Make a Windows extended style from the given wxWindows window style
-WXDWORD wxWindow::MakeExtendedStyle(long style, bool eliminateBorders)
+WXDWORD wxWindowMSW::MakeExtendedStyle(long style, bool eliminateBorders)
 {
     WXDWORD exStyle = 0;
     if ( style & wxTRANSPARENT_WINDOW )
 {
     WXDWORD exStyle = 0;
     if ( style & wxTRANSPARENT_WINDOW )
@@ -895,12 +1034,16 @@ WXDWORD wxWindow::MakeExtendedStyle(long style, bool eliminateBorders)
 // Determines whether native 3D effects or CTL3D should be used,
 // applying a default border style if required, and returning an extended
 // style to pass to CreateWindowEx.
 // Determines whether native 3D effects or CTL3D should be used,
 // applying a default border style if required, and returning an extended
 // style to pass to CreateWindowEx.
-WXDWORD wxWindow::Determine3DEffects(WXDWORD defaultBorderStyle,
+WXDWORD wxWindowMSW::Determine3DEffects(WXDWORD defaultBorderStyle,
                                      bool *want3D) const
 {
     // If matches certain criteria, then assume no 3D effects
     // unless specifically requested (dealt with in MakeExtendedStyle)
                                      bool *want3D) const
 {
     // If matches certain criteria, then assume no 3D effects
     // unless specifically requested (dealt with in MakeExtendedStyle)
-    if ( !GetParent() || !IsKindOf(CLASSINFO(wxControl)) || (m_windowStyle & wxNO_BORDER) )
+    if ( !GetParent()
+#if wxUSE_CONTROLS
+            || !IsKindOf(CLASSINFO(wxControl))
+#endif // wxUSE_CONTROLS
+            || (m_windowStyle & wxNO_BORDER) )
     {
         *want3D = FALSE;
         return MakeExtendedStyle(m_windowStyle, FALSE);
     {
         *want3D = FALSE;
         return MakeExtendedStyle(m_windowStyle, FALSE);
@@ -955,7 +1098,7 @@ WXDWORD wxWindow::Determine3DEffects(WXDWORD defaultBorderStyle,
 // If nothing defined for this, try the parent.
 // E.g. we may be a button loaded from a resource, with no callback function
 // defined.
 // If nothing defined for this, try the parent.
 // E.g. we may be a button loaded from a resource, with no callback function
 // defined.
-void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
+void wxWindowMSW::OnCommand(wxWindow& win, wxCommandEvent& event)
 {
     if ( GetEventHandler()->ProcessEvent(event)  )
         return;
 {
     if ( GetEventHandler()->ProcessEvent(event)  )
         return;
@@ -965,7 +1108,7 @@ void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
 #endif // WXWIN_COMPATIBILITY_2
 
 #if WXWIN_COMPATIBILITY
 #endif // WXWIN_COMPATIBILITY_2
 
 #if WXWIN_COMPATIBILITY
-wxObject* wxWindow::GetChild(int number) const
+wxObject* wxWindowMSW::GetChild(int number) const
 {
     // Return a pointer to the Nth object in the Panel
     wxNode *node = GetChildren().First();
 {
     // Return a pointer to the Nth object in the Panel
     wxNode *node = GetChildren().First();
@@ -983,27 +1126,40 @@ wxObject* wxWindow::GetChild(int number) const
 #endif // WXWIN_COMPATIBILITY
 
 // Setup background and foreground colours correctly
 #endif // WXWIN_COMPATIBILITY
 
 // Setup background and foreground colours correctly
-void wxWindow::SetupColours()
+void wxWindowMSW::SetupColours()
 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 }
 
 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 }
 
-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
+bool wxWindowMSW::IsMouseInWindow() const
+{
+    // get the mouse position
+    POINT pt;
+    ::GetCursorPos(&pt);
+
+    // find the window which currently has the cursor and go up the window
+    // chain until we find this window - or exhaust it
+    HWND hwnd = ::WindowFromPoint(pt);
+    while ( hwnd && (hwnd != GetHwnd()) )
+        hwnd = ::GetParent(hwnd);
+
+    return hwnd != NULL;
+}
+
+void wxWindowMSW::OnIdle(wxIdleEvent& WXUNUSED(event))
 {
     // Check if we need to send a LEAVE event
     if ( m_mouseInWindow )
     {
 {
     // Check if we need to send a LEAVE event
     if ( m_mouseInWindow )
     {
-        POINT pt;
-        ::GetCursorPos(&pt);
-        if ( ::WindowFromPoint(pt) != GetHwnd() )
+        if ( !IsMouseInWindow() )
         {
             // Generate a LEAVE event
             m_mouseInWindow = FALSE;
 
         {
             // Generate a LEAVE event
             m_mouseInWindow = FALSE;
 
-            // Unfortunately the mouse button and keyboard state may have changed
-            // by the time the OnIdle function is called, so 'state' may be
-            // meaningless.
+            // Unfortunately the mouse button and keyboard state may have
+            // changed by the time the OnIdle function is called, so 'state'
+            // may be meaningless.
             int state = 0;
             if ( wxIsShiftDown() )
                 state |= MK_SHIFT;
             int state = 0;
             if ( wxIsShiftDown() )
                 state |= MK_SHIFT;
@@ -1016,10 +1172,26 @@ void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
             if ( GetKeyState( VK_RBUTTON ) )
                 state |= MK_RBUTTON;
 
             if ( GetKeyState( VK_RBUTTON ) )
                 state |= MK_RBUTTON;
 
-            wxMouseEvent event(wxEVT_LEAVE_WINDOW);
-            InitMouseEvent(event, pt.x, pt.y, state);
+            POINT pt;
+            if ( !::GetCursorPos(&pt) )
+            {
+                wxLogLastError(_T("GetCursorPos"));
+            }
 
 
-            (void)GetEventHandler()->ProcessEvent(event);
+            // we need to have client coordinates here for symmetry with
+            // wxEVT_ENTER_WINDOW
+            RECT rect;
+            if ( !::GetWindowRect(GetHwnd(), &rect) )
+            {
+                wxLogLastError(_T("GetWindowRect"));
+            }
+            pt.x -= rect.left;
+            pt.y -= rect.top;
+
+            wxMouseEvent event2(wxEVT_LEAVE_WINDOW);
+            InitMouseEvent(event2, pt.x, pt.y, state);
+
+            (void)GetEventHandler()->ProcessEvent(event2);
         }
     }
 
         }
     }
 
@@ -1027,7 +1199,7 @@ void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
 }
 
 // Set this window to be the child of 'parent'.
 }
 
 // Set this window to be the child of 'parent'.
-bool wxWindow::Reparent(wxWindowBase *parent)
+bool wxWindowMSW::Reparent(wxWindowBase *parent)
 {
     if ( !wxWindowBase::Reparent(parent) )
         return FALSE;
 {
     if ( !wxWindowBase::Reparent(parent) )
         return FALSE;
@@ -1040,15 +1212,34 @@ bool wxWindow::Reparent(wxWindowBase *parent)
     return TRUE;
 }
 
     return TRUE;
 }
 
-void wxWindow::Clear()
+void wxWindowMSW::Clear()
 {
 {
-    wxClientDC dc(this);
+    wxClientDC dc((wxWindow *)this);
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBackground(brush);
     dc.Clear();
 }
 
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBackground(brush);
     dc.Clear();
 }
 
-void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
+static inline void SendSetRedraw(HWND hwnd, bool on)
+{
+    ::SendMessage(hwnd, WM_SETREDRAW, (WPARAM)on, 0);
+}
+
+void wxWindowMSW::Freeze()
+{
+    SendSetRedraw(GetHwnd(), FALSE);
+}
+
+void wxWindowMSW::Thaw()
+{
+    SendSetRedraw(GetHwnd(), TRUE);
+
+    // we need to refresh everything or otherwise he invalidated area is not
+    // repainted
+    Refresh();
+}
+
+void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
 {
     HWND hWnd = GetHwnd();
     if ( hWnd )
 {
     HWND hWnd = GetHwnd();
     if ( hWnd )
@@ -1068,13 +1259,27 @@ void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
     }
 }
 
     }
 }
 
+void wxWindowMSW::Update()
+{
+    if ( !::UpdateWindow(GetHwnd()) )
+    {
+        wxLogLastError(_T("UpdateWindow"));
+    }
+
+#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+    // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
+    // handler needs to be really drawn right now
+    (void)::GdiFlush();
+#endif // __WIN32__
+}
+
 // ---------------------------------------------------------------------------
 // drag and drop
 // ---------------------------------------------------------------------------
 
 #if wxUSE_DRAG_AND_DROP
 
 // ---------------------------------------------------------------------------
 // drag and drop
 // ---------------------------------------------------------------------------
 
 #if wxUSE_DRAG_AND_DROP
 
-void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
+void wxWindowMSW::SetDropTarget(wxDropTarget *pDropTarget)
 {
     if ( m_dropTarget != 0 ) {
         m_dropTarget->Revoke(m_hWnd);
 {
     if ( m_dropTarget != 0 ) {
         m_dropTarget->Revoke(m_hWnd);
@@ -1090,7 +1295,7 @@ void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 
 // old style file-manager drag&drop support: we retain the old-style
 // DragAcceptFiles in parallel with SetDropTarget.
 
 // old style file-manager drag&drop support: we retain the old-style
 // DragAcceptFiles in parallel with SetDropTarget.
-void wxWindow::DragAcceptFiles(bool accept)
+void wxWindowMSW::DragAcceptFiles(bool accept)
 {
     HWND hWnd = GetHwnd();
     if ( hWnd )
 {
     HWND hWnd = GetHwnd();
     if ( hWnd )
@@ -1103,7 +1308,7 @@ void wxWindow::DragAcceptFiles(bool accept)
 
 #if wxUSE_TOOLTIPS
 
 
 #if wxUSE_TOOLTIPS
 
-void wxWindow::DoSetToolTip(wxToolTip *tooltip)
+void wxWindowMSW::DoSetToolTip(wxToolTip *tooltip)
 {
     wxWindowBase::DoSetToolTip(tooltip);
 
 {
     wxWindowBase::DoSetToolTip(tooltip);
 
@@ -1118,7 +1323,7 @@ void wxWindow::DoSetToolTip(wxToolTip *tooltip)
 // ---------------------------------------------------------------------------
 
 // Get total size
 // ---------------------------------------------------------------------------
 
 // Get total size
-void wxWindow::DoGetSize(int *x, int *y) const
+void wxWindowMSW::DoGetSize(int *x, int *y) const
 {
     HWND hWnd = GetHwnd();
     RECT rect;
 {
     HWND hWnd = GetHwnd();
     RECT rect;
@@ -1136,7 +1341,7 @@ void wxWindow::DoGetSize(int *x, int *y) const
         *y = rect.bottom - rect.top;
 }
 
         *y = rect.bottom - rect.top;
 }
 
-void wxWindow::DoGetPosition(int *x, int *y) const
+void wxWindowMSW::DoGetPosition(int *x, int *y) const
 {
     HWND hWnd = GetHwnd();
 
 {
     HWND hWnd = GetHwnd();
 
@@ -1179,7 +1384,7 @@ void wxWindow::DoGetPosition(int *x, int *y) const
         *y = point.y;
 }
 
         *y = point.y;
 }
 
-void wxWindow::DoScreenToClient(int *x, int *y) const
+void wxWindowMSW::DoScreenToClient(int *x, int *y) const
 {
     POINT pt;
     if ( x )
 {
     POINT pt;
     if ( x )
@@ -1196,7 +1401,7 @@ void wxWindow::DoScreenToClient(int *x, int *y) const
         *y = pt.y;
 }
 
         *y = pt.y;
 }
 
-void wxWindow::DoClientToScreen(int *x, int *y) const
+void wxWindowMSW::DoClientToScreen(int *x, int *y) const
 {
     POINT pt;
     if ( x )
 {
     POINT pt;
     if ( x )
@@ -1214,7 +1419,7 @@ void wxWindow::DoClientToScreen(int *x, int *y) const
 }
 
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 }
 
 // Get size *available for subwindows* i.e. excluding menu bar etc.
-void wxWindow::DoGetClientSize(int *x, int *y) const
+void wxWindowMSW::DoGetClientSize(int *x, int *y) const
 {
     HWND hWnd = GetHwnd();
     RECT rect;
 {
     HWND hWnd = GetHwnd();
     RECT rect;
@@ -1225,7 +1430,7 @@ void wxWindow::DoGetClientSize(int *x, int *y) const
         *y = rect.bottom;
 }
 
         *y = rect.bottom;
 }
 
-void wxWindow::DoMoveWindow(int x, int y, int width, int height)
+void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
 {
     if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
     {
 {
     if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
     {
@@ -1241,7 +1446,7 @@ void wxWindow::DoMoveWindow(int x, int y, int width, int height)
 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height
 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height
-void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 {
     // get the current size and position...
     int currentX, currentY;
 {
     // get the current size and position...
     int currentX, currentY;
@@ -1300,7 +1505,7 @@ void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
     DoMoveWindow(x, y, width, height);
 }
 
     DoMoveWindow(x, y, width, height);
 }
 
-void wxWindow::DoSetClientSize(int width, int height)
+void wxWindowMSW::DoSetClientSize(int width, int height)
 {
     wxWindow *parent = GetParent();
     HWND hWnd = GetHwnd();
 {
     wxWindow *parent = GetParent();
     HWND hWnd = GetHwnd();
@@ -1340,14 +1545,14 @@ void wxWindow::DoSetClientSize(int width, int height)
 
 // For implementation purposes - sometimes decorations make the client area
 // smaller
 
 // For implementation purposes - sometimes decorations make the client area
 // smaller
-wxPoint wxWindow::GetClientAreaOrigin() const
+wxPoint wxWindowMSW::GetClientAreaOrigin() const
 {
     return wxPoint(0, 0);
 }
 
 // Makes an adjustment to the window position (for example, a frame that has
 // a toolbar that it manages itself).
 {
     return wxPoint(0, 0);
 }
 
 // Makes an adjustment to the window position (for example, a frame that has
 // a toolbar that it manages itself).
-void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
+void wxWindowMSW::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
 {
     // don't do it for the dialogs/frames - they float independently of their
     // parent
 {
     // don't do it for the dialogs/frames - they float independently of their
     // parent
@@ -1357,7 +1562,8 @@ void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
         if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
         {
             wxPoint pt(parent->GetClientAreaOrigin());
         if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
         {
             wxPoint pt(parent->GetClientAreaOrigin());
-            x += pt.x; y += pt.y;
+            x += pt.x;
+            y += pt.y;
         }
     }
 }
         }
     }
 }
@@ -1366,23 +1572,23 @@ void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
 // text metrics
 // ---------------------------------------------------------------------------
 
 // text metrics
 // ---------------------------------------------------------------------------
 
-int wxWindow::GetCharHeight() const
+int wxWindowMSW::GetCharHeight() const
 {
     return wxGetTextMetrics(this).tmHeight;
 }
 
 {
     return wxGetTextMetrics(this).tmHeight;
 }
 
-int wxWindow::GetCharWidth() const
+int wxWindowMSW::GetCharWidth() const
 {
     // +1 is needed because Windows apparently adds it when calculating the
     // dialog units size in pixels
 #if wxDIALOG_UNIT_COMPATIBILITY
 {
     // +1 is needed because Windows apparently adds it when calculating the
     // dialog units size in pixels
 #if wxDIALOG_UNIT_COMPATIBILITY
-    return wxGetTextMetrics(this).tmAveCharWidth ;
+    return wxGetTextMetrics(this).tmAveCharWidth;
 #else
     return wxGetTextMetrics(this).tmAveCharWidth + 1;
 #endif
 }
 
 #else
     return wxGetTextMetrics(this).tmAveCharWidth + 1;
 #endif
 }
 
-void wxWindow::GetTextExtent(const wxString& string,
+void wxWindowMSW::GetTextExtent(const wxString& string,
                              int *x, int *y,
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const
                              int *x, int *y,
                              int *descent, int *externalLeading,
                              const wxFont *theFont) const
@@ -1428,36 +1634,36 @@ void wxWindow::GetTextExtent(const wxString& string,
 // Caret manipulation
 // ---------------------------------------------------------------------------
 
 // Caret manipulation
 // ---------------------------------------------------------------------------
 
-void wxWindow::CreateCaret(int w, int h)
+void wxWindowMSW::CreateCaret(int w, int h)
 {
     SetCaret(new wxCaret(this, w, h));
 }
 
 {
     SetCaret(new wxCaret(this, w, h));
 }
 
-void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
+void wxWindowMSW::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
 {
     wxFAIL_MSG("not implemented");
 }
 
 {
     wxFAIL_MSG("not implemented");
 }
 
-void wxWindow::ShowCaret(bool show)
+void wxWindowMSW::ShowCaret(bool show)
 {
     wxCHECK_RET( m_caret, "no caret to show" );
 
     m_caret->Show(show);
 }
 
 {
     wxCHECK_RET( m_caret, "no caret to show" );
 
     m_caret->Show(show);
 }
 
-void wxWindow::DestroyCaret()
+void wxWindowMSW::DestroyCaret()
 {
     SetCaret(NULL);
 }
 
 {
     SetCaret(NULL);
 }
 
-void wxWindow::SetCaretPos(int x, int y)
+void wxWindowMSW::SetCaretPos(int x, int y)
 {
     wxCHECK_RET( m_caret, "no caret to move" );
 
     m_caret->Move(x, y);
 }
 
 {
     wxCHECK_RET( m_caret, "no caret to move" );
 
     m_caret->Move(x, y);
 }
 
-void wxWindow::GetCaretPos(int *x, int *y) const
+void wxWindowMSW::GetCaretPos(int *x, int *y) const
 {
     wxCHECK_RET( m_caret, "no caret to get position of" );
 
 {
     wxCHECK_RET( m_caret, "no caret to get position of" );
 
@@ -1469,7 +1675,26 @@ void wxWindow::GetCaretPos(int *x, int *y) const
 // popup menu
 // ---------------------------------------------------------------------------
 
 // popup menu
 // ---------------------------------------------------------------------------
 
-bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
+// yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
+// immediately, without waiting for the next event loop iteration
+//
+// NB: this function should probably be made public later as it can almost
+//     surely replace wxYield() elsewhere as well
+static void wxYieldForCommandsOnly()
+{
+    // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
+    // want to process it here)
+    MSG msg;
+    while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE)
+                && msg.message != WM_QUIT )
+    {
+        wxTheApp->DoMessage((WXMSG *)&msg);
+    }
+}
+
+#if wxUSE_MENUS_NATIVE
+
+bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
 {
     menu->SetInvokingWindow(this);
     menu->UpdateUI();
 {
     menu->SetInvokingWindow(this);
     menu->UpdateUI();
@@ -1482,7 +1707,16 @@ bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
     ::ClientToScreen(hWnd, &point);
     wxCurrentPopupMenu = menu;
     ::TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, point.x, point.y, 0, hWnd, NULL);
     ::ClientToScreen(hWnd, &point);
     wxCurrentPopupMenu = menu;
     ::TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, point.x, point.y, 0, hWnd, NULL);
-    wxYieldIfNeeded();
+
+    // we need to do it righ now as otherwise the events are never going to be
+    // sent to wxCurrentPopupMenu from HandleCommand()
+    //
+    // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
+    // help and we'd still need wxYieldForCommandsOnly() as the menu may be
+    // destroyed as soon as we return (it can be a local variable in the caller
+    // for example) and so we do need to process the event immediately
+    wxYieldForCommandsOnly();
+
     wxCurrentPopupMenu = NULL;
 
     menu->SetInvokingWindow(NULL);
     wxCurrentPopupMenu = NULL;
 
     menu->SetInvokingWindow(NULL);
@@ -1490,11 +1724,13 @@ bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
     return TRUE;
 }
 
     return TRUE;
 }
 
+#endif // wxUSE_MENUS_NATIVE
+
 // ===========================================================================
 // pre/post message processing
 // ===========================================================================
 
 // ===========================================================================
 // pre/post message processing
 // ===========================================================================
 
-long wxWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+long 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);
@@ -1502,8 +1738,10 @@ long wxWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
         return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
 }
 
         return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
 }
 
-bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
+bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
 {
 {
+    // wxUniversal implements tab traversal itself
+#ifndef __WXUNIVERSAL__
     if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
     {
         // intercept dialog navigation keys
     if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
     {
         // intercept dialog navigation keys
@@ -1591,9 +1829,10 @@ bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
 
                             bProcess = FALSE;
                         }
 
                             bProcess = FALSE;
                         }
+#if wxUSE_BUTTON
                         else
                         {
                         else
                         {
-                            wxPanel *panel = wxDynamicThisCast(this, wxPanel);
+                            wxPanel *panel = wxDynamicCastThis(wxPanel);
                             wxButton *btn = NULL;
                             if ( panel )
                             {
                             wxButton *btn = NULL;
                             if ( panel )
                             {
@@ -1613,6 +1852,7 @@ bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
                             //       it work like a TAB - and that's what we do.
                             //       Note that Ctrl-Enter always works this way.
                         }
                             //       it work like a TAB - and that's what we do.
                             //       Note that Ctrl-Enter always works this way.
                         }
+#endif // wxUSE_BUTTON
                     }
                     break;
 
                     }
                     break;
 
@@ -1629,12 +1869,14 @@ bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
 
                 if ( GetEventHandler()->ProcessEvent(event) )
                 {
 
                 if ( GetEventHandler()->ProcessEvent(event) )
                 {
+#if wxUSE_BUTTON
                     wxButton *btn = wxDynamicCast(FindFocus(), wxButton);
                     if ( btn )
                     {
                         // the button which has focus should be default
                         btn->SetDefault();
                     }
                     wxButton *btn = wxDynamicCast(FindFocus(), wxButton);
                     if ( btn )
                     {
                         // the button which has focus should be default
                         btn->SetDefault();
                     }
+#endif // wxUSE_BUTTON
 
                     return TRUE;
                 }
 
                     return TRUE;
                 }
@@ -1676,6 +1918,7 @@ bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
             return TRUE;
         }
     }
             return TRUE;
         }
     }
+#endif // __WXUNIVERSAL__
 
 #if wxUSE_TOOLTIPS
     if ( m_tooltip )
 
 #if wxUSE_TOOLTIPS
     if ( m_tooltip )
@@ -1690,9 +1933,13 @@ bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
     return FALSE;
 }
 
     return FALSE;
 }
 
-bool wxWindow::MSWTranslateMessage(WXMSG* pMsg)
+bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
 {
 {
+#if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
     return m_acceleratorTable.Translate(this, pMsg);
     return m_acceleratorTable.Translate(this, pMsg);
+#else
+    return FALSE;
+#endif // wxUSE_ACCEL
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------
@@ -1701,7 +1948,7 @@ bool wxWindow::MSWTranslateMessage(WXMSG* pMsg)
 
 #ifdef __WIN32__
 
 
 #ifdef __WIN32__
 
-void wxWindow::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
                              WORD *id, WXHWND *hwnd, WORD *cmd)
 {
     *id = LOWORD(wParam);
                              WORD *id, WXHWND *hwnd, WORD *cmd)
 {
     *id = LOWORD(wParam);
@@ -1709,7 +1956,7 @@ void wxWindow::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
     *cmd = HIWORD(wParam);
 }
 
     *cmd = HIWORD(wParam);
 }
 
-void wxWindow::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
                               WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
 {
     *state = LOWORD(wParam);
                               WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
 {
     *state = LOWORD(wParam);
@@ -1717,7 +1964,7 @@ void wxWindow::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
     *hwnd = (WXHWND)lParam;
 }
 
     *hwnd = (WXHWND)lParam;
 }
 
-void wxWindow::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
                             WXWORD *code, WXWORD *pos, WXHWND *hwnd)
 {
     *code = LOWORD(wParam);
                             WXWORD *code, WXWORD *pos, WXHWND *hwnd)
 {
     *code = LOWORD(wParam);
@@ -1725,15 +1972,17 @@ void wxWindow::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
     *hwnd = (WXHWND)lParam;
 }
 
     *hwnd = (WXHWND)lParam;
 }
 
-void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
                               WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
 {
                               WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
 {
+#ifndef __WXMICROWIN__
     *nCtlColor = CTLCOLOR_BTN;
     *hwnd = (WXHWND)lParam;
     *hdc = (WXHDC)wParam;
     *nCtlColor = CTLCOLOR_BTN;
     *hwnd = (WXHWND)lParam;
     *hdc = (WXHDC)wParam;
+#endif
 }
 
 }
 
-void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
 {
     *item = (WXWORD)wParam;
                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
 {
     *item = (WXWORD)wParam;
@@ -1743,7 +1992,7 @@ void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
 
 #else // Win16
 
 
 #else // Win16
 
-void wxWindow::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
                              WXWORD *id, WXHWND *hwnd, WXWORD *cmd)
 {
     *id = (WXWORD)wParam;
                              WXWORD *id, WXHWND *hwnd, WXWORD *cmd)
 {
     *id = (WXWORD)wParam;
@@ -1751,7 +2000,7 @@ void wxWindow::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
     *cmd = HIWORD(lParam);
 }
 
     *cmd = HIWORD(lParam);
 }
 
-void wxWindow::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
                               WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
 {
     *state = (WXWORD)wParam;
                               WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
 {
     *state = (WXWORD)wParam;
@@ -1759,7 +2008,7 @@ void wxWindow::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
     *hwnd = (WXHWND)HIWORD(lParam);
 }
 
     *hwnd = (WXHWND)HIWORD(lParam);
 }
 
-void wxWindow::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
                             WXWORD *code, WXWORD *pos, WXHWND *hwnd)
 {
     *code = (WXWORD)wParam;
                             WXWORD *code, WXWORD *pos, WXHWND *hwnd)
 {
     *code = (WXWORD)wParam;
@@ -1767,7 +2016,7 @@ void wxWindow::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
     *hwnd = (WXHWND)HIWORD(lParam);
 }
 
     *hwnd = (WXHWND)HIWORD(lParam);
 }
 
-void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
                               WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
 {
     *hwnd = (WXHWND)LOWORD(lParam);
                               WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
 {
     *hwnd = (WXHWND)LOWORD(lParam);
@@ -1775,7 +2024,7 @@ void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
     *hdc = (WXHDC)wParam;
 }
 
     *hdc = (WXHDC)wParam;
 }
 
-void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
+void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
 {
     *item = (WXWORD)wParam;
                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
 {
     *item = (WXWORD)wParam;
@@ -1791,7 +2040,7 @@ void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
 
 // Hook for new window just as it's being created, when the window isn't yet
 // associated with the handle
 
 // Hook for new window just as it's being created, when the window isn't yet
 // associated with the handle
-wxWindow *wxWndHook = NULL;
+wxWindowMSW *wxWndHook = NULL;
 
 // Main window proc
 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 // Main window proc
 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
@@ -1802,7 +2051,7 @@ LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM w
                wxGetMessageName(message), wParam, lParam);
 #endif // __WXDEBUG__
 
                wxGetMessageName(message), wParam, lParam);
 #endif // __WXDEBUG__
 
-    wxWindow *wnd = wxFindWinFromHandle((WXHWND) hWnd);
+    wxWindowMSW *wnd = wxFindWinFromHandle((WXHWND) hWnd);
 
     // when we get the first message for the HWND we just created, we associate
     // it with wxWindow stored in wxWndHook
 
     // when we get the first message for the HWND we just created, we associate
     // it with wxWindow stored in wxWndHook
@@ -1841,7 +2090,7 @@ LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM w
     return rc;
 }
 
     return rc;
 }
 
-long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 {
     // did we process the message?
     bool processed = FALSE;
 {
     // did we process the message?
     bool processed = FALSE;
@@ -1881,9 +2130,39 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
             break;
 
         case WM_SIZE:
             break;
 
         case WM_SIZE:
-            processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
+            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;
 
             break;
 
+#ifndef __WXMICROWIN__
+        case WM_ACTIVATEAPP:
+            wxTheApp->SetActive(wParam != 0, FindFocus());
+            break;
+#endif
+
         case WM_ACTIVATE:
             {
                 WXWORD state, minimized;
         case WM_ACTIVATE:
             {
                 WXWORD state, minimized;
@@ -1930,12 +2209,6 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 #endif
 
         case WM_LBUTTONDOWN:
 #endif
 
         case WM_LBUTTONDOWN:
-           // set focus to this window
-           if (AcceptsFocus())
-                SetFocus();
-
-           // fall through
-
         case WM_LBUTTONUP:
         case WM_LBUTTONDBLCLK:
         case WM_RBUTTONDOWN:
         case WM_LBUTTONUP:
         case WM_LBUTTONDBLCLK:
         case WM_RBUTTONDOWN:
@@ -1944,12 +2217,70 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
         case WM_MBUTTONDOWN:
         case WM_MBUTTONUP:
         case WM_MBUTTONDBLCLK:
         case WM_MBUTTONDOWN:
         case WM_MBUTTONUP:
         case WM_MBUTTONDBLCLK:
-            processed = HandleMouseEvent(message,
+         {
+                processed = FALSE;
+#ifdef __WXMICROWIN__
+                // MicroWindows seems to ignore the fact that a window is
+                // disabled. So catch mouse events and throw them away if
+                // necessary.
+                wxWindowMSW* win = this;
+                while (win)
+                {
+                    if (!win->IsEnabled())
+                    {
+                        processed = TRUE;
+                        break;
+                    }
+                    win = win->GetParent();
+                    if (win && win->IsTopLevel())
+                        break;
+                }
+#endif // __WXMICROWIN__
+                if (!processed)
+                {
+                    if (message == WM_LBUTTONDOWN && AcceptsFocus())
+                        SetFocus();
+                     processed = HandleMouseEvent(message,
                                          GET_X_LPARAM(lParam),
                                          GET_Y_LPARAM(lParam),
                                          GET_X_LPARAM(lParam),
                                          GET_Y_LPARAM(lParam),
-                                         wParam);
-            break;
+                                                  wParam);
+                }
+                break;
+         }
+
+#ifdef __WXMICROWIN__
+        case WM_NCLBUTTONDOWN:
+        case WM_NCLBUTTONUP:
+        case WM_NCLBUTTONDBLCLK:
+        case WM_NCRBUTTONDOWN:
+        case WM_NCRBUTTONUP:
+        case WM_NCRBUTTONDBLCLK:
+#if 0
+        case WM_NCMBUTTONDOWN:
+        case WM_NCMBUTTONUP:
+        case WM_NCMBUTTONDBLCLK:
+#endif
+            {
+                // MicroWindows seems to ignore the fact that a window
+                // is disabled. So catch mouse events and throw them away if necessary.
+                processed = FALSE;
+                wxWindowMSW* win = this;
+                while (win)
+                {
+                    if (!win->IsEnabled())
+                    {
+                        processed = TRUE;
+                        break;
+                    }
+                    win = win->GetParent();
+                    if (win && win->IsTopLevel())
+                        break;
+                }
+                break;
+            }
+#endif // __WXMICROWIN__
 
 
+#ifdef MM_JOY1MOVE
         case MM_JOY1MOVE:
         case MM_JOY2MOVE:
         case MM_JOY1ZMOVE:
         case MM_JOY1MOVE:
         case MM_JOY2MOVE:
         case MM_JOY1ZMOVE:
@@ -1963,6 +2294,7 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
                                             GET_Y_LPARAM(lParam),
                                             wParam);
             break;
                                             GET_Y_LPARAM(lParam),
                                             wParam);
             break;
+#endif // __WXMICROWIN__
 
         case WM_SYSCOMMAND:
             processed = HandleSysCommand(wParam, lParam);
 
         case WM_SYSCOMMAND:
             processed = HandleSysCommand(wParam, lParam);
@@ -1985,6 +2317,7 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 #endif  // Win95
 
             // for these messages we must return TRUE if process the message
 #endif  // Win95
 
             // for these messages we must return TRUE if process the message
+#ifdef WM_DRAWITEM
         case WM_DRAWITEM:
         case WM_MEASUREITEM:
             {
         case WM_DRAWITEM:
         case WM_MEASUREITEM:
             {
@@ -2004,6 +2337,7 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
                     rc.result = TRUE;
             }
             break;
                     rc.result = TRUE;
             }
             break;
+#endif // defined(WM_DRAWITEM)
 
         case WM_GETDLGCODE:
             if ( m_lDlgCode )
 
         case WM_GETDLGCODE:
             if ( m_lDlgCode )
@@ -2112,7 +2446,8 @@ long wxWindow::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
+        // colors#ifndef __WXMICROWIN__
+#ifndef __WXMICROWIN__
 #ifdef __WIN32__
         case WM_CTLCOLORMSGBOX:
         case WM_CTLCOLOREDIT:
 #ifdef __WIN32__
         case WM_CTLCOLORMSGBOX:
         case WM_CTLCOLOREDIT:
@@ -2139,6 +2474,7 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
                                            lParam);
             }
             break;
                                            lParam);
             }
             break;
+#endif // !__WXMICROWIN__
 
             // the return value for this message is ignored
         case WM_SYSCOLORCHANGE:
 
             // the return value for this message is ignored
         case WM_SYSCOLORCHANGE:
@@ -2202,14 +2538,14 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
             }
             break;
 
             }
             break;
 
-#ifdef __WIN32__
+#if defined(__WIN32__) && defined(WM_HELP)
         case WM_HELP:
             {
                 HELPINFO* info = (HELPINFO*) lParam;
                 // Don't yet process menu help events, just windows
                 if (info->iContextType == HELPINFO_WINDOW)
                 {
         case WM_HELP:
             {
                 HELPINFO* info = (HELPINFO*) lParam;
                 // Don't yet process menu help events, just windows
                 if (info->iContextType == HELPINFO_WINDOW)
                 {
-                    wxWindow* subjectOfHelp = this;
+                    wxWindowMSW* subjectOfHelp = this;
                     bool eventProcessed = FALSE;
                     while (subjectOfHelp && !eventProcessed)
                     {
                     bool eventProcessed = FALSE;
                     while (subjectOfHelp && !eventProcessed)
                     {
@@ -2246,16 +2582,22 @@ long wxWindow::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);
-                GetEventHandler()->ProcessEvent(evtCtx);
-
-                // set processed to true even if the event is not handled
-                // because if we don't windows will propogate the
-                // WM_CONTEXTMENU up the parent window chain, which we have
-                // already done ourselves.
-                processed = true;
+                processed = GetEventHandler()->ProcessEvent(evtCtx);
             }
             break;
 #endif // __WIN32__
             }
             break;
 #endif // __WIN32__
+
+#ifdef __WXUNIVERSAL__
+        case WM_NCHITTEST:
+            // we shouldn't allow the windows which don't want to get focus to
+            // get it
+            if ( !AcceptsFocus() )
+            {
+                rc.result = HTTRANSPARENT;
+                processed = TRUE;
+            }
+            break;
+#endif // __WXUNIVERSAL__
     }
 
     if ( !processed )
     }
 
     if ( !processed )
@@ -2301,7 +2643,7 @@ wxWindow *wxFindWinFromHandle(WXHWND hWnd)
 static int gs_AssociationCount = 0;
 #endif
 
 static int gs_AssociationCount = 0;
 #endif
 
-void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win)
+void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
 {
     // adding NULL hWnd is (first) surely a result of an error and
     // (secondly) breaks menu command processing
 {
     // adding NULL hWnd is (first) surely a result of an error and
     // (secondly) breaks menu command processing
@@ -2326,7 +2668,7 @@ void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win)
     }
 }
 
     }
 }
 
-void wxRemoveHandleAssociation(wxWindow *win)
+void wxRemoveHandleAssociation(wxWindowMSW *win)
 {
 #if 0 // def __WXDEBUG__
     if (wxWinHandleList->Member(win))
 {
 #if 0 // def __WXDEBUG__
     if (wxWinHandleList->Member(win))
@@ -2340,12 +2682,13 @@ void wxRemoveHandleAssociation(wxWindow *win)
 
 // Default destroyer - override if you destroy it in some other way
 // (e.g. with MDI child windows)
 
 // Default destroyer - override if you destroy it in some other way
 // (e.g. with MDI child windows)
-void wxWindow::MSWDestroyWindow()
+void wxWindowMSW::MSWDestroyWindow()
 {
 }
 
 {
 }
 
-void wxWindow::MSWDetachWindowMenu()
+void wxWindowMSW::MSWDetachWindowMenu()
 {
 {
+#ifndef __WXUNIVERSAL__
     if ( m_hMenu )
     {
         wxChar buf[1024];
     if ( m_hMenu )
     {
         wxChar buf[1024];
@@ -2372,20 +2715,21 @@ void wxWindow::MSWDetachWindowMenu()
             }
         }
     }
             }
         }
     }
+#endif
 }
 
 }
 
-bool wxWindow::MSWCreate(int id,
-                         wxWindow *parent,
-                         const wxChar *wclass,
-                         wxWindow *WXUNUSED(wx_win),
-                         const wxChar *title,
-                         int x,
-                         int y,
-                         int width,
-                         int height,
-                         WXDWORD style,
-                         const wxChar *dialog_template,
-                         WXDWORD extendedStyle)
+bool wxWindowMSW::MSWCreate(int id,
+                            wxWindow *parent,
+                            const wxChar *wclass,
+                            wxWindow * WXUNUSED(wx_win),
+                            const wxChar *title,
+                            int x,
+                            int y,
+                            int width,
+                            int height,
+                            WXDWORD style,
+                            const wxChar *dialog_template,
+                            WXDWORD extendedStyle)
 {
     int x1 = CW_USEDEFAULT;
     int y1 = 0;
 {
     int x1 = CW_USEDEFAULT;
     int y1 = 0;
@@ -2394,13 +2738,13 @@ bool wxWindow::MSWCreate(int id,
 
     // Find parent's size, if it exists, to set up a possible default
     // panel size the size of the parent window
 
     // Find parent's size, if it exists, to set up a possible default
     // panel size the size of the parent window
-    RECT parent_rect;
+    RECT rectParent;
     if ( parent )
     {
     if ( parent )
     {
-        ::GetClientRect((HWND) parent->GetHWND(), &parent_rect);
+        ::GetClientRect(GetHwndOf(parent), &rectParent);
 
 
-        width1 = parent_rect.right - parent_rect.left;
-        height1 = parent_rect.bottom - parent_rect.top;
+        width1 = rectParent.right - rectParent.left;
+        height1 = rectParent.bottom - rectParent.top;
     }
 
     if ( x != -1 )
     }
 
     if ( x != -1 )
@@ -2426,10 +2770,26 @@ bool wxWindow::MSWCreate(int id,
     }
 #endif // 0
 
     }
 #endif // 0
 
-    HWND hParent = parent ? GetHwndOf(parent) : NULL;
+    HWND hParent;
+    if ( GetWindowStyleFlag() & wxPOPUP_WINDOW )
+    {
+        // popup windows should have desktop as parent because they shouldn't
+        // be limited to the parents client area as child windows usually are
+        hParent = ::GetDesktopWindow();
+    }
+    else if ( parent )
+    {
+        hParent = GetHwndOf(parent);
+    }
+    else
+    {
+        // top level window
+        hParent = NULL;
+    }
 
     wxWndHook = this;
 
 
     wxWndHook = this;
 
+#ifndef __WXMICROWIN__
     if ( dialog_template )
     {
         // for the dialogs without wxDIALOG_NO_PARENT style, use the top level
     if ( dialog_template )
     {
         // for the dialogs without wxDIALOG_NO_PARENT style, use the top level
@@ -2503,15 +2863,21 @@ bool wxWindow::MSWCreate(int id,
         {
             wxLogLastError(wxT("MoveWindow"));
         }
         {
             wxLogLastError(wxT("MoveWindow"));
         }
+
     }
     else // creating a normal window, not a dialog
     }
     else // creating a normal window, not a dialog
+#endif // !__WXMICROWIN__
     {
         int controlId = 0;
         if ( style & WS_CHILD )
     {
         int controlId = 0;
         if ( style & WS_CHILD )
+        {
             controlId = id;
 
             controlId = id;
 
-        if ( GetWindowStyleFlag() & wxCLIP_SIBLINGS )
-          style |= WS_CLIPSIBLINGS;
+            if ( GetWindowStyleFlag() & wxCLIP_SIBLINGS )
+            {
+                style |= WS_CLIPSIBLINGS;
+            }
+        }
 
         wxString className(wclass);
         if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE )
 
         wxString className(wclass);
         if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE )
@@ -2569,8 +2935,9 @@ bool wxWindow::MSWCreate(int id,
 
 #ifdef __WIN95__
 // FIXME: VZ: I'm not sure at all that the order of processing is correct
 
 #ifdef __WIN95__
 // FIXME: VZ: I'm not sure at all that the order of processing is correct
-bool wxWindow::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
+bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 {
 {
+#ifndef __WXMICROWIN__
     LPNMHDR hdr = (LPNMHDR)lParam;
     HWND hWnd = hdr->hwndFrom;
     wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
     LPNMHDR hdr = (LPNMHDR)lParam;
     HWND hWnd = hdr->hwndFrom;
     wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
@@ -2596,9 +2963,12 @@ bool wxWindow::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 
     // finally try this window too (catches toolbar case)
     return MSWOnNotify(idCtrl, lParam, result);
 
     // finally try this window too (catches toolbar case)
     return MSWOnNotify(idCtrl, lParam, result);
+#else // __WXMICROWIN__
+    return FALSE;
+#endif
 }
 
 }
 
-bool wxWindow::MSWOnNotify(int WXUNUSED(idCtrl),
+bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
                            WXLPARAM lParam,
                            WXLPARAM* WXUNUSED(result))
 {
                            WXLPARAM lParam,
                            WXLPARAM* WXUNUSED(result))
 {
@@ -2622,7 +2992,7 @@ bool wxWindow::MSWOnNotify(int WXUNUSED(idCtrl),
 // end session messages
 // ---------------------------------------------------------------------------
 
 // end session messages
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleQueryEndSession(long logOff, bool *mayEnd)
+bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
 {
     wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
     event.SetEventObject(wxTheApp);
 {
     wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
     event.SetEventObject(wxTheApp);
@@ -2641,7 +3011,7 @@ bool wxWindow::HandleQueryEndSession(long logOff, bool *mayEnd)
     return rc;
 }
 
     return rc;
 }
 
-bool wxWindow::HandleEndSession(bool endSession, long logOff)
+bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
 {
     // do nothing if the session isn't ending
     if ( !endSession )
 {
     // do nothing if the session isn't ending
     if ( !endSession )
@@ -2662,10 +3032,10 @@ bool wxWindow::HandleEndSession(bool endSession, long logOff)
 // window creation/destruction
 // ---------------------------------------------------------------------------
 
 // window creation/destruction
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleCreate(WXLPCREATESTRUCT WXUNUSED(cs), bool *mayCreate)
+bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT WXUNUSED(cs), bool *mayCreate)
 {
     // TODO: should generate this event from WM_NCCREATE
 {
     // TODO: should generate this event from WM_NCCREATE
-    wxWindowCreateEvent event(this);
+    wxWindowCreateEvent event((wxWindow *)this);
     (void)GetEventHandler()->ProcessEvent(event);
 
     *mayCreate = TRUE;
     (void)GetEventHandler()->ProcessEvent(event);
 
     *mayCreate = TRUE;
@@ -2673,9 +3043,9 @@ bool wxWindow::HandleCreate(WXLPCREATESTRUCT WXUNUSED(cs), bool *mayCreate)
     return TRUE;
 }
 
     return TRUE;
 }
 
-bool wxWindow::HandleDestroy()
+bool wxWindowMSW::HandleDestroy()
 {
 {
-    wxWindowDestroyEvent event(this);
+    wxWindowDestroyEvent event((wxWindow *)this);
     (void)GetEventHandler()->ProcessEvent(event);
 
     // delete our drop target if we've got one
     (void)GetEventHandler()->ProcessEvent(event);
 
     // delete our drop target if we've got one
@@ -2697,7 +3067,7 @@ bool wxWindow::HandleDestroy()
 // activation/focus
 // ---------------------------------------------------------------------------
 
 // activation/focus
 // ---------------------------------------------------------------------------
 
-void wxWindow::OnSetFocus(wxFocusEvent& event)
+void wxWindowMSW::OnSetFocus(wxFocusEvent& event)
 {
     // panel wants to track the window which was the last to have focus in it,
     // so we want to set ourselves as the window which last had focus
 {
     // panel wants to track the window which was the last to have focus in it,
     // so we want to set ourselves as the window which last had focus
@@ -2705,7 +3075,7 @@ void wxWindow::OnSetFocus(wxFocusEvent& event)
     // notice that it's also important to do it upwards the tree becaus
     // otherwise when the top level panel gets focus, it won't set it back to
     // us, but to some other sibling
     // notice that it's also important to do it upwards the tree becaus
     // otherwise when the top level panel gets focus, it won't set it back to
     // us, but to some other sibling
-    wxWindow *win = this;
+    wxWindow *win = (wxWindow *)this;
     while ( win )
     {
         wxWindow *parent = win->GetParent();
     while ( win )
     {
         wxWindow *parent = win->GetParent();
@@ -2724,7 +3094,7 @@ void wxWindow::OnSetFocus(wxFocusEvent& event)
     event.Skip();
 }
 
     event.Skip();
 }
 
-bool wxWindow::HandleActivate(int state,
+bool wxWindowMSW::HandleActivate(int state,
                               bool WXUNUSED(minimized),
                               WXHWND WXUNUSED(activate))
 {
                               bool WXUNUSED(minimized),
                               WXHWND WXUNUSED(activate))
 {
@@ -2736,7 +3106,7 @@ bool wxWindow::HandleActivate(int state,
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleSetFocus(WXHWND WXUNUSED(hwnd))
+bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
 {
 #if wxUSE_CARET
     // Deal with caret
 {
 #if wxUSE_CARET
     // Deal with caret
@@ -2749,10 +3119,13 @@ bool wxWindow::HandleSetFocus(WXHWND WXUNUSED(hwnd))
     wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
     event.SetEventObject(this);
 
     wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
     event.SetEventObject(this);
 
+    // wxFindWinFromHandle() may return NULL, it is ok
+    event.SetWindow(wxFindWinFromHandle(hwnd));
+
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleKillFocus(WXHWND WXUNUSED(hwnd))
+bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
 {
 #if wxUSE_CARET
     // Deal with caret
 {
 #if wxUSE_CARET
     // Deal with caret
@@ -2765,6 +3138,9 @@ bool wxWindow::HandleKillFocus(WXHWND WXUNUSED(hwnd))
     wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
     event.SetEventObject(this);
 
     wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
     event.SetEventObject(this);
 
+    // wxFindWinFromHandle() may return NULL, it is ok
+    event.SetWindow(wxFindWinFromHandle(hwnd));
+
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
@@ -2772,7 +3148,7 @@ bool wxWindow::HandleKillFocus(WXHWND WXUNUSED(hwnd))
 // miscellaneous
 // ---------------------------------------------------------------------------
 
 // miscellaneous
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleShow(bool show, int WXUNUSED(status))
+bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
 {
     wxShowEvent event(GetId(), show);
     event.m_eventObject = this;
 {
     wxShowEvent event(GetId(), show);
     event.m_eventObject = this;
@@ -2780,7 +3156,7 @@ bool wxWindow::HandleShow(bool show, int WXUNUSED(status))
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
+bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
 {
     wxInitDialogEvent event(GetId());
     event.m_eventObject = this;
 {
     wxInitDialogEvent event(GetId());
     event.m_eventObject = this;
@@ -2788,8 +3164,9 @@ bool wxWindow::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleDropFiles(WXWPARAM wParam)
+bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
 {
 {
+#ifndef __WXMICROWIN__
     HDROP hFilesInfo = (HDROP) wParam;
     POINT dropPoint;
     DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
     HDROP hFilesInfo = (HDROP) wParam;
     POINT dropPoint;
     DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
@@ -2821,12 +3198,16 @@ bool wxWindow::HandleDropFiles(WXWPARAM wParam)
     delete[] files;
 
     return rc;
     delete[] files;
 
     return rc;
+#else // __WXMICROWIN__
+    return FALSE;
+#endif
 }
 
 }
 
-bool wxWindow::HandleSetCursor(WXHWND WXUNUSED(hWnd),
-                               short nHitTest,
-                               int WXUNUSED(mouseMsg))
+bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
+                                  short nHitTest,
+                                  int WXUNUSED(mouseMsg))
 {
 {
+#ifndef __WXMICROWIN__
     // the logic is as follows:
     // -1. don't set cursor for non client area, including but not limited to
     //     the title bar, scrollbars, &c
     // the logic is as follows:
     // -1. don't set cursor for non client area, including but not limited to
     //     the title bar, scrollbars, &c
@@ -2903,6 +3284,7 @@ bool wxWindow::HandleSetCursor(WXHWND WXUNUSED(hWnd),
         // cursor set, stop here
         return TRUE;
     }
         // cursor set, stop here
         return TRUE;
     }
+#endif // __WXMICROWIN__
 
     // pass up the window chain
     return FALSE;
 
     // pass up the window chain
     return FALSE;
@@ -2912,9 +3294,11 @@ bool wxWindow::HandleSetCursor(WXHWND WXUNUSED(hWnd),
 // owner drawn stuff
 // ---------------------------------------------------------------------------
 
 // owner drawn stuff
 // ---------------------------------------------------------------------------
 
-bool wxWindow::MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
+bool wxWindowMSW::MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
 {
 #if wxUSE_OWNER_DRAWN
 {
 #if wxUSE_OWNER_DRAWN
+
+#if wxUSE_MENUS_NATIVE
     // is it a menu item?
     if ( id == 0 )
     {
     // is it a menu item?
     if ( id == 0 )
     {
@@ -2938,18 +3322,22 @@ bool wxWindow::MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
                 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
                );
     }
                 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
                );
     }
+#endif // wxUSE_MENUS_NATIVE
 
 
+#if wxUSE_CONTROLS
     wxWindow *item = FindItem(id);
     if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
     {
         return ((wxControl *)item)->MSWOnDraw(itemStruct);
     }
     wxWindow *item = FindItem(id);
     if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
     {
         return ((wxControl *)item)->MSWOnDraw(itemStruct);
     }
+#endif // wxUSE_CONTROLS
+
 #endif // USE_OWNER_DRAWN
 
     return FALSE;
 }
 
 #endif // USE_OWNER_DRAWN
 
     return FALSE;
 }
 
-bool wxWindow::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
+bool wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
 {
 #if wxUSE_OWNER_DRAWN
     // is it a menu item?
 {
 #if wxUSE_OWNER_DRAWN
     // is it a menu item?
@@ -2977,7 +3365,7 @@ bool wxWindow::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
 // colours and palettes
 // ---------------------------------------------------------------------------
 
 // colours and palettes
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleSysColorChange()
+bool wxWindowMSW::HandleSysColorChange()
 {
     wxSysColourChangedEvent event;
     event.SetEventObject(this);
 {
     wxSysColourChangedEvent event;
     event.SetEventObject(this);
@@ -2985,7 +3373,7 @@ bool wxWindow::HandleSysColorChange()
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleCtlColor(WXHBRUSH *brush,
+bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
                               WXHDC pDC,
                               WXHWND pWnd,
                               WXUINT nCtlColor,
                               WXHDC pDC,
                               WXHWND pWnd,
                               WXUINT nCtlColor,
@@ -2993,37 +3381,43 @@ bool wxWindow::HandleCtlColor(WXHBRUSH *brush,
                               WXWPARAM wParam,
                               WXLPARAM lParam)
 {
                               WXWPARAM wParam,
                               WXLPARAM lParam)
 {
+#ifndef __WXMICROWIN__
     WXHBRUSH hBrush = 0;
 
     if ( nCtlColor == CTLCOLOR_DLG )
     {
         hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
     }
     WXHBRUSH hBrush = 0;
 
     if ( nCtlColor == CTLCOLOR_DLG )
     {
         hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
     }
+#if wxUSE_CONTROLS
     else
     {
         wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
         if ( item )
             hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
     }
     else
     {
         wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
         if ( item )
             hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
     }
+#endif // wxUSE_CONTROLS
 
     if ( hBrush )
         *brush = hBrush;
 
     return hBrush != 0;
 
     if ( hBrush )
         *brush = hBrush;
 
     return hBrush != 0;
+#else // __WXMICROWIN__
+    return FALSE;
+#endif
 }
 
 // Define for each class of dialog and control
 }
 
 // Define for each class of dialog and control
-WXHBRUSH wxWindow::OnCtlColor(WXHDC WXUNUSED(hDC),
-                              WXHWND WXUNUSED(hWnd),
-                              WXUINT WXUNUSED(nCtlColor),
-                              WXUINT WXUNUSED(message),
-                              WXWPARAM WXUNUSED(wParam),
-                              WXLPARAM WXUNUSED(lParam))
+WXHBRUSH wxWindowMSW::OnCtlColor(WXHDC WXUNUSED(hDC),
+                                 WXHWND WXUNUSED(hWnd),
+                                 WXUINT WXUNUSED(nCtlColor),
+                                 WXUINT WXUNUSED(message),
+                                 WXWPARAM WXUNUSED(wParam),
+                                 WXLPARAM WXUNUSED(lParam))
 {
     return (WXHBRUSH)0;
 }
 
 {
     return (WXHBRUSH)0;
 }
 
-bool wxWindow::HandlePaletteChanged(WXHWND hWndPalChange)
+bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
 {
     wxPaletteChangedEvent event(GetId());
     event.SetEventObject(this);
 {
     wxPaletteChangedEvent event(GetId());
     event.SetEventObject(this);
@@ -3032,7 +3426,7 @@ bool wxWindow::HandlePaletteChanged(WXHWND hWndPalChange)
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleQueryNewPalette()
+bool wxWindowMSW::HandleQueryNewPalette()
 {
     wxQueryNewPaletteEvent event(GetId());
     event.SetEventObject(this);
 {
     wxQueryNewPaletteEvent event(GetId());
     event.SetEventObject(this);
@@ -3041,7 +3435,7 @@ bool wxWindow::HandleQueryNewPalette()
 }
 
 // Responds to colour changes: passes event on to children.
 }
 
 // Responds to colour changes: passes event on to children.
-void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
+void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& event)
 {
     wxNode *node = GetChildren().First();
     while ( node )
 {
     wxNode *node = GetChildren().First();
     while ( node )
@@ -3063,7 +3457,7 @@ void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 // painting
 // ---------------------------------------------------------------------------
 
 // painting
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandlePaint()
+bool wxWindowMSW::HandlePaint()
 {
 #ifdef __WIN32__
     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
 {
 #ifdef __WIN32__
     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
@@ -3073,32 +3467,45 @@ bool wxWindow::HandlePaint()
         wxLogLastError(wxT("GetUpdateRgn"));
 
     m_updateRegion = wxRegion((WXHRGN) hRegion);
         wxLogLastError(wxT("GetUpdateRgn"));
 
     m_updateRegion = wxRegion((WXHRGN) hRegion);
-#else
+#else // Win16
     RECT updateRect;
     RECT updateRect;
-    ::GetUpdateRect(GetHwnd(), & updateRect, FALSE);
+    ::GetUpdateRect(GetHwnd(), &updateRect, FALSE);
 
     m_updateRegion = wxRegion(updateRect.left, updateRect.top,
                               updateRect.right - updateRect.left,
                               updateRect.bottom - updateRect.top);
 
     m_updateRegion = wxRegion(updateRect.left, updateRect.top,
                               updateRect.right - updateRect.left,
                               updateRect.bottom - updateRect.top);
-#endif
+#endif // Win32/16
 
     wxPaintEvent event(m_windowId);
     event.SetEventObject(this);
 
 
     wxPaintEvent event(m_windowId);
     event.SetEventObject(this);
 
-    return GetEventHandler()->ProcessEvent(event);
+    bool processed = GetEventHandler()->ProcessEvent(event);
+
+    // note that we must generate NC event after the normal one as otherwise
+    // BeginPaint() will happily overwrite our decorations with the background
+    // colour
+    wxNcPaintEvent eventNc(m_windowId);
+    eventNc.SetEventObject(this);
+    GetEventHandler()->ProcessEvent(eventNc);
+
+    return processed;
 }
 
 // Can be called from an application's OnPaint handler
 }
 
 // Can be called from an application's OnPaint handler
-void wxWindow::OnPaint(wxPaintEvent& event)
+void wxWindowMSW::OnPaint(wxPaintEvent& event)
 {
 {
+#ifdef __WXUNIVERSAL__
+    event.Skip();
+#else
     HDC hDC = (HDC) wxPaintDC::FindDCInCache((wxWindow*) event.GetEventObject());
     if (hDC != 0)
     {
         MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
     }
     HDC hDC = (HDC) wxPaintDC::FindDCInCache((wxWindow*) event.GetEventObject());
     if (hDC != 0)
     {
         MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
     }
+#endif
 }
 
 }
 
-bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
+bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
 {
     // Prevents flicker when dragging
     if ( ::IsIconic(GetHwnd()) )
 {
     // Prevents flicker when dragging
     if ( ::IsIconic(GetHwnd()) )
@@ -3106,7 +3513,8 @@ bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
 
     wxDCTemp dc(hdc);
 
 
     wxDCTemp dc(hdc);
 
-    dc.SetWindow(this);
+    dc.SetHDC(hdc);
+    dc.SetWindow((wxWindow *)this);
     dc.BeginDrawing();
 
     wxEraseEvent event(m_windowId, &dc);
     dc.BeginDrawing();
 
     wxEraseEvent event(m_windowId, &dc);
@@ -3121,7 +3529,7 @@ bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
     return rc;
 }
 
     return rc;
 }
 
-void wxWindow::OnEraseBackground(wxEraseEvent& event)
+void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
 {
     RECT rect;
     ::GetClientRect(GetHwnd(), &rect);
 {
     RECT rect;
     ::GetClientRect(GetHwnd(), &rect);
@@ -3146,7 +3554,7 @@ void wxWindow::OnEraseBackground(wxEraseEvent& event)
 // moving and resizing
 // ---------------------------------------------------------------------------
 
 // moving and resizing
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleMinimize()
+bool wxWindowMSW::HandleMinimize()
 {
     wxIconizeEvent event(m_windowId);
     event.SetEventObject(this);
 {
     wxIconizeEvent event(m_windowId);
     event.SetEventObject(this);
@@ -3154,7 +3562,7 @@ bool wxWindow::HandleMinimize()
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleMaximize()
+bool wxWindowMSW::HandleMaximize()
 {
     wxMaximizeEvent event(m_windowId);
     event.SetEventObject(this);
 {
     wxMaximizeEvent event(m_windowId);
     event.SetEventObject(this);
@@ -3162,7 +3570,7 @@ bool wxWindow::HandleMaximize()
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleMove(int x, int y)
+bool wxWindowMSW::HandleMove(int x, int y)
 {
     wxMoveEvent event(wxPoint(x, y), m_windowId);
     event.SetEventObject(this);
 {
     wxMoveEvent event(wxPoint(x, y), m_windowId);
     event.SetEventObject(this);
@@ -3170,7 +3578,7 @@ bool wxWindow::HandleMove(int x, int y)
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleSize(int w, int h, WXUINT WXUNUSED(flag))
+bool wxWindowMSW::HandleSize(int w, int h, WXUINT WXUNUSED(flag))
 {
     wxSizeEvent event(wxSize(w, h), m_windowId);
     event.SetEventObject(this);
 {
     wxSizeEvent event(wxSize(w, h), m_windowId);
     event.SetEventObject(this);
@@ -3178,7 +3586,7 @@ bool wxWindow::HandleSize(int w, int h, WXUINT WXUNUSED(flag))
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleGetMinMaxInfo(void *mmInfo)
+bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
 {
     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
 
 {
     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
 
@@ -3211,31 +3619,13 @@ bool wxWindow::HandleGetMinMaxInfo(void *mmInfo)
     return rc;
 }
 
     return rc;
 }
 
-// generate an artificial resize event
-/* FUNCTION IS NOW A MEMBER OF wxFrame - gt
-void wxWindow::SendSizeEvent()
-{
-    RECT r;
-#ifdef __WIN16__
-    ::GetWindowRect(GetHwnd(), &r);
-#else
-    if ( !::GetWindowRect(GetHwnd(), &r) )
-    {
-        wxLogLastError(_T("GetWindowRect"));
-    }
-#endif
-
-    (void)::PostMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
-                        MAKELPARAM(r.right - r.left, r.bottom - r.top));
-}
-*/
-
 // ---------------------------------------------------------------------------
 // command messages
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // command messages
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
+bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
 {
 {
+#if wxUSE_MENUS_NATIVE
     if ( wxCurrentPopupMenu )
     {
         wxMenu *popupMenu = wxCurrentPopupMenu;
     if ( wxCurrentPopupMenu )
     {
         wxMenu *popupMenu = wxCurrentPopupMenu;
@@ -3243,6 +3633,7 @@ bool wxWindow::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
 
         return popupMenu->MSWCommand(cmd, id);
     }
 
         return popupMenu->MSWCommand(cmd, id);
     }
+#endif // wxUSE_MENUS_NATIVE
 
     wxWindow *win = (wxWindow*) NULL;
     if ( cmd == 0 || cmd == 1 ) // menu or accel - use id
 
     wxWindow *win = (wxWindow*) NULL;
     if ( cmd == 0 || cmd == 1 ) // menu or accel - use id
@@ -3279,7 +3670,7 @@ bool wxWindow::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
 
         return GetEventHandler()->ProcessEvent(event);
     }
 
         return GetEventHandler()->ProcessEvent(event);
     }
-#if wxUSE_SPINCTRL
+#if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
     else
     {
         // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
     else
     {
         // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
@@ -3294,7 +3685,7 @@ bool wxWindow::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
     return FALSE;
 }
 
     return FALSE;
 }
 
-bool wxWindow::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
+bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
 {
     // 4 bits are reserved
     switch ( wParam & 0xFFFFFFF0 )
 {
     // 4 bits are reserved
     switch ( wParam & 0xFFFFFFF0 )
@@ -3313,16 +3704,22 @@ bool wxWindow::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
 // mouse events
 // ---------------------------------------------------------------------------
 
 // mouse events
 // ---------------------------------------------------------------------------
 
-void wxWindow::InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags)
+void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
+                                 int x, int y,
+                                 WXUINT flags)
 {
 {
-    event.m_x = x;
-    event.m_y = y;
-    event.m_shiftDown = ((flags & MK_SHIFT) != 0);
-    event.m_controlDown = ((flags & MK_CONTROL) != 0);
-    event.m_leftDown = ((flags & MK_LBUTTON) != 0);
-    event.m_middleDown = ((flags & MK_MBUTTON) != 0);
-    event.m_rightDown = ((flags & MK_RBUTTON) != 0);
+    // our client coords are not quite the same as Windows ones
+    wxPoint pt = GetClientAreaOrigin();
+    event.m_x = x - pt.x;
+    event.m_y = y - pt.y;
+
+    event.m_shiftDown = (flags & MK_SHIFT) != 0;
+    event.m_controlDown = (flags & MK_CONTROL) != 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;
     event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
+
     event.SetTimestamp(s_currentMsg.time);
     event.m_eventObject = this;
 
     event.SetTimestamp(s_currentMsg.time);
     event.m_eventObject = this;
 
@@ -3331,10 +3728,9 @@ void wxWindow::InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags)
     m_lastMouseY = y;
     m_lastMouseEvent = event.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK
     m_lastMouseY = y;
     m_lastMouseEvent = event.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK
-
 }
 
 }
 
-bool wxWindow::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
+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
 {
     // the mouse events take consecutive IDs from WM_MOUSEFIRST to
     // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
@@ -3360,17 +3756,24 @@ bool wxWindow::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 
-bool wxWindow::HandleMouseMove(int x, int y, WXUINT flags)
+bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
 {
     if ( !m_mouseInWindow )
     {
 {
     if ( !m_mouseInWindow )
     {
-        // Generate an ENTER event
-        m_mouseInWindow = TRUE;
+        // it would be wrong to assume that just because we get a mouse move
+        // event that the mouse is inside the window: although this is usually
+        // true, it is not if we had captured the mouse, so we need to check
+        // the mouse coordinates here
+        if ( !HasCapture() || IsMouseInWindow() )
+        {
+            // Generate an ENTER event
+            m_mouseInWindow = TRUE;
 
 
-        wxMouseEvent event(wxEVT_ENTER_WINDOW);
-        InitMouseEvent(event, x, y, flags);
+            wxMouseEvent event(wxEVT_ENTER_WINDOW);
+            InitMouseEvent(event, x, y, flags);
 
 
-        (void)GetEventHandler()->ProcessEvent(event);
+            (void)GetEventHandler()->ProcessEvent(event);
+        }
     }
 
 #if wxUSE_MOUSEEVENT_HACK
     }
 
 #if wxUSE_MOUSEEVENT_HACK
@@ -3392,7 +3795,7 @@ bool wxWindow::HandleMouseMove(int x, int y, WXUINT flags)
 }
 
 
 }
 
 
-bool wxWindow::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
+bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
 {
 #if wxUSE_MOUSEWHEEL
     wxMouseEvent event(wxEVT_MOUSEWHEEL);
 {
 #if wxUSE_MOUSEWHEEL
     wxMouseEvent event(wxEVT_MOUSEWHEEL);
@@ -3426,6 +3829,9 @@ bool wxWindow::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
     return GetEventHandler()->ProcessEvent(event);
 
 #else
     return GetEventHandler()->ProcessEvent(event);
 
 #else
+    (void) wParam;
+    (void) lParam;
+
     return FALSE;
 #endif
 }
     return FALSE;
 #endif
 }
@@ -3437,7 +3843,7 @@ bool wxWindow::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
 
 // create the key event of the given type for the given key - used by
 // HandleChar and HandleKeyDown/Up
 
 // create the key event of the given type for the given key - used by
 // HandleChar and HandleKeyDown/Up
-wxKeyEvent wxWindow::CreateKeyEvent(wxEventType evType,
+wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
                                     int id,
                                     WXLPARAM lParam) const
 {
                                     int id,
                                     WXLPARAM lParam) const
 {
@@ -3467,7 +3873,7 @@ wxKeyEvent wxWindow::CreateKeyEvent(wxEventType evType,
 
 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
 // WM_KEYDOWN one
 
 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
 // WM_KEYDOWN one
-bool wxWindow::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
+bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
 {
     bool ctrlDown = FALSE;
 
 {
     bool ctrlDown = FALSE;
 
@@ -3520,7 +3926,7 @@ bool wxWindow::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
     return FALSE;
 }
 
     return FALSE;
 }
 
-bool wxWindow::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
+bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
 {
     int id = wxCharCodeMSWToWX(wParam);
 
 {
     int id = wxCharCodeMSWToWX(wParam);
 
@@ -3542,7 +3948,7 @@ bool wxWindow::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
     return FALSE;
 }
 
     return FALSE;
 }
 
-bool wxWindow::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
+bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
 {
     int id = wxCharCodeMSWToWX(wParam);
 
 {
     int id = wxCharCodeMSWToWX(wParam);
 
@@ -3566,8 +3972,9 @@ bool wxWindow::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
 // joystick
 // ---------------------------------------------------------------------------
 
 // joystick
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
+bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
 {
 {
+#ifdef JOY_BUTTON1
     int change = 0;
     if ( flags & JOY_BUTTON1CHG )
         change = wxJOY_BUTTON1;
     int change = 0;
     if ( flags & JOY_BUTTON1CHG )
         change = wxJOY_BUTTON1;
@@ -3644,13 +4051,16 @@ bool wxWindow::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
     event.SetEventObject(this);
 
     return GetEventHandler()->ProcessEvent(event);
     event.SetEventObject(this);
 
     return GetEventHandler()->ProcessEvent(event);
+#else
+    return FALSE;
+#endif
 }
 
 // ---------------------------------------------------------------------------
 // scrolling
 // ---------------------------------------------------------------------------
 
 }
 
 // ---------------------------------------------------------------------------
 // scrolling
 // ---------------------------------------------------------------------------
 
-bool wxWindow::MSWOnScroll(int orientation, WXWORD wParam,
+bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
                            WXWORD pos, WXHWND control)
 {
     if ( control )
                            WXWORD pos, WXHWND control)
 {
     if ( control )
@@ -3805,14 +4215,11 @@ int wxCharCodeMSWToWX(int keySym)
         case VK_NUMPAD7:    id = WXK_NUMPAD7; break;
         case VK_NUMPAD8:    id = WXK_NUMPAD8; break;
         case VK_NUMPAD9:    id = WXK_NUMPAD9; break;
         case VK_NUMPAD7:    id = WXK_NUMPAD7; break;
         case VK_NUMPAD8:    id = WXK_NUMPAD8; break;
         case VK_NUMPAD9:    id = WXK_NUMPAD9; break;
-        case VK_MULTIPLY:   id = WXK_MULTIPLY; break;
-        case 0xBB: // VK_OEM_PLUS
-        case VK_ADD:        id = WXK_ADD; break;
-        case 0xBD: // VK_OEM_MINUS
-        case VK_SUBTRACT:   id = WXK_SUBTRACT; break;
-        case 0xBE: // VK_OEM_PERIOD
-        case VK_DECIMAL:    id = WXK_DECIMAL; break;
-        case VK_DIVIDE:     id = WXK_DIVIDE; break;
+        case VK_MULTIPLY:   id = WXK_NUMPAD_MULTIPLY; break;
+        case VK_ADD:        id = WXK_NUMPAD_ADD; break;
+        case VK_SUBTRACT:   id = WXK_NUMPAD_SUBTRACT; break;
+        case VK_DECIMAL:    id = WXK_NUMPAD_DECIMAL; break;
+        case VK_DIVIDE:     id = WXK_NUMPAD_DIVIDE; break;
         case VK_F1:         id = WXK_F1; break;
         case VK_F2:         id = WXK_F2; break;
         case VK_F3:         id = WXK_F3; break;
         case VK_F1:         id = WXK_F1; break;
         case VK_F2:         id = WXK_F2; break;
         case VK_F3:         id = WXK_F3; break;
@@ -3882,11 +4289,11 @@ int wxCharCodeWXToMSW(int id, bool *isVirtual)
     case WXK_NUMPAD7:   keySym = VK_NUMPAD7; break;
     case WXK_NUMPAD8:   keySym = VK_NUMPAD8; break;
     case WXK_NUMPAD9:   keySym = VK_NUMPAD9; break;
     case WXK_NUMPAD7:   keySym = VK_NUMPAD7; break;
     case WXK_NUMPAD8:   keySym = VK_NUMPAD8; break;
     case WXK_NUMPAD9:   keySym = VK_NUMPAD9; break;
-    case WXK_MULTIPLY:  keySym = VK_MULTIPLY; break;
-    case WXK_ADD:       keySym = VK_ADD; break;
-    case WXK_SUBTRACT:  keySym = VK_SUBTRACT; break;
-    case WXK_DECIMAL:   keySym = VK_DECIMAL; break;
-    case WXK_DIVIDE:    keySym = VK_DIVIDE; break;
+    case WXK_NUMPAD_MULTIPLY:  keySym = VK_MULTIPLY; break;
+    case WXK_NUMPAD_ADD:       keySym = VK_ADD; break;
+    case WXK_NUMPAD_SUBTRACT:  keySym = VK_SUBTRACT; break;
+    case WXK_NUMPAD_DECIMAL:   keySym = VK_DECIMAL; break;
+    case WXK_NUMPAD_DIVIDE:    keySym = VK_DIVIDE; break;
     case WXK_F1:        keySym = VK_F1; break;
     case WXK_F2:        keySym = VK_F2; break;
     case WXK_F3:        keySym = VK_F3; break;
     case WXK_F1:        keySym = VK_F1; break;
     case WXK_F2:        keySym = VK_F2; break;
     case WXK_F3:        keySym = VK_F3; break;
@@ -3962,7 +4369,7 @@ extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
 
             // spin control text buddy window should be mapped to spin ctrl
             // itself so try it too
 
             // spin control text buddy window should be mapped to spin ctrl
             // itself so try it too
-#if wxUSE_SPINCTRL
+#if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
             if ( !win )
             {
                 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
             if ( !win )
             {
                 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
@@ -3988,6 +4395,8 @@ extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
     return win;
 }
 
     return win;
 }
 
+#ifndef __WXMICROWIN__
+
 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
 // in active frames and dialogs, regardless of where the focus is.
 static HHOOK wxTheKeyboardHook = 0;
 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
 // in active frames and dialogs, regardless of where the focus is.
 static HHOOK wxTheKeyboardHook = 0;
@@ -4065,6 +4474,8 @@ wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
     return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
 }
 
     return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
 }
 
+#endif // !__WXMICROWIN__
+
 #ifdef __WXDEBUG__
 const char *wxGetMessageName(int message)
 {
 #ifdef __WXDEBUG__
 const char *wxGetMessageName(int message)
 {
@@ -4485,7 +4896,8 @@ const char *wxGetMessageName(int message)
 }
 #endif //__WXDEBUG__
 
 }
 #endif //__WXDEBUG__
 
-static void TranslateKbdEventToMouse(wxWindow *win, int *x, int *y, WPARAM *flags)
+static void TranslateKbdEventToMouse(wxWindowMSW *win,
+                                     int *x, int *y, WPARAM *flags)
 {
     // construct the key mask
     WPARAM& fwKeys = *flags;
 {
     // construct the key mask
     WPARAM& fwKeys = *flags;
@@ -4504,7 +4916,7 @@ static void TranslateKbdEventToMouse(wxWindow *win, int *x, int *y, WPARAM *flag
     win->ScreenToClient(x, y);
 }
 
     win->ScreenToClient(x, y);
 }
 
-static TEXTMETRIC wxGetTextMetrics(const wxWindow *win)
+static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
 {
     // prepare the DC
     TEXTMETRIC tm;
 {
     // prepare the DC
     TEXTMETRIC tm;
wxWidgets (Impactor)