]> git.saurik.com Git - wxWidgets.git/blob - src/msw/cursor.cpp
Tweaks for demos on MacOSX
[wxWidgets.git] / 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 wxUSE_WXDIB
213 if ( !hcursor )
214 {
215 wxLogWarning(_("Failed to create cursor."));
216 return;
217 }
218 #else
219 HCURSOR hcursor = 0;
220 #endif
221
222 m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
223 }
224 #endif
225
226 wxCursor::wxCursor(const char WXUNUSED(bits)[],
227 int WXUNUSED(width),
228 int WXUNUSED(height),
229 int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY),
230 const char WXUNUSED(maskBits)[])
231 {
232 }
233
234 // MicroWin doesn't have support needed for the other ctors
235 #ifdef __WXMICROWIN__
236
237 wxCursor::wxCursor(const wxString& WXUNUSED(filename),
238 long WXUNUSED(kind),
239 int WXUNUSED(hotSpotX),
240 int WXUNUSED(hotSpotY))
241 {
242 }
243
244 wxCursor::wxCursor(int WXUNUSED(cursor_type))
245 {
246 }
247
248 #else // !__WXMICROWIN__
249
250 wxCursor::wxCursor(const wxString& filename,
251 long kind,
252 int hotSpotX,
253 int hotSpotY)
254 {
255 HCURSOR hcursor;
256 switch ( kind )
257 {
258 case wxBITMAP_TYPE_CUR_RESOURCE:
259 hcursor = ::LoadCursor(wxGetInstance(), filename);
260 break;
261
262 #ifndef __WXWINCE__
263 case wxBITMAP_TYPE_CUR:
264 hcursor = ::LoadCursorFromFile(filename);
265 break;
266 #endif
267
268 case wxBITMAP_TYPE_ICO:
269 hcursor = wxBitmapToHCURSOR
270 (
271 wxIcon(filename, wxBITMAP_TYPE_ICO),
272 hotSpotX,
273 hotSpotY
274 );
275 break;
276
277 case wxBITMAP_TYPE_BMP:
278 hcursor = wxBitmapToHCURSOR
279 (
280 wxBitmap(filename, wxBITMAP_TYPE_BMP),
281 hotSpotX,
282 hotSpotY
283 );
284 break;
285
286 default:
287 wxFAIL_MSG( _T("unknown cursor resource type") );
288
289 hcursor = NULL;
290 }
291
292 if ( hcursor )
293 {
294 m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
295 }
296 }
297
298 // Cursors by stock number
299 wxCursor::wxCursor(int idCursor)
300 {
301 // all wxWidgets standard cursors
302 static const struct StdCursor
303 {
304 // is this a standard Windows cursor?
305 bool isStd;
306
307 // the cursor name or id
308 LPCTSTR name;
309 } stdCursors[] =
310 {
311 { true, NULL }, // wxCURSOR_NONE
312 { true, IDC_ARROW }, // wxCURSOR_ARROW
313 { false, _T("WXCURSOR_RIGHT_ARROW") }, // wxCURSOR_RIGHT_ARROW
314 { false, _T("WXCURSOR_BULLSEYE") }, // wxCURSOR_BULLSEYE
315 { true, IDC_ARROW }, // WXCURSOR_CHAR
316
317 // Displays as an I-beam on XP, so use a cursor file
318 // { true, IDC_CROSS }, // WXCURSOR_CROSS
319 { false, _T("WXCURSOR_CROSS") }, // WXCURSOR_CROSS
320
321 // See special handling below for wxCURSOR_HAND
322 // { false, _T("WXCURSOR_HAND") }, // wxCURSOR_HAND
323 { true, IDC_HAND }, // wxCURSOR_HAND
324
325 { true, IDC_IBEAM }, // WXCURSOR_IBEAM
326 { true, IDC_ARROW }, // WXCURSOR_LEFT_BUTTON
327 { false, _T("WXCURSOR_MAGNIFIER") }, // wxCURSOR_MAGNIFIER
328 { true, IDC_ARROW }, // WXCURSOR_MIDDLE_BUTTON
329 { true, IDC_NO }, // WXCURSOR_NO_ENTRY
330 { false, _T("WXCURSOR_PBRUSH") }, // wxCURSOR_PAINT_BRUSH
331 { false, _T("WXCURSOR_PENCIL") }, // wxCURSOR_PENCIL
332 { false, _T("WXCURSOR_PLEFT") }, // wxCURSOR_POINT_LEFT
333 { false, _T("WXCURSOR_PRIGHT") }, // wxCURSOR_POINT_RIGHT
334 { true, IDC_HELP }, // WXCURSOR_QUESTION_ARROW
335 { true, IDC_ARROW }, // WXCURSOR_RIGHT_BUTTON
336 { true, IDC_SIZENESW }, // WXCURSOR_SIZENESW
337 { true, IDC_SIZENS }, // WXCURSOR_SIZENS
338 { true, IDC_SIZENWSE }, // WXCURSOR_SIZENWSE
339 { true, IDC_SIZEWE }, // WXCURSOR_SIZEWE
340 { true, IDC_SIZEALL }, // WXCURSOR_SIZING
341 { false, _T("WXCURSOR_PBRUSH") }, // wxCURSOR_SPRAYCAN
342 { true, IDC_WAIT }, // WXCURSOR_WAIT
343 { true, IDC_WAIT }, // WXCURSOR_WATCH
344 { false, _T("WXCURSOR_BLANK") }, // wxCURSOR_BLANK
345 { true, IDC_APPSTARTING }, // wxCURSOR_ARROWWAIT
346
347 // no entry for wxCURSOR_MAX
348 };
349
350 wxCOMPILE_TIME_ASSERT( WXSIZEOF(stdCursors) == wxCURSOR_MAX,
351 CursorsIdArrayMismatch );
352
353 wxCHECK_RET( idCursor > 0 && (size_t)idCursor < WXSIZEOF(stdCursors),
354 _T("invalid cursor id in wxCursor() ctor") );
355
356 const StdCursor& stdCursor = stdCursors[idCursor];
357 bool deleteLater = !stdCursor.isStd;
358
359 HCURSOR hcursor = ::LoadCursor(stdCursor.isStd ? NULL : wxGetInstance(),
360 stdCursor.name);
361
362 // IDC_HAND may not be available on some versions of Windows.
363 if ( !hcursor && idCursor == wxCURSOR_HAND)
364 {
365 hcursor = ::LoadCursor(wxGetInstance(), _T("WXCURSOR_HAND"));
366 deleteLater = true;
367 }
368
369 if ( !hcursor )
370 {
371 wxLogLastError(_T("LoadCursor"));
372 }
373 else
374 {
375 m_refData = new wxCursorRefData(hcursor, deleteLater);
376 }
377 }
378
379 #endif // __WXMICROWIN__/!__WXMICROWIN__
380
381 wxCursor::~wxCursor()
382 {
383 }
384
385 // ----------------------------------------------------------------------------
386 // other wxCursor functions
387 // ----------------------------------------------------------------------------
388
389 bool wxCursor::operator==(const wxCursor& cursor) const
390 {
391 if ( !m_refData )
392 return !cursor.m_refData;
393
394 return cursor.m_refData &&
395 ((wxCursorRefData *)m_refData)->m_hCursor ==
396 ((wxCursorRefData *)cursor.m_refData)->m_hCursor;
397 }
398
399 wxGDIImageRefData *wxCursor::CreateData() const
400 {
401 return new wxCursorRefData;
402 }
403
404 // ----------------------------------------------------------------------------
405 // Global cursor setting
406 // ----------------------------------------------------------------------------
407
408 const wxCursor *wxGetGlobalCursor()
409 {
410 return gs_globalCursor;
411 }
412
413 void wxSetCursor(const wxCursor& cursor)
414 {
415 if ( cursor.Ok() )
416 {
417 ::SetCursor(GetHcursorOf(cursor));
418
419 if ( gs_globalCursor )
420 *gs_globalCursor = cursor;
421 }
422 }
423
424