diff --git a/distrib/msw/tmake/filelist.txt b/distrib/msw/tmake/filelist.txt
index 8807a1492e..5b66d38147 100644
--- a/distrib/msw/tmake/filelist.txt
+++ b/distrib/msw/tmake/filelist.txt
@@ -230,6 +230,7 @@ fontutil.cpp	M
 frame.cpp	M
 gauge95.cpp	M	32
 gaugemsw.cpp	M	16
+gdiimage.cpp	M
 gdiobj.cpp	M
 helpwin.cpp	M
 icon.cpp	M
@@ -772,6 +773,7 @@ frame.h	9
 gauge.h	9
 gauge95.h	9
 gaugemsw.h	9
+gdiimage.h	9
 gdiobj.h	9
 helpwin.h	9
 icon.h	9
diff --git a/include/wx/msw/gdiimage.h b/include/wx/msw/gdiimage.h
new file mode 100644
index 0000000000..68d36488eb
--- /dev/null
+++ b/include/wx/msw/gdiimage.h
@@ -0,0 +1,190 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        include/wx/msw/gdiimage.h
+// Purpose:     wxGDIImage class: base class for wxBitmap, wxIcon, wxCursor
+//              under MSW
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     20.11.99
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence:     wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+// NB: this is a private header, it is not intended to be directly included by
+//     user code (but may be included from other, public, wxWin headers
+
+#ifndef _WX_MSW_GDIIMAGE_H_
+#define _WX_MSW_GDIIMAGE_H_
+
+#ifdef __GNUG__
+    #pragma interface "gdiimage.h"
+#endif
+
+#include "wx/gdiobj.h"          // base class
+
+class WXDLLEXPORT wxGDIImageRefData;
+class WXDLLEXPORT wxGDIImageHandler;
+class WXDLLEXPORT wxGDIImage;
+
+// ----------------------------------------------------------------------------
+// wxGDIImageRefData: common data fields for all derived classes
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGDIImageRefData : public wxGDIRefData
+{
+public:
+    wxGDIImageRefData()
+    {
+        m_width = m_height = m_depth = 0;
+
+        m_handle = 0;
+
+#if WXWIN_COMPATIBILITY_2
+        m_ok = FALSE;
+#endif // WXWIN_COMPATIBILITY_2
+    }
+
+    // accessors
+    bool IsOk() const { return m_handle != 0; }
+
+    void SetSize(int w, int h) { m_width = w; m_height = h; }
+
+    // free the ressources we allocated
+    virtual void Free() = 0;
+
+    // for compatibility, the member fields are public
+
+    // the size of the image
+    int m_width, m_height;
+
+    // the depth of the image
+    int m_depth;
+
+    // the handle to it
+    union
+    {
+        WXHANDLE  m_handle;     // for untyped access
+        WXHBITMAP m_hBitmap;
+        WXHICON   m_hIcon;
+        WXHCURSOR m_hCursor;
+    };
+
+    // this filed is redundant and using it is error prone but keep it for
+    // backwards compatibility
+#if WXWIN_COMPATIBILITY_2
+    void SetOk() { m_ok = m_handle != 0; }
+
+    bool          m_ok;
+#endif // WXWIN_COMPATIBILITY_2
+};
+
+// ----------------------------------------------------------------------------
+// wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGDIImageHandler : public wxObject
+{
+public:
+    // ctor
+    wxGDIImageHandler() { m_type = wxBITMAP_TYPE_INVALID; }
+    wxGDIImageHandler(const wxString& name,
+                      const wxString& ext,
+                      long type)
+        : m_name(name), m_extension(ext)
+    {
+        m_type = type;
+    }
+
+    // accessors
+    void SetName(const wxString& name) { m_name = name; }
+    void SetExtension(const wxString& ext) { m_extension = ext; }
+    void SetType(long type) { m_type = type; }
+
+    wxString GetName() const { return m_name; }
+    wxString GetExtension() const { return m_extension; }
+    long GetType() const { return m_type; }
+
+    // real handler operations: to implement in derived classes
+    virtual bool Create(wxGDIImage *image,
+                        void *data,
+                        long flags,
+                        int width, int height, int depth = 1) = 0;
+    virtual bool Load(wxGDIImage *image,
+                      const wxString& name,
+                      long flags,
+                      int desiredWidth, int desiredHeight) = 0;
+    virtual bool Save(wxGDIImage *image,
+                      const wxString& name,
+                      int type) = 0;
+
+protected:
+    wxString  m_name;
+    wxString  m_extension;
+    long      m_type;
+};
+
+// ----------------------------------------------------------------------------
+// wxGDIImage: this class supports GDI image handlers which may be registered
+// dynamically and will be used for loading/saving the images in the specified
+// format. It also falls back to wxImage if no appropriate image is found.
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGDIImage : public wxGDIObject
+{
+public:
+    // handlers list interface
+    static wxList& GetHandlers() { return ms_handlers; }
+
+    static void AddHandler(wxGDIImageHandler *handler);
+    static void InsertHandler(wxGDIImageHandler *handler);
+    static bool RemoveHandler(const wxString& name);
+
+    static wxGDIImageHandler *FindHandler(const wxString& name);
+    static wxGDIImageHandler *FindHandler(const wxString& extension, long type);
+    static wxGDIImageHandler *FindHandler(long type);
+
+    static void InitStandardHandlers();
+    static void CleanUpHandlers();
+
+    // access to the ref data casted to the right type
+    wxGDIImageRefData *GetGDIImageData() const
+        { return (wxGDIImageRefData *)m_refData; }
+
+    // create data if we don't have it yet
+    void EnsureHasData() { if ( IsNull() ) m_refData = CreateData(); }
+
+    // accessors
+    WXHANDLE GetHandle() const
+        { return IsNull() ? 0 : GetGDIImageData()->m_handle; }
+    void SetHandle(WXHANDLE handle)
+        { EnsureHasData(); GetGDIImageData()->m_handle = handle; }
+
+    bool Ok() const { return GetHandle() != 0; }
+
+    int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_width; }
+    int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_height; }
+    int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_depth; }
+
+    void SetWidth(int w) { EnsureHasData(); GetGDIImageData()->m_width = w; }
+    void SetHeight(int h) { EnsureHasData(); GetGDIImageData()->m_height = h; }
+    void SetDepth(int d) { EnsureHasData(); GetGDIImageData()->m_depth = d; }
+
+    void SetSize(int w, int h)
+    {
+        EnsureHasData();
+        GetGDIImageData()->SetSize(w, h);
+    }
+    void SetSize(const wxSize& size) { SetSize(size.x, size.y); }
+
+    // forward some of base class virtuals to wxGDIImageRefData
+    bool FreeResource(bool force = FALSE);
+    virtual WXHANDLE GetResourceHandle();
+
+protected:
+    // create the data for the derived class here
+    virtual wxGDIImageRefData *CreateData() const = 0;
+
+    static wxList ms_handlers;
+};
+
+#endif // _WX_MSW_GDIIMAGE_H_
diff --git a/src/msw/cursor.cpp b/src/msw/cursor.cpp
index b483ad0145..706b97fb92 100644
--- a/src/msw/cursor.cpp
+++ b/src/msw/cursor.cpp
@@ -9,271 +9,271 @@
 // Licence:       wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
-#pragma implementation "cursor.h"
+    #pragma implementation "cursor.h"
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #ifndef WX_PRECOMP
-#include <stdio.h>
-#include "wx/setup.h"
-#include "wx/list.h"
-#include "wx/utils.h"
-#include "wx/app.h"
-#include "wx/cursor.h"
-#include "wx/icon.h"
+    #include "wx/list.h"
+    #include "wx/utils.h"
+    #include "wx/app.h"
+    #include "wx/cursor.h"
+    #include "wx/icon.h"
 #endif
 
 #include "wx/msw/private.h"
 #include "wx/msw/dib.h"
 
-#include "assert.h"
-
 #if wxUSE_RESOURCE_LOADING_IN_MSW
-#include "wx/msw/curico.h"
-#include "wx/msw/curicop.h"
+    #include "wx/msw/curico.h"
+    #include "wx/msw/curicop.h"
 #endif
 
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
+
 #if !USE_SHARED_LIBRARIES
-IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
+    IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxCursorBase)
 #endif
 
