[wxWidgets.git] / src / mac / corefoundation / hidjoystick.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        joystick.cpp
// Purpose:     wxJoystick class
// Author:      Ryan Norton
// Modified by:
// Created:     2/13/2005
// RCS-ID:      $Id$
// Copyright:   (c) Ryan Norton
// Licence:       wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "joystick.h"
#endif

#include "wx/wxprec.h"

#ifdef __DARWIN__

#if wxUSE_JOYSTICK

#include "wx/event.h"
#include "wx/log.h"
#include "wx/joystick.h"
#include "wx/thread.h"
#include "wx/window.h"

#include "wx/mac/corefoundation/hid.h"

#include <CoreServices/CoreServices.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <unistd.h>

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

    wxJS_AXIS_MAX = 255, //32767,
    wxJS_AXIS_MIN = 0, //-32767
};

class wxHIDJoystick : public wxHIDDevice
{
public:
	bool Create(int nWhich);
	virtual void BuildCookies(wxCFArray& Array);
	void MakeCookies(wxCFArray& Array);
    IOHIDElementCookie* GetCookies() {return m_pCookies;}
    IOHIDQueueInterface** GetQueue() {return m_ppQueue;}
    
    friend class wxJoystick;
};


bool wxHIDJoystick::Create(int nWhich)
{
    int nJoysticks = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
    
    if (nWhich <= nJoysticks)
        return wxHIDDevice::Create(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
    else
        nWhich -= nJoysticks;
    
    int nGamePads = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
    
    if (nWhich <= nGamePads)
        return wxHIDDevice::Create(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
    else
        return false;
}

void wxHIDJoystick::BuildCookies(wxCFArray& Array)
{
	Array = CFDictionaryGetValue((CFDictionaryRef)Array[0], CFSTR(kIOHIDElementKey));
	InitCookies(50, true);

    memset(m_pCookies, 0, sizeof(*m_pCookies) * 50);
    MakeCookies(Array);
    
//    for(int i = 0; i < 50; ++i)
//        wxPrintf(wxT("\nVAL #%i:[%i]"), i, m_pCookies[i]);
}//end buildcookies

void wxHIDJoystick::MakeCookies(wxCFArray& Array)
{
	int i,
		nUsage,
        nPage;
	for (i = 0; i < Array.Count(); ++i)
	{
        const void* ref = CFDictionaryGetValue((CFDictionaryRef)Array[i], CFSTR(kIOHIDElementKey));

//        wxPrintf(wxT("ELM\n"));
        if (ref  != NULL)
        {
            wxCFArray newarray(ref);
            MakeCookies(newarray);
        }
        else
        {
            CFNumberGetValue(
			(CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) Array[i], CFSTR(kIOHIDElementUsageKey)), 
				kCFNumberLongType, &nUsage);
			
            CFNumberGetValue(
			(CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) Array[i], CFSTR(kIOHIDElementUsagePageKey)), 
				kCFNumberLongType, &nPage);

            if (nPage == kHIDPage_Button && nUsage <= 40)
                AddCookieInQueue(Array[i], nUsage-1 );
            else if (nPage == kHIDPage_GenericDesktop)
            {
                switch(nUsage)
                {
                    case kHIDUsage_GD_X:
                        AddCookieInQueue(Array[i], wxJS_AXIS_X);
                        break;                    
                    case kHIDUsage_GD_Y:
                        AddCookieInQueue(Array[i], wxJS_AXIS_Y);
                        break;
                    case kHIDUsage_GD_Z:
                        AddCookieInQueue(Array[i], wxJS_AXIS_Z);
                        break;
                    default:
                        break;
                }
            }
            else if (nPage == kHIDPage_Simulation && nUsage == kHIDUsage_Sim_Rudder)
                AddCookieInQueue(Array[i], wxJS_AXIS_RUDDER );
        }
	}
}


IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)


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

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

    static void HIDCallback(void* target, IOReturn res, void* context, void* sender)
    {
        IOHIDEventStruct hidevent;
        AbsoluteTime bogustime = {0,0};
        IOReturn ret;
        wxJoystickThread* pThis = (wxJoystickThread*) context;
        wxHIDJoystick* m_hid = pThis->m_hid;
        
//        wxMutexGuiEnter();
        ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(), 
                        &hidevent, bogustime, 0);
  //      wxMutexGuiLeave(); 
        while (    ret != kIOReturnUnderrun )
        {
            if (pThis->TestDestroy())
                break;

//            wxPrintf(wxT("ENTER\n"));
            if(ret != kIOReturnSuccess)
            {
                wxLogSysError(wxString::Format(wxT("wxJoystick Error:[%i]"), ret));
                return;
            }	
                
            wxJoystickEvent wxevent;
            
            int nIndex = 0;
            IOHIDElementCookie* pCookies = m_hid->GetCookies();
            while(nIndex < 50)
            {
                if(hidevent.elementCookie == pCookies[nIndex])
                    break;
                    
                ++nIndex;
            } 
            if(nIndex == 50)
            {
                wxLogSysError(wxString::Format(wxT("wxJoystick Out Of Bounds Error")));
                break;
            }	
            
            if (nIndex < 40)
            {
                if (hidevent.value)
                {
                    pThis->m_buttons |= (1 << nIndex);
                    wxevent.SetEventType(wxEVT_JOY_BUTTON_DOWN);
                }
                else
                {
                    pThis->m_buttons &= ~(1 << nIndex);
                    wxevent.SetEventType(wxEVT_JOY_BUTTON_UP);
                }

                wxevent.SetButtonChange(nIndex+1);
            }
            else if (nIndex == wxJS_AXIS_X)
            {
                pThis->m_lastposition.x = hidevent.value;
                wxevent.SetEventType(wxEVT_JOY_MOVE);
                pThis->m_axe[0] = hidevent.value;
            }
            else if (nIndex == wxJS_AXIS_Y)
            {
                pThis->m_lastposition.y = hidevent.value;
                wxevent.SetEventType(wxEVT_JOY_MOVE);
                pThis->m_axe[1] = hidevent.value;
            }
            else if (nIndex == wxJS_AXIS_Z)
            {
                wxevent.SetEventType(wxEVT_JOY_ZMOVE);
                pThis->m_axe[2] = hidevent.value;
            }
            else
                wxevent.SetEventType(wxEVT_JOY_MOVE);            

            Nanoseconds timestamp = AbsoluteToNanoseconds(hidevent.timestamp);
            
            wxULongLong llTime(timestamp.hi, timestamp.lo);
            
            llTime /= 1000000;
            
            wxevent.SetTimestamp(llTime.GetValue());
            wxevent.SetJoystick(pThis->m_joystick);
            wxevent.SetButtonState(pThis->m_buttons);
            wxevent.SetPosition(pThis->m_lastposition);
            wxevent.SetZPosition(pThis->m_axe[2]);
            wxevent.SetEventObject(pThis->m_catchwin);

//            wxPrintf(wxT("SEND\n"));

            if (pThis->m_catchwin)
                pThis->m_catchwin->AddPendingEvent(wxevent);            

         //   wxMutexGuiEnter();
            ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(), 
                        &hidevent, bogustime, 0);
           // wxMutexGuiLeave(); 
        }
    }
    
private:
    wxHIDJoystick*       m_hid;
    int       m_joystick;
    wxPoint   m_lastposition;
    int       m_axe[15];
    int       m_buttons;
    wxWindow* m_catchwin;
    int       m_polling;

    friend class wxJoystick;
};


wxJoystickThread::wxJoystickThread(wxHIDJoystick* hid, int joystick)
    : m_hid(hid),
      m_joystick(joystick),
      m_lastposition(127,127),
      m_buttons(0),
      m_catchwin(NULL),
      m_polling(0)
{
    for (int i=0; i<15; i++)
        m_axe[i] = 0;
}


