dwCallback if DWORD.

[wxWidgets.git] / src / msw / window.cpp
diff --git a/src/msw/window.cpp b/src/msw/window.cpp

index bbca2e056f2dd6f17a540a51063f775e414c3566..bcba0c04c8e24789e53abab5b914b4b104772338 100644 (file)
--- a/src/msw/window.cpp
+++ b/src/msw/window.cpp
@@ -97,7 +97,7 @@
  
  #include <string.h>
  
  
  #include <string.h>
  
-#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
+#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
      #include <shellapi.h>
      #include <mmsystem.h>
  #endif
      #include <shellapi.h>
      #include <mmsystem.h>
  #endif
@@ -106,7 +106,7 @@
      #include <windowsx.h>
  #endif
  
      #include <windowsx.h>
  #endif
  
-#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
+#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
      #ifdef __WIN95__
          #include <commctrl.h>
      #endif
      #ifdef __WIN95__
          #include <commctrl.h>
      #endif
@@ -128,11 +128,15 @@
  wxMenu *wxCurrentPopupMenu = NULL;
  #endif // wxUSE_MENUS_NATIVE
  
  wxMenu *wxCurrentPopupMenu = NULL;
  #endif // wxUSE_MENUS_NATIVE
  
+#ifdef __WXWINCE__
+extern       wxChar *wxCanvasClassName;
+#else
  extern const wxChar *wxCanvasClassName;
  extern const wxChar *wxCanvasClassName;
+#endif
  
  // true if we had already created the std colour map, used by
  // wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)
  
  // true if we had already created the std colour map, used by
  // wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)
-static bool gs_hasStdCmap = FALSE;
+static bool gs_hasStdCmap = false;
  
  // ---------------------------------------------------------------------------
  // private functions
  
  // ---------------------------------------------------------------------------
  // private functions
@@ -151,11 +155,6 @@ void wxRemoveHandleAssociation(wxWindowMSW *win);
  extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
  wxWindow *wxFindWinFromHandle(WXHWND hWnd);
  
  extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
  wxWindow *wxFindWinFromHandle(WXHWND hWnd);
  
-// this magical function is used to translate VK_APPS key presses to right
-// mouse clicks
-static void TranslateKbdEventToMouse(wxWindowMSW *win,
-                                     int *x, int *y, WPARAM *flags);
-
  // get the text metrics for the current font
  static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
  
  // get the text metrics for the current font
  static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
  
@@ -180,6 +179,8 @@ static inline void wxBringWindowToTop(HWND hwnd)
      }
  }
  
      }
  }
  
+#ifndef __WXWINCE__
+
  // ensure that all our parent windows have WS_EX_CONTROLPARENT style
  static void EnsureParentHasControlParentStyle(wxWindow *parent)
  {
  // ensure that all our parent windows have WS_EX_CONTROLPARENT style
  static void EnsureParentHasControlParentStyle(wxWindow *parent)
  {
@@ -196,7 +197,6 @@ static void EnsureParentHasControlParentStyle(wxWindow *parent)
         but if the parent doesn't have it, it wouldn't recurse inside it later
         on and so wouldn't have a chance of getting back to this window neither.
       */
         but if the parent doesn't have it, it wouldn't recurse inside it later
         on and so wouldn't have a chance of getting back to this window neither.
       */
-#ifndef __WXWINCE__
      while ( parent && !parent->IsTopLevel() )
      {
          LONG exStyle = ::GetWindowLong(GetHwndOf(parent), GWL_EXSTYLE);
      while ( parent && !parent->IsTopLevel() )
      {
          LONG exStyle = ::GetWindowLong(GetHwndOf(parent), GWL_EXSTYLE);
@@ -209,9 +209,10 @@ static void EnsureParentHasControlParentStyle(wxWindow *parent)
  
          parent = parent->GetParent();
      }
  
          parent = parent->GetParent();
      }
-#endif // !__WXWINCE__
  }
  
  }
  
+#endif // !__WXWINCE__
+
  // ---------------------------------------------------------------------------
  // event tables
  // ---------------------------------------------------------------------------
  // ---------------------------------------------------------------------------
  // event tables
  // ---------------------------------------------------------------------------
@@ -258,7 +259,7 @@ wxBEGIN_FLAGS( wxWindowStyle )
      wxFLAGS_MEMBER(wxBORDER_RAISED)
      wxFLAGS_MEMBER(wxBORDER_STATIC)
      wxFLAGS_MEMBER(wxBORDER_NONE)
      wxFLAGS_MEMBER(wxBORDER_RAISED)
      wxFLAGS_MEMBER(wxBORDER_STATIC)
      wxFLAGS_MEMBER(wxBORDER_NONE)
-    
+
      // old style border flags
      wxFLAGS_MEMBER(wxSIMPLE_BORDER)
      wxFLAGS_MEMBER(wxSUNKEN_BORDER)
      // old style border flags
      wxFLAGS_MEMBER(wxSIMPLE_BORDER)
      wxFLAGS_MEMBER(wxSUNKEN_BORDER)
@@ -280,16 +281,16 @@ wxBEGIN_FLAGS( wxWindowStyle )
  wxEND_FLAGS( wxWindowStyle )
  
  wxBEGIN_PROPERTIES_TABLE(wxWindow)
  wxEND_FLAGS( wxWindowStyle )
  
  wxBEGIN_PROPERTIES_TABLE(wxWindow)
-       wxEVENT_PROPERTY( Close , wxEVT_CLOSE_WINDOW , wxCloseEvent)
-       wxEVENT_PROPERTY( Create , wxEVT_CREATE , wxWindowCreateEvent )
-       wxEVENT_PROPERTY( Destroy , wxEVT_DESTROY , wxWindowDestroyEvent )
+    wxEVENT_PROPERTY( Close , wxEVT_CLOSE_WINDOW , wxCloseEvent)
+    wxEVENT_PROPERTY( Create , wxEVT_CREATE , wxWindowCreateEvent )
+    wxEVENT_PROPERTY( Destroy , wxEVT_DESTROY , wxWindowDestroyEvent )
      // Always constructor Properties first
  
      // Always constructor Properties first
  
