TRUE, not true; FALSE, not false....

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

diff --git a/src/msw/cursor.cpp b/src/msw/cursor.cpp
index 3ae986e71920c46b861e365ffd3a9b29d60e7bda..d84d6c2aa488a6c5e6d97dfee1c4ff192a1a6241 100644 (file)
--- a/src/msw/cursor.cpp
+++ b/src/msw/cursor.cpp
@@ -9,273 +9,342 @@
 // Licence:       wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // 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/icon.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"

 #endif
 
 #endif
 

+#include "wx/module.h"

 #include "wx/msw/private.h"
 #include "wx/msw/private.h"

+#ifndef __WXMICROWIN__

 #include "wx/msw/dib.h"
 #include "wx/msw/dib.h"

-
-#include "assert.h"
+#endif

 
 #if wxUSE_RESOURCE_LOADING_IN_MSW
 
 #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
 
 #endif
 

-#if !USE_SHARED_LIBRARIES
-IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
-#endif
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxCursorBase)
+
+// ----------------------------------------------------------------------------
+// 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;
+    }
+};
+
+// ============================================================================
+// implementation
+// ============================================================================

 
 

-wxCursorRefData::wxCursorRefData(void)
+// ----------------------------------------------------------------------------
+// wxCursorRefData
+// ----------------------------------------------------------------------------
+
+wxCursorRefData::wxCursorRefData()

 {
 {

-  m_width = 32; m_height = 32;
-  m_hCursor = 0 ;
-  m_destroyCursor = FALSE;
+  m_width = 32;
+  m_height = 32;
+
+  m_destroyCursor = TRUE;

 }
 
 }
 

-wxCursorRefData::~wxCursorRefData(void)
+void wxCursorRefData::Free()

 {
 {

-    if ( m_hCursor && m_destroyCursor)
-#ifdef __WXWINE__
-        ::DestroyCursor((HCURSOR) m_hCursor);
-#else
-        ::DestroyCursor((HICON) m_hCursor);
+    if ( m_hCursor )
+    {
+#ifndef __WXMICROWIN__
+        if ( m_destroyCursor )
+            ::DestroyCursor((HCURSOR)m_hCursor);

 #endif
 #endif

+
+        m_hCursor = 0;
+    }

 }
 
 }
 

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

 // Cursors
 // 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;
+#ifdef __WXMICROWIN__
+    m_refData = NULL;
+#else
+    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)
-  {
-    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 (flags == wxBITMAP_TYPE_CUR_RESOURCE)
+    {
+#ifdef __WIN95__
+        refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, 0);
+#else
+        refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
+#endif
+    }
+    else if (flags == wxBITMAP_TYPE_CUR)
+    {
+#ifdef __WIN95__
+        refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
+#else

 #if wxUSE_RESOURCE_LOADING_IN_MSW
 #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);

 #endif
 #endif

-  }
-  else if (flags & wxBITMAP_TYPE_ICO)
-  {
+#endif
+    }
+    else if (flags == wxBITMAP_TYPE_ICO)
+    {

 #if wxUSE_RESOURCE_LOADING_IN_MSW
 #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);

 #endif
 #endif

-  }
-  else if (flags & wxBITMAP_TYPE_BMP)
-  {
+    }
+    else if (flags == wxBITMAP_TYPE_BMP)
+    {

 #if wxUSE_RESOURCE_LOADING_IN_MSW
 #if wxUSE_RESOURCE_LOADING_IN_MSW

-    HBITMAP hBitmap = 0;
-    HPALETTE hPalette = 0;
-    bool success = ReadDIB(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);
+        DeleteObject(hBitmap);
+#endif
+    }
+
+#if WXWIN_COMPATIBILITY_2
+    refData->SetOk();
+#endif // WXWIN_COMPATIBILITY_2
+

 #endif
 #endif

