[wxWidgets.git] / src / x11 / utils.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        utils.cpp
// Purpose:     Various utilities
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "wx/setup.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/msgdlg.h"
#include "wx/cursor.h"
#include "wx/window.h" // for wxTopLevelWindows

#include <ctype.h>
#include <stdarg.h>
#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <pwd.h>
#include <errno.h>
// #include <netdb.h>
#include <signal.h>

#if (defined(__SUNCC__) || defined(__CLCC__))
    #include <sysent.h>
#endif

#ifdef __VMS__
#pragma message disable nosimpint
#endif

#include "wx/unix/execute.h"

#include "wx/x11/private.h"

#include "X11/Xutil.h"

#ifdef __VMS__
#pragma message enable nosimpint
#endif

// ----------------------------------------------------------------------------
// async event processing
// ----------------------------------------------------------------------------

// Consume all events until no more left
void wxFlushEvents()
{
    Display *display = (Display*) wxGetDisplay();

    XSync (display, FALSE);

#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.
    while (XtAppPending ((XtAppContext) wxTheApp->GetAppContext()) & XtIMXEvent)
    {
        XFlush (XtDisplay ((Widget) wxTheApp->GetTopLevelWidget()));
        // Jan Lessner: works better when events are non-X events
        XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMXEvent);
    }
#endif
#ifdef __WXX11__
    // TODO for X11
    // ??
#endif
}

bool wxCheckForInterrupt(wxWindow *wnd)
{
#ifdef __WXMOTIF__
    wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );

    Display *dpy=(Display*) wnd->GetXDisplay();
    Window win=(Window) wnd->GetXWindow();
    XEvent event;
    XFlush(dpy);
    if (wnd->GetMainWidget())
    {
        XmUpdateDisplay((Widget)(wnd->GetMainWidget()));
    }

    bool hadEvents = FALSE;
    while( XCheckMaskEvent(dpy,
                           ButtonPressMask|ButtonReleaseMask|ButtonMotionMask|
                           PointerMotionMask|KeyPressMask|KeyReleaseMask,
                           &event) )
    {
        if ( event.xany.window == win )
        {
            hadEvents = TRUE;

            XtDispatchEvent(&event);
        }
    }

    return hadEvents;
#else
    wxASSERT_MSG(FALSE, "wxCheckForInterrupt not yet implemented.");
    return FALSE;
#endif
}

// ----------------------------------------------------------------------------
// wxExecute stuff
// ----------------------------------------------------------------------------

int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
{
#ifdef __WXMOTIF__
    XtInputId id = XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
                                 fd,
                                 (XtPointer *) XtInputReadMask,
                                 (XtInputCallbackProc) xt_notify_end_process,
                                 (XtPointer) proc_data);

    return (int)id;
#endif
#ifdef __WXX11__
    // TODO
    return 0;
#endif
}

// ----------------------------------------------------------------------------
// misc
// ----------------------------------------------------------------------------

// Emit a beeeeeep
void wxBell()
{
    // Use current setting for the bell
    XBell ((Display*) wxGetDisplay(), 0);
}

int wxGetOsVersion(int *majorVsn, int *minorVsn)
{
#ifdef __WXX11__
    if (majorVsn)
        *majorVsn = 0;
        
    if (minorVsn)
        *minorVsn = 0;
        
    return wxX11;
#endif
}

// ----------------------------------------------------------------------------
// 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(),
                  DefaultRootWindow((Display*) wxGetDisplay()),
                  &root, &child,
                  &(xev.x_root), &(xev.y_root),
                  &(xev.x),      &(xev.y),
                  &(xev.state));
    *x = xev.x_root;
    *y = xev.y_root;
#endif
};

// Return TRUE if we have a colour display
bool wxColourDisplay()
{
    return wxDisplayDepth() > 1;
}

// Returns depth of screen
int wxDisplayDepth()
{
    Display *dpy = (Display*) wxGetDisplay();

    return DefaultDepth (dpy, DefaultScreen (dpy));
}

// Get size of display
void wxDisplaySize(int *width, int *height)
{
    Display *dpy = (Display*) wxGetDisplay();

    if ( width )
        *width = DisplayWidth (dpy, DefaultScreen (dpy));
    if ( height )
        *height = DisplayHeight (dpy, DefaultScreen (dpy));
}

void wxDisplaySizeMM(int *width, int *height)
{
    Display *dpy = (Display*) wxGetDisplay();

    if ( width )
        *width = DisplayWidthMM(dpy, DefaultScreen (dpy));
    if ( height )
        *height = DisplayHeightMM(dpy, DefaultScreen (dpy));
}

void wxClientDisplayRect(int *x, int *y, int *width, int *height)
{
    // This is supposed to return desktop dimensions minus any window
    // manager panels, menus, taskbars, etc.  If there is a way to do that
    // for this platform please fix this function, otherwise it defaults
    // to the entire desktop.
    if (x) *x = 0;
    if (y) *y = 0;
    wxDisplaySize(width, height);
}


// Configurable display in wxX11 and wxMotif
static WXDisplay *gs_currentDisplay = NULL;
static wxString gs_displayName;

WXDisplay *wxGetDisplay()
{
    if (gs_currentDisplay)
        return gs_currentDisplay;
#ifdef __WXMOTIF__
    if (wxTheApp && wxTheApp->GetTopLevelWidget())
        return XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());
    else if (wxTheApp)
        return wxTheApp->GetInitialDisplay();
    return NULL;
#endif
#ifdef __WXX11__
    return wxApp::GetDisplay();
#endif
}

bool wxSetDisplay(const wxString& display_name)
{
    gs_displayName = display_name;

    if ( display_name.IsEmpty() )
    {
        gs_currentDisplay = NULL;

        return TRUE;
    }
    else
    {
        Display* display = XOpenDisplay((char*) display_name.c_str());

        if (display)
        {
            gs_currentDisplay = (WXDisplay*) display;
            return TRUE;
        }
        else
            return FALSE;
    }
}