-    wxREADONLY_PROPERTY( Parent,wxWindow*, GetParent,  , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
-       wxPROPERTY( Id,wxWindowID, SetId, GetId, -1, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
-       wxPROPERTY( Position,wxPoint, SetPosition , GetPosition, wxPoint(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
-       wxPROPERTY( Size,wxSize, SetSize, GetSize, wxSize(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
-    wxPROPERTY( WindowStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
+    wxREADONLY_PROPERTY( Parent,wxWindow*, GetParent, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY( Id,wxWindowID, SetId, GetId, wxID_ANY, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
+    wxPROPERTY( Position,wxPoint, SetPosition , GetPosition, wxDefaultPosition , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
+    wxPROPERTY( Size,wxSize, SetSize, GetSize, wxDefaultSize , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
+    wxPROPERTY( WindowStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
  
      // Then all relations of the object graph
  
  
      // Then all relations of the object graph
  
@@ -297,23 +298,23 @@ wxBEGIN_PROPERTIES_TABLE(wxWindow)
  
     // and finally all other properties
  
  
     // and finally all other properties
  
-       wxPROPERTY( ExtraStyle , long , SetExtraStyle , GetExtraStyle , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
-       wxPROPERTY( BackgroundColour , wxColour , SetBackgroundColour , GetBackgroundColour , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
-       wxPROPERTY( ForegroundColour , wxColour , SetForegroundColour , GetForegroundColour , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
-       wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
-       wxPROPERTY( Shown , bool , Show , IsShown , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY( ExtraStyle , long , SetExtraStyle , GetExtraStyle , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
+    wxPROPERTY( BackgroundColour , wxColour , SetBackgroundColour , GetBackgroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
+    wxPROPERTY( ForegroundColour , wxColour , SetForegroundColour , GetForegroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
+    wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
+    wxPROPERTY( Shown , bool , Show , IsShown , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
  #if 0
      // possible property candidates (not in xrc) or not valid in all subclasses
  #if 0
      // possible property candidates (not in xrc) or not valid in all subclasses
-       wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxT("") )
-       wxPROPERTY( Font , wxFont , SetFont , GetWindowFont  , )
-       wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxT("") )
-       // MaxHeight, Width , MinHeight , Width
-       // TODO switch label to control and title to toplevels
+    wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxT("") )
+    wxPROPERTY( Font , wxFont , SetFont , GetWindowFont  , )
+    wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxT("") )
+    // MaxHeight, Width , MinHeight , Width
+    // TODO switch label to control and title to toplevels
  
  
-       wxPROPERTY( ThemeEnabled , bool , SetThemeEnabled , GetThemeEnabled , )
-       //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
-       // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
-       wxPROPERTY( AutoLayout , bool , SetAutoLayout , GetAutoLayout , )
+    wxPROPERTY( ThemeEnabled , bool , SetThemeEnabled , GetThemeEnabled , )
+    //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
+    // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
+    wxPROPERTY( AutoLayout , bool , SetAutoLayout , GetAutoLayout , )
  
  
  
  
  
  
@@ -333,7 +334,9 @@ wxCONSTRUCTOR_DUMMY(wxWindow)
  BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
      EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
      EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
  BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
      EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
      EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
+#ifdef __WXWINCE__
      EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
      EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
+#endif
  END_EVENT_TABLE()
  
  // ===========================================================================
  END_EVENT_TABLE()
  
  // ===========================================================================
@@ -415,7 +418,7 @@ wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
  // Default command handler
  bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
  {
  // Default command handler
  bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
  {
-    return FALSE;
+    return false;
  }
  
  // ----------------------------------------------------------------------------
  }
  
  // ----------------------------------------------------------------------------
@@ -425,12 +428,13 @@ bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
  void wxWindowMSW::Init()
  {
      // MSW specific
  void wxWindowMSW::Init()
  {
      // MSW specific
-    m_isBeingDeleted = FALSE;
+    m_isBeingDeleted = false;
      m_oldWndProc = NULL;
      m_oldWndProc = NULL;
-    m_mouseInWindow = FALSE;
-    m_lastKeydownProcessed = FALSE;
+    m_mouseInWindow = false;
+    m_lastKeydownProcessed = false;
  
      m_childrenDisabled = NULL;
  
      m_childrenDisabled = NULL;
+    m_frozenness = 0;
  
      // wxWnd
      m_hMenu = 0;
  
      // wxWnd
      m_hMenu = 0;
@@ -440,9 +444,6 @@ void wxWindowMSW::Init()
      m_xThumbSize = 0;
      m_yThumbSize = 0;
  
      m_xThumbSize = 0;
      m_yThumbSize = 0;
  
-    // as all windows are created with WS_VISIBLE style...
-    m_isShown = TRUE;
-
  #if wxUSE_MOUSEEVENT_HACK
      m_lastMouseX =
      m_lastMouseY = -1;
  #if wxUSE_MOUSEEVENT_HACK
      m_lastMouseX =
      m_lastMouseY = -1;
@@ -453,7 +454,7 @@ void wxWindowMSW::Init()
  // Destructor
  wxWindowMSW::~wxWindowMSW()
  {
  // Destructor
  wxWindowMSW::~wxWindowMSW()
  {
-    m_isBeingDeleted = TRUE;
+    m_isBeingDeleted = true;
  
  #ifndef __WXUNIVERSAL__
      // VS: make sure there's no wxFrame with last focus set to us:
  
  #ifndef __WXUNIVERSAL__
      // VS: make sure there's no wxFrame with last focus set to us:
@@ -500,10 +501,10 @@ bool wxWindowMSW::Create(wxWindow *parent,
                           long style,
                           const wxString& name)
  {
                           long style,
                           const wxString& name)
  {
-    wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
+    wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
  
      if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
  
      if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
-        return FALSE;
+        return false;
  
      parent->AddChild(this);
  
  
      parent->AddChild(this);
  
@@ -519,19 +520,17 @@ bool wxWindowMSW::Create(wxWindow *parent,
      msflags &= ~WS_BORDER;
  #endif // wxUniversal
  
      msflags &= ~WS_BORDER;
  #endif // wxUniversal
  
-    // all windows are created visible by default except popup ones (which are
-    // like the wxTopLevelWindows in this aspect)
-    if ( style & wxPOPUP_WINDOW )
-    {
-        msflags &= ~WS_VISIBLE;
-        m_isShown = FALSE;
-    }
-    else
+    if ( IsShown() )
      {
          msflags |= WS_VISIBLE;
      }
  
      {
          msflags |= WS_VISIBLE;
      }
  
-    return MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exstyle);
+    if ( !MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exstyle) )
+        return false;
+
+    InheritAttributes();
+
+    return true;
  }
  
  // ---------------------------------------------------------------------------
  }
  
  // ---------------------------------------------------------------------------
@@ -582,7 +581,7 @@ void wxWindowMSW::SetFocusFromKbd()
  }
  
  // Get the window with the focus
  }
  
  // Get the window with the focus
-wxWindow *wxWindowBase::FindFocus()
+wxWindow *wxWindowBase::DoFindFocus()
  {
      HWND hWnd = ::GetFocus();
      if ( hWnd )
  {
      HWND hWnd = ::GetFocus();
      if ( hWnd )
@@ -596,7 +595,7 @@ wxWindow *wxWindowBase::FindFocus()
  bool wxWindowMSW::Enable(bool enable)
  {
      if ( !wxWindowBase::Enable(enable) )
  bool wxWindowMSW::Enable(bool enable)
  {
      if ( !wxWindowBase::Enable(enable) )
-        return FALSE;
+        return false;
  
      HWND hWnd = GetHwnd();
      if ( hWnd )
  
      HWND hWnd = GetHwnd();
      if ( hWnd )
@@ -606,7 +605,7 @@ bool wxWindowMSW::Enable(bool enable)
      // showing a modal dialog would result in total greying out (and ungreying
      // out later) of everything which would be really ugly
      if ( IsTopLevel() )
      // showing a modal dialog would result in total greying out (and ungreying
      // out later) of everything which would be really ugly
      if ( IsTopLevel() )
-        return TRUE;
+        return true;
  
      // when the parent is disabled, all of its children should be disabled as
      // well but when it is enabled back, only those of the children which
  
      // when the parent is disabled, all of its children should be disabled as
      // well but when it is enabled back, only those of the children which
@@ -655,13 +654,13 @@ bool wxWindowMSW::Enable(bool enable)
          m_childrenDisabled = NULL;
      }
  
          m_childrenDisabled = NULL;
      }
  
-    return TRUE;
+    return true;
  }
  
  bool wxWindowMSW::Show(bool show)
  {
      if ( !wxWindowBase::Show(show) )
  }
  
  bool wxWindowMSW::Show(bool show)
  {
      if ( !wxWindowBase::Show(show) )
-        return FALSE;
+        return false;
  
      HWND hWnd = GetHwnd();
      int cshow = show ? SW_SHOW : SW_HIDE;
  
      HWND hWnd = GetHwnd();
      int cshow = show ? SW_SHOW : SW_HIDE;
@@ -672,7 +671,7 @@ bool wxWindowMSW::Show(bool show)
          wxBringWindowToTop(hWnd);
      }
  
          wxBringWindowToTop(hWnd);
      }
  
-    return TRUE;
+    return true;
  }
  
  // Raise the window to the top of the Z order
  }
  
  // Raise the window to the top of the Z order
@@ -726,7 +725,7 @@ bool wxWindowMSW::SetFont(const wxFont& font)
      if ( !wxWindowBase::SetFont(font) )
      {
          // nothing to do
      if ( !wxWindowBase::SetFont(font) )
      {
          // nothing to do
-        return FALSE;
+        return false;
      }
  
      HWND hWnd = GetHwnd();
      }
  
      HWND hWnd = GetHwnd();
@@ -739,14 +738,14 @@ bool wxWindowMSW::SetFont(const wxFont& font)
          ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
      }
  
          ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
      }
  
-    return TRUE;
+    return true;
  }
  bool wxWindowMSW::SetCursor(const wxCursor& cursor)
  {
      if ( !wxWindowBase::SetCursor(cursor) )
      {
          // no change
  }
  bool wxWindowMSW::SetCursor(const wxCursor& cursor)
  {
      if ( !wxWindowBase::SetCursor(cursor) )
      {
          // no change
-        return FALSE;
+        return false;
      }
  
      if ( m_cursor.Ok() )
      }
  
      if ( m_cursor.Ok() )
@@ -763,7 +762,7 @@ bool wxWindowMSW::SetCursor(const wxCursor& cursor)
              ::SetCursor(GetHcursorOf(m_cursor));
      }
  
              ::SetCursor(GetHcursorOf(m_cursor));
      }
  
-    return TRUE;
+    return true;
  }
  
  void wxWindowMSW::WarpPointer (int x, int y)
  }
  
  void wxWindowMSW::WarpPointer (int x, int y)
@@ -911,11 +910,12 @@ void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
      else
      {
          pr = NULL;
      else
      {
          pr = NULL;
+
      }
  
  #ifdef __WXWINCE__
      // FIXME: is this the exact equivalent of the line below?
      }
  
  #ifdef __WXWINCE__
      // FIXME: is this the exact equivalent of the line below?
-    ::ScrollWindowEx(GetHwnd(), dx, dy, pr, pr, 0, 0, SW_ERASE|SW_INVALIDATE);
+    ::ScrollWindowEx(GetHwnd(), dx, dy, pr, pr, 0, 0, SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
  #else
      ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
  #endif
  #else
      ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
  #endif
@@ -974,19 +974,19 @@ void wxWindowMSW::SubclassWin(WXHWND hWnd)
  
      wxAssociateWinWithHandle(hwnd, this);
  
  
      wxAssociateWinWithHandle(hwnd, this);
  
-    m_oldWndProc = (WXFARPROC)::GetWindowLong((HWND)hWnd, GWL_WNDPROC);
+    m_oldWndProc = (WXFARPROC)wxGetWindowProc((HWND)hWnd);
  
      // we don't need to subclass the window of our own class (in the Windows
      // sense of the word)
  
      // we don't need to subclass the window of our own class (in the Windows
      // sense of the word)
-       if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )
+    if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )
      {
      {
-        ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
+        wxSetWindowProc(hwnd, wxWndProc);
      }
      else
      {
          // don't bother restoring it neither: this also makes it easy to
      }
      else
      {
          // don't bother restoring it neither: this also makes it easy to
-        // implement IsOfStandardClass() method which returns TRUE for the
-        // standard controls and FALSE for the wxWindows own windows as it can
+        // implement IsOfStandardClass() method which returns true for the
+        // standard controls and false for the wxWidgets own windows as it can
          // simply check m_oldWndProc
          m_oldWndProc = NULL;
      }
          // simply check m_oldWndProc
          m_oldWndProc = NULL;
      }
@@ -1000,7 +1000,7 @@ void wxWindowMSW::UnsubclassWin()
      HWND hwnd = GetHwnd();
      if ( hwnd )
      {
      HWND hwnd = GetHwnd();
      if ( hwnd )
      {
-        m_hWnd = 0;
+        SetHWND(0);
  
          wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
  
  
          wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
  
@@ -1008,7 +1008,7 @@ void wxWindowMSW::UnsubclassWin()
          {
              if ( !wxCheckWindowWndProc((WXHWND)hwnd, m_oldWndProc) )
              {
          {
              if ( !wxCheckWindowWndProc((WXHWND)hwnd, m_oldWndProc) )
              {
-                ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) m_oldWndProc);
+                wxSetWindowProc(hwnd, (WNDPROC)m_oldWndProc);
              }
  
              m_oldWndProc = NULL;
              }
  
              m_oldWndProc = NULL;
@@ -1016,6 +1016,27 @@ void wxWindowMSW::UnsubclassWin()
      }
  }
  
      }
  }
  
+void wxWindowMSW::AssociateHandle(WXWidget handle)
+{
+    if ( m_hWnd )
+    {
+      if ( !::DestroyWindow(GetHwnd()) )
+        wxLogLastError(wxT("DestroyWindow"));
+    }
+
+    WXHWND wxhwnd = (WXHWND)handle;
+
+    SetHWND(wxhwnd);
+    SubclassWin(wxhwnd);
+}
+
+void wxWindowMSW::DissociateHandle()
+{
+    // this also calls SetHWND(0) for us
+    UnsubclassWin();
+}
+
+
  bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
  {
      // Unicows note: the code below works, but only because WNDCLASS contains
  bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
  {
      // Unicows note: the code below works, but only because WNDCLASS contains
@@ -1025,33 +1046,33 @@ bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
      // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
      // versions that keep track of fake<->real wnd proc mapping.
  
      // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
      // versions that keep track of fake<->real wnd proc mapping.
  
-       // On WinCE (at least), the wndproc comparison doesn't work,
-       // so have to use something like this.
+    // On WinCE (at least), the wndproc comparison doesn't work,
+    // so have to use something like this.
  #ifdef __WXWINCE__
  #ifdef __WXWINCE__
-       extern const wxChar *wxCanvasClassName;
-       extern const wxChar *wxCanvasClassNameNR;
-       extern const wxChar *wxMDIFrameClassName;
-       extern const wxChar *wxMDIFrameClassNameNoRedraw;
-       extern const wxChar *wxMDIChildFrameClassName;
-       extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
-       wxString str(wxGetWindowClass(hWnd));
-       if (str == wxCanvasClassName ||
-               str == wxCanvasClassNameNR ||
-               str == wxMDIFrameClassName ||
-               str == wxMDIFrameClassNameNoRedraw ||
-               str == wxMDIChildFrameClassName ||
-               str == wxMDIChildFrameClassNameNoRedraw ||
-               str == _T("wxTLWHiddenParent"))
-               return TRUE; // Effectively means don't subclass
-       else
-               return FALSE;
+    extern       wxChar *wxCanvasClassName;
+    extern       wxChar *wxCanvasClassNameNR;
+    extern const wxChar *wxMDIFrameClassName;
+    extern const wxChar *wxMDIFrameClassNameNoRedraw;
+    extern const wxChar *wxMDIChildFrameClassName;
+    extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
+    wxString str(wxGetWindowClass(hWnd));
+    if (str == wxCanvasClassName ||
+        str == wxCanvasClassNameNR ||
+        str == wxMDIFrameClassName ||
+        str == wxMDIFrameClassNameNoRedraw ||
+        str == wxMDIChildFrameClassName ||
+        str == wxMDIChildFrameClassNameNoRedraw ||
+        str == _T("wxTLWHiddenParent"))
+        return true; // Effectively means don't subclass
+    else
+        return false;
  #else
      WNDCLASS cls;
      if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd), &cls) )
      {
          wxLogLastError(_T("GetClassInfo"));
  
  #else
      WNDCLASS cls;
      if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd), &cls) )
      {
          wxLogLastError(_T("GetClassInfo"));
  
-        return FALSE;
+        return false;
      }
  
      return wndProc == (WXFARPROC)cls.lpfnWndProc;
      }
  
      return wndProc == (WXFARPROC)cls.lpfnWndProc;
@@ -1118,8 +1139,11 @@ void wxWindowMSW::SetWindowStyleFlag(long flags)
  
  WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
  {
  
  WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
  {
-    // translate the style
-    WXDWORD style = WS_CHILD | WS_VISIBLE;
+    // translate common wxWidgets styles to Windows ones
+
+    // most of windows are child ones, those which are not (such as
+    // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
+    WXDWORD style = WS_CHILD;
  
      if ( flags & wxCLIP_CHILDREN )
          style |= WS_CLIPCHILDREN;
  
      if ( flags & wxCLIP_CHILDREN )
          style |= WS_CLIPCHILDREN;
@@ -1224,7 +1248,7 @@ void wxWindowMSW::OnInternalIdle()
          if ( !IsMouseInWindow() )
          {
              // Generate a LEAVE event
          if ( !IsMouseInWindow() )
          {
              // Generate a LEAVE event
-            m_mouseInWindow = FALSE;
+            m_mouseInWindow = false;
  
              // Unfortunately the mouse button and keyboard state may have
              // changed by the time the OnInternalIdle function is called, so 'state'
  
              // Unfortunately the mouse button and keyboard state may have
              // changed by the time the OnInternalIdle function is called, so 'state'
@@ -1268,7 +1292,7 @@ void wxWindowMSW::OnInternalIdle()
  bool wxWindowMSW::Reparent(wxWindowBase *parent)
  {
      if ( !wxWindowBase::Reparent(parent) )
  bool wxWindowMSW::Reparent(wxWindowBase *parent)
  {
      if ( !wxWindowBase::Reparent(parent) )
-        return FALSE;
+        return false;
  
      HWND hWndChild = GetHwnd();
      HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
  
      HWND hWndChild = GetHwnd();
      HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
@@ -1282,7 +1306,7 @@ bool wxWindowMSW::Reparent(wxWindowBase *parent)
      }
  #endif // !__WXWINCE__
  
      }
  #endif // !__WXWINCE__
  
-    return TRUE;
+    return true;
  }
  
  static inline void SendSetRedraw(HWND hwnd, bool on)
  }
  
  static inline void SendSetRedraw(HWND hwnd, bool on)
@@ -1294,16 +1318,24 @@ static inline void SendSetRedraw(HWND hwnd, bool on)
  
  void wxWindowMSW::Freeze()
  {
  
  void wxWindowMSW::Freeze()
  {
-    SendSetRedraw(GetHwnd(), FALSE);
+    if ( !m_frozenness++ )
+    {
+        SendSetRedraw(GetHwnd(), false);
+    }
  }
  
  void wxWindowMSW::Thaw()
  {
  }
  
  void wxWindowMSW::Thaw()
  {
-    SendSetRedraw(GetHwnd(), TRUE);
+    wxASSERT_MSG( m_frozenness > 0, _T("Thaw() without matching Freeze()") );
+
+    if ( !--m_frozenness )
+    {
+        SendSetRedraw(GetHwnd(), true);
  
  
-    // we need to refresh everything or otherwise he invalidated area is not
-    // repainted
-    Refresh();
+        // we need to refresh everything or otherwise he invalidated area is not
+        // repainted
+        Refresh();
+    }
  }
  
  void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
  }
  
  void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
@@ -1367,6 +1399,8 @@ void wxWindowMSW::DragAcceptFiles(bool accept)
      HWND hWnd = GetHwnd();
      if ( hWnd )
          ::DragAcceptFiles(hWnd, (BOOL)accept);
      HWND hWnd = GetHwnd();
      if ( hWnd )
          ::DragAcceptFiles(hWnd, (BOOL)accept);
+#else
+    wxUnusedVar(accept);
  #endif
  }
  
  #endif
  }
  
@@ -1492,7 +1526,7 @@ void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
          width = 0;
      if (height < 0)
          height = 0;
          width = 0;
      if (height < 0)
          height = 0;
-    if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
+    if ( !::MoveWindow(GetHwnd(), x, y, width, height, IsShown() /*Repaint?*/) )
      {
          wxLogLastError(wxT("MoveWindow"));
      }
      {
          wxLogLastError(wxT("MoveWindow"));
      }
@@ -1521,15 +1555,15 @@ void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
          return;
      }
  
          return;
      }
  
