/*
* Copyright (c) 2004-2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Report base class implementation
*
*/


#include "hidfield.h"
#include "hidtranslate.h"
#include "hidinterfaces.h"

const TUint KValueMask      = 0xFFFFFFFF;
const TUint KSignBitMask    = 0x80000000;
const TInt  KThreeLSB       = 7;
const TInt  KThreeLSBShift  = 3;
// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// GetIndexOfUsage()
// ---------------------------------------------------------------------------
//
TBool TReportUtils::GetIndexOfUsage(const CField* aField,
    TInt aUsageId, TInt& aUsageIndex)
    {
    TArray<TInt> usages(aField->UsageArray());

    if ( usages.Count() > 0 )
        {
        // Find the usage in the array
        for ( TInt i = 0; i < usages.Count(); i++ )
            {
            if ( usages[i] == aUsageId )
                {
                aUsageIndex = i;
                return ETrue;
                }
            }
        }
    else
        {
        // The field includes all usages between the min and max
        if ( aField->UsageMin() <= aUsageId && aUsageId <= aField->UsageMax() )
            {
            aUsageIndex = aUsageId - aField->UsageMin();
            return ETrue;
            }
        }

    return EFalse;
    }

// ---------------------------------------------------------------------------
// UsageAtIndex()
// ---------------------------------------------------------------------------
//
TInt TReportUtils::UsageAtIndex(const CField* aField, TInt aUsageIndex)
    {
    TInt usageId = 0;
    TArray<TInt> usages(aField->UsageArray());

    if ( usages.Count() > 0 )
        {
        if ( aUsageIndex < 0 )
            {
            // Null state for array control
            }
        else if ( aUsageIndex < usages.Count() )
            {
            // Get the usage ID from the set of possible usages
            usageId = usages[aUsageIndex];
            }
        else
            {
            // If there aren't enough usages in the set, the last one repeats
            usageId = usages[usages.Count() - 1];
            }
        }
    else
        {
        // Get the usage ID from the range
        if ( 0 <= aUsageIndex
                && aUsageIndex <= (aField->UsageMax() - aField->UsageMin()) )
            {
            usageId = aField->UsageMin() + aUsageIndex;
            }
        }

    return usageId;
    }

// ---------------------------------------------------------------------------
// WriteData()
// ---------------------------------------------------------------------------
//
TInt TReportUtils::WriteData(HBufC8& aData, const CField* aField,
    TInt aIndex, TInt aValue)
    {
    if ( 0 <= aIndex && aIndex < aField->Count() )
        {
        // The offset in bits from the start of the report to the value
        TInt offset = aField->Offset() + aIndex * aField->Size();

        // How many bits in the least significant byte are not part of the value
        TInt bitsToShift = offset & KThreeLSB;

        TUint mask = KValueMask >> ((KSizeOfByte * sizeof(TInt)) - aField->Size());
        mask <<= bitsToShift;
        aValue <<= bitsToShift;

        TPtr8 data = aData.Des();

        // Write out the bytes, least significant first
        for ( TInt i = offset >> KThreeLSBShift; mask && i < aData.Length(); i++ )
            {
            TUint8 maskByte = static_cast<TUint8>(mask);

            // The extra cast is because MSVC6 thinks that or-ing 2
            // TUint8s together gives an int.
            data[i] = static_cast<TUint8>(
                (static_cast<TUint8>(aValue) & maskByte)
                | (aData[i] & ~maskByte));
            mask >>= KSizeOfByte;
            aValue >>= KSizeOfByte;
            }

        return KErrNone;
        }

    return KErrBadControlIndex;
    }

// ---------------------------------------------------------------------------
// ReadData()
// ---------------------------------------------------------------------------
//
TInt TReportUtils::ReadData(const TDesC8& aData, const CField* aField,
    TInt aIndex, TInt& aValue)
    {
    if ( 0 <= aIndex && aIndex < aField->Count() )
        {
        // The offset in bits from the start of the report to the value
        TInt offset = aField->Offset() + aIndex * aField->Size();

        // How many bits in the least significant byte are not part of
        // the value
        TInt bitsToShift = offset & KThreeLSB;

        // How many consecutive bytes we need to read to get the whole
        // value. According to the HID spec, a value cannot span more
        // than 4 bytes in a report
        TInt bytesToRead = (bitsToShift + aField->Size() + KThreeLSB) / KSizeOfByte;

        // Make sure we don't read past the end of the data
        if ( (offset >> KThreeLSBShift) + bytesToRead > aData.Length() )
            {
            bytesToRead = aData.Length() - (offset >> KThreeLSBShift);
            }

        TInt value = 0;

        // Read in the bytes, most significant first
        for ( TInt i = bytesToRead - 1; i >= 0; i-- )
            {
            value = (value << KSizeOfByte) | aData[(offset >> KThreeLSBShift) + i];
            }

        value >>= bitsToShift;

        // Make masks for the whole value and just the sign bit
        TUint valueMask = KValueMask >> ((KSizeOfByte * sizeof(TInt)) - aField->Size());
        TUint signMask = KSignBitMask >> ((KSizeOfByte * sizeof(TInt)) - aField->Size());

        if ( aField->LogicalMin() < 0 && (value & signMask) )
            {
            // The value is negative, so the leading bits should be 1s
            aValue = value | ~valueMask;
            }
        else
            {
            // The value is positive, so the leading bits should be 0s
            aValue = value & valueMask;
            }

        return KErrNone;
        }

    return KErrBadControlIndex;
    }