]> git.saurik.com Git - wxWidgets.git/blobdiff - src/motif/cursor.cpp
Regenerated some more makefiles/filelists.
[wxWidgets.git] / src / motif / cursor.cpp
index 24c94be559871dd43c2d9bc53262307d50e05ffd..72425e23d85c41c0dc8a7a1308bf98c3700fd01f 100644 (file)
 #endif
 
 #include "wx/cursor.h"
 #endif
 
 #include "wx/cursor.h"
-#include "wx/gdicmn.h"
-#include "wx/icon.h"
 #include "wx/app.h"
 #include "wx/utils.h"
 #include "wx/app.h"
 #include "wx/utils.h"
-
+#include "wx/list.h"
+#include "wx/window.h"
+#if wxUSE_IMAGE
+#include "wx/image.h"
+#endif                                                                      
+
+#ifdef __VMS__
+#pragma message disable nosimpint
+#endif
 #include <Xm/Xm.h>
 #include <X11/cursorfont.h>
 #include <Xm/Xm.h>
 #include <X11/cursorfont.h>
+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif
 
 #include "wx/motif/private.h"
 
 
 #include "wx/motif/private.h"
 
-#if !USE_SHARED_LIBRARIES
-IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
-IMPLEMENT_DYNAMIC_CLASS(wxXCursor, wxObject)
-#endif
+// Cursor for one display, so we can choose the correct one for
+// the current display.
+class wxXCursor
+{
+public:
+    WXDisplay*  m_display;
+    WXCursor    m_cursor;
+};
+
+WX_DECLARE_LIST(wxXCursor, wxXCursorList);
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxXCursorList);
+
+class WXDLLEXPORT wxCursorRefData: public wxObjectRefData
+{
+    friend class WXDLLEXPORT wxCursor;
+public:
+    wxCursorRefData();
+    ~wxCursorRefData();
+    
+    wxXCursorList m_cursors;  // wxXCursor objects, one per display
+    wxStockCursor m_cursorId; // wxWindows standard cursor id
+};
+
+#define M_CURSORDATA ((wxCursorRefData *)m_refData)
+#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData)
+
+IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxObject)
 
 wxCursorRefData::wxCursorRefData()
 {
 
 wxCursorRefData::wxCursorRefData()
 {
-    m_width = 32; m_height = 32;
     m_cursorId = wxCURSOR_NONE;
 }
 
 wxCursorRefData::~wxCursorRefData()
 {
     m_cursorId = wxCURSOR_NONE;
 }
 
 wxCursorRefData::~wxCursorRefData()
 {
-    wxNode* node = m_cursors.First();
+    wxXCursorList::Node* node = m_cursors.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxXCursor* c = (wxXCursor*) node->Data();
-        // TODO: how to delete cursor?
-        // XDestroyCursor((Display*) c->m_display, (Cursor) c->m_cursor); // ??
+        wxXCursor* c = node->GetData();
+        XFreeCursor((Display*) c->m_display, (Cursor) c->m_cursor);
         delete c;
         delete c;
-        node = node->Next();
+        node = node->GetNext();
     }
 }
 
     }
 }
 
@@ -52,6 +83,133 @@ wxCursor::wxCursor()
 {
 }
 
 {
 }
 
