/*

* Copyright (c) 2007-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:  image provider for liw buffer

*

*/

#include <fbs.h>

#include <AknsSkinInstance.h>

#include <AknsUtils.h>

#include <liwcommon.h>

#include <liwbufferextension.h>

#include <s32mem.h>

#include "hnattrimgprovliwimage.h"

#include "hnextbmpiconholder.h"

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

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

// 

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

//

CHnAttrImgProvLiwImage::CHnAttrImgProvLiwImage()

    {

    }

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

// 

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

//

void CHnAttrImgProvLiwImage::ConstructL( TLiwVariant*& aBitmap, 

                                         TLiwVariant*& aMaskBitmap )

    {

    ASSERT( aBitmap );

    CFbsBitmap* mask = NULL;

    CFbsBitmap* bitmap = CreateBitmapFromVariantL( *aBitmap );

    if ( bitmap )

        {

        if( aMaskBitmap )

            {

            mask = CreateBitmapFromVariantL( *aMaskBitmap );

            }

        CreateIconL( bitmap, mask );

        }

    else if ( aBitmap->TypeId() == LIW::EVariantTypeBuffer )

        {

        CLiwBitmapBuffer* bmpBuff =

            static_cast<CLiwBitmapBuffer*>( aBitmap->AsBuffer() ); 

        CLiwBitmapBuffer* maskBuff =

            static_cast<CLiwBitmapBuffer*>(

                    aMaskBitmap ? aMaskBitmap->AsBuffer() : NULL );

        if ( bmpBuff )

            {

            bitmap = bmpBuff->AsBitmap();

            }

        if ( maskBuff )

            {

            mask = maskBuff->AsBitmap();

            }

        if ( bitmap )

            {

            CreateExtIconL( bitmap, mask, bmpBuff, maskBuff );

            }

        }

    if ( !bitmap )

        {

        //No point to keep variant as bitmap was not created

        aBitmap->Reset();

        delete aBitmap;

        aBitmap = NULL;

        }

    if ( aMaskBitmap && !mask )

        {

        //No point to keep variant as bitmap was not created

        aMaskBitmap->Reset();

        delete aMaskBitmap;

        aMaskBitmap = NULL;

        }

    }

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

// 

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

//

void CHnAttrImgProvLiwImage::CreateExtIconL( CFbsBitmap* aBitmap,

        CFbsBitmap* aMask, CLiwBitmapBuffer* aExtBmp,

        CLiwBitmapBuffer* aExtMask )

    {

    // the condition in the assertion below means: if you provide aMask then

    // you must also provide aExtMask

    __ASSERT_DEBUG( aBitmap && aExtBmp && ( !aMask || aExtMask ),

            User::Invariant() );

    CGulIcon* newIcon = CGulIcon::NewL( aBitmap, aMask );

    CleanupStack::PushL( newIcon );

    newIcon->SetBitmapsOwnedExternally( ETrue );

    CHnExtBmpIconHolder *newIconHolder = new (ELeave) CHnExtBmpIconHolder();

    newIconHolder->SetGulIcon( newIcon , aExtBmp, aExtMask );

    CleanupStack::Pop( newIcon );

    if ( iIconHolder )

        {

        iIconHolder->Close();

        }

    iIconHolder = newIconHolder;

    }

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

// 

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

//

EXPORT_C CHnAttrImgProvLiwImage* CHnAttrImgProvLiwImage::NewL( 

        TLiwVariant*& aBitmap, TLiwVariant*& aMaskBitmap )

    {

    CHnAttrImgProvLiwImage* self = NewLC( aBitmap, aMaskBitmap );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

EXPORT_C CHnAttrImgProvLiwImage* CHnAttrImgProvLiwImage::NewLC( 

        TLiwVariant*& aBitmap, TLiwVariant*& aMaskBitmap )

    {

    CHnAttrImgProvLiwImage* self = new( ELeave ) CHnAttrImgProvLiwImage;

    CleanupStack::PushL( self );

    self->ConstructL( aBitmap, aMaskBitmap );

    return self;

    }

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

// 

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

//

CHnAttrImgProvLiwImage::~CHnAttrImgProvLiwImage()

    {

    }

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

// 

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

//

void CHnAttrImgProvLiwImage::RemoveLiwObjects()

    {

    if ( iIconHolder )

        {

        iIconHolder->Close();

        iIconHolder = NULL;

        }

    }

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

// 

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

//

const TDesC8& CHnAttrImgProvLiwImage::Value( )

    {

    return iValue;

    }

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

// 

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

//    

CFbsBitmap* CHnAttrImgProvLiwImage::CreateBitmapFromVariantL( 

                                                const TLiwVariant& aVariant )

    {

    CFbsBitmap* bitmap( NULL );

    TInt handle = 0;

    if ( ExtractBitmapHandleFromVariant( aVariant, handle ) == KErrNone )

        {

        CFbsBitmap* tempBitmap  = new( ELeave ) CFbsBitmap;

        if ( tempBitmap->Duplicate( handle ) == KErrNone )

            {

            bitmap = tempBitmap;

            }

        else

            {

            delete tempBitmap;

            }

        }

    else if ( aVariant.TypeId() == LIW::EVariantTypeDesC8 )

        {

        CFbsBitmap* tempBitmap = new ( ELeave ) CFbsBitmap;

        CleanupStack::PushL( tempBitmap );

        TPtrC8 buf = aVariant.AsData();

        RDesReadStream stream( buf );

        CleanupClosePushL( stream );

        tempBitmap->InternalizeL( stream );

        CleanupStack::PopAndDestroy( &stream );

        CleanupStack::Pop( tempBitmap );

        bitmap = tempBitmap;

        }

    return bitmap;

    }

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

// 

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

//  

TInt CHnAttrImgProvLiwImage::ExtractBitmapHandleFromVariant(

        const TLiwVariant& aVariant, TInt& aHandle )

    {

    TInt err = KErrNone;

    switch ( aVariant.TypeId() )

        {

        case LIW::EVariantTypeTInt32:

            aHandle = static_cast<TInt>( aVariant.AsTInt32() );         

            break;

        case LIW::EVariantTypeTUint:

            aHandle = static_cast<TInt>( aVariant.AsTUint() );         

            break;

        case LIW::EVariantTypeTInt64:

            aHandle = static_cast<TInt>( aVariant.AsTInt64() );         

            break;

        case LIW::EVariantTypeTBool:

            // Putting a TInt into a TLiwVariant will result in the variant

            // storing a TBool variable. CFbsBitmap::Handle() returns TInt, so

            // we can assume that the TBool stored in aVariant is in fact TInt.

            aHandle = static_cast<TInt>( aVariant.AsTBool() );

            break;

        default:

            err = KErrNotFound;

        }

    return err;

    }