/*

* Copyright (c) 2002 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:   

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <mifconvdefs.h>

#include "AknIconLocationInfo.h"

#include "AknIconLoader.h"

// CONSTANTS

// ================= MEMBER FUNCTIONS ==========================================

CAknIconLocationInfo::CAknIconLocationInfo()

    {

    }

CAknIconLocationInfo::CAknIconLocationInfo( const TDesC& aFileName )

    {

    // This constructor is used when the object is instantiated in stack,

    // so CBase's zero initialization is not done.

    Mem::FillZ( this, sizeof( CAknIconLocationInfo ) );

    iFileNameRef = &aFileName;

    }

CAknIconLocationInfo::~CAknIconLocationInfo()

    {

    delete iFileName;

    delete [] iLocations;

    delete iSharedOffsets;

    }

CAknIconLocationInfo* CAknIconLocationInfo::NewL(

    const TDesC& aFileName,

    MifHeader::CInstance& aOffsets )

    {

    CAknIconLocationInfo* item = new( ELeave ) CAknIconLocationInfo;

    CleanupStack::PushL( item );

    item->ConstructL( aFileName, aOffsets );

    CleanupStack::Pop();

    return item;

    }

CAknIconLocationInfo* CAknIconLocationInfo::NewL(

    const TDesC& aFileName,

    const TDesC8& aOffsetArray )

    {

    CAknIconLocationInfo* item = new( ELeave ) CAknIconLocationInfo;

    CleanupStack::PushL( item );

    item->ConstructL( aFileName, aOffsetArray );

    CleanupStack::Pop();

    return item;

    }

CAknIconLocationInfo* CAknIconLocationInfo::NewL(

    const TDesC& aFileName )

    {

    CAknIconLocationInfo* item = new( ELeave ) CAknIconLocationInfo;

    CleanupStack::PushL( item );

    item->ConstructL( aFileName );

    CleanupStack::Pop();

    return item;

    }

void CAknIconLocationInfo::ConstructL(

    const TDesC& aFileName,

    MifHeader::CInstance& aOffsets )

    {

    iFileName = aFileName.AllocL();

    iSharedOffsets = MifHeader::CInstance::NewL(aOffsets.Ref());

    iCount = iSharedOffsets->indicies().Count();

    }

void CAknIconLocationInfo::ConstructL(

    const TDesC& aFileName,

    const TDesC8& aOffsetArray )

    {

    iFileName = aFileName.AllocL();

    if ( aOffsetArray.Size() % sizeof( TMifBitmapOffsetElement ) )

        {

        User::Leave( KErrCorrupt );

        }

    iCount = aOffsetArray.Size() / sizeof(TMifBitmapOffsetElement);

    // iCount must always be even number

    if (iCount % 2)

        {

        User::Leave( KErrCorrupt );   

        }

    iLocations = new( ELeave ) TInt[iCount];

    TMifBitmapOffsetElement* ptr = (TMifBitmapOffsetElement*)aOffsetArray.Ptr();

    for ( TInt i = 0 ; i < iCount ; i++ )

        {

        iLocations[i] = ptr->iOffset; // copy the offset variable in iLocations

        ptr++;

        }

    }

void CAknIconLocationInfo::ConstructL( const TDesC& aFileName )

    {

    iFileName = aFileName.AllocL();

    }

// -----------------------------------------------------------------------------

// CAknIconLocationInfo::LinearOrder

// -----------------------------------------------------------------------------

//

TInt CAknIconLocationInfo::LinearOrder(

    const CAknIconLocationInfo& aFirst,

    const CAknIconLocationInfo& aSecond )

    {

    const TDesC* firstFileName = aFirst.iFileNameRef ?

        aFirst.iFileNameRef : aFirst.iFileName;

    const TDesC* secondFileName = aSecond.iFileNameRef ?

        aSecond.iFileNameRef : aSecond.iFileName;

    return firstFileName->CompareF( *secondFileName );

    }

// -----------------------------------------------------------------------------

// CAknIconLocationInfo::GetIconLocation

// -----------------------------------------------------------------------------

//

TInt CAknIconLocationInfo::GetIconLocation(

    TInt16& aBitmapId, TInt16& aMaskId ) const

    {

    if ( !iLocations && !iSharedOffsets )

        {

        // V1 MIF file. IDs do not need to be changed.

        return KErrNone;

        }

    TInt16 bitmapId;

    // MBG indexes start from KMifIdFirst.

    TInt bitmapIndex = aBitmapId - KMifIdFirst;

    if ( bitmapIndex < 0 ||

         bitmapIndex >= iCount )

        {

        return KErrEof;

        }

    TInt offset;

    if (iLocations)

        {

        // Fetch the icon offset info from the offset array that is

        // retrieved from the MIF file

        offset = iLocations[bitmapIndex];

        }

    else

        {

        // Fetch the icon offset info from the offset array that is

        // stored in the shared MifHeader instance

        offset = iSharedOffsets->indicies()[bitmapIndex].iOffset;

        }

    // Negative or zero offset means that it is a MBM icon,

    // and the real icon index is then that offset changed to positive.

    if ( offset <= 0 )

        {

        bitmapId = -offset;

        }

    // Positive offset means that it is a MIF icon,

    // the original icon index (from MBG file) should be used in that case.

    else

        {

        bitmapId = aBitmapId;

        }

    // Mask used?

    if ( aMaskId >= 0 )

        {

        // MBG indexes start from KMifIdFirst.

        TInt maskIndex = aMaskId - KMifIdFirst;

        if ( maskIndex < 0 ||

             maskIndex >= iCount )

            {

            return KErrEof;

            }

        if (iLocations)

            offset = iLocations[maskIndex];

        else

            offset = iSharedOffsets->indicies()[maskIndex].iOffset;

        if ( offset <= 0 )

            {

            aMaskId = -offset;

            }            

        }

    aBitmapId = bitmapId;

    return KErrNone;

    }

//  End of File