]> git.saurik.com Git - wxWidgets.git/blobdiff - src/x11/utils.cpp
A bit of scrolling works under GTK 2.0
[wxWidgets.git] / src / x11 / utils.cpp
index d6b5b7df84cbdb8623b8ea6f94f95d273eec6320..fc15ff0ce18e9336a9b6bccf17efad4ad88a90f8 100644 (file)
 #pragma message disable nosimpint
 #endif
 
 #pragma message disable nosimpint
 #endif
 
-#ifdef __VMS__
-#pragma message enable nosimpint
-#endif
-
 #include "wx/unix/execute.h"
 
 #include "wx/unix/execute.h"
 
+#ifdef __WXMOTIF__
+#include <Xm/Xm.h>
+#include "wx/motif/private.h"
+#endif
+
+#ifdef __WXX11__
 #include "wx/x11/private.h"
 #include "wx/x11/private.h"
+#endif
+
+#if wxUSE_RESOURCES
 #include "X11/Xresource.h"
 #include "X11/Xresource.h"
+#endif
+
 #include "X11/Xutil.h"
 
 #include "X11/Xutil.h"
 
+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif
+
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
@@ -83,11 +94,8 @@ void wxFlushEvents()
     Display *display = (Display*) wxGetDisplay();
 
     XSync (display, FALSE);
     Display *display = (Display*) wxGetDisplay();
 
     XSync (display, FALSE);
-    XFlush(display);
 
 
-    // TODO
-#if 0
-    
+#ifdef __WXMOTIF__   
     // XtAppPending returns availability of events AND timers/inputs, which
     // are processed via callbacks, so XtAppNextEvent will not return if
     // there are no events. So added '& XtIMXEvent' - Sergey.
     // XtAppPending returns availability of events AND timers/inputs, which
     // are processed via callbacks, so XtAppNextEvent will not return if
     // there are no events. So added '& XtIMXEvent' - Sergey.
@@ -98,15 +106,17 @@ void wxFlushEvents()
         XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMXEvent);
     }
 #endif
         XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMXEvent);
     }
 #endif
+#ifdef __WXX11__
+    // TODO for X11
+    // ??
+#endif
 }
 
 // Check whether this window wants to process messages, e.g. Stop button
 // in long calculations.
 bool wxCheckForInterrupt(wxWindow *wnd)
 {
 }
 
 // Check whether this window wants to process messages, e.g. Stop button
 // in long calculations.
 bool wxCheckForInterrupt(wxWindow *wnd)
 {
-    wxASSERT_MSG(FALSE, "wxCheckForInterrupt not yet implemented.");
-    return FALSE;
-#if 0
+#ifdef __WXMOTIF__
     wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
 
     Display *dpy=(Display*) wnd->GetXDisplay();
     wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
 
     Display *dpy=(Display*) wnd->GetXDisplay();
@@ -133,13 +143,16 @@ bool wxCheckForInterrupt(wxWindow *wnd)
     }
 
     return hadEvents;
     }
 
     return hadEvents;
+#else
+    wxASSERT_MSG(FALSE, "wxCheckForInterrupt not yet implemented.");
+    return FALSE;
 #endif
 }
 
 // ----------------------------------------------------------------------------
 // wxExecute stuff
 // ----------------------------------------------------------------------------
 #endif
 }
 
 // ----------------------------------------------------------------------------
 // wxExecute stuff
 // ----------------------------------------------------------------------------
-#if 0
+#ifdef __WXMOTIF__
 static void xt_notify_end_process(XtPointer data, int *WXUNUSED(fid),
                                   XtInputId *id)
 {
 static void xt_notify_end_process(XtPointer data, int *WXUNUSED(fid),
                                   XtInputId *id)
 {
@@ -152,9 +165,11 @@ static void xt_notify_end_process(XtPointer data, int *WXUNUSED(fid),
 
     XtRemoveInput(*id);
 }
 
     XtRemoveInput(*id);
 }
+#endif
 
 int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
 {
 
 int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
 {
+#ifdef __WXMOTIF__
     XtInputId id = XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
                                  fd,
                                  (XtPointer *) XtInputReadMask,
     XtInputId id = XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
                                  fd,
                                  (XtPointer *) XtInputReadMask,
@@ -162,8 +177,12 @@ int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
                                  (XtPointer) proc_data);
 
     return (int)id;
                                  (XtPointer) proc_data);
 
     return (int)id;
-}
 #endif
 #endif
+#ifdef __WXX11__
+    // TODO
+    return 0;
+#endif
+}
 
 // ----------------------------------------------------------------------------
 // misc
 
 // ----------------------------------------------------------------------------
 // misc