#	define wxJSVERIFY(arg)	if(!(arg)) {wxLogSysError(wxT(#arg)); return NULL;}
#	define wxJSASSERT(arg)	wxJSVERIFY(arg)

void* wxJoystickThread::Entry()
{
    CFRunLoopSourceRef pRLSource = NULL;

    wxJSVERIFY( (*m_hid->GetQueue())->createAsyncEventSource(m_hid->GetQueue(), &pRLSource) 
                        == kIOReturnSuccess );
    wxJSASSERT(pRLSource != NULL);

    //attach runloop source to main run loop in thread
    CFRunLoopRef pRL = CFRunLoopGetCurrent();  
    CFRunLoopAddSource(pRL, pRLSource, kCFRunLoopDefaultMode);
      
    wxJSVERIFY( (*m_hid->GetQueue())->start(m_hid->GetQueue()) == kIOReturnSuccess ); 
    wxJSVERIFY( (*m_hid->GetQueue())->setEventCallout(m_hid->GetQueue(), &wxJoystickThread::HIDCallback, this, this) == kIOReturnSuccess ); 
    
    double dTime;
    
    while(true)
    {
        if (TestDestroy())
            break;

        if (m_polling)
            dTime = 0.0001 * m_polling;
        else
            dTime = 0.0001 * 10;  // check at least every 10 msec in blocking case

        CFRunLoopRunInMode(kCFRunLoopDefaultMode, dTime, true);        
    }
    
    wxJSASSERT( CFRunLoopContainsSource(pRL, pRLSource, kCFRunLoopDefaultMode) );
    CFRunLoopRemoveSource(pRL, pRLSource, kCFRunLoopDefaultMode);
    CFRelease(pRLSource);

    return NULL;
}


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

wxJoystick::wxJoystick(int joystick)
    : m_joystick(joystick),
      m_thread(NULL)
{
    m_hid = new wxHIDJoystick();

    if (m_hid->Create(m_joystick))
    {
        m_thread = new wxJoystickThread(m_hid, m_joystick);
        m_thread->Create();
        m_thread->Run();
    }
    else
    {
        delete m_hid;
        m_hid = NULL;
    }
}


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


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

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

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;
}

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
{	return 0;				}

void wxJoystick::SetMovementThreshold(int threshold)
{							}

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

bool wxJoystick::IsOk() const
{	return m_hid != NULL;	}

int wxJoystick::GetNumberJoysticks() const
{    return wxHIDDevice::GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick) +
            wxHIDDevice::GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);   }
    
int wxJoystick::GetManufacturerId() const
{	return m_hid->m_nManufacturerId;				}

int wxJoystick::GetProductId() const
{	return m_hid->m_nProductId;				}

wxString wxJoystick::GetProductName() const
{	return m_hid->m_szProductName;				}

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
{
    int nCount = 0;
    
    for(int nIndex = 0; nIndex < 40; ++nIndex)
    {
        if(m_hid->HasElement(nIndex))
            ++nCount;
    }
    
    return nCount;
}

int wxJoystick::GetNumberAxes() const
{
    int nCount = 0;
    
    for(int nIndex = 40; nIndex < 50; ++nIndex)
    {
        if(m_hid->HasElement(nIndex))
            ++nCount;
    }
    
    return nCount;
}

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

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

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 m_hid->HasElement(wxJS_AXIS_RUDDER);	}

bool wxJoystick::HasZ() const
{	return m_hid->HasElement(wxJS_AXIS_Z);	}

bool wxJoystick::HasU() const
{	return m_hid->HasElement(wxJS_AXIS_U);	}

