ODBC library is built when wxUSE_GUI=0, too

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

diff --git a/src/msw/cursor.cpp b/src/msw/cursor.cpp
index 09ab2ba32e6e7a8356dbe72eb43d6785d2d2bf75..2478d85df13cd62c3c49145be8c86a343d6f2f7b 100644 (file)
--- a/src/msw/cursor.cpp
+++ b/src/msw/cursor.cpp
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// 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

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "cursor.h"
 #endif
 
     #pragma implementation "cursor.h"
 #endif
 


@@ -29,24 +29,53 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-    #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/utils.h"
     #include "wx/app.h"
     #include "wx/bitmap.h"
     #include "wx/icon.h"
     #include "wx/cursor.h"

+    #include "wx/settings.h"
+    #include "wx/intl.h"

 #endif
 
 #include "wx/module.h"
 #endif
 
 #include "wx/module.h"

+#include "wx/image.h"

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

-#ifndef __WXMICROWIN__
-#include "wx/msw/dib.h"
-#endif

 
 

-#if wxUSE_RESOURCE_LOADING_IN_MSW
-    #include "wx/msw/curico.h"
-    #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
 
 // ----------------------------------------------------------------------------
 // wxWin macros


@@ -91,19 +120,42 @@ public:
 // wxCursorRefData
 // ----------------------------------------------------------------------------
 
 // wxCursorRefData
 // ----------------------------------------------------------------------------
 

-wxCursorRefData::wxCursorRefData()
+wxSize wxCursorRefData::ms_sizeStd;
+
+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_width = 32;
-  m_height = 32;
+    m_hCursor = (WXHCURSOR)hcursor;

 
 

