Added new HID_ALIGN_DATA() macro to return the pre-retrieved value of a HID report item, left-aligned to a given datatype.
Added new PreviousValue to the HID Report Parser report item structure, for easy monitoring of previous report item values.
                        if (!(FoundData))\r
                          continue;\r
                          \r
-                       int16_t DeltaMovement = (int16_t)(ReportItem->Value << (16 - ReportItem->Attributes.BitSize));\r
+                       int16_t DeltaMovement = HID_ALIGN_DATA(ReportItem, int16_t);\r
                        \r
                        /* Determine if the report is for the X or Y delta movement */\r
                        if (ReportItem->Attributes.Usage.Usage == USAGE_X)\r
 
                        if (!(USB_GetHIDReportItemInfo(MouseReport, ReportItem)))\r
                          continue;                                                       \r
 \r
-                       int16_t WheelDelta = (int16_t)(ReportItem->Value << (16 - ReportItem->Attributes.BitSize));\r
+                       int16_t WheelDelta = HID_ALIGN_DATA(ReportItem, int16_t);\r
                        \r
                        if (WheelDelta)\r
                          LEDMask = (LEDS_LED1 | LEDS_LED2 | ((WheelDelta > 0) ? LEDS_LED3 : LEDS_LED4));\r
 
        HID_CollectionPath_t* CurrCollectionPath      = NULL;\r
        HID_ReportSizeInfo_t* CurrReportIDInfo        = &ParserData->ReportIDSizes[0];                  \r
        uint16_t              UsageList[HID_USAGE_STACK_DEPTH];\r
-       uint8_t               UsageListSize          = 0;\r
+       uint8_t               UsageListSize           = 0;\r
+       HID_MinMax_t          UsageMinMax             = {0, 0};\r
 \r
        memset(ParserData,       0x00, sizeof(HID_ReportInfo_t));\r
        memset(CurrStateTable,   0x00, sizeof(HID_StateTable_t));\r
                                UsageList[UsageListSize++] = ReportItemData;\r
                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):\r
-                               CurrStateTable->Attributes.Usage.MinMax.Minimum = ReportItemData;\r
+                               UsageMinMax.Minimum = ReportItemData;\r
                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):\r
-                               CurrStateTable->Attributes.Usage.MinMax.Maximum = ReportItemData;\r
+                               UsageMinMax.Maximum = ReportItemData;\r
                                break;\r
                        case (TYPE_MAIN | TAG_MAIN_COLLECTION):\r
                                if (CurrCollectionPath == NULL)\r
                                          \r
                                        UsageListSize--;\r
                                }\r
+                               else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)\r
+                               {\r
+                                       CurrCollectionPath->Usage.Usage = UsageMinMax.Minimum++;\r
+                               }\r
                                \r
                                break;\r
                        case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):\r
                                                  \r
                                                UsageListSize--;\r
                                        }\r
-\r
+                                       else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)\r
+                                       {\r
+                                               CurrCollectionPath->Usage.Usage = UsageMinMax.Minimum++;\r
+                                       }\r
+                               \r
                                        uint8_t ItemTag = (HIDReportItem & TAG_MASK);\r
 \r
                                        if (ItemTag == TAG_MAIN_INPUT)\r
          \r
                if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)\r
                {\r
-                       CurrStateTable->Attributes.Usage.MinMax.Minimum = 0;\r
-                       CurrStateTable->Attributes.Usage.MinMax.Maximum = 0;\r
-                       UsageListSize = 0;\r
+                       UsageMinMax.Minimum = 0;\r
+                       UsageMinMax.Maximum = 0;\r
+                       UsageListSize   = 0;\r
                }\r
        }\r
        \r
        uint16_t CurrentBit   = ReportItem->BitOffset;\r
        uint32_t BitMask      = (1 << 0);\r
 \r
+       ReportItem->PreviousValue = ReportItem->Value;\r
        ReportItem->Value = 0;\r
        \r
        if (ReportItem->ReportID)\r
                ReportData++;\r
        }\r
 \r