-wxCursorRefData::wxCursorRefData(void)
+// ----------------------------------------------------------------------------
+// wxCursorRefData
+// ----------------------------------------------------------------------------
+
+wxCursorRefData::wxCursorRefData()
 {
-  m_width = 32; m_height = 32;
-  m_hCursor = 0 ;
+  m_width = 32;
+  m_height = 32;
+
   m_destroyCursor = FALSE;
 }
 
-wxCursorRefData::~wxCursorRefData(void)
+void wxCursorRefData::Free()
 {
-    if ( m_hCursor && m_destroyCursor)
-#ifdef __WXWINE__
-        ::DestroyCursor((HCURSOR) m_hCursor);
-#else
-        ::DestroyCursor((HICON) m_hCursor);
-#endif
+    if ( m_hCursor && m_destroyCursor )
+        ::DestroyCursor((HCURSOR)m_hCursor);
 }
 
+// ----------------------------------------------------------------------------
 // Cursors
-wxCursor::wxCursor(void)
+// ----------------------------------------------------------------------------
+
+wxCursor::wxCursor()
 {
 }
 
-wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
-    int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
+wxCursor::wxCursor(const char WXUNUSED(bits)[],
+                   int WXUNUSED(width),
+                   int WXUNUSED(height),
+                   int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY),
+                   const char WXUNUSED(maskBits)[])
 {
 }
 
-wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
+wxCursor::wxCursor(const wxString& cursor_file,
+                   long flags,
+                   int hotSpotX, int hotSpotY)
 {
-  m_refData = new wxCursorRefData;
+    wxCursorRefData *refData = new wxCursorRefData;
+    m_refData = refData;
 
-  M_CURSORDATA->m_destroyCursor = FALSE;
-  M_CURSORDATA->m_hCursor = 0;
-  M_CURSORDATA->m_ok = FALSE;
-  if (flags == wxBITMAP_TYPE_CUR_RESOURCE)
-  {
+    refData->m_destroyCursor = FALSE;
+
+    if (flags == wxBITMAP_TYPE_CUR_RESOURCE)
+    {
 #ifdef __WIN95__
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, 0);
+        refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, 0);
 #else
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
+        refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
 #endif
-    if (M_CURSORDATA->m_hCursor)
-      M_CURSORDATA->m_ok = TRUE;
-    else
-      M_CURSORDATA->m_ok = FALSE;
-  }
-  else if (flags == wxBITMAP_TYPE_CUR)
-  {
+    }
+    else if (flags == wxBITMAP_TYPE_CUR)
+    {
 #ifdef __WIN95__
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
+        refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
 #else
 #if wxUSE_RESOURCE_LOADING_IN_MSW
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) ReadCursorFile(WXSTRINGCAST cursor_file, wxGetInstance(), &M_CURSORDATA->m_width, &M_CURSORDATA->m_height);
-    M_CURSORDATA->m_destroyCursor = TRUE;
+        refData->m_hCursor = (WXHCURSOR) ReadCursorFile(WXSTRINGCAST cursor_file, wxGetInstance(), &refData->m_width, &refData->m_height);
+        refData->m_destroyCursor = TRUE;
 #endif
 #endif
-  }
-  else if (flags == wxBITMAP_TYPE_ICO)
-  {
+    }
+    else if (flags == wxBITMAP_TYPE_ICO)
+    {
 #if wxUSE_RESOURCE_LOADING_IN_MSW
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) IconToCursor(WXSTRINGCAST cursor_file, wxGetInstance(), hotSpotX, hotSpotY, &M_CURSORDATA->m_width, &M_CURSORDATA->m_height);
-    M_CURSORDATA->m_destroyCursor = TRUE;
+        refData->m_hCursor = (WXHCURSOR) IconToCursor(WXSTRINGCAST cursor_file, wxGetInstance(), hotSpotX, hotSpotY, &refData->m_width, &refData->m_height);
+        refData->m_destroyCursor = TRUE;
 #endif
-  }
-  else if (flags == wxBITMAP_TYPE_BMP)
-  {
+    }
+    else if (flags == wxBITMAP_TYPE_BMP)
+    {
 #if wxUSE_RESOURCE_LOADING_IN_MSW
-    HBITMAP hBitmap = 0;
-    HPALETTE hPalette = 0;
-    bool success = wxReadDIB(WXSTRINGCAST cursor_file, &hBitmap, &hPalette) != 0;
-    if (!success)
-      return;
-    if (hPalette)
-      DeleteObject(hPalette);
-    POINT pnt;
-    pnt.x = hotSpotX;
-    pnt.y = hotSpotY;
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pnt);
-    M_CURSORDATA->m_destroyCursor = TRUE;
-    DeleteObject(hBitmap);
-    if (M_CURSORDATA->m_hCursor)
-      M_CURSORDATA->m_ok = TRUE;
+        HBITMAP hBitmap = 0;
+        HPALETTE hPalette = 0;
+        bool success = wxReadDIB(WXSTRINGCAST cursor_file, &hBitmap, &hPalette) != 0;
+        if (!success)
+            return;
+        if (hPalette)
+            DeleteObject(hPalette);
+        POINT pnt;
+        pnt.x = hotSpotX;
+        pnt.y = hotSpotY;
+        refData->m_hCursor = (WXHCURSOR) MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pnt);
+        refData->m_destroyCursor = TRUE;
+        DeleteObject(hBitmap);
 #endif
-  }
+    }
+
+#if WXWIN_COMPATIBILITY_2
+    refData->SetOk();
+#endif // WXWIN_COMPATIBILITY_2
 }
 
 // Cursors by stock number
 wxCursor::wxCursor(int cursor_type)
 {
-  m_refData = new wxCursorRefData;
+  wxCursorRefData *refData = new wxCursorRefData;
+  m_refData = refData;
 
   switch (cursor_type)
   {
     case wxCURSOR_WAIT:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_WAIT);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_WAIT);
       break;
     case wxCURSOR_IBEAM:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_IBEAM);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_IBEAM);
       break;
     case wxCURSOR_CROSS:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_CROSS);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_CROSS);
       break;
     case wxCURSOR_SIZENWSE:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENWSE);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENWSE);
       break;
     case wxCURSOR_SIZENESW:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENESW);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENESW);
       break;
     case wxCURSOR_SIZEWE:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZEWE);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZEWE);
       break;
     case wxCURSOR_SIZENS:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENS);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENS);
       break;
     case wxCURSOR_CHAR:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
       break;
     }
     case wxCURSOR_HAND:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_HAND"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_HAND"));
       break;
     }
     case wxCURSOR_BULLSEYE:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BULLSEYE"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BULLSEYE"));
       break;
     }
     case wxCURSOR_PENCIL:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PENCIL"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PENCIL"));
       break;
     }
     case wxCURSOR_MAGNIFIER:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_MAGNIFIER"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_MAGNIFIER"));
       break;
     }
     case wxCURSOR_NO_ENTRY:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_NO_ENTRY"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_NO_ENTRY"));
       break;
     }
     case wxCURSOR_LEFT_BUTTON:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
       break;
     }
     case wxCURSOR_RIGHT_BUTTON:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
       break;
     }
     case wxCURSOR_MIDDLE_BUTTON:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
       break;
     }
     case wxCURSOR_SIZING:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_SIZING"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_SIZING"));
       break;
     }
     case wxCURSOR_WATCH:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_WATCH"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_WATCH"));
       break;
     }
     case wxCURSOR_SPRAYCAN:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_ROLLER"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_ROLLER"));
       break;
     }
     case wxCURSOR_PAINT_BRUSH:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PBRUSH"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PBRUSH"));
       break;
     }
     case wxCURSOR_POINT_LEFT:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PLEFT"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PLEFT"));
       break;
     }
     case wxCURSOR_POINT_RIGHT:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));
       break;
     }
     case wxCURSOR_QUESTION_ARROW:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));
       break;
     }
     case wxCURSOR_BLANK:
     {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));
       break;
     }
     default:
     case wxCURSOR_ARROW:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
       break;
   }
 }
 
