new wxDIB class

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

diff --git a/src/msw/cursor.cpp b/src/msw/cursor.cpp
index 8eb388fae434a4be42e7680e8ec5543874602e9e..268a0931cb617fb9c8f1dfa191266f91b5632d60 100644 (file)
--- a/src/msw/cursor.cpp
+++ b/src/msw/cursor.cpp
@@ -1,279 +1,488 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        cursor.cpp
+// Name:        src/msw/cursor.cpp

 // Purpose:     wxCursor class
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Purpose:     wxCursor class
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:    wxWindows licence
+// Copyright:   (c) 1997-2003 Julian Smart and Vadim Zeitlin
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+

 #ifdef __GNUG__
 #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__
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #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/list.h"
+    #include "wx/utils.h"
+    #include "wx/app.h"
+    #include "wx/bitmap.h"
+    #include "wx/icon.h"
+    #include "wx/cursor.h"
+    #include "wx/settings.h"

 #endif
 
 #endif
 

-#include "wx/msw/private.h"
-#include "wx/msw/dib.h"
+#include "wx/ptr_scpd.h"

 
 

-#include "assert.h"
+#include "wx/module.h"
+#include "wx/image.h"
+#include "wx/msw/private.h"

 
 

-#if USE_XPM_IN_MSW
-#define FOR_MSW 1
-#include "..\..\contrib\wxxpm\libxpm.34b\lib\xpm34.h"
+#ifndef __WXMICROWIN__
+    #include "wx/msw/dib.h"

 #endif
 
 #endif
 

-#if USE_RESOURCE_LOADING_IN_MSW
-#include "wx/msw/curico.h"
-#include "wx/msw/curicop.h"
+#if wxUSE_RESOURCE_LOADING_IN_MSW
+    #include "wx/msw/curico.h"
+    #include "wx/msw/curicop.h"

 #endif
 
 #endif
 

-#if !USE_SHARED_LIBRARIES
-IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
-#endif
+// define functions missing in MicroWin
+#ifdef __WXMICROWIN__
+    static inline void DestroyCursor(HCURSOR) { }
+    static inline void SetCursor(HCURSOR) { }
+#endif // __WXMICROWIN__

 
 

-wxCursorRefData::wxCursorRefData(void)
-{
-  m_width = 32; m_height = 32;
-  m_hCursor = 0 ;
-  m_destroyCursor = FALSE;
-}
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------

 
 

-wxCursorRefData::~wxCursorRefData(void)
+class WXDLLEXPORT wxCursorRefData : public wxGDIImageRefData

 {
 {

-       if ( m_hCursor && m_destroyCursor)
-               ::DestroyCursor((HICON) m_hCursor);
-}
+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);

 
 

-// Cursors
-wxCursor::wxCursor(void)
+    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
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxGDIObject)
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+// Current cursor, in order to hang on to cursor handle when setting the cursor
+// globally
+static wxCursor *gs_globalCursor = NULL;
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class wxCursorModule : public wxModule

 {
 {

-}
+public:
+    virtual bool OnInit()
+    {
+        gs_globalCursor = new wxCursor;
+
+        return TRUE;
+    }
+
+    virtual void OnExit()
+    {
+        delete gs_globalCursor;
+        gs_globalCursor = (wxCursor *)NULL;
+    }
+};
+
+// ----------------------------------------------------------------------------
+// other types
+// ----------------------------------------------------------------------------
+
+wxDECLARE_SCOPED_ARRAY(unsigned char, ByteArray);
+wxDEFINE_SCOPED_ARRAY(unsigned char, ByteArray);
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxCursorRefData
+// ----------------------------------------------------------------------------

 
 

-wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
-    int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
+wxSize wxCursorRefData::ms_sizeStd;
+
+wxCoord wxCursorRefData::GetStandardWidth()

 {
 {

+    if ( !ms_sizeStd.x )
+        ms_sizeStd.x = wxSystemSettings::GetMetric(wxSYS_CURSOR_X);
+
+    return ms_sizeStd.x;

 }
 
 }
 

-wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
+wxCoord wxCursorRefData::GetStandardHeight()

 {
 {

-  m_refData = new wxIconRefData;
-
-  M_CURSORDATA->m_destroyCursor = FALSE;
-  M_CURSORDATA->m_hCursor = 0;
-  M_CURSORDATA->m_ok = FALSE;
-  if (flags & wxBITMAP_TYPE_CUR_RESOURCE)
-  {
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
-    if (M_CURSORDATA->m_hCursor)
-      M_CURSORDATA->m_ok = TRUE;
-    else
-      M_CURSORDATA->m_ok = FALSE;
-  }
-  else if (flags & wxBITMAP_TYPE_CUR)
-  {
-#if USE_RESOURCE_LOADING_IN_MSW
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) ReadCursorFile((char *)(const char *)cursor_file, wxGetInstance(), &M_CURSORDATA->m_width, &M_CURSORDATA->m_height);
-       M_CURSORDATA->m_destroyCursor = TRUE;
-#endif
-  }
-  else if (flags & wxBITMAP_TYPE_ICO)
-  {
-#if USE_RESOURCE_LOADING_IN_MSW
-    M_CURSORDATA->m_hCursor = (WXHCURSOR) IconToCursor((char *)(const char *)cursor_file, wxGetInstance(), hotSpotX, hotSpotY, &M_CURSORDATA->m_width, &M_CURSORDATA->m_height);
-       M_CURSORDATA->m_destroyCursor = TRUE;
-#endif
-  }
-  else if (flags & wxBITMAP_TYPE_BMP)
-  {
-#if USE_RESOURCE_LOADING_IN_MSW
-    HBITMAP hBitmap = 0;
-    HPALETTE hPalette = 0;
-    bool success = ReadDIB((char *)(const char *)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;
-#endif
-  }
+    if ( !ms_sizeStd.y )
+        ms_sizeStd.y = wxSystemSettings::GetMetric(wxSYS_CURSOR_Y);
+
+    return ms_sizeStd.y;

 }
 
 }
 

-// Cursors by stock number
-wxCursor::wxCursor(int cursor_type)
+wxCursorRefData::wxCursorRefData(HCURSOR hcursor, bool destroy)

 {
 {

-  m_refData = new wxIconRefData;
-
-  switch (cursor_type)
-  {
-    case wxCURSOR_WAIT:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_WAIT);
-      break;
-    case wxCURSOR_IBEAM:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_IBEAM);
-      break;
-    case wxCURSOR_CROSS:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_CROSS);
-      break;
-    case wxCURSOR_SIZENWSE:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENWSE);
-      break;
-    case wxCURSOR_SIZENESW:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENESW);
-      break;
-    case wxCURSOR_SIZEWE:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZEWE);
-      break;
-    case wxCURSOR_SIZENS:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENS);
-      break;
-    case wxCURSOR_CHAR:
-    {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
-      break;
-    }
-    case wxCURSOR_HAND:
-    {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_HAND");
-      break;
-    }
-    case wxCURSOR_BULLSEYE:
-    {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BULLSEYE");
-      break;
-    }
-    case wxCURSOR_PENCIL:
-    {
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PENCIL");
-      break;
-    }
-    case wxCURSOR_MAGNIFIER:
+    m_hCursor = (WXHCURSOR)hcursor;
+
+    if ( m_hCursor )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_MAGNIFIER");
-      break;
+        m_width = GetStandardWidth();
+        m_height = GetStandardHeight();

     }
     }

-    case wxCURSOR_NO_ENTRY:
+
+    m_destroyCursor = destroy;
+}
+
+void wxCursorRefData::Free()
+{
+    if ( m_hCursor )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_NO_ENTRY");
-      break;
+        if ( m_destroyCursor )
+            ::DestroyCursor((HCURSOR)m_hCursor);
+
+        m_hCursor = 0;

     }
     }

-    case wxCURSOR_LEFT_BUTTON:
+}
+
+// ----------------------------------------------------------------------------
+// Cursors
+// ----------------------------------------------------------------------------
+
+wxCursor::wxCursor()
+{
+}
+
+wxCursor::wxCursor(const wxImage& image)
+{
+    // image has to be of the standard cursor size, otherwise we won't be able
+    // to create it
+    const int w = wxCursorRefData::GetStandardWidth();
+    const int h = wxCursorRefData::GetStandardHeight();
+
+    wxImage image32 = image.Scale(w, h);
+
+    const int imagebitcount = (w*h)/8;
+
+    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++ )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
-      break;
+        bits[i] = 0;
+        i8 = i * 8;
+        // unlike gtk, the pixels go in the opposite order in the bytes
+        cMask = 128;
+        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;
+
+            // if average value is > mid grey
+            if ( c > 127 )
+                bits[i] = bits[i] | cMask;
+            cMask = cMask / 2;
+        }

     }
     }

-    case wxCURSOR_RIGHT_BUTTON:
+
+    // now the AND one
+    if ( image32.HasMask() )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
-      break;
+        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++ )
+            {
+                if ( rgbBits[(i8+j)*3] == r &&
+                        rgbBits[(i8+j)*3+1] == g &&
+                            rgbBits[(i8+j)*3+2] == b )
+                {
+                    maskBits[i] = maskBits[i] | cMask;
+                }
+
+                cMask = cMask / 2;
+            }
+        }

     }
     }

