]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: cursor.cpp | |
3 | // Purpose: | |
4 | // Author: Robert Roebling | |
5 | // Id: $Id$ | |
6 | // Copyright: (c) 1998 Robert Roebling | |
7 | // Licence: wxWindows licence | |
8 | ///////////////////////////////////////////////////////////////////////////// | |
9 | ||
10 | // For compilers that support precompilation, includes "wx.h". | |
11 | #include "wx/wxprec.h" | |
12 | ||
13 | #include "wx/cursor.h" | |
14 | #include "wx/utils.h" | |
15 | #include "wx/app.h" | |
16 | ||
17 | #include <gdk/gdk.h> | |
18 | #include <gtk/gtk.h> | |
19 | ||
20 | //----------------------------------------------------------------------------- | |
21 | // idle system | |
22 | //----------------------------------------------------------------------------- | |
23 | ||
24 | extern void wxapp_install_idle_handler(); | |
25 | extern bool g_isIdle; | |
26 | ||
27 | //----------------------------------------------------------------------------- | |
28 | // wxCursor | |
29 | //----------------------------------------------------------------------------- | |
30 | ||
31 | class wxCursorRefData: public wxObjectRefData | |
32 | { | |
33 | public: | |
34 | ||
35 | wxCursorRefData(); | |
36 | ~wxCursorRefData(); | |
37 | ||
38 | GdkCursor *m_cursor; | |
39 | }; | |
40 | ||
41 | wxCursorRefData::wxCursorRefData() | |
42 | { | |
43 | m_cursor = (GdkCursor *) NULL; | |
44 | } | |
45 | ||
46 | wxCursorRefData::~wxCursorRefData() | |
47 | { | |
48 | if (m_cursor) gdk_cursor_destroy( m_cursor ); | |
49 | } | |
50 | ||
51 | //----------------------------------------------------------------------------- | |
52 | ||
53 | #define M_CURSORDATA ((wxCursorRefData *)m_refData) | |
54 | ||
55 | IMPLEMENT_DYNAMIC_CLASS(wxCursor,wxObject) | |
56 | ||
57 | wxCursor::wxCursor() | |
58 | { | |
59 | ||
60 | } | |
61 | ||
62 | wxCursor::wxCursor( int cursorId ) | |
63 | { | |
64 | m_refData = new wxCursorRefData(); | |
65 | ||
66 | GdkCursorType gdk_cur = GDK_LEFT_PTR; | |
67 | switch (cursorId) | |
68 | { | |
69 | case wxCURSOR_BLANK: | |
70 | { | |
71 | static const gchar bits[] = { 0 }; | |
72 | static /* const -- not in GTK1 */ GdkColor color = { 0, 0, 0, 0 }; | |
73 | ||
74 | GdkPixmap *pixmap = gdk_bitmap_create_from_data(NULL, bits, 1, 1); | |
75 | M_CURSORDATA->m_cursor = gdk_cursor_new_from_pixmap(pixmap, | |
76 | pixmap, | |
77 | &color, | |
78 | &color, | |
79 | 0, 0); | |
80 | } | |
81 | return; | |
82 | ||
83 | case wxCURSOR_ARROW: // fall through to default | |
84 | case wxCURSOR_DEFAULT: gdk_cur = GDK_LEFT_PTR; break; | |
85 | case wxCURSOR_RIGHT_ARROW: gdk_cur = GDK_RIGHT_PTR; break; | |
86 | case wxCURSOR_HAND: gdk_cur = GDK_HAND1; break; | |
87 | case wxCURSOR_CROSS: gdk_cur = GDK_CROSSHAIR; break; | |
88 | case wxCURSOR_SIZEWE: gdk_cur = GDK_SB_H_DOUBLE_ARROW; break; | |
89 | case wxCURSOR_SIZENS: gdk_cur = GDK_SB_V_DOUBLE_ARROW; break; | |
90 | case wxCURSOR_ARROWWAIT: | |
91 | case wxCURSOR_WAIT: | |
92 | case wxCURSOR_WATCH: gdk_cur = GDK_WATCH; break; | |
93 | case wxCURSOR_SIZING: gdk_cur = GDK_SIZING; break; | |
94 | case wxCURSOR_SPRAYCAN: gdk_cur = GDK_SPRAYCAN; break; | |
95 | case wxCURSOR_IBEAM: gdk_cur = GDK_XTERM; break; | |
96 | case wxCURSOR_PENCIL: gdk_cur = GDK_PENCIL; break; | |
97 | case wxCURSOR_NO_ENTRY: gdk_cur = GDK_PIRATE; break; | |
98 | case wxCURSOR_SIZENWSE: | |
99 | case wxCURSOR_SIZENESW: gdk_cur = GDK_FLEUR; break; | |
100 | case wxCURSOR_QUESTION_ARROW: gdk_cur = GDK_QUESTION_ARROW; break; | |
101 | case wxCURSOR_PAINT_BRUSH: gdk_cur = GDK_SPRAYCAN; break; | |
102 | case wxCURSOR_MAGNIFIER: gdk_cur = GDK_PLUS; break; | |
103 | case wxCURSOR_CHAR: gdk_cur = GDK_XTERM; break; | |
104 | case wxCURSOR_LEFT_BUTTON: gdk_cur = GDK_LEFTBUTTON; break; | |
105 | case wxCURSOR_MIDDLE_BUTTON: gdk_cur = GDK_MIDDLEBUTTON; break; | |
106 | case wxCURSOR_RIGHT_BUTTON: gdk_cur = GDK_RIGHTBUTTON; break; | |
107 | case wxCURSOR_BULLSEYE: gdk_cur = GDK_TARGET; break; | |
108 | ||
109 | case wxCURSOR_POINT_LEFT: gdk_cur = GDK_SB_LEFT_ARROW; break; | |
110 | case wxCURSOR_POINT_RIGHT: gdk_cur = GDK_SB_RIGHT_ARROW; break; | |
111 | /* | |
112 | case wxCURSOR_DOUBLE_ARROW: gdk_cur = GDK_DOUBLE_ARROW; break; | |
113 | case wxCURSOR_CROSS_REVERSE: gdk_cur = GDK_CROSS_REVERSE; break; | |
114 | case wxCURSOR_BASED_ARROW_UP: gdk_cur = GDK_BASED_ARROW_UP; break; | |
115 | case wxCURSOR_BASED_ARROW_DOWN: gdk_cur = GDK_BASED_ARROW_DOWN; break; | |
116 | */ | |
117 | ||
118 | default: | |
119 | wxFAIL_MSG(wxT("unsupported cursor type")); | |
120 | // will use the standard one | |
121 | break; | |
122 | } | |
123 | ||
124 | M_CURSORDATA->m_cursor = gdk_cursor_new( gdk_cur ); | |
125 | } | |
126 | ||
127 | extern GtkWidget *wxGetRootWindow(); | |
128 | ||
129 | wxCursor::wxCursor(const char bits[], int width, int height, | |
130 | int hotSpotX, int hotSpotY, | |
131 | const char maskBits[], wxColour *fg, wxColour *bg) | |
132 | { | |
133 | if (!maskBits) | |
134 | maskBits = bits; | |
135 | if (!fg) | |
136 | fg = wxBLACK; | |
137 | if (!bg) | |
138 | bg = wxWHITE; | |
139 | if (hotSpotX < 0 || hotSpotX >= width) | |
140 | hotSpotX = 0; | |
141 | if (hotSpotY < 0 || hotSpotY >= height) | |
142 | hotSpotY = 0; | |
143 | ||
144 | GdkBitmap *data = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) bits, width, height ); | |
145 | GdkBitmap *mask = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) maskBits, width, height); | |
146 | ||
147 | m_refData = new wxCursorRefData; | |
148 | M_CURSORDATA->m_cursor = gdk_cursor_new_from_pixmap( | |
149 | data, mask, fg->GetColor(), bg->GetColor(), | |
150 | hotSpotX, hotSpotY ); | |
151 | ||
152 | gdk_bitmap_unref( data ); | |
153 | gdk_bitmap_unref( mask ); | |
154 | } | |
155 | ||
156 | ||
157 | wxCursor::wxCursor( const wxCursor &cursor ) | |
158 | : wxObject() | |
159 | { | |
160 | Ref( cursor ); | |
161 | } | |
162 | ||
163 | #if wxUSE_IMAGE | |
164 | ||
165 | wxCursor::wxCursor( const wxImage & image ) | |
166 | { | |
167 | unsigned char * rgbBits = image.GetData(); | |
168 | int w = image.GetWidth() ; | |
169 | int h = image.GetHeight(); | |
170 | bool bHasMask = image.HasMask(); | |
171 | int imagebitcount = (w*h)/8; | |
172 | ||
173 | unsigned char * bits = new unsigned char [imagebitcount]; | |
174 | unsigned char * maskBits = new unsigned char [imagebitcount]; | |
175 | ||
176 | int i, j, i8; unsigned char c, cMask; | |
177 | for (i=0; i<imagebitcount; i++) | |
178 | { | |
179 | bits[i] = 0; | |
180 | i8 = i * 8; | |
181 | ||
182 | cMask = 1; | |
183 | for (j=0; j<8; j++) | |
184 | { | |
185 | // possible overflow if we do the summation first ? | |
186 | c = rgbBits[(i8+j)*3]/3 + rgbBits[(i8+j)*3+1]/3 + rgbBits[(i8+j)*3+2]/3; | |
187 | //if average value is > mid grey | |
188 | if (c>127) | |
189 | bits[i] = bits[i] | cMask; | |
190 | cMask = cMask * 2; | |
191 | } | |
192 | } | |
193 | ||
194 | unsigned long keyMaskColor; | |
195 | if (bHasMask) | |
196 | { | |
197 | unsigned char | |
198 | r = image.GetMaskRed(), | |
199 | g = image.GetMaskGreen(), | |
200 | b = image.GetMaskBlue(); | |
201 | ||
202 | for (i=0; i<imagebitcount; i++) | |
203 | { | |
204 | maskBits[i] = 0x0; | |
205 | i8 = i * 8; | |
206 | ||
207 | cMask = 1; | |
208 | for (j=0; j<8; j++) | |
209 | { | |
210 | if (rgbBits[(i8+j)*3] != r || rgbBits[(i8+j)*3+1] != g || rgbBits[(i8+j)*3+2] != b) | |
211 | maskBits[i] = maskBits[i] | cMask; | |
212 | cMask = cMask * 2; | |
213 | } | |
214 | } | |
215 | ||
216 | keyMaskColor = (r << 16) | (g << 8) | b; | |
217 | } | |
218 | else // no mask | |
219 | { | |
220 | for (i=0; i<imagebitcount; i++) | |
221 | maskBits[i] = 0xFF; | |
222 | ||
223 | // init it to avoid compiler warnings | |
224 | keyMaskColor = 0; | |
225 | } | |
226 | ||
227 | // find the most frequent color(s) | |
228 | wxImageHistogram histogram; | |
229 | image.ComputeHistogram(histogram); | |
230 | ||
231 | // colors as rrggbb | |
232 | unsigned long key; | |
233 | unsigned long value; | |
234 | ||
235 | long colMostFreq = 0; | |
236 | unsigned long nMost = 0; | |
237 | long colNextMostFreq = 0; | |
238 | unsigned long nNext = 0; | |
239 | for ( wxImageHistogram::iterator entry = histogram.begin(); | |
240 | entry != histogram.end(); | |
241 | ++entry ) | |
242 | { | |
243 | value = entry->second.value; | |
244 | key = entry->first; | |
245 | if ( !bHasMask || (key != keyMaskColor) ) | |
246 | { | |
247 | if (value > nMost) | |
248 | { | |
249 | nMost = value; | |
250 | colMostFreq = key; | |
251 | } | |
252 | else if (value > nNext) | |
253 | { | |
254 | nNext = value; | |
255 | colNextMostFreq = key; | |
256 | } | |
257 | } | |
258 | } | |
259 | ||
260 | wxColour fg = wxColour ( (unsigned char)(colMostFreq >> 16), | |
261 | (unsigned char)(colMostFreq >> 8), | |
262 | (unsigned char)(colMostFreq) ); | |
263 | ||
264 | wxColour bg = wxColour ( (unsigned char)(colNextMostFreq >> 16), | |
265 | (unsigned char)(colNextMostFreq >> 8), | |
266 | (unsigned char)(colNextMostFreq) ); | |
267 | ||
268 | int fg_intensity = fg.Red() + fg.Green() + fg.Blue(); | |
269 | int bg_intensity = bg.Red() + bg.Green() + bg.Blue(); | |
270 | ||
271 | if (bg_intensity > fg_intensity) | |
272 | { | |
273 | //swap fg and bg | |
274 | wxColour tmp = fg; | |
275 | fg = bg; | |
276 | bg = tmp; | |
277 | } | |
278 | ||
279 | int hotSpotX; | |
280 | int hotSpotY; | |
281 | ||
282 | if (image.HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X)) | |
283 | hotSpotX = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X); | |
284 | else | |
285 | hotSpotX = 0; | |
286 | ||
287 | if (image.HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y)) | |
288 | hotSpotY = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y); | |
289 | else | |
290 | hotSpotY = 0; | |
291 | ||
292 | if (hotSpotX < 0 || hotSpotX >= w) | |
293 | hotSpotX = 0; | |
294 | if (hotSpotY < 0 || hotSpotY >= h) | |
295 | hotSpotY = 0; | |
296 | ||
297 | GdkBitmap *data = gdk_bitmap_create_from_data(wxGetRootWindow()->window, | |
298 | (gchar *) bits, w, h); | |
299 | GdkBitmap *mask = gdk_bitmap_create_from_data(wxGetRootWindow()->window, | |
300 | (gchar *) maskBits, w, h); | |
301 | ||
302 | m_refData = new wxCursorRefData; | |
303 | M_CURSORDATA->m_cursor = gdk_cursor_new_from_pixmap | |
304 | ( | |
305 | data, | |
306 | mask, | |
307 | fg.GetColor(), bg.GetColor(), | |
308 | hotSpotX, hotSpotY | |
309 | ); | |
310 | ||
311 | gdk_bitmap_unref( data ); | |
312 | gdk_bitmap_unref( mask ); | |
313 | delete [] bits; | |
314 | delete [] maskBits; | |
315 | } | |
316 | ||
317 | #endif // wxUSE_IMAGE | |
318 | ||
319 | wxCursor::~wxCursor() | |
320 | { | |
321 | } | |
322 | ||
323 | wxCursor& wxCursor::operator = ( const wxCursor& cursor ) | |
324 | { | |
325 | if (*this == cursor) | |
326 | return (*this); | |
327 | ||
328 | Ref( cursor ); | |
329 | ||
330 | return *this; | |
331 | } | |
332 | ||
333 | bool wxCursor::operator == ( const wxCursor& cursor ) const | |
334 | { | |
335 | return m_refData == cursor.m_refData; | |
336 | } | |
337 | ||
338 | bool wxCursor::operator != ( const wxCursor& cursor ) const | |
339 | { | |
340 | return m_refData != cursor.m_refData; | |
341 | } | |
342 | ||
343 | bool wxCursor::Ok() const | |
344 | { | |
345 | return (m_refData != NULL); | |
346 | } | |
347 | ||
348 | GdkCursor *wxCursor::GetCursor() const | |
349 | { | |
350 | return M_CURSORDATA->m_cursor; | |
351 | } | |
352 | ||
353 | //----------------------------------------------------------------------------- | |
354 | // busy cursor routines | |
355 | //----------------------------------------------------------------------------- | |
356 | ||
357 | extern wxCursor g_globalCursor; | |
358 | ||
359 | static wxCursor gs_savedCursor; | |
360 | static int gs_busyCount = 0; | |
361 | ||
362 | const wxCursor &wxBusyCursor::GetStoredCursor() | |
363 | { | |
364 | return gs_savedCursor; | |
365 | } | |
366 | ||
367 | const wxCursor wxBusyCursor::GetBusyCursor() | |
368 | { | |
369 | return wxCursor(wxCURSOR_WATCH); | |
370 | } | |
371 | ||
372 | void wxEndBusyCursor() | |
373 | { | |
374 | if (--gs_busyCount > 0) | |
375 | return; | |
376 | ||
377 | wxSetCursor( gs_savedCursor ); | |
378 | gs_savedCursor = wxNullCursor; | |
379 | ||
380 | if (wxTheApp) | |
381 | wxTheApp->ProcessIdle(); | |
382 | } | |
383 | ||
384 | void wxBeginBusyCursor( wxCursor *WXUNUSED(cursor) ) | |
385 | { | |
386 | if (gs_busyCount++ > 0) | |
387 | return; | |
388 | ||
389 | wxASSERT_MSG( !gs_savedCursor.Ok(), | |
390 | wxT("forgot to call wxEndBusyCursor, will leak memory") ); | |
391 | ||
392 | gs_savedCursor = g_globalCursor; | |
393 | ||
394 | wxSetCursor( wxCursor(wxCURSOR_WATCH) ); | |
395 | ||
396 | if (wxTheApp) | |
397 | wxTheApp->ProcessIdle(); | |
398 | ||
399 | gdk_flush(); | |
400 | } | |
401 | ||
402 | bool wxIsBusy() | |
403 | { | |
404 | return gs_busyCount > 0; | |
405 | } | |
406 | ||
407 | void wxSetCursor( const wxCursor& cursor ) | |
408 | { | |
409 | if (g_isIdle) | |
410 | wxapp_install_idle_handler(); | |
411 | ||
412 | g_globalCursor = cursor; | |
413 | } |