wxString wxGetDisplayName()
{
    return gs_displayName;
}

wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
{
    return wxGenericFindWindowAtPoint(pt);
}

// ----------------------------------------------------------------------------
// keycode translations
// ----------------------------------------------------------------------------

#include <X11/keysym.h>

// FIXME what about tables??

int wxCharCodeXToWX(KeySym keySym)
{
    int id;
    switch (keySym)
    {
        case XK_Shift_L:
        case XK_Shift_R:
            id = WXK_SHIFT; break;
        case XK_Control_L:
        case XK_Control_R:
            id = WXK_CONTROL; break;
        case XK_BackSpace:
            id = WXK_BACK; break;
        case XK_Delete:
            id = WXK_DELETE; break;
        case XK_Clear:
            id = WXK_CLEAR; break;
        case XK_Tab:
            id = WXK_TAB; break;
        case XK_numbersign:
            id = '#'; break;
        case XK_Return:
            id = WXK_RETURN; break;
        case XK_Escape:
            id = WXK_ESCAPE; break;
        case XK_Pause:
        case XK_Break:
            id = WXK_PAUSE; break;
        case XK_Num_Lock:
            id = WXK_NUMLOCK; break;
        case XK_Scroll_Lock:
            id = WXK_SCROLL; break;

        case XK_Home:
            id = WXK_HOME; break;
        case XK_End:
            id = WXK_END; break;
        case XK_Left:
            id = WXK_LEFT; break;
        case XK_Right:
            id = WXK_RIGHT; break;
        case XK_Up:
            id = WXK_UP; break;
        case XK_Down:
            id = WXK_DOWN; break;
        case XK_Next:
            id = WXK_NEXT; break;
        case XK_Prior:
            id = WXK_PRIOR; break;
        case XK_Menu:
            id = WXK_MENU; break;
        case XK_Select:
            id = WXK_SELECT; break;
        case XK_Cancel:
            id = WXK_CANCEL; break;
        case XK_Print:
            id = WXK_PRINT; break;
        case XK_Execute:
            id = WXK_EXECUTE; break;
        case XK_Insert:
            id = WXK_INSERT; break;
        case XK_Help:
            id = WXK_HELP; break;

        case XK_KP_Multiply:
            id = WXK_MULTIPLY; break;
        case XK_KP_Add:
            id = WXK_ADD; break;
        case XK_KP_Subtract:
            id = WXK_SUBTRACT; break;
        case XK_KP_Divide:
            id = WXK_DIVIDE; break;
        case XK_KP_Decimal:
            id = WXK_DECIMAL; break;
        case XK_KP_Equal:
            id = '='; break;
        case XK_KP_Space:
            id = ' '; break;
        case XK_KP_Tab:
            id = WXK_TAB; break;
        case XK_KP_Enter:
            id = WXK_RETURN; break;
        case XK_KP_0:
            id = WXK_NUMPAD0; break;
        case XK_KP_1:
            id = WXK_NUMPAD1; break;
        case XK_KP_2:
            id = WXK_NUMPAD2; break;
        case XK_KP_3:
            id = WXK_NUMPAD3; break;
        case XK_KP_4:
            id = WXK_NUMPAD4; break;
        case XK_KP_5:
            id = WXK_NUMPAD5; break;
        case XK_KP_6:
            id = WXK_NUMPAD6; break;
        case XK_KP_7:
            id = WXK_NUMPAD7; break;
        case XK_KP_8:
            id = WXK_NUMPAD8; break;
        case XK_KP_9:
            id = WXK_NUMPAD9; break;
        case XK_F1:
            id = WXK_F1; break;
        case XK_F2:
            id = WXK_F2; break;
        case XK_F3:
            id = WXK_F3; break;
        case XK_F4:
            id = WXK_F4; break;
        case XK_F5:
            id = WXK_F5; break;
        case XK_F6:
            id = WXK_F6; break;
        case XK_F7:
            id = WXK_F7; break;
        case XK_F8:
            id = WXK_F8; break;
        case XK_F9:
            id = WXK_F9; break;
        case XK_F10:
            id = WXK_F10; break;
        case XK_F11:
            id = WXK_F11; break;
        case XK_F12:
            id = WXK_F12; break;
        case XK_F13:
            id = WXK_F13; break;
        case XK_F14:
            id = WXK_F14; break;
        case XK_F15:
            id = WXK_F15; break;
        case XK_F16:
            id = WXK_F16; break;
        case XK_F17:
            id = WXK_F17; break;
        case XK_F18:
            id = WXK_F18; break;
        case XK_F19:
            id = WXK_F19; break;
        case XK_F20:
            id = WXK_F20; break;
        case XK_F21:
            id = WXK_F21; break;
        case XK_F22:
            id = WXK_F22; break;
        case XK_F23:
            id = WXK_F23; break;
        case XK_F24:
            id = WXK_F24; break;
        default:
            id = (keySym <= 255) ? (int)keySym : -1;
    }

    return id;
}