bool wxJoystick::HasV() const
{	return m_hid->HasElement(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
    //OSX 
    
#endif
    // wxUSE_JOYSTICK
Commit	Line	Data
4cb1d3da RN	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: joystick.cpp
	3	// Purpose: wxJoystick class
	4	// Author: Ryan Norton
	5	// Modified by:
	6	// Created: 2/13/2005
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Ryan Norton
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	13	#pragma implementation "joystick.h"
	14	#endif
	15
	16	#include "wx/wxprec.h"
	17
	18	#ifdef __DARWIN__
	19
	20	#if wxUSE_JOYSTICK
	21
	22	#include "wx/event.h"
	23	#include "wx/log.h"
	24	#include "wx/joystick.h"
	25	#include "wx/thread.h"
	26	#include "wx/window.h"
	27
	28	#include "wx/mac/corefoundation/hid.h"
	29
	30	#include <CoreServices/CoreServices.h>
	31	#include <mach/mach.h>
	32	#include <mach/mach_time.h>
	33	#include <unistd.h>
	34
	35	enum {
65442ab6	36	wxJS_AXIS_X = 40,
4cb1d3da RN	37	wxJS_AXIS_Y,
	38	wxJS_AXIS_Z,
	39	wxJS_AXIS_RUDDER,
	40	wxJS_AXIS_U,
	41	wxJS_AXIS_V,
	42
65442ab6 RN	43	wxJS_AXIS_MAX = 255, //32767,
65442ab6 RN	44	wxJS_AXIS_MIN = 0, //-32767
4cb1d3da RN	45	};
	46
	47	class wxHIDJoystick : public wxHIDDevice
	48	{
	49	public:
	50	bool Create(int nWhich);
	51	virtual void BuildCookies(wxCFArray& Array);
65442ab6	52	void MakeCookies(wxCFArray& Array);
4cb1d3da	53	IOHIDElementCookie* GetCookies() {return m_pCookies;}
4cb1d3da	54	IOHIDQueueInterface** GetQueue() {return m_ppQueue;}
65442ab6 RN	55
65442ab6 RN	56	friend class wxJoystick;
4cb1d3da RN	57	};
	58
	59
	60	bool wxHIDJoystick::Create(int nWhich)
	61	{
	62	int nJoysticks = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
	63
	64	if (nWhich <= nJoysticks)
	65	return wxHIDDevice::Create(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
	66	else
	67	nWhich -= nJoysticks;
	68
	69	int nGamePads = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
	70
	71	if (nWhich <= nGamePads)
	72	return wxHIDDevice::Create(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
	73	else
	74	return false;
	75	}
	76
	77	void wxHIDJoystick::BuildCookies(wxCFArray& Array)
	78	{
	79	Array = CFDictionaryGetValue((CFDictionaryRef)Array[0], CFSTR(kIOHIDElementKey));
	80	InitCookies(50, true);
65442ab6 RN	81
	82	memset(m_pCookies, 0, sizeof(m_pCookies) 50);
	83	MakeCookies(Array);
	84
	85	// for(int i = 0; i < 50; ++i)
	86	// wxPrintf(wxT("\nVAL #%i:[%i]"), i, m_pCookies[i]);
	87	}//end buildcookies
	88
	89	void wxHIDJoystick::MakeCookies(wxCFArray& Array)
	90	{
4cb1d3da RN	91	int i,
	92	nUsage,
	93	nPage;
	94	for (i = 0; i < Array.Count(); ++i)
	95	{
65442ab6 RN	96	const void* ref = CFDictionaryGetValue((CFDictionaryRef)Array[i], CFSTR(kIOHIDElementKey));
	97
	98	// wxPrintf(wxT("ELM\n"));
	99	if (ref != NULL)
	100	{
	101	wxCFArray newarray(ref);
	102	MakeCookies(newarray);
	103	}
	104	else
	105	{
	106	CFNumberGetValue(
4cb1d3da RN	107	(CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) Array[i], CFSTR(kIOHIDElementUsageKey)),
	108	kCFNumberLongType, &nUsage);
	109
65442ab6	110	CFNumberGetValue(
4cb1d3da RN	111	(CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) Array[i], CFSTR(kIOHIDElementUsagePageKey)),
	112	kCFNumberLongType, &nPage);
	113
65442ab6 RN	114	if (nPage == kHIDPage_Button && nUsage <= 40)
	115	AddCookieInQueue(Array[i], nUsage-1 );
	116	else if (nPage == kHIDPage_GenericDesktop)
4cb1d3da	117	{
65442ab6 RN	118	switch(nUsage)
	119	{
	120	case kHIDUsage_GD_X:
	121	AddCookieInQueue(Array[i], wxJS_AXIS_X);
	122	break;
	123	case kHIDUsage_GD_Y:
	124	AddCookieInQueue(Array[i], wxJS_AXIS_Y);
	125	break;
	126	case kHIDUsage_GD_Z:
	127	AddCookieInQueue(Array[i], wxJS_AXIS_Z);
	128	break;
	129	default:
	130	break;
	131	}
4cb1d3da	132	}
65442ab6 RN	133	else if (nPage == kHIDPage_Simulation && nUsage == kHIDUsage_Sim_Rudder)
65442ab6 RN	134	AddCookieInQueue(Array[i], wxJS_AXIS_RUDDER );
4cb1d3da	135	}
4cb1d3da	136	}
65442ab6	137	}
4cb1d3da RN	138
	139
	140
	141	IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
	142
	143
	144	////////////////////////////////////////////////////////////////////////////
	145	// Background thread for reading the joystick device
	146	////////////////////////////////////////////////////////////////////////////
	147
	148	class wxJoystickThread : public wxThread
	149	{
	150	public:
	151	wxJoystickThread(wxHIDJoystick* hid, int joystick);
	152	void* Entry();
	153
65442ab6 RN	154	static void HIDCallback(void* target, IOReturn res, void* context, void* sender)
	155	{
	156	IOHIDEventStruct hidevent;
	157	AbsoluteTime bogustime = {0,0};
	158	IOReturn ret;
	159	wxJoystickThread* pThis = (wxJoystickThread*) context;
	160	wxHIDJoystick* m_hid = pThis->m_hid;
	161
	162	// wxMutexGuiEnter();
	163	ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(),
	164	&hidevent, bogustime, 0);
	165	// wxMutexGuiLeave();
	166	while ( ret != kIOReturnUnderrun )
	167	{
	168	if (pThis->TestDestroy())
	169	break;
	170
	171	// wxPrintf(wxT("ENTER\n"));
	172	if(ret != kIOReturnSuccess)
	173	{
	174	wxLogSysError(wxString::Format(wxT("wxJoystick Error:[%i]"), ret));
	175	return;
	176	}
	177
	178	wxJoystickEvent wxevent;
	179
	180	int nIndex = 0;
	181	IOHIDElementCookie* pCookies = m_hid->GetCookies();
	182	while(nIndex < 50)
	183	{
	184	if(hidevent.elementCookie == pCookies[nIndex])
	185	break;
	186
	187	++nIndex;
	188	}
	189	if(nIndex == 50)
	190	{
	191	wxLogSysError(wxString::Format(wxT("wxJoystick Out Of Bounds Error")));
	192	break;
	193	}
	194
	195	if (nIndex < 40)
	196	{
	197	if (hidevent.value)
	198	{
	199	pThis->m_buttons \|= (1 << nIndex);
	200	wxevent.SetEventType(wxEVT_JOY_BUTTON_DOWN);
	201	}
	202	else
	203	{
	204	pThis->m_buttons &= ~(1 << nIndex);
	205	wxevent.SetEventType(wxEVT_JOY_BUTTON_UP);
	206	}
	207
	208	wxevent.SetButtonChange(nIndex+1);
	209	}
	210	else if (nIndex == wxJS_AXIS_X)
	211	{
	212	pThis->m_lastposition.x = hidevent.value;
	213	wxevent.SetEventType(wxEVT_JOY_MOVE);
	214	pThis->m_axe[0] = hidevent.value;
	215	}
	216	else if (nIndex == wxJS_AXIS_Y)
	217	{
218	pThis->m_lastposition.y = hidevent.value;
219	wxevent.SetEventType(wxEVT_JOY_MOVE);
220	pThis->m_axe[1] = hidevent.value;
221	}
222	else if (nIndex == wxJS_AXIS_Z)
223	{
224	wxevent.SetEventType(wxEVT_JOY_ZMOVE);
225	pThis->m_axe[2] = hidevent.value;
226	}
227	else
228	wxevent.SetEventType(wxEVT_JOY_MOVE);
229
230	Nanoseconds timestamp = AbsoluteToNanoseconds(hidevent.timestamp);
231
232	wxULongLong llTime(timestamp.hi, timestamp.lo);
233
234	llTime /= 1000000;
235
236	wxevent.SetTimestamp(llTime.GetValue());
237	wxevent.SetJoystick(pThis->m_joystick);
238	wxevent.SetButtonState(pThis->m_buttons);
239	wxevent.SetPosition(pThis->m_lastposition);
240	wxevent.SetZPosition(pThis->m_axe[2]);
241	wxevent.SetEventObject(pThis->m_catchwin);
242
243	// wxPrintf(wxT("SEND\n"));
244
245	if (pThis->m_catchwin)
246	pThis->m_catchwin->AddPendingEvent(wxevent);
247
248	// wxMutexGuiEnter();
249	ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(),
250	&hidevent, bogustime, 0);
251	// wxMutexGuiLeave();
252	}
253	}
254
4cb1d3da RN	255	private:
	256	wxHIDJoystick* m_hid;
	257	int m_joystick;
	258	wxPoint m_lastposition;
	259	int m_axe[15];
	260	int m_buttons;
	261	wxWindow* m_catchwin;
	262	int m_polling;
	263
	264	friend class wxJoystick;
	265	};
	266
	267
	268	wxJoystickThread::wxJoystickThread(wxHIDJoystick* hid, int joystick)
	269	: m_hid(hid),
	270	m_joystick(joystick),