-wxCursor::~wxCursor(void)
+wxCursor::~wxCursor()
 {
-//    FreeResource(TRUE);
-}
-
-bool wxCursor::FreeResource(bool WXUNUSED(force))
-{
-  if (M_CURSORDATA && M_CURSORDATA->m_hCursor && M_CURSORDATA->m_destroyCursor)
-  {
-    DestroyCursor((HCURSOR) M_CURSORDATA->m_hCursor);
-    M_CURSORDATA->m_hCursor = 0;
-  }
-  return TRUE;
-}
-
-void wxCursor::SetHCURSOR(WXHCURSOR cursor)
-{
-  if ( !M_CURSORDATA )
-    m_refData = new wxCursorRefData;
-
-  M_CURSORDATA->m_hCursor = cursor;
 }
 
+// ----------------------------------------------------------------------------
 // Global cursor setting
+// ----------------------------------------------------------------------------
+
 void wxSetCursor(const wxCursor& cursor)
 {
     extern wxCursor *g_globalCursor;
diff --git a/src/msw/dib.cpp b/src/msw/dib.cpp
index 3bf8fe09bc..2bc530afeb 100644
--- a/src/msw/dib.cpp
+++ b/src/msw/dib.cpp
@@ -731,7 +731,9 @@ bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal)
     bitmap->SetWidth(bm.bmWidth);
     bitmap->SetHeight(bm.bmHeight);
     bitmap->SetDepth(bm.bmPlanes * bm.bmBitsPixel);
+#if WXWIN_COMPATIBILITY_2
     bitmap->SetOk(TRUE);
+#endif // WXWIN_COMPATIBILITY_2
     return TRUE;
   }
   else return FALSE;