-    case wxCURSOR_MIDDLE_BUTTON:
+    else // no mask in the image

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
-      break;
+        memset(maskBits.get(), 0, sizeof(unsigned char)*imagebitcount);

     }
     }

-    case wxCURSOR_SIZING:
+
+    // 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)
+        hotSpotX = 0;
+    if (hotSpotY < 0 || hotSpotY >= h)
+        hotSpotY = 0;
+
+    // do create cursor now
+    HCURSOR hcursor = ::CreateCursor
+                        (
+                            wxGetInstance(),
+                            hotSpotX, hotSpotY,
+                            w, h,
+                            /* AND */ maskBits.get(),
+                            /* XOR */ bits.get()
+                        );
+
+    if ( !hcursor )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_SIZING");
-      break;
+        wxLogLastError(_T("CreateCursor"));

     }
     }

-    case wxCURSOR_WATCH:
+    else

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_WATCH");
-      break;
+        m_refData = new wxCursorRefData(hcursor, true /* delete it */);

     }
     }

-    case wxCURSOR_SPRAYCAN:
+}
+
+wxCursor::wxCursor(const char WXUNUSED(bits)[],
+                   int WXUNUSED(width),
+                   int WXUNUSED(height),
+                   int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY),
+                   const char WXUNUSED(maskBits)[])
+{
+}
+
+// MicroWin doesn't have support needed for the other ctors
+#ifdef __WXMICROWIN__
+
+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 )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_ROLLER");
-      break;
+        case wxBITMAP_TYPE_CUR_RESOURCE:
+            hcursor = ::LoadCursor(wxGetInstance(), filename);
+            break;
+
+        case wxBITMAP_TYPE_CUR:
+            hcursor = ::LoadCursorFromFile(filename);
+            break;
+
+#if wxUSE_RESOURCE_LOADING_IN_MSW
+        case wxBITMAP_TYPE_ICO:
+            hcursor = IconToCursor((wxChar *)filename.c_str(),
+                                   wxGetInstance(),
+                                   hotSpotX, hotSpotY,
+                                   NULL, NULL);
+            break;
+
+        case wxBITMAP_TYPE_BMP:
+            {
+                HBITMAP hBitmap = 0;
+                HPALETTE hPalette = 0;
+                if ( wxReadDIB((wxChar *)filename.c_str(), &hBitmap, &hPalette) )
+                {
+                    if (hPalette)
+                        DeleteObject(hPalette);
+
+                    POINT pt;
+                    pt.x = hotSpotX;
+                    pt.y = hotSpotY;
+                    hcursor = MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pt);
+                    DeleteObject(hBitmap);
+                }
+                else
+                {
+                    hcursor = NULL;
+                }
+            }
+            break;
+#endif // wxUSE_RESOURCE_LOADING_IN_MSW
+
+        default:
+            wxFAIL_MSG( _T("unknown cursor resource type") );
+
+            hcursor = NULL;

     }
     }

-    case wxCURSOR_PAINT_BRUSH:
+
+    if ( hcursor )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PBRUSH");
-      break;
+        m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
+
+#if WXWIN_COMPATIBILITY_2
+        ((wxCursorRefData *)m_refData)->SetOk();
+#endif // WXWIN_COMPATIBILITY_2

     }
     }

