/*

* Copyright (c) 2004-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:  Defines an internal class CAknsTemporaryBitmap which

*                encapsulates a single temporary bitmap entry.

*

*/

// INCLUDE FILES

#include "AknsTemporaryBitmap.h"

#include <fbs.h>

#include <bitdev.h>

#include "AknsDebug.h"

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

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

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CAknsTemporaryBitmap::CAknsTemporaryBitmap( const TAknsItemID& aID,

    const TSize& aSize, const TInt aKey, const TSize& aLayoutSize )

    // Explicit initialization required here!

    : iID( aID ), iSize( aSize ), iKey( aKey ),

      iData( NULL ), iDev( NULL ), iGc( NULL ), iMorphing( EFalse ),

      iLayoutSize(aLayoutSize)

    {

    }

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

// Two-phased constructor.

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

//

CAknsTemporaryBitmap* CAknsTemporaryBitmap::NewL( const TAknsItemID& aID,

    const TSize& aSize, const TInt aKey, const TBool aMorphing, const TSize& aLayoutSize )

    {

    CAknsTemporaryBitmap* self =

        new (ELeave) CAknsTemporaryBitmap( aID, aSize, aKey, aLayoutSize );

    // This value set outside constructor (to not confuse parameter construction

    // for LinearOrder-based comparisons)

    self->iMorphing = aMorphing;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor (2nd phase).

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

//

void CAknsTemporaryBitmap::ConstructL()

    {

    iData = CAknsMaskedBitmapItemData::NewL();

    }

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

// Destructor

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

//

CAknsTemporaryBitmap::~CAknsTemporaryBitmap()

    {

    delete iData;

    delete iDev;

    delete iGc;

    }

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

// CAknsTemporaryBitmap::Bitmap

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

//

CFbsBitmap* CAknsTemporaryBitmap::Bitmap()

    {

    return iData->Bitmap();

    }

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

// CAknsTemporaryBitmap::Mask

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

//

CFbsBitmap* CAknsTemporaryBitmap::Mask()

    {

    return iData->Mask();

    }

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

// CAknsTemporaryBitmap::ItemData

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

//

CAknsMaskedBitmapItemData* CAknsTemporaryBitmap::ItemData()

    {

    return iData;

    }

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

// CAknsTemporaryBitmap::IsMorphing

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

//

TBool CAknsTemporaryBitmap::IsMorphing()

    {

    return iMorphing;

    }

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

// CAknsTemporaryBitmap::ActivateGcL

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

//

CFbsBitGc* CAknsTemporaryBitmap::ActivateGcL(

    const TDisplayMode aMode, const TBool aMask )

    {

    CFbsBitmap* bmp = NULL;

    if( !aMask )

        {

        bmp = new (ELeave) CFbsBitmap();

        CleanupStack::PushL( bmp );

        User::LeaveIfError( bmp->Create( iSize, aMode ) );

        CleanupStack::Pop( bmp );

        iData->DestroyAndSetBitmap( bmp );

        }

    else

        {

        bmp = new (ELeave) CFbsBitmap();

        CleanupStack::PushL( bmp );

        User::LeaveIfError( bmp->Create( iSize, aMode ) );

        CleanupStack::Pop( bmp );

        iData->DestroyAndSetMask( bmp );

        }

    if ( iDev )

        {

        delete iDev;

        iDev = NULL;

        }

    iDev = CFbsBitmapDevice::NewL( bmp );

    iDev->Resize( iSize );

    if ( iGc )

        {

        delete iGc;

        iGc = NULL;

        }

    iGc = CFbsBitGc::NewL();

    iGc->Activate( iDev );

    return iGc;

    }

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

// CAknsTemporaryBitmap::ReleaseGc

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

//

void CAknsTemporaryBitmap::ReleaseGc()

    {

    delete iGc;

    iGc = NULL;

    delete iDev;

    iDev = NULL;

    }

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

// CAknsTemporaryBitmap::LinearOrder

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

//

TInt CAknsTemporaryBitmap::LinearOrder(

    const CAknsTemporaryBitmap& aFirst,

    const CAknsTemporaryBitmap& aSecond )

    {

    TInt idDiff = TAknsItemID::LinearOrder( aFirst.iID, aSecond.iID );

    if( !idDiff )

        {

        TInt keyDiff = aFirst.iKey - aSecond.iKey;

        if( !keyDiff )

            {

            TInt laysizeDif = aFirst.iLayoutSize.iWidth-aSecond.iLayoutSize.iWidth ?

                aFirst.iLayoutSize.iWidth-aSecond.iLayoutSize.iWidth :

                aFirst.iLayoutSize.iHeight-aSecond.iLayoutSize.iHeight;

            if (!laysizeDif)

                {

               return aFirst.iSize.iWidth-aSecond.iSize.iWidth ?

                   aFirst.iSize.iWidth-aSecond.iSize.iWidth :

                   aFirst.iSize.iHeight-aSecond.iSize.iHeight;

                }

            else

                {

                return laysizeDif;

                }

            }

        else

            {

            return keyDiff;

            }

        }

    else

        {

        return idDiff;

        }

    }

//  End of File