USB Host Shield 2.0
hidescriptorparser.cpp
Go to the documentation of this file.
1 /* Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
2 
3 This software may be distributed and modified under the terms of the GNU
4 General Public License version 2 (GPL2) as published by the Free Software
5 Foundation and appearing in the file GPL2.TXT included in the packaging of
6 this file. Please note that GPL2 Section 2[b] requires that all works based
7 on this software must also be made publicly available under the terms of
8 the GPL2 ("Copyleft").
9 
10 Contact information
11 -------------------
12 
13 Circuits At Home, LTD
14 Web : http://www.circuitsathome.com
15 e-mail : support@circuitsathome.com
16  */
17 
18 #include "hidescriptorparser.h"
19 
20 const char * const ReportDescParserBase::usagePageTitles0[] PROGMEM = {
36 };
37 
38 const char * const ReportDescParserBase::usagePageTitles1[] PROGMEM = {
45 };
46 const char * const ReportDescParserBase::genDesktopTitles0[] PROGMEM = {
55 
56 };
57 const char * const ReportDescParserBase::genDesktopTitles1[] PROGMEM = {
58  pstrUsageX,
59  pstrUsageY,
60  pstrUsageZ,
83 };
84 const char * const ReportDescParserBase::genDesktopTitles2[] PROGMEM = {
105 };
106 const char * const ReportDescParserBase::genDesktopTitles3[] PROGMEM = {
116 };
117 const char * const ReportDescParserBase::genDesktopTitles4[] PROGMEM = {
126 };
127 const char * const ReportDescParserBase::simuTitles0[] PROGMEM = {
140 };
141 const char * const ReportDescParserBase::simuTitles1[] PROGMEM = {
148 };
149 const char * const ReportDescParserBase::simuTitles2[] PROGMEM = {
183 };
184 const char * const ReportDescParserBase::vrTitles0[] PROGMEM = {
195 };
196 const char * const ReportDescParserBase::vrTitles1[] PROGMEM = {
199 };
200 const char * const ReportDescParserBase::sportsCtrlTitles0[] PROGMEM = {
205 };
206 const char * const ReportDescParserBase::sportsCtrlTitles1[] PROGMEM = {
207  pstrUsageOar,
217 };
218 const char * const ReportDescParserBase::sportsCtrlTitles2[] PROGMEM = {
239 };
240 const char * const ReportDescParserBase::gameTitles0[] PROGMEM = {
244 };
245 const char * const ReportDescParserBase::gameTitles1[] PROGMEM = {
271 };
272 const char * const ReportDescParserBase::genDevCtrlTitles[] PROGMEM = {
280 };
281 const char * const ReportDescParserBase::ledTitles[] PROGMEM = {
301  pstrUsageCAV,
302  pstrUsageCLV,
359 };
360 const char * const ReportDescParserBase::telTitles0 [] PROGMEM = {
368 };
369 const char * const ReportDescParserBase::telTitles1 [] PROGMEM = {
388 };
389 const char * const ReportDescParserBase::telTitles2 [] PROGMEM = {
394 };
395 const char * const ReportDescParserBase::telTitles3 [] PROGMEM = {
401 };
402 const char * const ReportDescParserBase::telTitles4 [] PROGMEM = {
418 };
419 const char * const ReportDescParserBase::telTitles5 [] PROGMEM = {
436 };
437 const char * const ReportDescParserBase::consTitles0[] PROGMEM = {
444 };
445 const char * const ReportDescParserBase::consTitles1[] PROGMEM = {
449 };
450 const char * const ReportDescParserBase::consTitles2[] PROGMEM = {
458 
459 };
460 const char * const ReportDescParserBase::consTitles3[] PROGMEM = {
470 };
471 const char * const ReportDescParserBase::consTitles4[] PROGMEM = {
479 };
480 const char * const ReportDescParserBase::consTitles5[] PROGMEM = {
518 };
519 const char * const ReportDescParserBase::consTitles6[] PROGMEM = {
551 };
552 const char * const ReportDescParserBase::consTitles7[] PROGMEM = {
561  pstrUsageMPX,
564 };
565 const char * const ReportDescParserBase::consTitles8[] PROGMEM = {
572 };
573 const char * const ReportDescParserBase::consTitles9[] PROGMEM = {
588 };
589 const char * const ReportDescParserBase::consTitlesA[] PROGMEM = {
596 };
597 const char * const ReportDescParserBase::consTitlesB[] PROGMEM = {
609 };
610 const char * const ReportDescParserBase::consTitlesC[] PROGMEM = {
616 };
617 const char * const ReportDescParserBase::consTitlesD[] PROGMEM = {
690 };
691 const char * const ReportDescParserBase::consTitlesE[] PROGMEM = {
833 };
834 const char * const ReportDescParserBase::digitTitles0[] PROGMEM = {
836  pstrUsagePen,
848 };
849 const char * const ReportDescParserBase::digitTitles1[] PROGMEM = {
853 
854 };
855 const char * const ReportDescParserBase::digitTitles2[] PROGMEM = {
861  pstrUsageTap,
879 };
880 const char * const ReportDescParserBase::aplphanumTitles0[] PROGMEM = {
883 };
884 const char * const ReportDescParserBase::aplphanumTitles1[] PROGMEM = {
904  pstrUsageRow,
931 };
932 const char * const ReportDescParserBase::aplphanumTitles2[] PROGMEM = {
954 };
955 const char * const ReportDescParserBase::medInstrTitles0[] PROGMEM = {
964 };
965 const char * const ReportDescParserBase::medInstrTitles1[] PROGMEM = {
971 };
972 const char * const ReportDescParserBase::medInstrTitles2[] PROGMEM = {
975 };
976 const char * const ReportDescParserBase::medInstrTitles3[] PROGMEM = {
987 };
988 const char * const ReportDescParserBase::medInstrTitles4[] PROGMEM = {
991 };
992 
993 void ReportDescParserBase::Parse(const uint16_t len, const uint8_t *pbuf, const uint16_t &offset __attribute__((unused))) {
994  uint16_t cntdn = (uint16_t)len;
995  uint8_t *p = (uint8_t*)pbuf;
996 
997 
998  totalSize = 0;
999 
1000  while(cntdn) {
1001  //USB_HOST_SERIAL.println("");
1002  //PrintHex<uint16_t>(offset + len - cntdn);
1003  //USB_HOST_SERIAL.print(":");
1004 
1005  ParseItem(&p, &cntdn);
1006 
1007  //if (ParseItem(&p, &cntdn))
1008  // return;
1009  }
1010  //USBTRACE2("Total:", totalSize);
1011 }
1012 
1013 void ReportDescParserBase::PrintValue(uint8_t *p, uint8_t len) {
1014  E_Notify(PSTR("("), 0x80);
1015  for(; len; p++, len--)
1016  PrintHex<uint8_t > (*p, 0x80);
1017  E_Notify(PSTR(")"), 0x80);
1018 }
1019 
1021  E_Notify(PSTR("("), 0x80);
1022  PrintHex<uint8_t > (data, 0x80);
1023  E_Notify(PSTR(")"), 0x80);
1024 }
1025 
1027  switch(prefix & (TYPE_MASK | TAG_MASK)) {
1028  case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
1029  E_Notify(PSTR("\r\nPush"), 0x80);
1030  break;
1031  case (TYPE_GLOBAL | TAG_GLOBAL_POP):
1032  E_Notify(PSTR("\r\nPop"), 0x80);
1033  break;
1035  E_Notify(PSTR("\r\nUsage Page"), 0x80);
1036  break;
1038  E_Notify(PSTR("\r\nLogical Min"), 0x80);
1039  break;
1041  E_Notify(PSTR("\r\nLogical Max"), 0x80);
1042  break;
1044  E_Notify(PSTR("\r\nPhysical Min"), 0x80);
1045  break;
1047  E_Notify(PSTR("\r\nPhysical Max"), 0x80);
1048  break;
1050  E_Notify(PSTR("\r\nUnit Exp"), 0x80);
1051  break;
1052  case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
1053  E_Notify(PSTR("\r\nUnit"), 0x80);
1054  break;
1056  E_Notify(PSTR("\r\nReport Size"), 0x80);
1057  break;
1059  E_Notify(PSTR("\r\nReport Count"), 0x80);
1060  break;
1062  E_Notify(PSTR("\r\nReport Id"), 0x80);
1063  break;
1064  case (TYPE_LOCAL | TAG_LOCAL_USAGE):
1065  E_Notify(PSTR("\r\nUsage"), 0x80);
1066  break;
1067  case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
1068  E_Notify(PSTR("\r\nUsage Min"), 0x80);
1069  break;
1070  case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
1071  E_Notify(PSTR("\r\nUsage Max"), 0x80);
1072  break;
1073  case (TYPE_MAIN | TAG_MAIN_COLLECTION):
1074  E_Notify(PSTR("\r\nCollection"), 0x80);
1075  break;
1077  E_Notify(PSTR("\r\nEnd Collection"), 0x80);
1078  break;
1079  case (TYPE_MAIN | TAG_MAIN_INPUT):
1080  E_Notify(PSTR("\r\nInput"), 0x80);
1081  break;
1082  case (TYPE_MAIN | TAG_MAIN_OUTPUT):
1083  E_Notify(PSTR("\r\nOutput"), 0x80);
1084  break;
1085  case (TYPE_MAIN | TAG_MAIN_FEATURE):
1086  E_Notify(PSTR("\r\nFeature"), 0x80);
1087  break;
1088  } // switch (**pp & (TYPE_MASK | TAG_MASK))
1089 }
1090 
1091 uint8_t ReportDescParserBase::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
1092  //uint8_t ret = enErrorSuccess;
1093  //reinterpret_cast<>(varBuffer);
1094  switch(itemParseState) {
1095  case 0:
1096  if(**pp == HID_LONG_ITEM_PREFIX)
1097  USBTRACE("\r\nLONG\r\n");
1098  else {
1099  uint8_t size = ((**pp) & DATA_SIZE_MASK);
1100 
1101  itemPrefix = (**pp);
1102  itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
1103 
1105  }
1106  (*pp)++;
1107  (*pcntdn)--;
1108  itemSize--;
1109  itemParseState = 1;
1110 
1111  if(!itemSize)
1112  break;
1113 
1114  if(!pcntdn)
1115  return enErrorIncomplete;
1116  // fall through
1117  case 1:
1118  //USBTRACE2("\r\niSz:",itemSize);
1119 
1122  itemParseState = 2;
1123  // fall through
1124  case 2:
1125  if(!valParser.Parse(pp, pcntdn))
1126  return enErrorIncomplete;
1127  itemParseState = 3;
1128  // fall through
1129  case 3:
1130  {
1131  uint8_t data = *((uint8_t*)varBuffer);
1132 
1133  switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
1134  case (TYPE_LOCAL | TAG_LOCAL_USAGE):
1135  if(pfUsage) {
1136  if(theBuffer.valueSize > 1) {
1137  uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
1138  pfUsage(*ui16);
1139  } else
1140  pfUsage(data);
1141  }
1142  break;
1144  rptSize = data;
1145  PrintByteValue(data);
1146  break;
1148  rptCount = data;
1149  PrintByteValue(data);
1150  break;
1156  case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
1157  case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
1159  case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
1161  break;
1162  case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
1163  case (TYPE_GLOBAL | TAG_GLOBAL_POP):
1164  break;
1166  SetUsagePage(data);
1167  PrintUsagePage(data);
1168  PrintByteValue(data);
1169  break;
1170  case (TYPE_MAIN | TAG_MAIN_COLLECTION):
1172  switch(data) {
1173  case 0x00:
1174  E_Notify(PSTR(" Physical"), 0x80);
1175  break;
1176  case 0x01:
1177  E_Notify(PSTR(" Application"), 0x80);
1178  break;
1179  case 0x02:
1180  E_Notify(PSTR(" Logical"), 0x80);
1181  break;
1182  case 0x03:
1183  E_Notify(PSTR(" Report"), 0x80);
1184  break;
1185  case 0x04:
1186  E_Notify(PSTR(" Named Array"), 0x80);
1187  break;
1188  case 0x05:
1189  E_Notify(PSTR(" Usage Switch"), 0x80);
1190  break;
1191  case 0x06:
1192  E_Notify(PSTR(" Usage Modifier"), 0x80);
1193  break;
1194  default:
1195  E_Notify(PSTR(" Vendor Defined("), 0x80);
1196  PrintHex<uint8_t > (data, 0x80);
1197  E_Notify(PSTR(")"), 0x80);
1198  }
1199  break;
1200  case (TYPE_MAIN | TAG_MAIN_INPUT):
1201  case (TYPE_MAIN | TAG_MAIN_OUTPUT):
1202  case (TYPE_MAIN | TAG_MAIN_FEATURE):
1203  totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
1204  rptSize = 0;
1205  rptCount = 0;
1206  E_Notify(PSTR("("), 0x80);
1207  PrintBin<uint8_t > (data, 0x80);
1208  E_Notify(PSTR(")"), 0x80);
1209  break;
1210  } // switch (**pp & (TYPE_MASK | TAG_MASK))
1211  }
1212  } // switch (itemParseState)
1213  itemParseState = 0;
1214  return enErrorSuccess;
1215 }
1216 
1224  NULL, // Keyboard/Keypad
1231  NULL, // Reserved
1232  NULL, // PID
1233  NULL // Unicode
1234 };
1235 
1237  pfUsage = NULL;
1238 
1239  if(VALUE_BETWEEN(page, 0x00, 0x11)) {
1240  pfUsage = (usagePageFunctions[page - 1]);
1241 
1242  } else {
1243  switch(page) {
1244  case 0x14:
1246  break;
1247  case 0x40:
1249  break;
1250  }
1251  }
1252 }
1253 
1255  const char * const * w;
1256  E_Notify(pstrSpace, 0x80);
1257 
1258  output_if_between(page, 0x00, 0x11, w, E_Notify, usagePageTitles0, 0x80)
1259  else output_if_between(page, 0x8b, 0x92, w, E_Notify, usagePageTitles1, 0x80)
1260  else if(VALUE_BETWEEN(page, 0x7f, 0x84))
1262  else if(VALUE_BETWEEN(page, 0x83, 0x8c))
1264  else if(page > 0xfeff /* && page <= 0xffff */)
1266  else
1267  switch(page) {
1268  case 0x14:
1270  break;
1271  case 0x40:
1273  break;
1274  default:
1276  }
1277 }
1278 
1280  E_Notify(pstrSpace, 0x80);
1281  E_Notify(PSTR("Btn"), 0x80);
1282  PrintHex<uint16_t > (usage, 0x80);
1283  E_Notify(PSTR("\r\n"), 0x80);
1284  //USB_HOST_SERIAL.print(usage, HEX);
1285 }
1286 
1288  E_Notify(pstrSpace, 0x80);
1289  E_Notify(PSTR("Inst"), 0x80);
1290  // Sorry, HEX for now...
1291  PrintHex<uint16_t > (usage, 0x80);
1292  E_Notify(PSTR("\r\n"), 0x80);
1293  //USB_HOST_SERIAL.print(usage, DEC);
1294 }
1295 
1297  const char * const * w;
1298  E_Notify(pstrSpace, 0x80);
1299 
1300  output_if_between(usage, 0x00, 0x0a, w, E_Notify, genDesktopTitles0, 0x80)
1301  else output_if_between(usage, 0x2f, 0x49, w, E_Notify, genDesktopTitles1, 0x80)
1302  else output_if_between(usage, 0x7f, 0x94, w, E_Notify, genDesktopTitles2, 0x80)
1303  else output_if_between(usage, 0x9f, 0xa9, w, E_Notify, genDesktopTitles3, 0x80)
1304  else output_if_between(usage, 0xaf, 0xb8, w, E_Notify, genDesktopTitles4, 0x80)
1305  else E_Notify(pstrUsagePageUndefined, 0x80);
1306 }
1307 
1309  const char * const * w;
1310  E_Notify(pstrSpace, 0x80);
1311 
1312  output_if_between(usage, 0x00, 0x0d, w, E_Notify, simuTitles0, 0x80)
1313  else output_if_between(usage, 0x1f, 0x26, w, E_Notify, simuTitles1, 0x80)
1314  else output_if_between(usage, 0xaf, 0xd1, w, E_Notify, simuTitles2, 0x80)
1315  else E_Notify(pstrUsagePageUndefined, 0x80);
1316 }
1317 
1319  const char * const * w;
1320  E_Notify(pstrSpace, 0x80);
1321 
1322  output_if_between(usage, 0x00, 0x0b, w, E_Notify, vrTitles0, 0x80)
1323  else output_if_between(usage, 0x1f, 0x22, w, E_Notify, vrTitles1, 0x80)
1324  else E_Notify(pstrUsagePageUndefined, 0x80);
1325 }
1326 
1328  const char * const * w;
1329  E_Notify(pstrSpace, 0x80);
1330 
1331  output_if_between(usage, 0x00, 0x05, w, E_Notify, sportsCtrlTitles0, 0x80)
1332  else output_if_between(usage, 0x2f, 0x3a, w, E_Notify, sportsCtrlTitles1, 0x80)
1333  else output_if_between(usage, 0x4f, 0x64, w, E_Notify, sportsCtrlTitles2, 0x80)
1334  else E_Notify(pstrUsagePageUndefined, 0x80);
1335 }
1336 
1338  const char * const * w;
1339  E_Notify(pstrSpace, 0x80);
1340 
1341  output_if_between(usage, 0x00, 0x04, w, E_Notify, gameTitles0, 0x80)
1342  else output_if_between(usage, 0x1f, 0x3a, w, E_Notify, gameTitles1, 0x80)
1343  else E_Notify(pstrUsagePageUndefined, 0x80);
1344 }
1345 
1347  const char * const * w;
1348  E_Notify(pstrSpace, 0x80);
1349 
1350  output_if_between(usage, 0x1f, 0x27, w, E_Notify, genDevCtrlTitles, 0x80)
1351  else E_Notify(pstrUsagePageUndefined, 0x80);
1352 }
1353 
1355  const char * const * w;
1356  E_Notify(pstrSpace, 0x80);
1357 
1358  output_if_between(usage, 0x00, 0x4e, w, E_Notify, ledTitles, 0x80)
1359  else E_Notify(pstrUsagePageUndefined, 0x80);
1360 }
1361 
1363  const char * const * w;
1364  E_Notify(pstrSpace, 0x80);
1365 
1366  output_if_between(usage, 0x00, 0x08, w, E_Notify, telTitles0, 0x80)
1367  else output_if_between(usage, 0x1f, 0x32, w, E_Notify, telTitles1, 0x80)
1368  else output_if_between(usage, 0x4f, 0x54, w, E_Notify, telTitles2, 0x80)
1369  else output_if_between(usage, 0x6f, 0x75, w, E_Notify, telTitles3, 0x80)
1370  else output_if_between(usage, 0x8f, 0x9f, w, E_Notify, telTitles4, 0x80)
1371  else output_if_between(usage, 0xaf, 0xc0, w, E_Notify, telTitles5, 0x80)
1372  else E_Notify(pstrUsagePageUndefined, 0x80);
1373 }
1374 
1376  const char * const * w;
1377  E_Notify(pstrSpace, 0x80);
1378 
1379  output_if_between(usage, 0x00, 0x07, w, E_Notify, consTitles0, 0x80)
1380  else output_if_between(usage, 0x1f, 0x23, w, E_Notify, consTitles1, 0x80)
1381  else output_if_between(usage, 0x2f, 0x37, w, E_Notify, consTitles2, 0x80)
1382  else output_if_between(usage, 0x3f, 0x49, w, E_Notify, consTitles3, 0x80)
1383  else output_if_between(usage, 0x5f, 0x67, w, E_Notify, consTitles4, 0x80)
1384  else output_if_between(usage, 0x7f, 0xa5, w, E_Notify, consTitles5, 0x80)
1385  else output_if_between(usage, 0xaf, 0xcf, w, E_Notify, consTitles6, 0x80)
1386  else output_if_between(usage, 0xdf, 0xeb, w, E_Notify, consTitles7, 0x80)
1387  else output_if_between(usage, 0xef, 0xf6, w, E_Notify, consTitles8, 0x80)
1388  else output_if_between(usage, 0xff, 0x10e, w, E_Notify, consTitles9, 0x80)
1389  else output_if_between(usage, 0x14f, 0x156, w, E_Notify, consTitlesA, 0x80)
1390  else output_if_between(usage, 0x15f, 0x16b, w, E_Notify, consTitlesB, 0x80)
1391  else output_if_between(usage, 0x16f, 0x175, w, E_Notify, consTitlesC, 0x80)
1392  else output_if_between(usage, 0x17f, 0x1c8, w, E_Notify, consTitlesD, 0x80)
1393  else output_if_between(usage, 0x1ff, 0x29d, w, E_Notify, consTitlesE, 0x80)
1394  else E_Notify(pstrUsagePageUndefined, 0x80);
1395 }
1396 
1398  const char * const * w;
1399  E_Notify(pstrSpace, 0x80);
1400 
1401  output_if_between(usage, 0x00, 0x0e, w, E_Notify, digitTitles0, 0x80)
1402  else output_if_between(usage, 0x1f, 0x23, w, E_Notify, digitTitles1, 0x80)
1403  else output_if_between(usage, 0x2f, 0x47, w, E_Notify, digitTitles2, 0x80)
1404  else E_Notify(pstrUsagePageUndefined, 0x80);
1405 }
1406 
1408  const char * const * w;
1409  E_Notify(pstrSpace, 0x80);
1410 
1411  output_if_between(usage, 0x00, 0x03, w, E_Notify, aplphanumTitles0, 0x80)
1412  else output_if_between(usage, 0x1f, 0x4e, w, E_Notify, aplphanumTitles1, 0x80)
1413  else output_if_between(usage, 0x7f, 0x96, w, E_Notify, digitTitles2, 0x80)
1414  else E_Notify(pstrUsagePageUndefined, 0x80);
1415 }
1416 
1418  const char * const * w;
1419  E_Notify(pstrSpace, 0x80);
1420 
1421  if(usage == 1) E_Notify(pstrUsageMedicalUltrasound, 0x80);
1422  else if(usage == 0x70)
1424  else output_if_between(usage, 0x1f, 0x28, w, E_Notify, medInstrTitles0, 0x80)
1425  else output_if_between(usage, 0x3f, 0x45, w, E_Notify, medInstrTitles1, 0x80)
1426  else output_if_between(usage, 0x5f, 0x62, w, E_Notify, medInstrTitles2, 0x80)
1427  else output_if_between(usage, 0x7f, 0x8a, w, E_Notify, medInstrTitles3, 0x80)
1428  else output_if_between(usage, 0x9f, 0xa2, w, E_Notify, medInstrTitles4, 0x80)
1429  else E_Notify(pstrUsagePageUndefined, 0x80);
1430 }
1431 
1432 uint8_t ReportDescParser2::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
1433  //uint8_t ret = enErrorSuccess;
1434 
1435  switch(itemParseState) {
1436  case 0:
1437  if(**pp == HID_LONG_ITEM_PREFIX)
1438  USBTRACE("\r\nLONG\r\n");
1439  else {
1440  uint8_t size = ((**pp) & DATA_SIZE_MASK);
1441  itemPrefix = (**pp);
1442  itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
1443  }
1444  (*pp)++;
1445  (*pcntdn)--;
1446  itemSize--;
1447  itemParseState = 1;
1448 
1449  if(!itemSize)
1450  break;
1451 
1452  if(!pcntdn)
1453  return enErrorIncomplete;
1454  // fall through
1455  case 1:
1458  itemParseState = 2;
1459  // fall through
1460  case 2:
1461  if(!valParser.Parse(pp, pcntdn))
1462  return enErrorIncomplete;
1463  itemParseState = 3;
1464  // fall through
1465  case 3:
1466  {
1467  uint8_t data = *((uint8_t*)varBuffer);
1468 
1469  switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
1470  case (TYPE_LOCAL | TAG_LOCAL_USAGE):
1471  if(pfUsage) {
1472  if(theBuffer.valueSize > 1) {
1473  uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
1474  pfUsage(*ui16);
1475  } else
1476  pfUsage(data);
1477  }
1478  break;
1480  rptSize = data;
1481  break;
1483  rptCount = data;
1484  break;
1486  rptId = data;
1487  break;
1488  case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
1489  useMin = data;
1490  break;
1491  case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
1492  useMax = data;
1493  break;
1495  SetUsagePage(data);
1496  break;
1497  case (TYPE_MAIN | TAG_MAIN_OUTPUT):
1498  case (TYPE_MAIN | TAG_MAIN_FEATURE):
1499  rptSize = 0;
1500  rptCount = 0;
1501  useMin = 0;
1502  useMax = 0;
1503  break;
1504  case (TYPE_MAIN | TAG_MAIN_INPUT):
1505  OnInputItem(data);
1506 
1507  totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
1508 
1509  rptSize = 0;
1510  rptCount = 0;
1511  useMin = 0;
1512  useMax = 0;
1513  break;
1514  } // switch (**pp & (TYPE_MASK | TAG_MASK))
1515  }
1516  } // switch (itemParseState)
1517  itemParseState = 0;
1518  return enErrorSuccess;
1519 }
1520 
1521 void ReportDescParser2::OnInputItem(uint8_t itm) {
1522  uint8_t byte_offset = (totalSize >> 3); // calculate offset to the next unhandled byte i = (int)(totalCount / 8);
1523  uint32_t tmp = (byte_offset << 3);
1524  uint8_t bit_offset = totalSize - tmp; // number of bits in the current byte already handled
1525  uint8_t *p = pBuf + byte_offset; // current byte pointer
1526 
1527  if(bit_offset)
1528  *p >>= bit_offset;
1529 
1530  uint8_t usage = useMin;
1531 
1532  bool print_usemin_usemax = ((useMin < useMax) && ((itm & 3) == 2) && pfUsage) ? true : false;
1533 
1534  uint8_t bits_of_byte = 8;
1535 
1536  // for each field in field array defined by rptCount
1537  for(uint8_t field = 0; field < rptCount; field++, usage++) {
1538 
1539  union {
1540  uint8_t bResult[4];
1541  uint16_t wResult[2];
1542  uint32_t dwResult;
1543  } result;
1544 
1545  result.dwResult = 0;
1546  uint8_t mask = 0;
1547 
1548  if(print_usemin_usemax)
1549  pfUsage(usage);
1550 
1551  // bits_left - number of bits in the field(array of fields, depending on Report Count) left to process
1552  // bits_of_byte - number of bits in current byte left to process
1553  // bits_to_copy - number of bits to copy to result buffer
1554 
1555  // for each bit in a field
1556  for(uint8_t bits_left = rptSize, bits_to_copy = 0; bits_left;
1557  bits_left -= bits_to_copy) {
1558  bits_to_copy = (bits_left > bits_of_byte) ? bits_of_byte : bits_left;
1559 
1560  result.dwResult <<= bits_to_copy; // Result buffer is shifted by the number of bits to be copied into it
1561 
1562  uint8_t val = *p;
1563 
1564  val >>= (8 - bits_of_byte); // Shift by the number of bits already processed
1565 
1566  mask = 0;
1567 
1568  for(uint8_t j = bits_to_copy; j; j--) {
1569  mask <<= 1;
1570  mask |= 1;
1571  }
1572 
1573  result.bResult[0] = (result.bResult[0] | (val & mask));
1574 
1575  bits_of_byte -= bits_to_copy;
1576 
1577  if(bits_of_byte < 1) {
1578  bits_of_byte = 8;
1579  p++;
1580  }
1581  }
1582  PrintByteValue(result.dwResult);
1583  }
1584  E_Notify(PSTR("\r\n"), 0x80);
1585 }
1586 
1587 void UniversalReportParser::Parse(USBHID *hid, bool is_rpt_id __attribute__((unused)), uint8_t len, uint8_t *buf) {
1588  ReportDescParser2 prs(len, buf);
1589 
1590  uint8_t ret = hid->GetReportDescr(0, &prs);
1591 
1592  if(ret)
1593  ErrorMessage<uint8_t > (PSTR("GetReportDescr-2"), ret);
1594 }
pstrUsageACUnprotect
const char pstrUsageACUnprotect[]
Definition: hidusagestr.h:735
pstrUsageSystemDisplayDual
const char pstrUsageSystemDisplayDual[]
Definition: hidusagestr.h:124
TAG_GLOBAL_LOGICALMAX
#define TAG_GLOBAL_LOGICALMAX
Definition: usbhid.h:47
pstrUsageLightPen
const char pstrUsageLightPen[]
Definition: hidusagestr.h:786
pstrUsageEqualizerEnable
const char pstrUsageEqualizerEnable[]
Definition: hidusagestr.h:284
pstrUsage11Iron
const char pstrUsage11Iron[]
Definition: hidusagestr.h:222
pstrUsageJoystick
const char pstrUsageJoystick[]
Definition: hidusagestr.h:61
pstrUsageArmature
const char pstrUsageArmature[]
Definition: hidusagestr.h:794
pstrUsageFanEnable
const char pstrUsageFanEnable[]
Definition: hidusagestr.h:534
pstrUsageFreeSpaceWand
const char pstrUsageFreeSpaceWand[]
Definition: hidusagestr.h:796
pstrUsageALDocuments
const char pstrUsageALDocuments[]
Definition: hidusagestr.h:609
pstrUsageALConsumerControlConfig
const char pstrUsageALConsumerControlConfig[]
Definition: hidusagestr.h:573
pstrUsagePageScale
const char pstrUsagePageScale[]
Definition: hidusagestr.h:50
pstrUsagePaletteData
const char pstrUsagePaletteData[]
Definition: hidusagestr.h:880
pstrUsageTreadmill
const char pstrUsageTreadmill[]
Definition: hidusagestr.h:200
pstrUsageACTileVert
const char pstrUsageACTileVert[]
Definition: hidusagestr.h:684
pstrUsageACFullScreenView
const char pstrUsageACFullScreenView[]
Definition: hidusagestr.h:673
pstrUsageCoverage
const char pstrUsageCoverage[]
Definition: hidusagestr.h:305
TAG_LOCAL_USAGE
#define TAG_LOCAL_USAGE
Definition: usbhid.h:58
pstrUsagePhoneKey7
const char pstrUsagePhoneKey7[]
Definition: hidusagestr.h:407
pstrUsageEraser
const char pstrUsageEraser[]
Definition: hidusagestr.h:821
pstrUsageDataOnScreen
const char pstrUsageDataOnScreen[]
Definition: hidusagestr.h:443
pstrUsageDPadRight
const char pstrUsageDPadRight[]
Definition: hidusagestr.h:109
ReportDescParserBase::genDesktopTitles3
static const char *const genDesktopTitles3[]
Definition: hidescriptorparser.h:51
pstrUsageMotionModeAdjust
const char pstrUsageMotionModeAdjust[]
Definition: hidusagestr.h:919
pstrUsageMoveForwardBackward
const char pstrUsageMoveForwardBackward[]
Definition: hidusagestr.h:241
pstrUsageTwist
const char pstrUsageTwist[]
Definition: hidusagestr.h:817
pstrUsageOffHook
const char pstrUsageOffHook[]
Definition: hidusagestr.h:294
pstrUsageRedial
const char pstrUsageRedial[]
Definition: hidusagestr.h:362
ReportDescParserBase::PrintGenericDeviceControlsPageUsage
static void PrintGenericDeviceControlsPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1346
pstrUsagePlay
const char pstrUsagePlay[]
Definition: hidusagestr.h:325
ReportDescParserBase::consTitlesB
static const char *const consTitlesB[]
Definition: hidescriptorparser.h:82
pstrUsageMedicalAlarm
const char pstrUsageMedicalAlarm[]
Definition: hidusagestr.h:547
pstrUsageMenuRight
const char pstrUsageMenuRight[]
Definition: hidusagestr.h:439
pstrUsagePitchForwardBackward
const char pstrUsagePitchForwardBackward[]
Definition: hidusagestr.h:238
pstrUsageMark
const char pstrUsageMark[]
Definition: hidusagestr.h:504
pstrUsageTrackingIncrement
const char pstrUsageTrackingIncrement[]
Definition: hidusagestr.h:512
pstrUsageMessage
const char pstrUsageMessage[]
Definition: hidusagestr.h:383
ReportDescParserBase::usagePageTitles0
static const char *const usagePageTitles0[]
Definition: hidescriptorparser.h:46
pstrUsageMessageControls
const char pstrUsageMessageControls[]
Definition: hidusagestr.h:353
pstrUsageCyclicTrim
const char pstrUsageCyclicTrim[]
Definition: hidusagestr.h:145
pstrUsageMenu
const char pstrUsageMenu[]
Definition: hidusagestr.h:434
pstrUsagePhoneKey1
const char pstrUsagePhoneKey1[]
Definition: hidusagestr.h:401
pstrUsageALNextTaskApplication
const char pstrUsageALNextTaskApplication[]
Definition: hidusagestr.h:605
pstrUsagePhoneKey8
const char pstrUsagePhoneKey8[]
Definition: hidusagestr.h:408
ReportDescParserBase::PrintOrdinalPageUsage
static void PrintOrdinalPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1287
pstrUsageAltitude
const char pstrUsageAltitude[]
Definition: hidusagestr.h:816
TAG_GLOBAL_USAGEPAGE
#define TAG_GLOBAL_USAGEPAGE
Definition: usbhid.h:45
pstrUsageHoldupAlarm
const char pstrUsageHoldupAlarm[]
Definition: hidusagestr.h:546
pstrUsageALDictionary
const char pstrUsageALDictionary[]
Definition: hidusagestr.h:611
pstrUsageBarrelSwitch
const char pstrUsageBarrelSwitch[]
Definition: hidusagestr.h:820
pstrUsageChannelDecrement
const char pstrUsageChannelDecrement[]
Definition: hidusagestr.h:479
pstrUsageCallPickup
const char pstrUsageCallPickup[]
Definition: hidusagestr.h:308
ReportDescParserBase::PrintTelephonyPageUsage
static void PrintTelephonyPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1362
pstrUsageMediaSelection
const char pstrUsageMediaSelection[]
Definition: hidusagestr.h:457
pstrUsageACEditTimeZone
const char pstrUsageACEditTimeZone[]
Definition: hidusagestr.h:754
pstrUsageMediaSelectDVD
const char pstrUsageMediaSelectDVD[]
Definition: hidusagestr.h:461
pstrUsageACZoom
const char pstrUsageACZoom[]
Definition: hidusagestr.h:672
TAG_MAIN_FEATURE
#define TAG_MAIN_FEATURE
Definition: usbhid.h:42
pstrSpace
const char pstrSpace[]
Definition: hidusagestr.h:22
pstrUsageACJustifyLeft
const char pstrUsageACJustifyLeft[]
Definition: hidusagestr.h:703
pstrUsageCharacterReport
const char pstrUsageCharacterReport[]
Definition: hidusagestr.h:838
pstrUsageVx
const char pstrUsageVx[]
Definition: hidusagestr.h:82
pstrUsageDepthGainCompensation
const char pstrUsageDepthGainCompensation[]
Definition: hidusagestr.h:911
pstrUsageACFontSize
const char pstrUsageACFontSize[]
Definition: hidusagestr.h:702
pstrUsageCAV
const char pstrUsageCAV[]
Definition: hidusagestr.h:291
pstrUsageSystemDisplayInvert
const char pstrUsageSystemDisplayInvert[]
Definition: hidusagestr.h:120
ReportDescParserBase::itemSize
uint8_t itemSize
Definition: hidescriptorparser.h:107
pstrUsageCursorEnable
const char pstrUsageCursorEnable[]
Definition: hidusagestr.h:852
pstrUsageRecallNumber
const char pstrUsageRecallNumber[]
Definition: hidusagestr.h:378
pstrUsageQuit
const char pstrUsageQuit[]
Definition: hidusagestr.h:470
pstrUsageError
const char pstrUsageError[]
Definition: hidusagestr.h:328
pstrUsageACMirrorVertical
const char pstrUsageACMirrorVertical[]
Definition: hidusagestr.h:699
ReportDescParserBase::genDesktopTitles1
static const char *const genDesktopTitles1[]
Definition: hidescriptorparser.h:49
ReportDescParserBase::ledTitles
static const char *const ledTitles[]
Definition: hidescriptorparser.h:64
pstrUsagePageButton
const char pstrUsagePageButton[]
Definition: hidusagestr.h:38
ReportDescParserBase::aplphanumTitles1
static const char *const aplphanumTitles1[]
Definition: hidescriptorparser.h:90
ReportDescParserBase::consTitlesC
static const char *const consTitlesC[]
Definition: hidescriptorparser.h:83
ReportDescParserBase::theBuffer
MultiValueBuffer theBuffer
Definition: hidescriptorparser.h:101
TAG_GLOBAL_REPORTSIZE
#define TAG_GLOBAL_REPORTSIZE
Definition: usbhid.h:52
ReportDescParserBase::telTitles1
static const char *const telTitles1[]
Definition: hidescriptorparser.h:66
pstrUsageACFontSelect
const char pstrUsageACFontSelect[]
Definition: hidusagestr.h:700
pstrUsageIndicatorGreen
const char pstrUsageIndicatorGreen[]
Definition: hidusagestr.h:344
VALUE_BETWEEN
#define VALUE_BETWEEN(v, l, h)
Definition: macros.h:34
pstrUsageSecurityCodeCharErased
const char pstrUsageSecurityCodeCharErased[]
Definition: hidusagestr.h:268
pstrUsageBatteryStrength
const char pstrUsageBatteryStrength[]
Definition: hidusagestr.h:263
pstrUsageALDigitalWallet
const char pstrUsageALDigitalWallet[]
Definition: hidusagestr.h:628
pstrUsageSubChannel
const char pstrUsageSubChannel[]
Definition: hidusagestr.h:565
pstrUsageALPreviousTaskApplication
const char pstrUsageALPreviousTaskApplication[]
Definition: hidusagestr.h:606
pstrUsageStereo
const char pstrUsageStereo[]
Definition: hidusagestr.h:288
pstrUsageIllumination
const char pstrUsageIllumination[]
Definition: hidusagestr.h:432
ReportDescParserBase::medInstrTitles0
static const char *const medInstrTitles0[]
Definition: hidescriptorparser.h:92
pstrUsagePageGameControls
const char pstrUsagePageGameControls[]
Definition: hidusagestr.h:34
pstrUsageForward
const char pstrUsageForward[]
Definition: hidusagestr.h:320
pstrUsageALGrammarCheck
const char pstrUsageALGrammarCheck[]
Definition: hidusagestr.h:614
pstrUsageDial
const char pstrUsageDial[]
Definition: hidusagestr.h:74
pstrUsageACRefresh
const char pstrUsageACRefresh[]
Definition: hidusagestr.h:664
pstrUsageACSelectAll
const char pstrUsageACSelectAll[]
Definition: hidusagestr.h:655
pstrUsageMicrophoneEnable
const char pstrUsageMicrophoneEnable[]
Definition: hidusagestr.h:903
pstrUsageACSubscriptions
const char pstrUsageACSubscriptions[]
Definition: hidusagestr.h:669
ReportDescParserBase::PrintGameControlsPageUsage
static void PrintGameControlsPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1337
pstrUsageThrottle
const char pstrUsageThrottle[]
Definition: hidusagestr.h:159
DATA_SIZE_MASK
#define DATA_SIZE_MASK
Definition: usbhid.h:26
pstrUsagePhoneKeyA
const char pstrUsagePhoneKeyA[]
Definition: hidusagestr.h:412
ReportDescParserBase::telTitles3
static const char *const telTitles3[]
Definition: hidescriptorparser.h:68
pstrUsageMediaSelectMessages
const char pstrUsageMediaSelectMessages[]
Definition: hidusagestr.h:466
pstrUsageStereoEnable
const char pstrUsageStereoEnable[]
Definition: hidusagestr.h:193
pstrUsagePhoneKeyB
const char pstrUsagePhoneKeyB[]
Definition: hidusagestr.h:413
pstrUsage3Wood
const char pstrUsage3Wood[]
Definition: hidusagestr.h:227
pstrUsageCallerID
const char pstrUsageCallerID[]
Definition: hidusagestr.h:374
pstrUsageFrameForward
const char pstrUsageFrameForward[]
Definition: hidusagestr.h:502
pstrUsagePagePointOfSale
const char pstrUsagePagePointOfSale[]
Definition: hidusagestr.h:52
pstrUsageACNo
const char pstrUsageACNo[]
Definition: hidusagestr.h:719
pstrUsageACHome
const char pstrUsageACHome[]
Definition: hidusagestr.h:660
pstrUsageDiscoverWirelessControl
const char pstrUsageDiscoverWirelessControl[]
Definition: hidusagestr.h:266
pstrUsageOnce
const char pstrUsageOnce[]
Definition: hidusagestr.h:482
pstrUsageCharacterSpacingVertical
const char pstrUsageCharacterSpacingVertical[]
Definition: hidusagestr.h:859
pstrUsageACJustifyRight
const char pstrUsageACJustifyRight[]
Definition: hidusagestr.h:705
ReportDescParserBase::medInstrTitles3
static const char *const medInstrTitles3[]
Definition: hidescriptorparser.h:95
pstrUsage7Iron
const char pstrUsage7Iron[]
Definition: hidusagestr.h:218
pstrUsageToeBrake
const char pstrUsageToeBrake[]
Definition: hidusagestr.h:163
pstrUsagePrint
const char pstrUsagePrint[]
Definition: hidusagestr.h:902
pstrUsageACViewToggle
const char pstrUsageACViewToggle[]
Definition: hidusagestr.h:675
pstrUsageACHistory
const char pstrUsageACHistory[]
Definition: hidusagestr.h:668
pstrUsageStatusReady
const char pstrUsageStatusReady[]
Definition: hidusagestr.h:842
pstrUsageACSyncronize
const char pstrUsageACSyncronize[]
Definition: hidusagestr.h:759
ReportDescParserBase::PrintVRControlsPageUsage
static void PrintVRControlsPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1318
pstrUsageSecondaryFlipper
const char pstrUsageSecondaryFlipper[]
Definition: hidusagestr.h:247
pstrUsageFrontBrake
const char pstrUsageFrontBrake[]
Definition: hidusagestr.h:179
pstrUsagePageCameraControl
const char pstrUsagePageCameraControl[]
Definition: hidusagestr.h:53
pstrUsageACExpand
const char pstrUsageACExpand[]
Definition: hidusagestr.h:724
pstrUsageWhiteBoard
const char pstrUsageWhiteBoard[]
Definition: hidusagestr.h:789
pstrUsagePhoneKey5
const char pstrUsagePhoneKey5[]
Definition: hidusagestr.h:405
pstrUsageScreenCalls
const char pstrUsageScreenCalls[]
Definition: hidusagestr.h:381
pstrUsage4Iron
const char pstrUsage4Iron[]
Definition: hidusagestr.h:215
ReportDescParser2
Definition: hidescriptorparser.h:148
ReportDescParserBase::telTitles4
static const char *const telTitles4[]
Definition: hidescriptorparser.h:69
pstrUsageACScrollUp
const char pstrUsageACScrollUp[]
Definition: hidusagestr.h:676
pstrUsageSystemColdRestart
const char pstrUsageSystemColdRestart[]
Definition: hidusagestr.h:105
ReportDescParserBase::aplphanumTitles2
static const char *const aplphanumTitles2[]
Definition: hidescriptorparser.h:91
pstrUsageACFilter
const char pstrUsageACFilter[]
Definition: hidusagestr.h:750
pstrUsageACSelectParagraph
const char pstrUsageACSelectParagraph[]
Definition: hidusagestr.h:741
ReportDescParserBase::gameTitles0
static const char *const gameTitles0[]
Definition: hidescriptorparser.h:61
pstrUsageDigitizer
const char pstrUsageDigitizer[]
Definition: hidusagestr.h:784
pstrUsageACSort
const char pstrUsageACSort[]
Definition: hidusagestr.h:747
pstrUsageRy
const char pstrUsageRy[]
Definition: hidusagestr.h:71
pstrUsagePhoneKeyC
const char pstrUsagePhoneKeyC[]
Definition: hidusagestr.h:414
pstrUsageMultiplePointDigitizer
const char pstrUsageMultiplePointDigitizer[]
Definition: hidusagestr.h:795
pstrUsageSystemMenuSelect
const char pstrUsageSystemMenuSelect[]
Definition: hidusagestr.h:100
pstrUsageTrackNormal
const char pstrUsageTrackNormal[]
Definition: hidusagestr.h:500
pstrUsagePlayer
const char pstrUsagePlayer[]
Definition: hidusagestr.h:251
pstrUsageFunctionButtons
const char pstrUsageFunctionButtons[]
Definition: hidusagestr.h:433
pstrUsageACAddToCart
const char pstrUsageACAddToCart[]
Definition: hidusagestr.h:723
pstrUsageLightIlluminationLevel
const char pstrUsageLightIlluminationLevel[]
Definition: hidusagestr.h:537
pstrUsageVy
const char pstrUsageVy[]
Definition: hidusagestr.h:83
pstrUsageMediaSelectComputer
const char pstrUsageMediaSelectComputer[]
Definition: hidusagestr.h:458
pstrUsageMediaSelectTape
const char pstrUsageMediaSelectTape[]
Definition: hidusagestr.h:472
ReportDescParserBase::Parse
void Parse(const uint16_t len, const uint8_t *pbuf, const uint16_t &offset)
Definition: hidescriptorparser.cpp:993
pstrUsageACSetBorders
const char pstrUsageACSetBorders[]
Definition: hidusagestr.h:769
pstrUsageALNetworkChat
const char pstrUsageALNetworkChat[]
Definition: hidusagestr.h:595
pstrUsageFrameBackwards
const char pstrUsageFrameBackwards[]
Definition: hidusagestr.h:503
pstrUsageMotocicleSimulationDevice
const char pstrUsageMotocicleSimulationDevice[]
Definition: hidusagestr.h:136
pstrUsageInsideDialTone
const char pstrUsageInsideDialTone[]
Definition: hidusagestr.h:385
pstrUsageSportsSimulationDevice
const char pstrUsageSportsSimulationDevice[]
Definition: hidusagestr.h:137
pstrUsageChannelTop
const char pstrUsageChannelTop[]
Definition: hidusagestr.h:563
pstrUsageBump
const char pstrUsageBump[]
Definition: hidusagestr.h:248
pstrUsageTrackControl
const char pstrUsageTrackControl[]
Definition: hidusagestr.h:147
pstrUsageInsideRingTone
const char pstrUsageInsideRingTone[]
Definition: hidusagestr.h:387
pstrUsageCLV
const char pstrUsageCLV[]
Definition: hidusagestr.h:292
ReportDescParserBase::consTitles8
static const char *const consTitles8[]
Definition: hidescriptorparser.h:79
pstrUsageALPowerStatus
const char pstrUsageALPowerStatus[]
Definition: hidusagestr.h:623
pstrUsagePen
const char pstrUsagePen[]
Definition: hidusagestr.h:785
pstrUsageElevator
const char pstrUsageElevator[]
Definition: hidusagestr.h:156
ReportDescParserBase::simuTitles1
static const char *const simuTitles1[]
Definition: hidescriptorparser.h:54
pstrUsageStandardPlay
const char pstrUsageStandardPlay[]
Definition: hidusagestr.h:530
pstrUsageRepeatFromMark
const char pstrUsageRepeatFromMark[]
Definition: hidusagestr.h:506
ReportDescParserBase::digitTitles1
static const char *const digitTitles1[]
Definition: hidescriptorparser.h:87
pstrUsageWheel
const char pstrUsageWheel[]
Definition: hidusagestr.h:75
pstrUsagePaletteReport
const char pstrUsagePaletteReport[]
Definition: hidusagestr.h:877
pstrUsageACBold
const char pstrUsageACBold[]
Definition: hidusagestr.h:687
pstrUsageErrorNotALoadableCharacter
const char pstrUsageErrorNotALoadableCharacter[]
Definition: hidusagestr.h:843
pstrUsageACSetClock
const char pstrUsageACSetClock[]
Definition: hidusagestr.h:751
ReportDescParserBase::consTitles5
static const char *const consTitles5[]
Definition: hidescriptorparser.h:76
pstrUsagePageOrdinal
const char pstrUsagePageOrdinal[]
Definition: hidusagestr.h:39
pstrUsageACForwardMessage
const char pstrUsageACForwardMessage[]
Definition: hidusagestr.h:764
pstrUsageKeypad
const char pstrUsageKeypad[]
Definition: hidusagestr.h:64
E_Notify
void E_Notify(char const *msg, int lvl)
Definition: message.cpp:41
pstrUsageUnicodeCharset
const char pstrUsageUnicodeCharset[]
Definition: hidusagestr.h:860
pstrUsageTransfer
const char pstrUsageTransfer[]
Definition: hidusagestr.h:363
pstrUsageDisplayEnable
const char pstrUsageDisplayEnable[]
Definition: hidusagestr.h:194
pstrUsagePhoneKeyPound
const char pstrUsagePhoneKeyPound[]
Definition: hidusagestr.h:411
pstrUsageLoudness
const char pstrUsageLoudness[]
Definition: hidusagestr.h:524
pstrUsageHold
const char pstrUsageHold[]
Definition: hidusagestr.h:303
TAG_LOCAL_USAGEMAX
#define TAG_LOCAL_USAGEMAX
Definition: usbhid.h:60
pstrUsagePageSimulationControls
const char pstrUsagePageSimulationControls[]
Definition: hidusagestr.h:31
pstrUsageSnapshot
const char pstrUsageSnapshot[]
Definition: hidusagestr.h:448
pstrUsageGenericGUIAppControls
const char pstrUsageGenericGUIAppControls[]
Definition: hidusagestr.h:641
pstrUsageElectronicCountermeasures
const char pstrUsageElectronicCountermeasures[]
Definition: hidusagestr.h:155
pstrUsagePuck
const char pstrUsagePuck[]
Definition: hidusagestr.h:798
pstrUsageAlternateAudioDecrement
const char pstrUsageAlternateAudioDecrement[]
Definition: hidusagestr.h:569
pstrUsageFlash
const char pstrUsageFlash[]
Definition: hidusagestr.h:359
pstrUsageResolutionMultiplier
const char pstrUsageResolutionMultiplier[]
Definition: hidusagestr.h:90
pstrUsageSlowBlinkOnTime
const char pstrUsageSlowBlinkOnTime[]
Definition: hidusagestr.h:338
pstrUsageOutsideRingTone
const char pstrUsageOutsideRingTone[]
Definition: hidusagestr.h:388
pstrUsageACNew
const char pstrUsageACNew[]
Definition: hidusagestr.h:642
HID_LONG_ITEM_PREFIX
#define HID_LONG_ITEM_PREFIX
Definition: usbhid.h:101
pstrUsageHelicopterSimulationDevice
const char pstrUsageHelicopterSimulationDevice[]
Definition: hidusagestr.h:139
pstrUsageGolfClub
const char pstrUsageGolfClub[]
Definition: hidusagestr.h:198
pstrUsageStop
const char pstrUsageStop[]
Definition: hidusagestr.h:322
pstrUsageACNextLink
const char pstrUsageACNextLink[]
Definition: hidusagestr.h:666
pstrUsageBlitRectangleY2
const char pstrUsageBlitRectangleY2[]
Definition: hidusagestr.h:885
ReportDescParserBase::PrintByteValue
static void PrintByteValue(uint8_t data)
Definition: hidescriptorparser.cpp:1020
pstrUsageACDistributeVerticaly
const char pstrUsageACDistributeVerticaly[]
Definition: hidusagestr.h:781
pstrUsageMicrophone
const char pstrUsageMicrophone[]
Definition: hidusagestr.h:304
pstrUsageSamplingRateDetect
const char pstrUsageSamplingRateDetect[]
Definition: hidusagestr.h:289
pstrUsageDuresAlarm
const char pstrUsageDuresAlarm[]
Definition: hidusagestr.h:545
pstrUsageACForward
const char pstrUsageACForward[]
Definition: hidusagestr.h:662
pstrUsageSailingSimulationDevice
const char pstrUsageSailingSimulationDevice[]
Definition: hidusagestr.h:135
pstrUsageStill
const char pstrUsageStill[]
Definition: hidusagestr.h:449
pstrUsage10Iron
const char pstrUsage10Iron[]
Definition: hidusagestr.h:221
pstrUsageFireAlarm
const char pstrUsageFireAlarm[]
Definition: hidusagestr.h:541
pstrUsageAlternateAudioIncrement
const char pstrUsageAlternateAudioIncrement[]
Definition: hidusagestr.h:568
ReportDescParserBase::gameTitles1
static const char *const gameTitles1[]
Definition: hidescriptorparser.h:62
pstrUsageACCut
const char pstrUsageACCut[]
Definition: hidusagestr.h:653
ReportDescParserBase::sportsCtrlTitles2
static const char *const sportsCtrlTitles2[]
Definition: hidescriptorparser.h:60
pstrUsageTouch
const char pstrUsageTouch[]
Definition: hidusagestr.h:803
pstrUsageACSaveAndClose
const char pstrUsageACSaveAndClose[]
Definition: hidusagestr.h:776
pstrUsageACFind
const char pstrUsageACFind[]
Definition: hidusagestr.h:656
pstrUsageACNumberedList
const char pstrUsageACNumberedList[]
Definition: hidusagestr.h:713
pstrUsageALScreenSaver
const char pstrUsageALScreenSaver[]
Definition: hidusagestr.h:619
ReportDescParserBase::rptCount
uint8_t rptCount
Definition: hidescriptorparser.h:110
pstrUsagePageUnicode
const char pstrUsagePageUnicode[]
Definition: hidusagestr.h:44
pstrUsageMultiModeIndicator
const char pstrUsageMultiModeIndicator[]
Definition: hidusagestr.h:331
pstrUsageRoomTemperature
const char pstrUsageRoomTemperature[]
Definition: hidusagestr.h:539
pstrUsageStickFaceAngle
const char pstrUsageStickFaceAngle[]
Definition: hidusagestr.h:205
pstrUsageALDatabaseApp
const char pstrUsageALDatabaseApp[]
Definition: hidusagestr.h:579
pstrUsage9Iron
const char pstrUsage9Iron[]
Definition: hidusagestr.h:220
pstrUsageRepeat
const char pstrUsageRepeat[]
Definition: hidusagestr.h:287
pstrUsageSubChannelIncrement
const char pstrUsageSubChannelIncrement[]
Definition: hidusagestr.h:566
pstrUsageTransmitPower
const char pstrUsageTransmitPower[]
Definition: hidusagestr.h:905
pstrUsageRudder
const char pstrUsageRudder[]
Definition: hidusagestr.h:158
pstrUsageVCRAcquisition
const char pstrUsageVCRAcquisition[]
Definition: hidusagestr.h:896
pstrUsageLineBusyTone
const char pstrUsageLineBusyTone[]
Definition: hidusagestr.h:392
pstrUsageGamepadFireJump
const char pstrUsageGamepadFireJump[]
Definition: hidusagestr.h:259
pstrUsageSoftButton
const char pstrUsageSoftButton[]
Definition: hidusagestr.h:887
pstrUsageACSelectRow
const char pstrUsageACSelectRow[]
Definition: hidusagestr.h:743
pstrUsageGunBolt
const char pstrUsageGunBolt[]
Definition: hidusagestr.h:252
pstrUsageSleepMode
const char pstrUsageSleepMode[]
Definition: hidusagestr.h:431
ReportDescParserBase::enErrorSuccess
@ enErrorSuccess
Definition: hidescriptorparser.h:139
DATA_SIZE_4
#define DATA_SIZE_4
Definition: usbhid.h:33
pstrUsageACSelectColumn
const char pstrUsageACSelectColumn[]
Definition: hidusagestr.h:742
pstrUsagePageGenericDeviceControls
const char pstrUsagePageGenericDeviceControls[]
Definition: hidusagestr.h:35
ReportDescParserBase::consTitlesE
static const char *const consTitlesE[]
Definition: hidescriptorparser.h:85
pstrUsageSystemDebuggerBreak
const char pstrUsageSystemDebuggerBreak[]
Definition: hidusagestr.h:115
pstrUsageCharAttributeBlink
const char pstrUsageCharAttributeBlink[]
Definition: hidusagestr.h:872
pstrUsageIndicatorColor
const char pstrUsageIndicatorColor[]
Definition: hidusagestr.h:342
pstrUsagePriorityRingTone
const char pstrUsagePriorityRingTone[]
Definition: hidusagestr.h:389
pstrUsageBallast
const char pstrUsageBallast[]
Definition: hidusagestr.h:176
pstrUsagePointOfView
const char pstrUsagePointOfView[]
Definition: hidusagestr.h:236
pstrUsageACAttachFile
const char pstrUsageACAttachFile[]
Definition: hidusagestr.h:766
ReportDescParserBase::consTitlesA
static const char *const consTitlesA[]
Definition: hidescriptorparser.h:81
pstrUsageRandomPlay
const char pstrUsageRandomPlay[]
Definition: hidusagestr.h:495
pstrUsageClimateControlEnable
const char pstrUsageClimateControlEnable[]
Definition: hidusagestr.h:538
pstrUsagePageAlphaNumericDisplay
const char pstrUsagePageAlphaNumericDisplay[]
Definition: hidusagestr.h:45
pstrUsageMessageWaiting
const char pstrUsageMessageWaiting[]
Definition: hidusagestr.h:296
ReportDescParserBase::consTitles3
static const char *const consTitles3[]
Definition: hidescriptorparser.h:74
pstrUsageBarrelElevation
const char pstrUsageBarrelElevation[]
Definition: hidusagestr.h:174
pstrUsageX
const char pstrUsageX[]
Definition: hidusagestr.h:67
pstrUsageFocus
const char pstrUsageFocus[]
Definition: hidusagestr.h:907
pstrUsageACUndo
const char pstrUsageACUndo[]
Definition: hidusagestr.h:651
pstrUsageStickTempo
const char pstrUsageStickTempo[]
Definition: hidusagestr.h:208
pstrUsageToneEnable
const char pstrUsageToneEnable[]
Definition: hidusagestr.h:281
pstrUsageTouchPad
const char pstrUsageTouchPad[]
Definition: hidusagestr.h:788
pstrUsageScanPreviousTrack
const char pstrUsageScanPreviousTrack[]
Definition: hidusagestr.h:492
ReportDescParserBase::vrTitles0
static const char *const vrTitles0[]
Definition: hidescriptorparser.h:56
pstrUsageAttributeData
const char pstrUsageAttributeData[]
Definition: hidusagestr.h:869
pstrUsagePhoneKeyD
const char pstrUsagePhoneKeyD[]
Definition: hidusagestr.h:415
pstrUsageACFlipHorizontal
const char pstrUsageACFlipHorizontal[]
Definition: hidusagestr.h:696
pstrUsageBalanceRight
const char pstrUsageBalanceRight[]
Definition: hidusagestr.h:548
pstrUsageTrackingDecrement
const char pstrUsageTrackingDecrement[]
Definition: hidusagestr.h:513
hidescriptorparser.h
pstrUsageProximity
const char pstrUsageProximity[]
Definition: hidusagestr.h:543
TAG_MAIN_COLLECTION
#define TAG_MAIN_COLLECTION
Definition: usbhid.h:41
pstrUsage3Iron
const char pstrUsage3Iron[]
Definition: hidusagestr.h:214
ReportDescParserBase::genDesktopTitles2
static const char *const genDesktopTitles2[]
Definition: hidescriptorparser.h:50
pstrUsageBassIncrement
const char pstrUsageBassIncrement[]
Definition: hidusagestr.h:550
pstrUsageErrorFotDataCanNotBeRead
const char pstrUsageErrorFotDataCanNotBeRead[]
Definition: hidusagestr.h:844
pstrUsagePhoneKey4
const char pstrUsagePhoneKey4[]
Definition: hidusagestr.h:404
pstrUsageMediaSelectCD
const char pstrUsageMediaSelectCD[]
Definition: hidusagestr.h:467
ReportDescParserBase::genDesktopTitles0
static const char *const genDesktopTitles0[]
Definition: hidescriptorparser.h:48
pstrUsageACNewWindow
const char pstrUsageACNewWindow[]
Definition: hidusagestr.h:682
pstrUsageACEdit
const char pstrUsageACEdit[]
Definition: hidusagestr.h:686
pstrUsageALCalculator
const char pstrUsageALCalculator[]
Definition: hidusagestr.h:588
pstrUsageACFlipVertical
const char pstrUsageACFlipVertical[]
Definition: hidusagestr.h:697
pstrUsageBassBoost
const char pstrUsageBassBoost[]
Definition: hidusagestr.h:522
pstrUsagePause
const char pstrUsagePause[]
Definition: hidusagestr.h:326
pstrUsageACCancel
const char pstrUsageACCancel[]
Definition: hidusagestr.h:720
ReportDescParserBase::pfUsage
UsagePageFunc pfUsage
Definition: hidescriptorparser.h:117
pstrUsageALVoicemail
const char pstrUsageALVoicemail[]
Definition: hidusagestr.h:582
pstrUsageAnimatronicDevice
const char pstrUsageAnimatronicDevice[]
Definition: hidusagestr.h:192
TAG_GLOBAL_POP
#define TAG_GLOBAL_POP
Definition: usbhid.h:56
pstrUsageFontReport
const char pstrUsageFontReport[]
Definition: hidusagestr.h:854
ReportDescParserBase::totalSize
uint16_t totalSize
Definition: hidescriptorparser.h:112
pstrUsageHeadMountedDisplay
const char pstrUsageHeadMountedDisplay[]
Definition: hidusagestr.h:188
pstrUsageACStrikethrough
const char pstrUsageACStrikethrough[]
Definition: hidusagestr.h:690
pstrUsageSystemDisplayToggleIntExt
const char pstrUsageSystemDisplayToggleIntExt[]
Definition: hidusagestr.h:125
USBHID::GetReportDescr
uint8_t GetReportDescr(uint16_t wIndex, USBReadParser *parser=NULL)
Definition: usbhid.cpp:34
pstrUsageMediaSelectGames
const char pstrUsageMediaSelectGames[]
Definition: hidusagestr.h:465
pstrUsage7SegmentDirectMap
const char pstrUsage7SegmentDirectMap[]
Definition: hidusagestr.h:862
pstrUsageSpectralDopplerModeSelect
const char pstrUsageSpectralDopplerModeSelect[]
Definition: hidusagestr.h:914
pstrUsageHeadphone
const char pstrUsageHeadphone[]
Definition: hidusagestr.h:422
ReportDescParserBase::PrintGenericDesktopPageUsage
static void PrintGenericDesktopPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1296
pstrUsageTipSwitch
const char pstrUsageTipSwitch[]
Definition: hidusagestr.h:818
pstrUsageAutomobileSimulationDevice
const char pstrUsageAutomobileSimulationDevice[]
Definition: hidusagestr.h:131
pstrUsageSoftButtonSide
const char pstrUsageSoftButtonSide[]
Definition: hidusagestr.h:889
pstrUsageLeanForwardBackward
const char pstrUsageLeanForwardBackward[]
Definition: hidusagestr.h:244
pstrUsageAntiTorqueControl
const char pstrUsageAntiTorqueControl[]
Definition: hidusagestr.h:150
pstrUsageHeightOfPOV
const char pstrUsageHeightOfPOV[]
Definition: hidusagestr.h:245
ReportDescParserBase::genDesktopTitles4
static const char *const genDesktopTitles4[]
Definition: hidescriptorparser.h:52
ReportDescParserBase::PrintAlphanumDisplayPageUsage
static void PrintAlphanumDisplayPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1407
pstrUsageSystemMenuUp
const char pstrUsageSystemMenuUp[]
Definition: hidusagestr.h:103
pstrUsageMultiAxisController
const char pstrUsageMultiAxisController[]
Definition: hidusagestr.h:65
pstrUsageACSnoozeAlarm
const char pstrUsageACSnoozeAlarm[]
Definition: hidusagestr.h:757
pstrUsageSystemControl
const char pstrUsageSystemControl[]
Definition: hidusagestr.h:91
pstrUsageHeadSet
const char pstrUsageHeadSet[]
Definition: hidusagestr.h:302
pstrUsageMagicCarpetSimulationDevice
const char pstrUsageMagicCarpetSimulationDevice[]
Definition: hidusagestr.h:140
pstrUsagePriorityRingback
const char pstrUsagePriorityRingback[]
Definition: hidusagestr.h:391
TAG_MAIN_OUTPUT
#define TAG_MAIN_OUTPUT
Definition: usbhid.h:40
pstrUsageACDemote
const char pstrUsageACDemote[]
Definition: hidusagestr.h:717
pstrUsageALFileBrowser
const char pstrUsageALFileBrowser[]
Definition: hidusagestr.h:622
pstrUsageSystemMenuExit
const char pstrUsageSystemMenuExit[]
Definition: hidusagestr.h:99
pstrUsageCyclicControl
const char pstrUsageCyclicControl[]
Definition: hidusagestr.h:144
pstrUsageSoftButtonOffset1
const char pstrUsageSoftButtonOffset1[]
Definition: hidusagestr.h:890
pstrUsageRemote
const char pstrUsageRemote[]
Definition: hidusagestr.h:319
TYPE_GLOBAL
#define TYPE_GLOBAL
Definition: usbhid.h:36
pstrUsageSlow
const char pstrUsageSlow[]
Definition: hidusagestr.h:533
pstrUsagePhoneKey3
const char pstrUsagePhoneKey3[]
Definition: hidusagestr.h:403
pstrUsageSelectedIndicator
const char pstrUsageSelectedIndicator[]
Definition: hidusagestr.h:329
pstrUsageSearchMarkBackwards
const char pstrUsageSearchMarkBackwards[]
Definition: hidusagestr.h:509
pstrUsageTelephonyKeyPad
const char pstrUsageTelephonyKeyPad[]
Definition: hidusagestr.h:356
pstrUsageALDigitalRightsManager
const char pstrUsageALDigitalRightsManager[]
Definition: hidusagestr.h:627
pstrUsage14SegmentDirectMap
const char pstrUsage14SegmentDirectMap[]
Definition: hidusagestr.h:864
ReportDescParserBase::itemPrefix
uint8_t itemPrefix
Definition: hidescriptorparser.h:108
pstrUsageACDeleteComment
const char pstrUsageACDeleteComment[]
Definition: hidusagestr.h:737
pstrUsageFlashOnTime
const char pstrUsageFlashOnTime[]
Definition: hidusagestr.h:337
pstrUsageALPresentationApp
const char pstrUsageALPresentationApp[]
Definition: hidusagestr.h:578
pstrUsageHandset
const char pstrUsageHandset[]
Definition: hidusagestr.h:354
pstrUsageBarrelPressure
const char pstrUsageBarrelPressure[]
Definition: hidusagestr.h:801
pstrUsageALAudioBrowser
const char pstrUsageALAudioBrowser[]
Definition: hidusagestr.h:625
pstrUsageGunAutomatic
const char pstrUsageGunAutomatic[]
Definition: hidusagestr.h:257
pstrUsageLightEnable
const char pstrUsageLightEnable[]
Definition: hidusagestr.h:536
pstrUsageStickFollowThough
const char pstrUsageStickFollowThough[]
Definition: hidusagestr.h:207
pstrUsagePagePID
const char pstrUsagePagePID[]
Definition: hidusagestr.h:43
pstrUsageFlightYoke
const char pstrUsageFlightYoke[]
Definition: hidusagestr.h:146
pstrUsageALAlarms
const char pstrUsageALAlarms[]
Definition: hidusagestr.h:620
pstrUsageFeatureNotification
const char pstrUsageFeatureNotification[]
Definition: hidusagestr.h:89
pstrUsageIndicatorAmber
const char pstrUsageIndicatorAmber[]
Definition: hidusagestr.h:345
pstrUsageACCatalog
const char pstrUsageACCatalog[]
Definition: hidusagestr.h:721
pstrUsageSlowTracking
const char pstrUsageSlowTracking[]
Definition: hidusagestr.h:501
pstrUsageIndicatorFlash
const char pstrUsageIndicatorFlash[]
Definition: hidusagestr.h:333
ReportDescParserBase::valParser
MultiByteValueParser valParser
Definition: hidescriptorparser.h:102
pstrUsageCursorPixelPosition
const char pstrUsageCursorPixelPosition[]
Definition: hidusagestr.h:850
pstrUsageWeaponsSelect
const char pstrUsageWeaponsSelect[]
Definition: hidusagestr.h:166
pstrUsageFlightSimulationDevice
const char pstrUsageFlightSimulationDevice[]
Definition: hidusagestr.h:130
pstrUsageDisplayControlReport
const char pstrUsageDisplayControlReport[]
Definition: hidusagestr.h:831
pstrUsageSystemMainMenu
const char pstrUsageSystemMainMenu[]
Definition: hidusagestr.h:96
pstrUsageHelp
const char pstrUsageHelp[]
Definition: hidusagestr.h:471
pstrUsageACPrintPreview
const char pstrUsageACPrintPreview[]
Definition: hidusagestr.h:728
pstrUsageLowCutFilter
const char pstrUsageLowCutFilter[]
Definition: hidusagestr.h:283
TYPE_MAIN
#define TYPE_MAIN
Definition: usbhid.h:35
MultiByteValueParser::Parse
bool Parse(uint8_t **pp, uint16_t *pcntdn)
Definition: parsetools.cpp:26
pstrUsageMediaSelectCable
const char pstrUsageMediaSelectCable[]
Definition: hidusagestr.h:473
pstrUsageALLogonLogoff
const char pstrUsageALLogonLogoff[]
Definition: hidusagestr.h:599
pstrUsagePageConsumer
const char pstrUsagePageConsumer[]
Definition: hidusagestr.h:41
pstrUsageACInsertSymbol
const char pstrUsageACInsertSymbol[]
Definition: hidusagestr.h:775
pstrUsageConfirmationTone1
const char pstrUsageConfirmationTone1[]
Definition: hidusagestr.h:395
pstrUsageACClearAlarm
const char pstrUsageACClearAlarm[]
Definition: hidusagestr.h:756
pstrUsageACInsertRow
const char pstrUsageACInsertRow[]
Definition: hidusagestr.h:770
pstrUsageSystemUndock
const char pstrUsageSystemUndock[]
Definition: hidusagestr.h:112
pstrUsageALMovieBrowser
const char pstrUsageALMovieBrowser[]
Definition: hidusagestr.h:626
pstrUsageACInsertObject
const char pstrUsageACInsertObject[]
Definition: hidusagestr.h:774
pstrUsageTabletFunctionKeys
const char pstrUsageTabletFunctionKeys[]
Definition: hidusagestr.h:809
pstrUsageALInternetBrowser
const char pstrUsageALInternetBrowser[]
Definition: hidusagestr.h:592
pstrUsagePageVendorDefined
const char pstrUsagePageVendorDefined[]
Definition: hidusagestr.h:56
ReportDescParserBase::simuTitles0
static const char *const simuTitles0[]
Definition: hidescriptorparser.h:53
pstrUsageBitDepthFormat
const char pstrUsageBitDepthFormat[]
Definition: hidusagestr.h:875
pstrUsage2DModeAdjust
const char pstrUsage2DModeAdjust[]
Definition: hidusagestr.h:921
pstrUsageACSelectSentence
const char pstrUsageACSelectSentence[]
Definition: hidusagestr.h:740
ReportDescParserBase::itemParseState
uint8_t itemParseState
Definition: hidescriptorparser.h:106
pstrUsageScreenSaverEnable
const char pstrUsageScreenSaverEnable[]
Definition: hidusagestr.h:835
ReportDescParserBase::PrintLEDPageUsage
static void PrintLEDPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1354
pstrUsageSandWedge
const char pstrUsageSandWedge[]
Definition: hidusagestr.h:223
pstrUsageModeStep
const char pstrUsageModeStep[]
Definition: hidusagestr.h:452
pstrUsageBicycleCrank
const char pstrUsageBicycleCrank[]
Definition: hidusagestr.h:177
pstrUsageInUseIndicator
const char pstrUsageInUseIndicator[]
Definition: hidusagestr.h:330
pstrUsageACPasteSpecial
const char pstrUsageACPasteSpecial[]
Definition: hidusagestr.h:729
pstrUsageVbrx
const char pstrUsageVbrx[]
Definition: hidusagestr.h:85
pstrUsageALProgrammableButton
const char pstrUsageALProgrammableButton[]
Definition: hidusagestr.h:572
pstrUsageACPanLeft
const char pstrUsageACPanLeft[]
Definition: hidusagestr.h:679
pstrUsageSoftControlAdjust
const char pstrUsageSoftControlAdjust[]
Definition: hidusagestr.h:923
pstrUsageExternalPowerConnected
const char pstrUsageExternalPowerConnected[]
Definition: hidusagestr.h:348
pstrUsageFanSpeed
const char pstrUsageFanSpeed[]
Definition: hidusagestr.h:535
pstrUsageForwardCalls
const char pstrUsageForwardCalls[]
Definition: hidusagestr.h:366
pstrUsageDPadUp
const char pstrUsageDPadUp[]
Definition: hidusagestr.h:107
ReportDescParserBase::usagePageFunctions
static UsagePageFunc usagePageFunctions[]
Definition: hidescriptorparser.h:99
pstrUsageSystemDisplayExternal
const char pstrUsageSystemDisplayExternal[]
Definition: hidusagestr.h:122
pstrUsageSpectralDopplerModeAdjust
const char pstrUsageSpectralDopplerModeAdjust[]
Definition: hidusagestr.h:915
pstrUsageFastBlinkOffTime
const char pstrUsageFastBlinkOffTime[]
Definition: hidusagestr.h:341
pstrUsageScanNextTrack
const char pstrUsageScanNextTrack[]
Definition: hidusagestr.h:491
pstrUsageConference
const char pstrUsageConference[]
Definition: hidusagestr.h:309
pstrUsage5Wood
const char pstrUsage5Wood[]
Definition: hidusagestr.h:228
pstrUsageHighCutFilter
const char pstrUsageHighCutFilter[]
Definition: hidusagestr.h:282
ReportDescParserBase::aplphanumTitles0
static const char *const aplphanumTitles0[]
Definition: hidescriptorparser.h:89
pstrUsageACJustifyBlockV
const char pstrUsageACJustifyBlockV[]
Definition: hidusagestr.h:710
pstrUsageMediaSelectVCR
const char pstrUsageMediaSelectVCR[]
Definition: hidusagestr.h:468
pstrUsageArticulatedArm
const char pstrUsageArticulatedArm[]
Definition: hidusagestr.h:793
pstrUsageSystemDisplayBoth
const char pstrUsageSystemDisplayBoth[]
Definition: hidusagestr.h:123
pstrUsageSecurityCodeCleared
const char pstrUsageSecurityCodeCleared[]
Definition: hidusagestr.h:269
pstrUsageEnterChannel
const char pstrUsageEnterChannel[]
Definition: hidusagestr.h:454
ReportDescParserBase::consTitles0
static const char *const consTitles0[]
Definition: hidescriptorparser.h:71
pstrUsageRz
const char pstrUsageRz[]
Definition: hidusagestr.h:72
pstrUsageACBulletedList
const char pstrUsageACBulletedList[]
Definition: hidusagestr.h:715
pstrUsageTap
const char pstrUsageTap[]
Definition: hidusagestr.h:805
pstrUsageSleepAfter
const char pstrUsageSleepAfter[]
Definition: hidusagestr.h:430
pstrUsagePagePower
const char pstrUsagePagePower[]
Definition: hidusagestr.h:48
pstrUsageACBuyChkout
const char pstrUsageACBuyChkout[]
Definition: hidusagestr.h:722
pstrUsageDisplayBrightness
const char pstrUsageDisplayBrightness[]
Definition: hidusagestr.h:865
pstrUsagePageMonitor
const char pstrUsagePageMonitor[]
Definition: hidusagestr.h:47
pstrUsageOutsideRingback
const char pstrUsageOutsideRingback[]
Definition: hidusagestr.h:398
pstrUsageStickSpeed
const char pstrUsageStickSpeed[]
Definition: hidusagestr.h:204
pstrUsageChannelCenterFront
const char pstrUsageChannelCenterFront[]
Definition: hidusagestr.h:559
pstrUsageTurretDirection
const char pstrUsageTurretDirection[]
Definition: hidusagestr.h:173
pstrUsageMedicalUltrasound
const char pstrUsageMedicalUltrasound[]
Definition: hidusagestr.h:895
pstrUsageY
const char pstrUsageY[]
Definition: hidusagestr.h:68
pstrUsageHeadTracker
const char pstrUsageHeadTracker[]
Definition: hidusagestr.h:187
pstrUsageCursorPositionReport
const char pstrUsageCursorPositionReport[]
Definition: hidusagestr.h:845
pstrUsageConsumerControl
const char pstrUsageConsumerControl[]
Definition: hidusagestr.h:418
pstrUsageALGraphicsEditor
const char pstrUsageALGraphicsEditor[]
Definition: hidusagestr.h:577
pstrUsageApplicationLaunchButtons
const char pstrUsageApplicationLaunchButtons[]
Definition: hidusagestr.h:570
ReportDescParserBase::medInstrTitles4
static const char *const medInstrTitles4[]
Definition: hidescriptorparser.h:96
pstrUsageACUpload
const char pstrUsageACUpload[]
Definition: hidusagestr.h:767
pstrUsageHandleBars
const char pstrUsageHandleBars[]
Definition: hidusagestr.h:178
pstrUsageALLogJournalTimecard
const char pstrUsageALLogJournalTimecard[]
Definition: hidusagestr.h:586
pstrUsageSoftButtonReport
const char pstrUsageSoftButtonReport[]
Definition: hidusagestr.h:892
pstrUsageStickHeight
const char pstrUsageStickHeight[]
Definition: hidusagestr.h:210
pstrUsageMediaSelectTuner
const char pstrUsageMediaSelectTuner[]
Definition: hidusagestr.h:469
pstrUsageChannelLowFreqEnhancement
const char pstrUsageChannelLowFreqEnhancement[]
Definition: hidusagestr.h:562
pstrUsageAutopilotEnable
const char pstrUsageAutopilotEnable[]
Definition: hidusagestr.h:151
pstrUsageOnLine
const char pstrUsageOnLine[]
Definition: hidusagestr.h:313
pstrUsageAileronTrim
const char pstrUsageAileronTrim[]
Definition: hidusagestr.h:149
pstrUsagePageReserved
const char pstrUsagePageReserved[]
Definition: hidusagestr.h:55
pstrUsageWirelessChannel
const char pstrUsageWirelessChannel[]
Definition: hidusagestr.h:264
pstrUsageRollRightLeft
const char pstrUsageRollRightLeft[]
Definition: hidusagestr.h:239
pstrUsageALLocalMachineBrowser
const char pstrUsageALLocalMachineBrowser[]
Definition: hidusagestr.h:590
pstrUsageReset
const char pstrUsageReset[]
Definition: hidusagestr.h:428
pstrUsageSpeakerSystem
const char pstrUsageSpeakerSystem[]
Definition: hidusagestr.h:554
pstrUsageClosedCaptionSelect
const char pstrUsageClosedCaptionSelect[]
Definition: hidusagestr.h:445
pstrUsageFinger
const char pstrUsageFinger[]
Definition: hidusagestr.h:799
ReportDescParserBase::UsagePageFunc
void(* UsagePageFunc)(uint16_t usage)
Definition: hidescriptorparser.h:24
pstrUsageBassDecrement
const char pstrUsageBassDecrement[]
Definition: hidusagestr.h:551
pstrUsageACCopy
const char pstrUsageACCopy[]
Definition: hidusagestr.h:652
pstrUsageExtendedPlay
const char pstrUsageExtendedPlay[]
Definition: hidusagestr.h:532
pstrUsageACUnlock
const char pstrUsageACUnlock[]
Definition: hidusagestr.h:733
pstrUsageACCollapseAll
const char pstrUsageACCollapseAll[]
Definition: hidusagestr.h:727
pstrUsageSystemDisplaySwapPriSec
const char pstrUsageSystemDisplaySwapPriSec[]
Definition: hidusagestr.h:126
pstrUsageStickType
const char pstrUsageStickType[]
Definition: hidusagestr.h:209
MultiByteValueParser::Initialize
void Initialize(MultiValueBuffer *const pbuf)
Definition: parsetools.h:54
pstrUsageFlipper
const char pstrUsageFlipper[]
Definition: hidusagestr.h:246
pstrUsageACBack
const char pstrUsageACBack[]
Definition: hidusagestr.h:661
pstrUsageFreezeThaw
const char pstrUsageFreezeThaw[]
Definition: hidusagestr.h:897
pstrUsageCharacterSpacingHorizontal
const char pstrUsageCharacterSpacingHorizontal[]
Definition: hidusagestr.h:858
pstrUsagePhone
const char pstrUsagePhone[]
Definition: hidusagestr.h:351
pstrUsagePageTelephone
const char pstrUsagePageTelephone[]
Definition: hidusagestr.h:40
pstrUsageMediaSelectTelephone
const char pstrUsageMediaSelectTelephone[]
Definition: hidusagestr.h:462
pstrUsageACReply
const char pstrUsageACReply[]
Definition: hidusagestr.h:762
pstrUsageSpeakerPhone
const char pstrUsageSpeakerPhone[]
Definition: hidusagestr.h:369
pstrUsageMoveRightLeft
const char pstrUsageMoveRightLeft[]
Definition: hidusagestr.h:240
pstrUsageACNormalView
const char pstrUsageACNormalView[]
Definition: hidusagestr.h:674
pstrUsageIndicatorSlowBlink
const char pstrUsageIndicatorSlowBlink[]
Definition: hidusagestr.h:334
pstrUsage2Iron
const char pstrUsage2Iron[]
Definition: hidusagestr.h:213
pstrUsagePhoneKey2
const char pstrUsagePhoneKey2[]
Definition: hidusagestr.h:402
pstrUsageSelectDisk
const char pstrUsageSelectDisk[]
Definition: hidusagestr.h:496
pstrUsagePoliceAlarm
const char pstrUsagePoliceAlarm[]
Definition: hidusagestr.h:542
pstrUsageLeanRightLeft
const char pstrUsageLeanRightLeft[]
Definition: hidusagestr.h:243
pstrUsageOculometer
const char pstrUsageOculometer[]
Definition: hidusagestr.h:190
pstrUsageColorDopplerModeSelect
const char pstrUsageColorDopplerModeSelect[]
Definition: hidusagestr.h:916
pstrUsageMenuUp
const char pstrUsageMenuUp[]
Definition: hidusagestr.h:436
pstrUsageCounterReset
const char pstrUsageCounterReset[]
Definition: hidusagestr.h:510
ReportDescParserBase::PrintSimulationControlsPageUsage
static void PrintSimulationControlsPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1308
pstrUsageOrderMovie
const char pstrUsageOrderMovie[]
Definition: hidusagestr.h:455
pstrUsageGunBurst
const char pstrUsageGunBurst[]
Definition: hidusagestr.h:256
pstrUsageFastBlinkOnTime
const char pstrUsageFastBlinkOnTime[]
Definition: hidusagestr.h:340
pstrUsageACJustifyCenterH
const char pstrUsageACJustifyCenterH[]
Definition: hidusagestr.h:704
pstrUsageSystemPowerDown
const char pstrUsageSystemPowerDown[]
Definition: hidusagestr.h:92
pstrUsageACSplit
const char pstrUsageACSplit[]
Definition: hidusagestr.h:779
TAG_GLOBAL_PUSH
#define TAG_GLOBAL_PUSH
Definition: usbhid.h:55
pstrUsagePowerWedge
const char pstrUsagePowerWedge[]
Definition: hidusagestr.h:225
pstrUsageACFontColor
const char pstrUsageACFontColor[]
Definition: hidusagestr.h:701
pstrUsageSave
const char pstrUsageSave[]
Definition: hidusagestr.h:901
pstrUsageSoftButtonID
const char pstrUsageSoftButtonID[]
Definition: hidusagestr.h:888
pstrUsageSoftControlSelect
const char pstrUsageSoftControlSelect[]
Definition: hidusagestr.h:922
ReportDescParserBase::PrintButtonPageUsage
static void PrintButtonPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1279
pstrUsageFlexor
const char pstrUsageFlexor[]
Definition: hidusagestr.h:185
pstrUsageApplicationDebuggerBreak
const char pstrUsageApplicationDebuggerBreak[]
Definition: hidusagestr.h:117
pstrUsageReverse
const char pstrUsageReverse[]
Definition: hidusagestr.h:321
pstrUsageLoftWedge
const char pstrUsageLoftWedge[]
Definition: hidusagestr.h:224
pstrUsageALOnlineShoppingBrowser
const char pstrUsageALOnlineShoppingBrowser[]
Definition: hidusagestr.h:634
pstrUsageKeyboard
const char pstrUsageKeyboard[]
Definition: hidusagestr.h:63
pstrUsageALPreemptiveHaltTaskApp
const char pstrUsageALPreemptiveHaltTaskApp[]
Definition: hidusagestr.h:607
pstrUsageOar
const char pstrUsageOar[]
Definition: hidusagestr.h:201
pstrUsageSoftButtonOffset2
const char pstrUsageSoftButtonOffset2[]
Definition: hidusagestr.h:891
pstrUsageChannelIncrement
const char pstrUsageChannelIncrement[]
Definition: hidusagestr.h:478
pstrUsageFontReadBack
const char pstrUsageFontReadBack[]
Definition: hidusagestr.h:830
pstrUsageACSelectObject
const char pstrUsageACSelectObject[]
Definition: hidusagestr.h:745
pstrUsageACExit
const char pstrUsageACExit[]
Definition: hidusagestr.h:645
pstrUsageCharAttributeEnhance
const char pstrUsageCharAttributeEnhance[]
Definition: hidusagestr.h:870
pstrUsagePageUndefined
const char pstrUsagePageUndefined[]
Definition: hidusagestr.h:29
pstrUsageRing
const char pstrUsageRing[]
Definition: hidusagestr.h:295
pstrUsageACScrollDown
const char pstrUsageACScrollDown[]
Definition: hidusagestr.h:677
pstrUsageSystemBreak
const char pstrUsageSystemBreak[]
Definition: hidusagestr.h:114
pstrUsageMediaSelectVideoPhone
const char pstrUsageMediaSelectVideoPhone[]
Definition: hidusagestr.h:464
pstrUsageMotionWakeup
const char pstrUsageMotionWakeup[]
Definition: hidusagestr.h:79
pstrUsageMPX
const char pstrUsageMPX[]
Definition: hidusagestr.h:525
pstrUsageBrake
const char pstrUsageBrake[]
Definition: hidusagestr.h:169
ReportDescParserBase::PrintUsagePage
static void PrintUsagePage(uint16_t page)
Definition: hidescriptorparser.cpp:1254
pstrUsageNightMode
const char pstrUsageNightMode[]
Definition: hidusagestr.h:306
pstrUsageALResearchSearchBrowser
const char pstrUsageALResearchSearchBrowser[]
Definition: hidusagestr.h:639
pstrUsageACSuperscript
const char pstrUsageACSuperscript[]
Definition: hidusagestr.h:692
pstrUsageZoomAdjust
const char pstrUsageZoomAdjust[]
Definition: hidusagestr.h:913
pstrUsageVerticalScroll
const char pstrUsageVerticalScroll[]
Definition: hidusagestr.h:836
pstrUsageSystemSpeakerMute
const char pstrUsageSystemSpeakerMute[]
Definition: hidusagestr.h:118
pstrUsageWingFlaps
const char pstrUsageWingFlaps[]
Definition: hidusagestr.h:167
pstrUsageNumLock
const char pstrUsageNumLock[]
Definition: hidusagestr.h:272
pstrUsageBalance
const char pstrUsageBalance[]
Definition: hidusagestr.h:518
ReportDescParserBase::PrintValue
static void PrintValue(uint8_t *p, uint8_t len)
Definition: hidescriptorparser.cpp:1013
pstrUsageALCheckbookFinance
const char pstrUsageALCheckbookFinance[]
Definition: hidusagestr.h:587
pstrUsageSubChannelDecrement
const char pstrUsageSubChannelDecrement[]
Definition: hidusagestr.h:567
pstrUsageHorizontalScroll
const char pstrUsageHorizontalScroll[]
Definition: hidusagestr.h:837
pstrUsageACSortDescending
const char pstrUsageACSortDescending[]
Definition: hidusagestr.h:749
pstrUsageACDelete
const char pstrUsageACDelete[]
Definition: hidusagestr.h:731
pstrUsageWeaponsArm
const char pstrUsageWeaponsArm[]
Definition: hidusagestr.h:165
pstrUsageMediaSelectCall
const char pstrUsageMediaSelectCall[]
Definition: hidusagestr.h:477
ReportDescParserBase::consTitles4
static const char *const consTitles4[]
Definition: hidescriptorparser.h:75
pstrUsageGunClip
const char pstrUsageGunClip[]
Definition: hidusagestr.h:253
pstrUsageXTilt
const char pstrUsageXTilt[]
Definition: hidusagestr.h:813
pstrUsageSecurityEnable
const char pstrUsageSecurityEnable[]
Definition: hidusagestr.h:540
pstrUsageYTilt
const char pstrUsageYTilt[]
Definition: hidusagestr.h:814
pstrUsageChannelLeft
const char pstrUsageChannelLeft[]
Definition: hidusagestr.h:555
pstrUsageALCommandLineProcessorRun
const char pstrUsageALCommandLineProcessorRun[]
Definition: hidusagestr.h:602
pstrUsageBalanceLeft
const char pstrUsageBalanceLeft[]
Definition: hidusagestr.h:549
pstrUsageACFindAndReplace
const char pstrUsageACFindAndReplace[]
Definition: hidusagestr.h:657
pstrUsageDivePlane
const char pstrUsageDivePlane[]
Definition: hidusagestr.h:175
pstrUsageSpinning
const char pstrUsageSpinning[]
Definition: hidusagestr.h:290
pstrUsageVbry
const char pstrUsageVbry[]
Definition: hidusagestr.h:86
pstrUsageBlitRectangleX1
const char pstrUsageBlitRectangleX1[]
Definition: hidusagestr.h:882
pstrUsageZoomSelect
const char pstrUsageZoomSelect[]
Definition: hidusagestr.h:912
ReportDescParserBase::telTitles0
static const char *const telTitles0[]
Definition: hidescriptorparser.h:65
pstrUsageChannelFront
const char pstrUsageChannelFront[]
Definition: hidusagestr.h:558
pstrUsageACMirrorHorizontal
const char pstrUsageACMirrorHorizontal[]
Definition: hidusagestr.h:698
ReportDescParserBase::PrintConsumerPageUsage
static void PrintConsumerPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1375
pstrUsageALAVCapturePlayback
const char pstrUsageALAVCapturePlayback[]
Definition: hidusagestr.h:589
pstrUsage2DModeSelect
const char pstrUsage2DModeSelect[]
Definition: hidusagestr.h:920
pstrUsageACExpandAll
const char pstrUsageACExpandAll[]
Definition: hidusagestr.h:725
pstrUsageByteCount
const char pstrUsageByteCount[]
Definition: hidusagestr.h:78
pstrUsageSecurityCodeCharEntered
const char pstrUsageSecurityCodeCharEntered[]
Definition: hidusagestr.h:267
pstrUsageVolume
const char pstrUsageVolume[]
Definition: hidusagestr.h:517
pstrUsageAlphanumericDisplay
const char pstrUsageAlphanumericDisplay[]
Definition: hidusagestr.h:825
pstrUsageRearBrake
const char pstrUsageRearBrake[]
Definition: hidusagestr.h:180
pstrUsageFlightCommunications
const char pstrUsageFlightCommunications[]
Definition: hidusagestr.h:160
pstrUsage7Wood
const char pstrUsage7Wood[]
Definition: hidusagestr.h:229
pstrUsageNext
const char pstrUsageNext[]
Definition: hidusagestr.h:900
pstrUsageTransducerIndex
const char pstrUsageTransducerIndex[]
Definition: hidusagestr.h:808
pstrUsageCallWaitingTone
const char pstrUsageCallWaitingTone[]
Definition: hidusagestr.h:394
pstrUsageACProtect
const char pstrUsageACProtect[]
Definition: hidusagestr.h:734
pstrUsageCharacterHeight
const char pstrUsageCharacterHeight[]
Definition: hidusagestr.h:857
pstrUsageNumericKeyPad
const char pstrUsageNumericKeyPad[]
Definition: hidusagestr.h:419
pstrUsage5Iron
const char pstrUsage5Iron[]
Definition: hidusagestr.h:216
pstrUsageCursorBlink
const char pstrUsageCursorBlink[]
Definition: hidusagestr.h:853
pstrUsageACRestartNumbering
const char pstrUsageACRestartNumbering[]
Definition: hidusagestr.h:714
pstrUsage6Iron
const char pstrUsage6Iron[]
Definition: hidusagestr.h:217
pstrUsageASCIICharacterSet
const char pstrUsageASCIICharacterSet[]
Definition: hidusagestr.h:828
pstrUsageBlitData
const char pstrUsageBlitData[]
Definition: hidusagestr.h:886
TAG_GLOBAL_REPORTID
#define TAG_GLOBAL_REPORTID
Definition: usbhid.h:53
pstrUsageALImageBrowser
const char pstrUsageALImageBrowser[]
Definition: hidusagestr.h:624
pstrUsageWeekly
const char pstrUsageWeekly[]
Definition: hidusagestr.h:484
pstrUsageMediaSelectSecurity
const char pstrUsageMediaSelectSecurity[]
Definition: hidusagestr.h:475
pstrUsageVz
const char pstrUsageVz[]
Definition: hidusagestr.h:84
pstrUsageVno
const char pstrUsageVno[]
Definition: hidusagestr.h:88
UniversalReportParser::Parse
virtual void Parse(USBHID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf)
Definition: hidescriptorparser.cpp:1587
pstrUsageSpeedDial
const char pstrUsageSpeedDial[]
Definition: hidusagestr.h:376
pstrUsageACSelectTimeZone
const char pstrUsageACSelectTimeZone[]
Definition: hidusagestr.h:753
pstrUsageGunSafety
const char pstrUsageGunSafety[]
Definition: hidusagestr.h:258
pstrUsageACAllCaps
const char pstrUsageACAllCaps[]
Definition: hidusagestr.h:693
pstrUsageACDownload
const char pstrUsageACDownload[]
Definition: hidusagestr.h:768
pstrUsageShift
const char pstrUsageShift[]
Definition: hidusagestr.h:278
pstrUsageALLogon
const char pstrUsageALLogon[]
Definition: hidusagestr.h:597
pstrUsageCameraOn
const char pstrUsageCameraOn[]
Definition: hidusagestr.h:311
pstrUsageInsideRingback
const char pstrUsageInsideRingback[]
Definition: hidusagestr.h:390
pstrUsageMediaSelectProgramGuide
const char pstrUsageMediaSelectProgramGuide[]
Definition: hidusagestr.h:463
pstrUsageALMarketMonitorFinBrowser
const char pstrUsageALMarketMonitorFinBrowser[]
Definition: hidusagestr.h:636
pstrUsageSoundFieldOn
const char pstrUsageSoundFieldOn[]
Definition: hidusagestr.h:285
pstrUsageShootBall
const char pstrUsageShootBall[]
Definition: hidusagestr.h:250
pstrUsageACRedoRepeat
const char pstrUsageACRedoRepeat[]
Definition: hidusagestr.h:746
pstrUsageVbrz
const char pstrUsageVbrz[]
Definition: hidusagestr.h:87
pstrUsageACSetAlarm
const char pstrUsageACSetAlarm[]
Definition: hidusagestr.h:755
pstrUsagePointer
const char pstrUsagePointer[]
Definition: hidusagestr.h:59
pstrUsage8Iron
const char pstrUsage8Iron[]
Definition: hidusagestr.h:219
pstrUsageACIndentDecrease
const char pstrUsageACIndentDecrease[]
Definition: hidusagestr.h:711
pstrUsageALAudioPlayer
const char pstrUsageALAudioPlayer[]
Definition: hidusagestr.h:640
pstrUsagePaletteDataSize
const char pstrUsagePaletteDataSize[]
Definition: hidusagestr.h:878
pstrUsageACResetAlarm
const char pstrUsageACResetAlarm[]
Definition: hidusagestr.h:758
pstrUsageMoveUpDown
const char pstrUsageMoveUpDown[]
Definition: hidusagestr.h:242
pstrUsageAirplaneSimulationDevice
const char pstrUsageAirplaneSimulationDevice[]
Definition: hidusagestr.h:138
pstrUsageRowingMachine
const char pstrUsageRowingMachine[]
Definition: hidusagestr.h:199
pstrUsageReturnToMark
const char pstrUsageReturnToMark[]
Definition: hidusagestr.h:507
pstrUsageACJustifyCenterV
const char pstrUsageACJustifyCenterV[]
Definition: hidusagestr.h:708
pstrUsageTrebleIncrement
const char pstrUsageTrebleIncrement[]
Definition: hidusagestr.h:552
pstrUsageFont7Segment
const char pstrUsageFont7Segment[]
Definition: hidusagestr.h:861
pstrUsageGlove
const char pstrUsageGlove[]
Definition: hidusagestr.h:186
pstrUsageSlider
const char pstrUsageSlider[]
Definition: hidusagestr.h:73
pstrUsageALTermLockScrSav
const char pstrUsageALTermLockScrSav[]
Definition: hidusagestr.h:600
pstrUsageMonthly
const char pstrUsageMonthly[]
Definition: hidusagestr.h:485
pstrUsageBlitRectangleX2
const char pstrUsageBlitRectangleX2[]
Definition: hidusagestr.h:884
pstrUsageChannelCenter
const char pstrUsageChannelCenter[]
Definition: hidusagestr.h:557
pstrUsageALIntegratedHelpCenter
const char pstrUsageALIntegratedHelpCenter[]
Definition: hidusagestr.h:608
pstrUsageALCustomCorpNewsBrowser
const char pstrUsageALCustomCorpNewsBrowser[]
Definition: hidusagestr.h:637
ReportDescParserBase::PrintSportsControlsPageUsage
static void PrintSportsControlsPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1327
pstrUsageALOEMHelp
const char pstrUsageALOEMHelp[]
Definition: hidusagestr.h:631
pstrUsageSystemWarmRestart
const char pstrUsageSystemWarmRestart[]
Definition: hidusagestr.h:106
TAG_MAIN_ENDCOLLECTION
#define TAG_MAIN_ENDCOLLECTION
Definition: usbhid.h:43
pstrUsageGunDevice
const char pstrUsageGunDevice[]
Definition: hidusagestr.h:235
pstrUsageMute
const char pstrUsageMute[]
Definition: hidusagestr.h:280
pstrUsageCapsLock
const char pstrUsageCapsLock[]
Definition: hidusagestr.h:273
pstrUsageACProperties
const char pstrUsageACProperties[]
Definition: hidusagestr.h:650
pstrUsageRate
const char pstrUsageRate[]
Definition: hidusagestr.h:203
pstrUsageACInsertPicture
const char pstrUsageACInsertPicture[]
Definition: hidusagestr.h:773
TAG_GLOBAL_PHYSMAX
#define TAG_GLOBAL_PHYSMAX
Definition: usbhid.h:49
pstrUsageSystemMenuDown
const char pstrUsageSystemMenuDown[]
Definition: hidusagestr.h:104
pstrUsageMediaSelectSatellite
const char pstrUsageMediaSelectSatellite[]
Definition: hidusagestr.h:474
pstrUsageProgrammableButton
const char pstrUsageProgrammableButton[]
Definition: hidusagestr.h:357
pstrUsageIndicatorFastBlink
const char pstrUsageIndicatorFastBlink[]
Definition: hidusagestr.h:335
pstrUsageALContactsAddressBook
const char pstrUsageALContactsAddressBook[]
Definition: hidusagestr.h:583
pstrUsageTabletPick
const char pstrUsageTabletPick[]
Definition: hidusagestr.h:822
pstrUsageACJustifyTop
const char pstrUsageACJustifyTop[]
Definition: hidusagestr.h:707
TAG_GLOBAL_REPORTCOUNT
#define TAG_GLOBAL_REPORTCOUNT
Definition: usbhid.h:54
pstrUsageALSpreadsheet
const char pstrUsageALSpreadsheet[]
Definition: hidusagestr.h:576
pstrUsageACCollapse
const char pstrUsageACCollapse[]
Definition: hidusagestr.h:726
pstrUsageFlightControlStick
const char pstrUsageFlightControlStick[]
Definition: hidusagestr.h:142
pstrUsageACItalics
const char pstrUsageACItalics[]
Definition: hidusagestr.h:688
pstrUsageBitmappedDisplay
const char pstrUsageBitmappedDisplay[]
Definition: hidusagestr.h:826
pstrUsagePlus10
const char pstrUsagePlus10[]
Definition: hidusagestr.h:424
pstrUsageACIndentIncrease
const char pstrUsageACIndentIncrease[]
Definition: hidusagestr.h:712
pstrUsageALSelectTaskApplication
const char pstrUsageALSelectTaskApplication[]
Definition: hidusagestr.h:604
pstrUsageALCalendarSchedule
const char pstrUsageALCalendarSchedule[]
Definition: hidusagestr.h:584
pstrUsageStylus
const char pstrUsageStylus[]
Definition: hidusagestr.h:797
ReportDescParserBase::medInstrTitles2
static const char *const medInstrTitles2[]
Definition: hidescriptorparser.h:94
pstrUsageAnsweringMachine
const char pstrUsageAnsweringMachine[]
Definition: hidusagestr.h:352
pstrUsagePageGenericDesktopControls
const char pstrUsagePageGenericDesktopControls[]
Definition: hidusagestr.h:30
pstrUsagePhoneMute
const char pstrUsagePhoneMute[]
Definition: hidusagestr.h:373
pstrUsageSteering
const char pstrUsageSteering[]
Definition: hidusagestr.h:172
pstrUsageALRemoteNetISPConnect
const char pstrUsageALRemoteNetISPConnect[]
Definition: hidusagestr.h:593
pstrUsageBroadcastMode
const char pstrUsageBroadcastMode[]
Definition: hidusagestr.h:447
pstrUsageSend
const char pstrUsageSend[]
Definition: hidusagestr.h:375
pstrUsageHatSwitch
const char pstrUsageHatSwitch[]
Definition: hidusagestr.h:76
ReportDescParserBase::digitTitles0
static const char *const digitTitles0[]
Definition: hidescriptorparser.h:86
pstrUsageSystemAppMenu
const char pstrUsageSystemAppMenu[]
Definition: hidusagestr.h:97
pstrUsageStopEject
const char pstrUsageStopEject[]
Definition: hidusagestr.h:514
pstrUsageSelect
const char pstrUsageSelect[]
Definition: hidusagestr.h:81
pstrUsageACJustifyBlockH
const char pstrUsageACJustifyBlockH[]
Definition: hidusagestr.h:706
pstrUsageALOnlineCommunity
const char pstrUsageALOnlineCommunity[]
Definition: hidusagestr.h:632
pstrUsageAMPM
const char pstrUsageAMPM[]
Definition: hidusagestr.h:426
pstrUsageDisplayOrientation
const char pstrUsageDisplayOrientation[]
Definition: hidusagestr.h:876
pstrUsageFastForward
const char pstrUsageFastForward[]
Definition: hidusagestr.h:324
pstrUsageHookSwitch
const char pstrUsageHookSwitch[]
Definition: hidusagestr.h:358
pstrUsageMenuValueDecrease
const char pstrUsageMenuValueDecrease[]
Definition: hidusagestr.h:442
pstrUsageSystemMenuRight
const char pstrUsageSystemMenuRight[]
Definition: hidusagestr.h:101
ReportDescParserBase::telTitles2
static const char *const telTitles2[]
Definition: hidescriptorparser.h:67
pstrUsageALLANWANBrow
const char pstrUsageALLANWANBrow[]
Definition: hidusagestr.h:591
pstrUsageSecondaryTipSwitch
const char pstrUsageSecondaryTipSwitch[]
Definition: hidusagestr.h:819
pstrUsageCoordinateMeasuringMachine
const char pstrUsageCoordinateMeasuringMachine[]
Definition: hidusagestr.h:790
pstrUsageLongPlay
const char pstrUsageLongPlay[]
Definition: hidusagestr.h:531
TAG_MAIN_INPUT
#define TAG_MAIN_INPUT
Definition: usbhid.h:39
pstrUsageACMaximize
const char pstrUsageACMaximize[]
Definition: hidusagestr.h:646
pstrUsage9Wood
const char pstrUsage9Wood[]
Definition: hidusagestr.h:230
pstrUsageFlareRelease
const char pstrUsageFlareRelease[]
Definition: hidusagestr.h:161
ReportDescParserBase::consTitles9
static const char *const consTitles9[]
Definition: hidescriptorparser.h:80
pstrUsageTouchScreen
const char pstrUsageTouchScreen[]
Definition: hidusagestr.h:787
pstrUsageDataValid
const char pstrUsageDataValid[]
Definition: hidusagestr.h:807
ReportDescParserBase::digitTitles2
static const char *const digitTitles2[]
Definition: hidescriptorparser.h:88
pstrUsageTracking
const char pstrUsageTracking[]
Definition: hidusagestr.h:499
pstrUsageACSubscript
const char pstrUsageACSubscript[]
Definition: hidusagestr.h:691
ReportDescParserBase::varBuffer
uint8_t varBuffer[sizeof(USB_CONFIGURATION_DESCRIPTOR)]
Definition: hidescriptorparser.h:104
pstrUsageEject
const char pstrUsageEject[]
Definition: hidusagestr.h:494
pstrUsageCine
const char pstrUsageCine[]
Definition: hidusagestr.h:904
pstrUsagePageMSRDevices
const char pstrUsagePageMSRDevices[]
Definition: hidusagestr.h:51
pstrUsageACUnderline
const char pstrUsageACUnderline[]
Definition: hidusagestr.h:689
pstrUsagePhoneKey0
const char pstrUsagePhoneKey0[]
Definition: hidusagestr.h:400
pstrUsageTrebleDecrement
const char pstrUsageTrebleDecrement[]
Definition: hidusagestr.h:553
pstrUsageALSmartCardInfoHelp
const char pstrUsageALSmartCardInfoHelp[]
Definition: hidusagestr.h:635
ReportDescParserBase::ParseItem
virtual uint8_t ParseItem(uint8_t **pp, uint16_t *pcntdn)
Definition: hidescriptorparser.cpp:1091
pstrUsageALThesaurus
const char pstrUsageALThesaurus[]
Definition: hidusagestr.h:610
pstrUsageVCRPlus
const char pstrUsageVCRPlus[]
Definition: hidusagestr.h:481
pstrUsageHandTracker
const char pstrUsageHandTracker[]
Definition: hidusagestr.h:189
pstrUsageConfirmationTone2
const char pstrUsageConfirmationTone2[]
Definition: hidusagestr.h:396
pstrUsageQuality
const char pstrUsageQuality[]
Definition: hidusagestr.h:806
pstrUsageScreenSaverDelay
const char pstrUsageScreenSaverDelay[]
Definition: hidusagestr.h:834
pstrUsageGamepadTrigger
const char pstrUsageGamepadTrigger[]
Definition: hidusagestr.h:260
pstrUsageTonesOff
const char pstrUsageTonesOff[]
Definition: hidusagestr.h:397
pstrUsageBlitRectangleY1
const char pstrUsageBlitRectangleY1[]
Definition: hidusagestr.h:883
pstrUsageALTelephonyDialer
const char pstrUsageALTelephonyDialer[]
Definition: hidusagestr.h:596
pstrUsageSurroundOn
const char pstrUsageSurroundOn[]
Definition: hidusagestr.h:286
pstrUsageDepth
const char pstrUsageDepth[]
Definition: hidusagestr.h:908
ReportDescParserBase::simuTitles2
static const char *const simuTitles2[]
Definition: hidescriptorparser.h:55
pstrUsageAzimuth
const char pstrUsageAzimuth[]
Definition: hidusagestr.h:815
pstrUsageSelection
const char pstrUsageSelection[]
Definition: hidusagestr.h:450
pstrUsageAccelerator
const char pstrUsageAccelerator[]
Definition: hidusagestr.h:168
pstrUsageBatteryLow
const char pstrUsageBatteryLow[]
Definition: hidusagestr.h:300
pstrUsagePhoneKey6
const char pstrUsagePhoneKey6[]
Definition: hidusagestr.h:406
pstrUsageDataReadBack
const char pstrUsageDataReadBack[]
Definition: hidusagestr.h:829
pstrUsageOutsideDialTone
const char pstrUsageOutsideDialTone[]
Definition: hidusagestr.h:386
pstrUsageMediaSelectSAP
const char pstrUsageMediaSelectSAP[]
Definition: hidusagestr.h:480
pstrUsageSearchMarkForward
const char pstrUsageSearchMarkForward[]
Definition: hidusagestr.h:508
pstrUsageClipStore
const char pstrUsageClipStore[]
Definition: hidusagestr.h:898
pstrUsage3DDigitizer
const char pstrUsage3DDigitizer[]
Definition: hidusagestr.h:791
pstrUsageGenericIndicator
const char pstrUsageGenericIndicator[]
Definition: hidusagestr.h:346
pstrUsagePhoneKeyStar
const char pstrUsagePhoneKeyStar[]
Definition: hidusagestr.h:410
pstrUsageDoNotDisturb
const char pstrUsageDoNotDisturb[]
Definition: hidusagestr.h:279
pstrUsageCharacterAttribute
const char pstrUsageCharacterAttribute[]
Definition: hidusagestr.h:867
pstrUsageMenuEscape
const char pstrUsageMenuEscape[]
Definition: hidusagestr.h:440
pstrUsageACPromote
const char pstrUsageACPromote[]
Definition: hidusagestr.h:716
pstrUsageACScroll
const char pstrUsageACScroll[]
Definition: hidusagestr.h:678
pstrUsageDrop
const char pstrUsageDrop[]
Definition: hidusagestr.h:364
pstrUsagePinballDevice
const char pstrUsagePinballDevice[]
Definition: hidusagestr.h:234
pstrUsageCharacterWidth
const char pstrUsageCharacterWidth[]
Definition: hidusagestr.h:856
pstrUsageReady
const char pstrUsageReady[]
Definition: hidusagestr.h:316
pstrUsageDisplayStatus
const char pstrUsageDisplayStatus[]
Definition: hidusagestr.h:840
pstrUsageACInsertMode
const char pstrUsageACInsertMode[]
Definition: hidusagestr.h:730
TAG_LOCAL_USAGEMIN
#define TAG_LOCAL_USAGEMIN
Definition: usbhid.h:59
ReportDescParserBase::sportsCtrlTitles1
static const char *const sportsCtrlTitles1[]
Definition: hidescriptorparser.h:59
pstrUsageSystemDock
const char pstrUsageSystemDock[]
Definition: hidusagestr.h:111
pstrUsageSoftStepSecondary
const char pstrUsageSoftStepSecondary[]
Definition: hidusagestr.h:910
pstrUsageCollectiveControl
const char pstrUsageCollectiveControl[]
Definition: hidusagestr.h:153
pstrUsageACDistributeHorizontaly
const char pstrUsageACDistributeHorizontaly[]
Definition: hidusagestr.h:780
pstrUsageALNetworkConference
const char pstrUsageALNetworkConference[]
Definition: hidusagestr.h:594
pstrUsagePlaySkip
const char pstrUsagePlaySkip[]
Definition: hidusagestr.h:516
TAG_GLOBAL_PHYSMIN
#define TAG_GLOBAL_PHYSMIN
Definition: usbhid.h:48
pstrUsageChannelSide
const char pstrUsageChannelSide[]
Definition: hidusagestr.h:560
pstrUsageBicycleSimulationDevice
const char pstrUsageBicycleSimulationDevice[]
Definition: hidusagestr.h:141
pstrUsageALWordProcessor
const char pstrUsageALWordProcessor[]
Definition: hidusagestr.h:574
pstrUsageVoiceMail
const char pstrUsageVoiceMail[]
Definition: hidusagestr.h:380
pstrUsageBelt
const char pstrUsageBelt[]
Definition: hidusagestr.h:183
pstrUsageRinger
const char pstrUsageRinger[]
Definition: hidusagestr.h:399
pstrUsageProgramChangeKeys
const char pstrUsageProgramChangeKeys[]
Definition: hidusagestr.h:810
pstrUsageACTileHoriz
const char pstrUsageACTileHoriz[]
Definition: hidusagestr.h:683
pstrUsageLine
const char pstrUsageLine[]
Definition: hidusagestr.h:368
pstrUsagePhoneDirectory
const char pstrUsagePhoneDirectory[]
Definition: hidusagestr.h:379
ReportDescParserBase::consTitles7
static const char *const consTitles7[]
Definition: hidescriptorparser.h:78
pstrUsageACSearch
const char pstrUsageACSearch[]
Definition: hidusagestr.h:658
pstrUsageAlternateFunction
const char pstrUsageAlternateFunction[]
Definition: hidusagestr.h:367
pstrUsagePaperJam
const char pstrUsagePaperJam[]
Definition: hidusagestr.h:318
ReportDescParserBase::enErrorIncomplete
@ enErrorIncomplete
Definition: hidescriptorparser.h:140
pstrUsageScrollLock
const char pstrUsageScrollLock[]
Definition: hidusagestr.h:274
pstrUsageDPadDown
const char pstrUsageDPadDown[]
Definition: hidusagestr.h:108
pstrUsagePageDigitizer
const char pstrUsagePageDigitizer[]
Definition: hidusagestr.h:42
pstrUsageALSpellCheck
const char pstrUsageALSpellCheck[]
Definition: hidusagestr.h:613
pstrUsageUntouch
const char pstrUsageUntouch[]
Definition: hidusagestr.h:804
pstrUsagePaletteDataOffset
const char pstrUsagePaletteDataOffset[]
Definition: hidusagestr.h:879
pstrUsageACClose
const char pstrUsageACClose[]
Definition: hidusagestr.h:644
pstrUsageColorDopplerModeAdjust
const char pstrUsageColorDopplerModeAdjust[]
Definition: hidusagestr.h:917
pstrUsageTabletPCSystemControls
const char pstrUsageTabletPCSystemControls[]
Definition: hidusagestr.h:66
pstrUsageBatteryOperation
const char pstrUsageBatteryOperation[]
Definition: hidusagestr.h:298
TAG_GLOBAL_UNITEXP
#define TAG_GLOBAL_UNITEXP
Definition: usbhid.h:50
pstrUsageACFormat
const char pstrUsageACFormat[]
Definition: hidusagestr.h:685
pstrUsageGraphicEqualizer
const char pstrUsageGraphicEqualizer[]
Definition: hidusagestr.h:423
pstrUsageACRename
const char pstrUsageACRename[]
Definition: hidusagestr.h:777
pstrUsagePutter
const char pstrUsagePutter[]
Definition: hidusagestr.h:211
pstrUsageVolumeDecrement
const char pstrUsageVolumeDecrement[]
Definition: hidusagestr.h:527
TAG_MASK
#define TAG_MASK
Definition: usbhid.h:28
pstrUsageReorderTone
const char pstrUsageReorderTone[]
Definition: hidusagestr.h:393
pstrUsageACMinimize
const char pstrUsageACMinimize[]
Definition: hidusagestr.h:647
pstrUsagePark
const char pstrUsagePark[]
Definition: hidusagestr.h:365
pstrUsagePaperOut
const char pstrUsagePaperOut[]
Definition: hidusagestr.h:317
pstrUsageSlowBlinkOffTime
const char pstrUsageSlowBlinkOffTime[]
Definition: hidusagestr.h:339
pstrUsageRingEnable
const char pstrUsageRingEnable[]
Definition: hidusagestr.h:371
pstrUsageClearDisplay
const char pstrUsageClearDisplay[]
Definition: hidusagestr.h:832
pstrUsageACPreviousLink
const char pstrUsageACPreviousLink[]
Definition: hidusagestr.h:665
pstrUsageACPanRight
const char pstrUsageACPanRight[]
Definition: hidusagestr.h:680
pstrUsageBitmapSizeY
const char pstrUsageBitmapSizeY[]
Definition: hidusagestr.h:874
pstrUsageNewGame
const char pstrUsageNewGame[]
Definition: hidusagestr.h:249
pstrUsageDiveBrake
const char pstrUsageDiveBrake[]
Definition: hidusagestr.h:154
USBTRACE
#define USBTRACE(s)
Definition: macros.h:82
pstrUsageChaffRelease
const char pstrUsageChaffRelease[]
Definition: hidusagestr.h:152
pstrUsageRecord
const char pstrUsageRecord[]
Definition: hidusagestr.h:327
PSTR
#define PSTR(str)
Definition: version_helper.h:54
pstrUsageACViewComment
const char pstrUsageACViewComment[]
Definition: hidusagestr.h:738
pstrUsagePlaybackSpeed
const char pstrUsagePlaybackSpeed[]
Definition: hidusagestr.h:529
pstrUsageALOEMFeaturesBrowser
const char pstrUsageALOEMFeaturesBrowser[]
Definition: hidusagestr.h:630
pstrUsageBass
const char pstrUsageBass[]
Definition: hidusagestr.h:520
pstrUsageEnterDisk
const char pstrUsageEnterDisk[]
Definition: hidusagestr.h:497
pstrUsageRecordingFormatDetect
const char pstrUsageRecordingFormatDetect[]
Definition: hidusagestr.h:293
pstrUsageACSendReceive
const char pstrUsageACSendReceive[]
Definition: hidusagestr.h:760
pstrUsageSystemMenuHelp
const char pstrUsageSystemMenuHelp[]
Definition: hidusagestr.h:98
pstrUsageALWirelessStatus
const char pstrUsageALWirelessStatus[]
Definition: hidusagestr.h:615
pstrUsageColumns
const char pstrUsageColumns[]
Definition: hidusagestr.h:849
pstrUsagePageArcade
const char pstrUsagePageArcade[]
Definition: hidusagestr.h:54
pstrUsageMotionModeSelect
const char pstrUsageMotionModeSelect[]
Definition: hidusagestr.h:918
pstrUsageRow
const char pstrUsageRow[]
Definition: hidusagestr.h:846
pstrUsageACSelectWord
const char pstrUsageACSelectWord[]
Definition: hidusagestr.h:739
ReportDescParserBase::telTitles5
static const char *const telTitles5[]
Definition: hidescriptorparser.h:70
pstrUsageMediaSelectWWW
const char pstrUsageMediaSelectWWW[]
Definition: hidusagestr.h:460
pstrUsageVolumeIncrement
const char pstrUsageVolumeIncrement[]
Definition: hidusagestr.h:526
pstrUsageStart
const char pstrUsageStart[]
Definition: hidusagestr.h:80
pstrUsageGunSingleShot
const char pstrUsageGunSingleShot[]
Definition: hidusagestr.h:255
pstrUsagePhoneKey9
const char pstrUsagePhoneKey9[]
Definition: hidusagestr.h:409
pstrUsageApplicationBreak
const char pstrUsageApplicationBreak[]
Definition: hidusagestr.h:116
pstrUsageClosedCaption
const char pstrUsageClosedCaption[]
Definition: hidusagestr.h:444
pstrUsageMediaSelectTV
const char pstrUsageMediaSelectTV[]
Definition: hidusagestr.h:459
ReportDescParserBase::sportsCtrlTitles0
static const char *const sportsCtrlTitles0[]
Definition: hidescriptorparser.h:58
pstrUsageStandBy
const char pstrUsageStandBy[]
Definition: hidusagestr.h:310
pstrUsageZ
const char pstrUsageZ[]
Definition: hidusagestr.h:69
pstrUsageTankSimulationDevice
const char pstrUsageTankSimulationDevice[]
Definition: hidusagestr.h:132
pstrUsage1Wood
const char pstrUsage1Wood[]
Definition: hidusagestr.h:226
pstrUsageALEntertainmentContentBrow
const char pstrUsageALEntertainmentContentBrow[]
Definition: hidusagestr.h:633
pstrUsagePageLEDs
const char pstrUsagePageLEDs[]
Definition: hidusagestr.h:37
pstrUsageMotion
const char pstrUsageMotion[]
Definition: hidusagestr.h:544
pstrUsageACOpen
const char pstrUsageACOpen[]
Definition: hidusagestr.h:643
ReportDescParserBase::SetUsagePage
void SetUsagePage(uint16_t page)
Definition: hidescriptorparser.cpp:1236
TAG_GLOBAL_UNIT
#define TAG_GLOBAL_UNIT
Definition: usbhid.h:51
pstrUsageSystemDisplayLCDAutoscale
const char pstrUsageSystemDisplayLCDAutoscale[]
Definition: hidusagestr.h:127
pstrUsageSendCalls
const char pstrUsageSendCalls[]
Definition: hidusagestr.h:307
ReportDescParserBase::consTitles2
static const char *const consTitles2[]
Definition: hidescriptorparser.h:73
pstrUsageALKeyboardLayout
const char pstrUsageALKeyboardLayout[]
Definition: hidusagestr.h:616
pstrUsageALProcessTaskManager
const char pstrUsageALProcessTaskManager[]
Definition: hidusagestr.h:603
pstrUsageMenuDown
const char pstrUsageMenuDown[]
Definition: hidusagestr.h:437
pstrUsageACJustifyBottom
const char pstrUsageACJustifyBottom[]
Definition: hidusagestr.h:709
pstrUsageCountedBuffer
const char pstrUsageCountedBuffer[]
Definition: hidusagestr.h:77
pstrUsageOffLine
const char pstrUsageOffLine[]
Definition: hidusagestr.h:314
pstrUsagePageSportControls
const char pstrUsagePageSportControls[]
Definition: hidusagestr.h:33
pstrUsageTipPressure
const char pstrUsageTipPressure[]
Definition: hidusagestr.h:800
pstrUsageSpeedSelect
const char pstrUsageSpeedSelect[]
Definition: hidusagestr.h:528
pstrUsageSurroundMode
const char pstrUsageSurroundMode[]
Definition: hidusagestr.h:523
pstrUsageChannelRight
const char pstrUsageChannelRight[]
Definition: hidusagestr.h:556
pstrUsageAnswerOnOff
const char pstrUsageAnswerOnOff[]
Definition: hidusagestr.h:384
pstrUsagePlus100
const char pstrUsagePlus100[]
Definition: hidusagestr.h:425
pstrUsageACReplyAll
const char pstrUsageACReplyAll[]
Definition: hidusagestr.h:763
pstrUsageAssignSelection
const char pstrUsageAssignSelection[]
Definition: hidusagestr.h:451
pstrUsageHeadset
const char pstrUsageHeadset[]
Definition: hidusagestr.h:355
pstrUsageACGoto
const char pstrUsageACGoto[]
Definition: hidusagestr.h:659
pstrUsageALVirusProtection
const char pstrUsageALVirusProtection[]
Definition: hidusagestr.h:617
pstrUsageClearMark
const char pstrUsageClearMark[]
Definition: hidusagestr.h:505
pstrUsageRows
const char pstrUsageRows[]
Definition: hidusagestr.h:848
pstrUsageIndicatorOn
const char pstrUsageIndicatorOn[]
Definition: hidusagestr.h:332
pstrUsageChannelUnknown
const char pstrUsageChannelUnknown[]
Definition: hidusagestr.h:564
pstrUsageRecallLast
const char pstrUsageRecallLast[]
Definition: hidusagestr.h:453
pstrUsageALLaunchButtonConfigTool
const char pstrUsageALLaunchButtonConfigTool[]
Definition: hidusagestr.h:571
pstrUsageSystemContextMenu
const char pstrUsageSystemContextMenu[]
Definition: hidusagestr.h:95
pstrUsageInvert
const char pstrUsageInvert[]
Definition: hidusagestr.h:812
pstrUsageWirelessID
const char pstrUsageWirelessID[]
Definition: hidusagestr.h:265
pstrUsageSleep
const char pstrUsageSleep[]
Definition: hidusagestr.h:429
pstrUsageSystemDisplayInternal
const char pstrUsageSystemDisplayInternal[]
Definition: hidusagestr.h:121
pstrUsageVest
const char pstrUsageVest[]
Definition: hidusagestr.h:191
pstrUsageMouse
const char pstrUsageMouse[]
Definition: hidusagestr.h:60
pstrUsageBatteryOK
const char pstrUsageBatteryOK[]
Definition: hidusagestr.h:299
pstrUsageSystemSetup
const char pstrUsageSystemSetup[]
Definition: hidusagestr.h:113
pstrUsageBitmapSizeX
const char pstrUsageBitmapSizeX[]
Definition: hidusagestr.h:873
pstrUsageSystemSuspend
const char pstrUsageSystemSuspend[]
Definition: hidusagestr.h:347
pstrUsageFont14Segment
const char pstrUsageFont14Segment[]
Definition: hidusagestr.h:863
pstrUsageAttributeReadback
const char pstrUsageAttributeReadback[]
Definition: hidusagestr.h:868
pstrUsageShowCounter
const char pstrUsageShowCounter[]
Definition: hidusagestr.h:511
pstrUsageGunSelector
const char pstrUsageGunSelector[]
Definition: hidusagestr.h:254
ReportDescParserBase::consTitles6
static const char *const consTitles6[]
Definition: hidescriptorparser.h:77
pstrUsageACBookmarks
const char pstrUsageACBookmarks[]
Definition: hidusagestr.h:667
pstrUsagePageKeyboardKeypad
const char pstrUsagePageKeyboardKeypad[]
Definition: hidusagestr.h:36
pstrUsageTreble
const char pstrUsageTreble[]
Definition: hidusagestr.h:521
pstrUsageDaily
const char pstrUsageDaily[]
Definition: hidusagestr.h:483
pstrUsageALInstantMessaging
const char pstrUsageALInstantMessaging[]
Definition: hidusagestr.h:629
USBHID
Definition: usbhid.h:143
pstrUsageCharAttributeUnderline
const char pstrUsageCharAttributeUnderline[]
Definition: hidusagestr.h:871
ReportDescParserBase::vrTitles1
static const char *const vrTitles1[]
Definition: hidescriptorparser.h:57
TAG_GLOBAL_LOGICALMIN
#define TAG_GLOBAL_LOGICALMIN
Definition: usbhid.h:46
TYPE_LOCAL
#define TYPE_LOCAL
Definition: usbhid.h:37
pstrUsageBusy
const char pstrUsageBusy[]
Definition: hidusagestr.h:315
ReportDescParserBase::usagePageTitles1
static const char *const usagePageTitles1[]
Definition: hidescriptorparser.h:47
pstrUsageALEmailReader
const char pstrUsageALEmailReader[]
Definition: hidusagestr.h:580
pstrUsageMediaSelectHome
const char pstrUsageMediaSelectHome[]
Definition: hidusagestr.h:476
ReportDescParserBase::PrintMedicalInstrumentPageUsage
static void PrintMedicalInstrumentPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1417
ReportDescParserBase::consTitlesD
static const char *const consTitlesD[]
Definition: hidescriptorparser.h:84
pstrUsageALNewsreader
const char pstrUsageALNewsreader[]
Definition: hidusagestr.h:581
pstrUsageIndicatorRed
const char pstrUsageIndicatorRed[]
Definition: hidusagestr.h:343
pstrUsageRewind
const char pstrUsageRewind[]
Definition: hidusagestr.h:323
pstrUsageALLogoff
const char pstrUsageALLogoff[]
Definition: hidusagestr.h:598
pstrUsageACZoomOut
const char pstrUsageACZoomOut[]
Definition: hidusagestr.h:671
pstrUsageBaseballBat
const char pstrUsageBaseballBat[]
Definition: hidusagestr.h:197
pstrUsageStickHeelToe
const char pstrUsageStickHeelToe[]
Definition: hidusagestr.h:206
MultiValueBuffer::valueSize
uint8_t valueSize
Definition: parsetools.h:31
ReportDescParserBase::genDevCtrlTitles
static const char *const genDevCtrlTitles[]
Definition: hidescriptorparser.h:63
pstrUsageRingSelect
const char pstrUsageRingSelect[]
Definition: hidusagestr.h:372
pstrUsageCursorMode
const char pstrUsageCursorMode[]
Definition: hidusagestr.h:851
pstrUsageACAttachComment
const char pstrUsageACAttachComment[]
Definition: hidusagestr.h:736
pstrUsageACSendTo
const char pstrUsageACSendTo[]
Definition: hidusagestr.h:761
pstrUsageDPadLeft
const char pstrUsageDPadLeft[]
Definition: hidusagestr.h:110
pstrUsageACZoomIn
const char pstrUsageACZoomIn[]
Definition: hidusagestr.h:670
pstrUsageALClock
const char pstrUsageALClock[]
Definition: hidusagestr.h:621
pstrUsageACLock
const char pstrUsageACLock[]
Definition: hidusagestr.h:732
pstrUsageChannelSurround
const char pstrUsageChannelSurround[]
Definition: hidusagestr.h:561
pstrUsageShifter
const char pstrUsageShifter[]
Definition: hidusagestr.h:171
pstrUsageSoftStepPrimary
const char pstrUsageSoftStepPrimary[]
Definition: hidusagestr.h:909
ReportDescParser2::ParseItem
virtual uint8_t ParseItem(uint8_t **pp, uint16_t *pcntdn)
Definition: hidescriptorparser.cpp:1432
ReportDescParserBase::PrintItemTitle
static void PrintItemTitle(uint8_t prefix)
Definition: hidescriptorparser.cpp:1026
pstrUsageACRotate
const char pstrUsageACRotate[]
Definition: hidusagestr.h:694
pstrUsageDisplayData
const char pstrUsageDisplayData[]
Definition: hidusagestr.h:839
pstrUsageFeature
const char pstrUsageFeature[]
Definition: hidusagestr.h:360
pstrUsageRx
const char pstrUsageRx[]
Definition: hidusagestr.h:70
pstrUsageMenuValueIncrease
const char pstrUsageMenuValueIncrease[]
Definition: hidusagestr.h:441
ReportDescParserBase::PrintDigitizerPageUsage
static void PrintDigitizerPageUsage(uint16_t usage)
Definition: hidescriptorparser.cpp:1397
pstrUsageStereoPlotter
const char pstrUsageStereoPlotter[]
Definition: hidusagestr.h:792
pstrUsagePageBarCodeScanner
const char pstrUsagePageBarCodeScanner[]
Definition: hidusagestr.h:49
pstrUsageGamePad
const char pstrUsageGamePad[]
Definition: hidusagestr.h:62
pstrUsageSystemWakeup
const char pstrUsageSystemWakeup[]
Definition: hidusagestr.h:94
pstrUsageACPan
const char pstrUsageACPan[]
Definition: hidusagestr.h:681
ReportDescParserBase::medInstrTitles1
static const char *const medInstrTitles1[]
Definition: hidescriptorparser.h:93
ReportDescParserBase::rptSize
uint8_t rptSize
Definition: hidescriptorparser.h:109
pstrUsageInRange
const char pstrUsageInRange[]
Definition: hidusagestr.h:802
pstrUsageACPaste
const char pstrUsageACPaste[]
Definition: hidusagestr.h:654
pstrUsageTrigger
const char pstrUsageTrigger[]
Definition: hidusagestr.h:164
TYPE_MASK
#define TYPE_MASK
Definition: usbhid.h:27
pstrUsageALTaskProjectManager
const char pstrUsageALTaskProjectManager[]
Definition: hidusagestr.h:585
pstrUsageACViewClock
const char pstrUsageACViewClock[]
Definition: hidusagestr.h:752
pstrUsageMenuPick
const char pstrUsageMenuPick[]
Definition: hidusagestr.h:435
pstrUsageACInsertColumn
const char pstrUsageACInsertColumn[]
Definition: hidusagestr.h:771
pstrUsage1Iron
const char pstrUsage1Iron[]
Definition: hidusagestr.h:212
pstrUsageCompose
const char pstrUsageCompose[]
Definition: hidusagestr.h:275
pstrUsageSystemSleep
const char pstrUsageSystemSleep[]
Definition: hidusagestr.h:93
pstrUsageACSave
const char pstrUsageACSave[]
Definition: hidusagestr.h:648
ReportDescParserBase::consTitles1
static const char *const consTitles1[]
Definition: hidescriptorparser.h:72
pstrUsageCameraOff
const char pstrUsageCameraOff[]
Definition: hidusagestr.h:312
pstrUsageStoreNumber
const char pstrUsageStoreNumber[]
Definition: hidusagestr.h:377
pstrUsageACYes
const char pstrUsageACYes[]
Definition: hidusagestr.h:718
pstrUsageSpaceshipSimulationDevice
const char pstrUsageSpaceshipSimulationDevice[]
Definition: hidusagestr.h:133
pstrUsageALControlPannel
const char pstrUsageALControlPannel[]
Definition: hidusagestr.h:601
pstrUsageLandingGear
const char pstrUsageLandingGear[]
Definition: hidusagestr.h:162
pstrUsageStatusNotReady
const char pstrUsageStatusNotReady[]
Definition: hidusagestr.h:841
pstrUsageACPrint
const char pstrUsageACPrint[]
Definition: hidusagestr.h:649
pstrUsageTurnRightLeft
const char pstrUsageTurnRightLeft[]
Definition: hidusagestr.h:237
pstrUsageDisplayAttributesReport
const char pstrUsageDisplayAttributesReport[]
Definition: hidusagestr.h:827
pstrUsageSlope
const char pstrUsageSlope[]
Definition: hidusagestr.h:202
pstrUsageDataMode
const char pstrUsageDataMode[]
Definition: hidusagestr.h:297
pstrUsageACSelectTable
const char pstrUsageACSelectTable[]
Definition: hidusagestr.h:744
pstrUsageBodySuit
const char pstrUsageBodySuit[]
Definition: hidusagestr.h:184
pstrUsageClutch
const char pstrUsageClutch[]
Definition: hidusagestr.h:170
pstrUsageACSortAscending
const char pstrUsageACSortAscending[]
Definition: hidusagestr.h:748
pstrUsageFontData
const char pstrUsageFontData[]
Definition: hidusagestr.h:855
pstrUsageALTextEditor
const char pstrUsageALTextEditor[]
Definition: hidusagestr.h:575
pstrUsageACSend
const char pstrUsageACSend[]
Definition: hidusagestr.h:765
pstrUsageMenuLeft
const char pstrUsageMenuLeft[]
Definition: hidusagestr.h:438
pstrUsageSystemMenuLeft
const char pstrUsageSystemMenuLeft[]
Definition: hidusagestr.h:102
pstrUsageSubmarineSimulationDevice
const char pstrUsageSubmarineSimulationDevice[]
Definition: hidusagestr.h:134
pstrUsageALDesktop
const char pstrUsageALDesktop[]
Definition: hidusagestr.h:612
pstrUsageACStop
const char pstrUsageACStop[]
Definition: hidusagestr.h:663
pstrUsageVCRTV
const char pstrUsageVCRTV[]
Definition: hidusagestr.h:446
pstrUsageBlitReport
const char pstrUsageBlitReport[]
Definition: hidusagestr.h:881
pstrUsagePageMedicalInstruments
const char pstrUsagePageMedicalInstruments[]
Definition: hidusagestr.h:46
pstrUsagePower
const char pstrUsagePower[]
Definition: hidusagestr.h:277
pstrUsagePlayPause
const char pstrUsagePlayPause[]
Definition: hidusagestr.h:515
pstrUsageUpdate
const char pstrUsageUpdate[]
Definition: hidusagestr.h:899
pstrUsageSpeaker
const char pstrUsageSpeaker[]
Definition: hidusagestr.h:301
pstrUsageALOnlineActivityBrowser
const char pstrUsageALOnlineActivityBrowser[]
Definition: hidusagestr.h:638
pstrUsageIndicatorOff
const char pstrUsageIndicatorOff[]
Definition: hidusagestr.h:336
pstrUsageAileron
const char pstrUsageAileron[]
Definition: hidusagestr.h:148
pstrUsageKana
const char pstrUsageKana[]
Definition: hidusagestr.h:276
pstrUsage3DGameController
const char pstrUsage3DGameController[]
Definition: hidusagestr.h:233
pstrUsageElevatorTrim
const char pstrUsageElevatorTrim[]
Definition: hidusagestr.h:157
pstrUsageSystemHibernate
const char pstrUsageSystemHibernate[]
Definition: hidusagestr.h:119
pstrUsageFlightStick
const char pstrUsageFlightStick[]
Definition: hidusagestr.h:143
pstrUsageALEncryption
const char pstrUsageALEncryption[]
Definition: hidusagestr.h:618
pstrUsagePageVRControls
const char pstrUsagePageVRControls[]
Definition: hidusagestr.h:32
pstrUsageACInsertFile
const char pstrUsageACInsertFile[]
Definition: hidusagestr.h:772
pstrUsageDisplayContrast
const char pstrUsageDisplayContrast[]
Definition: hidusagestr.h:866
pstrUsageACResize
const char pstrUsageACResize[]
Definition: hidusagestr.h:695
output_if_between
#define output_if_between(v, l, h, wa, fp, mp, el)
Definition: macros.h:37
pstrUsageColumn
const char pstrUsageColumn[]
Definition: hidusagestr.h:847
pstrUsageACMerge
const char pstrUsageACMerge[]
Definition: hidusagestr.h:778
pstrUsageChannel
const char pstrUsageChannel[]
Definition: hidusagestr.h:456