+#if wxUSE_IMAGE
+wxCursor::wxCursor(const wxImage & image)
+{
+    unsigned char * rgbBits = image.GetData();
+    int w = image.GetWidth() ;
+    int h = image.GetHeight();
+    bool bHasMask = image.HasMask();
+    int imagebitcount = (w*h)/8;
+
+    unsigned char * bits = new unsigned char [imagebitcount];
+    unsigned char * maskBits = new unsigned char [imagebitcount];
+
+    int i, j, i8; unsigned char c, cMask;
+    for (i=0; i<imagebitcount; i++)
+    {
+        bits[i] = 0;
+        i8 = i * 8;
+
+        cMask = 1;
+        for (j=0; j<8; j++)
+        {
+            // possible overflow if we do the summation first ?
+            c = rgbBits[(i8+j)*3]/3 + rgbBits[(i8+j)*3+1]/3 + rgbBits[(i8+j)*3+2]/3;
+            //if average value is > mid grey
+            if (c>127)
+                bits[i] = bits[i] | cMask;
+            cMask = cMask * 2;
+        }
+    }
+
+    if (bHasMask)
+    {
+        unsigned char
+            r = image.GetMaskRed(),
+            g = image.GetMaskGreen(),
+            b = image.GetMaskBlue();
+
+        for (i=0; i<imagebitcount; i++)
+        {
+            maskBits[i] = 0x0;
+            i8 = i * 8;
+
+            cMask = 1;
+            for (j=0; j<8; j++)
+            {
+                if (rgbBits[(i8+j)*3] != r || rgbBits[(i8+j)*3+1] != g || rgbBits[(i8+j)*3+2] != b)
+                    maskBits[i] = maskBits[i] | cMask;
+                cMask = cMask * 2;
+            }
+        }
+    }
+    else // no mask
+    {
+        for (i=0; i<imagebitcount; i++)
+            maskBits[i] = 0xFF;
+    }
+
+    int hotSpotX;
+    int hotSpotY;
+
+    if (image.HasOption(wxCUR_HOTSPOT_X))
+        hotSpotX = image.GetOptionInt(wxCUR_HOTSPOT_X);
+    else
+        hotSpotX = 0;
+
+    if (image.HasOption(wxCUR_HOTSPOT_Y))
+        hotSpotY = image.GetOptionInt(wxCUR_HOTSPOT_Y);
+    else
+        hotSpotY = 0;
+
+    if (hotSpotX < 0 || hotSpotX >= w)
+        hotSpotX = 0;
+    if (hotSpotY < 0 || hotSpotY >= h)
+        hotSpotY = 0;
+   
+    m_refData = new wxCursorRefData;
+
+    Display *dpy = (Display*) wxGetDisplay();
+    int screen_num =  DefaultScreen (dpy);
+
+    Pixmap pixmap = XCreatePixmapFromBitmapData (dpy,
+                                          RootWindow (dpy, DefaultScreen(dpy)),
+                                          (char*) bits, w, h,
+                                          1 , 0 , 1);
+
+    Pixmap mask_pixmap = None;
+    if (maskBits != NULL)
+    {
+        mask_pixmap = XCreatePixmapFromBitmapData (dpy,
+                                          RootWindow (dpy, DefaultScreen(dpy)),
+                                          (char*) maskBits, w, h,
+                                          1 , 0 , 1);
+    }
+
+    XColor foreground_color;
+    XColor background_color;
+    foreground_color.pixel = BlackPixel(dpy, screen_num);
+    background_color.pixel = WhitePixel(dpy, screen_num);
+    Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
+    XQueryColor(dpy, cmap, &foreground_color);
+    XQueryColor(dpy, cmap, &background_color);
+
+    Cursor cursor = XCreatePixmapCursor (dpy,
+                                  pixmap,
+                                  mask_pixmap,
+                                  &foreground_color,
+                                  &background_color,
+                                  hotSpotX , 
+                                  hotSpotY);
+
+    XFreePixmap( dpy, pixmap );
+    if (mask_pixmap != None)
+    {
+        XFreePixmap( dpy, mask_pixmap );
+    }
+
+    if (cursor)
+    {
+        wxXCursor *c = new wxXCursor;
+
+        c->m_cursor = (WXCursor) cursor;
+        c->m_display = (WXDisplay*) dpy;
+        M_CURSORDATA->m_cursors.Append(c);
+    }
+}
+#endif
+
 wxCursor::wxCursor(const char bits[], int width, int height,
     int hotSpotX, int hotSpotY, const char maskBits[])
 {
 wxCursor::wxCursor(const char bits[], int width, int height,
     int hotSpotX, int hotSpotY, const char maskBits[])
 {
@@ -103,11 +261,6 @@ wxCursor::wxCursor(const char bits[], int width, int height,
         c->m_cursor = (WXCursor) cursor;
         c->m_display = (WXDisplay*) dpy;
         M_CURSORDATA->m_cursors.Append(c);
         c->m_cursor = (WXCursor) cursor;
         c->m_display = (WXDisplay*) dpy;
         M_CURSORDATA->m_cursors.Append(c);
-        M_CURSORDATA->m_ok = TRUE;
-    }
-    else
-    {
-        M_CURSORDATA->m_ok = TRUE;
     }
 }
 
     }
 }
 
