big wxCursor cleanup

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@19058 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/msw/cursor.h

@@ -20,26 +20,12 @@
 
 class WXDLLEXPORT wxImage;
 
-class WXDLLEXPORT wxCursorRefData : public wxGDIImageRefData
-{
-public:
-    wxCursorRefData();
-    virtual ~wxCursorRefData() { Free(); }
-
-    virtual void Free();
-
-    // for compatibility
-public:
-    bool m_destroyCursor;
-};
-
 // Cursor
 class WXDLLEXPORT wxCursor : public wxGDIImage
 {
 public:
+    // constructors
     wxCursor();
-
-    // Copy constructors
     wxCursor(const wxCursor& cursor) { Ref(cursor); }
     wxCursor(const wxImage& image);
     wxCursor(const char bits[], int width, int height,
@@ -48,18 +34,22 @@ public:
     wxCursor(const wxString& name,
              long flags = wxBITMAP_TYPE_CUR_RESOURCE,
              int hotSpotX = 0, int hotSpotY = 0);
-    wxCursor(int cursor_type);
+    wxCursor(int idCursor);
     virtual ~wxCursor();
 
-    wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
+    wxCursor& operator=(const wxCursor& cursor)
-    bool operator == (const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
+        { if (*this == cursor) return (*this); Ref(cursor); return *this; }
-    bool operator != (const wxCursor& cursor) const { return m_refData != cursor.m_refData; }
 
+    bool operator==(const wxCursor& cursor) const;
+    bool operator!=(const wxCursor& cursor) const
+        { return !(*this == cursor); }
+
+    // implementation only
     void SetHCURSOR(WXHCURSOR cursor) { SetHandle((WXHANDLE)cursor); }
     WXHCURSOR GetHCURSOR() const { return (WXHCURSOR)GetHandle(); }
 
 protected:
-    virtual wxGDIImageRefData *CreateData() const { return new wxCursorRefData; }
+    virtual wxGDIImageRefData *CreateData() const;
 
 private:
     DECLARE_DYNAMIC_CLASS(wxCursor)

src/msw/cursor.cpp

@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        cursor.cpp
+// Name:        src/msw/cursor.cpp
 // Purpose:     wxCursor class
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart and Markus Holzem
+// Copyright:   (c) 1997-2003 Julian Smart and Vadim Zeitlin
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -37,11 +37,14 @@
     #include "wx/cursor.h"
 #endif
 
+#include "wx/ptr_scpd.h"
+
 #include "wx/module.h"
 #include "wx/image.h"
 #include "wx/msw/private.h"
+
 #ifndef __WXMICROWIN__
-#include "wx/msw/dib.h"
+    #include "wx/msw/dib.h"
 #endif
 
 #if wxUSE_RESOURCE_LOADING_IN_MSW
@@ -49,6 +52,41 @@
     #include "wx/msw/curicop.h"
 #endif
 
+// define functions missing in MicroWin
+#ifdef __WXMICROWIN__
+    static inline void DestroyCursor(HCURSOR) { }
+    static inline void SetCursor(HCURSOR) { }
+#endif // __WXMICROWIN__
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxCursorRefData : public wxGDIImageRefData
+{
+public:
+    // the second parameter is used to tell us to delete the cursor when we're
+    // done with it (normally we shouldn't call DestroyCursor() this is why it
+    // doesn't happen by default)
+    wxCursorRefData(HCURSOR hcursor = 0, bool takeOwnership = false);
+
+    virtual ~wxCursorRefData() { Free(); }
+
+    virtual void Free();
+
+
+    // return the size of the standard cursor: notice that the system only
+    // supports the cursors of this size
+    static wxCoord GetStandardWidth();
+    static wxCoord GetStandardHeight();
+
+private:
+    bool m_destroyCursor;
+
+    // standard cursor size, computed on first use
+    static wxSize ms_sizeStd;
+};
+
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
@@ -84,6 +122,13 @@ public:
     }
 };
 
+// ----------------------------------------------------------------------------
+// other types
+// ----------------------------------------------------------------------------
+
+wxDECLARE_SCOPED_ARRAY(unsigned char, ByteArray);
+wxDEFINE_SCOPED_ARRAY(unsigned char, ByteArray);
+
 // ============================================================================
 // implementation
 // ============================================================================
@@ -92,22 +137,43 @@ public:
 // wxCursorRefData
 // ----------------------------------------------------------------------------
 
-wxCursorRefData::wxCursorRefData()
+wxSize wxCursorRefData::ms_sizeStd;
-{
-  m_width = 32;
-  m_height = 32;
 
-  m_destroyCursor = TRUE;
+wxCoord wxCursorRefData::GetStandardWidth()
+{
+    if ( !ms_sizeStd.x )
+        ms_sizeStd.x = wxSystemSettings::GetMetric(wxSYS_CURSOR_X);
+
+    return ms_sizeStd.x;
+}
+
+wxCoord wxCursorRefData::GetStandardHeight()
+{
+    if ( !ms_sizeStd.y )
+        ms_sizeStd.y = wxSystemSettings::GetMetric(wxSYS_CURSOR_Y);
+
+    return ms_sizeStd.y;
+}
+
+wxCursorRefData::wxCursorRefData(HCURSOR hcursor, bool destroy)
+{
+    m_hCursor = (WXHCURSOR)hcursor;
+
+    if ( m_hCursor )
+    {
+        m_width = GetStandardWidth();
+        m_height = GetStandardHeight();
+    }
+
+    m_destroyCursor = destroy;
 }
 
 void wxCursorRefData::Free()
 {
     if ( m_hCursor )
     {
-#ifndef __WXMICROWIN__
         if ( m_destroyCursor )
             ::DestroyCursor((HCURSOR)m_hCursor);
-#endif
 
         m_hCursor = 0;
     }
@@ -121,63 +187,78 @@ wxCursor::wxCursor()
 {
 }
 
-wxCursor::wxCursor( const wxImage & image )
+wxCursor::wxCursor(const wxImage& image)
 {
-    //image has to be 32x32
+    // image has to be of the standard cursor size, otherwise we won't be able
-    wxImage image32 = image.Scale(32,32);
+    // to create it
-    unsigned char * rgbBits = image32.GetData();
+    const int w = wxCursorRefData::GetStandardWidth();
-    int w = image32.GetWidth()  ;
+    const int h = wxCursorRefData::GetStandardHeight();
-    int h = image32.GetHeight() ;
-    bool bHasMask = image32.HasMask() ;
-    int imagebitcount = (w*h)/8;
 
-    unsigned char r, g, b ;
+    wxImage image32 = image.Scale(w, h);
-    unsigned char * bits = new unsigned char [imagebitcount];
-    unsigned char * maskBits = new unsigned char [imagebitcount];
 
-    int i,j, i8; unsigned char c, cMask;
+    const int imagebitcount = (w*h)/8;
-    for (i=0; i<imagebitcount; i++)
+
+    ByteArray bits(new unsigned char [imagebitcount]),
+              maskBits(new unsigned char [imagebitcount]);
+
+    int i, j, i8;
+    unsigned char c, cMask;
+
+    const unsigned char * const rgbBits = image32.GetData();
+
+    // first create the XOR mask
+    for ( i = 0; i < imagebitcount; i++ )
     {
         bits[i] = 0;
         i8 = i * 8;
-//unlike gtk, the pixels go in the opposite order in the bytes
+        // unlike gtk, the pixels go in the opposite order in the bytes
         cMask = 128;
-        for (j=0; j<8; j++)
+        for ( j = 0; j < 8; j++ )
         {
             // possible overflow if we do the summation first ?
-           c = rgbBits[(i8+j)*3]/3 + rgbBits[(i8+j)*3+1]/3 + rgbBits[(i8+j)*3+2]/3 ;
+            c = rgbBits[(i8+j)*3]/3 +
-           //if average value is > mid grey
+                rgbBits[(i8+j)*3+1]/3 +
-           if (c>127)
+                rgbBits[(i8+j)*3+2]/3;
-              bits[i] = bits[i] | cMask ;
-           cMask = cMask / 2 ;
-           }
-        }
-    if (bHasMask)
-        {
-        r = image32.GetMaskRed() ;
-        g = image32.GetMaskGreen() ;
-        b = image32.GetMaskBlue() ;
 
-        for (i=0; i<imagebitcount; i++)
+            // if average value is > mid grey
+            if ( c > 127 )
+                bits[i] = bits[i] | cMask;
+            cMask = cMask / 2;
+        }
+    }
+
+    // now the AND one
+    if ( image32.HasMask() )
+    {
+        unsigned char r = image32.GetMaskRed(),
+                      g = image32.GetMaskGreen(),
+                      b = image32.GetMaskBlue();
+
+        for ( i = 0; i < imagebitcount; i++ )
         {
             maskBits[i] = 0x0;
             i8 = i * 8;
 
             cMask = 128;
-        for (j=0; j<8; j++)
+            for ( j = 0; j < 8; j++ )
             {
-           if (rgbBits[(i8+j)*3] == r && rgbBits[(i8+j)*3+1] == g && rgbBits[(i8+j)*3+2] == b)
+                if ( rgbBits[(i8+j)*3] == r &&
-              maskBits[i] = maskBits[i] | cMask ;
+                        rgbBits[(i8+j)*3+1] == g &&
-           cMask = cMask / 2 ;
+                            rgbBits[(i8+j)*3+2] == b )
-           }
-        }
-        }
-      else
                 {
-        for (i=0; i<imagebitcount; i++)
+                    maskBits[i] = maskBits[i] | cMask;
-            maskBits[i]= 0x0 ;
                 }
 
+                cMask = cMask / 2;
+            }
+        }
+    }
+    else // no mask in the image
+    {
+        memset(maskBits.get(), 0, sizeof(unsigned char)*imagebitcount);
+    }
+
+    // determine where should the cursors hot spot be
     int hotSpotX = image32.GetOptionInt(wxCUR_HOTSPOT_X);
     int hotSpotY = image32.GetOptionInt(wxCUR_HOTSPOT_Y);
     if (hotSpotX < 0 || hotSpotX >= w)
