int PsychHIDReturnEventFromEventBuffer(int deviceIndex, int outArgIndex, double maxWaitTimeSecs)
{
unsigned int navail, j;
PsychHIDEventRecord evt;
PsychGenericScriptType *retevent;
double* foo = NULL;
PsychGenericScriptType *outMat;
double *v;
const char *FieldNames[] = { "Type", "Time", "Pressed", "Keycode", "CookedKey", "ButtonStates", "Motion", "X", "Y", "NormX", "NormY", "Valuators" };
if (deviceIndex < 0) deviceIndex = PsychHIDGetDefaultKbQueueDevice();
if (!hidEventBuffer[deviceIndex]) return(0);
PsychLockMutex(&hidEventBufferMutex[deviceIndex]);
navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex];
// If nothing available and we're asked to wait for something, then wait:
if ((navail == 0) && (maxWaitTimeSecs > 0)) {
// Wait for something:
PsychTimedWaitCondition(&hidEventBufferCondition[deviceIndex], &hidEventBufferMutex[deviceIndex], maxWaitTimeSecs);
// Recompute number of available events:
navail = hidEventBufferWritePos[deviceIndex] - hidEventBufferReadPos[deviceIndex];
}
// Check if anything available, copy it if so:
if (navail) {
memcpy(&evt, &(hidEventBuffer[deviceIndex][hidEventBufferReadPos[deviceIndex] % hidEventBufferCapacity[deviceIndex]]), sizeof(PsychHIDEventRecord));
hidEventBufferReadPos[deviceIndex]++;
}
PsychUnlockMutex(&hidEventBufferMutex[deviceIndex]);
if (navail) {
// Return event struct:
switch (evt.type) {
case 0: // Press/Release
case 1: // Motion/Valuator change
PsychAllocOutStructArray(outArgIndex, kPsychArgOptional, 1, 12, FieldNames, &retevent);
break;
case 2: // Touch begin
case 3: // Touch update/move
case 4: // Touch end
case 5: // Touch sequence compromised marker. If this one shows up - with magic touch point
// id 0xffffffff btw., then the user script knows the sequence was cut short / aborted
// by some higher priority consumer, e.g., some global gesture recognizer.
PsychAllocOutStructArray(outArgIndex, kPsychArgOptional, 1, 12, FieldNames, &retevent);
break;
default:
PsychErrorExitMsg(PsychError_internal, "Unhandled keyboard queue event type!");
}
PsychSetStructArrayDoubleElement("Type", 0, (double) evt.type, retevent);
PsychSetStructArrayDoubleElement("Time", 0, evt.timestamp, retevent);
PsychSetStructArrayDoubleElement("Pressed", 0, (double) (evt.status & (1 << 0)) ? 1 : 0, retevent);
PsychSetStructArrayDoubleElement("Keycode", 0, (double) evt.rawEventCode, retevent);
PsychSetStructArrayDoubleElement("CookedKey", 0, (double) evt.cookedEventCode, retevent);
PsychSetStructArrayDoubleElement("ButtonStates", 0, (double) evt.buttonStates, retevent);
PsychSetStructArrayDoubleElement("Motion", 0, (double) (evt.status & (1 << 1)) ? 1 : 0, retevent);
PsychSetStructArrayDoubleElement("X", 0, (double) evt.X, retevent);
PsychSetStructArrayDoubleElement("Y", 0, (double) evt.Y, retevent);
PsychSetStructArrayDoubleElement("NormX", 0, (double) evt.normX, retevent);
PsychSetStructArrayDoubleElement("NormY", 0, (double) evt.normY, retevent);
// Copy out all valuators (including redundant (X,Y) again:
PsychAllocateNativeDoubleMat(1, evt.numValuators, 1, &v, &outMat);
for (j = 0; j < evt.numValuators; j++)
*(v++) = (double) evt.valuators[j];
PsychSetStructArrayNativeElement("Valuators", 0, outMat, retevent);
return(navail - 1);
}
else {
// Return empty matrix:
PsychCopyOutDoubleMatArg(outArgIndex, kPsychArgOptional, 0, 0, 0, foo);
return(0);
}
}
PsychError PSYCHHIDGetCollections(void)
{
pRecDevice specDevice=NULL;
UInt32 numDeviceElements;
const char *elementFieldNames[]={"typeMaskName", "name", "deviceIndex", "collectionIndex", "typeValue", "typeName", "usagePageValue",
"usageValue", "usageName", "memberCollectionIndices", "memberElementIndices"};
int i, numElementStructElements, numElementStructFieldNames=11, elementIndex, deviceIndex;
PsychGenericScriptType *elementStruct, *memberCollectionIndicesMat, *memberIOElementIndicesMat;
pRecElement currentElement;
char elementTypeName[PSYCH_HID_MAX_DEVICE_ELEMENT_TYPE_NAME_LENGTH];
char usageName[PSYCH_HID_MAX_DEVICE_ELEMENT_USAGE_NAME_LENGTH];
char *typeMaskName;
HIDElementTypeMask typeMask;
pRecElement *memberCollectionRecords, *memberIOElementRecords;
double *memberCollectionIndices, *memberIOElementIndices;
int numSubCollections, numSubIOElements;
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumOutputArgs(1));
PsychErrorExit(PsychCapNumInputArgs(1));
PsychCopyInIntegerArg(1, TRUE, &deviceIndex);
PsychHIDVerifyInit();
specDevice= PsychHIDGetDeviceRecordPtrFromIndex(deviceIndex);
PsychHIDVerifyOpenDeviceInterfaceFromDeviceRecordPtr(specDevice);
numDeviceElements= HIDCountDeviceElements(specDevice, kHIDElementTypeCollection);
numElementStructElements = (int)numDeviceElements;
PsychAllocOutStructArray(1, FALSE, numElementStructElements, numElementStructFieldNames, elementFieldNames, &elementStruct);
elementIndex=0;
for(currentElement=HIDGetFirstDeviceElement(specDevice,kHIDElementTypeCollection);
currentElement != NULL;
currentElement=HIDGetNextDeviceElement(currentElement, kHIDElementTypeCollection))
{
typeMask=HIDConvertElementTypeToMask (currentElement->type);
PsychHIDGetTypeMaskStringFromTypeMask(typeMask, &typeMaskName);
PsychSetStructArrayStringElement("typeMaskName", elementIndex, typeMaskName, elementStruct);
PsychSetStructArrayStringElement("name", elementIndex, currentElement->name, elementStruct);
PsychSetStructArrayDoubleElement("deviceIndex", elementIndex, (double)deviceIndex, elementStruct);
PsychSetStructArrayDoubleElement("collectionIndex", elementIndex, (double)elementIndex+1, elementStruct);
PsychSetStructArrayDoubleElement("typeValue", elementIndex, (double)currentElement->type, elementStruct);
HIDGetTypeName(currentElement->type, elementTypeName);
PsychSetStructArrayStringElement("typeName", elementIndex, elementTypeName, elementStruct);
PsychSetStructArrayDoubleElement("usagePageValue", elementIndex, (double)currentElement->usagePage, elementStruct);
PsychSetStructArrayDoubleElement("usageValue", elementIndex, (double)currentElement->usage, elementStruct);
HIDGetUsageName (currentElement->usagePage, currentElement->usage, usageName);
PsychSetStructArrayStringElement("usageName", elementIndex, usageName, elementStruct);
//find and return the indices of this collection's member collections and indices
numSubCollections=PsychHIDCountCollectionElements(currentElement, kHIDElementTypeCollection);
numSubIOElements=PsychHIDCountCollectionElements(currentElement, kHIDElementTypeIO);
memberCollectionRecords=(pRecElement*)PsychMallocTemp(sizeof(pRecElement) * numSubCollections);
memberIOElementRecords=(pRecElement*)PsychMallocTemp(sizeof(pRecElement) * numSubIOElements);
PsychHIDFindCollectionElements(currentElement, kHIDElementTypeCollection, memberCollectionRecords, numSubCollections);
PsychHIDFindCollectionElements(currentElement, kHIDElementTypeIO, memberIOElementRecords, numSubIOElements);
memberCollectionIndices=NULL;
PsychAllocateNativeDoubleMat(1, numSubCollections, 1, &memberCollectionIndices, &memberCollectionIndicesMat);
memberIOElementIndices=NULL;
PsychAllocateNativeDoubleMat(1, numSubIOElements, 1, &memberIOElementIndices, &memberIOElementIndicesMat);
for(i=0;i<numSubCollections;i++)
memberCollectionIndices[i]=PsychHIDGetIndexFromRecord(specDevice, memberCollectionRecords[i], kHIDElementTypeCollection);
for(i=0;i<numSubIOElements;i++)
memberIOElementIndices[i]=PsychHIDGetIndexFromRecord(specDevice, memberIOElementRecords[i], kHIDElementTypeIO);
PsychFreeTemp(memberCollectionRecords);
PsychFreeTemp(memberIOElementRecords);
PsychSetStructArrayNativeElement("memberCollectionIndices", elementIndex, memberCollectionIndicesMat, elementStruct);
PsychSetStructArrayNativeElement("memberElementIndices", elementIndex, memberIOElementIndicesMat, elementStruct);
++elementIndex;
}
return(PsychError_none);
}