KeySym wxCharCodeWXToX(int id)
{
    KeySym keySym;

    switch (id)
    {
        case WXK_CANCEL:            keySym = XK_Cancel; break;
        case WXK_BACK:              keySym = XK_BackSpace; break;
        case WXK_TAB:            keySym = XK_Tab; break;
        case WXK_CLEAR:        keySym = XK_Clear; break;
        case WXK_RETURN:        keySym = XK_Return; break;
        case WXK_SHIFT:        keySym = XK_Shift_L; break;
        case WXK_CONTROL:        keySym = XK_Control_L; break;
        case WXK_MENU :        keySym = XK_Menu; break;
        case WXK_PAUSE:        keySym = XK_Pause; break;
        case WXK_ESCAPE:        keySym = XK_Escape; break;
        case WXK_SPACE:        keySym = ' '; break;
        case WXK_PRIOR:        keySym = XK_Prior; break;
        case WXK_NEXT :        keySym = XK_Next; break;
        case WXK_END:        keySym = XK_End; break;
        case WXK_HOME :        keySym = XK_Home; break;
        case WXK_LEFT :        keySym = XK_Left; break;
        case WXK_UP:        keySym = XK_Up; break;
        case WXK_RIGHT:        keySym = XK_Right; break;
        case WXK_DOWN :        keySym = XK_Down; break;
        case WXK_SELECT:        keySym = XK_Select; break;
        case WXK_PRINT:        keySym = XK_Print; break;
        case WXK_EXECUTE:        keySym = XK_Execute; break;
        case WXK_INSERT:        keySym = XK_Insert; break;
        case WXK_DELETE:        keySym = XK_Delete; break;
        case WXK_HELP :        keySym = XK_Help; break;
        case WXK_NUMPAD0:        keySym = XK_KP_0; break;
        case WXK_NUMPAD1:        keySym = XK_KP_1; break;
        case WXK_NUMPAD2:        keySym = XK_KP_2; break;
        case WXK_NUMPAD3:        keySym = XK_KP_3; break;
        case WXK_NUMPAD4:        keySym = XK_KP_4; break;
        case WXK_NUMPAD5:        keySym = XK_KP_5; break;
        case WXK_NUMPAD6:        keySym = XK_KP_6; break;
        case WXK_NUMPAD7:        keySym = XK_KP_7; break;
        case WXK_NUMPAD8:        keySym = XK_KP_8; break;
        case WXK_NUMPAD9:        keySym = XK_KP_9; break;
        case WXK_MULTIPLY:        keySym = XK_KP_Multiply; break;
        case WXK_ADD:        keySym = XK_KP_Add; break;
        case WXK_SUBTRACT:        keySym = XK_KP_Subtract; break;
        case WXK_DECIMAL:        keySym = XK_KP_Decimal; break;
        case WXK_DIVIDE:        keySym = XK_KP_Divide; break;
        case WXK_F1:        keySym = XK_F1; break;
        case WXK_F2:        keySym = XK_F2; break;
        case WXK_F3:        keySym = XK_F3; break;
        case WXK_F4:        keySym = XK_F4; break;
        case WXK_F5:        keySym = XK_F5; break;
        case WXK_F6:        keySym = XK_F6; break;
        case WXK_F7:        keySym = XK_F7; break;
        case WXK_F8:        keySym = XK_F8; break;
        case WXK_F9:        keySym = XK_F9; break;
        case WXK_F10:        keySym = XK_F10; break;
        case WXK_F11:        keySym = XK_F11; break;
        case WXK_F12:        keySym = XK_F12; break;
        case WXK_F13:        keySym = XK_F13; break;
        case WXK_F14:        keySym = XK_F14; break;
        case WXK_F15:        keySym = XK_F15; break;
        case WXK_F16:        keySym = XK_F16; break;
        case WXK_F17:        keySym = XK_F17; break;
        case WXK_F18:        keySym = XK_F18; break;
        case WXK_F19:        keySym = XK_F19; break;
        case WXK_F20:        keySym = XK_F20; break;
        case WXK_F21:        keySym = XK_F21; break;
        case WXK_F22:        keySym = XK_F22; break;
        case WXK_F23:        keySym = XK_F23; break;
        case WXK_F24:        keySym = XK_F24; break;
        case WXK_NUMLOCK:    keySym = XK_Num_Lock; break;
        case WXK_SCROLL:     keySym = XK_Scroll_Lock; break;
        default:             keySym = id <= 255 ? (KeySym)id : 0;
    }

    return keySym;
}

// ----------------------------------------------------------------------------
// Some colour manipulation routines
// ----------------------------------------------------------------------------

void wxHSVToXColor(wxHSV *hsv,XColor *rgb)
{
    int h = hsv->h;
    int s = hsv->s;
    int v = hsv->v;
    int r = 0, g = 0, b = 0;
    int i, f;
    int p, q, t;
    s = (s * wxMAX_RGB) / wxMAX_SV;
    v = (v * wxMAX_RGB) / wxMAX_SV;
    if (h == 360) h = 0;
    if (s == 0) { h = 0; r = g = b = v; }
    i = h / 60;
    f = h % 60;
    p = v * (wxMAX_RGB - s) / wxMAX_RGB;
    q = v * (wxMAX_RGB - s * f / 60) / wxMAX_RGB;
    t = v * (wxMAX_RGB - s * (60 - f) / 60) / wxMAX_RGB;
    switch (i)
    {
    case 0: r = v, g = t, b = p; break;
    case 1: r = q, g = v, b = p; break;
    case 2: r = p, g = v, b = t; break;
    case 3: r = p, g = q, b = v; break;
    case 4: r = t, g = p, b = v; break;
    case 5: r = v, g = p, b = q; break;
    }
    rgb->red = r << 8;
    rgb->green = g << 8;
    rgb->blue = b << 8;
}