@@ -185,13 +266,24 @@ wxCursor::wxCursor( const wxImage & image )
     if (hotSpotY < 0 || hotSpotY >= h)
         hotSpotY = 0;
 
-    wxCursorRefData *refData = new wxCursorRefData;
+    // do create cursor now
-    m_refData = refData;
+    HCURSOR hcursor = ::CreateCursor
-    refData->m_hCursor = (WXHCURSOR) CreateCursor ( wxGetInstance(), hotSpotX, hotSpotY, w, h, /*AND*/ maskBits, /*XOR*/ bits   );
+                        (
-
+                            wxGetInstance(),
-    delete [] bits ;
+                            hotSpotX, hotSpotY,
-    delete [] maskBits;
+                            w, h,
+                            /* AND */ maskBits.get(),
+                            /* XOR */ bits.get()
+                        );
 
+    if ( !hcursor )
+    {
+        wxLogLastError(_T("CreateCursor"));
+    }
+    else
+    {
+        m_refData = new wxCursorRefData(hcursor, true /* delete it */);
+    }
 }
 
 wxCursor::wxCursor(const char WXUNUSED(bits)[],
@@ -202,210 +294,178 @@ wxCursor::wxCursor(const char WXUNUSED(bits)[],
 {
 }
 
-wxCursor::wxCursor(const wxString& cursor_file,
+// MicroWin doesn't have support needed for the other ctors
-                   long flags,
-                   int hotSpotX, int hotSpotY)
-{
 #ifdef __WXMICROWIN__
-    m_refData = NULL;
-#else
-    wxCursorRefData *refData = new wxCursorRefData;
-    m_refData = refData;
 
-    if (flags == wxBITMAP_TYPE_CUR_RESOURCE)
+wxCursor::wxCursor(const wxString& WXUNUSED(filename),
+                   long WXUNUSED(kind),
+                   int WXUNUSED(hotSpotX),
+                   int WXUNUSED(hotSpotY))
+{
+}
+
+wxCursor::wxCursor(int WXUNUSED(cursor_type))
+{
+}
+
+#else // !__WXMICROWIN__
+
+wxCursor::wxCursor(const wxString& filename,
+                   long kind,
+                   int hotSpotX,
+                   int hotSpotY)
+{
+    HCURSOR hcursor;
+    switch ( kind )
     {
-#ifdef __WIN95__
+        case wxBITMAP_TYPE_CUR_RESOURCE:
-        refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, 0);
+            hcursor = ::LoadCursor(wxGetInstance(), filename);
-#else
+            break;
-        refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
+
-#endif
+        case wxBITMAP_TYPE_CUR:
-    }
+            hcursor = ::LoadCursorFromFile(filename);
-    else if (flags == wxBITMAP_TYPE_CUR)
+            break;
-    {
+
-#ifdef __WIN95__
+        case wxBITMAP_TYPE_ICO:
-        refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
-#else
 #if wxUSE_RESOURCE_LOADING_IN_MSW
-        refData->m_hCursor = (WXHCURSOR) ReadCursorFile(WXSTRINGCAST cursor_file, wxGetInstance(), &refData->m_width, &refData->m_height);
+            hcursor = IconToCursor((wxChar *)filename.c_str(),
-#endif
+                                   wxGetInstance(),
-#endif
+                                   hotSpotX, hotSpotY,
-    }
+                                   NULL, NULL);
-    else if (flags == wxBITMAP_TYPE_ICO)
+#endif // wxUSE_RESOURCE_LOADING_IN_MSW
-    {
+            break;
-#if wxUSE_RESOURCE_LOADING_IN_MSW
+
-        refData->m_hCursor = (WXHCURSOR) IconToCursor(WXSTRINGCAST cursor_file, wxGetInstance(), hotSpotX, hotSpotY, &refData->m_width, &refData->m_height);
+        case wxBITMAP_TYPE_BMP:
-#endif
-    }
-    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 ( wxReadDIB((wxChar *)filename.c_str(), &hBitmap, &hPalette) )
-        if (!success)
+                {
-            return;
                     if (hPalette)
                         DeleteObject(hPalette);
-        POINT pnt;
+
-        pnt.x = hotSpotX;
+                    POINT pt;
-        pnt.y = hotSpotY;
+                    pt.x = hotSpotX;
-        refData->m_hCursor = (WXHCURSOR) MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pnt);
+                    pt.y = hotSpotY;
+                    hcursor = MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pt);
                     DeleteObject(hBitmap);
-#endif
+#endif // wxUSE_RESOURCE_LOADING_IN_MSW
                 }
+                else
+                {
+                    hcursor = NULL;
+                }
+            }
+            break;
+
+        default:
+            wxFAIL_MSG( _T("unknown cursor resource type") );
+
+            hcursor = NULL;
+    }
+
+    if ( hcursor )
+    {
+        m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
 
 #if WXWIN_COMPATIBILITY_2
         refData->SetOk();
 #endif // WXWIN_COMPATIBILITY_2
-
+    }
-#endif
 }
 
 // Cursors by stock number