65442ab6	271	m_lastposition(127,127),
4cb1d3da RN	272	m_buttons(0),
	273	m_catchwin(NULL),
	274	m_polling(0)
	275	{
	276	for (int i=0; i<15; i++)
	277	m_axe[i] = 0;
	278	}
	279
	280
	281	# define wxJSVERIFY(arg) if(!(arg)) {wxLogSysError(wxT(#arg)); return NULL;}
	282	# define wxJSASSERT(arg) wxJSVERIFY(arg)
	283
	284	void* wxJoystickThread::Entry()
	285	{
	286	CFRunLoopSourceRef pRLSource = NULL;
	287
	288	wxJSVERIFY( (*m_hid->GetQueue())->createAsyncEventSource(m_hid->GetQueue(), &pRLSource)
	289	== kIOReturnSuccess );
	290	wxJSASSERT(pRLSource != NULL);
	291
	292	//attach runloop source to main run loop in thread
	293	CFRunLoopRef pRL = CFRunLoopGetCurrent();
	294	CFRunLoopAddSource(pRL, pRLSource, kCFRunLoopDefaultMode);
	295
65442ab6 RN	296	wxJSVERIFY( (*m_hid->GetQueue())->start(m_hid->GetQueue()) == kIOReturnSuccess );
65442ab6 RN	297	wxJSVERIFY( (*m_hid->GetQueue())->setEventCallout(m_hid->GetQueue(), &wxJoystickThread::HIDCallback, this, this) == kIOReturnSuccess );
4cb1d3da RN	298
4cb1d3da RN	299	double dTime;
4cb1d3da RN	300
	301	while(true)
	302	{
	303	if (TestDestroy())
	304	break;
	305
	306	if (m_polling)
	307	dTime = 0.0001 * m_polling;
	308	else
	309	dTime = 0.0001 * 10; // check at least every 10 msec in blocking case
	310
65442ab6	311	CFRunLoopRunInMode(kCFRunLoopDefaultMode, dTime, true);
4cb1d3da	312	}
65442ab6 RN	313
	314	wxJSASSERT( CFRunLoopContainsSource(pRL, pRLSource, kCFRunLoopDefaultMode) );
	315	CFRunLoopRemoveSource(pRL, pRLSource, kCFRunLoopDefaultMode);
	316	CFRelease(pRLSource);
	317
4cb1d3da RN	318	return NULL;
	319	}
	320
	321
	322	////////////////////////////////////////////////////////////////////////////
	323
	324	wxJoystick::wxJoystick(int joystick)
	325	: m_joystick(joystick),
	326	m_thread(NULL)
	327	{
	328	m_hid = new wxHIDJoystick();
	329
	330	if (m_hid->Create(m_joystick))
	331	{
	332	m_thread = new wxJoystickThread(m_hid, m_joystick);
	333	m_thread->Create();
	334	m_thread->Run();
	335	}
	336	else
	337	{
	338	delete m_hid;
	339	m_hid = NULL;
	340	}
	341	}
	342
	343
	344	wxJoystick::~wxJoystick()
	345	{
	346	ReleaseCapture();
	347	if (m_thread)
	348	m_thread->Delete(); // It's detached so it will delete itself
	349
	350	if (m_hid)
	351	delete m_hid;
	352	}
	353
	354
	355	////////////////////////////////////////////////////////////////////////////
	356	// State
	357	////////////////////////////////////////////////////////////////////////////
	358
	359	wxPoint wxJoystick::GetPosition() const
	360	{
	361	wxPoint pos(wxDefaultPosition);
	362	if (m_thread) pos = m_thread->m_lastposition;
	363	return pos;
	364	}
	365
	366	int wxJoystick::GetZPosition() const
	367	{
	368	if (m_thread)
	369	return m_thread->m_axe[wxJS_AXIS_Z];
	370	return 0;
	371	}
	372
	373	int wxJoystick::GetButtonState() const
	374	{
	375	if (m_thread)
	376	return m_thread->m_buttons;
	377	return 0;
	378	}
	379
	380	int wxJoystick::GetPOVPosition() const
	381	{ return -1; }