@@ -178,7 +197,7 @@ void wxBell()
 
 int wxGetOsVersion(int *majorVsn, int *minorVsn)
 {
 
 int wxGetOsVersion(int *majorVsn, int *minorVsn)
 {
-#if 0
+#ifdef __WXMOTIF__
     // FIXME TODO
     // This code is WRONG!! Does NOT return the
     // Motif version of the libs but the X protocol
     // FIXME TODO
     // This code is WRONG!! Does NOT return the
     // Motif version of the libs but the X protocol
@@ -190,7 +209,8 @@ int wxGetOsVersion(int *majorVsn, int *minorVsn)
         *minorVsn = ProtocolRevision (display);
 
     return wxMOTIF_X;
         *minorVsn = ProtocolRevision (display);
 
     return wxMOTIF_X;
-#else
+#endif
+#ifdef __WXX11__
     if (majorVsn)
         *majorVsn = 0;
     if (minorVsn)
     if (majorVsn)
         *majorVsn = 0;
     if (minorVsn)
@@ -542,91 +562,17 @@ wxSetDefaultResources (const Widget w, const char **resourceSpec, const char *na
 
 #endif // wxUSE_RESOURCES
 
 
 #endif // wxUSE_RESOURCES
 
-// ----------------------------------------------------------------------------
-// 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(wxNode *node = win->GetChildren().First (); node; node = node->Next())
-    {
-        wxWindow *child = (wxWindow *) node->Data ();
-        wxXSetBusyCursor (child, cursor);
-    }
-}
-
-// Set the cursor to the busy cursor for all windows
-void wxBeginBusyCursor(wxCursor *cursor)
-{
-    wxBusyCursorCount++;
-    if (wxBusyCursorCount == 1)
-    {
-        for(wxNode *node = wxTopLevelWindows.First (); node; node = node->Next())
-        {
-            wxWindow *win = (wxWindow *) node->Data ();
-            wxXSetBusyCursor (win, cursor);
-        }
-    }
-}
-
-// Restore cursor to normal
-void wxEndBusyCursor()
-{
-    if (wxBusyCursorCount == 0)
-        return;
-
-    wxBusyCursorCount--;
-    if (wxBusyCursorCount == 0)
-    {
-        for(wxNode *node = wxTopLevelWindows.First (); node; node = node->Next())
-        {
-            wxWindow *win = (wxWindow *) node->Data ();
-            wxXSetBusyCursor (win, NULL);
-        }
-    }
-}
-
-// TRUE if we're between the above two calls
-bool wxIsBusy()
-{
-    return (wxBusyCursorCount > 0);
-}
-
 // ----------------------------------------------------------------------------
 // display info
 // ----------------------------------------------------------------------------
 
 void wxGetMousePosition( int* x, int* y )
 {
 // ----------------------------------------------------------------------------
 // display info
 // ----------------------------------------------------------------------------
 
 void wxGetMousePosition( int* x, int* y )
 {
+#if wxUSE_NANOX
+    // TODO
+    *x = 0;
+    *y = 0;
+#else
     XMotionEvent xev;
     Window root, child;
     XQueryPointer((Display*) wxGetDisplay(),
     XMotionEvent xev;
     Window root, child;
     XQueryPointer((Display*) wxGetDisplay(),
@@ -637,6 +583,7 @@ void wxGetMousePosition( int* x, int* y )
                   &(xev.state));
     *x = xev.x_root;
     *y = xev.y_root;
                   &(xev.state));
     *x = xev.x_root;
     *y = xev.y_root;
+#endif
 };
 
 // Return TRUE if we have a colour display
 };
 
 // Return TRUE if we have a colour display
@@ -686,7 +633,7 @@ void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 }
 
 
 }
 
 
-// Configurable display in X11
+// Configurable display in wxX11 and wxMotif
 static WXDisplay *gs_currentDisplay = NULL;
 static wxString gs_displayName;
 
 static WXDisplay *gs_currentDisplay = NULL;
 static wxString gs_displayName;
 
@@ -694,10 +641,16 @@ WXDisplay *wxGetDisplay()
 {
     if (gs_currentDisplay)
         return gs_currentDisplay;
 {
     if (gs_currentDisplay)
         return gs_currentDisplay;
+#ifdef __WXMOTIF__
+    if (wxTheApp && wxTheApp->GetTopLevelWidget())
+        return XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());
     else if (wxTheApp)
         return wxTheApp->GetInitialDisplay();
     else if (wxTheApp)
         return wxTheApp->GetInitialDisplay();
-    else
-        return (WXDisplay*) NULL;
+    return NULL;
+#endif
+#ifdef __WXX11__
+    return wxApp::GetDisplay();
+#endif
 }
 
 bool wxSetDisplay(const wxString& display_name)
 }
 
 bool wxSetDisplay(const wxString& display_name)
