remove more unused libraries

1 files changed, 0 insertions, 1588 deletions

diff --git a/lib/usbhost/USB_Host_Shield_2.0/hidescriptorparser.cpp b/lib/usbhost/USB_Host_Shield_2.0/hidescriptorparser.cpp
deleted file mode 100644
index e4491b4e97..0000000000
--- a/lib/usbhost/USB_Host_Shield_2.0/hidescriptorparser.cpp
+++ /dev/null
@@ -1,1588 +0,0 @@
-/* Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
-
-This software may be distributed and modified under the terms of the GNU
-General Public License version 2 (GPL2) as published by the Free Software
-Foundation and appearing in the file GPL2.TXT included in the packaging of
-this file. Please note that GPL2 Section 2[b] requires that all works based
-on this software must also be made publicly available under the terms of
-the GPL2 ("Copyleft").
-
-Contact information
--------------------
-
-Circuits At Home, LTD
-Web      :  http://www.circuitsathome.com
-e-mail   :  support@circuitsathome.com
- */
-
-#include "hidescriptorparser.h"
-
-const char * const ReportDescParserBase::usagePageTitles0[] PROGMEM = {
-        pstrUsagePageGenericDesktopControls,
-        pstrUsagePageSimulationControls,
-        pstrUsagePageVRControls,
-        pstrUsagePageSportControls,
-        pstrUsagePageGameControls,
-        pstrUsagePageGenericDeviceControls,
-        pstrUsagePageKeyboardKeypad,
-        pstrUsagePageLEDs,
-        pstrUsagePageButton,
-        pstrUsagePageOrdinal,
-        pstrUsagePageTelephone,
-        pstrUsagePageConsumer,
-        pstrUsagePageDigitizer,
-        pstrUsagePagePID,
-        pstrUsagePageUnicode
-};
-
-const char * const ReportDescParserBase::usagePageTitles1[] PROGMEM = {
-        pstrUsagePageBarCodeScanner,
-        pstrUsagePageScale,
-        pstrUsagePageMSRDevices,
-        pstrUsagePagePointOfSale,
-        pstrUsagePageCameraControl,
-        pstrUsagePageArcade
-};
-const char * const ReportDescParserBase::genDesktopTitles0[] PROGMEM = {
-        pstrUsagePointer,
-        pstrUsageMouse,
-        pstrUsageJoystick,
-        pstrUsageGamePad,
-        pstrUsageKeyboard,
-        pstrUsageKeypad,
-        pstrUsageMultiAxisController,
-        pstrUsageTabletPCSystemControls
-
-};
-const char * const ReportDescParserBase::genDesktopTitles1[] PROGMEM = {
-        pstrUsageX,
-        pstrUsageY,
-        pstrUsageZ,
-        pstrUsageRx,
-        pstrUsageRy,
-        pstrUsageRz,
-        pstrUsageSlider,
-        pstrUsageDial,
-        pstrUsageWheel,
-        pstrUsageHatSwitch,
-        pstrUsageCountedBuffer,
-        pstrUsageByteCount,
-        pstrUsageMotionWakeup,
-        pstrUsageStart,
-        pstrUsageSelect,
-        pstrUsagePageReserved,
-        pstrUsageVx,
-        pstrUsageVy,
-        pstrUsageVz,
-        pstrUsageVbrx,
-        pstrUsageVbry,
-        pstrUsageVbrz,
-        pstrUsageVno,
-        pstrUsageFeatureNotification,
-        pstrUsageResolutionMultiplier
-};
-const char * const ReportDescParserBase::genDesktopTitles2[] PROGMEM = {
-        pstrUsageSystemControl,
-        pstrUsageSystemPowerDown,
-        pstrUsageSystemSleep,
-        pstrUsageSystemWakeup,
-        pstrUsageSystemContextMenu,
-        pstrUsageSystemMainMenu,
-        pstrUsageSystemAppMenu,
-        pstrUsageSystemMenuHelp,
-        pstrUsageSystemMenuExit,
-        pstrUsageSystemMenuSelect,
-        pstrUsageSystemMenuRight,
-        pstrUsageSystemMenuLeft,
-        pstrUsageSystemMenuUp,
-        pstrUsageSystemMenuDown,
-        pstrUsageSystemColdRestart,
-        pstrUsageSystemWarmRestart,
-        pstrUsageDPadUp,
-        pstrUsageDPadDown,
-        pstrUsageDPadRight,
-        pstrUsageDPadLeft
-};
-const char * const ReportDescParserBase::genDesktopTitles3[] PROGMEM = {
-        pstrUsageSystemDock,
-        pstrUsageSystemUndock,
-        pstrUsageSystemSetup,
-        pstrUsageSystemBreak,
-        pstrUsageSystemDebuggerBreak,
-        pstrUsageApplicationBreak,
-        pstrUsageApplicationDebuggerBreak,
-        pstrUsageSystemSpeakerMute,
-        pstrUsageSystemHibernate
-};
-const char * const ReportDescParserBase::genDesktopTitles4[] PROGMEM = {
-        pstrUsageSystemDisplayInvert,
-        pstrUsageSystemDisplayInternal,
-        pstrUsageSystemDisplayExternal,
-        pstrUsageSystemDisplayBoth,
-        pstrUsageSystemDisplayDual,
-        pstrUsageSystemDisplayToggleIntExt,
-        pstrUsageSystemDisplaySwapPriSec,
-        pstrUsageSystemDisplayLCDAutoscale
-};
-const char * const ReportDescParserBase::simuTitles0[] PROGMEM = {
-        pstrUsageFlightSimulationDevice,
-        pstrUsageAutomobileSimulationDevice,
-        pstrUsageTankSimulationDevice,
-        pstrUsageSpaceshipSimulationDevice,
-        pstrUsageSubmarineSimulationDevice,
-        pstrUsageSailingSimulationDevice,
-        pstrUsageMotocicleSimulationDevice,
-        pstrUsageSportsSimulationDevice,
-        pstrUsageAirplaneSimulationDevice,
-        pstrUsageHelicopterSimulationDevice,
-        pstrUsageMagicCarpetSimulationDevice,
-        pstrUsageBicycleSimulationDevice
-};
-const char * const ReportDescParserBase::simuTitles1[] PROGMEM = {
-        pstrUsageFlightControlStick,
-        pstrUsageFlightStick,
-        pstrUsageCyclicControl,
-        pstrUsageCyclicTrim,
-        pstrUsageFlightYoke,
-        pstrUsageTrackControl
-};
-const char * const ReportDescParserBase::simuTitles2[] PROGMEM = {
-        pstrUsageAileron,
-        pstrUsageAileronTrim,
-        pstrUsageAntiTorqueControl,
-        pstrUsageAutopilotEnable,
-        pstrUsageChaffRelease,
-        pstrUsageCollectiveControl,
-        pstrUsageDiveBrake,
-        pstrUsageElectronicCountermeasures,
-        pstrUsageElevator,
-        pstrUsageElevatorTrim,
-        pstrUsageRudder,
-        pstrUsageThrottle,
-        pstrUsageFlightCommunications,
-        pstrUsageFlareRelease,
-        pstrUsageLandingGear,
-        pstrUsageToeBrake,
-        pstrUsageTrigger,
-        pstrUsageWeaponsArm,
-        pstrUsageWeaponsSelect,
-        pstrUsageWingFlaps,
-        pstrUsageAccelerator,
-        pstrUsageBrake,
-        pstrUsageClutch,
-        pstrUsageShifter,
-        pstrUsageSteering,
-        pstrUsageTurretDirection,
-        pstrUsageBarrelElevation,
-        pstrUsageDivePlane,
-        pstrUsageBallast,
-        pstrUsageBicycleCrank,
-        pstrUsageHandleBars,
-        pstrUsageFrontBrake,
-        pstrUsageRearBrake
-};
-const char * const ReportDescParserBase::vrTitles0[] PROGMEM = {
-        pstrUsageBelt,
-        pstrUsageBodySuit,
-        pstrUsageFlexor,
-        pstrUsageGlove,
-        pstrUsageHeadTracker,
-        pstrUsageHeadMountedDisplay,
-        pstrUsageHandTracker,
-        pstrUsageOculometer,
-        pstrUsageVest,
-        pstrUsageAnimatronicDevice
-};
-const char * const ReportDescParserBase::vrTitles1[] PROGMEM = {
-        pstrUsageStereoEnable,
-        pstrUsageDisplayEnable
-};
-const char * const ReportDescParserBase::sportsCtrlTitles0[] PROGMEM = {
-        pstrUsageBaseballBat,
-        pstrUsageGolfClub,
-        pstrUsageRowingMachine,
-        pstrUsageTreadmill
-};
-const char * const ReportDescParserBase::sportsCtrlTitles1[] PROGMEM = {
-        pstrUsageOar,
-        pstrUsageSlope,
-        pstrUsageRate,
-        pstrUsageStickSpeed,
-        pstrUsageStickFaceAngle,
-        pstrUsageStickHeelToe,
-        pstrUsageStickFollowThough,
-        pstrUsageStickTempo,
-        pstrUsageStickType,
-        pstrUsageStickHeight
-};
-const char * const ReportDescParserBase::sportsCtrlTitles2[] PROGMEM = {
-        pstrUsagePutter,
-        pstrUsage1Iron,
-        pstrUsage2Iron,
-        pstrUsage3Iron,
-        pstrUsage4Iron,
-        pstrUsage5Iron,
-        pstrUsage6Iron,
-        pstrUsage7Iron,
-        pstrUsage8Iron,
-        pstrUsage9Iron,
-        pstrUsage10Iron,
-        pstrUsage11Iron,
-        pstrUsageSandWedge,
-        pstrUsageLoftWedge,
-        pstrUsagePowerWedge,
-        pstrUsage1Wood,
-        pstrUsage3Wood,
-        pstrUsage5Wood,
-        pstrUsage7Wood,
-        pstrUsage9Wood
-};
-const char * const ReportDescParserBase::gameTitles0[] PROGMEM = {
-        pstrUsage3DGameController,
-        pstrUsagePinballDevice,
-        pstrUsageGunDevice
-};
-const char * const ReportDescParserBase::gameTitles1[] PROGMEM = {
-        pstrUsagePointOfView,
-        pstrUsageTurnRightLeft,
-        pstrUsagePitchForwardBackward,
-        pstrUsageRollRightLeft,
-        pstrUsageMoveRightLeft,
-        pstrUsageMoveForwardBackward,
-        pstrUsageMoveUpDown,
-        pstrUsageLeanRightLeft,
-        pstrUsageLeanForwardBackward,
-        pstrUsageHeightOfPOV,
-        pstrUsageFlipper,
-        pstrUsageSecondaryFlipper,
-        pstrUsageBump,
-        pstrUsageNewGame,
-        pstrUsageShootBall,
-        pstrUsagePlayer,
-        pstrUsageGunBolt,
-        pstrUsageGunClip,
-        pstrUsageGunSelector,
-        pstrUsageGunSingleShot,
-        pstrUsageGunBurst,
-        pstrUsageGunAutomatic,
-        pstrUsageGunSafety,
-        pstrUsageGamepadFireJump,
-        pstrUsageGamepadTrigger
-};
-const char * const ReportDescParserBase::genDevCtrlTitles[] PROGMEM = {
-        pstrUsageBatteryStrength,
-        pstrUsageWirelessChannel,
-        pstrUsageWirelessID,
-        pstrUsageDiscoverWirelessControl,
-        pstrUsageSecurityCodeCharEntered,
-        pstrUsageSecurityCodeCharErased,
-        pstrUsageSecurityCodeCleared
-};
-const char * const ReportDescParserBase::ledTitles[] PROGMEM = {
-        pstrUsageNumLock,
-        pstrUsageCapsLock,
-        pstrUsageScrollLock,
-        pstrUsageCompose,
-        pstrUsageKana,
-        pstrUsagePower,
-        pstrUsageShift,
-        pstrUsageDoNotDisturb,
-        pstrUsageMute,
-        pstrUsageToneEnable,
-        pstrUsageHighCutFilter,
-        pstrUsageLowCutFilter,
-        pstrUsageEqualizerEnable,
-        pstrUsageSoundFieldOn,
-        pstrUsageSurroundOn,
-        pstrUsageRepeat,
-        pstrUsageStereo,
-        pstrUsageSamplingRateDetect,
-        pstrUsageSpinning,
-        pstrUsageCAV,
-        pstrUsageCLV,
-        pstrUsageRecordingFormatDetect,
-        pstrUsageOffHook,
-        pstrUsageRing,
-        pstrUsageMessageWaiting,
-        pstrUsageDataMode,
-        pstrUsageBatteryOperation,
-        pstrUsageBatteryOK,
-        pstrUsageBatteryLow,
-        pstrUsageSpeaker,
-        pstrUsageHeadSet,
-        pstrUsageHold,
-        pstrUsageMicrophone,
-        pstrUsageCoverage,
-        pstrUsageNightMode,
-        pstrUsageSendCalls,
-        pstrUsageCallPickup,
-        pstrUsageConference,
-        pstrUsageStandBy,
-        pstrUsageCameraOn,
-        pstrUsageCameraOff,
-        pstrUsageOnLine,
-        pstrUsageOffLine,
-        pstrUsageBusy,
-        pstrUsageReady,
-        pstrUsagePaperOut,
-        pstrUsagePaperJam,
-        pstrUsageRemote,
-        pstrUsageForward,
-        pstrUsageReverse,
-        pstrUsageStop,
-        pstrUsageRewind,
-        pstrUsageFastForward,
-        pstrUsagePlay,
-        pstrUsagePause,
-        pstrUsageRecord,
-        pstrUsageError,
-        pstrUsageSelectedIndicator,
-        pstrUsageInUseIndicator,
-        pstrUsageMultiModeIndicator,
-        pstrUsageIndicatorOn,
-        pstrUsageIndicatorFlash,
-        pstrUsageIndicatorSlowBlink,
-        pstrUsageIndicatorFastBlink,
-        pstrUsageIndicatorOff,
-        pstrUsageFlashOnTime,
-        pstrUsageSlowBlinkOnTime,
-        pstrUsageSlowBlinkOffTime,
-        pstrUsageFastBlinkOnTime,
-        pstrUsageFastBlinkOffTime,
-        pstrUsageIndicatorColor,
-        pstrUsageIndicatorRed,
-        pstrUsageIndicatorGreen,
-        pstrUsageIndicatorAmber,
-        pstrUsageGenericIndicator,
-        pstrUsageSystemSuspend,
-        pstrUsageExternalPowerConnected
-};
-const char * const ReportDescParserBase::telTitles0 [] PROGMEM = {
-        pstrUsagePhone,
-        pstrUsageAnsweringMachine,
-        pstrUsageMessageControls,
-        pstrUsageHandset,
-        pstrUsageHeadset,
-        pstrUsageTelephonyKeyPad,
-        pstrUsageProgrammableButton
-};
-const char * const ReportDescParserBase::telTitles1 [] PROGMEM = {
-        pstrUsageHookSwitch,
-        pstrUsageFlash,
-        pstrUsageFeature,
-        pstrUsageHold,
-        pstrUsageRedial,
-        pstrUsageTransfer,
-        pstrUsageDrop,
-        pstrUsagePark,
-        pstrUsageForwardCalls,
-        pstrUsageAlternateFunction,
-        pstrUsageLine,
-        pstrUsageSpeakerPhone,
-        pstrUsageConference,
-        pstrUsageRingEnable,
-        pstrUsageRingSelect,
-        pstrUsagePhoneMute,
-        pstrUsageCallerID,
-        pstrUsageSend
-};
-const char * const ReportDescParserBase::telTitles2 [] PROGMEM = {
-        pstrUsageSpeedDial,
-        pstrUsageStoreNumber,
-        pstrUsageRecallNumber,
-        pstrUsagePhoneDirectory
-};
-const char * const ReportDescParserBase::telTitles3 [] PROGMEM = {
-        pstrUsageVoiceMail,
-        pstrUsageScreenCalls,
-        pstrUsageDoNotDisturb,
-        pstrUsageMessage,
-        pstrUsageAnswerOnOff
-};
-const char * const ReportDescParserBase::telTitles4 [] PROGMEM = {
-        pstrUsageInsideDialTone,
-        pstrUsageOutsideDialTone,
-        pstrUsageInsideRingTone,
-        pstrUsageOutsideRingTone,
-        pstrUsagePriorityRingTone,
-        pstrUsageInsideRingback,
-        pstrUsagePriorityRingback,
-        pstrUsageLineBusyTone,
-        pstrUsageReorderTone,
-        pstrUsageCallWaitingTone,
-        pstrUsageConfirmationTone1,
-        pstrUsageConfirmationTone2,
-        pstrUsageTonesOff,
-        pstrUsageOutsideRingback,
-        pstrUsageRinger
-};
-const char * const ReportDescParserBase::telTitles5 [] PROGMEM = {
-        pstrUsagePhoneKey0,
-        pstrUsagePhoneKey1,
-        pstrUsagePhoneKey2,
-        pstrUsagePhoneKey3,
-        pstrUsagePhoneKey4,
-        pstrUsagePhoneKey5,
-        pstrUsagePhoneKey6,
-        pstrUsagePhoneKey7,
-        pstrUsagePhoneKey8,
-        pstrUsagePhoneKey9,
-        pstrUsagePhoneKeyStar,
-        pstrUsagePhoneKeyPound,
-        pstrUsagePhoneKeyA,
-        pstrUsagePhoneKeyB,
-        pstrUsagePhoneKeyC,
-        pstrUsagePhoneKeyD
-};
-const char * const ReportDescParserBase::consTitles0[] PROGMEM = {
-        pstrUsageConsumerControl,
-        pstrUsageNumericKeyPad,
-        pstrUsageProgrammableButton,
-        pstrUsageMicrophone,
-        pstrUsageHeadphone,
-        pstrUsageGraphicEqualizer
-};
-const char * const ReportDescParserBase::consTitles1[] PROGMEM = {
-        pstrUsagePlus10,
-        pstrUsagePlus100,
-        pstrUsageAMPM
-};
-const char * const ReportDescParserBase::consTitles2[] PROGMEM = {
-        pstrUsagePower,
-        pstrUsageReset,
-        pstrUsageSleep,
-        pstrUsageSleepAfter,
-        pstrUsageSleepMode,
-        pstrUsageIllumination,
-        pstrUsageFunctionButtons
-
-};
-const char * const ReportDescParserBase::consTitles3[] PROGMEM = {
-        pstrUsageMenu,
-        pstrUsageMenuPick,
-        pstrUsageMenuUp,
-        pstrUsageMenuDown,
-        pstrUsageMenuLeft,
-        pstrUsageMenuRight,
-        pstrUsageMenuEscape,
-        pstrUsageMenuValueIncrease,
-        pstrUsageMenuValueDecrease
-};
-const char * const ReportDescParserBase::consTitles4[] PROGMEM = {
-        pstrUsageDataOnScreen,
-        pstrUsageClosedCaption,
-        pstrUsageClosedCaptionSelect,
-        pstrUsageVCRTV,
-        pstrUsageBroadcastMode,
-        pstrUsageSnapshot,
-        pstrUsageStill
-};
-const char * const ReportDescParserBase::consTitles5[] PROGMEM = {
-        pstrUsageSelection,
-        pstrUsageAssignSelection,
-        pstrUsageModeStep,
-        pstrUsageRecallLast,
-        pstrUsageEnterChannel,
-        pstrUsageOrderMovie,
-        pstrUsageChannel,
-        pstrUsageMediaSelection,
-        pstrUsageMediaSelectComputer,
-        pstrUsageMediaSelectTV,
-        pstrUsageMediaSelectWWW,
-        pstrUsageMediaSelectDVD,
-        pstrUsageMediaSelectTelephone,
-        pstrUsageMediaSelectProgramGuide,
-        pstrUsageMediaSelectVideoPhone,
-        pstrUsageMediaSelectGames,
-        pstrUsageMediaSelectMessages,
-        pstrUsageMediaSelectCD,
-        pstrUsageMediaSelectVCR,
-        pstrUsageMediaSelectTuner,
-        pstrUsageQuit,
-        pstrUsageHelp,
-        pstrUsageMediaSelectTape,
-        pstrUsageMediaSelectCable,
-        pstrUsageMediaSelectSatellite,
-        pstrUsageMediaSelectSecurity,
-        pstrUsageMediaSelectHome,
-        pstrUsageMediaSelectCall,
-        pstrUsageChannelIncrement,
-        pstrUsageChannelDecrement,
-        pstrUsageMediaSelectSAP,
-        pstrUsagePageReserved,
-        pstrUsageVCRPlus,
-        pstrUsageOnce,
-        pstrUsageDaily,
-        pstrUsageWeekly,
-        pstrUsageMonthly
-};
-const char * const ReportDescParserBase::consTitles6[] PROGMEM = {
-        pstrUsagePlay,
-        pstrUsagePause,
-        pstrUsageRecord,
-        pstrUsageFastForward,
-        pstrUsageRewind,
-        pstrUsageScanNextTrack,
-        pstrUsageScanPreviousTrack,
-        pstrUsageStop,
-        pstrUsageEject,
-        pstrUsageRandomPlay,
-        pstrUsageSelectDisk,
-        pstrUsageEnterDisk,
-        pstrUsageRepeat,
-        pstrUsageTracking,
-        pstrUsageTrackNormal,
-        pstrUsageSlowTracking,
-        pstrUsageFrameForward,
-        pstrUsageFrameBackwards,
-        pstrUsageMark,
-        pstrUsageClearMark,
-        pstrUsageRepeatFromMark,
-        pstrUsageReturnToMark,
-        pstrUsageSearchMarkForward,
-        pstrUsageSearchMarkBackwards,
-        pstrUsageCounterReset,
-        pstrUsageShowCounter,
-        pstrUsageTrackingIncrement,
-        pstrUsageTrackingDecrement,
-        pstrUsageStopEject,
-        pstrUsagePlayPause,
-        pstrUsagePlaySkip
-};
-const char * const ReportDescParserBase::consTitles7[] PROGMEM = {
-        pstrUsageVolume,
-        pstrUsageBalance,
-        pstrUsageMute,
-        pstrUsageBass,
-        pstrUsageTreble,
-        pstrUsageBassBoost,
-        pstrUsageSurroundMode,
-        pstrUsageLoudness,
-        pstrUsageMPX,
-        pstrUsageVolumeIncrement,
-        pstrUsageVolumeDecrement
-};
-const char * const ReportDescParserBase::consTitles8[] PROGMEM = {
-        pstrUsageSpeedSelect,
-        pstrUsagePlaybackSpeed,
-        pstrUsageStandardPlay,
-        pstrUsageLongPlay,
-        pstrUsageExtendedPlay,
-        pstrUsageSlow
-};
-const char * const ReportDescParserBase::consTitles9[] PROGMEM = {
-        pstrUsageFanEnable,
-        pstrUsageFanSpeed,
-        pstrUsageLightEnable,
-        pstrUsageLightIlluminationLevel,
-        pstrUsageClimateControlEnable,
-        pstrUsageRoomTemperature,
-        pstrUsageSecurityEnable,
-        pstrUsageFireAlarm,
-        pstrUsagePoliceAlarm,
-        pstrUsageProximity,
-        pstrUsageMotion,
-        pstrUsageDuresAlarm,
-        pstrUsageHoldupAlarm,
-        pstrUsageMedicalAlarm
-};
-const char * const ReportDescParserBase::consTitlesA[] PROGMEM = {
-        pstrUsageBalanceRight,
-        pstrUsageBalanceLeft,
-        pstrUsageBassIncrement,
-        pstrUsageBassDecrement,
-        pstrUsageTrebleIncrement,
-        pstrUsageTrebleDecrement
-};
-const char * const ReportDescParserBase::consTitlesB[] PROGMEM = {
-        pstrUsageSpeakerSystem,
-        pstrUsageChannelLeft,
-        pstrUsageChannelRight,
-        pstrUsageChannelCenter,
-        pstrUsageChannelFront,
-        pstrUsageChannelCenterFront,
-        pstrUsageChannelSide,
-        pstrUsageChannelSurround,
-        pstrUsageChannelLowFreqEnhancement,
-        pstrUsageChannelTop,
-        pstrUsageChannelUnknown
-};
-const char * const ReportDescParserBase::consTitlesC[] PROGMEM = {
-        pstrUsageSubChannel,
-        pstrUsageSubChannelIncrement,
-        pstrUsageSubChannelDecrement,
-        pstrUsageAlternateAudioIncrement,
-        pstrUsageAlternateAudioDecrement
-};
-const char * const ReportDescParserBase::consTitlesD[] PROGMEM = {
-        pstrUsageApplicationLaunchButtons,
-        pstrUsageALLaunchButtonConfigTool,
-        pstrUsageALProgrammableButton,
-        pstrUsageALConsumerControlConfig,
-        pstrUsageALWordProcessor,
-        pstrUsageALTextEditor,
-        pstrUsageALSpreadsheet,
-        pstrUsageALGraphicsEditor,
-        pstrUsageALPresentationApp,
-        pstrUsageALDatabaseApp,
-        pstrUsageALEmailReader,
-        pstrUsageALNewsreader,
-        pstrUsageALVoicemail,
-        pstrUsageALContactsAddressBook,
-        pstrUsageALCalendarSchedule,
-        pstrUsageALTaskProjectManager,
-        pstrUsageALLogJournalTimecard,
-        pstrUsageALCheckbookFinance,
-        pstrUsageALCalculator,
-        pstrUsageALAVCapturePlayback,
-        pstrUsageALLocalMachineBrowser,
-        pstrUsageALLANWANBrow,
-        pstrUsageALInternetBrowser,
-        pstrUsageALRemoteNetISPConnect,
-        pstrUsageALNetworkConference,
-        pstrUsageALNetworkChat,
-        pstrUsageALTelephonyDialer,
-        pstrUsageALLogon,
-        pstrUsageALLogoff,
-        pstrUsageALLogonLogoff,
-        pstrUsageALTermLockScrSav,
-        pstrUsageALControlPannel,
-        pstrUsageALCommandLineProcessorRun,
-        pstrUsageALProcessTaskManager,
-        pstrUsageALSelectTaskApplication,
-        pstrUsageALNextTaskApplication,
-        pstrUsageALPreviousTaskApplication,
-        pstrUsageALPreemptiveHaltTaskApp,
-        pstrUsageALIntegratedHelpCenter,
-        pstrUsageALDocuments,
-        pstrUsageALThesaurus,
-        pstrUsageALDictionary,
-        pstrUsageALDesktop,
-        pstrUsageALSpellCheck,
-        pstrUsageALGrammarCheck,
-        pstrUsageALWirelessStatus,
-        pstrUsageALKeyboardLayout,
-        pstrUsageALVirusProtection,
-        pstrUsageALEncryption,
-        pstrUsageALScreenSaver,
-        pstrUsageALAlarms,
-        pstrUsageALClock,
-        pstrUsageALFileBrowser,
-        pstrUsageALPowerStatus,
-        pstrUsageALImageBrowser,
-        pstrUsageALAudioBrowser,
-        pstrUsageALMovieBrowser,
-        pstrUsageALDigitalRightsManager,
-        pstrUsageALDigitalWallet,
-        pstrUsagePageReserved,
-        pstrUsageALInstantMessaging,
-        pstrUsageALOEMFeaturesBrowser,
-        pstrUsageALOEMHelp,
-        pstrUsageALOnlineCommunity,
-        pstrUsageALEntertainmentContentBrow,
-        pstrUsageALOnlineShoppingBrowser,
-        pstrUsageALSmartCardInfoHelp,
-        pstrUsageALMarketMonitorFinBrowser,
-        pstrUsageALCustomCorpNewsBrowser,
-        pstrUsageALOnlineActivityBrowser,
-        pstrUsageALResearchSearchBrowser,
-        pstrUsageALAudioPlayer
-};
-const char * const ReportDescParserBase::consTitlesE[] PROGMEM = {
-        pstrUsageGenericGUIAppControls,
-        pstrUsageACNew,
-        pstrUsageACOpen,
-        pstrUsageACClose,
-        pstrUsageACExit,
-        pstrUsageACMaximize,
-        pstrUsageACMinimize,
-        pstrUsageACSave,
-        pstrUsageACPrint,
-        pstrUsageACProperties,
-        pstrUsageACUndo,
-        pstrUsageACCopy,
-        pstrUsageACCut,
-        pstrUsageACPaste,
-        pstrUsageACSelectAll,
-        pstrUsageACFind,
-        pstrUsageACFindAndReplace,
-        pstrUsageACSearch,
-        pstrUsageACGoto,
-        pstrUsageACHome,
-        pstrUsageACBack,
-        pstrUsageACForward,
-        pstrUsageACStop,
-        pstrUsageACRefresh,
-        pstrUsageACPreviousLink,
-        pstrUsageACNextLink,
-        pstrUsageACBookmarks,
-        pstrUsageACHistory,
-        pstrUsageACSubscriptions,
-        pstrUsageACZoomIn,
-        pstrUsageACZoomOut,
-        pstrUsageACZoom,
-        pstrUsageACFullScreenView,
-        pstrUsageACNormalView,
-        pstrUsageACViewToggle,
-        pstrUsageACScrollUp,
-        pstrUsageACScrollDown,
-        pstrUsageACScroll,
-        pstrUsageACPanLeft,
-        pstrUsageACPanRight,
-        pstrUsageACPan,
-        pstrUsageACNewWindow,
-        pstrUsageACTileHoriz,
-        pstrUsageACTileVert,
-        pstrUsageACFormat,
-        pstrUsageACEdit,
-        pstrUsageACBold,
-        pstrUsageACItalics,
-        pstrUsageACUnderline,
-        pstrUsageACStrikethrough,
-        pstrUsageACSubscript,
-        pstrUsageACSuperscript,
-        pstrUsageACAllCaps,
-        pstrUsageACRotate,
-        pstrUsageACResize,
-        pstrUsageACFlipHorizontal,
-        pstrUsageACFlipVertical,
-        pstrUsageACMirrorHorizontal,
-        pstrUsageACMirrorVertical,
-        pstrUsageACFontSelect,
-        pstrUsageACFontColor,
-        pstrUsageACFontSize,
-        pstrUsageACJustifyLeft,
-        pstrUsageACJustifyCenterH,
-        pstrUsageACJustifyRight,
-        pstrUsageACJustifyBlockH,
-        pstrUsageACJustifyTop,
-        pstrUsageACJustifyCenterV,
-        pstrUsageACJustifyBottom,
-        pstrUsageACJustifyBlockV,
-        pstrUsageACIndentDecrease,
-        pstrUsageACIndentIncrease,
-        pstrUsageACNumberedList,
-        pstrUsageACRestartNumbering,
-        pstrUsageACBulletedList,
-        pstrUsageACPromote,
-        pstrUsageACDemote,
-        pstrUsageACYes,
-        pstrUsageACNo,
-        pstrUsageACCancel,
-        pstrUsageACCatalog,
-        pstrUsageACBuyChkout,
-        pstrUsageACAddToCart,
-        pstrUsageACExpand,
-        pstrUsageACExpandAll,
-        pstrUsageACCollapse,
-        pstrUsageACCollapseAll,
-        pstrUsageACPrintPreview,
-        pstrUsageACPasteSpecial,
-        pstrUsageACInsertMode,
-        pstrUsageACDelete,
-        pstrUsageACLock,
-        pstrUsageACUnlock,
-        pstrUsageACProtect,
-        pstrUsageACUnprotect,
-        pstrUsageACAttachComment,
-        pstrUsageACDeleteComment,
-        pstrUsageACViewComment,
-        pstrUsageACSelectWord,
-        pstrUsageACSelectSentence,
-        pstrUsageACSelectParagraph,
-        pstrUsageACSelectColumn,
-        pstrUsageACSelectRow,
-        pstrUsageACSelectTable,
-        pstrUsageACSelectObject,
-        pstrUsageACRedoRepeat,
-        pstrUsageACSort,
-        pstrUsageACSortAscending,
-        pstrUsageACSortDescending,
-        pstrUsageACFilter,
-        pstrUsageACSetClock,
-        pstrUsageACViewClock,
-        pstrUsageACSelectTimeZone,
-        pstrUsageACEditTimeZone,
-        pstrUsageACSetAlarm,
-        pstrUsageACClearAlarm,
-        pstrUsageACSnoozeAlarm,
-        pstrUsageACResetAlarm,
-        pstrUsageACSyncronize,
-        pstrUsageACSendReceive,
-        pstrUsageACSendTo,
-        pstrUsageACReply,
-        pstrUsageACReplyAll,
-        pstrUsageACForwardMessage,
-        pstrUsageACSend,
-        pstrUsageACAttachFile,
-        pstrUsageACUpload,
-        pstrUsageACDownload,
-        pstrUsageACSetBorders,
-        pstrUsageACInsertRow,
-        pstrUsageACInsertColumn,
-        pstrUsageACInsertFile,
-        pstrUsageACInsertPicture,
-        pstrUsageACInsertObject,
-        pstrUsageACInsertSymbol,
-        pstrUsageACSaveAndClose,
-        pstrUsageACRename,
-        pstrUsageACMerge,
-        pstrUsageACSplit,
-        pstrUsageACDistributeHorizontaly,
-        pstrUsageACDistributeVerticaly
-};
-const char * const ReportDescParserBase::digitTitles0[] PROGMEM = {
-        pstrUsageDigitizer,
-        pstrUsagePen,
-        pstrUsageLightPen,
-        pstrUsageTouchScreen,
-        pstrUsageTouchPad,
-        pstrUsageWhiteBoard,
-        pstrUsageCoordinateMeasuringMachine,
-        pstrUsage3DDigitizer,
-        pstrUsageStereoPlotter,
-        pstrUsageArticulatedArm,
-        pstrUsageArmature,
-        pstrUsageMultiplePointDigitizer,
-        pstrUsageFreeSpaceWand
-};
-const char * const ReportDescParserBase::digitTitles1[] PROGMEM = {
-        pstrUsageStylus,
-        pstrUsagePuck,
-        pstrUsageFinger
-
-};
-const char * const ReportDescParserBase::digitTitles2[] PROGMEM = {
-        pstrUsageTipPressure,
-        pstrUsageBarrelPressure,
-        pstrUsageInRange,
-        pstrUsageTouch,
-        pstrUsageUntouch,
-        pstrUsageTap,
-        pstrUsageQuality,
-        pstrUsageDataValid,
-        pstrUsageTransducerIndex,
-        pstrUsageTabletFunctionKeys,
-        pstrUsageProgramChangeKeys,
-        pstrUsageBatteryStrength,
-        pstrUsageInvert,
-        pstrUsageXTilt,
-        pstrUsageYTilt,
-        pstrUsageAzimuth,
-        pstrUsageAltitude,
-        pstrUsageTwist,
-        pstrUsageTipSwitch,
-        pstrUsageSecondaryTipSwitch,
-        pstrUsageBarrelSwitch,
-        pstrUsageEraser,
-        pstrUsageTabletPick
-};
-const char * const ReportDescParserBase::aplphanumTitles0[] PROGMEM = {
-        pstrUsageAlphanumericDisplay,
-        pstrUsageBitmappedDisplay
-};
-const char * const ReportDescParserBase::aplphanumTitles1[] PROGMEM = {
-        pstrUsageDisplayAttributesReport,
-        pstrUsageASCIICharacterSet,
-        pstrUsageDataReadBack,
-        pstrUsageFontReadBack,
-        pstrUsageDisplayControlReport,
-        pstrUsageClearDisplay,
-        pstrUsageDisplayEnable,
-        pstrUsageScreenSaverDelay,
-        pstrUsageScreenSaverEnable,
-        pstrUsageVerticalScroll,
-        pstrUsageHorizontalScroll,
-        pstrUsageCharacterReport,
-        pstrUsageDisplayData,
-        pstrUsageDisplayStatus,
-        pstrUsageStatusNotReady,
-        pstrUsageStatusReady,
-        pstrUsageErrorNotALoadableCharacter,
-        pstrUsageErrorFotDataCanNotBeRead,
-        pstrUsageCursorPositionReport,
-        pstrUsageRow,
-        pstrUsageColumn,
-        pstrUsageRows,
-        pstrUsageColumns,
-        pstrUsageCursorPixelPosition,
-        pstrUsageCursorMode,
-        pstrUsageCursorEnable,
-        pstrUsageCursorBlink,
-        pstrUsageFontReport,
-        pstrUsageFontData,
-        pstrUsageCharacterWidth,
-        pstrUsageCharacterHeight,
-        pstrUsageCharacterSpacingHorizontal,
-        pstrUsageCharacterSpacingVertical,
-        pstrUsageUnicodeCharset,
-        pstrUsageFont7Segment,
-        pstrUsage7SegmentDirectMap,
-        pstrUsageFont14Segment,
-        pstrUsage14SegmentDirectMap,
-        pstrUsageDisplayBrightness,
-        pstrUsageDisplayContrast,
-        pstrUsageCharacterAttribute,
-        pstrUsageAttributeReadback,
-        pstrUsageAttributeData,
-        pstrUsageCharAttributeEnhance,
-        pstrUsageCharAttributeUnderline,
-        pstrUsageCharAttributeBlink
-};
-const char * const ReportDescParserBase::aplphanumTitles2[] PROGMEM = {
-        pstrUsageBitmapSizeX,
-        pstrUsageBitmapSizeY,
-        pstrUsagePageReserved,
-        pstrUsageBitDepthFormat,
-        pstrUsageDisplayOrientation,
-        pstrUsagePaletteReport,
-        pstrUsagePaletteDataSize,
-        pstrUsagePaletteDataOffset,
-        pstrUsagePaletteData,
-        pstrUsageBlitReport,
-        pstrUsageBlitRectangleX1,
-        pstrUsageBlitRectangleY1,
-        pstrUsageBlitRectangleX2,
-        pstrUsageBlitRectangleY2,
-        pstrUsageBlitData,
-        pstrUsageSoftButton,
-        pstrUsageSoftButtonID,
-        pstrUsageSoftButtonSide,
-        pstrUsageSoftButtonOffset1,
-        pstrUsageSoftButtonOffset2,
-        pstrUsageSoftButtonReport
-};
-const char * const ReportDescParserBase::medInstrTitles0[] PROGMEM = {
-        pstrUsageVCRAcquisition,
-        pstrUsageFreezeThaw,
-        pstrUsageClipStore,
-        pstrUsageUpdate,
-        pstrUsageNext,
-        pstrUsageSave,
-        pstrUsagePrint,
-        pstrUsageMicrophoneEnable
-};
-const char * const ReportDescParserBase::medInstrTitles1[] PROGMEM = {
-        pstrUsageCine,
-        pstrUsageTransmitPower,
-        pstrUsageVolume,
-        pstrUsageFocus,
-        pstrUsageDepth
-};
-const char * const ReportDescParserBase::medInstrTitles2[] PROGMEM = {
-        pstrUsageSoftStepPrimary,
-        pstrUsageSoftStepSecondary
-};
-const char * const ReportDescParserBase::medInstrTitles3[] PROGMEM = {
-        pstrUsageZoomSelect,
-        pstrUsageZoomAdjust,
-        pstrUsageSpectralDopplerModeSelect,
-        pstrUsageSpectralDopplerModeAdjust,
-        pstrUsageColorDopplerModeSelect,
-        pstrUsageColorDopplerModeAdjust,
-        pstrUsageMotionModeSelect,
-        pstrUsageMotionModeAdjust,
-        pstrUsage2DModeSelect,
-        pstrUsage2DModeAdjust
-};
-const char * const ReportDescParserBase::medInstrTitles4[] PROGMEM = {
-        pstrUsageSoftControlSelect,
-        pstrUsageSoftControlAdjust
-};
-
-void ReportDescParserBase::Parse(const uint16_t len, const uint8_t *pbuf, const uint16_t &offset) {
-        uint16_t cntdn = (uint16_t)len;
-        uint8_t *p = (uint8_t*)pbuf;
-
-
-        totalSize = 0;
-
-        while(cntdn) {
-                //USB_HOST_SERIAL.println("");
-                //PrintHex<uint16_t>(offset + len - cntdn);
-                //USB_HOST_SERIAL.print(":");
-
-                ParseItem(&p, &cntdn);
-
-                //if (ParseItem(&p, &cntdn))
-                //        return;
-        }
-        //USBTRACE2("Total:", totalSize);
-}
-
-void ReportDescParserBase::PrintValue(uint8_t *p, uint8_t len) {
-        E_Notify(PSTR("("), 0x80);
-        for(; len; p++, len--)
-                PrintHex<uint8_t > (*p, 0x80);
-        E_Notify(PSTR(")"), 0x80);
-}
-
-void ReportDescParserBase::PrintByteValue(uint8_t data) {
-        E_Notify(PSTR("("), 0x80);
-        PrintHex<uint8_t > (data, 0x80);
-        E_Notify(PSTR(")"), 0x80);
-}
-
-void ReportDescParserBase::PrintItemTitle(uint8_t prefix) {
-        switch(prefix & (TYPE_MASK | TAG_MASK)) {
-                case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
-                        E_Notify(PSTR("\r\nPush"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_POP):
-                        E_Notify(PSTR("\r\nPop"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
-                        E_Notify(PSTR("\r\nUsage Page"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN):
-                        E_Notify(PSTR("\r\nLogical Min"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX):
-                        E_Notify(PSTR("\r\nLogical Max"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN):
-                        E_Notify(PSTR("\r\nPhysical Min"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX):
-                        E_Notify(PSTR("\r\nPhysical Max"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP):
-                        E_Notify(PSTR("\r\nUnit Exp"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
-                        E_Notify(PSTR("\r\nUnit"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
-                        E_Notify(PSTR("\r\nReport Size"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
-                        E_Notify(PSTR("\r\nReport Count"), 0x80);
-                        break;
-                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
-                        E_Notify(PSTR("\r\nReport Id"), 0x80);
-                        break;
-                case (TYPE_LOCAL | TAG_LOCAL_USAGE):
-                        E_Notify(PSTR("\r\nUsage"), 0x80);
-                        break;
-                case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
-                        E_Notify(PSTR("\r\nUsage Min"), 0x80);
-                        break;
-                case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
-                        E_Notify(PSTR("\r\nUsage Max"), 0x80);
-                        break;
-                case (TYPE_MAIN | TAG_MAIN_COLLECTION):
-                        E_Notify(PSTR("\r\nCollection"), 0x80);
-                        break;
-                case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
-                        E_Notify(PSTR("\r\nEnd Collection"), 0x80);
-                        break;
-                case (TYPE_MAIN | TAG_MAIN_INPUT):
-                        E_Notify(PSTR("\r\nInput"), 0x80);
-                        break;
-                case (TYPE_MAIN | TAG_MAIN_OUTPUT):
-                        E_Notify(PSTR("\r\nOutput"), 0x80);
-                        break;
-                case (TYPE_MAIN | TAG_MAIN_FEATURE):
-                        E_Notify(PSTR("\r\nFeature"), 0x80);
-                        break;
-        } // switch (**pp & (TYPE_MASK | TAG_MASK))
-}
-
-uint8_t ReportDescParserBase::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
-        //uint8_t ret = enErrorSuccess;
-        //reinterpret_cast<>(varBuffer);
-        switch(itemParseState) {
-                case 0:
-                        if(**pp == HID_LONG_ITEM_PREFIX)
-                                USBTRACE("\r\nLONG\r\n");
-                        else {
-                                uint8_t size = ((**pp) & DATA_SIZE_MASK);
-
-                                itemPrefix = (**pp);
-                                itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
-
-                                PrintItemTitle(itemPrefix);
-                        }
-                        (*pp)++;
-                        (*pcntdn)--;
-                        itemSize--;
-                        itemParseState = 1;
-
-                        if(!itemSize)
-                                break;
-
-                        if(!pcntdn)
-                                return enErrorIncomplete;
-                case 1:
-                        //USBTRACE2("\r\niSz:",itemSize);
-
-                        theBuffer.valueSize = itemSize;
-                        valParser.Initialize(&theBuffer);
-                        itemParseState = 2;
-                case 2:
-                        if(!valParser.Parse(pp, pcntdn))
-                                return enErrorIncomplete;
-                        itemParseState = 3;
-                case 3:
-                {
-                        uint8_t data = *((uint8_t*)varBuffer);
-
-                        switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
-                                case (TYPE_LOCAL | TAG_LOCAL_USAGE):
-                                        if(pfUsage) {
-                                                if(theBuffer.valueSize > 1) {
-                                                        uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
-                                                        pfUsage(*ui16);
-                                                } else
-                                                        pfUsage(data);
-                                        }
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
-                                        rptSize = data;
-                                        PrintByteValue(data);
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
-                                        rptCount = data;
-                                        PrintByteValue(data);
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN):
-                                case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX):
-                                case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN):
-                                case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX):
-                                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
-                                case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
-                                case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
-                                case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP):
-                                case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
-                                        PrintValue(varBuffer, theBuffer.valueSize);
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
-                                case (TYPE_GLOBAL | TAG_GLOBAL_POP):
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
-                                        SetUsagePage(data);
-                                        PrintUsagePage(data);
-                                        PrintByteValue(data);
-                                        break;
-                                case (TYPE_MAIN | TAG_MAIN_COLLECTION):
-                                case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
-                                        switch(data) {
-                                                case 0x00:
-                                                        E_Notify(PSTR(" Physical"), 0x80);
-                                                        break;
-                                                case 0x01:
-                                                        E_Notify(PSTR(" Application"), 0x80);
-                                                        break;
-                                                case 0x02:
-                                                        E_Notify(PSTR(" Logical"), 0x80);
-                                                        break;
-                                                case 0x03:
-                                                        E_Notify(PSTR(" Report"), 0x80);
-                                                        break;
-                                                case 0x04:
-                                                        E_Notify(PSTR(" Named Array"), 0x80);
-                                                        break;
-                                                case 0x05:
-                                                        E_Notify(PSTR(" Usage Switch"), 0x80);
-                                                        break;
-                                                case 0x06:
-                                                        E_Notify(PSTR(" Usage Modifier"), 0x80);
-                                                        break;
-                                                default:
-                                                        E_Notify(PSTR(" Vendor Defined("), 0x80);
-                                                        PrintHex<uint8_t > (data, 0x80);
-                                                        E_Notify(PSTR(")"), 0x80);
-                                        }
-                                        break;
-                                case (TYPE_MAIN | TAG_MAIN_INPUT):
-                                case (TYPE_MAIN | TAG_MAIN_OUTPUT):
-                                case (TYPE_MAIN | TAG_MAIN_FEATURE):
-                                        totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
-                                        rptSize = 0;
-                                        rptCount = 0;
-                                        E_Notify(PSTR("("), 0x80);
-                                        PrintBin<uint8_t > (data, 0x80);
-                                        E_Notify(PSTR(")"), 0x80);
-                                        break;
-                        } // switch (**pp & (TYPE_MASK | TAG_MASK))
-                }
-        } // switch (itemParseState)
-        itemParseState = 0;
-        return enErrorSuccess;
-}
-
-ReportDescParserBase::UsagePageFunc ReportDescParserBase::usagePageFunctions[] /*PROGMEM*/ = {
-        &ReportDescParserBase::PrintGenericDesktopPageUsage,
-        &ReportDescParserBase::PrintSimulationControlsPageUsage,
-        &ReportDescParserBase::PrintVRControlsPageUsage,
-        &ReportDescParserBase::PrintSportsControlsPageUsage,
-        &ReportDescParserBase::PrintGameControlsPageUsage,
-        &ReportDescParserBase::PrintGenericDeviceControlsPageUsage,
-        NULL, // Keyboard/Keypad
-        &ReportDescParserBase::PrintLEDPageUsage,
-        &ReportDescParserBase::PrintButtonPageUsage,
-        &ReportDescParserBase::PrintOrdinalPageUsage,
-        &ReportDescParserBase::PrintTelephonyPageUsage,
-        &ReportDescParserBase::PrintConsumerPageUsage,
-        &ReportDescParserBase::PrintDigitizerPageUsage,
-        NULL, // Reserved
-        NULL, // PID
-        NULL // Unicode
-};
-
-void ReportDescParserBase::SetUsagePage(uint16_t page) {
-        pfUsage = NULL;
-
-        if(VALUE_BETWEEN(page, 0x00, 0x11)) {
-                pfUsage = (usagePageFunctions[page - 1]);
-
-        } else {
-                switch(page) {
-                        case 0x14:
-                                pfUsage = &ReportDescParserBase::PrintAlphanumDisplayPageUsage;
-                                break;
-                        case 0x40:
-                                pfUsage = &ReportDescParserBase::PrintMedicalInstrumentPageUsage;
-                                break;
-                }
-        }
-}
-
-void ReportDescParserBase::PrintUsagePage(uint16_t page) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(page, 0x00, 0x11, w, E_Notify, usagePageTitles0, 0x80)
-        else output_if_between(page, 0x8b, 0x92, w, E_Notify, usagePageTitles1, 0x80)
-        else if(VALUE_BETWEEN(page, 0x7f, 0x84))
-                E_Notify(pstrUsagePageMonitor, 0x80);
-        else if(VALUE_BETWEEN(page, 0x83, 0x8c))
-                E_Notify(pstrUsagePagePower, 0x80);
-        else if(page > 0xfeff /* && page <= 0xffff */)
-                E_Notify(pstrUsagePageVendorDefined, 0x80);
-        else
-                switch(page) {
-                        case 0x14:
-                                E_Notify(pstrUsagePageAlphaNumericDisplay, 0x80);
-                                break;
-                        case 0x40:
-                                E_Notify(pstrUsagePageMedicalInstruments, 0x80);
-                                break;
-                        default:
-                                E_Notify(pstrUsagePageUndefined, 0x80);
-                }
-}
-
-void ReportDescParserBase::PrintButtonPageUsage(uint16_t usage) {
-        E_Notify(pstrSpace, 0x80);
-        E_Notify(PSTR("Btn"), 0x80);
-        PrintHex<uint16_t > (usage, 0x80);
-        E_Notify(PSTR("\r\n"), 0x80);
-        //USB_HOST_SERIAL.print(usage, HEX);
-}
-
-void ReportDescParserBase::PrintOrdinalPageUsage(uint16_t usage) {
-        E_Notify(pstrSpace, 0x80);
-        E_Notify(PSTR("Inst"), 0x80);
-        // Sorry, HEX for now...
-        PrintHex<uint16_t > (usage, 0x80);
-        E_Notify(PSTR("\r\n"), 0x80);
-        //USB_HOST_SERIAL.print(usage, DEC);
-}
-
-void ReportDescParserBase::PrintGenericDesktopPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x0a, w, E_Notify, genDesktopTitles0, 0x80)
-        else output_if_between(usage, 0x2f, 0x49, w, E_Notify, genDesktopTitles1, 0x80)
-        else output_if_between(usage, 0x7f, 0x94, w, E_Notify, genDesktopTitles2, 0x80)
-        else output_if_between(usage, 0x9f, 0xa9, w, E_Notify, genDesktopTitles3, 0x80)
-        else output_if_between(usage, 0xaf, 0xb8, w, E_Notify, genDesktopTitles4, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintSimulationControlsPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x0d, w, E_Notify, simuTitles0, 0x80)
-        else output_if_between(usage, 0x1f, 0x26, w, E_Notify, simuTitles1, 0x80)
-        else output_if_between(usage, 0xaf, 0xd1, w, E_Notify, simuTitles2, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintVRControlsPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x0b, w, E_Notify, vrTitles0, 0x80)
-        else output_if_between(usage, 0x1f, 0x22, w, E_Notify, vrTitles1, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintSportsControlsPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x05, w, E_Notify, sportsCtrlTitles0, 0x80)
-        else output_if_between(usage, 0x2f, 0x3a, w, E_Notify, sportsCtrlTitles1, 0x80)
-        else output_if_between(usage, 0x4f, 0x64, w, E_Notify, sportsCtrlTitles2, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintGameControlsPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x04, w, E_Notify, gameTitles0, 0x80)
-        else output_if_between(usage, 0x1f, 0x3a, w, E_Notify, gameTitles1, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintGenericDeviceControlsPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x1f, 0x27, w, E_Notify, genDevCtrlTitles, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintLEDPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x4e, w, E_Notify, ledTitles, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintTelephonyPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x08, w, E_Notify, telTitles0, 0x80)
-        else output_if_between(usage, 0x1f, 0x32, w, E_Notify, telTitles1, 0x80)
-        else output_if_between(usage, 0x4f, 0x54, w, E_Notify, telTitles2, 0x80)
-        else output_if_between(usage, 0x6f, 0x75, w, E_Notify, telTitles3, 0x80)
-        else output_if_between(usage, 0x8f, 0x9f, w, E_Notify, telTitles4, 0x80)
-        else output_if_between(usage, 0xaf, 0xc0, w, E_Notify, telTitles5, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintConsumerPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x07, w, E_Notify, consTitles0, 0x80)
-        else output_if_between(usage, 0x1f, 0x23, w, E_Notify, consTitles1, 0x80)
-        else output_if_between(usage, 0x2f, 0x37, w, E_Notify, consTitles2, 0x80)
-        else output_if_between(usage, 0x3f, 0x49, w, E_Notify, consTitles3, 0x80)
-        else output_if_between(usage, 0x5f, 0x67, w, E_Notify, consTitles4, 0x80)
-        else output_if_between(usage, 0x7f, 0xa5, w, E_Notify, consTitles5, 0x80)
-        else output_if_between(usage, 0xaf, 0xcf, w, E_Notify, consTitles6, 0x80)
-        else output_if_between(usage, 0xdf, 0xeb, w, E_Notify, consTitles7, 0x80)
-        else output_if_between(usage, 0xef, 0xf6, w, E_Notify, consTitles8, 0x80)
-        else output_if_between(usage, 0xff, 0x10e, w, E_Notify, consTitles9, 0x80)
-        else output_if_between(usage, 0x14f, 0x156, w, E_Notify, consTitlesA, 0x80)
-        else output_if_between(usage, 0x15f, 0x16b, w, E_Notify, consTitlesB, 0x80)
-        else output_if_between(usage, 0x16f, 0x175, w, E_Notify, consTitlesC, 0x80)
-        else output_if_between(usage, 0x17f, 0x1c8, w, E_Notify, consTitlesD, 0x80)
-        else output_if_between(usage, 0x1ff, 0x29d, w, E_Notify, consTitlesE, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintDigitizerPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x0e, w, E_Notify, digitTitles0, 0x80)
-        else output_if_between(usage, 0x1f, 0x23, w, E_Notify, digitTitles1, 0x80)
-        else output_if_between(usage, 0x2f, 0x47, w, E_Notify, digitTitles2, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintAlphanumDisplayPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        output_if_between(usage, 0x00, 0x03, w, E_Notify, aplphanumTitles0, 0x80)
-        else output_if_between(usage, 0x1f, 0x4e, w, E_Notify, aplphanumTitles1, 0x80)
-        else output_if_between(usage, 0x7f, 0x96, w, E_Notify, digitTitles2, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-void ReportDescParserBase::PrintMedicalInstrumentPageUsage(uint16_t usage) {
-        const char * const * w;
-        E_Notify(pstrSpace, 0x80);
-
-        if(usage == 1) E_Notify(pstrUsageMedicalUltrasound, 0x80);
-        else if(usage == 0x70)
-                E_Notify(pstrUsageDepthGainCompensation, 0x80);
-        else output_if_between(usage, 0x1f, 0x28, w, E_Notify, medInstrTitles0, 0x80)
-        else output_if_between(usage, 0x3f, 0x45, w, E_Notify, medInstrTitles1, 0x80)
-        else output_if_between(usage, 0x5f, 0x62, w, E_Notify, medInstrTitles2, 0x80)
-        else output_if_between(usage, 0x7f, 0x8a, w, E_Notify, medInstrTitles3, 0x80)
-        else output_if_between(usage, 0x9f, 0xa2, w, E_Notify, medInstrTitles4, 0x80)
-        else E_Notify(pstrUsagePageUndefined, 0x80);
-}
-
-uint8_t ReportDescParser2::ParseItem(uint8_t **pp, uint16_t *pcntdn) {
-        //uint8_t ret = enErrorSuccess;
-
-        switch(itemParseState) {
-                case 0:
-                        if(**pp == HID_LONG_ITEM_PREFIX)
-                                USBTRACE("\r\nLONG\r\n");
-                        else {
-                                uint8_t size = ((**pp) & DATA_SIZE_MASK);
-                                itemPrefix = (**pp);
-                                itemSize = 1 + ((size == DATA_SIZE_4) ? 4 : size);
-                        }
-                        (*pp)++;
-                        (*pcntdn)--;
-                        itemSize--;
-                        itemParseState = 1;
-
-                        if(!itemSize)
-                                break;
-
-                        if(!pcntdn)
-                                return enErrorIncomplete;
-                case 1:
-                        theBuffer.valueSize = itemSize;
-                        valParser.Initialize(&theBuffer);
-                        itemParseState = 2;
-                case 2:
-                        if(!valParser.Parse(pp, pcntdn))
-                                return enErrorIncomplete;
-                        itemParseState = 3;
-                case 3:
-                {
-                        uint8_t data = *((uint8_t*)varBuffer);
-
-                        switch(itemPrefix & (TYPE_MASK | TAG_MASK)) {
-                                case (TYPE_LOCAL | TAG_LOCAL_USAGE):
-                                        if(pfUsage) {
-                                                if(theBuffer.valueSize > 1) {
-                                                        uint16_t* ui16 = reinterpret_cast<uint16_t *>(varBuffer);
-                                                        pfUsage(*ui16);
-                                                } else
-                                                        pfUsage(data);
-                                        }
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
-                                        rptSize = data;
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
-                                        rptCount = data;
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
-                                        rptId = data;
-                                        break;
-                                case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
-                                        useMin = data;
-                                        break;
-                                case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
-                                        useMax = data;
-                                        break;
-                                case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
-                                        SetUsagePage(data);
-                                        break;
-                                case (TYPE_MAIN | TAG_MAIN_OUTPUT):
-                                case (TYPE_MAIN | TAG_MAIN_FEATURE):
-                                        rptSize = 0;
-                                        rptCount = 0;
-                                        useMin = 0;
-                                        useMax = 0;
-                                        break;
-                                case (TYPE_MAIN | TAG_MAIN_INPUT):
-                                        OnInputItem(data);
-
-                                        totalSize += (uint16_t)rptSize * (uint16_t)rptCount;
-
-                                        rptSize = 0;
-                                        rptCount = 0;
-                                        useMin = 0;
-                                        useMax = 0;
-                                        break;
-                        } // switch (**pp & (TYPE_MASK | TAG_MASK))
-                }
-        } // switch (itemParseState)
-        itemParseState = 0;
-        return enErrorSuccess;
-}
-
-void ReportDescParser2::OnInputItem(uint8_t itm) {
-        uint8_t byte_offset = (totalSize >> 3); // calculate offset to the next unhandled byte i = (int)(totalCount / 8);
-        uint32_t tmp = (byte_offset << 3);
-        uint8_t bit_offset = totalSize - tmp; // number of bits in the current byte already handled
-        uint8_t *p = pBuf + byte_offset; // current byte pointer
-
-        if(bit_offset)
-                *p >>= bit_offset;
-
-        uint8_t usage = useMin;
-
-        bool print_usemin_usemax = ((useMin < useMax) && ((itm & 3) == 2) && pfUsage) ? true : false;
-
-        uint8_t bits_of_byte = 8;
-
-        // for each field in field array defined by rptCount
-        for(uint8_t field = 0; field < rptCount; field++, usage++) {
-
-                union {
-                        uint8_t bResult[4];
-                        uint16_t wResult[2];
-                        uint32_t dwResult;
-                } result;
-
-                result.dwResult = 0;
-                uint8_t mask = 0;
-
-                if(print_usemin_usemax)
-                        pfUsage(usage);
-
-                // bits_left            - number of bits in the field(array of fields, depending on Report Count) left to process
-                // bits_of_byte         - number of bits in current byte left to process
-                // bits_to_copy         - number of bits to copy to result buffer
-
-                // for each bit in a field
-                for(uint8_t bits_left = rptSize, bits_to_copy = 0; bits_left;
-                        bits_left -= bits_to_copy) {
-                        bits_to_copy = (bits_left > bits_of_byte) ? bits_of_byte : bits_left;
-
-                        result.dwResult <<= bits_to_copy; // Result buffer is shifted by the number of bits to be copied into it
-
-                        uint8_t val = *p;
-
-                        val >>= (8 - bits_of_byte); // Shift by the number of bits already processed
-
-                        mask = 0;
-
-                        for(uint8_t j = bits_to_copy; j; j--) {
-                                mask <<= 1;
-                                mask |= 1;
-                        }
-
-                        result.bResult[0] = (result.bResult[0] | (val & mask));
-
-                        bits_of_byte -= bits_to_copy;
-
-                        if(bits_of_byte < 1) {
-                                bits_of_byte = 8;
-                                p++;
-                        }
-                }
-                PrintByteValue(result.dwResult);
-        }
-        E_Notify(PSTR("\r\n"), 0x80);
-}
-
-void UniversalReportParser::Parse(HID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf) {
-        ReportDescParser2 prs(len, buf);
-
-        uint8_t ret = hid->GetReportDescr(0, &prs);
-
-        if(ret)
-                ErrorMessage<uint8_t > (PSTR("GetReportDescr-2"), ret);
-}