diff --git a/src/msw/frame.cpp b/src/msw/frame.cpp
index 45df30ead7..aa75762ebc 100644
--- a/src/msw/frame.cpp
+++ b/src/msw/frame.cpp
@@ -357,6 +357,8 @@ wxStatusBar *wxFrame::OnCreateStatusBar(int number,
     if ( UsesNativeStatusBar() )
     {
         statusBar = new wxStatusBar95(this, id, style);
+
+        statusBar->SetFieldsCount(number);
     }
     else
 #endif
diff --git a/src/msw/gdiimage.cpp b/src/msw/gdiimage.cpp
new file mode 100644
index 0000000000..d8015b11e3
--- /dev/null
+++ b/src/msw/gdiimage.cpp
@@ -0,0 +1,503 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        msw/gdiimage.cpp
+// Purpose:     wxGDIImage implementation
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     20.11.99
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence:     wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "gdiimage.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+    #include "wx/string.h"
+#endif // WX_PRECOMP
+
+#include "wx/app.h"
+
+#include "wx/msw/dib.h"
+#include "wx/msw/gdiimage.h"
+
+#include "wx/msw/private.h"
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+// all image handlers are declared/defined in this file because the outside
+// world doesn't have to know about them (but only about wxBITMAP_TYPE_XXX ids)
+
+class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
+{
+public:
+    wxBMPFileHandler() : wxBitmapHandler(_T("Windows bitmap file"), _T("bmp"),
+                                         wxBITMAP_TYPE_BMP)
+    {
+    }
+
+    virtual bool LoadFile(wxBitmap *bitmap,
+                          const wxString& name, long flags,
+                          int desiredWidth, int desiredHeight);
+    virtual bool SaveFile(wxBitmap *bitmap,
+                          const wxString& name, int type,
+                          const wxPalette *palette = NULL);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
+};
+
+class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
+{
+public:
+    wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"),
+                                             wxEmptyString,
+                                             wxBITMAP_TYPE_BMP_RESOURCE)
+    {
+    }
+
+    virtual bool LoadFile(wxBitmap *bitmap,
+                          const wxString& name, long flags,
+                          int desiredWidth, int desiredHeight);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
+};
+
+class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
+{
+public:
+    wxIconHandler(const wxString& name, const wxString& ext, long type)
+        : wxGDIImageHandler(name, ext, type)
+    {
+    }
+
+    // creating and saving icons is not supported
+    virtual bool Create(wxGDIImage *WXUNUSED(image),
+                        void *WXUNUSED(data),
+                        long WXUNUSED(flags),
+                        int WXUNUSED(width),
+                        int WXUNUSED(height),
+                        int WXUNUSED(depth) = 1)
+    {
+        return FALSE;
+    }
+
+    virtual bool Save(wxGDIImage *WXUNUSED(image),
+                      const wxString& WXUNUSED(name),
+                      int WXUNUSED(type))
+    {
+        return FALSE;
+    }
+
+    virtual bool Load(wxGDIImage *image,
+                      const wxString& name,
+                      long flags,
+                      int desiredWidth, int desiredHeight)
+    {
+        wxIcon *icon = wxDynamicCast(image, wxIcon);
+        wxCHECK_MSG( icon, FALSE, _T("wxIconHandler only works with icons") );
+
+        return LoadIcon(icon, name, flags, desiredWidth, desiredHeight);
+    }
+
+protected:
+    virtual bool LoadIcon(wxIcon *icon,
+                          const wxString& name, long flags,
+                          int desiredWidth = -1, int desiredHeight = -1) = 0;
+};
+
+class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
+{
+public:
+    wxICOFileHandler() : wxIconHandler(_T("ICO icon file"),
+                                       _T("ico"),
+                                       wxBITMAP_TYPE_ICO)
+    {
+    }
+
+    virtual bool LoadIcon(wxIcon *icon,
+                          const wxString& name, long flags,
+                          int desiredWidth = -1, int desiredHeight = -1);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
+};
+
+class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
+{
+public:
+    wxICOResourceHandler() : wxIconHandler(_T("ICO resource"),
+                                           _T("ico"),
+                                           wxBITMAP_TYPE_ICO_RESOURCE)
+    {
+    }
+
+    virtual bool LoadIcon(wxIcon *icon,
+                          const wxString& name, long flags,
+                          int desiredWidth = -1, int desiredHeight = -1);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
+};
+
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
+
+#if !USE_SHARED_LIBRARIES
+    IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
+    IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
+    IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxGDIImageHandler)
+    IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxGDIImageHandler)
+#endif
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static wxSize GetHiconSize(HICON hicon);
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+wxList wxGDIImage::ms_handlers;
+
+// ----------------------------------------------------------------------------
+// wxGDIImage functions forwarded to wxGDIImageRefData
+// ----------------------------------------------------------------------------
+
+bool wxGDIImage::FreeResource(bool WXUNUSED(force))
+{
+    if ( !IsNull() )
+    {
+        GetGDIImageData()->Free();
+        GetGDIImageData()->m_handle = 0;
+    }
+
+    return TRUE;
+}
+
+WXHANDLE wxGDIImage::GetResourceHandle()
+{
+    return GetHandle();
+}
+
+// ----------------------------------------------------------------------------
+// wxGDIImage handler stuff
+// ----------------------------------------------------------------------------
+
+void wxGDIImage::AddHandler(wxGDIImageHandler *handler)
+{
+    ms_handlers.Append(handler);
+}
+
+void wxGDIImage::InsertHandler(wxGDIImageHandler *handler)
+{
+    ms_handlers.Insert(handler);
+}
+
+bool wxGDIImage::RemoveHandler(const wxString& name)
+{
+    wxGDIImageHandler *handler = FindHandler(name);
+    if ( handler )
+    {
+        ms_handlers.DeleteObject(handler);
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& name)
+{
+    wxNode *node = ms_handlers.First();
+    while ( node )
+    {
+        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
+        if ( handler->GetName() == name )
+            return handler;
+        node = node->Next();
+    }
+
+    return NULL;
+}
+
+wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& extension,
+                                           long type)
+{
+    wxNode *node = ms_handlers.First();
+    while ( node )
+    {
+        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
+        if ( (handler->GetExtension() = extension) &&
+             (type == -1 || handler->GetType() == type) )
+        {
+            return handler;
+        }
+
+        node = node->Next();
+    }
+    return NULL;
+}
+
+wxGDIImageHandler *wxGDIImage::FindHandler(long type)
+{
+    wxNode *node = ms_handlers.First();
+    while ( node )
+    {
+        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
+        if ( handler->GetType() == type )
+            return handler;
+
+        node = node->Next();
+    }
+
+    return NULL;
+}
+
+void wxGDIImage::CleanUpHandlers()
+{
+    wxNode *node = ms_handlers.First();
+    while ( node )
+    {
+        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
+        wxNode *next = node->Next();
+        delete handler;
+        delete node;
+        node = next;
+    }
+}
+
+void wxGDIImage::InitStandardHandlers()
+{
+    AddHandler(new wxBMPResourceHandler);
+    AddHandler(new wxBMPFileHandler);
+
+    // Not added by default: include xpmhand.h in your app
+    // and call these in your wxApp::OnInit.
+    //  AddHandler(new wxXPMFileHandler);
+    //  AddHandler(new wxXPMDataHandler);
+
+    AddHandler(new wxICOResourceHandler);
+    AddHandler(new wxICOFileHandler);
+}
+
+// ----------------------------------------------------------------------------
+// wxBitmap handlers
+// ----------------------------------------------------------------------------
+
+bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap,
+                                    const wxString& name, long WXUNUSED(flags),
+                                    int WXUNUSED(desiredWidth),
+                                    int WXUNUSED(desiredHeight))
+{
+    // TODO: load colourmap.
+    bitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), name));
+
+    wxBitmapRefData *data = bitmap->GetBitmapData();
+    if ( bitmap->Ok() )
+    {
+        BITMAP bm;
+        if ( !::GetObject(GetHbitmapOf(*bitmap), sizeof(BITMAP), (LPSTR) &bm) )
+        {
+            wxLogLastError("GetObject(HBITMAP)");
+        }
+
+        data->m_width = bm.bmWidth;
+        data->m_height = bm.bmHeight;
+        data->m_depth = bm.bmBitsPixel;
+    }
+    else
+    {
+        // it's probably not found
+        wxLogError(wxT("Can't load bitmap '%s' from resources! Check .rc file."),
+                   name.c_str());
+    }
+
+    return bitmap->Ok();
+}
+
+bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
+                                const wxString& name, long WXUNUSED(flags),
+                                int WXUNUSED(desiredWidth),
+                                int WXUNUSED(desiredHeight))
+{
+#if wxUSE_IMAGE_LOADING_IN_MSW
+    wxPalette *palette = NULL;
+    bool success = wxLoadIntoBitmap(WXSTRINGCAST name, bitmap, &palette) != 0;
+    if ( success && palette )
+    {
+        bitmap->SetPalette(*palette);
+    }
+
+    // it was copied by the bitmap if it was loaded successfully
+    delete palette;
+
+    return success;
+#else
+    return FALSE;
+#endif
+}
+
+bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap,
+                                const wxString& name,
+                                int WXUNUSED(type),
+                                const wxPalette *pal)
+{
+#if wxUSE_IMAGE_LOADING_IN_MSW
+    wxPalette *actualPalette = (wxPalette *)pal;
+    if ( !actualPalette )
+        actualPalette = bitmap->GetPalette();
+    return wxSaveBitmap(WXSTRINGCAST name, bitmap, actualPalette) != 0;
+#else
+    return FALSE;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// wxIcon handlers
+// ----------------------------------------------------------------------------
+
+bool wxICOFileHandler::LoadIcon(wxIcon *icon,
+                                const wxString& name,
+                                long flags,
+                                int desiredWidth, int desiredHeight)
+{
+#if wxUSE_RESOURCE_LOADING_IN_MSW
+    icon->UnRef();
+
+    // actual size
+    wxSize size;
+
+#ifdef __WIN32__
+    HICON hicon = ::ExtractIcon(wxGetInstance(), name, 0 /* first */);
+    if ( !hicon )
+    {
+        wxLogSysError(_T("Failed to load icon from the file '%s'"),
+                      name.c_str());
+
+        return FALSE;
+    }
+
+    size = GetHiconSize(hicon);
+#else // Win16
+    HICON hicon = ReadIconFile((wxChar *)name.c_str(),
+                               wxGetInstance(),
+                               &size.x, &size.y);
+#endif // Win32/Win16
+
+    if ( (desiredWidth != -1 && desiredWidth != size.x) ||
+         (desiredHeight != -1 && desiredHeight != size.y) )
+    {
+        wxLogDebug(_T("Returning FALSE from wxICOFileHandler::Load because "
+                      "of the size mismatch: actual (%d, %d), "
+                      "requested (%d, %d)"),
+                      size.x, size.y,
+                      desiredWidth, desiredHeight);
+
+        ::DestroyIcon(hicon);
+
+        return FALSE;
+    }
+
+    icon->SetHICON((WXHICON)hicon);
+    icon->SetSize(size.x, size.y);
+
+    return icon->Ok();
+#else
+    return FALSE;
+#endif
+}
+
+bool wxICOResourceHandler::LoadIcon(wxIcon *icon,
+                                    const wxString& name,
+                                    long flags,
+                                    int desiredWidth, int desiredHeight)
+{
+    HICON hicon;
+
+#if defined(__WIN32__) && !defined(__SC__)
+    if ( desiredWidth != -1 && desiredHeight != -1 )
+    {
+        hicon = (HICON)::LoadImage(wxGetInstance(), name, IMAGE_ICON,
+                                    desiredWidth, desiredHeight,
+                                    LR_DEFAULTCOLOR);
+    }
+    else
+#endif // Win32
+    {
+        hicon = ::LoadIcon(wxGetInstance(), name);
+    }
+
+    wxSize size = GetHiconSize(hicon);
+    icon->SetSize(size.x, size.y);
+
+    // Override the found values with desired values
+    if ( desiredWidth > -1 && desiredHeight > -1 )
+    {
+        icon->SetSize(desiredWidth, desiredHeight);
+    }
+
+    icon->SetHICON((WXHICON)hicon);
+
+    return icon->Ok();
+}
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static wxSize GetHiconSize(HICON hicon)
+{
+    wxSize size(32, 32);    // default
+
+#ifdef __WIN32__
+    // Win32s doesn't have GetIconInfo function...
+    if ( hicon && wxGetOsVersion() != wxWIN32S )
+    {
+        ICONINFO info;
+        if ( !::GetIconInfo(hicon, &info) )
+        {
+            wxLogLastError("GetIconInfo");
+        }
+        else
+        {
+            HBITMAP hbmp = info.hbmMask;
+            if ( hbmp )
+            {
+                BITMAP bm;
+                if ( ::GetObject(hbmp, sizeof(BITMAP), (LPSTR) &bm) )
+                {
+                    size = wxSize(bm.bmWidth, bm.bmHeight);
+                }
+
+                ::DeleteObject(info.hbmMask);
+            }
+            if ( info.hbmColor )
+                ::DeleteObject(info.hbmColor);
+        }
+    }
+#endif
+
+    return size;
+}
diff --git a/src/msw/icon.cpp b/src/msw/icon.cpp
index a788d29ed1..0c2187db94 100644
--- a/src/msw/icon.cpp
+++ b/src/msw/icon.cpp
@@ -1,189 +1,111 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        icon.cpp
+// Name:        msw/icon.cpp
 // Purpose:     wxIcon class
 // Author:      Julian Smart
-// Modified by:
+// Modified by: 20.11.99 (VZ): don't derive from wxBitmap any more
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
-#pragma implementation "icon.h"
+    #pragma implementation "icon.h"
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #ifndef WX_PRECOMP
-#include <stdio.h>
-#include "wx/setup.h"
-#include "wx/list.h"
-#include "wx/utils.h"
-#include "wx/app.h"
-#include "wx/icon.h"
+    #include "wx/defs.h"
+    #include "wx/list.h"
+    #include "wx/utils.h"
+    #include "wx/app.h"
+    #include "wx/icon.h"
 #endif
 
 #include "wx/msw/private.h"
-#include "assert.h"
 
 #if wxUSE_RESOURCE_LOADING_IN_MSW
-#include "wx/msw/curico.h"
-#include "wx/msw/curicop.h"
+    #include "wx/msw/curico.h"
+    #include "wx/msw/curicop.h"
 #endif
 
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
+
 #if !USE_SHARED_LIBRARIES
-IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
-IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
-IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
+    IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxIconBase)
 #endif
 
-/*
- * Icons
- */
+// ============================================================================
+// implementation
+// ============================================================================
 
+// ----------------------------------------------------------------------------
+// wxIconRefData
+// ----------------------------------------------------------------------------
 
-wxIconRefData::wxIconRefData(void)
+void wxIconRefData::Free()
 {
-  m_hIcon = (WXHICON) NULL ;
+    if ( m_hIcon )
+        ::DestroyIcon((HICON) m_hIcon);
 }
 
