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
// 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"
    #include "wx/log.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))
            {
                // Ignore invalid axis.
                if ( j_evt.number >= wxJS_MAX_AXES )
                {
                    wxLogDebug(wxS("Invalid axis index %d in joystick message."),
                               j_evt.number);
                    continue;
                }

                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	// Copyright: (c) Guilhem Lavaux
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// for compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#if wxUSE_JOYSTICK
	15
	16	#include "wx/joystick.h"
	17
	18	#ifndef WX_PRECOMP
	19	#include "wx/event.h"
	20	#include "wx/window.h"
	21	#include "wx/log.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	// Ignore invalid axis.
	140	if ( j_evt.number >= wxJS_MAX_AXES )
	141	{
	142	wxLogDebug(wxS("Invalid axis index %d in joystick message."),
	143	j_evt.number);
	144	continue;
	145	}
	146
	147	if ( (m_axe[j_evt.number] + m_threshold < j_evt.value)
	148	\|\| (m_axe[j_evt.number] - m_threshold > j_evt.value) )
	149	{
	150	m_axe[j_evt.number] = j_evt.value;
	151
	152	switch (j_evt.number)
	153	{
	154	case wxJS_AXIS_X:
	155	m_lastposition.x = j_evt.value;
	156	SendEvent(wxEVT_JOY_MOVE, j_evt.time);
	157	break;
	158	case wxJS_AXIS_Y:
	159	m_lastposition.y = j_evt.value;
	160	SendEvent(wxEVT_JOY_MOVE, j_evt.time);
	161	break;
	162	case wxJS_AXIS_Z:
	163	SendEvent(wxEVT_JOY_ZMOVE, j_evt.time);
	164	break;
	165	default:
	166	SendEvent(wxEVT_JOY_MOVE, j_evt.time);
	167	// TODO: There should be a way to indicate that the event
	168	// is for some other axes.
	169	break;
	170	}
	171	}
	172	}
	173
	174	if ( (j_evt.type & JS_EVENT_BUTTON) && (j_evt.number < wxJS_MAX_BUTTONS) )
	175	{
	176	if (j_evt.value)
	177	{
	178	m_buttons \|= (1 << j_evt.number);
	179	SendEvent(wxEVT_JOY_BUTTON_DOWN, j_evt.time, j_evt.number);
	180	}
	181	else
	182	{
	183	m_buttons &= ~(1 << j_evt.number);
	184	SendEvent(wxEVT_JOY_BUTTON_UP, j_evt.time, j_evt.number);
	185	}
	186	}
	187	}
	188	}
	189
	190	close(m_device);
	191	return NULL;
	192	}
	193
	194
	195	////////////////////////////////////////////////////////////////////////////
	196
	197	wxJoystick::wxJoystick(int joystick)
	198	: m_device(-1),
	199	m_joystick(joystick),
	200	m_thread(NULL)
	201	{
	202	wxString dev_name;
	203
	204	// old /dev structure
	205	dev_name.Printf( wxT("/dev/js%d"), joystick);
	206	m_device = open(dev_name.fn_str(), O_RDONLY);
	207
	208	// new /dev structure with "input" subdirectory
	209	if (m_device == -1)
	210	{
	211	dev_name.Printf( wxT("/dev/input/js%d"), joystick);
	212	m_device = open(dev_name.fn_str(), O_RDONLY);
	213	}
	214
	215	if (m_device != -1)
	216	{
	217	m_thread = new wxJoystickThread(m_device, m_joystick);
	218	m_thread->Create();
	219	m_thread->Run();
	220	}
	221	}
	222
	223
	224	wxJoystick::~wxJoystick()
	225	{
	226	ReleaseCapture();
	227	if (m_thread)
	228	m_thread->Delete(); // It's detached so it will delete itself
	229	m_device = -1;
	230	}
	231
	232
	233	////////////////////////////////////////////////////////////////////////////
	234	// State
	235	////////////////////////////////////////////////////////////////////////////
	236
	237	wxPoint wxJoystick::GetPosition() const
	238	{
	239	wxPoint pos(wxDefaultPosition);
	240	if (m_thread) pos = m_thread->m_lastposition;
	241	return pos;
	242	}
	243
	244	int wxJoystick::GetPosition(unsigned axis) const
	245	{
	246	if (m_thread && (axis < wxJS_MAX_AXES))
	247	return m_thread->m_axe[axis];
	248	return 0;
	249	}
	250
	251	int wxJoystick::GetZPosition() const
	252	{
	253	if (m_thread)
	254	return m_thread->m_axe[wxJS_AXIS_Z];
	255	return 0;
	256	}
	257
	258	int wxJoystick::GetButtonState() const
	259	{
	260	if (m_thread)
	261	return m_thread->m_buttons;
	262	return 0;
	263	}
	264
	265	bool wxJoystick::GetButtonState(unsigned id) const
	266	{
	267	if (m_thread && (id < wxJS_MAX_BUTTONS))
	268	return (m_thread->m_buttons & (1 << id)) != 0;
	269	return false;
	270	}
	271
	272	int wxJoystick::GetPOVPosition() const
	273	{
	274	return -1;
	275	}
	276
	277	int wxJoystick::GetPOVCTSPosition() const
	278	{
	279	return -1;
	280	}
	281
	282	int wxJoystick::GetRudderPosition() const
	283	{
	284	if (m_thread)
	285	return m_thread->m_axe[wxJS_AXIS_RUDDER];
	286	return 0;
	287	}
	288
	289	int wxJoystick::GetUPosition() const
	290	{
	291	if (m_thread)
	292	return m_thread->m_axe[wxJS_AXIS_U];
	293	return 0;
	294	}
	295
	296	int wxJoystick::GetVPosition() const
	297	{
	298	if (m_thread)
	299	return m_thread->m_axe[wxJS_AXIS_V];
	300	return 0;
	301	}
	302
	303	int wxJoystick::GetMovementThreshold() const
	304	{
	305	if (m_thread)
	306	return m_thread->m_threshold;
	307	return 0;
	308	}
	309
	310	void wxJoystick::SetMovementThreshold(int threshold)
	311	{
	312	if (m_thread)
	313	m_thread->m_threshold = threshold;
	314	}
	315
	316	////////////////////////////////////////////////////////////////////////////
	317	// Capabilities
	318	////////////////////////////////////////////////////////////////////////////
	319
	320	bool wxJoystick::IsOk() const
	321	{
	322	return (m_device != -1);
	323	}
	324
	325	int wxJoystick::GetNumberJoysticks()
	326	{
	327	wxString dev_name;
	328	int fd, j;
	329
	330	for (j=0; j<4; j++) {
	331	dev_name.Printf(wxT("/dev/js%d"), j);
	332	fd = open(dev_name.fn_str(), O_RDONLY);
	333	if (fd == -1)
	334	break;
	335	close(fd);
	336	}
	337
	338	if (j == 0) {
	339	for (j=0; j<4; j++) {
	340	dev_name.Printf(wxT("/dev/input/js%d"), j);
	341	fd = open(dev_name.fn_str(), O_RDONLY);
	342	if (fd == -1)
	343	return j;
	344	close(fd);
	345	}
	346	}
	347
	348	return j;
	349	}
	350
	351	int wxJoystick::GetManufacturerId() const
	352	{
	353	return 0;
	354	}
	355
	356	int wxJoystick::GetProductId() const
	357	{
	358	return 0;
	359	}
	360
	361	wxString wxJoystick::GetProductName() const
	362	{
	363	char name[128];
	364
	365	if (ioctl(m_device, JSIOCGNAME(sizeof(name)), name) < 0)
	366	strcpy(name, "Unknown");
	367	return wxString(name, wxConvLibc);
	368	}
	369
	370	int wxJoystick::GetXMin() const
	371	{
	372	return wxJS_AXIS_MIN;
	373	}
	374
	375	int wxJoystick::GetYMin() const
	376	{
	377	return wxJS_AXIS_MIN;
	378	}
	379
	380	int wxJoystick::GetZMin() const
	381	{
	382	return wxJS_AXIS_MIN;
	383	}
	384
	385	int wxJoystick::GetXMax() const
	386	{
	387	return wxJS_AXIS_MAX;
	388	}
	389
	390	int wxJoystick::GetYMax() const
	391	{
	392	return wxJS_AXIS_MAX;
	393	}
	394
	395	int wxJoystick::GetZMax() const
	396	{
	397	return wxJS_AXIS_MAX;
	398	}
	399
	400	int wxJoystick::GetNumberButtons() const
	401	{
	402	char nb=0;
	403
	404	if (m_device != -1)
	405	ioctl(m_device, JSIOCGBUTTONS, &nb);
	406
	407	if ((int)nb > wxJS_MAX_BUTTONS)
	408	nb = wxJS_MAX_BUTTONS;
	409
	410	return nb;
	411	}
	412
	413	int wxJoystick::GetNumberAxes() const
	414	{
	415	char nb=0;
	416
	417	if (m_device != -1)
	418	ioctl(m_device, JSIOCGAXES, &nb);
	419
	420	if ((int)nb > wxJS_MAX_AXES)
	421	nb = wxJS_MAX_AXES;
	422
	423	return nb;
	424	}
	425
	426	int wxJoystick::GetMaxButtons() const
	427	{
	428	return wxJS_MAX_BUTTONS; // internal
	429	}
	430
	431	int wxJoystick::GetMaxAxes() const
	432	{
	433	return wxJS_MAX_AXES; // internal
	434	}
	435
	436	int wxJoystick::GetPollingMin() const
	437	{
	438	return 10;
	439	}
	440
	441	int wxJoystick::GetPollingMax() const
	442	{
	443	return 1000;
	444	}
	445
	446	int wxJoystick::GetRudderMin() const
	447	{
	448	return wxJS_AXIS_MIN;
	449	}
	450
	451	int wxJoystick::GetRudderMax() const
	452	{
	453	return wxJS_AXIS_MAX;
	454	}
	455
	456	int wxJoystick::GetUMin() const
	457	{
	458	return wxJS_AXIS_MIN;
	459	}
	460
	461	int wxJoystick::GetUMax() const
	462	{
	463	return wxJS_AXIS_MAX;
	464	}
	465
	466	int wxJoystick::GetVMin() const
	467	{
	468	return wxJS_AXIS_MIN;
	469	}
	470
	471	int wxJoystick::GetVMax() const
	472	{
	473	return wxJS_AXIS_MAX;
	474	}
	475
	476	bool wxJoystick::HasRudder() const
	477	{
	478	return GetNumberAxes() >= wxJS_AXIS_RUDDER;
	479	}
	480
	481	bool wxJoystick::HasZ() const
	482	{
	483	return GetNumberAxes() >= wxJS_AXIS_Z;
	484	}
	485
	486	bool wxJoystick::HasU() const
	487	{
	488	return GetNumberAxes() >= wxJS_AXIS_U;
	489	}
	490
	491	bool wxJoystick::HasV() const
	492	{
	493	return GetNumberAxes() >= wxJS_AXIS_V;
	494	}
	495
	496	bool wxJoystick::HasPOV() const
	497	{
	498	return false;
	499	}
	500
	501	bool wxJoystick::HasPOV4Dir() const
	502	{
	503	return false;
	504	}
	505
	506	bool wxJoystick::HasPOVCTS() const
	507	{
	508	return false;
	509	}
	510
	511	////////////////////////////////////////////////////////////////////////////
	512	// Operations
	513	////////////////////////////////////////////////////////////////////////////
	514
	515	bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
	516	{
	517	if (m_thread)
	518	{
	519	m_thread->m_catchwin = win;
	520	m_thread->m_polling = pollingFreq;
	521	return true;
	522	}
	523	return false;
	524	}
	525
	526	bool wxJoystick::ReleaseCapture()
	527	{
	528	if (m_thread)
	529	{
	530	m_thread->m_catchwin = NULL;
	531	m_thread->m_polling = 0;
	532	return true;
	533	}
	534	return false;
	535	}
	536	#endif // wxUSE_JOYSTICK