[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/apptrait.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);

    // TODO for X11
    // ??
}

bool wxCheckForInterrupt(wxWindow *wnd)
{
    wxASSERT_MSG(FALSE, "wxCheckForInterrupt not yet implemented.");
    return FALSE;
}

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

int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
{
    // TODO
    return 0;
}

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

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

wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
{
    static wxToolkitInfo info;
    info.shortName = _T("x11univ");
    info.name = _T("wxX11");
    info.versionMajor = 0;
    info.versionMinor = 0;
    info.os = wxX11;
    return info;
}

// ----------------------------------------------------------------------------
// 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;
    return wxApp::GetDisplay();
}

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