src/msw/cursor.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/cursor.cpp
   3 // Purpose:     wxCursor class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997-2003 Julian Smart and Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "cursor.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/utils.h"
  33     #include "wx/app.h"
  34     #include "wx/bitmap.h"
  35     #include "wx/icon.h"
  36     #include "wx/cursor.h"
  37     #include "wx/settings.h"
  38     #include "wx/intl.h"
  39 #endif
  40
  41 #include "wx/module.h"
  42 #include "wx/image.h"
  43 #include "wx/msw/private.h"
  44
  45 // define functions missing in MicroWin
  46 #ifdef __WXMICROWIN__
  47     static inline void DestroyCursor(HCURSOR) { }
  48     static inline void SetCursor(HCURSOR) { }
  49 #endif // __WXMICROWIN__
  50
  51 // ----------------------------------------------------------------------------
  52 // private classes
  53 // ----------------------------------------------------------------------------
  54
  55 class WXDLLEXPORT wxCursorRefData : public wxGDIImageRefData
  56 {
  57 public:
  58     // the second parameter is used to tell us to delete the cursor when we're
  59     // done with it (normally we shouldn't call DestroyCursor() this is why it
  60     // doesn't happen by default)
  61     wxCursorRefData(HCURSOR hcursor = 0, bool takeOwnership = false);
  62
  63     virtual ~wxCursorRefData() { Free(); }
  64
  65     virtual void Free();
  66
  67
  68     // return the size of the standard cursor: notice that the system only
  69     // supports the cursors of this size
  70     static wxCoord GetStandardWidth();
  71     static wxCoord GetStandardHeight();
  72
  73 private:
  74     bool m_destroyCursor;
  75
  76     // standard cursor size, computed on first use
  77     static wxSize ms_sizeStd;
  78 };
  79
  80 // ----------------------------------------------------------------------------
  81 // wxWin macros
  82 // ----------------------------------------------------------------------------
  83
  84 IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxGDIObject)
  85
  86 // ----------------------------------------------------------------------------
  87 // globals
  88 // ----------------------------------------------------------------------------
  89
  90 // Current cursor, in order to hang on to cursor handle when setting the cursor
  91 // globally
  92 static wxCursor *gs_globalCursor = NULL;
  93
  94 // ----------------------------------------------------------------------------
  95 // private classes
  96 // ----------------------------------------------------------------------------
  97
  98 class wxCursorModule : public wxModule
  99 {
 100 public:
 101     virtual bool OnInit()
 102     {
 103         gs_globalCursor = new wxCursor;
 104
 105         return TRUE;
 106     }
 107
 108     virtual void OnExit()
 109     {
 110         delete gs_globalCursor;
 111         gs_globalCursor = (wxCursor *)NULL;
 112     }
 113 };
 114
 115 // ============================================================================
 116 // implementation
 117 // ============================================================================
 118
 119 // ----------------------------------------------------------------------------
 120 // wxCursorRefData
 121 // ----------------------------------------------------------------------------
 122
 123 wxSize wxCursorRefData::ms_sizeStd;
 124
 125 wxCoord wxCursorRefData::GetStandardWidth()
 126 {
 127     if ( !ms_sizeStd.x )
 128         ms_sizeStd.x = wxSystemSettings::GetMetric(wxSYS_CURSOR_X);
 129
 130     return ms_sizeStd.x;
 131 }
 132
 133 wxCoord wxCursorRefData::GetStandardHeight()
 134 {
 135     if ( !ms_sizeStd.y )
 136         ms_sizeStd.y = wxSystemSettings::GetMetric(wxSYS_CURSOR_Y);
 137
 138     return ms_sizeStd.y;
 139 }
 140
 141 wxCursorRefData::wxCursorRefData(HCURSOR hcursor, bool destroy)
 142 {
 143     m_hCursor = (WXHCURSOR)hcursor;
 144
 145     if ( m_hCursor )
 146     {
 147         m_width = GetStandardWidth();
 148         m_height = GetStandardHeight();
 149     }
 150
 151     m_destroyCursor = destroy;
 152 }
 153
 154 void wxCursorRefData::Free()
 155 {
 156     if ( m_hCursor )
 157     {
 158 #ifndef __WXWINCE__
 159         if ( m_destroyCursor )
 160             ::DestroyCursor((HCURSOR)m_hCursor);
 161 #endif
 162
 163         m_hCursor = 0;
 164     }
 165 }
 166
 167 // ----------------------------------------------------------------------------
 168 // Cursors
 169 // ----------------------------------------------------------------------------
 170
 171 wxCursor::wxCursor()
 172 {
 173 }
 174
 175 #if wxUSE_IMAGE
 176 wxCursor::wxCursor(const wxImage& image)
 177 {
 178     // image has to be of the standard cursor size, otherwise we won't be able
 179     // to create it
 180     const int w = wxCursorRefData::GetStandardWidth();
 181     const int h = wxCursorRefData::GetStandardHeight();
 182
 183     const int hotSpotX = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
 184     const int hotSpotY = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
 185
 186     wxASSERT_MSG( hotSpotX >= 0 && hotSpotX < w &&
 187                     hotSpotY >= 0 && hotSpotY < h,
 188                   _T("invalid cursor hot spot coordinates") );
 189
 190     HCURSOR hcursor = wxBitmapToHCURSOR
 191                       (
 192                         wxBitmap(image.Scale(w, h)),
 193                         hotSpotX,
 194                         hotSpotY
 195                       );
 196     if ( !hcursor )
 197     {
 198         wxLogWarning(_("Failed to create cursor."));
 199         return;
 200     }
 201
 202     m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
 203 }
 204 #endif
 205
 206 wxCursor::wxCursor(const char WXUNUSED(bits)[],
 207                    int WXUNUSED(width),
 208                    int WXUNUSED(height),
 209                    int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY),
 210                    const char WXUNUSED(maskBits)[])
 211 {
 212 }
 213
 214 // MicroWin doesn't have support needed for the other ctors
 215 #ifdef __WXMICROWIN__
 216
 217 wxCursor::wxCursor(const wxString& WXUNUSED(filename),
 218                    long WXUNUSED(kind),
 219                    int WXUNUSED(hotSpotX),
 220                    int WXUNUSED(hotSpotY))
 221 {
 222 }
 223
 224 wxCursor::wxCursor(int WXUNUSED(cursor_type))
 225 {
 226 }
 227
 228 #else // !__WXMICROWIN__
 229
 230 wxCursor::wxCursor(const wxString& filename,
 231                    long kind,
 232                    int hotSpotX,
 233                    int hotSpotY)
 234 {
 235     HCURSOR hcursor;
 236     switch ( kind )
 237     {
 238         case wxBITMAP_TYPE_CUR_RESOURCE:
 239             hcursor = ::LoadCursor(wxGetInstance(), filename);
 240             break;
 241
 242 #ifndef __WXWINCE__
 243         case wxBITMAP_TYPE_CUR:
 244             hcursor = ::LoadCursorFromFile(filename);
 245             break;
 246 #endif
 247
 248         case wxBITMAP_TYPE_ICO:
 249             hcursor = wxBitmapToHCURSOR
 250                       (
 251                        wxIcon(filename, wxBITMAP_TYPE_ICO),
 252                        hotSpotX,
 253                        hotSpotY
 254                       );
 255             break;
 256
 257         case wxBITMAP_TYPE_BMP:
 258             hcursor = wxBitmapToHCURSOR
 259                       (
 260                        wxBitmap(filename, wxBITMAP_TYPE_BMP),
 261                        hotSpotX,
 262                        hotSpotY
 263                       );
 264             break;
 265
 266         default:
 267             wxFAIL_MSG( _T("unknown cursor resource type") );
 268
 269             hcursor = NULL;
 270     }
 271
 272     if ( hcursor )
 273     {
 274         m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
 275     }
 276 }
 277
 278 // Cursors by stock number
 279 wxCursor::wxCursor(int idCursor)
 280 {
 281     // all wxWindows standard cursors
 282     static const struct StdCursor
 283     {
 284         // is this a standard Windows cursor?
 285         bool isStd;
 286
 287         // the cursor name or id
 288         LPCTSTR name;
 289     } stdCursors[] =
 290     {
 291         {  true, NULL                        }, // wxCURSOR_NONE
 292         {  true, IDC_ARROW                   }, // wxCURSOR_ARROW
 293         { false, _T("WXCURSOR_RIGHT_ARROW")  }, // wxCURSOR_RIGHT_ARROW
 294         { false, _T("WXCURSOR_BULLSEYE")     }, // wxCURSOR_BULLSEYE
 295         {  true, IDC_ARROW                   }, // WXCURSOR_CHAR
 296         {  true, IDC_CROSS                   }, // WXCURSOR_CROSS
 297         { false, _T("WXCURSOR_HAND")         }, // wxCURSOR_HAND
 298         {  true, IDC_IBEAM                   }, // WXCURSOR_IBEAM
 299         {  true, IDC_ARROW                   }, // WXCURSOR_LEFT_BUTTON
 300         { false, _T("WXCURSOR_MAGNIFIER")    }, // wxCURSOR_MAGNIFIER
 301         {  true, IDC_ARROW                   }, // WXCURSOR_MIDDLE_BUTTON
 302         {  true, IDC_NO                      }, // WXCURSOR_NO_ENTRY
 303         { false, _T("WXCURSOR_PBRUSH")       }, // wxCURSOR_PAINT_BRUSH
 304         { false, _T("WXCURSOR_PENCIL")       }, // wxCURSOR_PENCIL
 305         { false, _T("WXCURSOR_PLEFT")        }, // wxCURSOR_POINT_LEFT
 306         { false, _T("WXCURSOR_PRIGHT")       }, // wxCURSOR_POINT_RIGHT
 307         {  true, IDC_HELP                    }, // WXCURSOR_QUESTION_ARROW
 308         {  true, IDC_ARROW                   }, // WXCURSOR_RIGHT_BUTTON
 309         {  true, IDC_SIZENESW                }, // WXCURSOR_SIZENESW
 310         {  true, IDC_SIZENS                  }, // WXCURSOR_SIZENS
 311         {  true, IDC_SIZENWSE                }, // WXCURSOR_SIZENWSE
 312         {  true, IDC_SIZEWE                  }, // WXCURSOR_SIZEWE
 313         {  true, IDC_SIZEALL                 }, // WXCURSOR_SIZING
 314         { false, _T("WXCURSOR_PBRUSH")       }, // wxCURSOR_SPRAYCAN
 315         {  true, IDC_WAIT                    }, // WXCURSOR_WAIT
 316         { false, _T("WXCURSOR_WATCH")        }, // WXCURSOR_WATCH
 317         { false, _T("WXCURSOR_BLANK")        }, // wxCURSOR_BLANK
 318         {  true, IDC_APPSTARTING             }, // wxCURSOR_ARROWWAIT
 319
 320         // no entry for wxCURSOR_MAX
 321     };
 322
 323     wxCOMPILE_TIME_ASSERT( WXSIZEOF(stdCursors) == wxCURSOR_MAX,
 324                            CursorsIdArrayMismatch );
 325
 326     wxCHECK_RET( idCursor > 0 && (size_t)idCursor < WXSIZEOF(stdCursors),
 327                  _T("invalid cursor id in wxCursor() ctor") );
 328
 329     const StdCursor& stdCursor = stdCursors[idCursor];
 330
 331     HCURSOR hcursor = ::LoadCursor(stdCursor.isStd ? NULL : wxGetInstance(),
 332                                    stdCursor.name);
 333
 334     if ( !hcursor )
 335     {
 336         wxLogLastError(_T("LoadCursor"));
 337     }
 338     else
 339     {
 340         m_refData = new wxCursorRefData(hcursor);
 341     }
 342 }
 343
 344 #endif // __WXMICROWIN__/!__WXMICROWIN__
 345
 346 wxCursor::~wxCursor()
 347 {
 348 }
 349
 350 // ----------------------------------------------------------------------------
 351 // other wxCursor functions
 352 // ----------------------------------------------------------------------------
 353
 354 bool wxCursor::operator==(const wxCursor& cursor) const
 355 {
 356     if ( !m_refData )
 357         return !cursor.m_refData;
 358
 359     return cursor.m_refData &&
 360                 ((wxCursorRefData *)m_refData)->m_hCursor ==
 361                 ((wxCursorRefData *)cursor.m_refData)->m_hCursor;
 362 }
 363
 364 wxGDIImageRefData *wxCursor::CreateData() const
 365 {
 366     return new wxCursorRefData;
 367 }
 368
 369 // ----------------------------------------------------------------------------
 370 // Global cursor setting
 371 // ----------------------------------------------------------------------------
 372
 373 const wxCursor *wxGetGlobalCursor()
 374 {
 375     return gs_globalCursor;
 376 }
 377
 378 void wxSetCursor(const wxCursor& cursor)
 379 {
 380     if ( cursor.Ok() )
 381     {
 382         ::SetCursor(GetHcursorOf(cursor));
 383
 384         if ( gs_globalCursor )
 385             *gs_globalCursor = cursor;
 386     }
 387 }
 388
 389