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