-wxCursor::wxCursor(int cursor_type)
+wxCursor::wxCursor(int idCursor)
 {
-#ifdef __WXMICROWIN__
+    // all wxWindows standard cursors
-    m_refData = NULL;
+    static const struct StdCursor
-#else
+    {
-  wxCursorRefData *refData = new wxCursorRefData;
+        // is this a standard Windows cursor?
-  m_refData = refData;
+        bool isStd;
 
-  switch (cursor_type)
+        // the cursor name or id
+        LPCTSTR name;
+    } stdCursors[] =
     {
-    case wxCURSOR_ARROWWAIT:
+        {  true, NULL                        }, // wxCURSOR_NONE
-#ifndef __WIN16__
+        {  true, IDC_ARROW                   }, // wxCURSOR_ARROW
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_APPSTARTING);
+        { false, _T("wxCURSOR_RIGHT_ARROW")  }, // wxCURSOR_RIGHT_ARROW
-      break;
+        { false, _T("wxCURSOR_BULLSEYE")     }, // wxCURSOR_BULLSEYE
-#endif
+        {  true, IDC_ARROW                   }, // wxCURSOR_CHAR
-    case wxCURSOR_WAIT:
+        {  true, IDC_CROSS                   }, // wxCURSOR_CROSS
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_WAIT);
+        { false, _T("wxCURSOR_HAND")         }, // wxCURSOR_HAND
-      break;
+        {  true, IDC_IBEAM                   }, // wxCURSOR_IBEAM
-    case wxCURSOR_IBEAM:
+        {  true, IDC_ARROW                   }, // wxCURSOR_LEFT_BUTTON
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_IBEAM);
+        { false, _T("wxCURSOR_MAGNIFIER")    }, // wxCURSOR_MAGNIFIER
-      break;
+        {  true, IDC_ARROW                   }, // wxCURSOR_MIDDLE_BUTTON
-    case wxCURSOR_CROSS:
+        {  true, IDC_NO                      }, // wxCURSOR_NO_ENTRY
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_CROSS);
+        { false, _T("wxCURSOR_PAINT_BRUSH")  }, // wxCURSOR_PAINT_BRUSH
-      break;
+        { false, _T("wxCURSOR_PENCIL")       }, // wxCURSOR_PENCIL
-    case wxCURSOR_SIZENWSE:
+        { false, _T("wxCURSOR_POINT_LEFT")   }, // wxCURSOR_POINT_LEFT
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENWSE);
+        { false, _T("wxCURSOR_POINT_RIGHT")  }, // wxCURSOR_POINT_RIGHT
-      break;
+        {  true, IDC_HELP                    }, // wxCURSOR_QUESTION_ARROW
-    case wxCURSOR_SIZENESW:
+        {  true, IDC_ARROW                   }, // wxCURSOR_RIGHT_BUTTON
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENESW);
+        {  true, IDC_SIZENESW                }, // wxCURSOR_SIZENESW
-      break;
+        {  true, IDC_SIZENS                  }, // wxCURSOR_SIZENS
-    case wxCURSOR_SIZEWE:
+        {  true, IDC_SIZENWSE                }, // wxCURSOR_SIZENWSE
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZEWE);
+        {  true, IDC_SIZEWE                  }, // wxCURSOR_SIZEWE
-      break;
+        {  true, IDC_SIZEALL                 }, // wxCURSOR_SIZING
-    case wxCURSOR_SIZENS:
+        { false, _T("wxCURSOR_SPRAYCAN")     }, // wxCURSOR_SPRAYCAN
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENS);
+        {  true, IDC_WAIT                    }, // wxCURSOR_WAIT
-      break;
+        {  true, IDC_WAIT                    }, // wxCURSOR_WATCH
-    case wxCURSOR_CHAR:
+        { false, _T("wxCURSOR_BLANK")        }, // wxCURSOR_BLANK
-    {
+        {  true, IDC_APPSTARTING             }, // wxCURSOR_ARROWWAIT
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
-      break;
-    }
-    case wxCURSOR_HAND:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_HAND"));
-      break;
-    }
-    case wxCURSOR_BULLSEYE:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BULLSEYE"));
-      break;
-    }
-    case wxCURSOR_PENCIL:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PENCIL"));
-      break;
-    }
-    case wxCURSOR_MAGNIFIER:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_MAGNIFIER"));
-      break;
-    }
-    case wxCURSOR_NO_ENTRY:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_NO_ENTRY"));
-      break;
-    }
-    case wxCURSOR_LEFT_BUTTON:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
-      break;
-    }
-    case wxCURSOR_RIGHT_BUTTON:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
-      break;
-    }
-    case wxCURSOR_MIDDLE_BUTTON:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
-      break;
-    }
-    case wxCURSOR_SIZING:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_SIZING"));
-      break;
-    }
-    case wxCURSOR_WATCH:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_WATCH"));
-      break;
-    }
-    case wxCURSOR_SPRAYCAN:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_ROLLER"));
-      break;
-    }
-    case wxCURSOR_PAINT_BRUSH:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PBRUSH"));
-      break;
-    }
-    case wxCURSOR_POINT_LEFT:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PLEFT"));
-      break;
-    }
-    case wxCURSOR_POINT_RIGHT:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));
-      break;
-    }
-    case wxCURSOR_QUESTION_ARROW:
-    {
-//      refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), wxT("wxCURSOR_QARROW"), IMAGE_CURSOR, 16, 16, LR_MONOCHROME);
-//      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_HELP);
-      break;
-    }
-    case wxCURSOR_BLANK:
-    {
-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));
-      break;
-    }
-    case wxCURSOR_RIGHT_ARROW:
-    {
-        refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_RIGHT_ARROW"));
-        break;
-    }
-    default:
-    case wxCURSOR_ARROW:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
-      break;
-  }
 