@@ -127,11 +280,8 @@ wxCursor::wxCursor(const wxString& name, long flags, int hotSpotX, int hotSpotY)
     int screen_num =  DefaultScreen (dpy);
 
     int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
     int screen_num =  DefaultScreen (dpy);
 
     int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-                        (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
-
-    M_BITMAPDATA->m_width = w;
-    M_BITMAPDATA->m_height = h;
-    M_BITMAPDATA->m_depth = 1;
+                                 wxConstCast(name.c_str(), char),
+                                 &w, &h, &pixmap, &hotX, &hotY);
 
     if ((value == BitmapFileInvalid) ||
         (value == BitmapOpenFailed) ||
 
     if ((value == BitmapFileInvalid) ||
         (value == BitmapOpenFailed) ||
@@ -177,7 +327,6 @@ wxCursor::wxCursor(const wxString& name, long flags, int hotSpotX, int hotSpotY)
             c->m_cursor = (WXCursor) cursor;
             c->m_display = (WXDisplay*) dpy;
             M_CURSORDATA->m_cursors.Append(c);
             c->m_cursor = (WXCursor) cursor;
             c->m_display = (WXDisplay*) dpy;
             M_CURSORDATA->m_cursors.Append(c);
-            M_CURSORDATA->m_ok = TRUE;
         }
     }
 
         }
     }
 
@@ -188,34 +337,29 @@ wxCursor::wxCursor(wxStockCursor id)
 {
     m_refData = new wxCursorRefData;
     M_CURSORDATA->m_cursorId = id;
 {
     m_refData = new wxCursorRefData;
     M_CURSORDATA->m_cursorId = id;
-
-    WXCursor cursor = GetXCursor(wxGetDisplay());
-    if (cursor)
-    {
-        wxXCursor* c = new wxXCursor;
-        c->m_cursor = cursor;
-        c->m_display = wxGetDisplay();
-        M_CURSORDATA->m_cursors.Append(c);
-        M_CURSORDATA->m_ok = TRUE;
-    }
 }
 
 wxCursor::~wxCursor()
 {
 }
 
 }
 
 wxCursor::~wxCursor()
 {
 }
 
+bool wxCursor::Ok() const
+{
+    return m_refData != NULL;
+}
+
 // Motif-specific: create/get a cursor for the current display
 WXCursor wxCursor::GetXCursor(WXDisplay* display)
 {
     if (!M_CURSORDATA)
         return (WXCursor) 0;
 // Motif-specific: create/get a cursor for the current display
 WXCursor wxCursor::GetXCursor(WXDisplay* display)
 {
     if (!M_CURSORDATA)
         return (WXCursor) 0;
-    wxNode* node = M_CURSORDATA->m_cursors.First();
+    wxXCursorList::Node* node = M_CURSORDATA->m_cursors.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxXCursor* c = (wxXCursor*) node->Data();
+        wxXCursor* c = node->GetData();
         if (c->m_display == display)
             return c->m_cursor;
         if (c->m_display == display)
             return c->m_cursor;
-        node = node->Next();
+        node = node->GetNext();
     }
 
     // No cursor for this display, so let's see if we're an id-type cursor.
     }
 
     // No cursor for this display, so let's see if we're an id-type cursor.
