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 #include "wx/cursor.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/utils.h"
  31     #include "wx/app.h"
  32     #include "wx/bitmap.h"
  33     #include "wx/icon.h"
  34     #include "wx/settings.h"
  35     #include "wx/intl.h"
  36     #include "wx/image.h"
  37     #include "wx/module.h"
  38 #endif
  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         wxDELETE(gs_globalCursor);
 109     }
 110 };
 111
 112 // ============================================================================
 113 // implementation
 114 // ============================================================================
 115
 116 // ----------------------------------------------------------------------------
 117 // wxCursorRefData
 118 // ----------------------------------------------------------------------------
 119
 120 wxSize wxCursorRefData::ms_sizeStd;
 121
 122 wxCoord wxCursorRefData::GetStandardWidth()
 123 {
 124     if ( !ms_sizeStd.x )
 125         ms_sizeStd.x = wxSystemSettings::GetMetric(wxSYS_CURSOR_X);
 126
 127     return ms_sizeStd.x;
 128 }
 129
 130 wxCoord wxCursorRefData::GetStandardHeight()
 131 {
 132     if ( !ms_sizeStd.y )
 133         ms_sizeStd.y = wxSystemSettings::GetMetric(wxSYS_CURSOR_Y);
 134
 135     return ms_sizeStd.y;
 136 }
 137
 138 wxCursorRefData::wxCursorRefData(HCURSOR hcursor, bool destroy)
 139 {
 140     m_hCursor = (WXHCURSOR)hcursor;
 141
 142     if ( m_hCursor )
 143     {
 144         m_width = GetStandardWidth();
 145         m_height = GetStandardHeight();
 146     }
 147
 148     m_destroyCursor = destroy;
 149 }
 150
 151 void wxCursorRefData::Free()
 152 {
 153     if ( m_hCursor )
 154     {
 155 #ifndef __WXWINCE__
 156         if ( m_destroyCursor )
 157             ::DestroyCursor((HCURSOR)m_hCursor);
 158 #endif
 159
 160         m_hCursor = 0;
 161     }
 162 }
 163
 164 // ----------------------------------------------------------------------------
 165 // Cursors
 166 // ----------------------------------------------------------------------------
 167
 168 wxCursor::wxCursor()
 169 {
 170 }
 171
 172 #if wxUSE_IMAGE
 173 wxCursor::wxCursor(const wxImage& image)
 174 {
 175     // image has to be of the standard cursor size, otherwise we won't be able
 176     // to create it
 177     const int w = wxCursorRefData::GetStandardWidth();
 178     const int h = wxCursorRefData::GetStandardHeight();
 179
 180     int hotSpotX = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
 181     int hotSpotY = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
 182     int image_w = image.GetWidth();
 183     int image_h = image.GetHeight();
 184
 185     wxASSERT_MSG( hotSpotX >= 0 && hotSpotX < image_w &&
 186                   hotSpotY >= 0 && hotSpotY < image_h,
 187                   wxT("invalid cursor hot spot coordinates") );
 188
 189     wxImage imageSized(image); // final image of correct size
 190
 191     // if image is too small then place it in the center, resize it if too big
 192     if ((w > image_w) && (h > image_h))
 193     {
 194         wxPoint offset((w - image_w)/2, (h - image_h)/2);
 195         hotSpotX = hotSpotX + offset.x;
 196         hotSpotY = hotSpotY + offset.y;
 197
 198         imageSized = image.Size(wxSize(w, h), offset);
 199     }
 200     else if ((w != image_w) || (h != image_h))
 201     {
 202         hotSpotX = int(hotSpotX * double(w) / double(image_w));
 203         hotSpotY = int(hotSpotY * double(h) / double(image_h));
 204
 205         imageSized = image.Scale(w, h);
 206     }
 207
 208     HCURSOR hcursor = wxBitmapToHCURSOR( wxBitmap(imageSized),
 209                                          hotSpotX, hotSpotY );
 210
 211     if ( !hcursor )
 212     {
 213         wxLogWarning(_("Failed to create cursor."));
 214         return;
 215     }
 216
 217     m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
 218 }
 219 #endif // wxUSE_IMAGE
 220
 221 // MicroWin doesn't have support needed for the other ctors
 222 #ifdef __WXMICROWIN__
 223
 224 wxCursor::InitFromStock(wxStockCursor WXUNUSED(cursor_type))
 225 {
 226 }
 227
 228 #else // !__WXMICROWIN__
 229
 230 wxCursor::wxCursor(const wxString& filename,
 231                    wxBitmapType 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.t_str());
 240             break;
 241
 242 #ifndef __WXWINCE__
 243         case wxBITMAP_TYPE_ANI:
 244         case wxBITMAP_TYPE_CUR:
 245             hcursor = ::LoadCursorFromFile(filename.t_str());
 246             break;
 247 #endif
 248
 249         case wxBITMAP_TYPE_ICO:
 250             hcursor = wxBitmapToHCURSOR
 251                       (
 252                        wxIcon(filename, wxBITMAP_TYPE_ICO),
 253                        hotSpotX,
 254                        hotSpotY
 255                       );
 256             break;
 257
 258         case wxBITMAP_TYPE_BMP:
 259             hcursor = wxBitmapToHCURSOR
 260                       (
 261                        wxBitmap(filename, wxBITMAP_TYPE_BMP),
 262                        hotSpotX,
 263                        hotSpotY
 264                       );
 265             break;
 266
 267         default:
 268             wxLogError( wxT("unknown cursor resource type '%d'"), kind );
 269
 270             hcursor = NULL;
 271     }
 272
 273     if ( hcursor )
 274     {
 275         m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
 276     }
 277 }
 278
 279 namespace
 280 {
 281
 282 void ReverseBitmap(HBITMAP bitmap, int width, int height)
 283 {
 284     MemoryHDC hdc;
 285     SelectInHDC selBitmap(hdc, bitmap);
 286     ::StretchBlt(hdc, width - 1, 0, -width, height,
 287                  hdc, 0, 0, width, height, SRCCOPY);
 288 }
 289
 290 HCURSOR CreateReverseCursor(HCURSOR cursor)
 291 {
 292     ICONINFO info;
 293     if ( !::GetIconInfo(cursor, &info) )
 294         return NULL;
 295
 296     HCURSOR cursorRev = NULL;
 297
 298     BITMAP bmp;
 299     if ( ::GetObject(info.hbmMask, sizeof(bmp), &bmp) )
 300     {
 301         ReverseBitmap(info.hbmMask, bmp.bmWidth, bmp.bmHeight);
 302         if ( info.hbmColor )
 303             ReverseBitmap(info.hbmColor, bmp.bmWidth, bmp.bmHeight);
 304         info.xHotspot = (DWORD)bmp.bmWidth - 1 - info.xHotspot;
 305
 306         cursorRev = ::CreateIconIndirect(&info);
 307     }
 308
 309     ::DeleteObject(info.hbmMask);
 310     if ( info.hbmColor )
 311         ::DeleteObject(info.hbmColor);
 312
 313     return cursorRev;
 314 }
 315
 316 } // anonymous namespace
 317
 318 // Cursors by stock number
 319 void wxCursor::InitFromStock(wxStockCursor idCursor)
 320 {
 321     // all wxWidgets standard cursors
 322     static const struct StdCursor
 323     {
 324         // is this a standard Windows cursor?
 325         bool isStd;
 326
 327         // the cursor name or id
 328         LPCTSTR name;
 329     } stdCursors[] =
 330     {
 331         {  true, NULL                        }, // wxCURSOR_NONE
 332         {  true, IDC_ARROW                   }, // wxCURSOR_ARROW
 333         { false, wxT("WXCURSOR_RIGHT_ARROW")  }, // wxCURSOR_RIGHT_ARROW
 334         { false, wxT("WXCURSOR_BULLSEYE")     }, // wxCURSOR_BULLSEYE
 335         {  true, IDC_ARROW                   }, // WXCURSOR_CHAR
 336         {  true, IDC_CROSS                   }, // WXCURSOR_CROSS
 337         {  true, IDC_HAND                    }, // wxCURSOR_HAND
 338         {  true, IDC_IBEAM                   }, // WXCURSOR_IBEAM
 339         {  true, IDC_ARROW                   }, // WXCURSOR_LEFT_BUTTON
 340         { false, wxT("WXCURSOR_MAGNIFIER")    }, // wxCURSOR_MAGNIFIER
 341         {  true, IDC_ARROW                   }, // WXCURSOR_MIDDLE_BUTTON
 342         {  true, IDC_NO                      }, // WXCURSOR_NO_ENTRY
 343         { false, wxT("WXCURSOR_PBRUSH")       }, // wxCURSOR_PAINT_BRUSH
 344         { false, wxT("WXCURSOR_PENCIL")       }, // wxCURSOR_PENCIL
 345         { false, wxT("WXCURSOR_PLEFT")        }, // wxCURSOR_POINT_LEFT
 346         { false, wxT("WXCURSOR_PRIGHT")       }, // wxCURSOR_POINT_RIGHT
 347         {  true, IDC_HELP                    }, // WXCURSOR_QUESTION_ARROW
 348         {  true, IDC_ARROW                   }, // WXCURSOR_RIGHT_BUTTON
 349         {  true, IDC_SIZENESW                }, // WXCURSOR_SIZENESW
 350         {  true, IDC_SIZENS                  }, // WXCURSOR_SIZENS
 351         {  true, IDC_SIZENWSE                }, // WXCURSOR_SIZENWSE
 352         {  true, IDC_SIZEWE                  }, // WXCURSOR_SIZEWE
 353         {  true, IDC_SIZEALL                 }, // WXCURSOR_SIZING
 354         { false, wxT("WXCURSOR_PBRUSH")       }, // wxCURSOR_SPRAYCAN
 355         {  true, IDC_WAIT                    }, // WXCURSOR_WAIT
 356         {  true, IDC_WAIT                    }, // WXCURSOR_WATCH
 357         { false, wxT("WXCURSOR_BLANK")        }, // wxCURSOR_BLANK
 358         {  true, IDC_APPSTARTING             }, // wxCURSOR_ARROWWAIT
 359
 360         // no entry for wxCURSOR_MAX
 361     };
 362
 363     wxCOMPILE_TIME_ASSERT( WXSIZEOF(stdCursors) == wxCURSOR_MAX,
 364                            CursorsIdArrayMismatch );
 365
 366     wxCHECK_RET( idCursor > 0 && (size_t)idCursor < WXSIZEOF(stdCursors),
 367                  wxT("invalid cursor id in wxCursor() ctor") );
 368
 369     const StdCursor& stdCursor = stdCursors[idCursor];
 370     bool deleteLater = !stdCursor.isStd;
 371
 372     HCURSOR hcursor = ::LoadCursor(stdCursor.isStd ? NULL : wxGetInstance(),
 373                                    stdCursor.name);
 374
 375     // IDC_HAND may not be available on some versions of Windows.
 376     if ( !hcursor && idCursor == wxCURSOR_HAND)
 377     {
 378         hcursor = ::LoadCursor(wxGetInstance(), wxT("WXCURSOR_HAND"));
 379         deleteLater = true;
 380     }
 381
 382     if ( !hcursor && idCursor == wxCURSOR_RIGHT_ARROW)
 383     {
 384         hcursor = ::LoadCursor(NULL, IDC_ARROW);
 385         if ( hcursor )
 386         {
 387             hcursor = CreateReverseCursor(hcursor);
 388             deleteLater = true;
 389         }
 390     }
 391
 392     if ( !hcursor )
 393     {
 394         if ( !stdCursor.isStd )
 395         {
 396             // it may be not obvious to the programmer why did loading fail,
 397             // try to help by pointing to the by far the most probable reason
 398             wxFAIL_MSG(wxT("Loading a cursor defined by wxWidgets failed, ")
 399                        wxT("did you include include/wx/msw/wx.rc file from ")
 400                        wxT("your resource file?"));
 401         }
 402
 403         wxLogLastError(wxT("LoadCursor"));
 404     }
 405     else
 406     {
 407         m_refData = new wxCursorRefData(hcursor, deleteLater);
 408     }
 409 }
 410
 411 #endif // __WXMICROWIN__/!__WXMICROWIN__
 412
 413 wxCursor::~wxCursor()
 414 {
 415 }
 416
 417 // ----------------------------------------------------------------------------
 418 // other wxCursor functions
 419 // ----------------------------------------------------------------------------
 420
 421 wxGDIImageRefData *wxCursor::CreateData() const
 422 {
 423     return new wxCursorRefData;
 424 }
 425
 426 // ----------------------------------------------------------------------------
 427 // Global cursor setting
 428 // ----------------------------------------------------------------------------
 429
 430 const wxCursor *wxGetGlobalCursor()
 431 {
 432     return gs_globalCursor;
 433 }
 434
 435 void wxSetCursor(const wxCursor& cursor)
 436 {
 437     if ( cursor.IsOk() )
 438     {
 439         ::SetCursor(GetHcursorOf(cursor));
 440
 441         if ( gs_globalCursor )
 442             *gs_globalCursor = cursor;
 443     }
 444 }