-    case wxCURSOR_POINT_LEFT:
+}
+
+// Cursors by stock number
+wxCursor::wxCursor(int idCursor)
+{
+    // all wxWindows standard cursors
+    static const struct StdCursor

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PLEFT");
-      break;
-    }
-    case wxCURSOR_POINT_RIGHT:
+        // is this a standard Windows cursor?
+        bool isStd;
+
+        // the cursor name or id
+        LPCTSTR name;
+    } stdCursors[] =

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PRIGHT");
-      break;
-    }
-    case wxCURSOR_QUESTION_ARROW:
+        {  true, NULL                        }, // wxCURSOR_NONE
+        {  true, IDC_ARROW                   }, // wxCURSOR_ARROW
+        { false, _T("wxCURSOR_RIGHT_ARROW")  }, // wxCURSOR_RIGHT_ARROW
+        { false, _T("wxCURSOR_BULLSEYE")     }, // wxCURSOR_BULLSEYE
+        {  true, IDC_ARROW                   }, // wxCURSOR_CHAR
+        {  true, IDC_CROSS                   }, // wxCURSOR_CROSS
+        { false, _T("wxCURSOR_HAND")         }, // wxCURSOR_HAND
+        {  true, IDC_IBEAM                   }, // wxCURSOR_IBEAM
+        {  true, IDC_ARROW                   }, // wxCURSOR_LEFT_BUTTON
+        { false, _T("wxCURSOR_MAGNIFIER")    }, // wxCURSOR_MAGNIFIER
+        {  true, IDC_ARROW                   }, // wxCURSOR_MIDDLE_BUTTON
+        {  true, IDC_NO                      }, // wxCURSOR_NO_ENTRY
+        { false, _T("wxCURSOR_PAINT_BRUSH")  }, // wxCURSOR_PAINT_BRUSH
+        { false, _T("wxCURSOR_PENCIL")       }, // wxCURSOR_PENCIL
+        { false, _T("wxCURSOR_POINT_LEFT")   }, // wxCURSOR_POINT_LEFT
+        { false, _T("wxCURSOR_POINT_RIGHT")  }, // wxCURSOR_POINT_RIGHT
+        {  true, IDC_HELP                    }, // wxCURSOR_QUESTION_ARROW
+        {  true, IDC_ARROW                   }, // wxCURSOR_RIGHT_BUTTON
+        {  true, IDC_SIZENESW                }, // wxCURSOR_SIZENESW
+        {  true, IDC_SIZENS                  }, // wxCURSOR_SIZENS
+        {  true, IDC_SIZENWSE                }, // wxCURSOR_SIZENWSE
+        {  true, IDC_SIZEWE                  }, // wxCURSOR_SIZEWE
+        {  true, IDC_SIZEALL                 }, // wxCURSOR_SIZING
+        { false, _T("wxCURSOR_SPRAYCAN")     }, // wxCURSOR_SPRAYCAN
+        {  true, IDC_WAIT                    }, // wxCURSOR_WAIT
+        {  true, IDC_WAIT                    }, // wxCURSOR_WATCH
+        { false, _T("wxCURSOR_BLANK")        }, // wxCURSOR_BLANK
+        {  true, IDC_APPSTARTING             }, // wxCURSOR_ARROWWAIT
+
+        // no entry for wxCURSOR_MAX
+    };
+
+    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 )

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_QARROW");
-      break;
+        wxLogLastError(_T("LoadCursor"));

     }
     }

-    case wxCURSOR_BLANK:
+    else

     {
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BLANK");
-      break;
+        m_refData = new wxCursorRefData(hcursor);

     }
     }

-    default:
-    case wxCURSOR_ARROW:
-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
-      break;
-  }

 }
 
 }
 

-wxCursor::~wxCursor(void)
+#endif // __WXMICROWIN__/!__WXMICROWIN__
+
+wxCursor::~wxCursor()

 {
 {

-//     FreeResource(TRUE);

 }
 
 }
 

-bool wxCursor::FreeResource(bool force)
+// ----------------------------------------------------------------------------
+// other wxCursor functions
+// ----------------------------------------------------------------------------
+
+bool wxCursor::operator==(const wxCursor& cursor) const

 {
 {

-  if (M_CURSORDATA && M_CURSORDATA->m_hCursor && M_CURSORDATA->m_destroyCursor)
-  {
-    DestroyCursor((HCURSOR) M_CURSORDATA->m_hCursor);
-       M_CURSORDATA->m_hCursor = 0;
-  }
-  return TRUE;
+    if ( !m_refData )
+        return !cursor.m_refData;
+
+    return cursor.m_refData &&
+                ((wxCursorRefData *)m_refData)->m_hCursor ==
+                ((wxCursorRefData *)cursor.m_refData)->m_hCursor;

 }
 
 }
 

-void wxCursor::SetHCURSOR(WXHCURSOR cursor)
+wxGDIImageRefData *wxCursor::CreateData() const

 {
 {

-  if ( !M_CURSORDATA )
-       m_refData = new wxCursorRefData;
-
-  M_CURSORDATA->m_hCursor = cursor;
+    return new wxCursorRefData;

 }
 
 }
 

+// ----------------------------------------------------------------------------

 // Global cursor setting
 // Global cursor setting

+// ----------------------------------------------------------------------------
+
+const wxCursor *wxGetGlobalCursor()
+{
+    return gs_globalCursor;
+}
+

 void wxSetCursor(const wxCursor& cursor)
 {
 void wxSetCursor(const wxCursor& cursor)
 {

-  extern wxCursor *g_globalCursor;
-  if ( g_globalCursor )
-    (*g_globalCursor) = cursor;
+    if ( cursor.Ok() )
+    {
+        ::SetCursor(GetHcursorOf(cursor));

 
 

-  if (cursor.Ok() && cursor.GetHCURSOR())
-    ::SetCursor((HCURSOR) cursor.GetHCURSOR());
+        if ( gs_globalCursor )
+            *gs_globalCursor = cursor;
+    }

 }
 
 
 }