/*

* Copyright (c) 2003-2008 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:  Memory chunk lookup.

*

*/

// INCLUDE FILES

#include <AknsSrvChunkLookup.h>

#include "AknsSrvChunkMaintainer.h"

#include "AknsSrvItemDef.h"

#include <AknsImageAttributeData.h>

#include "AknsSrvChunkMaintainer.h"

#include "AknsSrvDescriptorFileLayout.h"

#include <AknsConstants.h>

#include <fbs.h>

#include "AknsDebug.h"

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

// C++ default constructor.

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

//

CAknsSrvChunkLookup::CAknsSrvChunkLookup()

    {

    }

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

// Destructor.

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

//

CAknsSrvChunkLookup::~CAknsSrvChunkLookup()

    {

    iSharedChunk.Close();

    iWaitSema.Close();

    iRenderMutex.Close();

    }

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

// Symbian 1st phase constructor.

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

//

CAknsSrvChunkLookup* CAknsSrvChunkLookup::NewL()

    {

    CAknsSrvChunkLookup* self = new (ELeave) CAknsSrvChunkLookup();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian 2nd phase constructor.

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

//

void CAknsSrvChunkLookup::ConstructL()

    {

    // Open the chunk in read only mode.

    User::LeaveIfError(

        iSharedChunk.OpenGlobal(KAKNSSRVSHAREDMEMORYCHUNKNAME, ETrue) );

    User::LeaveIfError(

        iWaitSema.OpenGlobal(KAKNSSRVWAITSEMAPHORENAME) );

    User::LeaveIfError(

        iRenderMutex.OpenGlobal(KAKNSSRVRENDERMUTEXNAME) );

    }

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

// RAknsSrvSession::LookupAndCreateDefL

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

//

EXPORT_C CAknsItemDef* CAknsSrvChunkLookup::LookupAndCreateDefL(

    const TAknsItemID& aID )

    {

    CAknsItemDef* itemdef = NULL;

    TAknsSrvMPPtr<TAknsSrvDef*>* defptr = NULL;

    TAknsItemType itemtype = EAknsITUnknown;

    //TAknsItemID* itemid = NULL;

    TInt* baseptr;

    // special case trying to search non-existent item, just return in that case

    if (aID == KAknsIIDNone)

        {

        return NULL;

        }

    // Block write access to the shared memory chunk.

    BeginRead();

    TUint32* chunkAddr = reinterpret_cast<TUint32*>(iSharedChunk.Base());

    TBool found = EFalse;

    //TInt defcount = chunkAddr[EAknsSrvItemDefAreaCurrentSizeOffset] / sizeof(TAknsSrvDef);

    TUint hashindex = (TUint)(aID.iMajor + aID.iMinor) % 128;

    TAknsSrvHashTable* h = reinterpret_cast<TAknsSrvHashTable*>(chunkAddr +

                (chunkAddr[EAknsSrvItemDefHashBaseOffset])/4 +

                hashindex* sizeof(TAknsSrvHashTable)/4);

    TAknsSrvDef* item = NULL;

    if ( h->iHead >= 0 )

        {

        TInt def = h->iHead;

        while ( def >= 0)

            {

            item = reinterpret_cast<TAknsSrvDef*>(chunkAddr +

                            (chunkAddr[EAknsSrvItemDefAreaBaseOffset])/4 +

                            def* sizeof(TAknsSrvDef)/4);

            if (TAknsItemID::LinearOrder( aID, item->iID) == 0 )

                {

                found = ETrue;

                chunkAddr = chunkAddr+

                    ((chunkAddr[EAknsSrvItemDefAreaBaseOffset])/4)+

                    def* sizeof(TAknsSrvDef)/4;

                break;

                }

            def = item->iHashNext;

            }

         }

    if (!found)

        {

        // Reached the end of the lookup table and found no match

        EndRead();

        return NULL;

        }

    itemtype = static_cast<TAknsItemType>(*(chunkAddr+2));

    defptr = reinterpret_cast<TAknsSrvMPPtr<TAknsSrvDef*>*>(chunkAddr+3);

    TInt creationError = KErrNone;

    if (defptr->iPtrType == EAknsSrvMPPtrAbsoluteROM)

        {

        baseptr = NULL;

        TRAP( creationError,

            (itemdef=CreateUnprotectedL( aID, defptr->Address(baseptr), itemtype,

            baseptr )) );

        }

    else

        {

        baseptr = (TInt*)iSharedChunk.Base();

        TRAP( creationError,

            (itemdef=CreateUnprotectedL( aID, defptr->Address(baseptr+(baseptr[3]/4)), itemtype,

            baseptr )) );

        }

    // Reading done, allow writes to the shared memory again.

    EndRead();

    if( creationError != KErrNone )

        {

        User::Leave( creationError );

        }

    return itemdef;

    }

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

// CAknsSrvChunkLookup::LookupAndCreateScalableItemL

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

//

EXPORT_C void CAknsSrvChunkLookup::LookupAndCreateScalableItemL(

    const TAknsItemID& aID, const TInt aLayout, const TSize& aLayoutSize, CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask, TInt& aMorphing)

    {

    BeginRead();

    TRAPD( err, LookupAndCreateScalableItemUnprotectedL(

        aID, aLayout, aLayoutSize,  aBitmap, aMask,aMorphing ) );

    EndRead();

    if( err )

        {

        User::Leave( err );

        }

    }

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

// CAknsSrvChunkLookup::BeginRead

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

//

void CAknsSrvChunkLookup::BeginRead()

    {

    // Wait if there is a write in progress.

    iWaitSema.Wait();

    }

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

// CAknsSrvChunkLookup::EndRead

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

//

void CAknsSrvChunkLookup::EndRead()

    {

    iWaitSema.Signal();

    }

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

// CAknsSrvChunkLookup::BeginRender

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

//

EXPORT_C void CAknsSrvChunkLookup::BeginRender()

    {

    // Wait if there is a rendering operation in progress...

    iRenderMutex.Wait();

    }

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

// CAknsSrvChunkLookup::EndRender

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

//

EXPORT_C void CAknsSrvChunkLookup::EndRender()

    {

    iRenderMutex.Signal();

    }

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

// RAknsSrvSession::Reserved

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

//

EXPORT_C TInt CAknsSrvChunkLookup::Reserved()

    {

    return 0;

    }

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

// CAknsSrvChunkLookup::CreateUnprotectedL

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

//

CAknsItemDef* CAknsSrvChunkLookup::CreateUnprotectedL( const TAknsItemID& aID,

    const TAny* aDef, const TAknsItemType aType, const TAny* aBasePtr )

    {

    CAknsItemDef* itemdef = NULL;

    TInt* baseptr = (TInt*)aBasePtr;

    switch( aType )

        {

        case EAknsITBitmap:

            {

            if (baseptr)

                {

                baseptr = baseptr+(baseptr[EAknsSrvFilenameAreaBaseOffset]/4);

                }

            const TAknsSrvBitmapDef* def =

                reinterpret_cast<const TAknsSrvBitmapDef*>(aDef);

            itemdef = CAknsBitmapItemDef::NewL( aID,

                TPtrC(def->iFilename.Address(baseptr)),

                def->iIndex);

            CleanupStack::PushL( itemdef );

            TAknsImageAttributeData attr;

            attr.iAttributes =

                static_cast<TAknsImageAttribute>(def->iImageAttributes);

            attr.iAlignment =

                static_cast<TAknsImageAlignment>(def->iImageAlignment);

            attr.iCoords = TPoint( def->iImageCoordX, def->iImageCoordY );

            attr.iSize = TSize( def->iImageSizeW, def->iImageSizeH );

            static_cast<CAknsImageItemDef*>(itemdef)->SetAttributesL( attr );

            CleanupStack::Pop( itemdef );

            break;

            }

        case EAknsITMaskedBitmap:

            {

            if (baseptr)

                {

                baseptr = baseptr+(baseptr[EAknsSrvFilenameAreaBaseOffset]/4);

                }

            const TAknsSrvMaskedBitmapDef* def =

                reinterpret_cast<const TAknsSrvMaskedBitmapDef*>(aDef);

            itemdef = CAknsMaskedBitmapItemDef::NewL(aID,

                TPtrC(def->iFilename.Address(baseptr)),  def->iIndex,

                def->iMaskIndex);

            CleanupStack::PushL( itemdef );

            TAknsImageAttributeData attr;

            attr.iAttributes =

                static_cast<TAknsImageAttribute>(def->iImageAttributes);

            attr.iAlignment =

                static_cast<TAknsImageAlignment>(def->iImageAlignment);

            attr.iCoords = TPoint( def->iImageCoordX, def->iImageCoordY );

            attr.iSize = TSize( def->iImageSizeW, def->iImageSizeH );

            static_cast<CAknsImageItemDef*>(itemdef)->SetAttributesL( attr );

            CleanupStack::Pop( itemdef );

            break;

            }

        case EAknsITColorTable:

            {

            if (baseptr)

                {

                baseptr = baseptr+(baseptr[EAknsSrvDataAreaBaseOffset]/4);

                }

            const TAknsSrvColorTableDef* def =

                reinterpret_cast<const TAknsSrvColorTableDef*>(aDef);

            itemdef = CAknsColorTableItemDef::NewL( aID,

                def->iNumberOfColors, def->iColors.Address(baseptr) );

            CleanupStack::PushL( itemdef );

            TAknsImageAttributeData attr;

            attr.iAttributes =

                static_cast<TAknsImageAttribute>(def->iImageAttributes);

            attr.iAlignment =

                static_cast<TAknsImageAlignment>(def->iImageAlignment);

            attr.iCoords = TPoint( def->iImageCoordX, def->iImageCoordY );

            attr.iSize = TSize( def->iImageSizeW, def->iImageSizeH );

            static_cast<CAknsImageItemDef*>(itemdef)->SetAttributesL( attr );

            CleanupStack::Pop( itemdef );

            break;

            }

        case EAknsITImageTable:

            {

            if (baseptr)

                {

                baseptr = baseptr+(baseptr[EAknsSrvDataAreaBaseOffset]/4);

                }

            const TAknsSrvImageTableDef* def =

                reinterpret_cast<const TAknsSrvImageTableDef*>(aDef);

            itemdef = CAknsImageTableItemDef::NewL(aID,

                def->iNumberOfImages,

                def->iImages.Address(baseptr));

            CleanupStack::PushL( itemdef );

            TAknsImageAttributeData attr;

            attr.iAttributes =

                static_cast<TAknsImageAttribute>(def->iImageAttributes);

            attr.iAlignment =

                static_cast<TAknsImageAlignment>(def->iImageAlignment);

            attr.iCoords = TPoint( def->iImageCoordX, def->iImageCoordY );

            attr.iSize = TSize( def->iImageSizeW, def->iImageSizeH );

            static_cast<CAknsImageItemDef*>(itemdef)->SetAttributesL( attr );

            CleanupStack::Pop( itemdef );

            break;

            }

        case EAknsITBmpAnim:

            {

            if (baseptr)

                {

                baseptr = baseptr+(baseptr[EAknsSrvDataAreaBaseOffset]/4);

                }

            const TAknsSrvBmpAnimDef* def =

                reinterpret_cast<const TAknsSrvBmpAnimDef*>(aDef);

            itemdef = CAknsBmpAnimItemDef::NewL( aID,

                def->iNumberOfImages,

                def->iImages.Address(baseptr),

                def->iFrameInfos.Address(baseptr) );

            CleanupStack::PushL( itemdef );

            TAknsImageAttributeData attr;

            attr.iAttributes =

                static_cast<TAknsImageAttribute>(def->iImageAttributes);

            attr.iAlignment =

                static_cast<TAknsImageAlignment>(def->iImageAlignment);

            attr.iCoords = TPoint( def->iImageCoordX, def->iImageCoordY );

            attr.iSize = TSize( def->iImageSizeW, def->iImageSizeH );

            static_cast<CAknsImageItemDef*>(itemdef)->SetAttributesL( attr );

            static_cast<CAknsBmpAnimItemDef*>(itemdef)->SetLastFrameBackground(

                def->iLastFrameBackground );

            static_cast<CAknsBmpAnimItemDef*>(itemdef)->SetFrameInterval(

                def->iFrameInterval );

            static_cast<CAknsBmpAnimItemDef*>(itemdef)->SetPlayMode(

                def->iPlayMode );

            static_cast<CAknsBmpAnimItemDef*>(itemdef)->SetFlash(

                def->iFlash );

            CleanupStack::Pop( itemdef );

            break;

            }

        case EAknsITString:

            {

            if (baseptr)

                {

                baseptr = baseptr+(baseptr[EAknsSrvDataAreaBaseOffset]/4);

                }

            const TAknsSrvStringDef* def =

                reinterpret_cast<const TAknsSrvStringDef*>(aDef);

            itemdef = CAknsStringItemDef::NewL( aID );

            CleanupStack::PushL( itemdef );

            TPtrC string( def->iString.Address(baseptr) );

            static_cast<CAknsStringItemDef*>(itemdef)->SetStringL(

                 string );

            CleanupStack::Pop( itemdef );

            break;

            }

        case EAknsITEffectQueue:

            {

            // Create def from raw data

            itemdef = CreateEffectQueueL( aID, aDef, aBasePtr );

            break;

            }

        case EAknsITAnimation:

            {

            // Create def from raw data

            itemdef = CreateAnimationL( aID, aDef, aBasePtr );

            break;

            }

        case EAknsITUnknown:

        case EAknsITImage:

        default:

            {

            User::Leave(KErrUnknown);

            break;

            }

        }

    return itemdef;

    }

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

// CAknsSrvChunkLookup::LookupAndCreateScalableItemUnprotectedL

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

//

void CAknsSrvChunkLookup::LookupAndCreateScalableItemUnprotectedL(

    const TAknsItemID& aID, const TInt aLayout, const TSize& aLayoutSize, CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask, TInt& aMorphing)

    {

    TTime currenttime;

    currenttime.HomeTime();

    TUint32* chunkAddr = reinterpret_cast<TUint32*>(iSharedChunk.Base());

    TInt defcount = chunkAddr[EAknsSrvScalableGfxAreaCurrentSizeOffset] /

        sizeof(TAknsSrvScalableItemDef);

    chunkAddr = chunkAddr+((chunkAddr[EAknsSrvScalableGfxAreaBaseOffset])/4);

    TAknsSrvScalableItemDef* table = (TAknsSrvScalableItemDef*)(chunkAddr);

    TInt bitmapHandle = 0;

    TInt maskHandle = 0;

    for (TInt index = 0; index < defcount; index++)

        {

        if ((table[index].iID == aID) &&

            (table[index].iLayoutType == aLayout) &&

            (table[index].iLayoutSize == aLayoutSize))

            {

            bitmapHandle = table[index].iBitmapHandle;

            if (table[index].iMaskHandle)

                {

                maskHandle = table[index].iMaskHandle;

                }

            // Update timestamp

            table[index].iTimeStamp = currenttime;

            aMorphing = table[index].isMorphing;

            break; // Break the loop, a match was found.

            }

        }

    // Avoid unnecessary duplicating

    if( bitmapHandle && aBitmap && (aBitmap->Handle()==bitmapHandle) )

        {

        if( (!maskHandle) && (!aMask) )

            {

            // No mask, everything OK.

            return;

            }

        if( maskHandle && aMask && (aMask->Handle()==maskHandle) )

            {

            // Mask is the same as well

            return;

            }

        }

    // Initialize to NULL and destroy any previous bitmaps

    delete aBitmap;

    aBitmap = NULL;

    delete aMask;

    aMask = NULL;

    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL( bitmap ); // (1)

    CFbsBitmap* mask = new (ELeave) CFbsBitmap;

    CleanupStack::PushL( mask ); // (2)

    if( bitmapHandle )

        {

        User::LeaveIfError( bitmap->Duplicate( bitmapHandle ) );

        if( maskHandle )

            {

            User::LeaveIfError( mask->Duplicate( maskHandle ) );

            }

        else

            {

            CleanupStack::PopAndDestroy(1); // mask (1)

            mask = NULL;

            CleanupStack::PushL( mask ); // (2)

            }

        CleanupStack::Pop(2); // mask, bitmap (0)

        aBitmap = bitmap;

        aMask = mask;

        }

    else

        {

        // No match

        CleanupStack::PopAndDestroy(2); // mask, bitmap (0)

        }

    }