-    if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+    if ( x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
          x = currentX;
          x = currentX;
-    if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+    if ( y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
          y = currentY;
  
      AdjustForParentClientOrigin(x, y, sizeFlags);
  
          y = currentY;
  
      AdjustForParentClientOrigin(x, y, sizeFlags);
  
-    wxSize size(-1, -1);
-    if ( width == -1 )
+    wxSize size = wxDefaultSize;
+    if ( width == wxDefaultCoord )
      {
          if ( sizeFlags & wxSIZE_AUTO_WIDTH )
          {
      {
          if ( sizeFlags & wxSIZE_AUTO_WIDTH )
          {
@@ -1543,11 +1577,11 @@ void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
          }
      }
  
          }
      }
  
-    if ( height == -1 )
+    if ( height == wxDefaultCoord )
      {
          if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
          {
      {
          if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
          {
-            if ( size.x == -1 )
+            if ( size.x == wxDefaultCoord )
              {
                  size = DoGetBestSize();
              }
              {
                  size = DoGetBestSize();
              }
@@ -1585,8 +1619,8 @@ void wxWindowMSW::DoSetClientSize(int width, int height)
          ::GetClientRect(GetHwnd(), &rectClient);
  
          // if the size is already ok, stop here (rectClient.left = top = 0)
          ::GetClientRect(GetHwnd(), &rectClient);
  
          // if the size is already ok, stop here (rectClient.left = top = 0)
-        if ( (rectClient.right == width || width == -1) &&
-             (rectClient.bottom == height || height == -1) )
+        if ( (rectClient.right == width || width == wxDefaultCoord) &&
+             (rectClient.bottom == height || height == wxDefaultCoord) )
          {
              break;
          }
          {
              break;
          }
@@ -1654,31 +1688,22 @@ void wxWindowMSW::GetTextExtent(const wxString& string,
                               int *descent, int *externalLeading,
                               const wxFont *theFont) const
  {
                               int *descent, int *externalLeading,
                               const wxFont *theFont) const
  {
-    const wxFont *fontToUse = theFont;
-    if ( !fontToUse )
-        fontToUse = &m_font;
+    wxASSERT_MSG( !theFont || theFont->Ok(),
+                    _T("invalid font in GetTextExtent()") );
  
  
-    HWND hWnd = GetHwnd();
-    HDC dc = ::GetDC(hWnd);
+    wxFont fontToUse;
+    if (theFont)
+        fontToUse = *theFont;
+    else
+        fontToUse = GetFont();
  
  
-    HFONT fnt = 0;
-    HFONT hfontOld = 0;
-    if ( fontToUse && fontToUse->Ok() )
-    {
-        fnt = (HFONT)((wxFont *)fontToUse)->GetResourceHandle(); // const_cast
-        if ( fnt )
-            hfontOld = (HFONT)SelectObject(dc,fnt);
-    }
+    WindowHDC hdc(GetHwnd());
+    SelectInHDC selectFont(hdc, GetHfontOf(fontToUse));
  
      SIZE sizeRect;
      TEXTMETRIC tm;
  
      SIZE sizeRect;
      TEXTMETRIC tm;
-    GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
-    GetTextMetrics(dc, &tm);
-
-    if ( fontToUse && fnt && hfontOld )
-        SelectObject(dc, hfontOld);
-
-    ReleaseDC(hWnd, dc);
+    GetTextExtentPoint(hdc, string, string.length(), &sizeRect);
+    GetTextMetrics(hdc, &tm);
  
      if ( x )
          *x = sizeRect.cx;
  
      if ( x )
          *x = sizeRect.cx;
@@ -1728,6 +1753,12 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
      menu->SetInvokingWindow(this);
      menu->UpdateUI();
  
      menu->SetInvokingWindow(this);
      menu->UpdateUI();
  
+    if ( x == wxDefaultCoord && y == wxDefaultCoord )
+    {
+        wxPoint mouse = ScreenToClient(wxGetMousePosition());
+        x = mouse.x; y = mouse.y;
+    }
+
      HWND hWnd = GetHwnd();
      HMENU hMenu = GetHmenuOf(menu);
      POINT point;
      HWND hWnd = GetHwnd();
      HMENU hMenu = GetHmenuOf(menu);
      POINT point;
@@ -1735,9 +1766,10 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
      point.y = y;
      ::ClientToScreen(hWnd, &point);
      wxCurrentPopupMenu = menu;
      point.y = y;
      ::ClientToScreen(hWnd, &point);
      wxCurrentPopupMenu = menu;
+#if defined(__WXWINCE__)
      UINT flags = 0;
      UINT flags = 0;
-#if !defined(__WXWINCE__)
-    flags = TPM_RIGHTBUTTON;
+#else
+    UINT flags = TPM_RIGHTBUTTON;
  #endif
      ::TrackPopupMenu(hMenu, flags, point.x, point.y, 0, hWnd, NULL);
  
  #endif
      ::TrackPopupMenu(hMenu, flags, point.x, point.y, 0, hWnd, NULL);
  
@@ -1754,7 +1786,7 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
  
      menu->SetInvokingWindow(NULL);
  
  
      menu->SetInvokingWindow(NULL);
  
-    return TRUE;
+    return true;
  }
  
  #endif // wxUSE_MENUS_NATIVE
  }
  
  #endif // wxUSE_MENUS_NATIVE
@@ -1763,7 +1795,7 @@ bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
  // pre/post message processing
  // ===========================================================================
  
  // pre/post message processing
  // ===========================================================================
  
-long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+WXLRESULT wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
  {
      if ( m_oldWndProc )
          return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
  {
      if ( m_oldWndProc )
          return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
@@ -1805,19 +1837,16 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                  }
              }
  
                  }
              }
  
-            bool bForward = TRUE,
-                 bWindowChange = FALSE;
+            bool bForward = true,
+                 bWindowChange = false;
  
              // should we process this message specially?
  
              // should we process this message specially?
-            bool bProcess = TRUE;
+            bool bProcess = true;
              switch ( msg->wParam )
              {
                  case VK_TAB:
              switch ( msg->wParam )
              {
                  case VK_TAB:
-                    // assume that nobody wants Shift-TAB for himself - if we
-                    // don't do it there is no easy way for a control to grab
-                    // TABs but still let Shift-TAB work as navugation key
-                    if ( (lDlgCode & DLGC_WANTTAB) && !bShiftDown ) {
-                        bProcess = FALSE;
+                    if ( lDlgCode & DLGC_WANTTAB ) {
+                        bProcess = false;
                      }
                      else {
                          // Ctrl-Tab cycles thru notebook pages
                      }
                      else {
                          // Ctrl-Tab cycles thru notebook pages
@@ -1829,15 +1858,34 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                  case VK_UP:
                  case VK_LEFT:
                      if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
                  case VK_UP:
                  case VK_LEFT:
                      if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
-                        bProcess = FALSE;
+                        bProcess = false;
                      else
                      else
-                        bForward = FALSE;
+                        bForward = false;
                      break;
  
                  case VK_DOWN:
                  case VK_RIGHT:
                      if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
                      break;
  
                  case VK_DOWN:
                  case VK_RIGHT:
                      if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
-                        bProcess = FALSE;
+                        bProcess = false;
+                    break;
+
+                case VK_ESCAPE:
+                    {
+#if wxUSE_BUTTON
+                        wxButton *btn = wxDynamicCast(FindWindow(wxID_CANCEL),
+                                                      wxButton);
+                        if ( btn && btn->IsEnabled() )
+                        {
+                            // if we do have a cancel button, do press it
+                            btn->MSWCommand(BN_CLICKED, 0 /* unused */);
+
+                            // we consumed the message
+                            return true;
+                        }
+#endif // wxUSE_BUTTON
+
+                        bProcess = false;
+                    }
                      break;
  
                  case VK_RETURN:
                      break;
  
                  case VK_RETURN:
@@ -1847,7 +1895,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                              // control wants to process Enter itself, don't
                              // call IsDialogMessage() which would interpret
                              // it
                              // control wants to process Enter itself, don't
                              // call IsDialogMessage() which would interpret
                              // it
-                            return FALSE;
+                            return false;
                          }
                          else if ( lDlgCode & DLGC_BUTTON )
                          {
                          }
                          else if ( lDlgCode & DLGC_BUTTON )
                          {
@@ -1863,7 +1911,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                      btn->MSWCommand(BN_CLICKED, 0 /* unused */);
                              }
  
                                      btn->MSWCommand(BN_CLICKED, 0 /* unused */);
                              }
  
-                            bProcess = FALSE;
+                            bProcess = false;
                          }
                          // FIXME: this should be handled by
                          //        wxNavigationKeyEvent handler and not here!!
                          }
                          // FIXME: this should be handled by
                          //        wxNavigationKeyEvent handler and not here!!
@@ -1877,11 +1925,11 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                  // if we do have a default button, do press it
                                  btn->MSWCommand(BN_CLICKED, 0 /* unused */);
  
                                  // if we do have a default button, do press it
                                  btn->MSWCommand(BN_CLICKED, 0 /* unused */);
  
-                                return TRUE;
+                                return true;
                              }
                              else // no default button
                              }
                              else // no default button
-                            {
  #endif // wxUSE_BUTTON
  #endif // wxUSE_BUTTON
+                            {
                                  // this is a quick and dirty test for a text
                                  // control
                                  if ( !(lDlgCode & DLGC_HASSETSEL) )
                                  // this is a quick and dirty test for a text
                                  // control
                                  if ( !(lDlgCode & DLGC_HASSETSEL) )
@@ -1890,13 +1938,13 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                      // need it for itself and don't let
                                      // ::IsDialogMessage() have it as it can
                                      // eat the Enter events sometimes
                                      // need it for itself and don't let
                                      // ::IsDialogMessage() have it as it can
                                      // eat the Enter events sometimes
-                                    return FALSE;
+                                    return false;
                                  }
                                  else if (!IsTopLevel())
                                  {
                                      // if not a top level window, let parent
                                      // handle it
                                  }
                                  else if (!IsTopLevel())
                                  {
                                      // if not a top level window, let parent
                                      // handle it
-                                    return FALSE;
+                                    return false;
                                  }
                                  //else: treat Enter as TAB: pass to the next
                                  //      control as this is the best thing to do
                                  }
                                  //else: treat Enter as TAB: pass to the next
                                  //      control as this is the best thing to do
@@ -1907,7 +1955,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                      break;
  
                  default:
                      break;
  
                  default:
-                    bProcess = FALSE;
+                    bProcess = false;
              }
  
              if ( bProcess )
              }
  
              if ( bProcess )
@@ -1919,7 +1967,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
  
                  if ( GetEventHandler()->ProcessEvent(event) )
                  {
  
                  if ( GetEventHandler()->ProcessEvent(event) )
                  {
-                    return TRUE;
+                    return true;
                  }
              }
          }
                  }
              }
          }
@@ -1953,8 +2001,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
          }
  #endif // 1/0
  
          }
  #endif // 1/0
  
-        // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
-        // shouldn't let IsDialogMessage() get it as it _always_ eats the
+        // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
          // message even when there is no cancel button and when the message is
          // needed by the control itself: in particular, it prevents the tree in
          // place edit control from being closed with Escape in a dialog
          // message even when there is no cancel button and when the message is
          // needed by the control itself: in particular, it prevents the tree in
          // place edit control from being closed with Escape in a dialog
@@ -1966,7 +2013,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
              // then
  
              // assume we can call it by default
              // then
  
              // assume we can call it by default
-            bool canSafelyCallIsDlgMsg = TRUE;
+            bool canSafelyCallIsDlgMsg = true;
  
              HWND hwndFocus = ::GetFocus();
  
  
              HWND hwndFocus = ::GetFocus();
  
@@ -1984,7 +2031,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
              if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
              {
                  // passimistic by default
              if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
              {
                  // passimistic by default
-                canSafelyCallIsDlgMsg = FALSE;
+                canSafelyCallIsDlgMsg = false;
                  for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
                        node;
                        node = node->GetNext() )
                  for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
                        node;
                        node = node->GetNext() )
@@ -1995,7 +2042,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                                  WS_EX_CONTROLPARENT) )
                      {
                          // it shouldn't hang...
                                  WS_EX_CONTROLPARENT) )
                      {
                          // it shouldn't hang...
-                        canSafelyCallIsDlgMsg = TRUE;
+                        canSafelyCallIsDlgMsg = true;
  
                          break;
                      }
  
                          break;
                      }
@@ -2015,7 +2062,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
                              !::IsWindowVisible(hwndFocus) )
                      {
                          // it would enter an infinite loop if we do this!
                              !::IsWindowVisible(hwndFocus) )
                      {
                          // it would enter an infinite loop if we do this!
-                        canSafelyCallIsDlgMsg = FALSE;
+                        canSafelyCallIsDlgMsg = false;
  
                          break;
                      }
  
                          break;
                      }
@@ -2036,7 +2083,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
              if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
              {
                  // IsDialogMessage() did something...
              if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
              {
                  // IsDialogMessage() did something...
-                return TRUE;
+                return true;
              }
          }
      }
              }
          }
      }
@@ -2052,7 +2099,7 @@ bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
      }
  #endif // wxUSE_TOOLTIPS
  
      }
  #endif // wxUSE_TOOLTIPS
  
-    return FALSE;
+    return false;
  }
  
  bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
  }
  
  bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
@@ -2061,14 +2108,14 @@ bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
      return m_acceleratorTable.Translate(this, pMsg);
  #else
      (void) pMsg;
      return m_acceleratorTable.Translate(this, pMsg);
  #else
      (void) pMsg;
-    return FALSE;
+    return false;
  #endif // wxUSE_ACCEL
  }
  
  bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
  {
      // preprocess all messages by default
  #endif // wxUSE_ACCEL
  }
  
  bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
  {
      // preprocess all messages by default
-    return TRUE;
+    return true;
  }
  
  // ---------------------------------------------------------------------------
  }
  
  // ---------------------------------------------------------------------------
@@ -2118,7 +2165,7 @@ void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
  }
  
  // ---------------------------------------------------------------------------
  }
  
  // ---------------------------------------------------------------------------
-// Main wxWindows window proc and the window proc for wxWindow
+// Main wxWidgets window proc and the window proc for wxWindow
  // ---------------------------------------------------------------------------
  
  // Hook for new window just as it's being created, when the window isn't yet
  // ---------------------------------------------------------------------------
  
  // Hook for new window just as it's being created, when the window isn't yet
@@ -2169,16 +2216,16 @@ LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM w
      return rc;
  }
  
      return rc;
  }
  