-  // no need to destroy the stock cursors
+        // no entry for wxCURSOR_MAX
-  // TODO: check this
+    };
-  //m_refData->m_destroyCursor = FALSE;
+
-#endif
+    wxCOMPILE_TIME_ASSERT( WXSIZEOF(stdCursors) == wxCURSOR_MAX,
+                           CursorsIdArrayMismatch );
+
+    wxCHECK_RET( idCursor > 0 && (size_t)idCursor < WXSIZEOF(stdCursors),
+                 _T("invalid cursor id in wxCursor() ctor") );
+
+    const StdCursor& stdCursor = stdCursors[idCursor];
+
+    HCURSOR hcursor = ::LoadCursor(stdCursor.isStd ? NULL : wxGetInstance(),
+                                   stdCursor.name);
+
+    if ( !hcursor )
+    {
+        wxLogLastError(_T("LoadCursor"));
+    }
+    else
+    {
+        m_refData = new wxCursorRefData(hcursor);
+    }
 }
 
+#endif // __WXMICROWIN__/!__WXMICROWIN__
+
 wxCursor::~wxCursor()
 {
 }
 
+// ----------------------------------------------------------------------------
+// other wxCursor functions
+// ----------------------------------------------------------------------------
+
+bool wxCursor::operator==(const wxCursor& cursor) const
+{
+    if ( !m_refData )
+        return !cursor.m_refData;
+
+    return cursor.m_refData &&
+                ((wxCursorRefData *)m_refData)->m_hCursor ==
+                ((wxCursorRefData *)cursor.m_refData)->m_hCursor;
+}
+
+wxGDIImageRefData *wxCursor::CreateData() const
+{
+    return new wxCursorRefData;
+}
+
 // ----------------------------------------------------------------------------
 // Global cursor setting
 // ----------------------------------------------------------------------------
@@ -419,9 +479,7 @@ void wxSetCursor(const wxCursor& cursor)
 {
     if ( cursor.Ok() )
     {
-#ifndef __WXMICROWIN__
         ::SetCursor(GetHcursorOf(cursor));
-#endif
 
         if ( gs_globalCursor )
             *gs_globalCursor = cursor;