-wxIconRefData::~wxIconRefData(void)
-{
-  if ( m_hIcon )
-    ::DestroyIcon((HICON) m_hIcon);
-}
+// ----------------------------------------------------------------------------
+// wxIcon
+// ----------------------------------------------------------------------------
 
-wxIcon::wxIcon(void)
+wxIcon::wxIcon()
 {
 }
 
-wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
+wxIcon::wxIcon(const char WXUNUSED(bits)[],
+               int WXUNUSED(width),
+               int WXUNUSED(height))
 {
 }
 
-wxIcon::wxIcon(const wxString& icon_file, long flags,
-    int desiredWidth, int desiredHeight)
+wxIcon::wxIcon(const wxString& iconfile,
+               long flags,
+               int desiredWidth,
+               int desiredHeight)
 
 {
-  LoadFile(icon_file, flags, desiredWidth, desiredHeight);
+    LoadFile(iconfile, flags, desiredWidth, desiredHeight);
 }
 
-wxIcon::~wxIcon(void)
+wxIcon::~wxIcon()
 {
 }
 
-bool wxIcon::FreeResource(bool force)
+bool wxIcon::LoadFile(const wxString& filename,
+                      long type,
+                      int desiredWidth, int desiredHeight)
 {
-  if (M_ICONDATA && M_ICONDATA->m_hIcon)
-  {
-    DestroyIcon((HICON) M_ICONDATA->m_hIcon);
-  M_ICONDATA->m_hIcon = (WXHICON) NULL;
-  }
-  return TRUE;
-}
+    UnRef();
 
-bool wxIcon::LoadFile(const wxString& filename, long type,
-    int desiredWidth, int desiredHeight)
-{
-  UnRef();
+    wxGDIImageHandler *handler = FindHandler(type);
 
-  m_refData = new wxIconRefData;
-
-  wxBitmapHandler *handler = FindHandler(type);
-
-  if ( handler )
-  return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
-  else
-  return FALSE;
-}
-
-void wxIcon::SetHICON(WXHICON ico)
-{
-  if ( !M_ICONDATA )
-  m_refData = new wxIconRefData;
-
-  M_ICONDATA->m_hIcon = ico;
-}
-
-bool wxICOFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth, int desiredHeight)
-{
-#if wxUSE_RESOURCE_LOADING_IN_MSW
-  if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
-  {
-    wxIcon *icon = (wxIcon *)bitmap;
-    wxIconRefData *data = (wxIconRefData *)icon->GetRefData();
-    data->m_hIcon = (WXHICON)ReadIconFile((wxChar *)name.c_str(), wxGetInstance(),
-                                          &data->m_width, &data->m_height);
-
-    data->m_ok = data->m_hIcon != 0;
-    return data->m_ok;
-  }
-  else
-    return FALSE;
-#else
-  return FALSE;
-#endif
-}
-
-bool wxICOResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-    int desiredWidth, int desiredHeight)
-{
-  if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
-  {
-#if defined(__WIN32__) && !defined(__SC__)
-    if (desiredWidth > -1 && desiredHeight > -1)
+    if ( !handler )
     {
-        M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadImage(wxGetInstance(), name, IMAGE_ICON, desiredWidth, desiredHeight, LR_DEFAULTCOLOR);
-    }
-    else
-#endif
-    {
-      M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadIcon(wxGetInstance(), name);
+        // say something?
+        return FALSE;
     }
 
-#ifdef __WIN32__
-      // Win32s doesn't have GetIconInfo function...
-      if (M_ICONHANDLERDATA->m_hIcon && wxGetOsVersion()!=wxWIN32S)
-      {
-          ICONINFO info ;
-          if (::GetIconInfo((HICON) M_ICONHANDLERDATA->m_hIcon, &info))
-          {
-            HBITMAP ms_bitmap = info.hbmMask ;
-            if (ms_bitmap)
-            {
-                BITMAP bm;
-                ::GetObject(ms_bitmap, sizeof(BITMAP), (LPSTR) &bm);
-                M_ICONHANDLERDATA->m_width = bm.bmWidth;
-                M_ICONHANDLERDATA->m_height = bm.bmHeight;
-            }
-            if (info.hbmMask)
-                ::DeleteObject(info.hbmMask) ;
-            if (info.hbmColor)
-                ::DeleteObject(info.hbmColor) ;
-          }
-      }
-#else
-      M_ICONHANDLERDATA->m_width = 32;
-      M_ICONHANDLERDATA->m_height = 32;
-#endif
-      // Override the found values with desired values
-      if (desiredWidth > -1 && desiredHeight > -1)
-      {
-          M_ICONHANDLERDATA->m_width = desiredWidth;
-          M_ICONHANDLERDATA->m_height = desiredHeight;
-      }
-
-      M_ICONHANDLERDATA->m_ok = (M_ICONHANDLERDATA->m_hIcon != 0);
-      return M_ICONHANDLERDATA->m_ok;
-  }
-  else
-      return FALSE;
+    return handler->Load(this, filename, type, desiredWidth, desiredHeight);
 }
 
diff --git a/src/msw/makefile.b32 b/src/msw/makefile.b32
index adf1b7ffe0..6b427c2518 100644
--- a/src/msw/makefile.b32
+++ b/src/msw/makefile.b32
@@ -1,6 +1,6 @@
 
 
-# This file was automatically generated by tmake at 14:56, 1999/11/15
+# This file was automatically generated by tmake at 13:22, 1999/11/24
 # DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE B32.T!
 
 #
@@ -245,6 +245,7 @@ MSWOBJS = $(MSWDIR)\accel.obj \
 		$(MSWDIR)\fontutil.obj \
 		$(MSWDIR)\frame.obj \
 		$(MSWDIR)\gauge95.obj \
+		$(MSWDIR)\gdiimage.obj \
 		$(MSWDIR)\gdiobj.obj \
 		$(MSWDIR)\gsocket.obj \
 		$(MSWDIR)\helpwin.obj \
@@ -446,6 +447,8 @@ $(MSWDIR)\frame.obj: $(MSWDIR)\frame.$(SRCSUFF)
 
 $(MSWDIR)\gauge95.obj: $(MSWDIR)\gauge95.$(SRCSUFF)
 
+$(MSWDIR)\gdiimage.obj: $(MSWDIR)\gdiimage.$(SRCSUFF)
+
 $(MSWDIR)\gdiobj.obj: $(MSWDIR)\gdiobj.$(SRCSUFF)
 
 $(MSWDIR)\gsocket.obj: $(MSWDIR)\gsocket.c
diff --git a/src/msw/makefile.bcc b/src/msw/makefile.bcc
index 32974bff59..796e088cc9 100644
--- a/src/msw/makefile.bcc
+++ b/src/msw/makefile.bcc
@@ -1,6 +1,6 @@
 
 
-# This file was automatically generated by tmake at 14:24, 1999/11/15
+# This file was automatically generated by tmake at 13:22, 1999/11/24
 # DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE BCC.T!
 
 #
@@ -215,6 +215,7 @@ MSWOBJS = $(MSWDIR)\accel.obj \
 		$(MSWDIR)\fontutil.obj \
 		$(MSWDIR)\frame.obj \
 		$(MSWDIR)\gaugemsw.obj \
+		$(MSWDIR)\gdiimage.obj \
 		$(MSWDIR)\gdiobj.obj \
 		$(MSWDIR)\gsocket.obj \
 		$(MSWDIR)\helpwin.obj \
@@ -360,6 +361,8 @@ $(MSWDIR)\frame.obj: $(MSWDIR)\frame.$(SRCSUFF)
 
 $(MSWDIR)\gaugemsw.obj: $(MSWDIR)\gaugemsw.$(SRCSUFF)
 
+$(MSWDIR)\gdiimage.obj: $(MSWDIR)\gdiimage.$(SRCSUFF)
+
 $(MSWDIR)\gdiobj.obj: $(MSWDIR)\gdiobj.$(SRCSUFF)
 
 $(MSWDIR)\gsocket.obj: $(MSWDIR)\gsocket.c