-  }

 }
 
 // Cursors by stock number
 wxCursor::wxCursor(int cursor_type)
 {
 }
 
 // Cursors by stock number
 wxCursor::wxCursor(int cursor_type)
 {

-  m_refData = new wxCursorRefData;
+#ifdef __WXMICROWIN__
+    m_refData = NULL;
+#else
+  wxCursorRefData *refData = new wxCursorRefData;
+  m_refData = refData;

 
   switch (cursor_type)
   {
 
   switch (cursor_type)
   {

+    case wxCURSOR_ARROWWAIT:
+#ifndef __WIN16__
+      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_APPSTARTING);
+      break;
+#endif

     case wxCURSOR_WAIT:
     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:
       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:
       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:
       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:
       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:
       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:
       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:
     {
       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:
     {
       break;
     }
     case wxCURSOR_HAND:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_HAND"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_HAND"));

       break;
     }
     case wxCURSOR_BULLSEYE:
     {
       break;
     }
     case wxCURSOR_BULLSEYE:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_BULLSEYE"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BULLSEYE"));

       break;
     }
     case wxCURSOR_PENCIL:
     {
       break;
     }
     case wxCURSOR_PENCIL:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_PENCIL"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PENCIL"));

       break;
     }
     case wxCURSOR_MAGNIFIER:
     {
       break;
     }
     case wxCURSOR_MAGNIFIER:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_MAGNIFIER"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_MAGNIFIER"));

       break;
     }
     case wxCURSOR_NO_ENTRY:
     {
       break;
     }
     case wxCURSOR_NO_ENTRY:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_NO_ENTRY"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_NO_ENTRY"));

       break;
     }
     case wxCURSOR_LEFT_BUTTON:
     {
       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:
     {
       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:
     {
       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:
     {
       break;
     }
     case wxCURSOR_SIZING:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_SIZING"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_SIZING"));

       break;
     }
     case wxCURSOR_WATCH:
     {
       break;
     }
     case wxCURSOR_WATCH:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_WATCH"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_WATCH"));

       break;
     }
     case wxCURSOR_SPRAYCAN:
     {
       break;
     }
     case wxCURSOR_SPRAYCAN:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_ROLLER"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_ROLLER"));

       break;
     }
     case wxCURSOR_PAINT_BRUSH:
     {
       break;
     }
     case wxCURSOR_PAINT_BRUSH:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_PBRUSH"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PBRUSH"));

       break;
     }
     case wxCURSOR_POINT_LEFT:
     {
       break;
     }
     case wxCURSOR_POINT_LEFT:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_PLEFT"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PLEFT"));

       break;
     }
     case wxCURSOR_POINT_RIGHT:
     {
       break;
     }
     case wxCURSOR_POINT_RIGHT:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_PRIGHT"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));

       break;
     }
     case wxCURSOR_QUESTION_ARROW:
     {
       break;
     }
     case wxCURSOR_QUESTION_ARROW:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_QARROW"));
+//      refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), wxT("wxCURSOR_QARROW"), IMAGE_CURSOR, 16, 16, LR_MONOCHROME);
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));

       break;
     }
     case wxCURSOR_BLANK:
     {
       break;
     }
     case wxCURSOR_BLANK:
     {

-      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), _T("wxCURSOR_BLANK"));
+      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));

       break;
     }
     default:
     case wxCURSOR_ARROW:
       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;
   }
       break;
   }

-}

 
 

-wxCursor::~wxCursor(void)
-{
-//    FreeResource(TRUE);
+  // no need to destroy the stock cursors
+  // TODO: check this
+  //m_refData->m_destroyCursor = FALSE;
+#endif

 }
 
 }
 

-bool wxCursor::FreeResource(bool WXUNUSED(force))
+wxCursor::~wxCursor()

 {
 {

-  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;
+// ----------------------------------------------------------------------------
+// Global cursor setting
+// ----------------------------------------------------------------------------

 
 

-  M_CURSORDATA->m_hCursor = cursor;
+const wxCursor *wxGetGlobalCursor()
+{
+    return gs_globalCursor;

 }
 
 }
 

-// Global cursor setting

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

-    extern wxCursor *g_globalCursor;
-
-    if ( cursor.Ok() && cursor.GetHCURSOR() )
+    if ( cursor.Ok() )

     {
     {

-        ::SetCursor((HCURSOR) cursor.GetHCURSOR());
+#ifndef __WXMICROWIN__
+        ::SetCursor(GetHcursorOf(cursor));
+#endif

 
 

-        if ( g_globalCursor )
-            (*g_globalCursor) = cursor;
+        if ( gs_globalCursor )
+            *gs_globalCursor = cursor;

     }
 }
 
     }
 }