@@ -244,188 +388,167 @@ WXCursor wxCursor::MakeCursor(WXDisplay* display, wxStockCursor id)
 {
     Display* dpy = (Display*) display;
     Cursor cursor = (Cursor) 0;
 {
     Display* dpy = (Display*) display;
     Cursor cursor = (Cursor) 0;
+    int x_cur = -1;
 
     switch (id)
     {
 
     switch (id)
     {
-        case wxCURSOR_WAIT:
-        {
-            cursor = XCreateFontCursor (dpy, XC_watch);
-            break;
-        }
-        case wxCURSOR_CROSS:
-        {
-            cursor = XCreateFontCursor (dpy, XC_crosshair);
-            break;
-        }
-        case wxCURSOR_CHAR:
-        {
-            // Nothing
-            break;
-        }
-        case wxCURSOR_HAND:
-        {
-            cursor = XCreateFontCursor (dpy, XC_hand1);
-            break;
-        }
-        case wxCURSOR_BULLSEYE:
-        {
-            cursor = XCreateFontCursor (dpy, XC_target);
-            break;
-        }
-        case wxCURSOR_PENCIL:
-       {
-            cursor = XCreateFontCursor (dpy, XC_pencil);
-            break;
-        }
-        case wxCURSOR_MAGNIFIER:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sizing);
-            break;
-        }
-        case wxCURSOR_IBEAM:
-        {
-            cursor = XCreateFontCursor (dpy, XC_xterm);
-            break;
-        }
-        case wxCURSOR_NO_ENTRY:
-        {
-            cursor = XCreateFontCursor (dpy, XC_pirate);
-            break;
-        }
-        case wxCURSOR_LEFT_BUTTON:
-        {
-            cursor = XCreateFontCursor (dpy, XC_leftbutton);
-            break;
-        }
-        case wxCURSOR_RIGHT_BUTTON:
-        {
-            cursor = XCreateFontCursor (dpy, XC_rightbutton);
-            break;
-        }
-        case wxCURSOR_MIDDLE_BUTTON:
-        {
-            cursor = XCreateFontCursor (dpy, XC_middlebutton);
-            break;
-        }
-        case wxCURSOR_QUESTION_ARROW:
-        {
-            cursor = XCreateFontCursor (dpy, XC_question_arrow);
-            break;
-        }
-        case wxCURSOR_SIZING:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sizing);
-            break;
-        }
-        case wxCURSOR_WATCH:
-        {
-            cursor = XCreateFontCursor (dpy, XC_watch);
-            break;
-        }
-        case wxCURSOR_SPRAYCAN:
-        {
-            cursor = XCreateFontCursor (dpy, XC_spraycan);
-            break;
-        }
-        case wxCURSOR_PAINT_BRUSH:
-        {
-            cursor = XCreateFontCursor (dpy, XC_spraycan);
-            break;
-        }
-        case wxCURSOR_SIZENWSE:
-        case wxCURSOR_SIZENESW:
-        {
-            // Not available in X
-            cursor = XCreateFontCursor (dpy, XC_crosshair);
-            break;
-        }
-        case wxCURSOR_SIZEWE:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
-            break;
-        }
-        case wxCURSOR_SIZENS:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_v_double_arrow);
-            break;
-        }
-        case wxCURSOR_POINT_LEFT:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_left_arrow);
-            break;
-        }
-        case wxCURSOR_POINT_RIGHT:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_right_arrow);
-            break;
-        }
+    case wxCURSOR_WAIT:             x_cur = XC_watch; break;
+    case wxCURSOR_CROSS:            x_cur = XC_crosshair; break; 
+    case wxCURSOR_CHAR:                       return (WXCursor)cursor; break;
+    case wxCURSOR_HAND:             x_cur = XC_hand1; break;
+    case wxCURSOR_BULLSEYE:         x_cur = XC_target; break;
+    case wxCURSOR_PENCIL:           x_cur = XC_pencil; break; 
+    case wxCURSOR_MAGNIFIER:        x_cur = XC_sizing; break; 
+    case wxCURSOR_IBEAM:            x_cur = XC_xterm; break; 
+    case wxCURSOR_NO_ENTRY:         x_cur = XC_pirate; break;
+    case wxCURSOR_LEFT_BUTTON:      x_cur = XC_leftbutton; break; 
+    case wxCURSOR_RIGHT_BUTTON:     x_cur = XC_rightbutton; break; 
+    case wxCURSOR_MIDDLE_BUTTON:    x_cur =  XC_middlebutton; break;
+    case wxCURSOR_QUESTION_ARROW:   x_cur = XC_question_arrow; break;
+    case wxCURSOR_SIZING:           x_cur = XC_sizing; break;
+    case wxCURSOR_WATCH:            x_cur = XC_watch; break;
+    case wxCURSOR_SPRAYCAN:         x_cur = XC_spraycan; break;
+    case wxCURSOR_PAINT_BRUSH:      x_cur = XC_spraycan; break;
+    case wxCURSOR_SIZENWSE:
+    case wxCURSOR_SIZENESW:         x_cur = XC_crosshair; break;
+    case wxCURSOR_SIZEWE:           x_cur = XC_sb_h_double_arrow; break;
+    case wxCURSOR_SIZENS:           x_cur = XC_sb_v_double_arrow; break;
+    case wxCURSOR_POINT_LEFT:       x_cur = XC_sb_left_arrow; break;
+    case wxCURSOR_POINT_RIGHT:      x_cur = XC_sb_right_arrow; break;
         // (JD Huggins) added more stock cursors for X
         // X-only cursors BEGIN
         // (JD Huggins) added more stock cursors for X
         // X-only cursors BEGIN