void wxXColorToHSV(wxHSV *hsv,XColor *rgb)
{
    int r = rgb->red >> 8;
    int g = rgb->green >> 8;
    int b = rgb->blue >> 8;
    int maxv = wxMax3(r, g, b);
    int minv = wxMin3(r, g, b);
    int h = 0, s, v;
    v = maxv;
    if (maxv) s = (maxv - minv) * wxMAX_RGB / maxv;
    else s = 0;
    if (s == 0) h = 0;
    else
    {
        int rc, gc, bc, hex = 0;
        rc = (maxv - r) * wxMAX_RGB / (maxv - minv);
        gc = (maxv - g) * wxMAX_RGB / (maxv - minv);
        bc = (maxv - b) * wxMAX_RGB / (maxv - minv);
        if (r == maxv) { h = bc - gc, hex = 0; }
        else if (g == maxv) { h = rc - bc, hex = 2; }
        else if (b == maxv) { h = gc - rc, hex = 4; }
        h = hex * 60 + (h * 60 / wxMAX_RGB);
        if (h < 0) h += 360;
    }
    hsv->h = h;
    hsv->s = (s * wxMAX_SV) / wxMAX_RGB;
    hsv->v = (v * wxMAX_SV) / wxMAX_RGB;
}

void wxAllocNearestColor(Display *d,Colormap cmp,XColor *xc)
{
#if !wxUSE_NANOX
    int llp;

    int screen = DefaultScreen(d);
    int num_colors = DisplayCells(d,screen);

    XColor *color_defs = new XColor[num_colors];
    for(llp = 0;llp < num_colors;llp++) color_defs[llp].pixel = llp;
    XQueryColors(d,cmp,color_defs,num_colors);

    wxHSV hsv_defs, hsv;
    wxXColorToHSV(&hsv,xc);

    int diff, min_diff = 0, pixel = 0;

    for(llp = 0;llp < num_colors;llp++)
    {
        wxXColorToHSV(&hsv_defs,&color_defs[llp]);
        diff = wxSIGN(wxH_WEIGHT * (hsv.h - hsv_defs.h)) +
            wxSIGN(wxS_WEIGHT * (hsv.s - hsv_defs.s)) +
            wxSIGN(wxV_WEIGHT * (hsv.v - hsv_defs.v));
        if (llp == 0) min_diff = diff;
        if (min_diff > diff) { min_diff = diff; pixel = llp; }
        if (min_diff == 0) break;
    }

    xc -> red = color_defs[pixel].red;
    xc -> green = color_defs[pixel].green;
    xc -> blue = color_defs[pixel].blue;
    xc -> flags = DoRed | DoGreen | DoBlue;

/*  FIXME, TODO
    if (!XAllocColor(d,cmp,xc))
        cout << "wxAllocNearestColor : Warning : Cannot find nearest color !\n";
*/

    delete[] color_defs;
#endif
}

