src/unix/joystick.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/unix/joystick.cpp
// Purpose:     wxJoystick class
// Author:      Ported to Linux by Guilhem Lavaux
// Modified by:
// Created:     05/23/98
// RCS-ID:      $Id$
// Copyright:   (c) Guilhem Lavaux
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if wxUSE_JOYSTICK

#include "wx/joystick.h"

#ifndef WX_PRECOMP
    #include "wx/event.h"
    #include "wx/window.h"
#endif //WX_PRECOMP

#include "wx/thread.h"

#include <linux/joystick.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>

#ifdef HAVE_SYS_SELECT_H
#   include <sys/select.h>
#endif

#include "wx/unix/private.h"

enum {
    wxJS_AXIS_X = 0,
    wxJS_AXIS_Y,
    wxJS_AXIS_Z,
    wxJS_AXIS_RUDDER,
    wxJS_AXIS_U,
    wxJS_AXIS_V,

    wxJS_AXIS_MAX = 32767,
    wxJS_AXIS_MIN = -32767,
    wxJS_MAX_AXES = 15,
    wxJS_MAX_BUTTONS = sizeof(int) * 8
};


IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)


////////////////////////////////////////////////////////////////////////////
// Background thread for reading the joystick device
////////////////////////////////////////////////////////////////////////////

class wxJoystickThread : public wxThread
{
public:
    wxJoystickThread(int device, int joystick);
    void* Entry();

private:
    void      SendEvent(wxEventType type, long ts, int change = 0);
    int       m_device;
    int       m_joystick;
    wxPoint   m_lastposition;
    int       m_axe[wxJS_MAX_AXES];
    int       m_buttons;
    wxWindow* m_catchwin;
    int       m_polling;
    int       m_threshold;

    friend class wxJoystick;
};


wxJoystickThread::wxJoystickThread(int device, int joystick)
    : m_device(device),
      m_joystick(joystick),
      m_lastposition(wxDefaultPosition),
      m_buttons(0),
      m_catchwin(NULL),
      m_polling(0),
      m_threshold(0)
{
    memset(m_axe, 0, sizeof(m_axe));
}

void wxJoystickThread::SendEvent(wxEventType type, long ts, int change)
{
    wxJoystickEvent jwx_event(type, m_buttons, m_joystick, change);

    jwx_event.SetTimestamp(ts);
    jwx_event.SetPosition(m_lastposition);
    jwx_event.SetZPosition(m_axe[wxJS_AXIS_Z]);
    jwx_event.SetEventObject(m_catchwin);

    if (m_catchwin)
        m_catchwin->GetEventHandler()->AddPendingEvent(jwx_event);
}

void* wxJoystickThread::Entry()
{
    struct js_event j_evt;
    fd_set read_fds;
    struct timeval time_out = {0, 0};

    wxFD_ZERO(&read_fds);
    while (true)
    {
        if (TestDestroy())
            break;

        // We use select when either polling or 'blocking' as even in the
        // blocking case we need to check TestDestroy periodically
        if (m_polling)
            time_out.tv_usec = m_polling * 1000;
        else
            time_out.tv_usec = 10 * 1000; // check at least every 10 msec in blocking case

        wxFD_SET(m_device, &read_fds);
        select(m_device+1, &read_fds, NULL, NULL, &time_out);
        if (wxFD_ISSET(m_device, &read_fds))
        {
            memset(&j_evt, 0, sizeof(j_evt));
            read(m_device, &j_evt, sizeof(j_evt));

            //printf("time: %d\t value: %d\t type: %d\t number: %d\n",
            //       j_evt.time, j_evt.value, j_evt.type, j_evt.number);

            if ((j_evt.type & JS_EVENT_AXIS) && (j_evt.number < wxJS_MAX_AXES))
            {
                if (   (m_axe[j_evt.number] + m_threshold < j_evt.value)
                    || (m_axe[j_evt.number] - m_threshold > j_evt.value) )
            {
                m_axe[j_evt.number] = j_evt.value;

                switch (j_evt.number)
                {
                    case wxJS_AXIS_X:
                        m_lastposition.x = j_evt.value;
                        SendEvent(wxEVT_JOY_MOVE, j_evt.time);
                        break;
                    case wxJS_AXIS_Y:
                        m_lastposition.y = j_evt.value;
                        SendEvent(wxEVT_JOY_MOVE, j_evt.time);
                        break;
                    case wxJS_AXIS_Z:
                        SendEvent(wxEVT_JOY_ZMOVE, j_evt.time);
                        break;
                    default:
                        SendEvent(wxEVT_JOY_MOVE, j_evt.time);
                        // TODO: There should be a way to indicate that the event
                        //       is for some other axes.
                        break;
                }
            }
            }

            if ( (j_evt.type & JS_EVENT_BUTTON) && (j_evt.number < wxJS_MAX_BUTTONS) )
            {
                if (j_evt.value)
                {
                    m_buttons |= (1 << j_evt.number);
                    SendEvent(wxEVT_JOY_BUTTON_DOWN, j_evt.time, j_evt.number);
                }
                else
                {
                    m_buttons &= ~(1 << j_evt.number);
                    SendEvent(wxEVT_JOY_BUTTON_UP, j_evt.time, j_evt.number);
                }
            }
        }
    }

    close(m_device);
    return NULL;
}


