hidescriptorparser.cpp

00001 /* Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
00002 
00003 This software may be distributed and modified under the terms of the GNU
00004 General Public License version 2 (GPL2) as published by the Free Software
00005 Foundation and appearing in the file GPL2.TXT included in the packaging of
00006 this file. Please note that GPL2 Section 2[b] requires that all works based
00007 on this software must also be made publicly available under the terms of
00008 the GPL2 ("Copyleft").
00009 
00010 Contact information
00011 -------------------
00012 
00013 Circuits At Home, LTD
00014 Web      :  http://www.circuitsathome.com
00015 e-mail   :  support@circuitsathome.com
00016  */
00017 
00018 #include "hidescriptorparser.h"
00019 
00020 const char * const ReportDescParserBase::usagePageTitles0[] PROGMEM = {
00021         pstrUsagePageGenericDesktopControls,
00022         pstrUsagePageSimulationControls,
00023         pstrUsagePageVRControls,
00024         pstrUsagePageSportControls,
00025         pstrUsagePageGameControls,
00026         pstrUsagePageGenericDeviceControls,
00027         pstrUsagePageKeyboardKeypad,
00028         pstrUsagePageLEDs,
00029         pstrUsagePageButton,
00030         pstrUsagePageOrdinal,
00031         pstrUsagePageTelephone,
00032         pstrUsagePageConsumer,
00033         pstrUsagePageDigitizer,
00034         pstrUsagePagePID,
00035         pstrUsagePageUnicode
00036 };
00037 
00038 const char * const ReportDescParserBase::usagePageTitles1[] PROGMEM = {
00039         pstrUsagePageBarCodeScanner,
00040         pstrUsagePageScale,
00041         pstrUsagePageMSRDevices,
00042         pstrUsagePagePointOfSale,
00043         pstrUsagePageCameraControl,
00044         pstrUsagePageArcade
00045 };
00046 const char * const ReportDescParserBase::genDesktopTitles0[] PROGMEM = {
00047         pstrUsagePointer,
00048         pstrUsageMouse,
00049         pstrUsageJoystick,
00050         pstrUsageGamePad,
00051         pstrUsageKeyboard,
00052         pstrUsageKeypad,
00053         pstrUsageMultiAxisController,
00054         pstrUsageTabletPCSystemControls
00055 
00056 };
00057 const char * const ReportDescParserBase::genDesktopTitles1[] PROGMEM = {
00058         pstrUsageX,
00059         pstrUsageY,
00060         pstrUsageZ,
00061         pstrUsageRx,
00062         pstrUsageRy,
00063         pstrUsageRz,
00064         pstrUsageSlider,
00065         pstrUsageDial,
00066         pstrUsageWheel,
00067         pstrUsageHatSwitch,
00068         pstrUsageCountedBuffer,
00069         pstrUsageByteCount,
00070         pstrUsageMotionWakeup,
00071         pstrUsageStart,
00072         pstrUsageSelect,
00073         pstrUsagePageReserved,
00074         pstrUsageVx,
00075         pstrUsageVy,
00076         pstrUsageVz,
00077         pstrUsageVbrx,
00078         pstrUsageVbry,
00079         pstrUsageVbrz,
00080         pstrUsageVno,
00081         pstrUsageFeatureNotification,
00082         pstrUsageResolutionMultiplier
00083 };
00084 const char * const ReportDescParserBase::genDesktopTitles2[] PROGMEM = {
00085         pstrUsageSystemControl,
00086         pstrUsageSystemPowerDown,
00087         pstrUsageSystemSleep,
00088         pstrUsageSystemWakeup,
00089         pstrUsageSystemContextMenu,
00090         pstrUsageSystemMainMenu,
00091         pstrUsageSystemAppMenu,
00092         pstrUsageSystemMenuHelp,
00093         pstrUsageSystemMenuExit,
00094         pstrUsageSystemMenuSelect,
00095         pstrUsageSystemMenuRight,
00096         pstrUsageSystemMenuLeft,
00097         pstrUsageSystemMenuUp,
00098         pstrUsageSystemMenuDown,
00099         pstrUsageSystemColdRestart,
00100         pstrUsageSystemWarmRestart,
00101         pstrUsageDPadUp,
00102         pstrUsageDPadDown,
00103         pstrUsageDPadRight,
00104         pstrUsageDPadLeft
00105 };
00106 const char * const ReportDescParserBase::genDesktopTitles3[] PROGMEM = {
00107         pstrUsageSystemDock,
00108         pstrUsageSystemUndock,
00109         pstrUsageSystemSetup,
00110         pstrUsageSystemBreak,
00111         pstrUsageSystemDebuggerBreak,
00112         pstrUsageApplicationBreak,
00113         pstrUsageApplicationDebuggerBreak,
00114         pstrUsageSystemSpeakerMute,
00115         pstrUsageSystemHibernate
00116 };
00117 const char * const ReportDescParserBase::genDesktopTitles4[] PROGMEM = {
00118         pstrUsageSystemDisplayInvert,
00119         pstrUsageSystemDisplayInternal,
00120         pstrUsageSystemDisplayExternal,
00121         pstrUsageSystemDisplayBoth,
00122         pstrUsageSystemDisplayDual,
00123         pstrUsageSystemDisplayToggleIntExt,
00124         pstrUsageSystemDisplaySwapPriSec,
00125         pstrUsageSystemDisplayLCDAutoscale
00126 };
00127 const char * const ReportDescParserBase::simuTitles0[] PROGMEM = {
00128         pstrUsageFlightSimulationDevice,
00129         pstrUsageAutomobileSimulationDevice,
00130         pstrUsageTankSimulationDevice,
00131         pstrUsageSpaceshipSimulationDevice,
00132         pstrUsageSubmarineSimulationDevice,
00133         pstrUsageSailingSimulationDevice,
00134         pstrUsageMotocicleSimulationDevice,
00135         pstrUsageSportsSimulationDevice,
00136         pstrUsageAirplaneSimulationDevice,
00137         pstrUsageHelicopterSimulationDevice,
00138         pstrUsageMagicCarpetSimulationDevice,
00139         pstrUsageBicycleSimulationDevice
00140 };
00141 const char * const ReportDescParserBase::simuTitles1[] PROGMEM = {
00142         pstrUsageFlightControlStick,
00143         pstrUsageFlightStick,
00144         pstrUsageCyclicControl,
00145         pstrUsageCyclicTrim,
00146         pstrUsageFlightYoke,
00147         pstrUsageTrackControl
00148 };
00149 const char * const ReportDescParserBase::simuTitles2[] PROGMEM = {
00150         pstrUsageAileron,
00151         pstrUsageAileronTrim,
00152         pstrUsageAntiTorqueControl,
00153         pstrUsageAutopilotEnable,
00154         pstrUsageChaffRelease,
00155         pstrUsageCollectiveControl,
00156         pstrUsageDiveBrake,
00157         pstrUsageElectronicCountermeasures,
00158         pstrUsageElevator,
00159         pstrUsageElevatorTrim,
00160         pstrUsageRudder,
00161         pstrUsageThrottle,
00162         pstrUsageFlightCommunications,
00163         pstrUsageFlareRelease,
00164         pstrUsageLandingGear,
00165         pstrUsageToeBrake,
00166         pstrUsageTrigger,
00167         pstrUsageWeaponsArm,
00168         pstrUsageWeaponsSelect,
00169         pstrUsageWingFlaps,
00170         pstrUsageAccelerator,
00171         pstrUsageBrake,
00172         pstrUsageClutch,
00173         pstrUsageShifter,
00174         pstrUsageSteering,
00175         pstrUsageTurretDirection,
00176         pstrUsageBarrelElevation,
00177         pstrUsageDivePlane,
00178         pstrUsageBallast,
00179         pstrUsageBicycleCrank,
00180         pstrUsageHandleBars,
00181         pstrUsageFrontBrake,
00182         pstrUsageRearBrake
00183 };
00184 const char * const ReportDescParserBase::vrTitles0[] PROGMEM = {
00185         pstrUsageBelt,
00186         pstrUsageBodySuit,
00187         pstrUsageFlexor,
00188         pstrUsageGlove,
00189         pstrUsageHeadTracker,
00190         pstrUsageHeadMountedDisplay,
00191         pstrUsageHandTracker,
00192         pstrUsageOculometer,
00193         pstrUsageVest,
00194         pstrUsageAnimatronicDevice
00195 };
00196 const char * const ReportDescParserBase::vrTitles1[] PROGMEM = {
00197         pstrUsageStereoEnable,
00198         pstrUsageDisplayEnable
00199 };
00200 const char * const ReportDescParserBase::sportsCtrlTitles0[] PROGMEM = {
00201         pstrUsageBaseballBat,
00202         pstrUsageGolfClub,
00203         pstrUsageRowingMachine,
00204         pstrUsageTreadmill
00205 };
00206 const char * const ReportDescParserBase::sportsCtrlTitles1[] PROGMEM = {
00207         pstrUsageOar,
00208         pstrUsageSlope,
00209         pstrUsageRate,
00210         pstrUsageStickSpeed,
00211         pstrUsageStickFaceAngle,
00212         pstrUsageStickHeelToe,
00213         pstrUsageStickFollowThough,
00214         pstrUsageStickTempo,
00215         pstrUsageStickType,
00216         pstrUsageStickHeight
00217 };
00218 const char * const ReportDescParserBase::sportsCtrlTitles2[] PROGMEM = {
00219         pstrUsagePutter,
00220         pstrUsage1Iron,
00221         pstrUsage2Iron,
00222         pstrUsage3Iron,
00223         pstrUsage4Iron,
00224         pstrUsage5Iron,
00225         pstrUsage6Iron,
00226         pstrUsage7Iron,
00227         pstrUsage8Iron,
00228         pstrUsage9Iron,
00229         pstrUsage10Iron,
00230         pstrUsage11Iron,
00231         pstrUsageSandWedge,
00232         pstrUsageLoftWedge,
00233         pstrUsagePowerWedge,
00234         pstrUsage1Wood,
00235         pstrUsage3Wood,
00236         pstrUsage5Wood,
00237         pstrUsage7Wood,
00238         pstrUsage9Wood
00239 };
00240 const char * const ReportDescParserBase::gameTitles0[] PROGMEM = {
00241         pstrUsage3DGameController,
00242         pstrUsagePinballDevice,
00243         pstrUsageGunDevice
00244 };
00245 const char * const ReportDescParserBase::gameTitles1[] PROGMEM = {
00246         pstrUsagePointOfView,
00247         pstrUsageTurnRightLeft,
00248         pstrUsagePitchForwardBackward,
00249         pstrUsageRollRightLeft,
00250         pstrUsageMoveRightLeft,
00251         pstrUsageMoveForwardBackward,
00252         pstrUsageMoveUpDown,
00253         pstrUsageLeanRightLeft,
00254         pstrUsageLeanForwardBackward,
00255         pstrUsageHeightOfPOV,
00256         pstrUsageFlipper,
00257         pstrUsageSecondaryFlipper,
00258         pstrUsageBump,
00259         pstrUsageNewGame,
00260         pstrUsageShootBall,
00261         pstrUsagePlayer,
00262         pstrUsageGunBolt,
00263         pstrUsageGunClip,
00264         pstrUsageGunSelector,
00265         pstrUsageGunSingleShot,
00266         pstrUsageGunBurst,
00267         pstrUsageGunAutomatic,
00268         pstrUsageGunSafety,
00269         pstrUsageGamepadFireJump,
00270         pstrUsageGamepadTrigger
00271 };
00272 const char * const ReportDescParserBase::genDevCtrlTitles[] PROGMEM = {
00273         pstrUsageBatteryStrength,
00274         pstrUsageWirelessChannel,
00275         pstrUsageWirelessID,
00276         pstrUsageDiscoverWirelessControl,
00277         pstrUsageSecurityCodeCharEntered,
00278         pstrUsageSecurityCodeCharErased,
00279         pstrUsageSecurityCodeCleared
00280 };
00281 const char * const ReportDescParserBase::ledTitles[] PROGMEM = {
00282         pstrUsageNumLock,
00283         pstrUsageCapsLock,
00284         pstrUsageScrollLock,
00285         pstrUsageCompose,
00286         pstrUsageKana,
00287         pstrUsagePower,
00288         pstrUsageShift,
00289         pstrUsageDoNotDisturb,
00290         pstrUsageMute,
00291         pstrUsageToneEnable,
00292         pstrUsageHighCutFilter,
00293         pstrUsageLowCutFilter,
00294         pstrUsageEqualizerEnable,
00295         pstrUsageSoundFieldOn,
00296         pstrUsageSurroundOn,
00297         pstrUsageRepeat,
00298         pstrUsageStereo,
00299         pstrUsageSamplingRateDetect,
00300         pstrUsageSpinning,
00301         pstrUsageCAV,
00302         pstrUsageCLV,
00303         pstrUsageRecordingFormatDetect,
00304         pstrUsageOffHook,
00305         pstrUsageRing,
00306         pstrUsageMessageWaiting,
00307         pstrUsageDataMode,
00308         pstrUsageBatteryOperation,
00309         pstrUsageBatteryOK,
00310         pstrUsageBatteryLow,
00311         pstrUsageSpeaker,
00312         pstrUsageHeadSet,
00313         pstrUsageHold,
00314         pstrUsageMicrophone,
00315         pstrUsageCoverage,
00316         pstrUsageNightMode,
00317         pstrUsageSendCalls,
00318         pstrUsageCallPickup,
00319         pstrUsageConference,
00320         pstrUsageStandBy,
00321         pstrUsageCameraOn,
00322         pstrUsageCameraOff,
00323         pstrUsageOnLine,
00324         pstrUsageOffLine,
00325         pstrUsageBusy,
00326         pstrUsageReady,
00327         pstrUsagePaperOut,
00328         pstrUsagePaperJam,
00329         pstrUsageRemote,
00330         pstrUsageForward,
00331         pstrUsageReverse,
00332         pstrUsageStop,
00333         pstrUsageRewind,
00334         pstrUsageFastForward,
00335         pstrUsagePlay,
00336         pstrUsagePause,
00337         pstrUsageRecord,
00338         pstrUsageError,
00339         pstrUsageSelectedIndicator,
00340         pstrUsageInUseIndicator,
00341         pstrUsageMultiModeIndicator,
00342         pstrUsageIndicatorOn,
00343         pstrUsageIndicatorFlash,
00344         pstrUsageIndicatorSlowBlink,
00345         pstrUsageIndicatorFastBlink,
00346         pstrUsageIndicatorOff,
00347         pstrUsageFlashOnTime,
00348         pstrUsageSlowBlinkOnTime,
00349         pstrUsageSlowBlinkOffTime,
00350         pstrUsageFastBlinkOnTime,
00351         pstrUsageFastBlinkOffTime,
00352         pstrUsageIndicatorColor,
00353         pstrUsageIndicatorRed,
00354         pstrUsageIndicatorGreen,
00355         pstrUsageIndicatorAmber,
00356         pstrUsageGenericIndicator,
00357         pstrUsageSystemSuspend,
00358         pstrUsageExternalPowerConnected
00359 };
00360 const char * const ReportDescParserBase::telTitles0 [] PROGMEM = {
00361         pstrUsagePhone,
00362         pstrUsageAnsweringMachine,
00363         pstrUsageMessageControls,
00364         pstrUsageHandset,
00365         pstrUsageHeadset,
00366         pstrUsageTelephonyKeyPad,
00367         pstrUsageProgrammableButton
00368 };
00369 const char * const ReportDescParserBase::telTitles1 [] PROGMEM = {
00370         pstrUsageHookSwitch,
00371         pstrUsageFlash,
00372         pstrUsageFeature,
00373         pstrUsageHold,
00374         pstrUsageRedial,
00375         pstrUsageTransfer,
00376         pstrUsageDrop,
00377         pstrUsagePark,
00378         pstrUsageForwardCalls,
00379         pstrUsageAlternateFunction,
00380         pstrUsageLine,
00381         pstrUsageSpeakerPhone,
00382         pstrUsageConference,
00383         pstrUsageRingEnable,
00384         pstrUsageRingSelect,
00385         pstrUsagePhoneMute,
00386         pstrUsageCallerID,
00387         pstrUsageSend
00388 };
00389 const char * const ReportDescParserBase::telTitles2 [] PROGMEM = {
00390         pstrUsageSpeedDial,
00391         pstrUsageStoreNumber,
00392         pstrUsageRecallNumber,
00393         pstrUsagePhoneDirectory
00394 };
00395 const char * const ReportDescParserBase::telTitles3 [] PROGMEM = {
00396         pstrUsageVoiceMail,
00397         pstrUsageScreenCalls,
00398         pstrUsageDoNotDisturb,
00399         pstrUsageMessage,
00400         pstrUsageAnswerOnOff
00401 };
00402 const char * const ReportDescParserBase::telTitles4 [] PROGMEM = {
00403         pstrUsageInsideDialTone,
00404         pstrUsageOutsideDialTone,
00405         pstrUsageInsideRingTone,
00406         pstrUsageOutsideRingTone,
00407         pstrUsagePriorityRingTone,
00408         pstrUsageInsideRingback,
00409         pstrUsagePriorityRingback,
00410         pstrUsageLineBusyTone,
00411         pstrUsageReorderTone,
00412         pstrUsageCallWaitingTone,
00413         pstrUsageConfirmationTone1,
00414         pstrUsageConfirmationTone2,
00415         pstrUsageTonesOff,
00416         pstrUsageOutsideRingback,
00417         pstrUsageRinger
00418 };
00419 const char * const ReportDescParserBase::telTitles5 [] PROGMEM = {
00420         pstrUsagePhoneKey0,
00421         pstrUsagePhoneKey1,
00422         pstrUsagePhoneKey2,
00423         pstrUsagePhoneKey3,
00424         pstrUsagePhoneKey4,
00425         pstrUsagePhoneKey5,
00426         pstrUsagePhoneKey6,
00427         pstrUsagePhoneKey7,
00428         pstrUsagePhoneKey8,
00429         pstrUsagePhoneKey9,
00430         pstrUsagePhoneKeyStar,
00431         pstrUsagePhoneKeyPound,
00432         pstrUsagePhoneKeyA,
00433         pstrUsagePhoneKeyB,
00434         pstrUsagePhoneKeyC,
00435         pstrUsagePhoneKeyD
00436 };
00437 const char * const ReportDescParserBase::consTitles0[] PROGMEM = {
00438         pstrUsageConsumerControl,
00439         pstrUsageNumericKeyPad,
00440         pstrUsageProgrammableButton,
00441         pstrUsageMicrophone,
00442         pstrUsageHeadphone,
00443         pstrUsageGraphicEqualizer
00444 };
00445 const char * const ReportDescParserBase::consTitles1[] PROGMEM = {
00446         pstrUsagePlus10,
00447         pstrUsagePlus100,
00448         pstrUsageAMPM
00449 };
00450 const char * const ReportDescParserBase::consTitles2[] PROGMEM = {
00451         pstrUsagePower,
00452         pstrUsageReset,
00453         pstrUsageSleep,
00454         pstrUsageSleepAfter,
00455         pstrUsageSleepMode,
00456         pstrUsageIllumination,
00457         pstrUsageFunctionButtons
00458 
00459 };
00460 const char * const ReportDescParserBase::consTitles3[] PROGMEM = {
00461         pstrUsageMenu,
00462         pstrUsageMenuPick,
00463         pstrUsageMenuUp,
00464         pstrUsageMenuDown,
00465         pstrUsageMenuLeft,
00466         pstrUsageMenuRight,
00467         pstrUsageMenuEscape,
00468         pstrUsageMenuValueIncrease,
00469         pstrUsageMenuValueDecrease
00470 };
00471 const char * const ReportDescParserBase::consTitles4[] PROGMEM = {
00472         pstrUsageDataOnScreen,
00473         pstrUsageClosedCaption,
00474         pstrUsageClosedCaptionSelect,
00475         pstrUsageVCRTV,
00476         pstrUsageBroadcastMode,
00477         pstrUsageSnapshot,
00478         pstrUsageStill
00479 };
00480 const char * const ReportDescParserBase::consTitles5[] PROGMEM = {
00481         pstrUsageSelection,
00482         pstrUsageAssignSelection,
00483         pstrUsageModeStep,
00484         pstrUsageRecallLast,
00485         pstrUsageEnterChannel,
00486         pstrUsageOrderMovie,
00487         pstrUsageChannel,
00488         pstrUsageMediaSelection,
00489         pstrUsageMediaSelectComputer,
00490         pstrUsageMediaSelectTV,
00491         pstrUsageMediaSelectWWW,
00492         pstrUsageMediaSelectDVD,
00493         pstrUsageMediaSelectTelephone,
00494         pstrUsageMediaSelectProgramGuide,
00495         pstrUsageMediaSelectVideoPhone,
00496         pstrUsageMediaSelectGames,
00497         pstrUsageMediaSelectMessages,
00498         pstrUsageMediaSelectCD,
00499         pstrUsageMediaSelectVCR,
00500         pstrUsageMediaSelectTuner,
00501         pstrUsageQuit,
00502         pstrUsageHelp,
00503         pstrUsageMediaSelectTape,
00504         pstrUsageMediaSelectCable,
00505         pstrUsageMediaSelectSatellite,
00506         pstrUsageMediaSelectSecurity,
00507         pstrUsageMediaSelectHome,
00508         pstrUsageMediaSelectCall,
00509         pstrUsageChannelIncrement,
00510         pstrUsageChannelDecrement,
00511         pstrUsageMediaSelectSAP,
00512         pstrUsagePageReserved,
00513         pstrUsageVCRPlus,
00514         pstrUsageOnce,
00515         pstrUsageDaily,
00516         pstrUsageWeekly,
00517         pstrUsageMonthly
00518 };
00519 const char * const ReportDescParserBase::consTitles6[] PROGMEM = {
00520         pstrUsagePlay,
00521         pstrUsagePause,
00522         pstrUsageRecord,
00523         pstrUsageFastForward,
00524         pstrUsageRewind,
00525         pstrUsageScanNextTrack,
00526         pstrUsageScanPreviousTrack,
00527         pstrUsageStop,
00528         pstrUsageEject,
00529         pstrUsageRandomPlay,
00530         pstrUsageSelectDisk,
00531         pstrUsageEnterDisk,
00532         pstrUsageRepeat,
00533         pstrUsageTracking,
00534         pstrUsageTrackNormal,
00535         pstrUsageSlowTracking,
00536         pstrUsageFrameForward,
00537         pstrUsageFrameBackwards,
00538         pstrUsageMark,
00539         pstrUsageClearMark,
00540         pstrUsageRepeatFromMark,
00541         pstrUsageReturnToMark,
00542         pstrUsageSearchMarkForward,
00543         pstrUsageSearchMarkBackwards,
00544         pstrUsageCounterReset,
00545         pstrUsageShowCounter,
00546         pstrUsageTrackingIncrement,
00547         pstrUsageTrackingDecrement,
00548         pstrUsageStopEject,
00549         pstrUsagePlayPause,
00550         pstrUsagePlaySkip
00551 };
00552 const char * const ReportDescParserBase::consTitles7[] PROGMEM = {
00553         pstrUsageVolume,
00554         pstrUsageBalance,
00555         pstrUsageMute,
00556         pstrUsageBass,
00557         pstrUsageTreble,
00558         pstrUsageBassBoost,
00559         pstrUsageSurroundMode,
00560         pstrUsageLoudness,
00561         pstrUsageMPX,
00562         pstrUsageVolumeIncrement,
00563         pstrUsageVolumeDecrement
00564 };
00565 const char * const ReportDescParserBase::consTitles8[] PROGMEM = {
00566         pstrUsageSpeedSelect,
00567         pstrUsagePlaybackSpeed,
00568         pstrUsageStandardPlay,
00569         pstrUsageLongPlay,
00570         pstrUsageExtendedPlay,
00571         pstrUsageSlow
00572 };
00573 const char * const ReportDescParserBase::consTitles9[] PROGMEM = {
00574         pstrUsageFanEnable,
00575         pstrUsageFanSpeed,
00576         pstrUsageLightEnable,
00577         pstrUsageLightIlluminationLevel,
00578         pstrUsageClimateControlEnable,
00579         pstrUsageRoomTemperature,
00580         pstrUsageSecurityEnable,
00581         pstrUsageFireAlarm,
00582         pstrUsagePoliceAlarm,
00583         pstrUsageProximity,
00584         pstrUsageMotion,
00585         pstrUsageDuresAlarm,
00586         pstrUsageHoldupAlarm,
00587         pstrUsageMedicalAlarm
00588 };
00589 const char * const ReportDescParserBase::consTitlesA[] PROGMEM = {
00590         pstrUsageBalanceRight,
00591         pstrUsageBalanceLeft,
00592         pstrUsageBassIncrement,
00593         pstrUsageBassDecrement,
00594         pstrUsageTrebleIncrement,
00595         pstrUsageTrebleDecrement
00596 };
00597 const char * const ReportDescParserBase::consTitlesB[] PROGMEM = {
00598         pstrUsageSpeakerSystem,
00599         pstrUsageChannelLeft,
00600         pstrUsageChannelRight,
00601         pstrUsageChannelCenter,
00602         pstrUsageChannelFront,
00603         pstrUsageChannelCenterFront,
00604         pstrUsageChannelSide,
00605         pstrUsageChannelSurround,
00606         pstrUsageChannelLowFreqEnhancement,
00607         pstrUsageChannelTop,
00608         pstrUsageChannelUnknown
00609 };
00610 const char * const ReportDescParserBase::consTitlesC[] PROGMEM = {
00611         pstrUsageSubChannel,
00612         pstrUsageSubChannelIncrement,
00613         pstrUsageSubChannelDecrement,
00614         pstrUsageAlternateAudioIncrement,
00615         pstrUsageAlternateAudioDecrement
00616 };
00617 const char * const ReportDescParserBase::consTitlesD[] PROGMEM = {
00618         pstrUsageApplicationLaunchButtons,
00619         pstrUsageALLaunchButtonConfigTool,
00620         pstrUsageALProgrammableButton,
00621         pstrUsageALConsumerControlConfig,
00622         pstrUsageALWordProcessor,
00623         pstrUsageALTextEditor,
00624         pstrUsageALSpreadsheet,
00625         pstrUsageALGraphicsEditor,
00626         pstrUsageALPresentationApp,
00627         pstrUsageALDatabaseApp,
00628         pstrUsageALEmailReader,
00629         pstrUsageALNewsreader,
00630         pstrUsageALVoicemail,
00631         pstrUsageALContactsAddressBook,
00632         pstrUsageALCalendarSchedule,
00633         pstrUsageALTaskProjectManager,
00634         pstrUsageALLogJournalTimecard,
00635         pstrUsageALCheckbookFinance,
00636         pstrUsageALCalculator,
00637         pstrUsageALAVCapturePlayback,
00638         pstrUsageALLocalMachineBrowser,
00639         pstrUsageALLANWANBrow,
00640         pstrUsageALInternetBrowser,
00641         pstrUsageALRemoteNetISPConnect,
00642         pstrUsageALNetworkConference,
00643         pstrUsageALNetworkChat,
00644         pstrUsageALTelephonyDialer,
00645         pstrUsageALLogon,
00646         pstrUsageALLogoff,
00647         pstrUsageALLogonLogoff,
00648         pstrUsageALTermLockScrSav,
00649         pstrUsageALControlPannel,
00650         pstrUsageALCommandLineProcessorRun,
00651         pstrUsageALProcessTaskManager,
00652         pstrUsageALSelectTaskApplication,
00653         pstrUsageALNextTaskApplication,
00654         pstrUsageALPreviousTaskApplication,
00655         pstrUsageALPreemptiveHaltTaskApp,
00656         pstrUsageALIntegratedHelpCenter,
00657         pstrUsageALDocuments,
00658         pstrUsageALThesaurus,
00659         pstrUsageALDictionary,
00660         pstrUsageALDesktop,
00661         pstrUsageALSpellCheck,
00662         pstrUsageALGrammarCheck,
00663         pstrUsageALWirelessStatus,
00664         pstrUsageALKeyboardLayout,
00665         pstrUsageALVirusProtection,
00666         pstrUsageALEncryption,
00667         pstrUsageALScreenSaver,
00668         pstrUsageALAlarms,
00669         pstrUsageALClock,
00670         pstrUsageALFileBrowser,
00671         pstrUsageALPowerStatus,
00672         pstrUsageALImageBrowser,
00673         pstrUsageALAudioBrowser,
00674         pstrUsageALMovieBrowser,
00675         pstrUsageALDigitalRightsManager,
00676         pstrUsageALDigitalWallet,
00677         pstrUsagePageReserved,
00678         pstrUsageALInstantMessaging,
00679         pstrUsageALOEMFeaturesBrowser,
00680         pstrUsageALOEMHelp,
00681         pstrUsageALOnlineCommunity,
00682         pstrUsageALEntertainmentContentBrow,
00683         pstrUsageALOnlineShoppingBrowser,
00684         pstrUsageALSmartCardInfoHelp,
00685         pstrUsageALMarketMonitorFinBrowser,
00686         pstrUsageALCustomCorpNewsBrowser,
00687         pstrUsageALOnlineActivityBrowser,
00688         pstrUsageALResearchSearchBrowser,
00689         pstrUsageALAudioPlayer
00690 };
00691 const char * const ReportDescParserBase::consTitlesE[] PROGMEM = {
00692         pstrUsageGenericGUIAppControls,
00693         pstrUsageACNew,
00694         pstrUsageACOpen,
00695         pstrUsageACClose,
00696         pstrUsageACExit,
00697         pstrUsageACMaximize,
00698         pstrUsageACMinimize,
00699         pstrUsageACSave,
00700         pstrUsageACPrint,
00701         pstrUsageACProperties,
00702         pstrUsageACUndo,
00703         pstrUsageACCopy,
00704         pstrUsageACCut,
00705         pstrUsageACPaste,
00706         pstrUsageACSelectAll,
00707         pstrUsageACFind,
00708         pstrUsageACFindAndReplace,
00709         pstrUsageACSearch,
00710         pstrUsageACGoto,
00711         pstrUsageACHome,
00712         pstrUsageACBack,
00713         pstrUsageACForward,
00714         pstrUsageACStop,
00715         pstrUsageACRefresh,
00716         pstrUsageACPreviousLink,
00717         pstrUsageACNextLink,
00718         pstrUsageACBookmarks,
00719         pstrUsageACHistory,
00720         pstrUsageACSubscriptions,
00721         pstrUsageACZoomIn,
00722         pstrUsageACZoomOut,
00723         pstrUsageACZoom,
00724         pstrUsageACFullScreenView,
00725         pstrUsageACNormalView,
00726         pstrUsageACViewToggle,
00727         pstrUsageACScrollUp,
00728         pstrUsageACScrollDown,
00729         pstrUsageACScroll,
00730         pstrUsageACPanLeft,
00731         pstrUsageACPanRight,
00732         pstrUsageACPan,
00733         pstrUsageACNewWindow,
00734         pstrUsageACTileHoriz,
00735         pstrUsageACTileVert,
00736         pstrUsageACFormat,
00737         pstrUsageACEdit,
00738         pstrUsageACBold,
00739         pstrUsageACItalics,
00740         pstrUsageACUnderline,
00741         pstrUsageACStrikethrough,
00742         pstrUsageACSubscript,
00743         pstrUsageACSuperscript,
00744         pstrUsageACAllCaps,
00745         pstrUsageACRotate,
00746         pstrUsageACResize,
00747         pstrUsageACFlipHorizontal,
00748         pstrUsageACFlipVertical,
00749         pstrUsageACMirrorHorizontal,
00750         pstrUsageACMirrorVertical,
00751         pstrUsageACFontSelect,
00752         pstrUsageACFontColor,
00753         pstrUsageACFontSize,
00754         pstrUsageACJustifyLeft,
00755         pstrUsageACJustifyCenterH,
00756         pstrUsageACJustifyRight,
00757         pstrUsageACJustifyBlockH,
00758         pstrUsageACJustifyTop,
00759         pstrUsageACJustifyCenterV,
00760         pstrUsageACJustifyBottom,
00761         pstrUsageACJustifyBlockV,
00762         pstrUsageACIndentDecrease,
00763         pstrUsageACIndentIncrease,
00764         pstrUsageACNumberedList,
00765         pstrUsageACRestartNumbering,
00766         pstrUsageACBulletedList,
00767         pstrUsageACPromote,
00768         pstrUsageACDemote,
00769         pstrUsageACYes,
00770         pstrUsageACNo,
00771         pstrUsageACCancel,
00772         pstrUsageACCatalog,
00773         pstrUsageACBuyChkout,
00774         pstrUsageACAddToCart,
00775         pstrUsageACExpand,
00776         pstrUsageACExpandAll,
00777         pstrUsageACCollapse,
00778         pstrUsageACCollapseAll,
00779         pstrUsageACPrintPreview,
00780         pstrUsageACPasteSpecial,
00781         pstrUsageACInsertMode,
00782         pstrUsageACDelete,
00783         pstrUsageACLock,
00784         pstrUsageACUnlock,
00785         pstrUsageACProtect,
00786         pstrUsageACUnprotect,
00787         pstrUsageACAttachComment,
00788         pstrUsageACDeleteComment,
00789         pstrUsageACViewComment,
00790         pstrUsageACSelectWord,
00791         pstrUsageACSelectSentence,
00792         pstrUsageACSelectParagraph,
00793         pstrUsageACSelectColumn,
00794         pstrUsageACSelectRow,
00795         pstrUsageACSelectTable,
00796         pstrUsageACSelectObject,
00797         pstrUsageACRedoRepeat,
00798         pstrUsageACSort,
00799         pstrUsageACSortAscending,
00800         pstrUsageACSortDescending,
00801         pstrUsageACFilter,
00802         pstrUsageACSetClock,
00803         pstrUsageACViewClock,
00804         pstrUsageACSelectTimeZone,
00805         pstrUsageACEditTimeZone,
00806         pstrUsageACSetAlarm,
00807         pstrUsageACClearAlarm,
00808         pstrUsageACSnoozeAlarm,
00809         pstrUsageACResetAlarm,
00810         pstrUsageACSyncronize,
00811         pstrUsageACSendReceive,
00812         pstrUsageACSendTo,
00813         pstrUsageACReply,
00814         pstrUsageACReplyAll,
00815         pstrUsageACForwardMessage,
00816         pstrUsageACSend,
00817         pstrUsageACAttachFile,
00818         pstrUsageACUpload,
00819         pstrUsageACDownload,
00820         pstrUsageACSetBorders,
00821         pstrUsageACInsertRow,
00822         pstrUsageACInsertColumn,
00823         pstrUsageACInsertFile,
00824         pstrUsageACInsertPicture,
00825         pstrUsageACInsertObject,
00826         pstrUsageACInsertSymbol,
00827         pstrUsageACSaveAndClose,
00828         pstrUsageACRename,
00829         pstrUsageACMerge,
00830         pstrUsageACSplit,
00831         pstrUsageACDistributeHorizontaly,
00832         pstrUsageACDistributeVerticaly
00833 };
00834 const char * const ReportDescParserBase::digitTitles0[] PROGMEM = {
00835         pstrUsageDigitizer,
00836         pstrUsagePen,
00837         pstrUsageLightPen,
00838         pstrUsageTouchScreen,
00839         pstrUsageTouchPad,
00840         pstrUsageWhiteBoard,
00841         pstrUsageCoordinateMeasuringMachine,
00842         pstrUsage3DDigitizer,
00843         pstrUsageStereoPlotter,
00844         pstrUsageArticulatedArm,
00845         pstrUsageArmature,
00846         pstrUsageMultiplePointDigitizer,
00847         pstrUsageFreeSpaceWand
00848 };
00849 const char * const ReportDescParserBase::digitTitles1[] PROGMEM = {
00850         pstrUsageStylus,
00851         pstrUsagePuck,
00852         pstrUsageFinger
00853 
00854 };
00855 const char * const ReportDescParserBase::digitTitles2[] PROGMEM = {
00856         pstrUsageTipPressure,
00857         pstrUsageBarrelPressure,
00858         pstrUsageInRange,
00859         pstrUsageTouch,
00860         pstrUsageUntouch,
00861         pstrUsageTap,
00862         pstrUsageQuality,
00863         pstrUsageDataValid,
00864         pstrUsageTransducerIndex,
00865         pstrUsageTabletFunctionKeys,
00866         pstrUsageProgramChangeKeys,
00867         pstrUsageBatteryStrength,
00868         pstrUsageInvert,
00869         pstrUsageXTilt,
00870         pstrUsageYTilt,
00871         pstrUsageAzimuth,
00872         pstrUsageAltitude,
00873         pstrUsageTwist,
00874         pstrUsageTipSwitch,
00875         pstrUsageSecondaryTipSwitch,
00876         pstrUsageBarrelSwitch,
00877         pstrUsageEraser,
00878         pstrUsageTabletPick
00879 };
00880 const char * const ReportDescParserBase::aplphanumTitles0[] PROGMEM = {
00881         pstrUsageAlphanumericDisplay,
00882         pstrUsageBitmappedDisplay
00883 };
00884 const char * const ReportDescParserBase::aplphanumTitles1[] PROGMEM = {
00885         pstrUsageDisplayAttributesReport,
00886         pstrUsageASCIICharacterSet,
00887         pstrUsageDataReadBack,
00888         pstrUsageFontReadBack,
00889         pstrUsageDisplayControlReport,
00890         pstrUsageClearDisplay,
00891         pstrUsageDisplayEnable,
00892         pstrUsageScreenSaverDelay,
00893         pstrUsageScreenSaverEnable,
00894         pstrUsageVerticalScroll,
00895         pstrUsageHorizontalScroll,
00896         pstrUsageCharacterReport,
00897         pstrUsageDisplayData,
00898         pstrUsageDisplayStatus,
00899         pstrUsageStatusNotReady,
00900         pstrUsageStatusReady,
00901         pstrUsageErrorNotALoadableCharacter,
00902         pstrUsageErrorFotDataCanNotBeRead,
00903         pstrUsageCursorPositionReport,
00904         pstrUsageRow,
00905         pstrUsageColumn,
00906         pstrUsageRows,
00907         pstrUsageColumns,
00908         pstrUsageCursorPixelPosition,
00909         pstrUsageCursorMode,
00910         pstrUsageCursorEnable,
00911         pstrUsageCursorBlink,
00912         pstrUsageFontReport,
00913         pstrUsageFontData,
00914         pstrUsageCharacterWidth,
00915         pstrUsageCharacterHeight,
00916         pstrUsageCharacterSpacingHorizontal,
00917         pstrUsageCharacterSpacingVertical,
00918         pstrUsageUnicodeCharset,
00919         pstrUsageFont7Segment,
00920         pstrUsage7SegmentDirectMap,
00921         pstrUsageFont14Segment,
00922         pstrUsage14SegmentDirectMap,
00923         pstrUsageDisplayBrightness,
00924         pstrUsageDisplayContrast,
00925         pstrUsageCharacterAttribute,
00926         pstrUsageAttributeReadback,
00927         pstrUsageAttributeData,
00928         pstrUsageCharAttributeEnhance,
00929         pstrUsageCharAttributeUnderline,
00930         pstrUsageCharAttributeBlink
00931 };
00932 const char * const ReportDescParserBase::aplphanumTitles2[] PROGMEM = {
00933         pstrUsageBitmapSizeX,
00934         pstrUsageBitmapSizeY,
00935         pstrUsagePageReserved,
00936         pstrUsageBitDepthFormat,
00937         pstrUsageDisplayOrientation,
00938         pstrUsagePaletteReport,
00939         pstrUsagePaletteDataSize,
00940         pstrUsagePaletteDataOffset,
00941         pstrUsagePaletteData,
00942         pstrUsageBlitReport,
00943         pstrUsageBlitRectangleX1,
00944         pstrUsageBlitRectangleY1,
00945         pstrUsageBlitRectangleX2,
00946         pstrUsageBlitRectangleY2,
00947         pstrUsageBlitData,
00948         pstrUsageSoftButton,
00949         pstrUsageSoftButtonID,
00950         pstrUsageSoftButtonSide,
00951         pstrUsageSoftButtonOffset1,
00952         pstrUsageSoftButtonOffset2,
00953         pstrUsageSoftButtonReport
00954 };
00955 const char * const ReportDescParserBase::medInstrTitles0[] PROGMEM = {
00956         pstrUsageVCRAcquisition,
00957         pstrUsageFreezeThaw,
00958         pstrUsageClipStore,
00959         pstrUsageUpdate,
00960         pstrUsageNext,
00961         pstrUsageSave,
00962         pstrUsagePrint,
00963         pstrUsageMicrophoneEnable
00964 };
00965 const char * const ReportDescParserBase::medInstrTitles1[] PROGMEM = {
00966         pstrUsageCine,
00967         pstrUsageTransmitPower,
00968         pstrUsageVolume,
00969         pstrUsageFocus,
00970         pstrUsageDepth
00971 };
00972 const char * const ReportDescParserBase::medInstrTitles2[] PROGMEM = {
00973         pstrUsageSoftStepPrimary,
00974         pstrUsageSoftStepSecondary
00975 };
00976 const char * const ReportDescParserBase::medInstrTitles3[] PROGMEM = {
00977         pstrUsageZoomSelect,
00978         pstrUsageZoomAdjust,
00979         pstrUsageSpectralDopplerModeSelect,
00980         pstrUsageSpectralDopplerModeAdjust,
00981         pstrUsageColorDopplerModeSelect,
00982         pstrUsageColorDopplerModeAdjust,
00983         pstrUsageMotionModeSelect,
00984         pstrUsageMotionModeAdjust,
00985         pstrUsage2DModeSelect,
00986         pstrUsage2DModeAdjust
00987 };
00988 const char * const ReportDescParserBase::medInstrTitles4[] PROGMEM = {
00989         pstrUsageSoftControlSelect,
00990         pstrUsageSoftControlAdjust
00991 };
00992 
00993 void ReportDescParserBase::Parse(const uint16_t len, const uint8_t *pbuf, const uint16_t &offset __attribute__((unused))) {
00994         uint16_t cntdn = (uint16_t)len;
00995         uint8_t *p = (uint8_t*)pbuf;
00996 
00997 
00998         totalSize = 0;
00999 
01000         while(cntdn) {
01001                 //USB_HOST_SERIAL.println("");
01002                 //PrintHex<uint16_t>(offset + len - cntdn);
01003                 //USB_HOST_SERIAL.print(":");
01004 
01005                 ParseItem(&p, &cntdn);
01006 
01007                 //if (ParseItem(&p, &cntdn))
01008                 //        return;
01009         }
01010         //USBTRACE2("Total:", totalSize);
01011 }
01012 
01013 void ReportDescParserBase::PrintValue(uint8_t *p, uint8_t len) {
01014         E_Notify(PSTR("("), 0x80);
01015         for(; len; p++, len--)
01016                 PrintHex<uint8_t > (*p, 0x80);
01017         E_Notify(PSTR(")"), 0x80);
01018 }
01019 
01020 void ReportDescParserBase::PrintByteValue(uint8_t data) {
01021         E_Notify(PSTR("("), 0x80);
01022         PrintHex<uint8_t > (data, 0x80);
01023         E_Notify(PSTR(")"), 0x80);
01024 }
01025 
01026 void ReportDescParserBase::PrintItemTitle(uint8_t prefix) {
01027         switch(prefix & (TYPE_MASK | TAG_MASK)) {
01028                 case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
01029                         E_Notify(PSTR("\r\nPush"), 0x80);
01030                         break;
01031                 case (TYPE_GLOBAL | TAG_GLOBAL_POP):
01032                         E_Notify(PSTR("\r\nPop"), 0x80);
01033                         break;
01034                 case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
01035                         E_Notify(PSTR("\r\nUsage Page"), 0x80);
01036                         break;
01037                 case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN):
01038                         E_Notify(PSTR("\r\nLogical Min"), 0x80);
01039                         break;
01040                 case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX):
01041                         E_Notify(PSTR("\r\nLogical Max"), 0x80);
01042                         break;
01043                 case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN):
01044                         E_Notify(PSTR("\r\nPhysical Min"), 0x80);
01045                         break;
01046                 case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX):
01047                         E_Notify(PSTR("\r\nPhysical Max"), 0x80);
01048                         break;
01049                 case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP):
01050                         E_Notify(PSTR("\r\nUnit Exp"), 0x80);
01051                         break;
01052                 case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
01053                         E_Notify(PSTR("\r\nUnit"), 0x80);
01054                         break;
01055                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
01056                         E_Notify(PSTR("\r\nReport Size"), 0x80);
01057                         break;
01058                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
01059                         E_Notify(PSTR("\r\nReport Count"), 0x80);
01060                         break;
01061                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
01062                         E_Notify(PSTR("\r\nReport Id"), 0x80);
01063                         break;
01064                 case (TYPE_LOCAL | TAG_LOCAL_USAGE):
01065                         E_Notify(PSTR("\r\nUsage"), 0x80);
01066                         break;
01067                 case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
01068                         E_Notify(PSTR("\r\nUsage Min"), 0x80);
01069                         break;
01070                 case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
01071                         E_Notify(PSTR("\r\nUsage Max"), 0x80);
01072                         break;
01073                 case (TYPE_MAIN | TAG_MAIN_COLLECTION):
01074                         E_Notify(PSTR("\r\nCollection"), 0x80);
01075                         break;
01076                 case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
01077                         E_Notify(PSTR("\r\nEnd Collection"), 0x80);
01078                         break;
01079                 case (TYPE_MAIN | TAG_MAIN_INPUT):
01080                         E_Notify(PSTR("\r\nInput"), 0x80);
01081                         break;
01082                 case (TYPE_MAIN | TAG_MAIN_OUTPUT):
01083                         E_Notify(PSTR("\r\nOutput"), 0x80);
01084                         break;
01085                 case (TYPE_MAIN | TAG_MAIN_FEATURE):
01086                         E_Notify(PSTR("\r\nFeature"), 0x80);
01087                         break;
01088         } // switch (**pp & (TYPE_MASK | TAG_MASK))
01089 }
01090 
01091 uint8_t ReportDescParserBase::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
01092         //uint8_t ret = enErrorSuccess;
01093         //reinterpret_cast<>(varBuffer);
01094         switch(itemParseState) {
01095                 case 0:
01096                         if(**pp == HID_LONG_ITEM_PREFIX)
01097                                 USBTRACE("\r\nLONG\r\n");
01098                         else {
01099                                 uint8_t size = ((**pp) & DATA_SIZE_MASK);
01100 
01101                                 itemPrefix = (**pp);
01102                                 itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
01103 
01104                                 PrintItemTitle(itemPrefix);
01105                         }
01106                         (*pp)++;
01107                         (*pcntdn)--;
01108                         itemSize--;
01109                         itemParseState = 1;
01110 
01111                         if(!itemSize)
01112                                 break;
01113 
01114                         if(!pcntdn)
01115                                 return enErrorIncomplete;
01116                 case 1:
01117                         //USBTRACE2("\r\niSz:",itemSize);
01118 
01119                         theBuffer.valueSize = itemSize;
01120                         valParser.Initialize(&theBuffer);
01121                         itemParseState = 2;
01122                 case 2:
01123                         if(!valParser.Parse(pp, pcntdn))
01124                                 return enErrorIncomplete;
01125                         itemParseState = 3;
01126                 case 3:
01127                 {
01128                         uint8_t data = *((uint8_t*)varBuffer);
01129 
01130                         switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
01131                                 case (TYPE_LOCAL | TAG_LOCAL_USAGE):
01132                                         if(pfUsage) {
01133                                                 if(theBuffer.valueSize > 1) {
01134                                                         uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
01135                                                         pfUsage(*ui16);
01136                                                 } else
01137                                                         pfUsage(data);
01138                                         }
01139                                         break;
01140                                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
01141                                         rptSize = data;
01142                                         PrintByteValue(data);
01143                                         break;
01144                                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
01145                                         rptCount = data;
01146                                         PrintByteValue(data);
01147                                         break;
01148                                 case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN):
01149                                 case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX):
01150                                 case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN):
01151                                 case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX):
01152                                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
01153                                 case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
01154                                 case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
01155                                 case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP):
01156                                 case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
01157                                         PrintValue(varBuffer, theBuffer.valueSize);
01158                                         break;
01159                                 case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
01160                                 case (TYPE_GLOBAL | TAG_GLOBAL_POP):
01161                                         break;
01162                                 case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
01163                                         SetUsagePage(data);
01164                                         PrintUsagePage(data);
01165                                         PrintByteValue(data);
01166                                         break;
01167                                 case (TYPE_MAIN | TAG_MAIN_COLLECTION):
01168                                 case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
01169                                         switch(data) {
01170                                                 case 0x00:
01171                                                         E_Notify(PSTR(" Physical"), 0x80);
01172                                                         break;
01173                                                 case 0x01:
01174                                                         E_Notify(PSTR(" Application"), 0x80);
01175                                                         break;
01176                                                 case 0x02:
01177                                                         E_Notify(PSTR(" Logical"), 0x80);
01178                                                         break;
01179                                                 case 0x03:
01180                                                         E_Notify(PSTR(" Report"), 0x80);
01181                                                         break;
01182                                                 case 0x04:
01183                                                         E_Notify(PSTR(" Named Array"), 0x80);
01184                                                         break;
01185                                                 case 0x05:
01186                                                         E_Notify(PSTR(" Usage Switch"), 0x80);
01187                                                         break;
01188                                                 case 0x06:
01189                                                         E_Notify(PSTR(" Usage Modifier"), 0x80);
01190                                                         break;
01191                                                 default:
01192                                                         E_Notify(PSTR(" Vendor Defined("), 0x80);
01193                                                         PrintHex<uint8_t > (data, 0x80);
01194                                                         E_Notify(PSTR(")"), 0x80);
01195                                         }
01196                                         break;
01197                                 case (TYPE_MAIN | TAG_MAIN_INPUT):
01198                                 case (TYPE_MAIN | TAG_MAIN_OUTPUT):
01199                                 case (TYPE_MAIN | TAG_MAIN_FEATURE):
01200                                         totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
01201                                         rptSize = 0;
01202                                         rptCount = 0;
01203                                         E_Notify(PSTR("("), 0x80);
01204                                         PrintBin<uint8_t > (data, 0x80);
01205                                         E_Notify(PSTR(")"), 0x80);
01206                                         break;
01207                         } // switch (**pp & (TYPE_MASK | TAG_MASK))
01208                 }
01209         } // switch (itemParseState)
01210         itemParseState = 0;
01211         return enErrorSuccess;
01212 }
01213 
01214 ReportDescParserBase::UsagePageFunc ReportDescParserBase::usagePageFunctions[] /*PROGMEM*/ = {
01215         &ReportDescParserBase::PrintGenericDesktopPageUsage,
01216         &ReportDescParserBase::PrintSimulationControlsPageUsage,
01217         &ReportDescParserBase::PrintVRControlsPageUsage,
01218         &ReportDescParserBase::PrintSportsControlsPageUsage,
01219         &ReportDescParserBase::PrintGameControlsPageUsage,
01220         &ReportDescParserBase::PrintGenericDeviceControlsPageUsage,
01221         NULL, // Keyboard/Keypad
01222         &ReportDescParserBase::PrintLEDPageUsage,
01223         &ReportDescParserBase::PrintButtonPageUsage,
01224         &ReportDescParserBase::PrintOrdinalPageUsage,
01225         &ReportDescParserBase::PrintTelephonyPageUsage,
01226         &ReportDescParserBase::PrintConsumerPageUsage,
01227         &ReportDescParserBase::PrintDigitizerPageUsage,
01228         NULL, // Reserved
01229         NULL, // PID
01230         NULL // Unicode
01231 };
01232 
01233 void ReportDescParserBase::SetUsagePage(uint16_t page) {
01234         pfUsage = NULL;
01235 
01236         if(VALUE_BETWEEN(page, 0x00, 0x11)) {
01237                 pfUsage = (usagePageFunctions[page - 1]);
01238 
01239         } else {
01240                 switch(page) {
01241                         case 0x14:
01242                                 pfUsage = &ReportDescParserBase::PrintAlphanumDisplayPageUsage;
01243                                 break;
01244                         case 0x40:
01245                                 pfUsage = &ReportDescParserBase::PrintMedicalInstrumentPageUsage;
01246                                 break;
01247                 }
01248         }
01249 }
01250 
01251 void ReportDescParserBase::PrintUsagePage(uint16_t page) {
01252         const char * const * w;
01253         E_Notify(pstrSpace, 0x80);
01254 
01255         output_if_between(page, 0x00, 0x11, w, E_Notify, usagePageTitles0, 0x80)
01256         else output_if_between(page, 0x8b, 0x92, w, E_Notify, usagePageTitles1, 0x80)
01257         else if(VALUE_BETWEEN(page, 0x7f, 0x84))
01258                 E_Notify(pstrUsagePageMonitor, 0x80);
01259         else if(VALUE_BETWEEN(page, 0x83, 0x8c))
01260                 E_Notify(pstrUsagePagePower, 0x80);
01261         else if(page > 0xfeff /* && page <= 0xffff */)
01262                 E_Notify(pstrUsagePageVendorDefined, 0x80);
01263         else
01264                 switch(page) {
01265                         case 0x14:
01266                                 E_Notify(pstrUsagePageAlphaNumericDisplay, 0x80);
01267                                 break;
01268                         case 0x40:
01269                                 E_Notify(pstrUsagePageMedicalInstruments, 0x80);
01270                                 break;
01271                         default:
01272                                 E_Notify(pstrUsagePageUndefined, 0x80);
01273                 }
01274 }
01275 
01276 void ReportDescParserBase::PrintButtonPageUsage(uint16_t usage) {
01277         E_Notify(pstrSpace, 0x80);
01278         E_Notify(PSTR("Btn"), 0x80);
01279         PrintHex<uint16_t > (usage, 0x80);
01280         E_Notify(PSTR("\r\n"), 0x80);
01281         //USB_HOST_SERIAL.print(usage, HEX);
01282 }
01283 
01284 void ReportDescParserBase::PrintOrdinalPageUsage(uint16_t usage) {
01285         E_Notify(pstrSpace, 0x80);
01286         E_Notify(PSTR("Inst"), 0x80);
01287         // Sorry, HEX for now...
01288         PrintHex<uint16_t > (usage, 0x80);
01289         E_Notify(PSTR("\r\n"), 0x80);
01290         //USB_HOST_SERIAL.print(usage, DEC);
01291 }
01292 
01293 void ReportDescParserBase::PrintGenericDesktopPageUsage(uint16_t usage) {
01294         const char * const * w;
01295         E_Notify(pstrSpace, 0x80);
01296 
01297         output_if_between(usage, 0x00, 0x0a, w, E_Notify, genDesktopTitles0, 0x80)
01298         else output_if_between(usage, 0x2f, 0x49, w, E_Notify, genDesktopTitles1, 0x80)
01299         else output_if_between(usage, 0x7f, 0x94, w, E_Notify, genDesktopTitles2, 0x80)
01300         else output_if_between(usage, 0x9f, 0xa9, w, E_Notify, genDesktopTitles3, 0x80)
01301         else output_if_between(usage, 0xaf, 0xb8, w, E_Notify, genDesktopTitles4, 0x80)
01302         else E_Notify(pstrUsagePageUndefined, 0x80);
01303 }
01304 
01305 void ReportDescParserBase::PrintSimulationControlsPageUsage(uint16_t usage) {
01306         const char * const * w;
01307         E_Notify(pstrSpace, 0x80);
01308 
01309         output_if_between(usage, 0x00, 0x0d, w, E_Notify, simuTitles0, 0x80)
01310         else output_if_between(usage, 0x1f, 0x26, w, E_Notify, simuTitles1, 0x80)
01311         else output_if_between(usage, 0xaf, 0xd1, w, E_Notify, simuTitles2, 0x80)
01312         else E_Notify(pstrUsagePageUndefined, 0x80);
01313 }
01314 
01315 void ReportDescParserBase::PrintVRControlsPageUsage(uint16_t usage) {
01316         const char * const * w;
01317         E_Notify(pstrSpace, 0x80);
01318 
01319         output_if_between(usage, 0x00, 0x0b, w, E_Notify, vrTitles0, 0x80)
01320         else output_if_between(usage, 0x1f, 0x22, w, E_Notify, vrTitles1, 0x80)
01321         else E_Notify(pstrUsagePageUndefined, 0x80);
01322 }
01323 
01324 void ReportDescParserBase::PrintSportsControlsPageUsage(uint16_t usage) {
01325         const char * const * w;
01326         E_Notify(pstrSpace, 0x80);
01327 
01328         output_if_between(usage, 0x00, 0x05, w, E_Notify, sportsCtrlTitles0, 0x80)
01329         else output_if_between(usage, 0x2f, 0x3a, w, E_Notify, sportsCtrlTitles1, 0x80)
01330         else output_if_between(usage, 0x4f, 0x64, w, E_Notify, sportsCtrlTitles2, 0x80)
01331         else E_Notify(pstrUsagePageUndefined, 0x80);
01332 }
01333 
01334 void ReportDescParserBase::PrintGameControlsPageUsage(uint16_t usage) {
01335         const char * const * w;
01336         E_Notify(pstrSpace, 0x80);
01337 
01338         output_if_between(usage, 0x00, 0x04, w, E_Notify, gameTitles0, 0x80)
01339         else output_if_between(usage, 0x1f, 0x3a, w, E_Notify, gameTitles1, 0x80)
01340         else E_Notify(pstrUsagePageUndefined, 0x80);
01341 }
01342 
01343 void ReportDescParserBase::PrintGenericDeviceControlsPageUsage(uint16_t usage) {
01344         const char * const * w;
01345         E_Notify(pstrSpace, 0x80);
01346 
01347         output_if_between(usage, 0x1f, 0x27, w, E_Notify, genDevCtrlTitles, 0x80)
01348         else E_Notify(pstrUsagePageUndefined, 0x80);
01349 }
01350 
01351 void ReportDescParserBase::PrintLEDPageUsage(uint16_t usage) {
01352         const char * const * w;
01353         E_Notify(pstrSpace, 0x80);
01354 
01355         output_if_between(usage, 0x00, 0x4e, w, E_Notify, ledTitles, 0x80)
01356         else E_Notify(pstrUsagePageUndefined, 0x80);
01357 }
01358 
01359 void ReportDescParserBase::PrintTelephonyPageUsage(uint16_t usage) {
01360         const char * const * w;
01361         E_Notify(pstrSpace, 0x80);
01362 
01363         output_if_between(usage, 0x00, 0x08, w, E_Notify, telTitles0, 0x80)
01364         else output_if_between(usage, 0x1f, 0x32, w, E_Notify, telTitles1, 0x80)
01365         else output_if_between(usage, 0x4f, 0x54, w, E_Notify, telTitles2, 0x80)
01366         else output_if_between(usage, 0x6f, 0x75, w, E_Notify, telTitles3, 0x80)
01367         else output_if_between(usage, 0x8f, 0x9f, w, E_Notify, telTitles4, 0x80)
01368         else output_if_between(usage, 0xaf, 0xc0, w, E_Notify, telTitles5, 0x80)
01369         else E_Notify(pstrUsagePageUndefined, 0x80);
01370 }
01371 
01372 void ReportDescParserBase::PrintConsumerPageUsage(uint16_t usage) {
01373         const char * const * w;
01374         E_Notify(pstrSpace, 0x80);
01375 
01376         output_if_between(usage, 0x00, 0x07, w, E_Notify, consTitles0, 0x80)
01377         else output_if_between(usage, 0x1f, 0x23, w, E_Notify, consTitles1, 0x80)
01378         else output_if_between(usage, 0x2f, 0x37, w, E_Notify, consTitles2, 0x80)
01379         else output_if_between(usage, 0x3f, 0x49, w, E_Notify, consTitles3, 0x80)
01380         else output_if_between(usage, 0x5f, 0x67, w, E_Notify, consTitles4, 0x80)
01381         else output_if_between(usage, 0x7f, 0xa5, w, E_Notify, consTitles5, 0x80)
01382         else output_if_between(usage, 0xaf, 0xcf, w, E_Notify, consTitles6, 0x80)
01383         else output_if_between(usage, 0xdf, 0xeb, w, E_Notify, consTitles7, 0x80)
01384         else output_if_between(usage, 0xef, 0xf6, w, E_Notify, consTitles8, 0x80)
01385         else output_if_between(usage, 0xff, 0x10e, w, E_Notify, consTitles9, 0x80)
01386         else output_if_between(usage, 0x14f, 0x156, w, E_Notify, consTitlesA, 0x80)
01387         else output_if_between(usage, 0x15f, 0x16b, w, E_Notify, consTitlesB, 0x80)
01388         else output_if_between(usage, 0x16f, 0x175, w, E_Notify, consTitlesC, 0x80)
01389         else output_if_between(usage, 0x17f, 0x1c8, w, E_Notify, consTitlesD, 0x80)
01390         else output_if_between(usage, 0x1ff, 0x29d, w, E_Notify, consTitlesE, 0x80)
01391         else E_Notify(pstrUsagePageUndefined, 0x80);
01392 }
01393 
01394 void ReportDescParserBase::PrintDigitizerPageUsage(uint16_t usage) {
01395         const char * const * w;
01396         E_Notify(pstrSpace, 0x80);
01397 
01398         output_if_between(usage, 0x00, 0x0e, w, E_Notify, digitTitles0, 0x80)
01399         else output_if_between(usage, 0x1f, 0x23, w, E_Notify, digitTitles1, 0x80)
01400         else output_if_between(usage, 0x2f, 0x47, w, E_Notify, digitTitles2, 0x80)
01401         else E_Notify(pstrUsagePageUndefined, 0x80);
01402 }
01403 
01404 void ReportDescParserBase::PrintAlphanumDisplayPageUsage(uint16_t usage) {
01405         const char * const * w;
01406         E_Notify(pstrSpace, 0x80);
01407 
01408         output_if_between(usage, 0x00, 0x03, w, E_Notify, aplphanumTitles0, 0x80)
01409         else output_if_between(usage, 0x1f, 0x4e, w, E_Notify, aplphanumTitles1, 0x80)
01410         else output_if_between(usage, 0x7f, 0x96, w, E_Notify, digitTitles2, 0x80)
01411         else E_Notify(pstrUsagePageUndefined, 0x80);
01412 }
01413 
01414 void ReportDescParserBase::PrintMedicalInstrumentPageUsage(uint16_t usage) {
01415         const char * const * w;
01416         E_Notify(pstrSpace, 0x80);
01417 
01418         if(usage == 1) E_Notify(pstrUsageMedicalUltrasound, 0x80);
01419         else if(usage == 0x70)
01420                 E_Notify(pstrUsageDepthGainCompensation, 0x80);
01421         else output_if_between(usage, 0x1f, 0x28, w, E_Notify, medInstrTitles0, 0x80)
01422         else output_if_between(usage, 0x3f, 0x45, w, E_Notify, medInstrTitles1, 0x80)
01423         else output_if_between(usage, 0x5f, 0x62, w, E_Notify, medInstrTitles2, 0x80)
01424         else output_if_between(usage, 0x7f, 0x8a, w, E_Notify, medInstrTitles3, 0x80)
01425         else output_if_between(usage, 0x9f, 0xa2, w, E_Notify, medInstrTitles4, 0x80)
01426         else E_Notify(pstrUsagePageUndefined, 0x80);
01427 }
01428 
01429 uint8_t ReportDescParser2::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
01430         //uint8_t ret = enErrorSuccess;
01431 
01432         switch(itemParseState) {
01433                 case 0:
01434                         if(**pp == HID_LONG_ITEM_PREFIX)
01435                                 USBTRACE("\r\nLONG\r\n");
01436                         else {
01437                                 uint8_t size = ((**pp) & DATA_SIZE_MASK);
01438                                 itemPrefix = (**pp);
01439                                 itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
01440                         }
01441                         (*pp)++;
01442                         (*pcntdn)--;
01443                         itemSize--;
01444                         itemParseState = 1;
01445 
01446                         if(!itemSize)
01447                                 break;
01448 
01449                         if(!pcntdn)
01450                                 return enErrorIncomplete;
01451                 case 1:
01452                         theBuffer.valueSize = itemSize;
01453                         valParser.Initialize(&theBuffer);
01454                         itemParseState = 2;
01455                 case 2:
01456                         if(!valParser.Parse(pp, pcntdn))
01457                                 return enErrorIncomplete;
01458                         itemParseState = 3;
01459                 case 3:
01460                 {
01461                         uint8_t data = *((uint8_t*)varBuffer);
01462 
01463                         switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
01464                                 case (TYPE_LOCAL | TAG_LOCAL_USAGE):
01465                                         if(pfUsage) {
01466                                                 if(theBuffer.valueSize > 1) {
01467                                                         uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
01468                                                         pfUsage(*ui16);
01469                                                 } else
01470                                                         pfUsage(data);
01471                                         }
01472                                         break;
01473                                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
01474                                         rptSize = data;
01475                                         break;
01476                                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
01477                                         rptCount = data;
01478                                         break;
01479                                 case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
01480                                         rptId = data;
01481                                         break;
01482                                 case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
01483                                         useMin = data;
01484                                         break;
01485                                 case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
01486                                         useMax = data;
01487                                         break;
01488                                 case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
01489                                         SetUsagePage(data);
01490                                         break;
01491                                 case (TYPE_MAIN | TAG_MAIN_OUTPUT):
01492                                 case (TYPE_MAIN | TAG_MAIN_FEATURE):
01493                                         rptSize = 0;
01494                                         rptCount = 0;
01495                                         useMin = 0;
01496                                         useMax = 0;
01497                                         break;
01498                                 case (TYPE_MAIN | TAG_MAIN_INPUT):
01499                                         OnInputItem(data);
01500 
01501                                         totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
01502 
01503                                         rptSize = 0;
01504                                         rptCount = 0;
01505                                         useMin = 0;
01506                                         useMax = 0;
01507                                         break;
01508                         } // switch (**pp & (TYPE_MASK | TAG_MASK))
01509                 }
01510         } // switch (itemParseState)
01511         itemParseState = 0;
01512         return enErrorSuccess;
01513 }
01514 
01515 void ReportDescParser2::OnInputItem(uint8_t itm) {
01516         uint8_t byte_offset = (totalSize >> 3); // calculate offset to the next unhandled byte i = (int)(totalCount / 8);
01517         uint32_t tmp = (byte_offset << 3);
01518         uint8_t bit_offset = totalSize - tmp; // number of bits in the current byte already handled
01519         uint8_t *p = pBuf + byte_offset; // current byte pointer
01520 
01521         if(bit_offset)
01522                 *p >>= bit_offset;
01523 
01524         uint8_t usage = useMin;
01525 
01526         bool print_usemin_usemax = ((useMin < useMax) && ((itm & 3) == 2) && pfUsage) ? true : false;
01527 
01528         uint8_t bits_of_byte = 8;
01529 
01530         // for each field in field array defined by rptCount
01531         for(uint8_t field = 0; field < rptCount; field++, usage++) {
01532 
01533                 union {
01534                         uint8_t bResult[4];
01535                         uint16_t wResult[2];
01536                         uint32_t dwResult;
01537                 } result;
01538 
01539                 result.dwResult = 0;
01540                 uint8_t mask = 0;
01541 
01542                 if(print_usemin_usemax)
01543                         pfUsage(usage);
01544 
01545                 // bits_left            - number of bits in the field(array of fields, depending on Report Count) left to process
01546                 // bits_of_byte         - number of bits in current byte left to process
01547                 // bits_to_copy         - number of bits to copy to result buffer
01548 
01549                 // for each bit in a field
01550                 for(uint8_t bits_left = rptSize, bits_to_copy = 0; bits_left;
01551                         bits_left -= bits_to_copy) {
01552                         bits_to_copy = (bits_left > bits_of_byte) ? bits_of_byte : bits_left;
01553 
01554                         result.dwResult <<= bits_to_copy; // Result buffer is shifted by the number of bits to be copied into it
01555 
01556                         uint8_t val = *p;
01557 
01558                         val >>= (8 - bits_of_byte); // Shift by the number of bits already processed
01559 
01560                         mask = 0;
01561 
01562                         for(uint8_t j = bits_to_copy; j; j--) {
01563                                 mask <<= 1;
01564                                 mask |= 1;
01565                         }
01566 
01567                         result.bResult[0] = (result.bResult[0] | (val & mask));
01568 
01569                         bits_of_byte -= bits_to_copy;
01570 
01571                         if(bits_of_byte < 1) {
01572                                 bits_of_byte = 8;
01573                                 p++;
01574                         }
01575                 }
01576                 PrintByteValue(result.dwResult);
01577         }
01578         E_Notify(PSTR("\r\n"), 0x80);
01579 }
01580 
01581 void UniversalReportParser::Parse(USBHID *hid, bool is_rpt_id __attribute__((unused)), uint8_t len, uint8_t *buf) {
01582         ReportDescParser2 prs(len, buf);
01583 
01584         uint8_t ret = hid->GetReportDescr(0, &prs);
01585 
01586         if(ret)
01587                 ErrorMessage<uint8_t > (PSTR("GetReportDescr-2"), ret);
01588 }