-long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+WXLRESULT wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
  {
      // did we process the message?
  {
      // did we process the message?
-    bool processed = FALSE;
+    bool processed = false;
  
      // the return value
      union
      {
          bool        allow;
  
      // the return value
      union
      {
          bool        allow;
-        long        result;
+        WXLRESULT   result;
          WXHICON     hIcon;
          WXHBRUSH    hBrush;
      } rc;
          WXHICON     hIcon;
          WXHBRUSH    hBrush;
      } rc;
@@ -2201,7 +2248,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
              break;
  
          case WM_DESTROY:
              break;
  
          case WM_DESTROY:
-            // never set processed to TRUE and *always* pass WM_DESTROY to
+            // never set processed to true and *always* pass WM_DESTROY to
              // DefWindowProc() as Windows may do some internal cleanup when
              // processing it and failing to pass the message along may cause
              // memory and resource leaks!
              // DefWindowProc() as Windows may do some internal cleanup when
              // processing it and failing to pass the message along may cause
              // memory and resource leaks!
@@ -2233,31 +2280,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
  #endif
  
          case WM_SIZE:
  #endif
  
          case WM_SIZE:
-            switch ( wParam )
-            {
-                case SIZE_MAXHIDE:
-                case SIZE_MAXSHOW:
-                    // we're not interested in these messages at all
-                    break;
-
-                case SIZE_MINIMIZED:
-                    // we shouldn't send sizev events for these messages as the
-                    // client size may be negative which breaks existing code
-                    //
-                    // OTOH we might send another (wxMinimizedEvent?) one or
-                    // add an additional parameter to wxSizeEvent if this is
-                    // useful to anybody
-                    break;
-
-                default:
-                    wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
-                    // fall through nevertheless
-
-                case SIZE_MAXIMIZED:
-                case SIZE_RESTORED:
-                    processed = HandleSize(LOWORD(lParam), HIWORD(lParam),
-                                           wParam);
-            }
+            processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
              break;
  
  #if !defined(__WXWINCE__)
              break;
  
  #if !defined(__WXWINCE__)
@@ -2322,9 +2345,11 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
  #ifndef __WXWINCE__
          case WM_PRINT:
              {
  #ifndef __WXWINCE__
          case WM_PRINT:
              {
+#if wxUSE_LISTCTRL
                  // Don't call the wx handlers in this case
                  if ( wxIsKindOf(this, wxListCtrl) )
                      break;
                  // Don't call the wx handlers in this case
                  if ( wxIsKindOf(this, wxListCtrl) )
                      break;
+#endif
  
                  if ( lParam & PRF_ERASEBKGND )
                      HandleEraseBkgnd((WXHDC)(HDC)wParam);
  
                  if ( lParam & PRF_ERASEBKGND )
                      HandleEraseBkgnd((WXHDC)(HDC)wParam);
@@ -2340,12 +2365,12 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
              // Universal uses its own wxFrame/wxDialog, so we don't receive
              // close events unless we have this.
              Close();
              // Universal uses its own wxFrame/wxDialog, so we don't receive
              // close events unless we have this.
              Close();
-            processed = TRUE;
+            processed = true;
              rc.result = TRUE;
  #else
              // don't let the DefWindowProc() destroy our window - we'll do it
              // ourselves in ~wxWindow
              rc.result = TRUE;
  #else
              // don't let the DefWindowProc() destroy our window - we'll do it
              // ourselves in ~wxWindow
-            processed = TRUE;
+            processed = true;
              rc.result = TRUE;
  #endif
              break;
              rc.result = TRUE;
  #endif
              break;
@@ -2365,18 +2390,18 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
          case WM_MOUSELEAVE:
             {
              wxASSERT_MSG( !m_mouseInWindow, wxT("the mouse should be in a window to generate this event!") );
          case WM_MOUSELEAVE:
             {
              wxASSERT_MSG( !m_mouseInWindow, wxT("the mouse should be in a window to generate this event!") );
-           
+
              // only process this message if the mouse is not in the window,
              // only process this message if the mouse is not in the window,
-            // This can also check for children in composite windows. 
+            // This can also check for children in composite windows.
              // however, this may mean the the wxEVT_LEAVE_WINDOW is never sent
              // however, this may mean the the wxEVT_LEAVE_WINDOW is never sent
-            // if the mouse does not enter the window from it's child before 
+            // if the mouse does not enter the window from it's child before
              // leaving the scope of the window. ( perhaps this can be picked
              // up in the OnIdle code as before, for this special case )
              if ( /*IsComposite() && */ !IsMouseInWindow() )
              {
              // leaving the scope of the window. ( perhaps this can be picked
              // up in the OnIdle code as before, for this special case )
              if ( /*IsComposite() && */ !IsMouseInWindow() )
              {
-                m_mouseInWindow = FALSE;
+                m_mouseInWindow = false;
  
  
-                // Unfortunately no mouse state is passed with a WM_MOUSE_LEAVE 
+                // Unfortunately no mouse state is passed with a WM_MOUSE_LEAVE
                  int state = 0;
                  if ( wxIsShiftDown() )
                      state |= MK_SHIFT;
                  int state = 0;
                  if ( wxIsShiftDown() )
                      state |= MK_SHIFT;
@@ -2415,7 +2440,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             break;
  #endif
   // __WXWINCE__
             break;
  #endif
   // __WXWINCE__
-           
+
  #if wxUSE_MOUSEWHEEL
          case WM_MOUSEWHEEL:
              processed = HandleMouseWheel(wParam, lParam);
  #if wxUSE_MOUSEWHEEL
          case WM_MOUSEWHEEL:
              processed = HandleMouseWheel(wParam, lParam);
@@ -2441,7 +2466,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                  {
                      if (!win->IsEnabled())
                      {
                  {
                      if (!win->IsEnabled())
                      {
-                        processed = TRUE;
+                        processed = true;
                          break;
                      }
  
                          break;
                      }
  
@@ -2473,19 +2498,23 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                      // this should never happen
                      wxCHECK_MSG( win, 0,
                                   _T("FindWindowForMouseEvent() returned NULL") );
                      // this should never happen
                      wxCHECK_MSG( win, 0,
                                   _T("FindWindowForMouseEvent() returned NULL") );
+                }
  
  
+                processed = win->HandleMouseEvent(message, x, y, wParam);
+
+                // if the app didn't eat the event, handle it in the default
+                // way, that is by giving this window the focus
+                if ( !processed )
+                {
                      // for the standard classes their WndProc sets the focus to
                      // them anyhow and doing it from here results in some weird
                      // for the standard classes their WndProc sets the focus to
                      // them anyhow and doing it from here results in some weird
-                    // problems, but for our windows we want them to acquire
-                    // focus when clicked
+                    // problems, so don't do it for them (unnecessary anyhow)
                      if ( !win->IsOfStandardClass() )
                      {
                          if ( message == WM_LBUTTONDOWN && win->AcceptsFocus() )
                              win->SetFocus();
                      }
                  }
                      if ( !win->IsOfStandardClass() )
                      {
                          if ( message == WM_LBUTTONDOWN && win->AcceptsFocus() )
                              win->SetFocus();
                      }
                  }
-
-                processed = win->HandleMouseEvent(message, x, y, wParam);
              }
              break;
  
              }
              break;
  
@@ -2505,10 +2534,6 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
              break;
  #endif // __WXMICROWIN__
  
              break;
  #endif // __WXMICROWIN__
  
-        case WM_SYSCOMMAND:
-            processed = HandleSysCommand(wParam, lParam);
-            break;
-
          case WM_COMMAND:
              {
                  WORD id, cmd;
          case WM_COMMAND:
              {
                  WORD id, cmd;
@@ -2523,7 +2548,20 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
              processed = HandleNotify((int)wParam, lParam, &rc.result);
              break;
  
              processed = HandleNotify((int)wParam, lParam, &rc.result);
              break;
  
-            // for these messages we must return TRUE if process the message
+        // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
+        // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
+        // apparently doesn't always behave properly and needs some help
+#if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
+        case WM_NOTIFYFORMAT:
+            if ( lParam == NF_QUERY )
+            {
+                processed = true;
+                rc.result = NFR_UNICODE;
+            }
+            break;
+#endif // wxUSE_UNICODE_MSLU
+
+            // for these messages we must return true if process the message
  #ifdef WM_DRAWITEM
          case WM_DRAWITEM:
          case WM_MEASUREITEM:
  #ifdef WM_DRAWITEM
          case WM_DRAWITEM:
          case WM_MEASUREITEM:
@@ -2560,7 +2598,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                                   DLGC_WANTALLKEYS;
                  }
  
                                   DLGC_WANTALLKEYS;
                  }
  
-                processed = TRUE;
+                processed = true;
              }
              //else: get the dlg code from the DefWindowProc()
              break;
              }
              //else: get the dlg code from the DefWindowProc()
              break;
@@ -2572,7 +2610,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
              m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
              if ( m_lastKeydownProcessed )
              {
              m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
              if ( m_lastKeydownProcessed )
              {
-                processed = TRUE;
+                processed = true;
              }
  
              if ( !processed )
              }
  
              if ( !processed )
@@ -2587,7 +2625,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                      case VK_CAPITAL:
                      case VK_NUMLOCK:
                      case VK_SCROLL:
                      case VK_CAPITAL:
                      case VK_NUMLOCK:
                      case VK_SCROLL:
-                        processed = TRUE;
+                        processed = true;
                          break;
  
                      // avoid duplicate messages to OnChar for these ASCII keys:
                          break;
  
                      // avoid duplicate messages to OnChar for these ASCII keys:
@@ -2613,23 +2651,17 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                      case VK_OEM_COMMA:
                      case VK_OEM_MINUS:
                      case VK_OEM_PERIOD:
                      case VK_OEM_COMMA:
                      case VK_OEM_MINUS:
                      case VK_OEM_PERIOD:
-                        // but set processed to FALSE, not TRUE to still pass them
+                        // but set processed to false, not true to still pass them
                          // to the control's default window proc - otherwise
                          // built-in keyboard handling won't work
                          // to the control's default window proc - otherwise
                          // built-in keyboard handling won't work
-                        processed = FALSE;
+                        processed = false;
                          break;
  
  #ifdef VK_APPS
                      // special case of VK_APPS: treat it the same as right mouse
                      // click because both usually pop up a context menu
                      case VK_APPS:
                          break;
  
  #ifdef VK_APPS
                      // special case of VK_APPS: treat it the same as right mouse
                      // click because both usually pop up a context menu
                      case VK_APPS:
-                        {
-                            WPARAM flags;
-                            int x, y;
-
-                            TranslateKbdEventToMouse(this, &x, &y, &flags);
-                            processed = HandleMouseEvent(WM_RBUTTONDOWN, x, y, flags);
-                        }
+                        processed = HandleMouseEvent(WM_RBUTTONDOWN, -1, -1, 0);
                          break;
  #endif // VK_APPS
  
                          break;
  #endif // VK_APPS
  
@@ -2639,7 +2671,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                  }
              }
              if (message == WM_SYSKEYDOWN)  // Let Windows still handle the SYSKEYs
                  }
              }
              if (message == WM_SYSKEYDOWN)  // Let Windows still handle the SYSKEYs
-                processed = FALSE;
+                processed = false;
              break;
  
          case WM_SYSKEYUP:
              break;
  
          case WM_SYSKEYUP:
@@ -2648,11 +2680,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
              // special case of VK_APPS: treat it the same as right mouse button
              if ( wParam == VK_APPS )
              {
              // special case of VK_APPS: treat it the same as right mouse button
              if ( wParam == VK_APPS )
              {
-                WPARAM flags;
-                int x, y;
-
-                TranslateKbdEventToMouse(this, &x, &y, &flags);
-                processed = HandleMouseEvent(WM_RBUTTONUP, x, y, flags);
+                processed = HandleMouseEvent(WM_RBUTTONUP, -1, -1, 0);
              }
              else
  #endif // VK_APPS
              }
              else
  #endif // VK_APPS
@@ -2668,12 +2696,12 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                  // The key was handled in the EVT_KEY_DOWN and handling
                  // a key in an EVT_KEY_DOWN handler is meant, by
                  // design, to prevent EVT_CHARs from happening
                  // The key was handled in the EVT_KEY_DOWN and handling
                  // a key in an EVT_KEY_DOWN handler is meant, by
                  // design, to prevent EVT_CHARs from happening
-                m_lastKeydownProcessed = FALSE;
-                processed = TRUE;
+                m_lastKeydownProcessed = false;
+                processed = true;
              }
              else
              {
              }
              else
              {
-                processed = HandleChar((WORD)wParam, lParam, TRUE);
+                processed = HandleChar((WORD)wParam, lParam, true);
              }
              break;
  
              }
              break;
  
@@ -2824,7 +2852,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                  {
  #endif
                      wxWindowMSW* subjectOfHelp = this;
                  {
  #endif
                      wxWindowMSW* subjectOfHelp = this;
-                    bool eventProcessed = FALSE;
+                    bool eventProcessed = false;
                      while (subjectOfHelp && !eventProcessed)
                      {
                          wxHelpEvent helpEvent(wxEVT_HELP,
                      while (subjectOfHelp && !eventProcessed)
                      {
                          wxHelpEvent helpEvent(wxEVT_HELP,
@@ -2855,7 +2883,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                      processed = GetEventHandler()->ProcessEvent(helpEvent);
  
                  }
                      processed = GetEventHandler()->ProcessEvent(helpEvent);
  
                  }
-                //else: processed is already FALSE
+                //else: processed is already false
  #endif
              }
              break;
  #endif
              }
              break;
@@ -2869,8 +2897,20 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                  wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
  
                  wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
                  wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
  
                  wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
-                evtCtx.SetEventObject(this);
-                processed = GetEventHandler()->ProcessEvent(evtCtx);
+
+                // we could have got an event from our child, reflect it back
+                // to it if this is the case
+                wxWindowMSW *win = NULL;
+                if ( (WXHWND)wParam != m_hWnd )
+                {
+                    win = FindItemByHWND((WXHWND)wParam);
+                }
+
+                if ( !win )
+                    win = this;
+
+                evtCtx.SetEventObject(win);
+                processed = win->GetEventHandler()->ProcessEvent(evtCtx);
              }
              break;
  #endif
              }
              break;
  #endif
@@ -2884,7 +2924,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                  if ( i != wxNOT_FOUND )
                  {
                      rc.result = MAKELRESULT(i, MNC_EXECUTE);
                  if ( i != wxNOT_FOUND )
                  {
                      rc.result = MAKELRESULT(i, MNC_EXECUTE);
-                    processed = TRUE;
+                    processed = true;
                  }
              }
              break;
                  }
              }
              break;