////////////////////////////////////////////////////////////////////////////

wxJoystick::wxJoystick(int joystick)
    : m_device(-1),
      m_joystick(joystick),
      m_thread(NULL)
{
    wxString dev_name;

     // old /dev structure
    dev_name.Printf( wxT("/dev/js%d"), joystick);
    m_device = open(dev_name.fn_str(), O_RDONLY);

    // new /dev structure with "input" subdirectory
    if (m_device == -1)
    {
        dev_name.Printf( wxT("/dev/input/js%d"), joystick);
        m_device = open(dev_name.fn_str(), O_RDONLY);
    }

    if (m_device != -1)
    {
        m_thread = new wxJoystickThread(m_device, m_joystick);
        m_thread->Create();
        m_thread->Run();
    }
}


wxJoystick::~wxJoystick()
{
    ReleaseCapture();
    if (m_thread)
        m_thread->Delete();  // It's detached so it will delete itself
    m_device = -1;
}


////////////////////////////////////////////////////////////////////////////
// State
////////////////////////////////////////////////////////////////////////////

wxPoint wxJoystick::GetPosition() const
{
    wxPoint pos(wxDefaultPosition);
    if (m_thread) pos = m_thread->m_lastposition;
    return pos;
}

int wxJoystick::GetPosition(unsigned axis) const
{
    if (m_thread && (axis < wxJS_MAX_AXES))
        return m_thread->m_axe[axis];
    return 0;
}

int wxJoystick::GetZPosition() const
{
    if (m_thread)
        return m_thread->m_axe[wxJS_AXIS_Z];
    return 0;
}

int wxJoystick::GetButtonState() const
{
    if (m_thread)
        return m_thread->m_buttons;
    return 0;
}

bool wxJoystick::GetButtonState(unsigned id) const
{
    if (m_thread && (id < wxJS_MAX_BUTTONS))
        return (m_thread->m_buttons & (1 << id)) != 0;
    return false;
}

int wxJoystick::GetPOVPosition() const
{
    return -1;
}

int wxJoystick::GetPOVCTSPosition() const
{
    return -1;
}

int wxJoystick::GetRudderPosition() const
{
    if (m_thread)
        return m_thread->m_axe[wxJS_AXIS_RUDDER];
    return 0;
}

int wxJoystick::GetUPosition() const
{
    if (m_thread)
        return m_thread->m_axe[wxJS_AXIS_U];
    return 0;
}

int wxJoystick::GetVPosition() const
{
    if (m_thread)
        return m_thread->m_axe[wxJS_AXIS_V];
    return 0;
}

int wxJoystick::GetMovementThreshold() const
{
    if (m_thread)
        return m_thread->m_threshold;
    return 0;
}

void wxJoystick::SetMovementThreshold(int threshold)
{
    if (m_thread)
        m_thread->m_threshold = threshold;
}

