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