@@ -2910,7 +2950,7 @@ wxWinHashTable *wxWinHandleHash = NULL;
  
  wxWindow *wxFindWinFromHandle(WXHWND hWnd)
  {
  
  wxWindow *wxFindWinFromHandle(WXHWND hWnd)
  {
-    return wxWinHandleHash->Get((long)hWnd);
+    return (wxWindow*)wxWinHandleHash->Get((long)hWnd);
  }
  
  void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
  }
  
  void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
@@ -2955,15 +2995,15 @@ bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
                                             int& x, int& y,
                                             int& w, int& h) const
  {
                                             int& x, int& y,
                                             int& w, int& h) const
  {
+    // yes, those are just some arbitrary hardcoded numbers
      static const int DEFAULT_Y = 200;
      static const int DEFAULT_Y = 200;
-    static const int DEFAULT_H = 250;
  
  
-    bool nonDefault = FALSE;
+    bool nonDefault = false;
  
  
-    if ( pos.x == -1 )
+    if ( pos.x == wxDefaultCoord )
      {
      {
-        // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
-        // just as well set it to CW_USEDEFAULT as well
+        // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
+        // can just as well set it to CW_USEDEFAULT as well
          x =
          y = CW_USEDEFAULT;
      }
          x =
          y = CW_USEDEFAULT;
      }
@@ -2973,15 +3013,15 @@ bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
          // neither because it is not handled as a special value by Windows then
          // and so we have to choose some default value for it
          x = pos.x;
          // neither because it is not handled as a special value by Windows then
          // and so we have to choose some default value for it
          x = pos.x;
-        y = pos.y == -1 ? DEFAULT_Y : pos.y;
+        y = pos.y == wxDefaultCoord ? DEFAULT_Y : pos.y;
  
  
-        nonDefault = TRUE;
+        nonDefault = true;
      }
  
      /*
        NB: there used to be some code here which set the initial size of the
            window to the client size of the parent if no explicit size was
      }
  
      /*
        NB: there used to be some code here which set the initial size of the
            window to the client size of the parent if no explicit size was
-          specified. This was wrong because wxWindows programs often assume
+          specified. This was wrong because wxWidgets programs often assume
            that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
            it. To see why, you should understand that Windows sends WM_SIZE from
            inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
            that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
            it. To see why, you should understand that Windows sends WM_SIZE from
            inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
@@ -2990,24 +3030,49 @@ bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
            event goes to some base class OnSize() instead). So the WM_SIZE we
            rely on is the one sent when the parent frame resizes its children
            but here is the problem: if the child already has just the right
            event goes to some base class OnSize() instead). So the WM_SIZE we
            rely on is the one sent when the parent frame resizes its children
            but here is the problem: if the child already has just the right
-          size, nothing will happen as both wxWindows and Windows check for
+          size, nothing will happen as both wxWidgets and Windows check for
            this and ignore any attempts to change the window size to the size it
            already has - so no WM_SIZE would be sent.
       */
            this and ignore any attempts to change the window size to the size it
            already has - so no WM_SIZE would be sent.
       */
-    if ( size.x == -1 )
-    {
-        // as above, h is not used at all in this case anyhow
-        w =
+
+
+    // we don't use CW_USEDEFAULT here for several reasons:
+    //
+    //  1. it results in huge frames on modern screens (1000*800 is not
+    //     uncommon on my 1280*1024 screen) which is way too big for a half
+    //     empty frame of most of wxWidgets samples for example)
+    //
+    //  2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
+    //     the default is for whatever reason 8*8 which breaks client <->
+    //     window size calculations (it would be nice if it didn't, but it
+    //     does and the simplest way to fix it seemed to change the broken
+    //     default size anyhow)
+    //
+    //  3. there is just no advantage in doing it: with x and y it is
+    //     possible that [future versions of] Windows position the new top
+    //     level window in some smart way which we can't do, but we can
+    //     guess a reasonably good size for a new window just as well
+    //     ourselves
+
+    // However, on PocketPC devices, we must use the default
+    // size if possible.
+#ifdef _WIN32_WCE
+    if (size.x == wxDefaultCoord)
+        w = CW_USEDEFAULT;
+    else
+        w = size.x;
+    if (size.y == wxDefaultCoord)
          h = CW_USEDEFAULT;
          h = CW_USEDEFAULT;
-    }
      else
      else
+        h = size.y;
+#else
+    if ( size.x == wxDefaultCoord || size.y == wxDefaultCoord)
      {
      {
-        // and, again as above, we can't set the height to CW_USEDEFAULT here
-        w = size.x;
-        h = size.y == -1 ? DEFAULT_H  : size.y;
-
-        nonDefault = TRUE;
+        nonDefault = true;
      }
      }
+    w = WidthDefault(size.x);
+    h = HeightDefault(size.y);
+#endif
  
      AdjustForParentClientOrigin(x, y);
  
  
      AdjustForParentClientOrigin(x, y);
  
@@ -3046,6 +3111,7 @@ bool wxWindowMSW::MSWCreate(const wxChar *wclass,
      // do create the window
      wxWindowCreationHook hook(this);
  
      // do create the window
      wxWindowCreationHook hook(this);
  
+    // VZ: anyonce cares to explain why is this done for CE?
  #ifdef __WXWINCE__
      if (extendedStyle == 0)
      {
  #ifdef __WXWINCE__
      if (extendedStyle == 0)
      {
@@ -3062,7 +3128,7 @@ bool wxWindowMSW::MSWCreate(const wxChar *wclass,
              );
      }
      else
              );
      }
      else
-#endif
+#endif // __WXWINCE__
      {
          m_hWnd = (WXHWND)::CreateWindowEx
              (
      {
          m_hWnd = (WXHWND)::CreateWindowEx
              (
@@ -3082,14 +3148,12 @@ bool wxWindowMSW::MSWCreate(const wxChar *wclass,
      {
          wxLogSysError(_("Can't create window of class %s"), wclass);
  
      {
          wxLogSysError(_("Can't create window of class %s"), wclass);
  
-        return FALSE;
+        return false;
      }
  
      SubclassWin(m_hWnd);
  
      }
  
      SubclassWin(m_hWnd);
  
-    SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
-
-    return TRUE;
+    return true;
  }
  
  // ===========================================================================
  }
  
  // ===========================================================================
@@ -3129,7 +3193,7 @@ bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
          wxWindow *child = node->GetData();
          if ( child->MSWOnNotify(idCtrl, lParam, result) )
          {
          wxWindow *child = node->GetData();
          if ( child->MSWOnNotify(idCtrl, lParam, result) )
          {
-            return TRUE;
+            return true;
          }
  
          node = node->GetNext();
          }
  
          node = node->GetNext();
@@ -3139,7 +3203,7 @@ bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
      // by default, handle it ourselves
      return MSWOnNotify(idCtrl, lParam, result);
  #else // __WXMICROWIN__
      // by default, handle it ourselves
      return MSWOnNotify(idCtrl, lParam, result);
  #else // __WXMICROWIN__
-    return FALSE;
+    return false;
  #endif
  }
  
  #endif
  }
  
@@ -3155,59 +3219,71 @@ bool wxWindowMSW::HandleTooltipNotify(WXUINT code,
      // we need to handle it as well, otherwise no tooltips will be shown in
      // this case
  #ifndef __WXWINCE__
      // we need to handle it as well, otherwise no tooltips will be shown in
      // this case
  #ifndef __WXWINCE__
-    if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW) || ttip.empty() )
+    if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW)
+            || ttip.empty() )
      {
          // not a tooltip message or no tooltip to show anyhow
      {
          // not a tooltip message or no tooltip to show anyhow
-        return FALSE;
+        return false;
      }
  #endif
  
      LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
  
      }
  #endif
  
      LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
  
+    // We don't want to use the szText buffer because it has a limit of 80
+    // bytes and this is not enough, especially for Unicode build where it
+    // limits the tooltip string length to only 40 characters
+    //
+    // The best would be, of course, to not impose any length limitations at
+    // all but then the buffer would have to be dynamic and someone would have
+    // to free it and we don't have the tooltip owner object here any more, so
+    // for now use our own static buffer with a higher fixed max length.
+    //
+    // Note that using a static buffer should not be a problem as only a single
+    // tooltip can be shown at the same time anyhow.
  #if !wxUSE_UNICODE
  #if !wxUSE_UNICODE
-    if ( code == (WXUINT) TTN_NEEDTEXTA )
-    {
-        // we pass just the pointer as we store the string internally anyhow
-        ttText->lpszText = (char *)ttip.c_str();
-    }
-    else // TTN_NEEDTEXTW
-#endif // !Unicode
+    if ( code == (WXUINT) TTN_NEEDTEXTW )
      {
      {
-#if wxUSE_UNICODE
-        // in Unicode mode this is just what we need
-        ttText->lpszText = (wxChar *)ttip.c_str();
-#else // !Unicode
-/*
-        MultiByteToWideChar(CP_ACP, 0, ttip, ttip.length()+1,
-                            (wchar_t *)ttText->szText,
-                            sizeof(ttText->szText) / sizeof(wchar_t));
-*/
-        // Fix by dimitrishortcut: see patch 771772
-
-        // FIXME: szText has a max of 80 bytes, so limit the tooltip string
-        // length accordingly. Ideally lpszText should be used, but who
-        // would be responsible for freeing the buffer?
-
-        // Maximum length of a tip is 39 characters. 39 is 80/2 minus 1 byte
-        // needed for NULL character.
-        size_t tipLength = wxMin(ttip.Len(), 39);
+        // We need to convert tooltip from multi byte to Unicode on the fly.
+        static wchar_t buf[513];
  
  
-        // Convert to WideChar without adding the NULL character. The NULL
-        // character is added afterwards (Could have used ttip.Left(tipLength)
-        // and a cchMultiByte parameter of tipLength+1, but this is more
-        //efficient.
-        ::MultiByteToWideChar(CP_ACP, 0, ttip, tipLength,
-                             (wchar_t *)ttText->szText,
-                             sizeof(ttText->szText) / sizeof(wchar_t));
+        // Truncate tooltip length if needed as otherwise we might not have
+        // enough space for it in the buffer and MultiByteToWideChar() would
+        // return an error
+        size_t tipLength = wxMin(ttip.Len(), WXSIZEOF(buf) - 1);
  
  
-        // Add the NULL character.
-        ttText->szText[tipLength*2+0] = '\0';
-        ttText->szText[tipLength*2+1] = '\0';
+        // Convert to WideChar without adding the NULL character. The NULL
+        // character is added afterwards (this is more efficient).
+        int len = ::MultiByteToWideChar
+                    (
+                        CP_ACP,
+                        0,                      // no flags
+                        ttip,
+                        tipLength,
+                        buf,
+                        WXSIZEOF(buf) - 1
+                    );
+
+        if ( !len )
+        {
+            wxLogLastError(_T("MultiByteToWideChar()"));
+        }
  
  
-#endif // Unicode/!Unicode
+        buf[len] = L'\0';
+        ttText->lpszText = (LPSTR) buf;
+    }
+    else // TTN_NEEDTEXTA
+#endif // !wxUSE_UNICODE
+    {
+        // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
+        // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
+        // to copy the string we have into the buffer
+        static wxChar buf[513];
+        wxStrncpy(buf, ttip.c_str(), WXSIZEOF(buf) - 1);
+        buf[WXSIZEOF(buf) - 1] = _T('\0');
+        ttText->lpszText = buf;
      }
  
      }
  
-    return TRUE;
+    return true;
  }
  
  #endif // wxUSE_TOOLTIPS
  }
  
  #endif // wxUSE_TOOLTIPS
@@ -3223,12 +3299,14 @@ bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
          if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
          {
              // processed
          if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
          {
              // processed
-            return TRUE;
+            return true;
          }
      }
          }
      }
+#else
+    wxUnusedVar(lParam);
  #endif // wxUSE_TOOLTIPS
  
  #endif // wxUSE_TOOLTIPS
  
-    return FALSE;
+    return false;
  }
  
  #endif // __WIN95__
  }
  
  #endif // __WIN95__
@@ -3240,9 +3318,9 @@ bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
  bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
  {
  #ifndef __WXWINCE__
  bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
  {
  #ifndef __WXWINCE__
-    wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
+    wxCloseEvent event(wxEVT_QUERY_END_SESSION, wxID_ANY);
      event.SetEventObject(wxTheApp);
      event.SetEventObject(wxTheApp);
-    event.SetCanVeto(TRUE);
+    event.SetCanVeto(true);
      event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
  
      bool rc = wxTheApp->ProcessEvent(event);
      event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
  
      bool rc = wxTheApp->ProcessEvent(event);
@@ -3256,7 +3334,7 @@ bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
  
      return rc;
  #else
  
      return rc;
  #else
-    return FALSE;
+    return false;
  #endif
  }
  
  #endif
  }
  
@@ -3265,20 +3343,20 @@ bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
  #ifndef __WXWINCE__
      // do nothing if the session isn't ending
      if ( !endSession )
  #ifndef __WXWINCE__
      // do nothing if the session isn't ending
      if ( !endSession )
-        return FALSE;
+        return false;
  
      // only send once
      if ( (this != wxTheApp->GetTopWindow()) )
  
      // only send once
      if ( (this != wxTheApp->GetTopWindow()) )
-        return FALSE;
+        return false;
  
  
-    wxCloseEvent event(wxEVT_END_SESSION, -1);
+    wxCloseEvent event(wxEVT_END_SESSION, wxID_ANY);
      event.SetEventObject(wxTheApp);
      event.SetEventObject(wxTheApp);
-    event.SetCanVeto(FALSE);
+    event.SetCanVeto(false);
      event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
  
      return wxTheApp->ProcessEvent(event);
  #else
      event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
  
      return wxTheApp->ProcessEvent(event);
  #else
-    return FALSE;
+    return false;
  #endif
  }
  
  #endif
  }
  
@@ -3294,15 +3372,17 @@ bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate)
  #ifndef __WXWINCE__
      if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
          EnsureParentHasControlParentStyle(GetParent());
  #ifndef __WXWINCE__
      if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
          EnsureParentHasControlParentStyle(GetParent());