diff --git a/src/msw/makefile.dos b/src/msw/makefile.dos
index 9112a5cdcd..bdc9acddae 100644
--- a/src/msw/makefile.dos
+++ b/src/msw/makefile.dos
@@ -1,4 +1,4 @@
-# This file was automatically generated by tmake at 14:24, 1999/11/15
+# This file was automatically generated by tmake at 13:22, 1999/11/24
 # DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE DOS.T!
 
 #
@@ -204,6 +204,7 @@ MSWOBJS1 = $(MSWDIR)\accel.obj \
 		$(MSWDIR)\fontutil.obj \
 		$(MSWDIR)\frame.obj \
 		$(MSWDIR)\gaugemsw.obj \
+		$(MSWDIR)\gdiimage.obj \
 		$(MSWDIR)\gdiobj.obj \
 		$(MSWDIR)\gsocket.obj \
 		$(MSWDIR)\helpwin.obj \
@@ -498,6 +499,11 @@ $(MSWDIR)/gaugemsw.obj:     $*.$(SRCSUFF)
 $(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
 <<
 
+$(MSWDIR)/gdiimage.obj:     $*.$(SRCSUFF)
+        cl @<<
+$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
+<<
+
 $(MSWDIR)/gdiobj.obj:     $*.$(SRCSUFF)
         cl @<<
 $(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
diff --git a/src/msw/makefile.g95 b/src/msw/makefile.g95
index 33541fcfd2..4670010e64 100644
--- a/src/msw/makefile.g95
+++ b/src/msw/makefile.g95
@@ -1,4 +1,4 @@
-# This file was automatically generated by tmake at 14:24, 1999/11/15
+# This file was automatically generated by tmake at 13:22, 1999/11/24
 # DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE G95.T!
 
 #
@@ -224,6 +224,7 @@ MSWOBJS     = \
 		$(MSWDIR)/fontutil.$(OBJSUFF) \
 		$(MSWDIR)/frame.$(OBJSUFF) \
 		$(MSWDIR)/gauge95.$(OBJSUFF) \
+		$(MSWDIR)/gdiimage.$(OBJSUFF) \
 		$(MSWDIR)/gdiobj.$(OBJSUFF) \
 		$(MSWDIR)/gsocket.$(OBJSUFF) \
 		$(MSWDIR)/helpwin.$(OBJSUFF) \
diff --git a/src/msw/makefile.sc b/src/msw/makefile.sc
index 97f153fb7d..9f6b1f2c86 100644
--- a/src/msw/makefile.sc
+++ b/src/msw/makefile.sc
@@ -1,6 +1,6 @@
 
 
-# This file was automatically generated by tmake at 14:24, 1999/11/15
+# This file was automatically generated by tmake at 13:22, 1999/11/24
 # DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE SC.T!
 
 # Symantec C++ makefile for the msw objects
@@ -184,6 +184,7 @@ MSWOBJS = $(MSWDIR)\accel.obj \
 		$(MSWDIR)\frame.obj \
 		$(MSWDIR)\gauge95.obj \
 		$(MSWDIR)\gaugemsw.obj \
+		$(MSWDIR)\gdiimage.obj \
 		$(MSWDIR)\gdiobj.obj \
 		$(MSWDIR)\gsocket.obj \
 		$(MSWDIR)\helpwin.obj \
diff --git a/src/msw/makefile.vc b/src/msw/makefile.vc
index 7f23a3faa3..760110149b 100644
--- a/src/msw/makefile.vc
+++ b/src/msw/makefile.vc
@@ -1,4 +1,4 @@
-# This file was automatically generated by tmake at 10:51, 1999/11/24
+# This file was automatically generated by tmake at 13:22, 1999/11/24
 # DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE VC.T!
 
 # File:     makefile.vc
@@ -262,6 +262,7 @@ MSWOBJS = ..\msw\$D\accel.obj \
 		..\msw\$D\fontutil.obj \
 		..\msw\$D\frame.obj \
 		..\msw\$D\gauge95.obj \
+		..\msw\$D\gdiimage.obj \
 		..\msw\$D\gdiobj.obj \
 		..\msw\$D\gsocket.obj \
 		..\msw\$D\helpwin.obj \
diff --git a/src/msw/makefile.wat b/src/msw/makefile.wat
index 98476d14c2..e3e852359b 100644
--- a/src/msw/makefile.wat
+++ b/src/msw/makefile.wat
@@ -1,6 +1,6 @@
 #!/binb/wmake.exe
 
-# This file was automatically generated by tmake at 14:24, 1999/11/15
+# This file was automatically generated by tmake at 13:22, 1999/11/24
 # DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE WAT.T!
 
 #
@@ -217,6 +217,7 @@ MSWOBJS = accel.obj &
 	frame.obj &
 	gauge95.obj &
 	gaugemsw.obj &
+	gdiimage.obj &
 	gdiobj.obj &
 	gsocket.obj &
 	helpwin.obj &
@@ -422,6 +423,9 @@ gauge95.obj:     $(MSWDIR)\gauge95.cpp
 gaugemsw.obj:     $(MSWDIR)\gaugemsw.cpp
   *$(CCC) $(CPPFLAGS) $(IFLAGS) $<
 
+gdiimage.obj:     $(MSWDIR)\gdiimage.cpp
+  *$(CCC) $(CPPFLAGS) $(IFLAGS) $<
+
 gdiobj.obj:     $(MSWDIR)\gdiobj.cpp
   *$(CCC) $(CPPFLAGS) $(IFLAGS) $<
 
diff --git a/src/msw/ole/dataobj.cpp b/src/msw/ole/dataobj.cpp
index 21eae48819..72e6a05a9c 100644
--- a/src/msw/ole/dataobj.cpp
+++ b/src/msw/ole/dataobj.cpp
@@ -18,26 +18,27 @@
 // ----------------------------------------------------------------------------
 
 #ifdef __GNUG__
-  #pragma implementation "dataobj.h"
+    #pragma implementation "dataobj.h"
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #if defined(__BORLANDC__)
-  #pragma hdrstop
+    #pragma hdrstop
 #endif
+
+#if defined(__WIN32__) && !defined(__GNUWIN32_OLD__)
+
 #ifndef WX_PRECOMP
-#include "wx/intl.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
 #endif
-#include "wx/defs.h"
 
-#if defined(__WIN32__) && !defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS)
-
-#include "wx/log.h"
 #include "wx/dataobj.h"
 
-#include <windows.h>
+#include "wx/msw/private.h"         // includes <windows.h>
+
 #ifdef wxUSE_NORLANDER_HEADERS
   #include <ole2.h>
 #endif
@@ -50,7 +51,9 @@
 
 #include <shlobj.h>
 
-#include  "wx/msw/ole/oleutils.h"
+#include "wx/msw/ole/oleutils.h"
+
+#include "wx/msw/dib.h"
 
 // ----------------------------------------------------------------------------
 // functions
@@ -62,10 +65,6 @@
     #define GetTymedName(tymed) ""
 #endif // Debug/!Debug
 
-// to be moved into wx/msw/bitmap.h
-extern size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap);
-extern wxBitmap wxConvertDIBToBitmap(const BITMAPINFO *bmi);
-
 // ----------------------------------------------------------------------------
 // wxIEnumFORMATETC interface implementation
 // ----------------------------------------------------------------------------
@@ -124,22 +123,6 @@ private:
     bool m_mustDelete;
 };
 
-// ----------------------------------------------------------------------------
-// small helper class for getting screen DC (we're working with bitmaps and
-// DIBs here)
-// ----------------------------------------------------------------------------
-
-class ScreenHDC
-{
-public:
-    ScreenHDC() { m_hdc = GetDC(NULL);    }
-   ~ScreenHDC() { ReleaseDC(NULL, m_hdc); }
-    operator HDC() const { return m_hdc;  }
-
-private:
-    HDC m_hdc;
-};
-
 // ============================================================================
 // implementation
 // ============================================================================
@@ -736,12 +719,12 @@ size_t wxBitmapDataObject::GetDataSize() const
 
 bool wxBitmapDataObject::GetDataHere(void *buf) const
 {
-    return wxConvertBitmapToDIB((BITMAPINFO *)buf, GetBitmap()) != 0;
+    return wxConvertBitmapToDIB((LPBITMAPINFO)buf, GetBitmap()) != 0;
 }
 
 bool wxBitmapDataObject::SetData(size_t len, const void *buf)
 {
-    wxBitmap bitmap(wxConvertDIBToBitmap((const BITMAPINFO *)buf));
+    wxBitmap bitmap(wxConvertDIBToBitmap((const LPBITMAPINFO)buf));
 
     if ( !bitmap.Ok() ) {
         wxFAIL_MSG(wxT("pasting/dropping invalid bitmap"));
@@ -1065,7 +1048,7 @@ static size_t wxGetNumOfBitmapColors(size_t bitsPerPixel)
     }
 }
 