void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
{
    if (!XAllocColor(d,cmp,xc))
    {
        //          cout << "wxAllocColor : Warning : Can not allocate color, attempt find nearest !\n";
        wxAllocNearestColor(d,cmp,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

bool wxWindowIsVisible(Window win)
{
    XWindowAttributes wa;
    XGetWindowAttributes(wxGlobalDisplay(), win, &wa);

    return (wa.map_state == IsViewable);
}
Commit	Line	Data
83df96d6 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: utils.cpp
	3	// Purpose: Various utilities
	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	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
83df96d6 JS	20	#include "wx/setup.h"
	21	#include "wx/utils.h"
	22	#include "wx/app.h"
	23	#include "wx/msgdlg.h"
	24	#include "wx/cursor.h"
	25	#include "wx/window.h" // for wxTopLevelWindows
	26
	27	#include <ctype.h>
	28	#include <stdarg.h>
	29	#include <dirent.h>
	30	#include <string.h>
	31	#include <sys/stat.h>
	32	#include <sys/types.h>
	33	#include <unistd.h>
	34	#include <sys/wait.h>
	35	#include <pwd.h>
	36	#include <errno.h>
2b5f62a0	37	// #include <netdb.h>
83df96d6 JS	38	#include <signal.h>
	39
	40	#if (defined(__SUNCC__) \|\| defined(__CLCC__))
	41	#include <sysent.h>
	42	#endif
	43
	44	#ifdef __VMS__
	45	#pragma message disable nosimpint
	46	#endif
bc797f4c	47
83df96d6 JS	48	#include "wx/unix/execute.h"
83df96d6 JS	49
bc797f4c	50	#include "wx/x11/private.h"
256d631a	51
7266b672	52	#include "X11/Xutil.h"
83df96d6	53
256d631a JS	54	#ifdef __VMS__
	55	#pragma message enable nosimpint
	56	#endif
	57
83df96d6 JS	58	// ----------------------------------------------------------------------------
	59	// async event processing
	60	// ----------------------------------------------------------------------------
	61
	62	// Consume all events until no more left
	63	void wxFlushEvents()
	64	{
	65	Display display = (Display) wxGetDisplay();
	66
	67	XSync (display, FALSE);
	68
5e29f97a	69	#ifdef __WXMOTIF__
83df96d6 JS	70	// XtAppPending returns availability of events AND timers/inputs, which
	71	// are processed via callbacks, so XtAppNextEvent will not return if
	72	// there are no events. So added '& XtIMXEvent' - Sergey.
	73	while (XtAppPending ((XtAppContext) wxTheApp->GetAppContext()) & XtIMXEvent)
	74	{
	75	XFlush (XtDisplay ((Widget) wxTheApp->GetTopLevelWidget()));
	76	// Jan Lessner: works better when events are non-X events
	77	XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMXEvent);
	78	}
7266b672	79	#endif
5e29f97a JS	80	#ifdef __WXX11__
	81	// TODO for X11
	82	// ??
	83	#endif
83df96d6 JS	84	}
83df96d6 JS	85
83df96d6 JS	86	bool wxCheckForInterrupt(wxWindow *wnd)
83df96d6 JS	87	{
5e29f97a	88	#ifdef __WXMOTIF__
83df96d6 JS	89	wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
	90
	91	Display dpy=(Display) wnd->GetXDisplay();
	92	Window win=(Window) wnd->GetXWindow();
	93	XEvent event;
	94	XFlush(dpy);
	95	if (wnd->GetMainWidget())
	96	{
	97	XmUpdateDisplay((Widget)(wnd->GetMainWidget()));
	98	}
	99
	100	bool hadEvents = FALSE;
	101	while( XCheckMaskEvent(dpy,
	102	ButtonPressMask\|ButtonReleaseMask\|ButtonMotionMask\|
	103	PointerMotionMask\|KeyPressMask\|KeyReleaseMask,
	104	&event) )
	105	{
	106	if ( event.xany.window == win )
	107	{
	108	hadEvents = TRUE;
	109
	110	XtDispatchEvent(&event);
	111	}
	112	}
	113
	114	return hadEvents;
5e29f97a JS	115	#else
	116	wxASSERT_MSG(FALSE, "wxCheckForInterrupt not yet implemented.");
	117	return FALSE;
bc797f4c	118	#endif
83df96d6 JS	119	}
	120
	121	// ----------------------------------------------------------------------------
	122	// wxExecute stuff
	123	// ----------------------------------------------------------------------------
83df96d6 JS	124
	125	int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
	126	{
707440dc	127	#ifdef __WXMOTIF__
83df96d6 JS	128	XtInputId id = XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
	129	fd,
	130	(XtPointer *) XtInputReadMask,
	131	(XtInputCallbackProc) xt_notify_end_process,
	132	(XtPointer) proc_data);
	133
	134	return (int)id;
5e29f97a	135	#endif
707440dc JS	136	#ifdef __WXX11__
	137	// TODO
	138	return 0;
	139	#endif
	140	}
83df96d6 JS	141
	142	// ----------------------------------------------------------------------------
	143	// misc
	144	// ----------------------------------------------------------------------------
	145
	146	// Emit a beeeeeep
	147	void wxBell()
	148	{
	149	// Use current setting for the bell
	150	XBell ((Display*) wxGetDisplay(), 0);
	151	}
	152
	153	int wxGetOsVersion(int majorVsn, int minorVsn)
	154	{
5e29f97a	155	#ifdef __WXX11__
bc797f4c JS	156	if (majorVsn)
bc797f4c JS	157	*majorVsn = 0;
2b5f62a0	158
bc797f4c JS	159	if (minorVsn)
bc797f4c JS	160	*minorVsn = 0;
2b5f62a0	161
bc797f4c	162	return wxX11;
5e29f97a	163	#endif
83df96d6 JS	164	}
83df96d6 JS	165
83df96d6 JS	166	// ----------------------------------------------------------------------------
	167	// display info
	168	// ----------------------------------------------------------------------------
	169
	170	void wxGetMousePosition( int* x, int* y )
	171	{
461e93f9 JS	172	#if wxUSE_NANOX
	173	// TODO
	174	*x = 0;
	175	*y = 0;
	176	#else
83df96d6 JS	177	XMotionEvent xev;
	178	Window root, child;
	179	XQueryPointer((Display*) wxGetDisplay(),
	180	DefaultRootWindow((Display*) wxGetDisplay()),
	181	&root, &child,
	182	&(xev.x_root), &(xev.y_root),
	183	&(xev.x), &(xev.y),
	184	&(xev.state));
	185	*x = xev.x_root;
	186	*y = xev.y_root;
461e93f9	187	#endif
83df96d6 JS	188	};
	189
	190	// Return TRUE if we have a colour display
	191	bool wxColourDisplay()
	192	{
	193	return wxDisplayDepth() > 1;
	194	}
	195
	196	// Returns depth of screen
	197	int wxDisplayDepth()
	198	{
	199	Display dpy = (Display) wxGetDisplay();
	200
	201	return DefaultDepth (dpy, DefaultScreen (dpy));
	202	}
	203
	204	// Get size of display
	205	void wxDisplaySize(int width, int height)
	206	{
	207	Display dpy = (Display) wxGetDisplay();
	208
	209	if ( width )
	210	*width = DisplayWidth (dpy, DefaultScreen (dpy));
	211	if ( height )
	212	*height = DisplayHeight (dpy, DefaultScreen (dpy));
	213	}
	214
	215	void wxDisplaySizeMM(int width, int height)
	216	{
	217	Display dpy = (Display) wxGetDisplay();
	218
	219	if ( width )
	220	*width = DisplayWidthMM(dpy, DefaultScreen (dpy));
	221	if ( height )
	222	*height = DisplayHeightMM(dpy, DefaultScreen (dpy));
	223	}
	224
	225	void wxClientDisplayRect(int x, int y, int width, int height)
	226	{
	227	// This is supposed to return desktop dimensions minus any window
	228	// manager panels, menus, taskbars, etc. If there is a way to do that
	229	// for this platform please fix this function, otherwise it defaults
	230	// to the entire desktop.
	231	if (x) *x = 0;
	232	if (y) *y = 0;
	233	wxDisplaySize(width, height);
	234	}
	235
	236
5e29f97a	237	// Configurable display in wxX11 and wxMotif
83df96d6 JS	238	static WXDisplay *gs_currentDisplay = NULL;
	239	static wxString gs_displayName;
	240
	241	WXDisplay *wxGetDisplay()
	242	{
	243	if (gs_currentDisplay)
	244	return gs_currentDisplay;
5e29f97a JS	245	#ifdef __WXMOTIF__
	246	if (wxTheApp && wxTheApp->GetTopLevelWidget())
	247	return XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());
	248	else if (wxTheApp)
	249	return wxTheApp->GetInitialDisplay();
a1de932d	250	return NULL;
5e29f97a	251	#endif
a1de932d	252	#ifdef __WXX11__
5e29f97a JS	253	return wxApp::GetDisplay();
5e29f97a JS	254	#endif
83df96d6 JS	255	}
	256
	257	bool wxSetDisplay(const wxString& display_name)
	258	{
	259	gs_displayName = display_name;
	260
bc797f4c	261	if ( display_name.IsEmpty() )
83df96d6 JS	262	{
	263	gs_currentDisplay = NULL;
	264
	265	return TRUE;
	266	}
	267	else
	268	{
461e93f9	269	Display* display = XOpenDisplay((char*) display_name.c_str());
83df96d6 JS	270
	271	if (display)
	272	{
	273	gs_currentDisplay = (WXDisplay*) display;
	274	return TRUE;
	275	}
	276	else
	277	return FALSE;
	278	}
	279	}
	280
	281	wxString wxGetDisplayName()
	282	{
	283	return gs_displayName;
	284	}
	285
	286	wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
	287	{
	288	return wxGenericFindWindowAtPoint(pt);
	289	}
	290