-        case wxCURSOR_CROSS_REVERSE:
-        {
-            cursor = XCreateFontCursor(dpy, XC_cross_reverse);
-            break;
-        }
-        case wxCURSOR_DOUBLE_ARROW:
-        {
-            cursor = XCreateFontCursor(dpy, XC_double_arrow);
-            break;
-        }
-        case wxCURSOR_BASED_ARROW_UP:
-        {
-            cursor = XCreateFontCursor(dpy, XC_based_arrow_up);
-            break;
-        }
-        case wxCURSOR_BASED_ARROW_DOWN:
-        {
-            cursor = XCreateFontCursor(dpy, XC_based_arrow_down);
-            break;
-        }
-        default:
-        case wxCURSOR_ARROW:
-        {
-            cursor = XCreateFontCursor (dpy, XC_top_left_arrow);
-            break;
-        }
-        case wxCURSOR_BLANK:
-        {
-            GC gc;
-            XGCValues gcv;
-            Pixmap empty_pixmap;
-            XColor blank_color;
-
-            empty_pixmap = XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-                              16, 16, 1);
-            gcv.function = GXxor;
-            gc = XCreateGC (dpy,
-                    empty_pixmap,
-                    GCFunction,
-                    &gcv);
-            XCopyArea (dpy,
+    case wxCURSOR_CROSS_REVERSE:    x_cur = XC_cross_reverse; break;
+    case wxCURSOR_DOUBLE_ARROW:     x_cur = XC_double_arrow; break;
+    case wxCURSOR_BASED_ARROW_UP:   x_cur = XC_based_arrow_up; break;
+    case wxCURSOR_BASED_ARROW_DOWN: x_cur = XC_based_arrow_down; break;
+    case wxCURSOR_BLANK:
+    {
+        GC gc;
+        XGCValues gcv;
+        Pixmap empty_pixmap;
+        XColor blank_color;
+
+        empty_pixmap =
+            XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
+                           16, 16, 1);
+        gcv.function = GXxor;
+        gc = XCreateGC (dpy,
+                        empty_pixmap,
+                        GCFunction,
+                        &gcv);
+        XCopyArea (dpy,
                    empty_pixmap,
                    empty_pixmap,
                    gc,
                    0, 0,
                    16, 16,
                    0, 0);
                    empty_pixmap,
                    empty_pixmap,
                    gc,
                    0, 0,
                    16, 16,
                    0, 0);