-size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap)
+size_t wxConvertBitmapToDIB(LPBITMAPINFO pbi, const wxBitmap& bitmap)
 {
     wxASSERT_MSG( bitmap.Ok(), wxT("invalid bmp can't be converted to DIB") );
 
@@ -1139,7 +1122,7 @@ size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap)
     return dwLen + bi.biSizeImage;
 }
 
-wxBitmap wxConvertDIBToBitmap(const BITMAPINFO *pbmi)
+wxBitmap wxConvertDIBToBitmap(const LPBITMAPINFO pbmi)
 {
     // here we get BITMAPINFO struct followed by the actual bitmap bits and
     // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info
diff --git a/src/msw/pnghand.cpp b/src/msw/pnghand.cpp
index 833dd0a0f2..543e96f6a2 100644
--- a/src/msw/pnghand.cpp
+++ b/src/msw/pnghand.cpp
@@ -313,8 +313,9 @@ bool wxPNGReader::InstantiateBitmap(wxBitmap *bitmap)
           bitmap->SetDepth(GetDepth());
           if ( GetDepth() > 1 && Palette )
             bitmap->SetPalette(*Palette);
+#if WXWIN_COMPATIBILITY_2
           bitmap->SetOk(TRUE);
-
+#endif // WXWIN_COMPATIBILITY_2
 
           // Make a mask if appropriate
           if ( bgindex > -1 )
diff --git a/src/msw/statbmp.cpp b/src/msw/statbmp.cpp
index ab210117e5..e37a780841 100644
--- a/src/msw/statbmp.cpp
+++ b/src/msw/statbmp.cpp
@@ -55,7 +55,7 @@
 // ---------------------------------------------------------------------------
 
 bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
-                            const wxBitmap& bitmap,
+                            const wxGDIImage& bitmap,
                             const wxPoint& pos,
                             const wxSize& size,
                             long style,
@@ -108,7 +108,7 @@ bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
 
     wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create static bitmap") );
 
-    SetBitmap(bitmap);
+    SetImage(bitmap);
 
     // Subclass again for purposes of dialog editing mode
     SubclassWin(m_hWnd);
@@ -122,22 +122,14 @@ bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
 
 bool wxStaticBitmap::ImageIsOk() const
 {
-    if ( m_isIcon && m_image.icon )
-        return m_image.icon->Ok();
-    else if ( m_image.bitmap )
-        return m_image.bitmap->Ok();
-    else
-        return FALSE;
+    return m_image && m_image->Ok();
 }
 
 void wxStaticBitmap::Free()
 {
-    if ( m_isIcon )
-        delete m_image.icon;
-    else
-        delete m_image.bitmap;
+    delete m_image;
 
-    m_image.icon = NULL;
+    m_image = NULL;
 }
 
 wxSize wxStaticBitmap::DoGetBestSize() const
@@ -147,15 +139,15 @@ wxSize wxStaticBitmap::DoGetBestSize() const
     return wxWindow::DoGetBestSize();
 }
 
-void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
+void wxStaticBitmap::SetImage(const wxGDIImage& bitmap)
 {
     Free();
 
     m_isIcon = bitmap.IsKindOf(CLASSINFO(wxIcon));
     if ( m_isIcon )
-        m_image.icon = new wxIcon((const wxIcon&)bitmap);
+        m_image = new wxIcon((const wxIcon&)bitmap);
     else
-        m_image.bitmap = new wxBitmap(bitmap);
+        m_image = new wxBitmap((const wxBitmap &)bitmap);
 
     int x, y;
     int w, h;
@@ -163,9 +155,8 @@ void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
     GetSize(&w, &h);
 
 #ifdef __WIN32__
-    HANDLE handle = m_isIcon ? (HANDLE)m_image.icon->GetHICON()
-                             : (HANDLE)m_image.bitmap->GetHBITMAP();
-    ::SendMessage((HWND)m_hWnd, STM_SETIMAGE,
+    HANDLE handle = (HANDLE)m_image->GetHandle();
+    ::SendMessage(GetHwnd(), STM_SETIMAGE,
                   m_isIcon ? IMAGE_ICON : IMAGE_BITMAP, (LPARAM)handle);
 #endif // Win32
 
@@ -178,16 +169,16 @@ void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
             w = width;
             h = height;
 
-            ::MoveWindow((HWND)GetHWND(), x, y, width, height, FALSE);
+            ::MoveWindow(GetHwnd(), x, y, width, height, FALSE);
         }
     }
 
-    RECT rect ;
-    rect.left   = x ;
-    rect.top    = y ;
-    rect.right  = x + w ;
-    rect.bottom = y + h ;
-    InvalidateRect((HWND)GetParent()->GetHWND(), &rect, TRUE);
+    RECT rect;
+    rect.left   = x;
+    rect.top    = y;
+    rect.right  = x + w;
+    rect.bottom = y + h;
+    InvalidateRect(GetHwndOf(GetParent()), &rect, TRUE);
 }
 
 // under Win32 we use the standard static control style for this
diff --git a/src/msw/textctrl.cpp b/src/msw/textctrl.cpp
index 3f00865a4c..49bd3207c4 100644
--- a/src/msw/textctrl.cpp
+++ b/src/msw/textctrl.cpp
@@ -57,7 +57,7 @@
 #   include <fstream>
 #endif
 
-#if wxUSE_RICHEDIT && (!defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS))
+#if wxUSE_RICHEDIT
     #include <richedit.h>
 #endif
 
@@ -115,8 +115,6 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
     if ( !CreateBase(parent, id, pos, size, style, validator, name) )
         return FALSE;
 
-    // Validator was set in CreateBase
-    //SetValidator(validator);
     if ( parent )
         parent->AddChild(this);
 
@@ -130,7 +128,7 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
     {
         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline "
-                         "text controls (they always process it)") );
+                          "text controls (they always process it)") );
 
         msStyle |= ES_MULTILINE | ES_WANTRETURN;
         if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
@@ -172,9 +170,32 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 #if wxUSE_RICHEDIT
     if ( m_windowStyle & wxTE_RICH )
     {
-        msStyle |= ES_AUTOVSCROLL;
-        m_isRich = TRUE;
-        windowClass = wxT("RICHEDIT");
+        static bool s_errorGiven = FALSE;   // MT-FIXME
+
+        // only give the error msg once if the DLL can't be loaded
+        if ( !s_errorGiven )
+        {
+            // first try to load the RichEdit DLL (will do nothing if already
+            // done)
+            if ( !wxTheApp->InitRichEdit() )
+            {
+                wxLogError(_("Impossible to create a rich edit control, "
+                             "using simple text control instead."));
+
+                s_errorGiven = TRUE;
+            }
+        }
+
+        if ( s_errorGiven )
+        {
+            m_isRich = FALSE;
+        }
+        else
+        {
+            msStyle |= ES_AUTOVSCROLL;
+            m_isRich = TRUE;
+            windowClass = wxT("RICHEDIT");
+        }
     }
     else
         m_isRich = FALSE;
diff --git a/src/msw/thread.cpp b/src/msw/thread.cpp
index 0722bd9361..22cc54ffe0 100644
--- a/src/msw/thread.cpp
+++ b/src/msw/thread.cpp
@@ -31,9 +31,7 @@
 
 #if wxUSE_THREADS
 
-#include <stdio.h>
-
-#include <windows.h>
+#include "wx/msw/private.h"
 
 #include "wx/module.h"
 #include "wx/thread.h"
@@ -84,6 +82,7 @@ static bool s_waitingForThread = FALSE;
 // ----------------------------------------------------------------------------
 // wxMutex implementation
 // ----------------------------------------------------------------------------