+#else
+    wxUnusedVar(cs);
  #endif // !__WXWINCE__
  
      // TODO: should generate this event from WM_NCCREATE
      wxWindowCreateEvent event((wxWindow *)this);
      (void)GetEventHandler()->ProcessEvent(event);
  
  #endif // !__WXWINCE__
  
      // TODO: should generate this event from WM_NCCREATE
      wxWindowCreateEvent event((wxWindow *)this);
      (void)GetEventHandler()->ProcessEvent(event);
  
-    *mayCreate = TRUE;
+    *mayCreate = true;
  
  
-    return TRUE;
+    return true;
  }
  
  bool wxWindowMSW::HandleDestroy()
  }
  
  bool wxWindowMSW::HandleDestroy()
@@ -3321,7 +3401,7 @@ bool wxWindowMSW::HandleDestroy()
  #endif // wxUSE_DRAG_AND_DROP
  
      // WM_DESTROY handled
  #endif // wxUSE_DRAG_AND_DROP
  
      // WM_DESTROY handled
-    return TRUE;
+    return true;
  }
  
  // ---------------------------------------------------------------------------
  }
  
  // ---------------------------------------------------------------------------
@@ -3342,6 +3422,13 @@ bool wxWindowMSW::HandleActivate(int state,
  
  bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
  {
  
  bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
  {
+    // Strangly enough, some controls get set focus events when they are being
+    // deleted, even if they already had focus before.
+    if ( m_isBeingDeleted )
+    {
+        return false;
+    }
+
      // notify the parent keeping track of focus for the kbd navigation
      // purposes that we got it
      wxChildFocusEvent eventFocus((wxWindow *)this);
      // notify the parent keeping track of focus for the kbd navigation
      // purposes that we got it
      wxChildFocusEvent eventFocus((wxWindow *)this);
@@ -3360,7 +3447,7 @@ bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
      // after the control gets to process it from EN_FOCUS handler
      if ( wxDynamicCastThis(wxTextCtrl) )
      {
      // after the control gets to process it from EN_FOCUS handler
      if ( wxDynamicCastThis(wxTextCtrl) )
      {
-        return FALSE;
+        return false;
      }
  #endif // wxUSE_TEXTCTRL
  
      }
  #endif // wxUSE_TEXTCTRL
  
@@ -3389,7 +3476,7 @@ bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
      wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
      if ( ctrl )
      {
      wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
      if ( ctrl )
      {
-        return FALSE;
+        return false;
      }
  #endif
  
      }
  #endif
  
@@ -3397,7 +3484,7 @@ bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
      // only cause problems if the event handler tries to access the object.
      if ( m_isBeingDeleted )
      {
      // only cause problems if the event handler tries to access the object.
      if ( m_isBeingDeleted )
      {
-        return FALSE;
+        return false;
      }
  
      wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
      }
  
      wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
@@ -3432,7 +3519,8 @@ bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
  bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
  {
  #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
  bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
  {
  #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
-    return FALSE;
+    wxUnusedVar(wParam);
+    return false;
  #else // __WXMICROWIN__
      HDROP hFilesInfo = (HDROP) wParam;
  
  #else // __WXMICROWIN__
      HDROP hFilesInfo = (HDROP) wParam;
  
@@ -3485,7 +3573,7 @@ bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
  
      if ( nHitTest != HTCLIENT )
      {
  
      if ( nHitTest != HTCLIENT )
      {
-        return FALSE;
+        return false;
      }
  
      HCURSOR hcursor = 0;
      }
  
      HCURSOR hcursor = 0;
@@ -3546,12 +3634,12 @@ bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
          ::SetCursor(hcursor);
  
          // cursor set, stop here
          ::SetCursor(hcursor);
  
          // cursor set, stop here
-        return TRUE;
+        return true;
      }
  #endif // __WXMICROWIN__
  
      // pass up the window chain
      }
  #endif // __WXMICROWIN__
  
      // pass up the window chain
-    return FALSE;
+    return false;
  }
  
  // ---------------------------------------------------------------------------
  }
  
  // ---------------------------------------------------------------------------
@@ -3578,7 +3666,8 @@ wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
      {
          wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
  
      {
          wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
  
-        wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
+        wxCHECK_MSG( pMenuItem && pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)),
+                         false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
  
          // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
          // the DC from being released
  
          // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
          // the DC from being released
@@ -3606,7 +3695,13 @@ wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
  #else // !wxUSE_OWNER_DRAWN
      // we may still have owner-drawn buttons internally because we have to make
      // them owner-drawn to support colour change
  #else // !wxUSE_OWNER_DRAWN
      // we may still have owner-drawn buttons internally because we have to make
      // them owner-drawn to support colour change
-    wxControl *item = wxDynamicCast(FindItem(id), wxButton);
+    wxControl *item =
+#                     if wxUSE_BUTTON
+                         wxDynamicCast(FindItem(id), wxButton)
+#                     else
+                         NULL
+#                     endif
+                    ;
  #endif // USE_OWNER_DRAWN
  
      if ( item )
  #endif // USE_OWNER_DRAWN
  
      if ( item )
@@ -3616,13 +3711,11 @@ wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
  
  #endif // wxUSE_CONTROLS
  
  
  #endif // wxUSE_CONTROLS
  
-    return FALSE;
+    return false;
  }
  
  bool
  }
  
  bool
-wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
-                              WXMEASUREITEMSTRUCT *
-                                  WXUNUSED_UNLESS_ODRAWN(itemStruct))
+wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
  {
  #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
      // is it a menu item?
  {
  #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
      // is it a menu item?
@@ -3631,10 +3724,16 @@ wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
      {
          wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
  
      {
          wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
  
-        wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
+        wxCHECK_MSG( pMenuItem && pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)),
+                        false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
  
  
-        return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
-                                        &pMeasureStruct->itemHeight);
+        size_t w, h;
+        bool rc = pMenuItem->OnMeasureItem(&w, &h);
+
+        pMeasureStruct->itemWidth = w;
+        pMeasureStruct->itemHeight = h;
+
+        return rc;
      }
  
      wxControl *item = wxDynamicCast(FindItem(id), wxControl);
      }
  
      wxControl *item = wxDynamicCast(FindItem(id), wxControl);
@@ -3642,9 +3741,12 @@ wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
      {
          return item->MSWOnMeasure(itemStruct);
      }
      {
          return item->MSWOnMeasure(itemStruct);
      }
-#endif // wxUSE_OWNER_DRAWN
+#else
+    wxUnusedVar(id);
+    wxUnusedVar(itemStruct);
+#endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
  
  
-    return FALSE;
+    return false;
  }
  
  // ---------------------------------------------------------------------------
  }
  
  // ---------------------------------------------------------------------------
@@ -3660,7 +3762,7 @@ bool wxWindowMSW::HandleSysColorChange()
  
      // always let the system carry on the default processing to allow the
      // native controls to react to the colours update
  
      // always let the system carry on the default processing to allow the
      // native controls to react to the colours update
-    return FALSE;
+    return false;
  }
  
  bool wxWindowMSW::HandleDisplayChange()
  }
  
  bool wxWindowMSW::HandleDisplayChange()
@@ -3683,7 +3785,7 @@ bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
      WXHBRUSH hBrush = 0;
  
  #ifdef __WXWINCE__
      WXHBRUSH hBrush = 0;
  
  #ifdef __WXWINCE__
-    if (FALSE)
+    if (false)
  #else
      if ( nCtlColor == CTLCOLOR_DLG )
  #endif
  #else
      if ( nCtlColor == CTLCOLOR_DLG )
  #endif
@@ -3693,7 +3795,7 @@ bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
  #if wxUSE_CONTROLS
      else
      {
  #if wxUSE_CONTROLS
      else
      {
-        wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
+        wxControl *item = (wxControl *)FindItemByHWND(pWnd, true);
          if ( item )
              hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
      }
          if ( item )
              hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
      }
@@ -3704,7 +3806,7 @@ bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
  
      return hBrush != 0;
  #else // __WXMICROWIN__
  
      return hBrush != 0;
  #else // __WXMICROWIN__
-    return FALSE;
+    return false;
  #endif
  }
  
  #endif
  }
  
@@ -3749,7 +3851,7 @@ bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
  
              // now check for the need to redraw
              if (result > 0)
  
              // now check for the need to redraw
              if (result > 0)
-                InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
+                ::InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
          }
  
      }
          }
  
      }
@@ -3779,7 +3881,7 @@ bool wxWindowMSW::HandleQueryNewPalette()
      while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
      if (win->HasCustomPalette()) {
          /* realize the palette to see whether redrawing is needed */
      while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
      if (win->HasCustomPalette()) {
          /* realize the palette to see whether redrawing is needed */
-        HDC hdc = GetDC((HWND) GetHWND());
+        HDC hdc = ::GetDC((HWND) GetHWND());
          win->m_palette.SetHPALETTE( (WXHPALETTE)
               ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
  
          win->m_palette.SetHPALETTE( (WXHPALETTE)
               ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
  
@@ -3810,7 +3912,7 @@ void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
      if ( IsTopLevel() )
      {
          // FIXME-MT
      if ( IsTopLevel() )
      {
          // FIXME-MT
-        gs_hasStdCmap = FALSE;
+        gs_hasStdCmap = false;
      }
      wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
      while ( node )
      }
      wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
      while ( node )
@@ -3828,20 +3930,6 @@ void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
  
          node = node->GetNext();
      }
  
          node = node->GetNext();
      }
-
-    // update the colours we use if they were not set explicitly by the user:
-    // this must be done or OnCtlColor() would continue to use the old colours
-    if ( !m_hasFgCol )
-    {
-        m_foregroundColour = wxSystemSettings::
-                                GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
-    }
-
-    if ( !m_hasBgCol )
-    {
-        m_backgroundColour = wxSystemSettings::
-                                GetSystemColour(wxSYS_COLOUR_BTNFACE);
-    }
  }
  
  extern wxCOLORMAP *wxGetStdColourMap()
  }
  
  extern wxCOLORMAP *wxGetStdColourMap()
@@ -3851,7 +3939,7 @@ extern wxCOLORMAP *wxGetStdColourMap()
  
      if ( !gs_hasStdCmap )
      {
  
      if ( !gs_hasStdCmap )
      {
-        static bool s_coloursInit = FALSE;
+        static bool s_coloursInit = false;
  
          if ( !s_coloursInit )
          {
  
          if ( !s_coloursInit )
          {
@@ -3889,10 +3977,10 @@ extern wxCOLORMAP *wxGetStdColourMap()
                  //s_stdColours[5] = RGB(255,000,255);     // magenta
              }
  
                  //s_stdColours[5] = RGB(255,000,255);     // magenta
              }
  
-            s_coloursInit = TRUE;
+            s_coloursInit = true;
          }
  
          }
  
-        gs_hasStdCmap = TRUE;
+        gs_hasStdCmap = true;
  
          // create the colour map
  #define INIT_CMAP_ENTRY(col) \
  
          // create the colour map
  #define INIT_CMAP_ENTRY(col) \
@@ -3917,7 +4005,7 @@ extern wxCOLORMAP *wxGetStdColourMap()
  bool wxWindowMSW::HandlePaint()
  {
  //    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
  bool wxWindowMSW::HandlePaint()
  {
  //    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
-//        return FALSE;
+//        return false;
  
      HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
      if ( !hRegion )
  
      HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
      if ( !hRegion )
@@ -3960,12 +4048,12 @@ bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
  {
      // Prevents flicker when dragging
      if ( ::IsIconic(GetHwnd()) )
  {
      // Prevents flicker when dragging
      if ( ::IsIconic(GetHwnd()) )
-        return TRUE;
+        return true;
  
  #if 0
      if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
      {
  
  #if 0
      if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
      {
-        return FALSE;
+        return false;
      }
  
      if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
      }
  
      if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
@@ -3979,7 +4067,7 @@ bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
                  ::GetClientRect((HWND) GetHWND(), (RECT*) & rect);
                  wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme, hdc, 10 /* TABP_BODY */, 0, &rect, &rect);
                  wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme);
                  ::GetClientRect((HWND) GetHWND(), (RECT*) & rect);
                  wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme, hdc, 10 /* TABP_BODY */, 0, &rect, &rect);
                  wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme);
-                return TRUE;
+                return true;
              }
          }
      }
              }
          }
      }
@@ -4008,9 +4096,10 @@ void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
      RECT rect;
      ::GetClientRect(GetHwnd(), &rect);
  
      RECT rect;
      ::GetClientRect(GetHwnd(), &rect);
  
-    COLORREF ref = PALETTERGB(m_backgroundColour.Red(),
-                              m_backgroundColour.Green(),
-                              m_backgroundColour.Blue());
+    wxColour backgroundColour( GetBackgroundColour());
+    COLORREF ref = PALETTERGB(backgroundColour.Red(),
+                              backgroundColour.Green(),
+                              backgroundColour.Blue());
      HBRUSH hBrush = ::CreateSolidBrush(ref);
      if ( !hBrush )
          wxLogLastError(wxT("CreateSolidBrush"));
      HBRUSH hBrush = ::CreateSolidBrush(ref);
      if ( !hBrush )
          wxLogLastError(wxT("CreateSolidBrush"));
@@ -4051,7 +4140,8 @@ bool wxWindowMSW::HandleMaximize()
  
  bool wxWindowMSW::HandleMove(int x, int y)
  {
  
  bool wxWindowMSW::HandleMove(int x, int y)
  {
-    wxMoveEvent event(wxPoint(x, y), m_windowId);
+    wxPoint point(x,y);
+    wxMoveEvent event(point, m_windowId);
      event.SetEventObject(this);
  
      return GetEventHandler()->ProcessEvent(event);
      event.SetEventObject(this);
  
      return GetEventHandler()->ProcessEvent(event);
@@ -4068,16 +4158,40 @@ bool wxWindowMSW::HandleMoving(wxRect& rect)
      return rc;
  }
  
      return rc;
  }
  
-bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
-                             WXUINT WXUNUSED(flag))
+bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h), WXUINT wParam)
  {
  {
-    // don't use w and h parameters as they specify the client size while
-    // according to the docs EVT_SIZE handler is supposed to receive the total
-    // size
-    wxSizeEvent event(GetSize(), m_windowId);
-    event.SetEventObject(this);
+    bool processed = false;
  
  
-    return GetEventHandler()->ProcessEvent(event);
+    switch ( wParam )
+    {
+        default:
+            wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
+            // fall through nevertheless
+
+        case SIZE_MAXHIDE:
+        case SIZE_MAXSHOW:
+            // we're not interested in these messages at all
+            break;
+
+        case SIZE_MINIMIZED:
+            processed = HandleMinimize();
+            break;
+
+        case SIZE_MAXIMIZED:
+            /* processed = */ HandleMaximize();
+            // fall through to send a normal size event as well
+
+        case SIZE_RESTORED:
+            // don't use w and h parameters as they specify the client size
+            // while according to the docs EVT_SIZE handler is supposed to
+            // receive the total size
+            wxSizeEvent event(GetSize(), m_windowId);
+            event.SetEventObject(this);
+
+            processed = GetEventHandler()->ProcessEvent(event);
+    }
+
+    return processed;
  }
  
  bool wxWindowMSW::HandleSizing(wxRect& rect)
  }
  
  bool wxWindowMSW::HandleSizing(wxRect& rect)
@@ -4094,39 +4208,40 @@ bool wxWindowMSW::HandleSizing(wxRect& rect)
  bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
  {
  #ifdef __WXWINCE__
  bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
  {
  #ifdef __WXWINCE__
-    return FALSE;
+    wxUnusedVar(mmInfo);
+    return false;
  #else
      MINMAXINFO *info = (MINMAXINFO *)mmInfo;
  
  #else
      MINMAXINFO *info = (MINMAXINFO *)mmInfo;
  
-    bool rc = FALSE;
+    bool rc = false;
  
      int minWidth = GetMinWidth(),
          minHeight = GetMinHeight(),
          maxWidth = GetMaxWidth(),
          maxHeight = GetMaxHeight();
  
  
      int minWidth = GetMinWidth(),
          minHeight = GetMinHeight(),
          maxWidth = GetMaxWidth(),
          maxHeight = GetMaxHeight();
  
-    if ( minWidth != -1 )
+    if ( minWidth != wxDefaultCoord )
      {
          info->ptMinTrackSize.x = minWidth;
      {
          info->ptMinTrackSize.x = minWidth;
-        rc = TRUE;
+        rc = true;
      }
  
      }
  
-    if ( minHeight != -1 )
+    if ( minHeight != wxDefaultCoord )
      {
          info->ptMinTrackSize.y = minHeight;
      {
          info->ptMinTrackSize.y = minHeight;
-        rc = TRUE;
+        rc = true;
      }
  
      }
  
-    if ( maxWidth != -1 )
+    if ( maxWidth != wxDefaultCoord )
      {
          info->ptMaxTrackSize.x = maxWidth;
      {
          info->ptMaxTrackSize.x = maxWidth;
-        rc = TRUE;
+        rc = true;
      }
  
      }
  
-    if ( maxHeight != -1 )
+    if ( maxHeight != wxDefaultCoord )
      {
          info->ptMaxTrackSize.y = maxHeight;
      {
          info->ptMaxTrackSize.y = maxHeight;
-        rc = TRUE;
+        rc = true;
      }
  
      return rc;
      }
  
      return rc;
@@ -4194,28 +4309,11 @@ bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
          // wxSpinCtrl
          wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
          if ( spin && spin->ProcessTextCommand(cmd, id) )
          // wxSpinCtrl
          wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
          if ( spin && spin->ProcessTextCommand(cmd, id) )
-            return TRUE;
+            return true;
      }
  #endif // wxUSE_SPINCTRL
  
      }
  #endif // wxUSE_SPINCTRL
  
-    return FALSE;
-}
-
-bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
-{
-#ifndef __WXWINCE__
-    // 4 bits are reserved
-    switch ( wParam & 0xFFFFFFF0 )
-    {
-        case SC_MAXIMIZE:
-            return HandleMaximize();
-
-        case SC_MINIMIZE:
-            return HandleMinimize();
-    }
-#endif
-
-    return FALSE;
+    return false;
  }
  
  // ---------------------------------------------------------------------------
  }
  
  // ---------------------------------------------------------------------------
@@ -4322,7 +4420,7 @@ static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //
  bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
  {
      // the mouse events take consecutive IDs from WM_MOUSEFIRST to
  bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
  {
      // the mouse events take consecutive IDs from WM_MOUSEFIRST to
-    // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
+    // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
      // from the message id and take the value in the table to get wxWin event
      // id
      static const wxEventType eventsMouse[] =
      // from the message id and take the value in the table to get wxWin event
      // id
      static const wxEventType eventsMouse[] =
@@ -4356,7 +4454,7 @@ bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
          if ( !HasCapture() || IsMouseInWindow() )
          {
              // Generate an ENTER event
          if ( !HasCapture() || IsMouseInWindow() )
          {
              // Generate an ENTER event
-            m_mouseInWindow = TRUE;
+            m_mouseInWindow = true;
  #if _WIN32_WINNT >= 0x0400
  #ifndef __WXWINCE__
              TRACKMOUSEEVENT trackinfo;
  #if _WIN32_WINNT >= 0x0400
  #ifndef __WXWINCE__
              TRACKMOUSEEVENT trackinfo;
@@ -4366,7 +4464,7 @@ bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
              trackinfo.hwndTrack = GetHwnd();
              //Use the commctrl.h _TrackMouseEvent, which will call the
              // appropriate TrackMouseEvent or emulate it ( win95 )
              trackinfo.hwndTrack = GetHwnd();
              //Use the commctrl.h _TrackMouseEvent, which will call the
              // appropriate TrackMouseEvent or emulate it ( win95 )
-            // else we need _WIN32_WINNT >= 0x0400 
+            // else we need _WIN32_WINNT >= 0x0400
              _TrackMouseEvent(&trackinfo);
  #endif
  #endif
              _TrackMouseEvent(&trackinfo);
  #endif
  #endif
@@ -4388,7 +4486,7 @@ bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
      {
          m_lastMouseEvent = wxEVT_MOTION;
  
      {
          m_lastMouseEvent = wxEVT_MOTION;
  
-        return FALSE;
+        return false;
      }
  #endif // wxUSE_MOUSEEVENT_HACK
  
      }
  #endif // wxUSE_MOUSEEVENT_HACK
  
@@ -4428,7 +4526,7 @@ bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
      (void) wParam;
      (void) lParam;
  
      (void) wParam;
      (void) lParam;
  
-    return FALSE;
+    return false;
  #endif
  }
  
  #endif
  }
  
@@ -4452,6 +4550,9 @@ wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
  
      event.m_eventObject = (wxWindow *)this; // const_cast
      event.m_keyCode = id;
  
      event.m_eventObject = (wxWindow *)this; // const_cast
      event.m_keyCode = id;
+#if wxUSE_UNICODE
+    event.m_uniChar = (wxChar) wParam;
+#endif
      event.m_rawCode = (wxUint32) wParam;
      event.m_rawFlags = (wxUint32) lParam;
  #ifndef __WXWINCE__
      event.m_rawCode = (wxUint32) wParam;
      event.m_rawFlags = (wxUint32) lParam;
  #ifndef __WXWINCE__
@@ -4472,7 +4573,7 @@ wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
      return event;
  }
  
      return event;
  }
  
-// isASCII is TRUE only when we're called from WM_CHAR handler and not from
+// isASCII is true only when we're called from WM_CHAR handler and not from
  // WM_KEYDOWN one
  bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
  {
  // WM_KEYDOWN one
  bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
  {
@@ -4481,7 +4582,7 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
      {
          // If 1 -> 26, translate to either special keycode or just set
          // ctrlDown.  IOW, Ctrl-C should result in keycode == 3 and
      {
          // If 1 -> 26, translate to either special keycode or just set
          // ctrlDown.  IOW, Ctrl-C should result in keycode == 3 and
-        // ControlDown() == TRUE.
+        // ControlDown() == true.
          id = wParam;
          if ( (id > 0) && (id < 27) )
          {
          id = wParam;
          if ( (id > 0) && (id < 27) )
          {
@@ -4500,19 +4601,19 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
                      break;
  
                  default:
                      break;
  
                  default:
-                    //ctrlDown = TRUE;
+                    //ctrlDown = true;
                      break;
              }
          }
      }
      else // we're called from WM_KEYDOWN
      {
                      break;
              }
          }
      }
      else // we're called from WM_KEYDOWN
      {
-        id = wxCharCodeMSWToWX(wParam);
+        id = wxCharCodeMSWToWX(wParam, lParam);
          if ( id == 0 )
          {
              // it's ASCII and will be processed here only when called from
          if ( id == 0 )
          {
              // it's ASCII and will be processed here only when called from
-            // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
-            return FALSE;
+            // WM_CHAR (i.e. when isASCII = true), don't process it now
+            return false;
          }
      }
  
          }
      }
  
@@ -4528,7 +4629,7 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
              (id >= 32 && id < 256) )
      {
          event.m_controlDown =
              (id >= 32 && id < 256) )
      {
          event.m_controlDown =
-        event.m_altDown = FALSE;
+        event.m_altDown = false;
      }
  
      return GetEventHandler()->ProcessEvent(event);
      }
  
      return GetEventHandler()->ProcessEvent(event);
@@ -4536,7 +4637,7 @@ bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
  
  bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
  {
  
  bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
  {
-    int id = wxCharCodeMSWToWX(wParam);
+    int id = wxCharCodeMSWToWX(wParam, lParam);
  
      if ( !id )
      {
  
      if ( !id )
      {
@@ -4549,16 +4650,16 @@ bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
          wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
          if ( GetEventHandler()->ProcessEvent(event) )
          {
          wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
          if ( GetEventHandler()->ProcessEvent(event) )
          {
-            return TRUE;
+            return true;
          }
      }
  
          }
      }
  
-    return FALSE;
+    return false;
  }
  
  bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
  {
  }
  
  bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
  {
-    int id = wxCharCodeMSWToWX(wParam);
+    int id = wxCharCodeMSWToWX(wParam, lParam);
  
      if ( !id )
      {
  
      if ( !id )
      {
@@ -4570,10 +4671,10 @@ bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
      {
          wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
          if ( GetEventHandler()->ProcessEvent(event) )
      {
          wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
          if ( GetEventHandler()->ProcessEvent(event) )
-            return TRUE;
+            return true;
      }
  
      }
  
-    return FALSE;
+    return false;
  }
  
  int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
  }
  
  int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
@@ -4614,7 +4715,7 @@ int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
                          // FIXME-UNICODE: this comparison doesn't risk to work
                          // for non ASCII accelerator characters I'm afraid, but
                          // what can we do?
                          // FIXME-UNICODE: this comparison doesn't risk to work
                          // for non ASCII accelerator characters I'm afraid, but
                          // what can we do?
-                        if ( wxToupper(*p) == chAccel )
+                        if ( (wchar_t)wxToupper(*p) == (wchar_t)chAccel )
                          {
                              return i;
                          }
                          {
                              return i;
                          }
@@ -4634,6 +4735,9 @@ int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
              wxLogLastError(_T("GetMenuItemInfo"));
          }
      }
              wxLogLastError(_T("GetMenuItemInfo"));
          }
      }
+#else
+    wxUnusedVar(chAccel);
+    wxUnusedVar(lParam);
  #endif
      return wxNOT_FOUND;
  }
  #endif
      return wxNOT_FOUND;
  }
@@ -4713,7 +4817,7 @@ bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
          default:
              wxFAIL_MSG(wxT("no such joystick event"));
  
          default:
              wxFAIL_MSG(wxT("no such joystick event"));
  
-            return FALSE;
+            return false;
      }
  
      wxJoystickEvent event(eventType, buttons, joystick, change);
      }
  
      wxJoystickEvent event(eventType, buttons, joystick, change);
@@ -4722,7 +4826,11 @@ bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
  
      return GetEventHandler()->ProcessEvent(event);
  #else
  
      return GetEventHandler()->ProcessEvent(event);
  #else
-    return FALSE;
+    wxUnusedVar(msg);
+    wxUnusedVar(x);
+    wxUnusedVar(y);
+    wxUnusedVar(flags);
+    return false;
  #endif
  }
  
  #endif
  }
  
@@ -4733,7 +4841,7 @@ bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
  bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
                                WXWORD pos, WXHWND control)
  {
  bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
                                WXWORD pos, WXHWND control)
  {
-    if ( control )
+    if ( control && control != m_hWnd ) // Prevent infinite recursion
      {
          wxWindow *child = wxFindWinFromHandle(control);
          if ( child )
      {
          wxWindow *child = wxFindWinFromHandle(control);
          if ( child )
@@ -4800,7 +4908,7 @@ bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
          break;
  
      default:
          break;
  
      default:
-        return FALSE;
+        return false;
      }
  
      return GetEventHandler()->ProcessEvent(event);
      }
  
      return GetEventHandler()->ProcessEvent(event);
@@ -4810,22 +4918,20 @@ bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
  // global functions
  // ===========================================================================
  
  // global functions
  // ===========================================================================
  
-void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
+void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font)
  {
      TEXTMETRIC tm;
      HDC dc = ::GetDC((HWND) wnd);
  {
      TEXTMETRIC tm;
      HDC dc = ::GetDC((HWND) wnd);
-    HFONT fnt =0;
      HFONT was = 0;
      HFONT was = 0;
-    if ( the_font )
-    {
-        //    the_font->UseResource();
-        //    the_font->RealizeResource();
-        fnt = (HFONT)((wxFont *)the_font)->GetResourceHandle(); // const_cast
-        if ( fnt )
-            was = (HFONT) SelectObject(dc,fnt);
-    }
+
+    //    the_font.UseResource();
+    //    the_font.RealizeResource();
+    HFONT fnt = (HFONT)the_font.GetResourceHandle(); // const_cast
+    if ( fnt )
+        was = (HFONT) SelectObject(dc,fnt);
+
      GetTextMetrics(dc, &tm);
      GetTextMetrics(dc, &tm);
-    if ( the_font && fnt && was )
+    if ( fnt && was )
      {
          SelectObject(dc,was);
      }
      {
          SelectObject(dc,was);
      }
@@ -4836,13 +4942,12 @@ void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
      if ( y )
          *y = tm.tmHeight + tm.tmExternalLeading;
  
      if ( y )
          *y = tm.tmHeight + tm.tmExternalLeading;
  
-    //  if ( the_font )
-    //    the_font->ReleaseResource();
+    //   the_font.ReleaseResource();
  }
  
  // Returns 0 if was a normal ASCII value, not a special key. This indicates that
  // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
  }
  
  // Returns 0 if was a normal ASCII value, not a special key. This indicates that
  // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