83df96d6 JS	291	// ----------------------------------------------------------------------------
	292	// keycode translations
	293	// ----------------------------------------------------------------------------
	294
	295	#include <X11/keysym.h>
	296
	297	// FIXME what about tables??
	298
	299	int wxCharCodeXToWX(KeySym keySym)
	300	{
	301	int id;
	302	switch (keySym)
	303	{
	304	case XK_Shift_L:
	305	case XK_Shift_R:
	306	id = WXK_SHIFT; break;
	307	case XK_Control_L:
	308	case XK_Control_R:
	309	id = WXK_CONTROL; break;
	310	case XK_BackSpace:
	311	id = WXK_BACK; break;
	312	case XK_Delete:
	313	id = WXK_DELETE; break;
	314	case XK_Clear:
	315	id = WXK_CLEAR; break;
	316	case XK_Tab:
	317	id = WXK_TAB; break;
	318	case XK_numbersign:
	319	id = '#'; break;
	320	case XK_Return:
	321	id = WXK_RETURN; break;
	322	case XK_Escape:
	323	id = WXK_ESCAPE; break;
	324	case XK_Pause:
	325	case XK_Break:
	326	id = WXK_PAUSE; break;
	327	case XK_Num_Lock:
	328	id = WXK_NUMLOCK; break;
	329	case XK_Scroll_Lock:
	330	id = WXK_SCROLL; break;
	331
	332	case XK_Home:
	333	id = WXK_HOME; break;
	334	case XK_End:
	335	id = WXK_END; break;
	336	case XK_Left:
	337	id = WXK_LEFT; break;
	338	case XK_Right:
	339	id = WXK_RIGHT; break;
	340	case XK_Up:
	341	id = WXK_UP; break;
	342	case XK_Down:
	343	id = WXK_DOWN; break;
	344	case XK_Next:
	345	id = WXK_NEXT; break;
	346	case XK_Prior:
	347	id = WXK_PRIOR; break;
	348	case XK_Menu:
	349	id = WXK_MENU; break;
	350	case XK_Select:
	351	id = WXK_SELECT; break;
	352	case XK_Cancel:
	353	id = WXK_CANCEL; break;
	354	case XK_Print:
355	id = WXK_PRINT; break;
356	case XK_Execute:
357	id = WXK_EXECUTE; break;
358	case XK_Insert:
359	id = WXK_INSERT; break;
360	case XK_Help:
361	id = WXK_HELP; break;
362
363	case XK_KP_Multiply:
364	id = WXK_MULTIPLY; break;
365	case XK_KP_Add:
366	id = WXK_ADD; break;
367	case XK_KP_Subtract:
368	id = WXK_SUBTRACT; break;
369	case XK_KP_Divide:
370	id = WXK_DIVIDE; break;
371	case XK_KP_Decimal:
372	id = WXK_DECIMAL; break;
373	case XK_KP_Equal:
374	id = '='; break;
375	case XK_KP_Space:
376	id = ' '; break;
377	case XK_KP_Tab:
378	id = WXK_TAB; break;
379	case XK_KP_Enter:
380	id = WXK_RETURN; break;
381	case XK_KP_0:
382	id = WXK_NUMPAD0; break;
383	case XK_KP_1:
384	id = WXK_NUMPAD1; break;
385	case XK_KP_2:
386	id = WXK_NUMPAD2; break;
387	case XK_KP_3:
388	id = WXK_NUMPAD3; break;
389	case XK_KP_4:
390	id = WXK_NUMPAD4; break;
391	case XK_KP_5:
392	id = WXK_NUMPAD5; break;
393	case XK_KP_6:
394	id = WXK_NUMPAD6; break;
395	case XK_KP_7:
396	id = WXK_NUMPAD7; break;
397	case XK_KP_8:
398	id = WXK_NUMPAD8; break;
399	case XK_KP_9:
400	id = WXK_NUMPAD9; break;
401	case XK_F1:
402	id = WXK_F1; break;
403	case XK_F2:
404	id = WXK_F2; break;
405	case XK_F3:
406	id = WXK_F3; break;
407	case XK_F4:
408	id = WXK_F4; break;
409	case XK_F5:
410	id = WXK_F5; break;
411	case XK_F6:
412	id = WXK_F6; break;
413	case XK_F7:
414	id = WXK_F7; break;
415	case XK_F8:
416	id = WXK_F8; break;
417	case XK_F9:
418	id = WXK_F9; break;
419	case XK_F10:
420	id = WXK_F10; break;
421	case XK_F11:
422	id = WXK_F11; break;
423	case XK_F12:
424	id = WXK_F12; break;
425	case XK_F13:
426	id = WXK_F13; break;
427	case XK_F14:
428	id = WXK_F14; break;
429	case XK_F15:
430	id = WXK_F15; break;
431	case XK_F16:
432	id = WXK_F16; break;
433	case XK_F17:
434	id = WXK_F17; break;
435	case XK_F18:
436	id = WXK_F18; break;
437	case XK_F19:
438	id = WXK_F19; break;
439	case XK_F20:
440	id = WXK_F20; break;
441	case XK_F21:
442	id = WXK_F21; break;
443	case XK_F22:
444	id = WXK_F22; break;
445	case XK_F23:
446	id = WXK_F23; break;
447	case XK_F24:
448	id = WXK_F24; break;
449	default:
450	id = (keySym <= 255) ? (int)keySym : -1;
451	}
452
453	return id;
454	}
455
456	KeySym wxCharCodeWXToX(int id)
457	{
458	KeySym keySym;
459
460	switch (id)
461	{
462	case WXK_CANCEL: keySym = XK_Cancel; break;
463	case WXK_BACK: keySym = XK_BackSpace; break;
464	case WXK_TAB: keySym = XK_Tab; break;
465	case WXK_CLEAR: keySym = XK_Clear; break;
466	case WXK_RETURN: keySym = XK_Return; break;
467	case WXK_SHIFT: keySym = XK_Shift_L; break;
468	case WXK_CONTROL: keySym = XK_Control_L; break;
469	case WXK_MENU : keySym = XK_Menu; break;
470	case WXK_PAUSE: keySym = XK_Pause; break;
471	case WXK_ESCAPE: keySym = XK_Escape; break;
472	case WXK_SPACE: keySym = ' '; break;
473	case WXK_PRIOR: keySym = XK_Prior; break;
474	case WXK_NEXT : keySym = XK_Next; break;
475	case WXK_END: keySym = XK_End; break;
476	case WXK_HOME : keySym = XK_Home; break;
477	case WXK_LEFT : keySym = XK_Left; break;
478	case WXK_UP: keySym = XK_Up; break;
479	case WXK_RIGHT: keySym = XK_Right; break;
480	case WXK_DOWN : keySym = XK_Down; break;
481	case WXK_SELECT: keySym = XK_Select; break;
482	case WXK_PRINT: keySym = XK_Print; break;
483	case WXK_EXECUTE: keySym = XK_Execute; break;
484	case WXK_INSERT: keySym = XK_Insert; break;
485	case WXK_DELETE: keySym = XK_Delete; break;
486	case WXK_HELP : keySym = XK_Help; break;
487	case WXK_NUMPAD0: keySym = XK_KP_0; break;
488	case WXK_NUMPAD1: keySym = XK_KP_1; break;
489	case WXK_NUMPAD2: keySym = XK_KP_2; break;
490	case WXK_NUMPAD3: keySym = XK_KP_3; break;
491	case WXK_NUMPAD4: keySym = XK_KP_4; break;
492	case WXK_NUMPAD5: keySym = XK_KP_5; break;
493	case WXK_NUMPAD6: keySym = XK_KP_6; break;
494	case WXK_NUMPAD7: keySym = XK_KP_7; break;
495	case WXK_NUMPAD8: keySym = XK_KP_8; break;
496	case WXK_NUMPAD9: keySym = XK_KP_9; break;
497	case WXK_MULTIPLY: keySym = XK_KP_Multiply; break;
498	case WXK_ADD: keySym = XK_KP_Add; break;
499	case WXK_SUBTRACT: keySym = XK_KP_Subtract; break;
500	case WXK_DECIMAL: keySym = XK_KP_Decimal; break;
501	case WXK_DIVIDE: keySym = XK_KP_Divide; break;
502	case WXK_F1: keySym = XK_F1; break;
503	case WXK_F2: keySym = XK_F2; break;
504	case WXK_F3: keySym = XK_F3; break;
505	case WXK_F4: keySym = XK_F4; break;
506	case WXK_F5: keySym = XK_F5; break;
507	case WXK_F6: keySym = XK_F6; break;
508	case WXK_F7: keySym = XK_F7; break;
509	case WXK_F8: keySym = XK_F8; break;
510	case WXK_F9: keySym = XK_F9; break;
511	case WXK_F10: keySym = XK_F10; break;
512	case WXK_F11: keySym = XK_F11; break;
513	case WXK_F12: keySym = XK_F12; break;
514	case WXK_F13: keySym = XK_F13; break;
515	case WXK_F14: keySym = XK_F14; break;
516	case WXK_F15: keySym = XK_F15; break;
517	case WXK_F16: keySym = XK_F16; break;
518	case WXK_F17: keySym = XK_F17; break;
519	case WXK_F18: keySym = XK_F18; break;
520	case WXK_F19: keySym = XK_F19; break;
521	case WXK_F20: keySym = XK_F20; break;
522	case WXK_F21: keySym = XK_F21; break;
523	case WXK_F22: keySym = XK_F22; break;
524	case WXK_F23: keySym = XK_F23; break;
525	case WXK_F24: keySym = XK_F24; break;
526	case WXK_NUMLOCK: keySym = XK_Num_Lock; break;
527	case WXK_SCROLL: keySym = XK_Scroll_Lock; break;
528	default: keySym = id <= 255 ? (KeySym)id : 0;
529	}
530
531	return keySym;
532	}
533
534	// ----------------------------------------------------------------------------
535	// Some colour manipulation routines
536	// ----------------------------------------------------------------------------
537
538	void wxHSVToXColor(wxHSV hsv,XColor rgb)
539	{
540	int h = hsv->h;
541	int s = hsv->s;
542	int v = hsv->v;
543	int r = 0, g = 0, b = 0;
544	int i, f;
545	int p, q, t;
546	s = (s * wxMAX_RGB) / wxMAX_SV;
547	v = (v * wxMAX_RGB) / wxMAX_SV;
548	if (h == 360) h = 0;
549	if (s == 0) { h = 0; r = g = b = v; }
550	i = h / 60;
551	f = h % 60;
552	p = v * (wxMAX_RGB - s) / wxMAX_RGB;
553	q = v * (wxMAX_RGB - s * f / 60) / wxMAX_RGB;
554	t = v * (wxMAX_RGB - s * (60 - f) / 60) / wxMAX_RGB;
555	switch (i)
556	{
557	case 0: r = v, g = t, b = p; break;
558	case 1: r = q, g = v, b = p; break;
559	case 2: r = p, g = v, b = t; break;
560	case 3: r = p, g = q, b = v; break;
561	case 4: r = t, g = p, b = v; break;
562	case 5: r = v, g = p, b = q; break;
563	}
564	rgb->red = r << 8;
565	rgb->green = g << 8;
566	rgb->blue = b << 8;
567	}
568
569	void wxXColorToHSV(wxHSV hsv,XColor rgb)
570	{
571	int r = rgb->red >> 8;
572	int g = rgb->green >> 8;
573	int b = rgb->blue >> 8;
574	int maxv = wxMax3(r, g, b);
575	int minv = wxMin3(r, g, b);
576	int h = 0, s, v;
577	v = maxv;
578	if (maxv) s = (maxv - minv) * wxMAX_RGB / maxv;
579	else s = 0;
580	if (s == 0) h = 0;
581	else
582	{
583	int rc, gc, bc, hex = 0;
584	rc = (maxv - r) * wxMAX_RGB / (maxv - minv);
585	gc = (maxv - g) * wxMAX_RGB / (maxv - minv);
586	bc = (maxv - b) * wxMAX_RGB / (maxv - minv);
587	if (r == maxv) { h = bc - gc, hex = 0; }
588	else if (g == maxv) { h = rc - bc, hex = 2; }
589	else if (b == maxv) { h = gc - rc, hex = 4; }
590	h = hex * 60 + (h * 60 / wxMAX_RGB);
591	if (h < 0) h += 360;
592	}
593	hsv->h = h;
594	hsv->s = (s * wxMAX_SV) / wxMAX_RGB;
595	hsv->v = (v * wxMAX_SV) / wxMAX_RGB;
596	}
597
598	void wxAllocNearestColor(Display d,Colormap cmp,XColor xc)
599	{
461e93f9	600	#if !wxUSE_NANOX
83df96d6 JS	601	int llp;
	602
	603	int screen = DefaultScreen(d);
	604	int num_colors = DisplayCells(d,screen);
	605
	606	XColor *color_defs = new XColor[num_colors];
	607	for(llp = 0;llp < num_colors;llp++) color_defs[llp].pixel = llp;
	608	XQueryColors(d,cmp,color_defs,num_colors);
	609
	610	wxHSV hsv_defs, hsv;
	611	wxXColorToHSV(&hsv,xc);
	612
	613	int diff, min_diff = 0, pixel = 0;
	614
	615	for(llp = 0;llp < num_colors;llp++)
	616	{
	617	wxXColorToHSV(&hsv_defs,&color_defs[llp]);
	618	diff = wxSIGN(wxH_WEIGHT * (hsv.h - hsv_defs.h)) +
	619	wxSIGN(wxS_WEIGHT * (hsv.s - hsv_defs.s)) +
	620	wxSIGN(wxV_WEIGHT * (hsv.v - hsv_defs.v));
	621	if (llp == 0) min_diff = diff;
	622	if (min_diff > diff) { min_diff = diff; pixel = llp; }
	623	if (min_diff == 0) break;
	624	}
	625
	626	xc -> red = color_defs[pixel].red;
	627	xc -> green = color_defs[pixel].green;
	628	xc -> blue = color_defs[pixel].blue;
	629	xc -> flags = DoRed \| DoGreen \| DoBlue;
	630
	631	/* FIXME, TODO
	632	if (!XAllocColor(d,cmp,xc))
	633	cout << "wxAllocNearestColor : Warning : Cannot find nearest color !\n";
	634	*/
	635
	636	delete[] color_defs;
461e93f9	637	#endif
83df96d6 JS	638	}
	639
	640	void wxAllocColor(Display d,Colormap cmp,XColor xc)
	641	{
	642	if (!XAllocColor(d,cmp,xc))
	643	{
	644	// cout << "wxAllocColor : Warning : Can not allocate color, attempt find nearest !\n";
	645	wxAllocNearestColor(d,cmp,xc);
	646	}
	647	}
	648