+       ReportItem->PreviousValue = ReportItem->Value;\r
+\r
        while (DataBitsRem--)\r
        {\r
                if (ReportItem->Value & (1 << (CurrentBit % 8)))\r
 
                        extern "C" {\r
                #endif\r
 \r
-       /* Preprocessor checks and defines: */\r
+       /* Macros: */\r
                #if !defined(HID_STATETABLE_STACK_DEPTH) || defined(__DOXYGEN__)\r
                        /** Constant indicating the maximum stack depth of the state table. A larger state table\r
                         *  allows for more PUSH/POP report items to be nested, but consumes more memory. By default\r
                        #define HID_MAX_REPORT_IDS            10\r
                #endif\r
 \r
+               /** Returns the value a given HID report item (once its value has been fetched via \ref USB_GetHIDReportItemInfo())\r
+                *  left-aligned to the given data type. This allows for signed data to be interpreted correctly, by shifting the data\r
+                *  leftwards until the data's sign bit is in the correct position.\r
+                *\r
+                *  \param[in] reportitem  HID Report Item whose retrieved value is to be aligned\r
+                *  \param[in] type  Data type to align the HID report item's value to\r
+                *\r
+                *  \return Left-aligned data of the given report item's pre-retrived value for the given datatype\r
+                */\r
+               #define HID_ALIGN_DATA(reportitem, type) ((type)(reportitem->Value << (sizeof(type) - reportitem->Attributes.BitSize)))\r
+\r
        /* Public Interface - May be used in end-application: */\r
                /* Enums: */                    \r
                        /** Enum for the possible error codes in the return value of the \ref USB_ProcessHIDReport() function */\r
                        {\r
                                uint16_t                     Page;   /**< Usage page of the report item. */\r
                                uint16_t                     Usage;  /**< Usage of the report item. */\r
-                               HID_MinMax_t                 MinMax; /**< Usage minimum and maximum of the report item. */\r
                        } HID_Usage_t;\r
 \r
                        /** Type define for a COLLECTION object. Contains the collection attributes and a reference to the\r
                                HID_ReportItem_Attributes_t  Attributes;     /**< Report item attributes. */\r
                                                        \r
                                uint32_t                     Value;          /**< Current value of the report item. */\r
+                               uint32_t                     PreviousValue;  /**< Previous value of the report item. */ \r
                        } HID_ReportItem_t;\r
                        \r
                        /** Type define for a report item size information structure */\r
                        /** Extracts the given report item's value out of the given HID report and places it into the Value\r
                         *  member of the report item's \ref HID_ReportItem_t structure.\r
                         *\r
+                        *  When called, this copies the report item's Value element to it's PreviousValue element for easy\r
+                        *  checking to see if an item's value has changed before processing a report.\r
+                        *\r
                         *  \param[in] ReportData  Buffer containing an IN or FEATURE report from an attached device\r
                         *  \param[in,out] ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array\r
                         *\r
                         *  buffer. The report buffer is assumed to have the appropriate bits cleared before calling\r
                         *  this function (i.e., the buffer should be explicitly cleared before report values are added).\r
                         *\r
+                        *  When called, this copies the report item's Value element to it's PreviousValue element for easy\r
+                        *  checking to see if an item's value has changed before sending a report.\r
+                        *\r
                         *  If the device has multiple HID reports, the first byte in the report is set to the report ID of the given item.\r
                         *\r
                         *  \param[out] ReportData  Buffer holding the current OUT or FEATURE report data\r
 
   *  - Added PDI programming support for XMEGA devices to the AVRISP programmer project\r
   *  - Added support for the XPLAIN board Dataflash, with new XPLAIN_REV1 board target for the different dataflash used\r
   *    on the first revision boards compared to the one mounted on later revisions\r
+  *  - Added new HID_ALIGN_DATA() macro to return the pre-retrieved value of a HID report item, left-aligned to a given datatype\r
+  *  - Added new PreviousValue to the HID Report Parser report item structure, for easy monitoring of previous report item values\r
   *\r
   *  <b>Changed:</b>\r
   *  - Removed code in the Keyboard demos to send zeroed reports between two reports with differing numbers of keycodes\r
   *  - Fixed misnamed Pipe_SetPipeToken() macro for setting a pipe's direction\r
   *  - Fixed CDCHost failing on devices with bidirectional endpoints\r
   *  - Fixed USB driver failing to define the PLL prescaler mask for the ATMEGA8U2 and ATMEGA16U2\r
+  *  - Fixed HID Parser not distributing the Usage Min and Usage Max values across an array of report items\r
   *\r
   *  \section Sec_ChangeLog091122 Version 091122\r
   *\r
 
  *      now named \ref SImage_Host_USBTask() and \ref SImage_Host_ConfigurePipes() respectively.\r
  *    - The HOST_SENDCONTROL_DeviceDisconnect enum value has been renamed to \ref HOST_SENDCONTROL_DeviceDisconnected to be in\r
  *      line with the rest of the library error codes.\r
+ *    - The HID Parser item usages no longer contain seperate minimum and maximum values, as this was a violation of the HID\r
+ *      specification. Instead, the values are distributed evenly across each item as its usage value, to ensure that all items\r
+ *      can be distinguished from oneanother.\r
  *\r
  *  <b>Device Mode</b>\r
  *    - The CALLBACK_HID_Device_CreateHIDReport() HID Device Class driver callback now has a new ReportType parameter to\r
 
                #include "V2Protocol.h"\r
                \r
        /* Preprocessor Checks: */\r
-               #if BOARD == BOARD_XPLAIN\r
+               #if (BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1)\r
                        #undef  ENABLE_ISP_PROTOCOL\r
                        \r
                        #if !defined(ENABLE_PDI_PROTOCOL)\r
 
                #include "V2ProtocolParams.h"\r
 \r
        /* Preprocessor Checks: */\r
-               #if BOARD == BOARD_XPLAIN\r
+               #if (BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1)\r
                        #undef  ENABLE_ISP_PROTOCOL\r
                        \r
                        #if !defined(ENABLE_PDI_PROTOCOL)\r
 
                #include "PDITarget.h"\r
 \r
        /* Preprocessor Checks: */\r
-               #if BOARD == BOARD_XPLAIN\r
+               #if (BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1)\r
                        #undef  ENABLE_ISP_PROTOCOL\r
                        \r
                        #if !defined(ENABLE_PDI_PROTOCOL)\r
 
 /** Writes a given byte to the attached XMEGA device, using a RS232 frame via software through the\r
  *  PDI interface.\r
  *\r
- *  \param Byte  Byte to send to the attached device\r
+ *  \param[in] Byte  Byte to send to the attached device\r
  */\r
 void PDITarget_SendByte(uint8_t Byte)\r
 {\r
 
                #include <LUFA/Common/Common.h>\r
        \r
        /* Preprocessor Checks: */\r
-               #if BOARD == BOARD_XPLAIN\r
+               #if (BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1)\r
                        #undef  ENABLE_ISP_PROTOCOL\r
                        \r
                        #if !defined(ENABLE_PDI_PROTOCOL)\r
 
                #include "PDIProtocol.h"\r
 \r
        /* Preprocessor Checks: */\r
-               #if BOARD == BOARD_XPLAIN\r
+               #if (BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1)\r
                        #undef  ENABLE_ISP_PROTOCOL\r
                        \r
                        #if !defined(ENABLE_PDI_PROTOCOL)\r