AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

applying patch 1411230

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@38620 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Stefan Csomor 2006-04-08 11:43:13 +00:00
parent a074f61eae
commit 32efab35c1
3 changed files with 430 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
include/wx/mac/corefoundation/hid.h
View File

@ -8,6 +8,7 @@
// Copyright: (c) Ryan Norton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ===========================================================================
// declarations
// ===========================================================================
@ -22,10 +23,6 @@
#include "wx/defs.h"
#include "wx/string.h"
// ---------------------------------------------------------------------------
// definitions
// ---------------------------------------------------------------------------
//Mac OSX only
#ifdef __DARWIN__
@ -44,28 +41,24 @@ extern "C" {
#include <mach/mach.h> //this actually includes mach_port.h (see above)
//Utility wrapper around CFArray
class wxCFArray
{
public:
wxCFArray(CFTypeRef pData) : pArray((CFArrayRef) pData) {}
CFTypeRef operator [] (const int& nIndex) {return CFArrayGetValueAtIndex(pArray, nIndex); }
int Count() {return CFArrayGetCount(pArray);}
private:
CFArrayRef pArray;
};
// ===========================================================================
// definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// wxHIDDevice
//
// A wrapper around OS X HID Manager procedures.
// The tutorial "Working With HID Class Device Interfaces" Is
// Quite good, as is the sample program associated with it
// (Depite the author's protests!).
// ---------------------------------------------------------------------------
class wxHIDDevice
{
public:
wxHIDDevice() : m_ppDevice(NULL), m_ppQueue(NULL), m_pCookies(NULL) {}
//kHIDPage_GenericDesktop
//kHIDUsage_GD_Joystick,kHIDUsage_GD_Mouse,kHIDUsage_GD_Keyboard
bool Create (int nClass = -1, int nType = -1, int nDev = 1);
static size_t GetCount(int nClass = -1, int nType = -1);
@ -78,12 +71,13 @@ public:
//builds the cookie array -
//first call InitCookies to initialize the cookie
//array, then AddCookie to add a cookie at a certain point in an array
virtual void BuildCookies(wxCFArray& Array) = 0;
virtual void BuildCookies(CFArrayRef Array) = 0;
//checks to see whether the cookie at nIndex is active (element value != 0)
bool IsActive(int nIndex);
//checks to see whether the cookie at nIndex exists
//checks to see whether an element in the internal cookie array
//exists
bool HasElement(int nIndex);
//closes the device and cleans the queue and cookies
@ -97,17 +91,25 @@ protected:
wxString m_szProductName; //product name
int m_nProductId; //product id
int m_nManufacturerId; //manufacturer id
mach_port_t m_pPort;
mach_port_t m_pPort; //mach port to use
};
// ---------------------------------------------------------------------------
// wxHIDKeyboard
//
// Semi-simple implementation that opens a connection to the first
// keyboard of the machine. Used in wxGetKeyState.
// ---------------------------------------------------------------------------
class wxHIDKeyboard : public wxHIDDevice
{
public:
bool Create();
virtual void BuildCookies(wxCFArray& Array);
static int GetCount();
bool Create(int nDev = 1);
void AddCookie(CFTypeRef Data, int i);
virtual void BuildCookies(CFArrayRef Array);
void DoBuildCookies(CFArrayRef Array);
};
#endif //__DARWIN__
#endif
//WX_MACCARBONHID_H
#endif //WX_MACCARBONHID_H

548
src/mac/corefoundation/hid.cpp
View File

@ -32,52 +32,38 @@
#include "wx/log.h"
#include "wx/mac/corefoundation/cfstring.h"
// ---------------------------------------------------------------------------
// assertion macros
// ---------------------------------------------------------------------------
#define wxFORCECHECK_MSG(arg, msg) \
{\
if (arg) \
{\
wxLogSysError(wxString::Format(wxT("Message:%s\nHID: %s failed!"), wxT(msg), wxT(#arg)));\
return false;\
}\
}
#define wxIOCHECK(arg, msg) wxFORCECHECK_MSG(arg != kIOReturnSuccess, msg)
#define wxKERNCHECK(arg, msg) wxFORCECHECK_MSG(arg != KERN_SUCCESS, msg)
#define wxSCHECK(arg, msg) wxFORCECHECK_MSG(arg != S_OK, msg)
/*
void CFShowTypeIDDescription(CFTypeRef pData)
{
if(!pData)
{
wxASSERT(false);
return;
}
wxMessageBox(
CFStringGetCStringPtr(
CFCopyTypeIDDescription(CFGetTypeID(pData)),CFStringGetSystemEncoding()
)
);
}
*/
#include "wx/utils.h"
#include "wx/module.h"
#include "wx/dynarray.h"
// ============================================================================
// implementation
// ============================================================================
// ---------------------------------------------------------------------------
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// wxHIDDevice
// ---------------------------------------------------------------------------
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ----------------------------------------------------------------------------
// wxHIDDevice::Create
//
// nClass is the HID Page such as
// kHIDPage_GenericDesktop
// nType is the HID Usage such as
// kHIDUsage_GD_Joystick,kHIDUsage_GD_Mouse,kHIDUsage_GD_Keyboard
// nDev is the device number to use
//
// ----------------------------------------------------------------------------
bool wxHIDDevice::Create (int nClass, int nType, int nDev)
{
//Create the mach port
wxIOCHECK(IOMasterPort(bootstrap_port, &m_pPort), "Could not create mach port");
if(IOMasterPort(bootstrap_port, &m_pPort) != kIOReturnSuccess)
{
wxLogSysError(wxT("Could not create mach port"));
return false;
}
//Dictionary that will hold first
//the matching dictionary for determining which kind of devices we want,
@ -87,10 +73,11 @@ bool wxHIDDevice::Create (int nClass, int nType, int nDev)
//the services we want to hid services (and also eats the
//dictionary up for us (consumes one reference))
CFMutableDictionaryRef pDictionary = IOServiceMatching(kIOHIDDeviceKey);
wxCHECK_MSG( pDictionary, false,
_T("IOServiceMatching(kIOHIDDeviceKey) failed") );
wxASSERT( pDictionary );
if(pDictionary == NULL)
{
wxLogSysError( _T("IOServiceMatching(kIOHIDDeviceKey) failed") );
return false;
}
//Here we'll filter down the services to what we want
if (nType != -1)
@ -110,7 +97,14 @@ bool wxHIDDevice::Create (int nClass, int nType, int nDev)
//Now get the maching services
io_iterator_t pIterator;
wxIOCHECK(IOServiceGetMatchingServices(m_pPort, pDictionary, &pIterator), "No Matching HID Services");
if( IOServiceGetMatchingServices(m_pPort,
pDictionary, &pIterator) != kIOReturnSuccess )
{
wxLogSysError(_T("No Matching HID Services"));
return false;
}
//Were there any devices matched?
if(pIterator == 0)
return false; // No devices found
@ -119,7 +113,10 @@ bool wxHIDDevice::Create (int nClass, int nType, int nDev)
while ( (pObject = IOIteratorNext(pIterator)) != 0)
{
if(--nDev != 0)
{
IOObjectRelease(pObject);
continue;
}
if ( IORegistryEntryCreateCFProperties
(
@ -132,57 +129,62 @@ bool wxHIDDevice::Create (int nClass, int nType, int nDev)
wxLogDebug(_T("IORegistryEntryCreateCFProperties failed"));
}
//Just for sanity :)
wxASSERT(CFGetTypeID(CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductKey))) == CFStringGetTypeID());
//
// Now we get the attributes of each "product" in the iterator
//
/*
kIOHIDTransportKey;
kIOHIDVendorIDKey;
kIOHIDProductIDKey;
kIOHIDVersionNumberKey;
kIOHIDManufacturerKey;
kIOHIDSerialNumberKey;
if !kIOHIDLocationIDKey
kUSBDevicePropertyLocationID
kIOHIDPrimaryUsageKey
kIOHIDPrimaryUsagePageKey
idProduct
idVendor
USB Product Name
*/
//Get [product] name
m_szProductName = wxMacCFStringHolder( (CFStringRef) CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductKey)), false ).AsString();
CFStringRef cfsProduct = (CFStringRef)
CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductKey));
m_szProductName =
wxMacCFStringHolder( cfsProduct,
false
).AsString();
CFNumberRef nref = (CFNumberRef) CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductIDKey));
//Get the Product ID Key
CFNumberRef cfnProductId = (CFNumberRef)
CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductIDKey));
if (cfnProductId)
{
CFNumberGetValue(cfnProductId, kCFNumberIntType, &m_nProductId);
}
if (nref)
CFNumberGetValue(
nref,
kCFNumberIntType,
&m_nProductId
);
//Get the Vendor ID Key
CFNumberRef cfnVendorId = (CFNumberRef)
CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDVendorIDKey));
if (cfnVendorId)
{
CFNumberGetValue(cfnVendorId, kCFNumberIntType, &m_nManufacturerId);
}
nref = (CFNumberRef) CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDVendorIDKey));
if (nref)
CFNumberGetValue(
nref,
kCFNumberIntType,
&m_nManufacturerId
);
//
// End attribute getting
//
//Create the interface (good grief - long function names!)
SInt32 nScore;
IOCFPlugInInterface** ppPlugin;
wxIOCHECK(IOCreatePlugInInterfaceForService(pObject, kIOHIDDeviceUserClientTypeID,
kIOCFPlugInInterfaceID, &ppPlugin, &nScore), "");
if(IOCreatePlugInInterfaceForService(pObject,
kIOHIDDeviceUserClientTypeID,
kIOCFPlugInInterfaceID, &ppPlugin,
&nScore) != kIOReturnSuccess)
{
wxLogSysError(wxT("Could not create HID Interface for product"));
return false;
}
//Now, the final thing we can check before we fall back to asserts
//(because the dtor only checks if the device is ok, so if anything
//fails from now on the dtor will delete the device anyway, so we can't break from this).
//Get the HID interface from the plugin to the mach port
wxSCHECK((*ppPlugin)->QueryInterface(ppPlugin,
CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID), (void**) &m_ppDevice), "");
if((*ppPlugin)->QueryInterface(ppPlugin,
CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
(void**) &m_ppDevice) != S_OK)
{
wxLogSysError(wxT("Could not get device interface from HID interface"));
return false;
}
//release the plugin
(*ppPlugin)->Release(ppPlugin);
@ -192,35 +194,53 @@ USB Product Name
wxLogDebug(_T("HID device: open failed"));
//
//Now the hard part - in order to scan things we need "cookies" -
//Now the hard part - in order to scan things we need "cookies"
//
wxCFArray CookieArray = CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDElementKey));
BuildCookies(CookieArray);
CFArrayRef cfaCookies = (CFArrayRef)CFDictionaryGetValue(pDictionary,
CFSTR(kIOHIDElementKey));
BuildCookies(cfaCookies);
//cleanup
CFRelease(pDictionary);
IOObjectRelease(pObject);
break;
//iterator cleanup
IOObjectRelease(pIterator);
return true;
}
//iterator cleanup
IOObjectRelease(pIterator);
return true;
return false; //no device
}//end Create()
// ----------------------------------------------------------------------------
// wxHIDDevice::GetCount [static]
//
// Obtains the number of devices on a system for a given HID Page (nClass)
// and HID Usage (nType).
// ----------------------------------------------------------------------------
size_t wxHIDDevice::GetCount (int nClass, int nType)
{
mach_port_t m_pPort;
//Create the mach port
wxIOCHECK(IOMasterPort(bootstrap_port, &m_pPort), "Could not create mach port");
mach_port_t pPort;
if(IOMasterPort(bootstrap_port, &pPort) != kIOReturnSuccess)
{
wxLogSysError(wxT("Could not create mach port"));
return false;
}
//Dictionary that will hold first
//the matching dictionary for determining which kind of devices we want,
//then later some registry properties from an iterator (see below)
CFMutableDictionaryRef pDictionary = IOServiceMatching(kIOHIDDeviceKey);
wxCHECK_MSG( pDictionary, 0,
_T("IOServiceMatching(kIOHIDDeviceKey) failed") );
if(pDictionary == NULL)
{
wxLogSysError( _T("IOServiceMatching(kIOHIDDeviceKey) failed") );
return false;
}
//Here we'll filter down the services to what we want
if (nType != -1)
@ -240,25 +260,38 @@ size_t wxHIDDevice::GetCount (int nClass, int nType)
//Now get the maching services
io_iterator_t pIterator;
wxIOCHECK(IOServiceGetMatchingServices(m_pPort, pDictionary, &pIterator), "No Matching HID Services");
if( IOServiceGetMatchingServices(pPort,
pDictionary, &pIterator) != kIOReturnSuccess )
{
wxLogSysError(_T("No Matching HID Services"));
return false;
}
//If the iterator doesn't exist there are no devices :)
if ( !pIterator )
return 0;
//Now we iterate through them
io_object_t pObject;
size_t nCount = 0;
io_object_t pObject;
while ( (pObject = IOIteratorNext(pIterator)) != 0)
{
++nCount;
//iterator cleanup
IOObjectRelease(pObject);
}
//cleanup
IOObjectRelease(pIterator);
mach_port_deallocate(mach_task_self(), pPort);
return nCount;
}//end Create()
// ----------------------------------------------------------------------------
// wxHIDDevice::AddCookie
//
// Adds a cookie to the internal cookie array from a CFType
// ----------------------------------------------------------------------------
void wxHIDDevice::AddCookie(CFTypeRef Data, int i)
{
CFNumberGetValue(
@ -270,6 +303,12 @@ void wxHIDDevice::AddCookie(CFTypeRef Data, int i)
);
}
// ----------------------------------------------------------------------------
// wxHIDDevice::AddCookieInQueue
//
// Adds a cookie to the internal cookie array from a CFType and additionally
// adds it to the internal HID Queue
// ----------------------------------------------------------------------------
void wxHIDDevice::AddCookieInQueue(CFTypeRef Data, int i)
{
//3rd Param flags (none yet)
@ -278,6 +317,11 @@ void wxHIDDevice::AddCookieInQueue(CFTypeRef Data, int i)
wxLogDebug(_T("HID device: adding element failed"));
}
// ----------------------------------------------------------------------------
// wxHIDDevice::InitCookies
//
// Create the internal cookie array, optionally creating a HID Queue
// ----------------------------------------------------------------------------
void wxHIDDevice::InitCookies(size_t dwSize, bool bQueue)
{
m_pCookies = new IOHIDElementCookie[dwSize];
@ -297,27 +341,47 @@ void wxHIDDevice::InitCookies(size_t dwSize, bool bQueue)
wxLogDebug(_T("HID device: create failed"));
}
}
//make sure that cookie array is clear
memset(m_pCookies, 0, sizeof(*m_pCookies) * dwSize);
}
// ----------------------------------------------------------------------------
// wxHIDDevice::IsActive
//
// Returns true if a cookie of the device is active - for example if a key is
// held down, joystick button pressed, caps lock active, etc..
// ----------------------------------------------------------------------------
bool wxHIDDevice::IsActive(int nIndex)
{
wxASSERT(m_pCookies[nIndex] != NULL);
if(!HasElement(nIndex))
{
//cookie at index does not exist - getElementValue
//could return true which would be incorrect so we
//check here
return false;
}
IOHIDEventStruct Event;
(*m_ppDevice)->getElementValue(m_ppDevice, m_pCookies[nIndex], &Event);
/*
wxString ss;
ss << _T("[") << (int) m_pCookies[nIndex] << _T("] = ") << Event.value << _T(" SIZE:") << Event.longValueSize;
wxLogDebug(ss);
*/
return !!Event.value;
}
// ----------------------------------------------------------------------------
// wxHIDDevice::HasElement
//
// Returns true if the element in the internal cookie array exists
// ----------------------------------------------------------------------------
bool wxHIDDevice::HasElement(int nIndex)
{
return m_pCookies[nIndex] != NULL;
}
// ----------------------------------------------------------------------------
// wxHIDDevice Destructor
//
// Frees all memory and objects from the structure
// ----------------------------------------------------------------------------
wxHIDDevice::~wxHIDDevice()
{
if (m_ppDevice != NULL)
@ -339,36 +403,107 @@ wxHIDDevice::~wxHIDDevice()
}
}
// ---------------------------------------------------------------------------
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// wxHIDKeyboard
// ---------------------------------------------------------------------------
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//There are no right shift, alt etc. in the wx headers yet so just sort
//of "define our own" for now
enum
{
WXK_RSHIFT = 400,
WXK_RALT,
WXK_RCONTROL,
WXK_RMENU
};
bool wxHIDKeyboard::Create()
// ----------------------------------------------------------------------------
// wxHIDKeyboard::GetCount [static]
//
// Get number of HID keyboards available
// ----------------------------------------------------------------------------
int wxHIDKeyboard::GetCount()
{
return wxHIDDevice::Create(kHIDPage_GenericDesktop, kHIDUsage_GD_Keyboard);
return wxHIDDevice::GetCount(kHIDPage_GenericDesktop,
kHIDUsage_GD_Keyboard);
}
void wxHIDKeyboard::BuildCookies(wxCFArray& Array)
// ----------------------------------------------------------------------------
// wxHIDKeyboard::Create
//
// Create the HID Keyboard
// ----------------------------------------------------------------------------
bool wxHIDKeyboard::Create(int nDev /* = 1*/)
{
Array = CFDictionaryGetValue((CFDictionaryRef)Array[0], CFSTR(kIOHIDElementKey));
return wxHIDDevice::Create(kHIDPage_GenericDesktop,
kHIDUsage_GD_Keyboard,
nDev);
}
// ----------------------------------------------------------------------------
// wxHIDKeyboard::AddCookie
//
// Overloaded version of wxHIDDevice::AddCookie that simply does not
// add a cookie if a duplicate is found
// ----------------------------------------------------------------------------
void wxHIDKeyboard::AddCookie(CFTypeRef Data, int i)
{
if(!HasElement(i))
wxHIDDevice::AddCookie(Data, i);
}
// ----------------------------------------------------------------------------
// wxHIDKeyboard::BuildCookies
//
// Callback from Create() to build the HID cookies for the internal cookie
// array
// ----------------------------------------------------------------------------
void wxHIDKeyboard::BuildCookies(CFArrayRef Array)
{
//Create internal cookie array
InitCookies(500);
//Begin recursing in array
DoBuildCookies(Array);
}
void wxHIDKeyboard::DoBuildCookies(CFArrayRef Array)
{
//Now go through each possible cookie
int i,
nUsage;
bool bEOTriggered = false;
for (i = 0; i < Array.Count(); ++i)
// bool bEOTriggered = false;
for (i = 0; i < CFArrayGetCount(Array); ++i)
{
const void* ref = CFDictionaryGetValue(
(CFDictionaryRef)CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementKey)
);
if (ref != NULL)
{
DoBuildCookies((CFArrayRef) ref);
}
else
{
//
// Get the usage #
//
CFNumberGetValue(
(CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) Array[i], CFSTR(kIOHIDElementUsageKey)),
kCFNumberLongType, &nUsage);
(CFNumberRef)
CFDictionaryGetValue((CFDictionaryRef)
CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementUsageKey)
),
kCFNumberLongType,
&nUsage);
//
// Now translate the usage # into a wx keycode
//
//
// OK, this is strange - basically this kind of strange -
@ -382,200 +517,223 @@ void wxHIDKeyboard::BuildCookies(wxCFArray& Array)
//
// Something to spend a support request on, if I had one, LOL.
//
if(nUsage == 0xE0)
{
if(bEOTriggered)
break;
bEOTriggered = true;
}
/*
wxString msg;
int cookie;
CFNumberGetValue(
(CFNumberRef) CFDictionaryGetValue ( (CFDictionaryRef) Array[i]
, CFSTR(kIOHIDElementCookieKey)
),
kCFNumberIntType,
&cookie
);
msg << wxT("KEY:") << nUsage << wxT("COOKIE:") << cookie;
wxLogDebug(msg);
*/
//if(nUsage == 0xE0)
//{
// if(bEOTriggered)
// break;
// bEOTriggered = true;
//}
//Instead of that though we now just don't add duplicate keys
if (nUsage >= kHIDUsage_KeyboardA && nUsage <= kHIDUsage_KeyboardZ)
AddCookie(Array[i], 'A' + (nUsage - kHIDUsage_KeyboardA) );
AddCookie(CFArrayGetValueAtIndex(Array, i), 'A' + (nUsage - kHIDUsage_KeyboardA) );
else if (nUsage >= kHIDUsage_Keyboard1 && nUsage <= kHIDUsage_Keyboard9)
AddCookie(Array[i], '1' + (nUsage - kHIDUsage_Keyboard1) );
AddCookie(CFArrayGetValueAtIndex(Array, i), '1' + (nUsage - kHIDUsage_Keyboard1) );
else if (nUsage >= kHIDUsage_KeyboardF1 && nUsage <= kHIDUsage_KeyboardF12)
AddCookie(Array[i], WXK_F1 + (nUsage - kHIDUsage_KeyboardF1) );
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_F1 + (nUsage - kHIDUsage_KeyboardF1) );
else if (nUsage >= kHIDUsage_KeyboardF13 && nUsage <= kHIDUsage_KeyboardF24)
AddCookie(Array[i], WXK_F13 + (nUsage - kHIDUsage_KeyboardF13) );
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_F13 + (nUsage - kHIDUsage_KeyboardF13) );
else if (nUsage >= kHIDUsage_Keypad1 && nUsage <= kHIDUsage_Keypad9)
AddCookie(Array[i], WXK_NUMPAD1 + (nUsage - kHIDUsage_Keypad1) );
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_NUMPAD1 + (nUsage - kHIDUsage_Keypad1) );
else switch (nUsage)
{
//0's (wx & ascii go 0-9, but HID goes 1-0)
case kHIDUsage_Keyboard0:
AddCookie(Array[i],'0');
AddCookie(CFArrayGetValueAtIndex(Array, i), '0');
break;
case kHIDUsage_Keypad0:
AddCookie(Array[i],WXK_NUMPAD0);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_NUMPAD0);
break;
//Basic
case kHIDUsage_KeyboardReturnOrEnter:
AddCookie(Array[i], WXK_RETURN);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_RETURN);
break;
case kHIDUsage_KeyboardEscape:
AddCookie(Array[i], WXK_ESCAPE);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_ESCAPE);
break;
case kHIDUsage_KeyboardDeleteOrBackspace:
AddCookie(Array[i], WXK_BACK);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_BACK);
break;
case kHIDUsage_KeyboardTab:
AddCookie(Array[i], WXK_TAB);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_TAB);
break;
case kHIDUsage_KeyboardSpacebar:
AddCookie(Array[i], WXK_SPACE);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_SPACE);
break;
case kHIDUsage_KeyboardPageUp:
AddCookie(Array[i], WXK_PAGEUP);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_PAGEUP);
break;
case kHIDUsage_KeyboardEnd:
AddCookie(Array[i], WXK_END);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_END);
break;
case kHIDUsage_KeyboardPageDown:
AddCookie(Array[i], WXK_PAGEDOWN);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_PAGEDOWN);
break;
case kHIDUsage_KeyboardRightArrow:
AddCookie(Array[i], WXK_RIGHT);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_RIGHT);
break;
case kHIDUsage_KeyboardLeftArrow:
AddCookie(Array[i], WXK_LEFT);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_LEFT);
break;
case kHIDUsage_KeyboardDownArrow:
AddCookie(Array[i], WXK_DOWN);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_DOWN);
break;
case kHIDUsage_KeyboardUpArrow:
AddCookie(Array[i], WXK_UP);
AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_UP);
break;
//LEDS
case kHIDUsage_KeyboardCapsLock:
AddCookie(Array[i],WXK_CAPITAL);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_CAPITAL);
break;
case kHIDUsage_KeypadNumLock:
AddCookie(Array[i],WXK_NUMLOCK);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_NUMLOCK);
break;
case kHIDUsage_KeyboardScrollLock:
AddCookie(Array[i],WXK_SCROLL);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_SCROLL);
break;
//Menu keys, Shift, other specials
case kHIDUsage_KeyboardLeftControl:
AddCookie(Array[i],WXK_CONTROL);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_CONTROL);
break;
case kHIDUsage_KeyboardLeftShift:
AddCookie(Array[i],WXK_SHIFT);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_SHIFT);
break;
case kHIDUsage_KeyboardLeftAlt:
AddCookie(Array[i],WXK_ALT);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_ALT);
break;
case kHIDUsage_KeyboardLeftGUI:
AddCookie(Array[i],WXK_MENU);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_MENU);
break;
case kHIDUsage_KeyboardRightControl:
AddCookie(Array[i],WXK_RCONTROL);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RCONTROL);
break;
case kHIDUsage_KeyboardRightShift:
AddCookie(Array[i],WXK_RSHIFT);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RSHIFT);
break;
case kHIDUsage_KeyboardRightAlt:
AddCookie(Array[i],WXK_RALT);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RALT);
break;
case kHIDUsage_KeyboardRightGUI:
AddCookie(Array[i],WXK_RMENU);
AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RMENU);
break;
//Default
default:
//not in wx keycodes - do nothing....
break;
}
}
} //end mightly long switch
} //end if the current element is not an array...
} //end for loop for Array
}//end buildcookies
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// wxGetKeyState
// wxHIDModule
//
#include "wx/utils.h"
#include "wx/module.h"
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class wxHIDModule : public wxModule
{
DECLARE_DYNAMIC_CLASS(wxHIDModule)
public:
static wxHIDKeyboard* sm_keyboard;
static wxArrayPtrVoid sm_keyboards;
virtual bool OnInit()
{
sm_keyboard = NULL;
return true;
}
virtual void OnExit()
{
if (sm_keyboard)
delete sm_keyboard;
for(size_t i = 0; i < sm_keyboards.GetCount(); ++i)
delete (wxHIDKeyboard*) sm_keyboards[i];
}
};
IMPLEMENT_DYNAMIC_CLASS(wxHIDModule, wxModule)
wxHIDKeyboard* wxHIDModule::sm_keyboard;
wxArrayPtrVoid wxHIDModule::sm_keyboards;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// wxGetKeyState()
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
bool wxGetKeyState (wxKeyCode key)
{
wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));
if (!wxHIDModule::sm_keyboard)
if (wxHIDModule::sm_keyboards.GetCount() == 0)
{
wxHIDModule::sm_keyboard = new wxHIDKeyboard();
bool bOK = wxHIDModule::sm_keyboard->Create();
wxASSERT(bOK);
if(!bOK)
int nKeyboards = wxHIDKeyboard::GetCount();
for(int i = 1; i <= nKeyboards; ++i)
{
delete wxHIDModule::sm_keyboard;
wxHIDModule::sm_keyboard = NULL;
return false;
wxHIDKeyboard* keyboard = new wxHIDKeyboard();
if(keyboard->Create(i))
{
wxHIDModule::sm_keyboards.Add(keyboard);
}
else
{
delete keyboard;
break;
}
}
wxASSERT_MSG(wxHIDModule::sm_keyboards.GetCount() != 0,
wxT("No keyboards found!"));
}
for(size_t i = 0; i < wxHIDModule::sm_keyboards.GetCount(); ++i)
{
wxHIDKeyboard* keyboard = (wxHIDKeyboard*)
wxHIDModule::sm_keyboards[i];
switch(key)
{
case WXK_SHIFT:
return wxHIDModule::sm_keyboard->IsActive(WXK_SHIFT) ||
wxHIDModule::sm_keyboard->IsActive(WXK_RSHIFT);
if( keyboard->IsActive(WXK_SHIFT) ||
keyboard->IsActive(WXK_RSHIFT) )
{
return true;
}
break;
case WXK_ALT:
return wxHIDModule::sm_keyboard->IsActive(WXK_ALT) ||
wxHIDModule::sm_keyboard->IsActive(WXK_RALT);
if( keyboard->IsActive(WXK_ALT) ||
keyboard->IsActive(WXK_RALT) )
{
return true;
}
break;
case WXK_CONTROL:
return wxHIDModule::sm_keyboard->IsActive(WXK_CONTROL) ||
wxHIDModule::sm_keyboard->IsActive(WXK_RCONTROL);
if( keyboard->IsActive(WXK_CONTROL) ||
keyboard->IsActive(WXK_RCONTROL) )
{
return true;
}
break;
case WXK_MENU:
return wxHIDModule::sm_keyboard->IsActive(WXK_MENU) ||
wxHIDModule::sm_keyboard->IsActive(WXK_RMENU);
if( keyboard->IsActive(WXK_MENU) ||
keyboard->IsActive(WXK_RMENU) )
{
return true;
}
break;
default:
return wxHIDModule::sm_keyboard->IsActive(key);
if( keyboard->IsActive(key) )
{
return true;
}
break;
}
}
return false; //not down/error
}
#endif //__DARWIN__