-int wxCharCodeMSWToWX(int keySym)
+int wxCharCodeMSWToWX(int keySym, WXLPARAM lParam)
  {
      int id;
      switch (keySym)
  {
      int id;
      switch (keySym)
@@ -4851,7 +4956,6 @@ int wxCharCodeMSWToWX(int keySym)
          case VK_BACK:       id = WXK_BACK; break;
          case VK_TAB:        id = WXK_TAB; break;
          case VK_CLEAR:      id = WXK_CLEAR; break;
          case VK_BACK:       id = WXK_BACK; break;
          case VK_TAB:        id = WXK_TAB; break;
          case VK_CLEAR:      id = WXK_CLEAR; break;
-        case VK_RETURN:     id = WXK_RETURN; break;
          case VK_SHIFT:      id = WXK_SHIFT; break;
          case VK_CONTROL:    id = WXK_CONTROL; break;
          case VK_MENU :      id = WXK_MENU; break;
          case VK_SHIFT:      id = WXK_SHIFT; break;
          case VK_CONTROL:    id = WXK_CONTROL; break;
          case VK_MENU :      id = WXK_MENU; break;
@@ -4933,6 +5037,13 @@ int wxCharCodeMSWToWX(int keySym)
          case VK_APPS:       id = WXK_WINDOWS_MENU; break;
  #endif // VK_APPS defined
  
          case VK_APPS:       id = WXK_WINDOWS_MENU; break;
  #endif // VK_APPS defined
  
+        case VK_RETURN:
+            // the same key is sent for both the "return" key on the main
+            // keyboard and the numeric keypad but we want to distinguish
+            // between them: we do this using the "extended" bit (24) of lParam
+            id = lParam & (1 << 24) ? WXK_NUMPAD_ENTER : WXK_RETURN;
+            break;
+
          default:
              id = 0;
      }
          default:
              id = 0;
      }
@@ -4940,18 +5051,20 @@ int wxCharCodeMSWToWX(int keySym)
      return id;
  }
  
      return id;
  }
  
-int wxCharCodeWXToMSW(int id, bool *isVirtual)
+WXWORD wxCharCodeWXToMSW(int id, bool *isVirtual)
  {
  {
-    *isVirtual = TRUE;
-    int keySym;
+    *isVirtual = true;
+    WXWORD keySym;
      switch (id)
      {
      case WXK_CANCEL:    keySym = VK_CANCEL; break;
      case WXK_CLEAR:     keySym = VK_CLEAR; break;
      case WXK_SHIFT:     keySym = VK_SHIFT; break;
      case WXK_CONTROL:   keySym = VK_CONTROL; break;
      switch (id)
      {
      case WXK_CANCEL:    keySym = VK_CANCEL; break;
      case WXK_CLEAR:     keySym = VK_CLEAR; break;
      case WXK_SHIFT:     keySym = VK_SHIFT; break;
      case WXK_CONTROL:   keySym = VK_CONTROL; break;
+    case WXK_ALT:       keySym = VK_MENU; break;
      case WXK_MENU :     keySym = VK_MENU; break;
      case WXK_PAUSE:     keySym = VK_PAUSE; break;
      case WXK_MENU :     keySym = VK_MENU; break;
      case WXK_PAUSE:     keySym = VK_PAUSE; break;
+    case WXK_CAPITAL:   keySym = VK_CAPITAL; break;
      case WXK_PRIOR:     keySym = VK_PRIOR; break;
      case WXK_NEXT :     keySym = VK_NEXT; break;
      case WXK_END:       keySym = VK_END; break;
      case WXK_PRIOR:     keySym = VK_PRIOR; break;
      case WXK_NEXT :     keySym = VK_NEXT; break;
      case WXK_END:       keySym = VK_END; break;
@@ -5009,8 +5122,8 @@ int wxCharCodeWXToMSW(int id, bool *isVirtual)
      case WXK_SCROLL:    keySym = VK_SCROLL; break;
      default:
          {
      case WXK_SCROLL:    keySym = VK_SCROLL; break;
      default:
          {
-            *isVirtual = FALSE;
-            keySym = id;
+            *isVirtual = false;
+            keySym = (WORD)id;
              break;
          }
      }
              break;
          }
      }
@@ -5020,13 +5133,32 @@ int wxCharCodeWXToMSW(int id, bool *isVirtual)
  bool wxGetKeyState(wxKeyCode key)
  {
      bool bVirtual;
  bool wxGetKeyState(wxKeyCode key)
  {
      bool bVirtual;
-    int vkey = wxCharCodeWXToMSW(key, &bVirtual);
-    
-    //there aren't WXK_ macros for non-virtual key codes
-    if (bVirtual == false)
-        return false;
  
  
-    return GetKeyState(vkey) < 0;
+//High order with GetAsyncKeyState only available on WIN32
+#ifdef __WIN32__    
+    //If the requested key is a LED key, return
+    //true if the led is pressed
+    if (key == WXK_NUMLOCK ||
+        key == WXK_CAPITAL ||
+        key == WXK_SCROLL)
+    {
+#endif
+        //low order bit means LED is highlighted, 
+        //high order means key is down
+        //Here, for compat with other ports we want both
+        return GetKeyState( wxCharCodeWXToMSW(key, &bVirtual) ) != 0;
+
+#ifdef __WIN32__    
+    }
+    else
+    {
+        //normal key
+        //low order bit means key pressed since last call
+        //high order means key is down
+        //We want only the high order bit - the key may not be down if only low order
+        return ( GetAsyncKeyState( wxCharCodeWXToMSW(key, &bVirtual) ) & (1<<15) ) != 0;
+    }
+#endif
  }
  
  wxWindow *wxGetActiveWindow()
  }
  
  wxWindow *wxGetActiveWindow()
@@ -5058,7 +5190,7 @@ extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
              // do it as well, win would be already non NULL
              if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
              {
              // do it as well, win would be already non NULL
              if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
              {
-                win = (wxWindow *)::GetWindowLong(hwnd, GWL_USERDATA);
+                win = (wxWindow *)wxGetWindowUserData(hwnd);
              }
              //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
  #endif // wxUSE_RADIOBOX
              }
              //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
  #endif // wxUSE_RADIOBOX
@@ -5131,12 +5263,12 @@ wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
      DWORD hiWord = HIWORD(lParam);
      if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
      {
      DWORD hiWord = HIWORD(lParam);
      if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
      {
-        int id = wxCharCodeMSWToWX(wParam);
+        int id = wxCharCodeMSWToWX(wParam, lParam);
          if ( id != 0 )
          {
              wxKeyEvent event(wxEVT_CHAR_HOOK);
              if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
          if ( id != 0 )
          {
              wxKeyEvent event(wxEVT_CHAR_HOOK);
              if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
-                event.m_altDown = TRUE;
+                event.m_altDown = true;
  
              event.m_eventObject = NULL;
              event.m_keyCode = id;
  
              event.m_eventObject = NULL;
              event.m_keyCode = id;
@@ -5155,7 +5287,7 @@ wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
              else
              {
                  handler = wxTheApp;
              else
              {
                  handler = wxTheApp;
-                event.SetId(-1);
+                event.SetId(wxID_ANY);
              }
  
              if ( handler && handler->ProcessEvent(event) )
              }
  
              if ( handler && handler->ProcessEvent(event) )
@@ -5583,26 +5715,6 @@ const char *wxGetMessageName(int message)
  }
  #endif //__WXDEBUG__
  
  }
  #endif //__WXDEBUG__
  
-static void TranslateKbdEventToMouse(wxWindowMSW *win,
-                                     int *x, int *y, WPARAM *flags)
-{
-    // construct the key mask
-    WPARAM& fwKeys = *flags;
-
-    fwKeys = MK_RBUTTON;
-    if ( wxIsCtrlDown() )
-        fwKeys |= MK_CONTROL;
-    if ( wxIsShiftDown() )
-        fwKeys |= MK_SHIFT;
-
-    // simulate right mouse button click
-    DWORD dwPos = ::GetMessagePos();
-    *x = GET_X_LPARAM(dwPos);
-    *y = GET_Y_LPARAM(dwPos);
-
-    win->ScreenToClient(x, y);
-}
-
  static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
  {
      // prepare the DC
  static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
  {
      // prepare the DC
@@ -5689,10 +5801,10 @@ bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
      {
          wxLogLastError(_T("RegisterHotKey"));
  
      {
          wxLogLastError(_T("RegisterHotKey"));
  
-        return FALSE;
+        return false;
      }
  
      }
  
-    return TRUE;
+    return true;
  }
  
  bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
  }
  
  bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
@@ -5701,12 +5813,14 @@ bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
      {
          wxLogLastError(_T("UnregisterHotKey"));
  
      {
          wxLogLastError(_T("UnregisterHotKey"));
  
-        return FALSE;
+        return false;
      }
  
      }
  
-    return TRUE;
+    return true;
  }
  
  }
  
+#if wxUSE_ACCEL
+
  bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
  {
      int hotkeyId = wParam;
  bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
  {
      int hotkeyId = wParam;
@@ -5723,56 +5837,99 @@ bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
      return GetEventHandler()->ProcessEvent(event);
  }
  
      return GetEventHandler()->ProcessEvent(event);
  }
  
+#endif // wxUSE_ACCEL
+
  #endif // wxUSE_HOTKEY
  
  #endif // wxUSE_HOTKEY
  
-// Not verified for WinCE
+// Not tested under WinCE
  #ifndef __WXWINCE__
  #ifndef __WXWINCE__
-/*
- *     wxEventFixModule (needs a better name) allows message handling to continute while a menu
- *  is being shown - ie, to continue processing messages from a worker thread.
- * 
- *  Code originally by Jason W. from wx-dev, reworked into a wxModule by Chris Mellon
- */
-
-class wxEventFixModule : public wxModule {
+
+// this class installs a message hook which really wakes up our idle processing
+// each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
+// sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
+// being dragged or even inside ::MessageBox()) and so don't control message
+// dispatching otherwise
+class wxIdleWakeUpModule : public wxModule
+{
  public:
  public:
-       //base class virtuals
-       virtual bool OnInit() {
-               wxEventFixModule::s_hMsgHookProc = SetWindowsHookEx(
-                       WH_GETMESSAGE,
-                       &wxEventFixModule::MsgHookProc,
-                       NULL,
-                       GetCurrentThreadId());
-                       wxLogDebug(_T("Loaded event fix module"));
-                       return true;
-       };
-       virtual void OnExit() {
-               UnhookWindowsHookEx(wxEventFixModule::s_hMsgHookProc);
-
-       };
-       static LRESULT CALLBACK MsgHookProc(int nCode, WPARAM wParam, LPARAM lParam) {
-               MSG *msg = (MSG*)lParam;
-               switch (msg->message)
-               {
-        case WM_NULL:
-            static bool bInHookProc = false;
-            if (!bInHookProc)
-            {
-                bInHookProc = true;
-                wxTheApp->ProcessPendingEvents();
-                bInHookProc = false;
-            }
-            break;
-               }
-               return CallNextHookEx(wxEventFixModule::s_hMsgHookProc, nCode, wParam, lParam);
-       };
+    virtual bool OnInit()
+    {
+        ms_hMsgHookProc = ::SetWindowsHookEx
+                            (
+                             WH_GETMESSAGE,
+                             &wxIdleWakeUpModule::MsgHookProc,
+                             NULL,
+                             GetCurrentThreadId()
+                            );
+
+        if ( !ms_hMsgHookProc )
+        {
+            wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    virtual void OnExit()
+    {
+        ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc);
+    }
+
+    static LRESULT CALLBACK MsgHookProc(int nCode, WPARAM wParam, LPARAM lParam)
+    {
+        MSG *msg = (MSG*)lParam;
+        if ( msg->message == WM_NULL )
+        {
+            wxTheApp->ProcessPendingEvents();
+        }
+
+        return CallNextHookEx(ms_hMsgHookProc, nCode, wParam, lParam);
+    };
+
  private:
  private:
-       static HHOOK s_hMsgHookProc;
-DECLARE_DYNAMIC_CLASS(wxEventFixModule)
+    static HHOOK ms_hMsgHookProc;
+
+    DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule)
  };
  };
-HHOOK wxEventFixModule::s_hMsgHookProc = 0;
  
  
-IMPLEMENT_DYNAMIC_CLASS(wxEventFixModule, wxModule)
+HHOOK wxIdleWakeUpModule::ms_hMsgHookProc = 0;
+
+IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule, wxModule)
+
+#endif // __WXWINCE__
+
+#ifdef __WXWINCE__
+
+#if wxUSE_STATBOX
+static void wxAdjustZOrder(wxWindow* parent)
+{
+    if (parent->IsKindOf(CLASSINFO(wxStaticBox)))
+    {
+        // Set the z-order correctly
+        SetWindowPos((HWND) parent->GetHWND(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+    }
+
+    wxWindowList::compatibility_iterator current = parent->GetChildren().GetFirst();
+    while (current)
+    {
+        wxWindow *childWin = current->GetData();
+        wxAdjustZOrder(childWin);
+        current = current->GetNext();
+    }
+}
+#endif
+
+// We need to adjust the z-order of static boxes in WinCE, to
+// make 'contained' controls visible
+void wxWindowMSW::OnInitDialog( wxInitDialogEvent& event )
+{
+#if wxUSE_STATBOX
+    wxAdjustZOrder(this);
+#endif
+
+    event.Skip();
+}
  #endif
  #endif
-    // __WXWINCE__
-    
+