-            XFreeGC (dpy, gc);
-            cursor = XCreatePixmapCursor (dpy,
-                            empty_pixmap,
-                            empty_pixmap,
-                            &blank_color,
-                            &blank_color,
-                            8, 8);
-
-            break;
-        }
+        XFreeGC (dpy, gc);
+        cursor = XCreatePixmapCursor (dpy,
+                                      empty_pixmap,
+                                      empty_pixmap,
+                                      &blank_color,
+                                      &blank_color,
+                                      8, 8);
+
+        break;
+    }
+    case wxCURSOR_ARROW:
+    default:       x_cur =  XC_top_left_arrow; break;
     }
     }
+
+    if( x_cur == -1 )
+        return (WXCursor)cursor;
+
+    cursor = XCreateFontCursor (dpy, x_cur);
     return (WXCursor) cursor;
 }
 
 // Global cursor setting
     return (WXCursor) cursor;
 }
 
 // Global cursor setting
-void wxSetCursor(const wxCursor& cursor)
+void wxSetCursor(const wxCursor& WXUNUSED(cursor))
 {
   // Nothing to do for Motif (no global cursor)
 }
 
 
 {
   // Nothing to do for Motif (no global cursor)
 }
 
 
+// ----------------------------------------------------------------------------
+// busy cursor stuff
+// ----------------------------------------------------------------------------
+
+static int wxBusyCursorCount = 0;
+
+// Helper function
+static void
+wxXSetBusyCursor (wxWindow * win, wxCursor * cursor)
+{
+    Display *display = (Display*) win->GetXDisplay();
+
+    Window xwin = (Window) win->GetXWindow();
+    if (!xwin)
+       return;
+
+    XSetWindowAttributes attrs;
+
+    if (cursor)
+    {
+        attrs.cursor = (Cursor) cursor->GetXCursor(display);
+    }
+    else
+    {
+        // Restore old cursor
+        if (win->GetCursor().Ok())
+            attrs.cursor = (Cursor) win->GetCursor().GetXCursor(display);
+        else
+            attrs.cursor = None;
+    }
+    if (xwin)
+        XChangeWindowAttributes (display, xwin, CWCursor, &attrs);
+
+    XFlush (display);
+
+    for(wxWindowList::Node *node = win->GetChildren().GetFirst (); node; 
+        node = node->GetNext())
+    {
+        wxWindow *child = node->GetData ();
+        wxXSetBusyCursor (child, cursor);
+    }
+}
+
+// Set the cursor to the busy cursor for all windows
+void wxBeginBusyCursor(wxCursor *cursor)
+{
+    wxBusyCursorCount++;
+    if (wxBusyCursorCount == 1)
+    {
+        for(wxWindowList::Node *node = wxTopLevelWindows.GetFirst (); node;
+            node = node->GetNext())
+        {
+            wxWindow *win = node->GetData ();
+            wxXSetBusyCursor (win, cursor);
+        }
+    }
+}
+
+// Restore cursor to normal
+void wxEndBusyCursor()
+{
+    if (wxBusyCursorCount == 0)
+        return;
+
+    wxBusyCursorCount--;
+    if (wxBusyCursorCount == 0)
+    {
+        for(wxWindowList::Node *node = wxTopLevelWindows.GetFirst (); node;
+            node = node->GetNext())
+        {
+            wxWindow *win = node->GetData ();
+            wxXSetBusyCursor (win, NULL);
+        }
+    }
+}
+
+// TRUE if we're between the above two calls
+bool wxIsBusy()
+{
+    return (wxBusyCursorCount > 0);
+}