382
383	int wxJoystick::GetPOVCTSPosition() const
384	{ return -1; }
385
386	int wxJoystick::GetRudderPosition() const
387	{
388	if (m_thread)
389	return m_thread->m_axe[wxJS_AXIS_RUDDER];
390	return 0;
391	}
392
393	int wxJoystick::GetUPosition() const
394	{
395	if (m_thread)
396	return m_thread->m_axe[wxJS_AXIS_U];
397	return 0;
398	}
399
400	int wxJoystick::GetVPosition() const
401	{
402	if (m_thread)
403	return m_thread->m_axe[wxJS_AXIS_V];
404	return 0;
405	}
406
407	int wxJoystick::GetMovementThreshold() const
408	{ return 0; }
409
410	void wxJoystick::SetMovementThreshold(int threshold)
411	{ }
412
413	////////////////////////////////////////////////////////////////////////////
414	// Capabilities
415	////////////////////////////////////////////////////////////////////////////
416
417	bool wxJoystick::IsOk() const
418	{ return m_hid != NULL; }
419
420	int wxJoystick::GetNumberJoysticks() const
421	{ return wxHIDDevice::GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick) +
422	wxHIDDevice::GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad); }
423
424	int wxJoystick::GetManufacturerId() const
65442ab6	425	{ return m_hid->m_nManufacturerId; }
4cb1d3da RN	426
4cb1d3da RN	427	int wxJoystick::GetProductId() const
65442ab6	428	{ return m_hid->m_nProductId; }
4cb1d3da RN	429
4cb1d3da RN	430	wxString wxJoystick::GetProductName() const
65442ab6	431	{ return m_hid->m_szProductName; }
4cb1d3da RN	432
	433	int wxJoystick::GetXMin() const
	434	{ return wxJS_AXIS_MIN; }
	435
	436	int wxJoystick::GetYMin() const
	437	{ return wxJS_AXIS_MIN; }
	438
	439	int wxJoystick::GetZMin() const
	440	{ return wxJS_AXIS_MIN; }
	441
	442	int wxJoystick::GetXMax() const
	443	{ return wxJS_AXIS_MAX; }
	444
	445	int wxJoystick::GetYMax() const
	446	{ return wxJS_AXIS_MAX; }
	447
	448	int wxJoystick::GetZMax() const
	449	{ return wxJS_AXIS_MAX; }
	450
	451	int wxJoystick::GetNumberButtons() const
	452	{
	453	int nCount = 0;
	454
	455	for(int nIndex = 0; nIndex < 40; ++nIndex)
	456	{
	457	if(m_hid->HasElement(nIndex))
	458	++nCount;
	459	}
	460
	461	return nCount;
	462	}
	463
	464	int wxJoystick::GetNumberAxes() const
	465	{
	466	int nCount = 0;
	467
	468	for(int nIndex = 40; nIndex < 50; ++nIndex)
	469	{
	470	if(m_hid->HasElement(nIndex))
	471	++nCount;
	472	}
	473
	474	return nCount;
	475	}
	476
	477	//
	478	// internal
	479	//
	480	int wxJoystick::GetMaxButtons() const
	481	{ return 15; }
	482
	483	int wxJoystick::GetMaxAxes() const
	484	{ return 10; }
	485
	486	int wxJoystick::GetPollingMin() const
	487	{ return 10; }
	488
	489	int wxJoystick::GetPollingMax() const
	490	{ return 1000; }
	491
	492	int wxJoystick::GetRudderMin() const
	493	{ return wxJS_AXIS_MIN; }
	494
	495	int wxJoystick::GetRudderMax() const