83
src/mac/corefoundation/hidjoystick.cpp
View File

@ -74,8 +74,8 @@ public:
~wxHIDJoystick();
bool Create(int nWhich);
virtual void BuildCookies(wxCFArray& Array);
void MakeCookies(wxCFArray& Array);
virtual void BuildCookies(CFArrayRef Array);
void MakeCookies(CFArrayRef Array);
IOHIDElementCookie* GetCookies();
IOHIDQueueInterface** GetQueue();
@ -145,7 +145,7 @@ wxJoystick::wxJoystick(int joystick)
{
m_hid = new wxHIDJoystick();
if (m_hid->Create(m_joystick))
if (m_hid->Create(m_joystick+1)) //wxHIDDevice is 1-based while this is 0
{
m_thread = new wxJoystickThread(m_hid, m_joystick);
m_thread->Create();
@ -449,14 +449,18 @@ bool wxHIDJoystick::Create(int nWhich)
int nJoysticks = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
if (nWhich <= nJoysticks)
return wxHIDDevice::Create(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
return wxHIDDevice::Create(kHIDPage_GenericDesktop,
kHIDUsage_GD_Joystick,
nWhich);
else
nWhich -= nJoysticks;
int nGamePads = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
if (nWhich <= nGamePads)
return wxHIDDevice::Create(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
return wxHIDDevice::Create(kHIDPage_GenericDesktop,
kHIDUsage_GD_GamePad,
nWhich);
else
return false;
}
@ -471,13 +475,10 @@ bool wxHIDJoystick::Create(int nWhich)
// MakeCookies is just a recursive function for each array within
// BuildCookies.
//---------------------------------------------------------------------------
void wxHIDJoystick::BuildCookies(wxCFArray& Array)
void wxHIDJoystick::BuildCookies(CFArrayRef Array)
{
Array = CFDictionaryGetValue((CFDictionaryRef)Array[0], CFSTR(kIOHIDElementKey));
InitCookies(50, true);
memset(m_pCookies, 0, sizeof(*m_pCookies) * 50);
//
// I wasted two hours of my life on this line :(
// accidently removed it during some source cleaning...
@ -491,58 +492,76 @@ void wxHIDJoystick::BuildCookies(wxCFArray& Array)
#endif
}//end buildcookies
void wxHIDJoystick::MakeCookies(wxCFArray& Array)
void wxHIDJoystick::MakeCookies(CFArrayRef Array)
{
int i, nUsage, nPage;
for (i = 0; i < Array.Count(); ++i)
for (i = 0; i < CFArrayGetCount(Array); ++i)
{
const void* ref = CFDictionaryGetValue((CFDictionaryRef)Array[i], CFSTR(kIOHIDElementKey));
const void* ref = CFDictionaryGetValue(
(CFDictionaryRef)CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementKey)
);
if (ref != NULL)
{
wxCFArray newarray(ref);
MakeCookies(newarray);
MakeCookies((CFArrayRef) ref);
}
else
{
CFNumberGetValue(
(CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) Array[i], CFSTR(kIOHIDElementUsageKey)),
kCFNumberIntType, &nUsage);
(CFNumberRef)
CFDictionaryGetValue(
(CFDictionaryRef) CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementUsageKey)
),
kCFNumberIntType,
&nUsage );
CFNumberGetValue(
(CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) Array[i], CFSTR(kIOHIDElementUsagePageKey)),
kCFNumberIntType, &nPage);
(CFNumberRef)
CFDictionaryGetValue(
(CFDictionaryRef) CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementUsagePageKey)
),
kCFNumberIntType,
&nPage );
#if 0
wxLogSysError(wxT("[%i][%i]"), nUsage, nPage);
#endif
if (nPage == kHIDPage_Button && nUsage <= 40)
AddCookieInQueue(Array[i], nUsage-1 );
AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), nUsage-1 );
else if (nPage == kHIDPage_GenericDesktop)
{
//axis...
switch(nUsage)
{
case kHIDUsage_GD_X:
AddCookieInQueue(Array[i], wxJS_AXIS_X);
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMaxKey),
AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_X);
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMaxKey),
&m_nXMax);
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMinKey),
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMinKey),
&m_nXMin);
break;
case kHIDUsage_GD_Y:
AddCookieInQueue(Array[i], wxJS_AXIS_Y);
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMaxKey),
AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_Y);
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMaxKey),
&m_nYMax);
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMinKey),
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMinKey),
&m_nYMin);
break;
case kHIDUsage_GD_Z:
AddCookieInQueue(Array[i], wxJS_AXIS_Z);
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMaxKey),
AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_Z);
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMaxKey),
&m_nZMax);
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMinKey),
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMinKey),
&m_nZMin);
break;
default:
@ -552,10 +571,12 @@ void wxHIDJoystick::MakeCookies(wxCFArray& Array)
else if (nPage == kHIDPage_Simulation && nUsage == kHIDUsage_Sim_Rudder)
{
//rudder...
AddCookieInQueue(Array[i], wxJS_AXIS_RUDDER );
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMaxKey),
AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_RUDDER );
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMaxKey),
&m_nRudderMax);
wxGetIntFromCFDictionary(Array[i], CFSTR(kIOHIDElementMinKey),
wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
CFSTR(kIOHIDElementMinKey),
&m_nRudderMin);
}
}