////////////////////////////////////////////////////////////////////////////
// Capabilities
////////////////////////////////////////////////////////////////////////////

bool wxJoystick::IsOk() const
{
    return (m_device != -1);
}

int wxJoystick::GetNumberJoysticks()
{
    wxString dev_name;
    int fd, j;

    for (j=0; j<4; j++) {
        dev_name.Printf(wxT("/dev/js%d"), j);
        fd = open(dev_name.fn_str(), O_RDONLY);
        if (fd == -1)
            break;
        close(fd);
    }

    if (j == 0) {
        for (j=0; j<4; j++) {
            dev_name.Printf(wxT("/dev/input/js%d"), j);
            fd = open(dev_name.fn_str(), O_RDONLY);
            if (fd == -1)
                return j;
            close(fd);
        }
    }

    return j;
}

int wxJoystick::GetManufacturerId() const
{
    return 0;
}

int wxJoystick::GetProductId() const
{
    return 0;
}

wxString wxJoystick::GetProductName() const
{
    char name[128];

    if (ioctl(m_device, JSIOCGNAME(sizeof(name)), name) < 0)
        strcpy(name, "Unknown");
    return wxString(name, wxConvLibc);
}

int wxJoystick::GetXMin() const
{
    return wxJS_AXIS_MIN;
}

int wxJoystick::GetYMin() const
{
    return wxJS_AXIS_MIN;
}

int wxJoystick::GetZMin() const
{
    return wxJS_AXIS_MIN;
}

int wxJoystick::GetXMax() const
{
    return wxJS_AXIS_MAX;
}

int wxJoystick::GetYMax() const
{
    return wxJS_AXIS_MAX;
}

int wxJoystick::GetZMax() const
{
    return wxJS_AXIS_MAX;
}

int wxJoystick::GetNumberButtons() const
{
    char nb=0;

    if (m_device != -1)
        ioctl(m_device, JSIOCGBUTTONS, &nb);

    if ((int)nb > wxJS_MAX_BUTTONS)
        nb = wxJS_MAX_BUTTONS;

    return nb;
}

int wxJoystick::GetNumberAxes() const
{
    char nb=0;

    if (m_device != -1)
        ioctl(m_device, JSIOCGAXES, &nb);

    if ((int)nb > wxJS_MAX_AXES)
        nb = wxJS_MAX_AXES;

    return nb;
}

int wxJoystick::GetMaxButtons() const
{
    return wxJS_MAX_BUTTONS; // internal
}

int wxJoystick::GetMaxAxes() const
{
    return wxJS_MAX_AXES; // internal
}

int wxJoystick::GetPollingMin() const
{
    return 10;
}

int wxJoystick::GetPollingMax() const
{
    return 1000;
}

int wxJoystick::GetRudderMin() const
{
    return wxJS_AXIS_MIN;
}

int wxJoystick::GetRudderMax() const
{
    return wxJS_AXIS_MAX;
}

int wxJoystick::GetUMin() const
{
    return wxJS_AXIS_MIN;
}

int wxJoystick::GetUMax() const
{
    return wxJS_AXIS_MAX;
}

int wxJoystick::GetVMin() const
{
    return wxJS_AXIS_MIN;
}

int wxJoystick::GetVMax() const
{
    return wxJS_AXIS_MAX;
}

bool wxJoystick::HasRudder() const
{
    return GetNumberAxes() >= wxJS_AXIS_RUDDER;
}

bool wxJoystick::HasZ() const
{
    return GetNumberAxes() >= wxJS_AXIS_Z;
}

bool wxJoystick::HasU() const
{
    return GetNumberAxes() >= wxJS_AXIS_U;
}

bool wxJoystick::HasV() const
{
    return GetNumberAxes() >= wxJS_AXIS_V;
}

bool wxJoystick::HasPOV() const
{
    return false;
}

bool wxJoystick::HasPOV4Dir() const
{
    return false;
}

bool wxJoystick::HasPOVCTS() const
{
    return false;
}

////////////////////////////////////////////////////////////////////////////
// Operations
////////////////////////////////////////////////////////////////////////////

bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
{
    if (m_thread)
    {
        m_thread->m_catchwin = win;
        m_thread->m_polling = pollingFreq;
        return true;
    }
    return false;
}

bool wxJoystick::ReleaseCapture()
{
    if (m_thread)
    {
        m_thread->m_catchwin = NULL;
        m_thread->m_polling = 0;
        return true;
    }
    return false;
}
#endif  // wxUSE_JOYSTICK
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/unix/joystick.cpp
	3	// Purpose: wxJoystick class
	4	// Author: Ported to Linux by Guilhem Lavaux
	5	// Modified by:
	6	// Created: 05/23/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Guilhem Lavaux
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// for compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#if wxUSE_JOYSTICK
	16
	17	#include "wx/joystick.h"
	18
	19	#ifndef WX_PRECOMP
	20	#include "wx/event.h"
	21	#include "wx/window.h"
	22	#endif //WX_PRECOMP
	23
	24	#include "wx/thread.h"
	25
	26	#include <linux/joystick.h>
	27	#include <sys/types.h>
	28	#include <sys/stat.h>
	29	#include <sys/time.h>
	30	#include <sys/ioctl.h>
	31	#include <fcntl.h>
	32	#include <unistd.h>
	33
	34	#ifdef HAVE_SYS_SELECT_H
	35	# include <sys/select.h>
	36	#endif
	37
	38	#include "wx/unix/private.h"
	39
	40	enum {
	41	wxJS_AXIS_X = 0,
	42	wxJS_AXIS_Y,
	43	wxJS_AXIS_Z,
	44	wxJS_AXIS_RUDDER,
	45	wxJS_AXIS_U,
	46	wxJS_AXIS_V,
	47
	48	wxJS_AXIS_MAX = 32767,
	49	wxJS_AXIS_MIN = -32767,
	50	wxJS_MAX_AXES = 15,
	51	wxJS_MAX_BUTTONS = sizeof(int) * 8
	52	};
	53
	54
	55	IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
	56
	57
	58	////////////////////////////////////////////////////////////////////////////
	59	// Background thread for reading the joystick device
	60	////////////////////////////////////////////////////////////////////////////
	61
	62	class wxJoystickThread : public wxThread
	63	{
	64	public:
	65	wxJoystickThread(int device, int joystick);
	66	void* Entry();
	67
	68	private:
	69	void SendEvent(wxEventType type, long ts, int change = 0);
	70	int m_device;
	71	int m_joystick;
	72	wxPoint m_lastposition;
	73	int m_axe[wxJS_MAX_AXES];
	74	int m_buttons;
	75	wxWindow* m_catchwin;
	76	int m_polling;
	77	int m_threshold;
	78
	79	friend class wxJoystick;
	80	};
	81
	82
	83	wxJoystickThread::wxJoystickThread(int device, int joystick)
	84	: m_device(device),
	85	m_joystick(joystick),
	86	m_lastposition(wxDefaultPosition),
	87	m_buttons(0),
	88	m_catchwin(NULL),
	89	m_polling(0),
	90	m_threshold(0)
	91	{
	92	memset(m_axe, 0, sizeof(m_axe));
	93	}
	94
	95	void wxJoystickThread::SendEvent(wxEventType type, long ts, int change)
	96	{
	97	wxJoystickEvent jwx_event(type, m_buttons, m_joystick, change);
	98
	99	jwx_event.SetTimestamp(ts);
	100	jwx_event.SetPosition(m_lastposition);
	101	jwx_event.SetZPosition(m_axe[wxJS_AXIS_Z]);
	102	jwx_event.SetEventObject(m_catchwin);
	103
	104	if (m_catchwin)
	105	m_catchwin->GetEventHandler()->AddPendingEvent(jwx_event);
	106	}
	107
	108	void* wxJoystickThread::Entry()
	109	{
	110	struct js_event j_evt;
	111	fd_set read_fds;
	112	struct timeval time_out = {0, 0};
	113
	114	wxFD_ZERO(&read_fds);
	115	while (true)
	116	{
	117	if (TestDestroy())
	118	break;
	119
	120	// We use select when either polling or 'blocking' as even in the
	121	// blocking case we need to check TestDestroy periodically
	122	if (m_polling)
	123	time_out.tv_usec = m_polling * 1000;
	124	else
	125	time_out.tv_usec = 10 * 1000; // check at least every 10 msec in blocking case
	126
	127	wxFD_SET(m_device, &read_fds);
	128	select(m_device+1, &read_fds, NULL, NULL, &time_out);
	129	if (wxFD_ISSET(m_device, &read_fds))
	130	{
	131	memset(&j_evt, 0, sizeof(j_evt));
	132	read(m_device, &j_evt, sizeof(j_evt));
	133
	134	//printf("time: %d\t value: %d\t type: %d\t number: %d\n",
	135	// j_evt.time, j_evt.value, j_evt.type, j_evt.number);
	136
	137	if ((j_evt.type & JS_EVENT_AXIS) && (j_evt.number < wxJS_MAX_AXES))
	138	{
	139	if ( (m_axe[j_evt.number] + m_threshold < j_evt.value)
	140	\|\| (m_axe[j_evt.number] - m_threshold > j_evt.value) )
	141	{
	142	m_axe[j_evt.number] = j_evt.value;
	143
	144	switch (j_evt.number)
	145	{
	146	case wxJS_AXIS_X:
	147	m_lastposition.x = j_evt.value;
	148	SendEvent(wxEVT_JOY_MOVE, j_evt.time);
	149	break;
	150	case wxJS_AXIS_Y:
	151	m_lastposition.y = j_evt.value;
	152	SendEvent(wxEVT_JOY_MOVE, j_evt.time);
	153	break;
	154	case wxJS_AXIS_Z:
	155	SendEvent(wxEVT_JOY_ZMOVE, j_evt.time);
	156	break;
	157	default:
	158	SendEvent(wxEVT_JOY_MOVE, j_evt.time);
	159	// TODO: There should be a way to indicate that the event
	160	// is for some other axes.
	161	break;
	162	}
	163	}
	164	}
	165
	166	if ( (j_evt.type & JS_EVENT_BUTTON) && (j_evt.number < wxJS_MAX_BUTTONS) )
	167	{
	168	if (j_evt.value)
	169	{
	170	m_buttons \|= (1 << j_evt.number);
	171	SendEvent(wxEVT_JOY_BUTTON_DOWN, j_evt.time, j_evt.number);
	172	}
	173	else
	174	{
	175	m_buttons &= ~(1 << j_evt.number);
	176	SendEvent(wxEVT_JOY_BUTTON_UP, j_evt.time, j_evt.number);
	177	}
	178	}
	179	}
	180	}
	181
	182	close(m_device);
	183	return NULL;
	184	}
	185
	186
	187	////////////////////////////////////////////////////////////////////////////
	188
	189	wxJoystick::wxJoystick(int joystick)
	190	: m_device(-1),
	191	m_joystick(joystick),
	192	m_thread(NULL)
	193	{
	194	wxString dev_name;
	195
	196	// old /dev structure
	197	dev_name.Printf( wxT("/dev/js%d"), joystick);
	198	m_device = open(dev_name.fn_str(), O_RDONLY);
	199
	200	// new /dev structure with "input" subdirectory
	201	if (m_device == -1)
	202	{
	203	dev_name.Printf( wxT("/dev/input/js%d"), joystick);
	204	m_device = open(dev_name.fn_str(), O_RDONLY);
	205	}
	206
	207	if (m_device != -1)
	208	{
	209	m_thread = new wxJoystickThread(m_device, m_joystick);
	210	m_thread->Create();
	211	m_thread->Run();
	212	}
	213	}
	214
	215
	216	wxJoystick::~wxJoystick()
	217	{
	218	ReleaseCapture();
	219	if (m_thread)
	220	m_thread->Delete(); // It's detached so it will delete itself
	221	m_device = -1;
	222	}
	223
	224
	225	////////////////////////////////////////////////////////////////////////////
	226	// State
	227	////////////////////////////////////////////////////////////////////////////
	228
	229	wxPoint wxJoystick::GetPosition() const
	230	{
	231	wxPoint pos(wxDefaultPosition);
	232	if (m_thread) pos = m_thread->m_lastposition;
	233	return pos;
	234	}
	235
	236	int wxJoystick::GetPosition(unsigned axis) const
	237	{
	238	if (m_thread && (axis < wxJS_MAX_AXES))
	239	return m_thread->m_axe[axis];
	240	return 0;
	241	}
	242
	243	int wxJoystick::GetZPosition() const
	244	{
	245	if (m_thread)
	246	return m_thread->m_axe[wxJS_AXIS_Z];
	247	return 0;
	248	}
	249
	250	int wxJoystick::GetButtonState() const
	251	{
	252	if (m_thread)
	253	return m_thread->m_buttons;
	254	return 0;
	255	}
	256
	257	bool wxJoystick::GetButtonState(unsigned id) const
	258	{
	259	if (m_thread && (id < wxJS_MAX_BUTTONS))
	260	return (m_thread->m_buttons & (1 << id)) != 0;
	261	return false;
	262	}
	263
	264	int wxJoystick::GetPOVPosition() const
	265	{
	266	return -1;
	267	}
	268
	269	int wxJoystick::GetPOVCTSPosition() const
	270	{
	271	return -1;
	272	}
	273
	274	int wxJoystick::GetRudderPosition() const
	275	{
	276	if (m_thread)
	277	return m_thread->m_axe[wxJS_AXIS_RUDDER];
	278	return 0;
	279	}
	280
	281	int wxJoystick::GetUPosition() const
	282	{
	283	if (m_thread)
	284	return m_thread->m_axe[wxJS_AXIS_U];
	285	return 0;
	286	}
	287
	288	int wxJoystick::GetVPosition() const
	289	{
	290	if (m_thread)
	291	return m_thread->m_axe[wxJS_AXIS_V];
	292	return 0;
	293	}
	294
	295	int wxJoystick::GetMovementThreshold() const
	296	{
	297	if (m_thread)
	298	return m_thread->m_threshold;
	299	return 0;
	300	}
	301
	302	void wxJoystick::SetMovementThreshold(int threshold)
	303	{
	304	if (m_thread)
	305	m_thread->m_threshold = threshold;
	306	}
	307
	308	////////////////////////////////////////////////////////////////////////////
	309	// Capabilities
	310	////////////////////////////////////////////////////////////////////////////
	311
	312	bool wxJoystick::IsOk() const
	313	{
	314	return (m_device != -1);
	315	}
	316
	317	int wxJoystick::GetNumberJoysticks()
	318	{
	319	wxString dev_name;
	320	int fd, j;
	321
	322	for (j=0; j<4; j++) {
	323	dev_name.Printf(wxT("/dev/js%d"), j);
	324	fd = open(dev_name.fn_str(), O_RDONLY);
	325	if (fd == -1)
	326	break;
	327	close(fd);
	328	}
	329
	330	if (j == 0) {
	331	for (j=0; j<4; j++) {
	332	dev_name.Printf(wxT("/dev/input/js%d"), j);
	333	fd = open(dev_name.fn_str(), O_RDONLY);
	334	if (fd == -1)
	335	return j;
	336	close(fd);
	337	}
	338	}
	339
	340	return j;
	341	}
	342
	343	int wxJoystick::GetManufacturerId() const
	344	{
	345	return 0;
	346	}
	347
	348	int wxJoystick::GetProductId() const
	349	{
	350	return 0;
	351	}
	352
	353	wxString wxJoystick::GetProductName() const
	354	{
	355	char name[128];
	356
	357	if (ioctl(m_device, JSIOCGNAME(sizeof(name)), name) < 0)
	358	strcpy(name, "Unknown");
	359	return wxString(name, wxConvLibc);
	360	}
	361
	362	int wxJoystick::GetXMin() const
	363	{
	364	return wxJS_AXIS_MIN;
	365	}
	366
	367	int wxJoystick::GetYMin() const
	368	{
	369	return wxJS_AXIS_MIN;
	370	}
	371
	372	int wxJoystick::GetZMin() const
	373	{
	374	return wxJS_AXIS_MIN;
	375	}
	376
	377	int wxJoystick::GetXMax() const
	378	{
	379	return wxJS_AXIS_MAX;
	380	}
	381
	382	int wxJoystick::GetYMax() const
	383	{
	384	return wxJS_AXIS_MAX;
	385	}
	386
	387	int wxJoystick::GetZMax() const
	388	{
	389	return wxJS_AXIS_MAX;
	390	}
	391
	392	int wxJoystick::GetNumberButtons() const
	393	{
	394	char nb=0;
	395
	396	if (m_device != -1)
	397	ioctl(m_device, JSIOCGBUTTONS, &nb);
	398
	399	if ((int)nb > wxJS_MAX_BUTTONS)
	400	nb = wxJS_MAX_BUTTONS;
	401
	402	return nb;
	403	}
	404
	405	int wxJoystick::GetNumberAxes() const
	406	{
	407	char nb=0;
	408
	409	if (m_device != -1)
	410	ioctl(m_device, JSIOCGAXES, &nb);
	411
	412	if ((int)nb > wxJS_MAX_AXES)
	413	nb = wxJS_MAX_AXES;
	414
	415	return nb;
	416	}
	417
	418	int wxJoystick::GetMaxButtons() const
	419	{
	420	return wxJS_MAX_BUTTONS; // internal
	421	}
	422
	423	int wxJoystick::GetMaxAxes() const
	424	{
	425	return wxJS_MAX_AXES; // internal
	426	}
	427
	428	int wxJoystick::GetPollingMin() const
	429	{
	430	return 10;
	431	}
	432
	433	int wxJoystick::GetPollingMax() const
	434	{
	435	return 1000;
	436	}
	437
	438	int wxJoystick::GetRudderMin() const
	439	{
	440	return wxJS_AXIS_MIN;
	441	}
	442
	443	int wxJoystick::GetRudderMax() const
	444	{
	445	return wxJS_AXIS_MAX;
	446	}
	447
	448	int wxJoystick::GetUMin() const
	449	{
	450	return wxJS_AXIS_MIN;
	451	}
	452
	453	int wxJoystick::GetUMax() const
	454	{
	455	return wxJS_AXIS_MAX;
	456	}
	457
	458	int wxJoystick::GetVMin() const
	459	{
	460	return wxJS_AXIS_MIN;
	461	}
	462
	463	int wxJoystick::GetVMax() const
	464	{
	465	return wxJS_AXIS_MAX;
	466	}
	467
	468	bool wxJoystick::HasRudder() const
	469	{
	470	return GetNumberAxes() >= wxJS_AXIS_RUDDER;
	471	}
	472
	473	bool wxJoystick::HasZ() const
	474	{
	475	return GetNumberAxes() >= wxJS_AXIS_Z;
	476	}
	477
	478	bool wxJoystick::HasU() const
	479	{
	480	return GetNumberAxes() >= wxJS_AXIS_U;
	481	}
	482
	483	bool wxJoystick::HasV() const
	484	{
	485	return GetNumberAxes() >= wxJS_AXIS_V;
	486	}
	487
	488	bool wxJoystick::HasPOV() const
	489	{
	490	return false;
	491	}
	492
	493	bool wxJoystick::HasPOV4Dir() const
	494	{
	495	return false;
	496	}
	497
	498	bool wxJoystick::HasPOVCTS() const
	499	{
	500	return false;
	501	}
	502
	503	////////////////////////////////////////////////////////////////////////////
	504	// Operations
	505	////////////////////////////////////////////////////////////////////////////
	506
	507	bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
	508	{
	509	if (m_thread)
	510	{
	511	m_thread->m_catchwin = win;
	512	m_thread->m_polling = pollingFreq;
	513	return true;
	514	}
	515	return false;
	516	}
	517
	518	bool wxJoystick::ReleaseCapture()
	519	{
	520	if (m_thread)
	521	{
	522	m_thread->m_catchwin = NULL;
	523	m_thread->m_polling = 0;
	524	return true;
	525	}
	526	return false;
	527	}
	528	#endif // wxUSE_JOYSTICK