]> git.saurik.com Git - wxWidgets.git/blob - src/msw/cursor.cpp
added possibility to throw different objects and crash directly from the main frame...
[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 #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 wxWidgets 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