@@ -712,7 +665,20 @@ bool wxSetDisplay(const wxString& display_name)
     }
     else
     {
     }
     else
     {
-        Display* display = XOpenDisplay((const char*) display_name);
+#ifdef __WXMOTIF__
+        Cardinal argc = 0;
+
+        Display *display = XtOpenDisplay((XtAppContext) wxTheApp->GetAppContext(),
+            (const char*) display_name,
+            (const char*) wxTheApp->GetAppName(),
+            (const char*) wxTheApp->GetClassName(),
+            NULL,
+#if XtSpecificationRelease < 5
+            0, &argc,
+#else
+            0, (int *)&argc,
+#endif
+            NULL);
 
         if (display)
         {
 
         if (display)
         {
@@ -721,6 +687,18 @@ bool wxSetDisplay(const wxString& display_name)
         }
         else
             return FALSE;
         }
         else
             return FALSE;
+#endif
+#ifdef __WXX11__
+        Display* display = XOpenDisplay((char*) display_name.c_str());
+
+        if (display)
+        {
+            gs_currentDisplay = (WXDisplay*) display;
+            return TRUE;
+        }
+        else
+            return FALSE;
+#endif
     }
 }
 
     }
 }
 
@@ -734,90 +712,6 @@ wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
     return wxGenericFindWindowAtPoint(pt);
 }
 
     return wxGenericFindWindowAtPoint(pt);
 }
 
-// ----------------------------------------------------------------------------
-// accelerators
-// ----------------------------------------------------------------------------
-
-// Find the letter corresponding to the mnemonic, for Motif
-char wxFindMnemonic (const char *s)
-{
-    char mnem = 0;
-    int len = strlen (s);
-    int i;
-    for (i = 0; i < len; i++)
-    {
-        if (s[i] == '&')
-        {
-            // Carefully handle &&
-            if ((i + 1) <= len && s[i + 1] == '&')
-                i++;
-            else
-            {
-                mnem = s[i + 1];
-                break;
-            }
-        }
-    }
-    return mnem;
-}
-
-char * wxFindAccelerator (const char *s)
-{
-    // VZ: this function returns incorrect keysym which completely breaks kbd
-    //     handling
-    return NULL;
-
-#if 0
-   // The accelerator text is after the \t char.
-    while (*s && *s != '\t')
-        s++;
-    if (*s == '\0')
-        return (NULL);
-    s++;
-    /*
-    Now we need to format it as X standard:
-
-      input            output
-
-        F7           --> <Key>F7
-        Ctrl+N       --> Ctrl<Key>N
-        Alt+k        --> Meta<Key>k
-        Ctrl+Shift+A --> Ctrl Shift<Key>A
-
-    */
-
-    wxBuffer[0] = '\0';
-    char *tmp = copystring (s);
-    s = tmp;
-    char *p = tmp;
-
-    while (1)
-    {
-        while (*p && *p != '+')
-            p++;
-        if (*p)
-        {
-            *p = '\0';
-            if (wxBuffer[0])
-                strcat (wxBuffer, " ");
-            if (strcmp (s, "Alt"))
-                strcat (wxBuffer, s);
-            else
-                strcat (wxBuffer, "Meta");
-            s = p++;
-        }
-        else
-        {
-            strcat (wxBuffer, "<Key>");
-            strcat (wxBuffer, s);
-            break;
-        }
-    }
-    delete[]tmp;
-    return wxBuffer;
-#endif
-}
-
 // ----------------------------------------------------------------------------
 // keycode translations
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // keycode translations
 // ----------------------------------------------------------------------------
@@ -1127,6 +1021,7 @@ void wxXColorToHSV(wxHSV *hsv,XColor *rgb)
 
 void wxAllocNearestColor(Display *d,Colormap cmp,XColor *xc)
 {
 
 void wxAllocNearestColor(Display *d,Colormap cmp,XColor *xc)
 {
+#if !wxUSE_NANOX
     int llp;
 
     int screen = DefaultScreen(d);
     int llp;
 
     int screen = DefaultScreen(d);
@@ -1163,6 +1058,7 @@ void wxAllocNearestColor(Display *d,Colormap cmp,XColor *xc)
 */
 
     delete[] color_defs;
 */
 
     delete[] color_defs;
+#endif
 }
 
 void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
 }
 
 void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
@@ -1174,3 +1070,185 @@ void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
     }
 }
 
     }
 }
 