-  m_destroyCursor = TRUE;
+    if ( m_hCursor )
+    {
+        m_width = GetStandardWidth();
+        m_height = GetStandardHeight();
+    }
+
+    m_destroyCursor = destroy;

 }
 
 void wxCursorRefData::Free()
 {
     if ( m_hCursor )
     {
 }
 
 void wxCursorRefData::Free()
 {
     if ( m_hCursor )
     {

-#ifndef __WXMICROWIN__
+#ifndef __WXWINCE__

         if ( m_destroyCursor )
             ::DestroyCursor((HCURSOR)m_hCursor);
 #endif
         if ( m_destroyCursor )
             ::DestroyCursor((HCURSOR)m_hCursor);
 #endif


@@ -120,6 +172,35 @@ 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();
+
+    const int hotSpotX = image.GetOptionInt(wxCUR_HOTSPOT_X);
+    const int hotSpotY = image.GetOptionInt(wxCUR_HOTSPOT_Y);
+
+    wxASSERT_MSG( hotSpotX >= 0 && hotSpotX < w &&
+                    hotSpotY >= 0 && hotSpotY < h,
+                  _T("invalid cursor hot spot coordinates") );
+
+    HCURSOR hcursor = wxBitmapToHCURSOR
+                      (
+                        wxBitmap(image.Scale(w, h)),
+                        hotSpotX,
+                        hotSpotY
+                      );
+    if ( !hcursor )
+    {
+        wxLogWarning(_("Failed to create cursor."));
+        return;
+    }
+
+    m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
+}
+

 wxCursor::wxCursor(const char WXUNUSED(bits)[],
                    int WXUNUSED(width),
                    int WXUNUSED(height),
 wxCursor::wxCursor(const char WXUNUSED(bits)[],
                    int WXUNUSED(width),
                    int WXUNUSED(height),


@@ -128,204 +209,165 @@ wxCursor::wxCursor(const char WXUNUSED(bits)[],
 {
 }
 
 {
 }
 

-wxCursor::wxCursor(const wxString& cursor_file,
-                   long flags,
-                   int hotSpotX, int hotSpotY)
-{
+// MicroWin doesn't have support needed for the other ctors

 #ifdef __WXMICROWIN__
 #ifdef __WXMICROWIN__

-    m_refData = NULL;
-#else
-    wxCursorRefData *refData = new wxCursorRefData;
-    m_refData = refData;

 
 

-    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
-        refData->m_hCursor = (WXHCURSOR) ReadCursorFile(WXSTRINGCAST cursor_file, wxGetInstance(), &refData->m_width, &refData->m_height);
-#endif
-#endif
-    }
-    else if (flags == wxBITMAP_TYPE_ICO)
+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 )

     {
     {

-#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_CUR_RESOURCE:
+            hcursor = ::LoadCursor(wxGetInstance(), filename);
+            break;
+
+#ifndef __WXWINCE__
+        case wxBITMAP_TYPE_CUR:
+            hcursor = ::LoadCursorFromFile(filename);
+            break;

 #endif
 #endif

+
+        case wxBITMAP_TYPE_ICO:
+            hcursor = wxBitmapToHCURSOR
+                      (
+                       wxIcon(filename, wxBITMAP_TYPE_ICO),
+                       hotSpotX,
+                       hotSpotY
+                      );
+            break;
+
+        case wxBITMAP_TYPE_BMP:
+            hcursor = wxBitmapToHCURSOR
+                      (
+                       wxBitmap(filename, wxBITMAP_TYPE_BMP),
+                       hotSpotX,
+                       hotSpotY
+                      );
+            break;
+
+        default:
+            wxFAIL_MSG( _T("unknown cursor resource type") );
+
+            hcursor = NULL;

     }
     }

-    else if (flags == wxBITMAP_TYPE_BMP)
+
+    if ( hcursor )

     {
     {

-#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;
-        refData->m_hCursor = (WXHCURSOR) MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pnt);
-        DeleteObject(hBitmap);
-#endif
-    }
+        m_refData = new wxCursorRefData(hcursor, true /* delete it later */);

 
 #if WXWIN_COMPATIBILITY_2
 
 #if WXWIN_COMPATIBILITY_2

-    refData->SetOk();
+        ((wxCursorRefData *)m_refData)->SetOk();

 #endif // WXWIN_COMPATIBILITY_2
 #endif // WXWIN_COMPATIBILITY_2

-
-#endif
+    }

 }
 
 // Cursors by stock number
 }
 
 // Cursors by stock number

-wxCursor::wxCursor(int cursor_type)
+wxCursor::wxCursor(int idCursor)

 {
 {

-#ifdef __WXMICROWIN__
-    m_refData = NULL;
-#else
-  wxCursorRefData *refData = new wxCursorRefData;
-  m_refData = refData;
-
-  switch (cursor_type)
-  {
-    case wxCURSOR_ARROWWAIT:
-#ifndef __WIN16__
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_APPSTARTING);
-      break;
-#endif
-    case wxCURSOR_WAIT:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_WAIT);
-      break;
-    case wxCURSOR_IBEAM:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_IBEAM);
-      break;
-    case wxCURSOR_CROSS:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_CROSS);
-      break;
-    case wxCURSOR_SIZENWSE:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENWSE);
-      break;
-    case wxCURSOR_SIZENESW:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENESW);
-      break;
-    case wxCURSOR_SIZEWE:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZEWE);
-      break;
-    case wxCURSOR_SIZENS:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENS);
-      break;
-    case wxCURSOR_CHAR:
-    {
-      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:
+    // all wxWindows standard cursors
+    static const struct StdCursor

     {
     {

-      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:
+        // is this a standard Windows cursor?
+        bool isStd;
+
+        // the cursor name or id
+        LPCTSTR name;
+    } stdCursors[] =

     {
     {

-      refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("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 )

     {
     {

-//      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;
+        wxLogLastError(_T("LoadCursor"));

     }
     }

-    case wxCURSOR_BLANK:
+    else

     {
     {

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

     }
     }

-    default:
-    case wxCURSOR_ARROW:
-      refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
-      break;
-  }
-
-  // no need to destroy the stock cursors
-  // TODO: check this
-  //m_refData->m_destroyCursor = FALSE;
-#endif

 }
 
 }
 

+#endif // __WXMICROWIN__/!__WXMICROWIN__
+

 wxCursor::~wxCursor()
 {
 }
 
 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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // Global cursor setting
 // ----------------------------------------------------------------------------


@@ -339,9 +381,7 @@ void wxSetCursor(const wxCursor& cursor)
 {
     if ( cursor.Ok() )
     {
 {
     if ( cursor.Ok() )
     {

-#ifndef __WXMICROWIN__

         ::SetCursor(GetHcursorOf(cursor));
         ::SetCursor(GetHcursorOf(cursor));

-#endif

 
         if ( gs_globalCursor )
             *gs_globalCursor = cursor;
 
         if ( gs_globalCursor )
             *gs_globalCursor = cursor;