45ff6421 JS	649	#ifdef __WXDEBUG__
	650	wxString wxGetXEventName(XEvent& event)
	651	{
461e93f9 JS	652	#if wxUSE_NANOX
	653	wxString str(wxT("(some event)"));
	654	return str;
	655	#else
45ff6421 JS	656	int type = event.xany.type;
	657	static char* event_name[] = {
	658	"", "unknown(-)", // 0-1
	659	"KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease", // 2-5
	660	"MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", // 6-9
	661	"FocusOut", "KeymapNotify", "Expose", "GraphicsExpose", // 10-13
	662	"NoExpose", "VisibilityNotify", "CreateNotify", // 14-16
	663	"DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",// 17-20
	664	"ReparentNotify", "ConfigureNotify", "ConfigureRequest", // 21-23
	665	"GravityNotify", "ResizeRequest", "CirculateNotify", // 24-26
	666	"CirculateRequest", "PropertyNotify", "SelectionClear", // 27-29
	667	"SelectionRequest", "SelectionNotify", "ColormapNotify", // 30-32
	668	"ClientMessage", "MappingNotify", // 33-34
	669	"unknown(+)"}; // 35
	670	type = wxMin(35, type); type = wxMax(1, type);
	671	wxString str(event_name[type]);
	672	return str;
461e93f9 JS	673	#endif
461e93f9 JS	674	}
45ff6421 JS	675	#endif
45ff6421 JS	676
3a0b23eb JS	677	bool wxWindowIsVisible(Window win)
	678	{
	679	XWindowAttributes wa;
	680	XGetWindowAttributes(wxGlobalDisplay(), win, &wa);
	681
	682	return (wa.map_state == IsViewable);
	683	}