+
 class wxMutexInternal
 {
 public:
@@ -237,42 +236,27 @@ void wxCondition::Broadcast()
 // wxCriticalSection implementation
 // ----------------------------------------------------------------------------
 
-class wxCriticalSectionInternal
-{
-public:
-    // init the critical section object
-    wxCriticalSectionInternal()
-        { ::InitializeCriticalSection(&m_data); }
-
-    // implicit cast to the associated data
-    operator CRITICAL_SECTION *() { return &m_data; }
-
-    // free the associated ressources
-    ~wxCriticalSectionInternal()
-        { ::DeleteCriticalSection(&m_data); }
-
-private:
-    CRITICAL_SECTION m_data;
-};
-
 wxCriticalSection::wxCriticalSection()
 {
-    m_critsect = new wxCriticalSectionInternal;
+    wxASSERT_MSG( sizeof(CRITICAL_SECTION) == sizeof(m_buffer),
+                  _T("must increase buffer size in wx/thread.h") );
+
+    ::InitializeCriticalSection((CRITICAL_SECTION *)m_buffer);
 }
 
 wxCriticalSection::~wxCriticalSection()
 {
-    delete m_critsect;
+    ::DeleteCriticalSection((CRITICAL_SECTION *)m_buffer);
 }
 
 void wxCriticalSection::Enter()
 {
-    ::EnterCriticalSection(*m_critsect);
+    ::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
 }
 
 void wxCriticalSection::Leave()
 {
-    ::LeaveCriticalSection(*m_critsect);
+    ::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
 }
 
 // ----------------------------------------------------------------------------
diff --git a/src/msw/window.cpp b/src/msw/window.cpp
index cb7ceddbda..0df00e9696 100644
--- a/src/msw/window.cpp
+++ b/src/msw/window.cpp
@@ -1841,8 +1841,9 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
                 short y = HIWORD(lParam);
 
                 processed = HandleMouseMove(x, y, wParam);
-                break;
-            }
+           }
+           break;
+
         case WM_LBUTTONDOWN:
         case WM_LBUTTONUP:
         case WM_LBUTTONDBLCLK:
diff --git a/src/msw/xpmhand.cpp b/src/msw/xpmhand.cpp
index 89e5cf85ba..759d10e985 100644
--- a/src/msw/xpmhand.cpp
+++ b/src/msw/xpmhand.cpp
@@ -45,6 +45,25 @@
 #include "wx/xpmhand.h"
 #include "wx/msw/dib.h"
 
+static void XpmToBitmap(wxBitmap *bitmap,
+                        const XImage *ximage,
+                        const XpmAttributes& xpmAttr)
+{
+    wxBitmapRefData *refData = bitmap->GetBitmapData();
+    refData->m_hBitmap = (WXHBITMAP)ximage->bitmap;
+
+    BITMAP bm;
+    if ( !::GetObject(GetHbitmapOf(*bitmap), sizeof(bm), (LPSTR) & bm) )
+    {
+        wxLogLastError("GetObject(bitmap)");
+    }
+
+    refData->m_width = bm.bmWidth;
+    refData->m_height = bm.bmHeight;
+    refData->m_depth = bm.bmPlanes * bm.bmBitsPixel;
+    refData->m_numColors = xpmAttr.npixels;
+}
+
 IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
 
 bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
@@ -55,7 +74,6 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long fla
     XpmAttributes xpmAttr;
     HDC     dc;
 
-    M_BITMAPHANDLERDATA->m_ok = FALSE;
     dc = CreateCompatibleDC(NULL);
     if (dc)
     {
@@ -64,26 +82,17 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long fla
       DeleteDC(dc);
       if (errorStatus == XpmSuccess)
       {
-        M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ximage->bitmap;
+        XpmToBitmap(bitmap, ximage, xpmAttr);
 
-        BITMAP  bm;
-        GetObject((HBITMAP)M_BITMAPHANDLERDATA->m_hBitmap, sizeof(bm), (LPSTR) & bm);
-
-        M_BITMAPHANDLERDATA->m_width = (bm.bmWidth);
-        M_BITMAPHANDLERDATA->m_height = (bm.bmHeight);
-        M_BITMAPHANDLERDATA->m_depth = (bm.bmPlanes * bm.bmBitsPixel);
-        M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
         XpmFreeAttributes(&xpmAttr);
         XImageFree(ximage);
+      }
 
-        M_BITMAPHANDLERDATA->m_ok = TRUE;
-        return TRUE;
-      }
-      else
-      {
-        M_BITMAPHANDLERDATA->m_ok = FALSE;
-        return FALSE;
-      }
+#if WXWIN_COMPATIBILITY_2
+      bitmap->SetOk(errorStatus == XpmSuccess);
+#endif // WXWIN_COMPATIBILITY_2
+
+      return bitmap->Ok();
     }
 #endif
 
@@ -94,26 +103,28 @@ bool wxXPMFileHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type
 {
 #if wxUSE_XPM_IN_MSW
     HDC     dc = NULL;
-    
+
     XImage  ximage;
-    
+
     dc = CreateCompatibleDC(NULL);
     if (dc)
     {
-        if (SelectObject(dc, (HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap))
+        if ( SelectObject(dc, GetHbitmapOf(*bitmap)) )
         {
             /* for following SetPixel */
             /* fill the XImage struct 'by hand' */
-            ximage.width = M_BITMAPHANDLERDATA->m_width; 
-            ximage.height = M_BITMAPHANDLERDATA->m_height;
-            ximage.depth = M_BITMAPHANDLERDATA->m_depth; 
-            ximage.bitmap = (HBITMAP)M_BITMAPHANDLERDATA->m_hBitmap;
+            wxBitmapRefData *refData = bitmap->GetBitmapData();
+            ximage.width = refData->m_width;
+            ximage.height = refData->m_height;
+            ximage.depth = refData->m_depth;
+            ximage.bitmap = (HBITMAP)refData->m_hBitmap;
             int errorStatus = XpmWriteFileFromImage(&dc, wxMBSTRINGCAST name.fn_str(),
-                &ximage, (XImage *) NULL, (XpmAttributes *) NULL);
-            
+                                                    &ximage, (XImage *) NULL,
+                                                    (XpmAttributes *) NULL);
+
             if (dc)
                 DeleteDC(dc);
-            
+
             if (errorStatus == XpmSuccess)
                 return TRUE;    /* no error */
             else
@@ -135,45 +146,35 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *data, long flags, int widt
   XpmAttributes xpmAttr;
   HDC     dc;
 
-  M_BITMAPHANDLERDATA->m_ok = FALSE;
-  M_BITMAPHANDLERDATA->m_numColors = 0;
-
   dc = CreateCompatibleDC(NULL);  /* memory DC */
 
   if (dc)
   {
     xpmAttr.valuemask = XpmReturnInfos; /* get infos back */
     ErrorStatus = XpmCreateImageFromData(&dc, (char **)data,
-         &ximage, (XImage **) NULL, &xpmAttr);
+                                         &ximage, (XImage **) NULL, &xpmAttr);
 
     if (ErrorStatus == XpmSuccess)
     {
-      /* ximage is malloced and contains bitmap and attributes */
-      M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ximage->bitmap;
+        XpmToBitmap(bitmap, ximage, xpmAttr);
 
-      BITMAP  bm;
-      GetObject((HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap, sizeof(bm), (LPSTR) & bm);
-
-      M_BITMAPHANDLERDATA->m_width = (bm.bmWidth);
-      M_BITMAPHANDLERDATA->m_height = (bm.bmHeight);
-      M_BITMAPHANDLERDATA->m_depth = (bm.bmPlanes * bm.bmBitsPixel);
-      M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
       XpmFreeAttributes(&xpmAttr);
 
       XImageFree(ximage); // releases the malloc, but does not detroy
                           // the bitmap
-      M_BITMAPHANDLERDATA->m_ok = TRUE;
-      DeleteDC(dc);
-
-      return TRUE;
-    } 
+    }
     else
     {
-      M_BITMAPHANDLERDATA->m_ok = FALSE;
-//    XpmDebugError(ErrorStatus, NULL);
-      DeleteDC(dc);
-      return FALSE;
+      //    XpmDebugError(ErrorStatus, NULL);
     }
+
+    DeleteDC(dc);
+
+#if WXWIN_COMPATIBILITY_2
+      bitmap->SetOk(errorStatus == XpmSuccess);
+#endif // WXWIN_COMPATIBILITY_2
+
+    return bitmap->Ok();
   }
 #endif