+#ifdef __WXDEBUG__
+wxString wxGetXEventName(XEvent& event)
+{
+#if wxUSE_NANOX
+    wxString str(wxT("(some event)"));
+    return str;
+#else
+    int type = event.xany.type;
+           static char* event_name[] = {
+               "", "unknown(-)",                                         // 0-1
+               "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease", // 2-5
+               "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn",  // 6-9
+               "FocusOut", "KeymapNotify", "Expose", "GraphicsExpose",   // 10-13
+               "NoExpose", "VisibilityNotify", "CreateNotify",           // 14-16
+               "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",// 17-20
+               "ReparentNotify", "ConfigureNotify", "ConfigureRequest",  // 21-23
+               "GravityNotify", "ResizeRequest", "CirculateNotify",      // 24-26
+               "CirculateRequest", "PropertyNotify", "SelectionClear",   // 27-29
+               "SelectionRequest", "SelectionNotify", "ColormapNotify",  // 30-32
+               "ClientMessage", "MappingNotify",                         // 33-34
+               "unknown(+)"};                                            // 35
+           type = wxMin(35, type); type = wxMax(1, type);
+        wxString str(event_name[type]);
+        return str;
+#endif
+}
+#endif
+
+#ifdef __WXMOTIF__
+// ----------------------------------------------------------------------------
+// accelerators
+// ----------------------------------------------------------------------------
+
+// Find the letter corresponding to the mnemonic, for Motif
+char wxFindMnemonic (const char *s)
+{
+    char mnem = 0;
+    int len = strlen (s);
+    int i;
+    for (i = 0; i < len; i++)
+    {
+        if (s[i] == '&')
+        {
+            // Carefully handle &&
+            if ((i + 1) <= len && s[i + 1] == '&')
+                i++;
+            else
+            {
+                mnem = s[i + 1];
+                break;
+            }
+        }
+    }
+    return mnem;
+}
+
+char * wxFindAccelerator (const char *s)
+{
+    // VZ: this function returns incorrect keysym which completely breaks kbd
+    //     handling
+    return NULL;
+
+#if 0
+   // The accelerator text is after the \t char.
+    while (*s && *s != '\t')
+        s++;
+    if (*s == '\0')
+        return (NULL);
+    s++;
+    /*
+    Now we need to format it as X standard:
+
+      input            output
+
+        F7           --> <Key>F7
+        Ctrl+N       --> Ctrl<Key>N
+        Alt+k        --> Meta<Key>k
+        Ctrl+Shift+A --> Ctrl Shift<Key>A
+
+    */
+
+    static char buf[256];
+    buf[0] = '\0';
+    char *tmp = copystring (s);
+    s = tmp;
+    char *p = tmp;
+
+    while (1)
+    {
+        while (*p && *p != '+')
+            p++;
+        if (*p)
+        {
+            *p = '\0';
+            if (buf[0])
+                strcat (buf, " ");
+            if (strcmp (s, "Alt"))
+                strcat (buf, s);
+            else
+                strcat (buf, "Meta");
+            s = p++;
+        }
+        else
+        {
+            strcat (buf, "<Key>");
+            strcat (buf, s);
+            break;
+        }
+    }
+    delete[]tmp;
+    return buf;
+#endif
+}
+
+XmString wxFindAcceleratorText (const char *s)
+{
+    // VZ: this function returns incorrect keysym which completely breaks kbd
+    //     handling
+    return NULL;
+
+#if 0
+   // The accelerator text is after the \t char.
+    while (*s && *s != '\t')
+        s++;
+    if (*s == '\0')
+        return (NULL);
+    s++;
+    XmString text = XmStringCreateSimple ((char *)s);
+    return text;
+#endif
+}
+
+
+// These functions duplicate those in wxWindow, but are needed
+// for use outside of wxWindow (e.g. wxMenu, wxMenuBar).
+
+// Change a widget's foreground and background colours.
+
+void wxDoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
+{
+    // When should we specify the foreground, if it's calculated
+    // by wxComputeColours?
+    // Solution: say we start with the default (computed) foreground colour.
+    // If we call SetForegroundColour explicitly for a control or window,
+    // then the foreground is changed.
+    // Therefore SetBackgroundColour computes the foreground colour, and
+    // SetForegroundColour changes the foreground colour. The ordering is
+    // important.
+
+    XtVaSetValues ((Widget) widget,
+        XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)),
+        NULL);
+}
+
+void wxDoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
+{
+    wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
+        (wxColour*) NULL);
+
+    XtVaSetValues ((Widget) widget,
+        XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
+        XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
+        XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
+        XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
+        NULL);
+
+    if (changeArmColour)
+        XtVaSetValues ((Widget) widget,
+        XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
+        NULL);
+}
+
+#endif
+    // __WXMOTIF__
+
+bool wxWindowIsVisible(Window win)
+{
+    XWindowAttributes wa;
+    XGetWindowAttributes(wxGlobalDisplay(), win, &wa);
+
+    return (wa.map_state == IsViewable);
+}