496	{ return wxJS_AXIS_MAX; }
497
498	int wxJoystick::GetUMin() const
499	{ return wxJS_AXIS_MIN; }
500
501	int wxJoystick::GetUMax() const
502	{ return wxJS_AXIS_MAX; }
503
504	int wxJoystick::GetVMin() const
505	{ return wxJS_AXIS_MIN; }
506
507	int wxJoystick::GetVMax() const
508	{ return wxJS_AXIS_MAX; }
509
510	bool wxJoystick::HasRudder() const
511	{ return m_hid->HasElement(wxJS_AXIS_RUDDER); }
512
513	bool wxJoystick::HasZ() const
514	{ return m_hid->HasElement(wxJS_AXIS_Z); }
515
516	bool wxJoystick::HasU() const
517	{ return m_hid->HasElement(wxJS_AXIS_U); }
518
519	bool wxJoystick::HasV() const
520	{ return m_hid->HasElement(wxJS_AXIS_V); }
521
522	bool wxJoystick::HasPOV() const
523	{ return false; }
524
525	bool wxJoystick::HasPOV4Dir() const
526	{ return false; }
527
528	bool wxJoystick::HasPOVCTS() const
529	{ return false; }
530
531	////////////////////////////////////////////////////////////////////////////
532	// Operations
533	////////////////////////////////////////////////////////////////////////////
534
535	bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
536	{
537	if (m_thread)
538	{
539	m_thread->m_catchwin = win;
540	m_thread->m_polling = pollingFreq;
541	return true;
542	}
543	return false;
544	}
545
546	bool wxJoystick::ReleaseCapture()
547	{
548	if (m_thread)
549	{
550	m_thread->m_catchwin = NULL;
551	m_thread->m_polling = 0;
552	return true;
553	}
554	return false;
555	}
556	#endif
557	//OSX
558
559	#endif
560	// wxUSE_JOYSTICK
561