src/motif/cursor.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/motif/cursor.cpp
   3 // Purpose:     wxCursor class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/list.h"
  17 #endif
  18
  19 #include "wx/cursor.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/app.h"
  23     #include "wx/utils.h"
  24     #include "wx/window.h"
  25     #include "wx/image.h"
  26 #endif
  27
  28 #ifdef __VMS__
  29 #pragma message disable nosimpint
  30 #endif
  31 #include <Xm/Xm.h>
  32 #include <X11/cursorfont.h>
  33 #ifdef __VMS__
  34 #pragma message enable nosimpint
  35 #endif
  36
  37 #include "wx/motif/private.h"
  38
  39 // Cursor for one display, so we can choose the correct one for
  40 // the current display.
  41 class wxXCursor
  42 {
  43 public:
  44     WXDisplay*  m_display;
  45     WXCursor    m_cursor;
  46 };
  47
  48 WX_DECLARE_LIST(wxXCursor, wxXCursorList);
  49 #include "wx/listimpl.cpp"
  50 WX_DEFINE_LIST(wxXCursorList)
  51
  52 class WXDLLEXPORT wxCursorRefData: public wxGDIRefData
  53 {
  54 public:
  55     wxCursorRefData();
  56     virtual ~wxCursorRefData();
  57
  58     wxXCursorList m_cursors;  // wxXCursor objects, one per display
  59     wxStockCursor m_cursorId; // wxWidgets standard cursor id
  60
  61     friend class wxCursor;
  62 };
  63
  64 #define M_CURSORDATA ((wxCursorRefData *)m_refData)
  65 #define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData)
  66
  67 IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxObject)
  68
  69 wxCursorRefData::wxCursorRefData()
  70 {
  71     m_cursorId = wxCURSOR_NONE;
  72 }
  73
  74 wxCursorRefData::~wxCursorRefData()
  75 {
  76     wxXCursorList::compatibility_iterator node = m_cursors.GetFirst();
  77     while (node)
  78     {
  79         wxXCursor* c = node->GetData();
  80         XFreeCursor((Display*) c->m_display, (Cursor) c->m_cursor);
  81         delete c;
  82         node = node->GetNext();
  83     }
  84 }
  85
  86 wxCursor::wxCursor()
  87 {
  88 }
  89
  90 #if wxUSE_IMAGE
  91 wxCursor::wxCursor(const wxImage & image)
  92 {
  93     unsigned char * rgbBits = image.GetData();
  94     int w = image.GetWidth() ;
  95     int h = image.GetHeight();
  96     bool bHasMask = image.HasMask();
  97     int imagebitcount = (w*h)/8;
  98
  99     unsigned char * bits = new unsigned char [imagebitcount];
 100     unsigned char * maskBits = new unsigned char [imagebitcount];
 101
 102     int i, j, i8;
 103     unsigned char c, cMask;
 104     for (i=0; i<imagebitcount; i++)
 105     {
 106         bits[i] = 0xff;
 107         i8 = i * 8;
 108
 109         cMask = 0xfe; // 11111110
 110         for (j=0; j<8; j++)
 111         {
 112             // possible overflow if we do the summation first ?
 113             c = (unsigned char)(rgbBits[(i8+j)*3]/3 + rgbBits[(i8+j)*3+1]/3 + rgbBits[(i8+j)*3+2]/3);
 114             // if average value is > mid grey
 115             if (c>127)
 116                 bits[i] = bits[i] & cMask;
 117             cMask = (unsigned char)((cMask << 1) | 1);
 118         }
 119     }
 120
 121     if (bHasMask)
 122     {
 123         unsigned char
 124             r = image.GetMaskRed(),
 125             g = image.GetMaskGreen(),
 126             b = image.GetMaskBlue();
 127
 128         for (i=0; i<imagebitcount; i++)
 129         {
 130             maskBits[i] = 0x0;
 131             i8 = i * 8;
 132
 133             cMask = 0x1;
 134             for (j=0; j<8; j++)
 135             {
 136                 if (rgbBits[(i8+j)*3] != r || rgbBits[(i8+j)*3+1] != g || rgbBits[(i8+j)*3+2] != b)
 137                     maskBits[i] = maskBits[i] | cMask;
 138                 cMask = (unsigned char)(cMask << 1);
 139             }
 140         }
 141     }
 142     else // no mask
 143     {
 144         for (i=0; i<imagebitcount; i++)
 145             maskBits[i] = 0xFF;
 146     }
 147
 148     int hotSpotX;
 149     int hotSpotY;
 150
 151     if (image.HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X))
 152         hotSpotX = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
 153     else
 154         hotSpotX = 0;
 155
 156     if (image.HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y))
 157         hotSpotY = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
 158     else
 159         hotSpotY = 0;
 160
 161     if (hotSpotX < 0 || hotSpotX >= w)
 162         hotSpotX = 0;
 163     if (hotSpotY < 0 || hotSpotY >= h)
 164         hotSpotY = 0;
 165
 166     Create( (const char*)bits, w, h, hotSpotX, hotSpotY,
 167             (const char*)maskBits );
 168
 169     delete[] bits;
 170     delete[] maskBits;
 171 }
 172 #endif
 173
 174 void wxCursor::Create(const char bits[], int width, int height,
 175                       int hotSpotX, int hotSpotY, const char maskBits[])
 176 {
 177     if( !m_refData )
 178         m_refData = new wxCursorRefData;
 179
 180     Display *dpy = (Display*) wxGetDisplay();
 181     int screen_num =  DefaultScreen (dpy);
 182
 183     Pixmap pixmap = XCreatePixmapFromBitmapData (dpy,
 184                                           RootWindow (dpy, screen_num),
 185                                           (char*) bits, width, height,
 186                                           1 , 0 , 1);
 187
 188     Pixmap mask_pixmap = None;
 189     if (maskBits != NULL)
 190     {
 191         mask_pixmap = XCreatePixmapFromBitmapData (dpy,
 192                                           RootWindow (dpy, screen_num),
 193                                           (char*) maskBits, width, height,
 194                                           1 , 0 , 1);
 195     }
 196
 197     Create( (WXPixmap)pixmap, (WXPixmap)mask_pixmap, hotSpotX, hotSpotY );
 198
 199     XFreePixmap( dpy, pixmap );
 200     if (mask_pixmap != None)
 201     {
 202         XFreePixmap( dpy, mask_pixmap );
 203     }
 204 }
 205
 206 void wxCursor::Create(WXPixmap pixmap, WXPixmap mask_pixmap,
 207                       int hotSpotX, int hotSpotY)
 208 {
 209     if( !m_refData )
 210         m_refData = new wxCursorRefData;
 211
 212     Display *dpy = (Display*) wxGetDisplay();
 213     int screen_num =  DefaultScreen (dpy);
 214
 215     XColor foreground_color;
 216     XColor background_color;
 217     foreground_color.pixel = BlackPixel(dpy, screen_num);
 218     background_color.pixel = WhitePixel(dpy, screen_num);
 219     Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
 220     XQueryColor(dpy, cmap, &foreground_color);
 221     XQueryColor(dpy, cmap, &background_color);
 222
 223     Cursor cursor = XCreatePixmapCursor (dpy,
 224                                   (Pixmap)pixmap,
 225                                   (Pixmap)mask_pixmap,
 226                                   &foreground_color,
 227                                   &background_color,
 228                                   hotSpotX ,
 229                                   hotSpotY);
 230
 231     if (cursor)
 232     {
 233         wxXCursor *c = new wxXCursor;
 234
 235         c->m_cursor = (WXCursor) cursor;
 236         c->m_display = (WXDisplay*) dpy;
 237         M_CURSORDATA->m_cursors.Append(c);
 238     }
 239 }
 240
 241 wxCursor::wxCursor(const char bits[], int width, int height,
 242                    int hotSpotX, int hotSpotY, const char maskBits[] ,
 243                    const wxColour* WXUNUSED(fg), const wxColour* WXUNUSED(bg) )
 244 {
 245     Create(bits, width, height, hotSpotX, hotSpotY, maskBits);
 246 }
 247
 248 wxCursor::wxCursor(const wxString& name, wxBitmapType type, int hotSpotX,
 249                    int hotSpotY )
 250 {
 251     // Must be an XBM file
 252     if (type != wxBITMAP_TYPE_XBM) {
 253         wxLogError("Invalid cursor bitmap type '%d'", type);
 254         return;
 255     }
 256
 257     m_refData = new wxCursorRefData;
 258
 259     int hotX = -1, hotY = -1;
 260     unsigned int w, h;
 261     Pixmap pixmap = None, mask_pixmap = None;
 262
 263     Display *dpy = (Display*) wxGetDisplay();
 264     int screen_num =  DefaultScreen (dpy);
 265
 266     int value = XReadBitmapFile (dpy, RootWindow (dpy, screen_num),
 267                                  name.mb_str(),
 268                                  &w, &h, &pixmap, &hotX, &hotY);
 269
 270     if (value == BitmapSuccess)
 271     {
 272         // TODO: how do we determine whether hotX, hotY were read correctly?
 273         if (hotX < 0 || hotY < 0)
 274         {
 275             hotX = hotSpotX;
 276             hotY = hotSpotY;
 277         }
 278         if (hotX < 0 || hotY < 0)
 279         {
 280             hotX = 0;
 281             hotY = 0;
 282         }
 283
 284         Create( (WXPixmap)pixmap, (WXPixmap)mask_pixmap, hotX, hotY );
 285
 286         XFreePixmap( dpy, pixmap );
 287     }
 288 }
 289
 290 // Cursors by stock number
 291 void wxCursor::InitFromStock(wxStockCursor id)
 292 {
 293     m_refData = new wxCursorRefData;
 294     M_CURSORDATA->m_cursorId = id;
 295 }
 296
 297 wxCursor::~wxCursor()
 298 {
 299 }
 300
 301 wxGDIRefData *wxCursor::CreateGDIRefData() const
 302 {
 303     return new wxCursorRefData;
 304 }
 305
 306 wxGDIRefData *wxCursor::CloneGDIRefData(const wxGDIRefData *data) const
 307 {
 308     return new wxCursorRefData(*static_cast<const wxCursorRefData *>(data));
 309 }
 310
 311 // Motif-specific: create/get a cursor for the current display
 312 WXCursor wxCursor::GetXCursor(WXDisplay* display) const
 313 {
 314     if (!M_CURSORDATA)
 315         return (WXCursor) 0;
 316     wxXCursorList::compatibility_iterator node = M_CURSORDATA->m_cursors.GetFirst();
 317     while (node)
 318     {
 319         wxXCursor* c = node->GetData();
 320         if (c->m_display == display)
 321             return c->m_cursor;
 322         node = node->GetNext();
 323     }
 324
 325     // No cursor for this display, so let's see if we're an id-type cursor.
 326
 327     if (M_CURSORDATA->m_cursorId != wxCURSOR_NONE)
 328     {
 329         WXCursor cursor = MakeCursor(display, M_CURSORDATA->m_cursorId);
 330         if (cursor)
 331         {
 332             wxXCursor* c = new wxXCursor;
 333             c->m_cursor = cursor;
 334             c->m_display = display;
 335             M_CURSORDATA->m_cursors.Append(c);
 336             return cursor;
 337         }
 338         else
 339             return (WXCursor) 0;
 340     }
 341
 342     // Not an id-type cursor, so we don't know how to create it.
 343     return (WXCursor) 0;
 344 }
 345
 346 // Make a cursor from standard id
 347 WXCursor wxCursor::MakeCursor(WXDisplay* display, wxStockCursor id) const
 348 {
 349     Display* dpy = (Display*) display;
 350     Cursor cursor = (Cursor) 0;
 351     int x_cur = -1;
 352
 353     switch (id)
 354     {
 355     case wxCURSOR_CHAR:             return (WXCursor)cursor;
 356
 357     case wxCURSOR_WAIT:             x_cur = XC_watch; break;
 358     case wxCURSOR_CROSS:            x_cur = XC_crosshair; break;
 359     case wxCURSOR_HAND:             x_cur = XC_hand1; break;
 360     case wxCURSOR_BULLSEYE:         x_cur = XC_target; break;
 361     case wxCURSOR_PENCIL:           x_cur = XC_pencil; break;
 362     case wxCURSOR_MAGNIFIER:        x_cur = XC_sizing; break;
 363     case wxCURSOR_IBEAM:            x_cur = XC_xterm; break;
 364     case wxCURSOR_NO_ENTRY:         x_cur = XC_pirate; break;
 365     case wxCURSOR_LEFT_BUTTON:      x_cur = XC_leftbutton; break;
 366     case wxCURSOR_RIGHT_BUTTON:     x_cur = XC_rightbutton; break;
 367     case wxCURSOR_MIDDLE_BUTTON:    x_cur =  XC_middlebutton; break;
 368     case wxCURSOR_QUESTION_ARROW:   x_cur = XC_question_arrow; break;
 369     case wxCURSOR_SIZING:           x_cur = XC_sizing; break;
 370     case wxCURSOR_WATCH:            x_cur = XC_watch; break;
 371     case wxCURSOR_SPRAYCAN:         x_cur = XC_spraycan; break;
 372     case wxCURSOR_PAINT_BRUSH:      x_cur = XC_spraycan; break;
 373     case wxCURSOR_SIZENWSE:
 374     case wxCURSOR_SIZENESW:         x_cur = XC_crosshair; break;
 375     case wxCURSOR_SIZEWE:           x_cur = XC_sb_h_double_arrow; break;
 376     case wxCURSOR_SIZENS:           x_cur = XC_sb_v_double_arrow; break;
 377     case wxCURSOR_POINT_LEFT:       x_cur = XC_sb_left_arrow; break;
 378     case wxCURSOR_POINT_RIGHT:      x_cur = XC_sb_right_arrow; break;
 379         // (JD Huggins) added more stock cursors for X
 380         // X-only cursors BEGIN
 381     case wxCURSOR_CROSS_REVERSE:    x_cur = XC_cross_reverse; break;
 382     case wxCURSOR_DOUBLE_ARROW:     x_cur = XC_double_arrow; break;
 383     case wxCURSOR_BASED_ARROW_UP:   x_cur = XC_based_arrow_up; break;
 384     case wxCURSOR_BASED_ARROW_DOWN: x_cur = XC_based_arrow_down; break;
 385     case wxCURSOR_BLANK:
 386     {
 387         GC gc;
 388         XGCValues gcv;
 389         Pixmap empty_pixmap;
 390         XColor blank_color;
 391
 392         empty_pixmap =
 393             XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
 394                            16, 16, 1);
 395         gcv.function = GXxor;
 396         gc = XCreateGC (dpy,
 397                         empty_pixmap,
 398                         GCFunction,
 399                         &gcv);
 400         XCopyArea (dpy,
 401                    empty_pixmap,
 402                    empty_pixmap,
 403                    gc,
 404                    0, 0,
 405                    16, 16,
 406                    0, 0);
 407         XFreeGC (dpy, gc);
 408         cursor = XCreatePixmapCursor (dpy,
 409                                       empty_pixmap,
 410                                       empty_pixmap,
 411                                       &blank_color,
 412                                       &blank_color,
 413                                       8, 8);
 414
 415         break;
 416     }
 417     case wxCURSOR_ARROW:
 418     default:       x_cur =  XC_top_left_arrow; break;
 419     }
 420
 421     if( x_cur == -1 )
 422         return (WXCursor)cursor;
 423
 424     cursor = XCreateFontCursor (dpy, x_cur);
 425     return (WXCursor) cursor;
 426 }
 427
 428 // Global cursor setting
 429 void wxSetCursor(const wxCursor& WXUNUSED(cursor))
 430 {
 431   // Nothing to do for Motif (no global cursor)
 432 }
 433
 434
 435 // ----------------------------------------------------------------------------
 436 // busy cursor stuff
 437 // ----------------------------------------------------------------------------
 438
 439 static int wxBusyCursorCount = 0;
 440
 441 // Helper function
 442 static void
 443 wxXSetBusyCursor (wxWindow * win, const wxCursor * cursor)
 444 {
 445     Display *display = (Display*) win->GetXDisplay();
 446
 447     Window xwin = (Window) win->GetXWindow();
 448     if (!xwin)
 449        return;
 450
 451     XSetWindowAttributes attrs;
 452
 453     if (cursor)
 454     {
 455         attrs.cursor = (Cursor) cursor->GetXCursor(display);
 456     }
 457     else
 458     {
 459         // Restore old cursor
 460         if (win->GetCursor().Ok())
 461             attrs.cursor = (Cursor) win->GetCursor().GetXCursor(display);
 462         else
 463             attrs.cursor = None;
 464     }
 465     if (xwin)
 466         XChangeWindowAttributes (display, xwin, CWCursor, &attrs);
 467
 468     XFlush (display);
 469
 470     for(wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst (); node;
 471         node = node->GetNext())
 472     {
 473         wxWindow *child = node->GetData ();
 474         wxXSetBusyCursor (child, cursor);
 475     }
 476 }
 477
 478 // Set the cursor to the busy cursor for all windows
 479 void wxBeginBusyCursor(const wxCursor *cursor)
 480 {
 481     wxBusyCursorCount++;
 482     if (wxBusyCursorCount == 1)
 483     {
 484         for(wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst (); node;
 485             node = node->GetNext())
 486         {
 487             wxWindow *win = node->GetData ();
 488             wxXSetBusyCursor (win, cursor);
 489         }
 490     }
 491 }
 492
 493 // Restore cursor to normal
 494 void wxEndBusyCursor()
 495 {
 496     if (wxBusyCursorCount == 0)
 497         return;
 498
 499     wxBusyCursorCount--;
 500     if (wxBusyCursorCount == 0)
 501     {
 502         for(wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst (); node;
 503             node = node->GetNext())
 504         {
 505             wxWindow *win = node->GetData ();
 506             wxXSetBusyCursor (win, NULL);
 507         }
 508     }
 509 }
 510
 511 // true if we're between the above two calls
 512 bool wxIsBusy()
 513 {
 514     return (wxBusyCursorCount > 0);
 515 }