/*

* 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:  Pictograph drawer

*

*/

// INCLUDE FILES

#include "AknPictographFactory.h"

#include "AknPictographConstants.h"

#include "AknPictographDefinitions.h"

#include "AknStaticPictographDefKey.h"

#include "AknAnimatedPictographDefKey.h"

#include <fbs.h>

#include <gdi.h>

#include <bitdev.h>

// CONSTANTS

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

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

// AknPictographFactory::SupportedPictographCodesL

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

//

HBufC* AknPictographFactory::SupportedPictographCodesL()

    {

    // static pictographs

    const TAknStaticPictographDefinition* staticTable = 

        TheStaticPictographDefinitions;

    // animated pictographs

    const TAknAnimatedPictographDefinition* animatedTable = 

        TheAnimatedPictographDefinitions;

    TInt numPictographs = KAknPictographStaticPictographsCount +

                          KAknPictographAnimatedPictographsCount;

    RArray<TUint> array( numPictographs );

    CleanupClosePushL( array );

    // append static pictograph codes

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

        {

        User::LeaveIfError( array.Append( staticTable[i].iCode ) );

        }

    // append animated pictograph codes

    for ( TInt j = 0 ; j < KAknPictographAnimatedPictographsCount ; j++ )

        {

        User::LeaveIfError( array.Append( animatedTable[j].iCode ) );

        }

    // sort

    array.Sort();

    // copy to descriptor

    HBufC* buf = HBufC::NewMaxL( numPictographs );

    TText* codes = const_cast<TText*>( buf->Ptr() );

    for ( TInt k = 0 ; k < numPictographs ; k++ )

        {

        codes[k] = static_cast<TText>( array[k] );

        }

    CleanupStack::PopAndDestroy(); // array

    return buf;

    }

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

// AknPictographFactory::StaticPictographData

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

//

TInt AknPictographFactory::StaticPictographData( 

    TText aCode, TAknPictographHeight aHeight, TAknPictographData& aData )

    {

    // Search static pictograph table.

    TAknStaticPictographDefKey staticDefKey;

    staticDefKey.SetPtr( &aCode );

    TInt pos;

    TInt ret = User::BinarySearch( KAknPictographStaticPictographsCount,

                                   staticDefKey,

                                   pos );

    const TAknStaticPictographDefinition* def = NULL;

    if ( ret == KErrNone )

        {

        def = &( TheStaticPictographDefinitions[pos] );

        TUint index = 0;

        ret = GetArrayIndexForHeight(aHeight,index);

        if ( ret == KErrNone )

            {

            aData.iOffset = def->iMetrics[index].iX;

            aData.iSize.iWidth = def->iMetrics[index].iWidth;

            aData.iSize.iHeight = def->iMetrics[index].iHeight;

            aData.iAnimated = EFalse;

            }

        }

    return ret;

    }

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

// AknPictographFactory::AnimatedPictographData

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

//

TInt AknPictographFactory::AnimatedPictographData(

    TText aCode,

    TAknPictographHeight aHeight,

    TUint aCounter,

    TAknPictographData& aData )

    {

    // Search animated pictograph table.

    TAknAnimatedPictographDefKey animatedDefKey;

    animatedDefKey.SetPtr( &aCode );

    TInt pos;

    TInt ret = User::BinarySearch( KAknPictographAnimatedPictographsCount,

                                   animatedDefKey,

                                   pos );

    const TAknAnimatedPictographDefinition* def = NULL;

    if ( ret == KErrNone )

        {

        def = &( TheAnimatedPictographDefinitions[pos] );

        TUint index = 0;

        ret = GetArrayIndexForHeight(aHeight,index);

        if ( ret == KErrNone )

            {

            TInt frame = aCounter % def->iFramesDefinitions[index].iFrames;

            const TAknPictographMetrics* metrics = def->iFramesDefinitions[index].iMetrics;

            aData.iOffset = metrics[frame].iX;

            aData.iSize.iWidth = metrics[frame].iWidth;

            aData.iSize.iHeight = metrics[frame].iHeight;

            aData.iAnimated = ETrue;

            }

        }

    return ret;

    }

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

// AknPictographFactory::StaticPictographTable

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

//

const TAknStaticPictographDefinition* 

    AknPictographFactory::StaticPictographTable()

    {

    return TheStaticPictographDefinitions;

    }

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

// AknPictographFactory::AnimatedPictographTable

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

//

const TAknAnimatedPictographDefinition* 

    AknPictographFactory::AnimatedPictographTable()

    {

    return TheAnimatedPictographDefinitions;

    }

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

// AknPictographFactory::LoadBitmapsL

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

//

void AknPictographFactory::LoadBitmapsL(

            RPointerArray<CFbsBitmap>*& aBitmaps,

            RPointerArray<CFbsBitmap>*& aMasks

            )

    {

    // Allocates array object and sets proper granularity values

    aBitmaps = new(ELeave) RPointerArray<CFbsBitmap>(KAknPictographSupportedHeightsCount);

    aMasks = new(ELeave) RPointerArray<CFbsBitmap>(KAknPictographSupportedHeightsCount);

    TFileName filename;

    CFbsBitmap* bitmap = NULL;

    // Loads supported bitamps and masks

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

        {

        // Load bitmap and append to aBitmaps

        filename = KBitmapFileNameBase;

        filename.AppendNum( TAknPictographSupportedHeightsNumbers[i] );

        filename.Append( KExtension );

        bitmap = new( ELeave ) CFbsBitmap;

        CleanupStack::PushL( bitmap );

        User::LeaveIfError( aBitmaps->Append(bitmap) );

        CleanupStack::Pop( bitmap );

        User::LeaveIfError( bitmap->Load( filename ) );

        // Load bitmap mask and append to aBitmaps

        filename = KMaskFileNameBase;

        filename.AppendNum( TAknPictographSupportedHeightsNumbers[i] );

        filename.Append( KExtension );

        bitmap = new( ELeave ) CFbsBitmap;

        CleanupStack::PushL( bitmap );

        User::LeaveIfError( aMasks->Append(bitmap) );

        CleanupStack::Pop( bitmap );

        User::LeaveIfError( bitmap->Load( filename ) );

        }

    }

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

// AknPictographFactory::CreateWhiteBitmapsL

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

//

void AknPictographFactory::CreateWhiteBitmapsL(

            CFbsBitmap*& aBitmap,

            CFbsBitmap*& aMask,

            CFbsBitmapDevice*& aMaskBitmapDevice,

            CFbsBitGc*& aMaskGc

            )

    {

    __ASSERT_DEBUG( KAknPictographSupportedHeightsCount > 0, User::Invariant() );

    // Note: TAknPictographSupportedHeightsNumbers should contain height numbers

    // ascending order

    // The size estimate below is derived from the heights of the biggest supported pictograph

    const TInt sideLenght = TAknPictographSupportedHeightsNumbers[KAknPictographSupportedHeightsCount-1]*2;

    const TSize whiteBitmapSize(sideLenght,sideLenght);

    // create white bitmap

    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();

    CleanupStack::PushL(bitmap);

    User::LeaveIfError( bitmap->Create( whiteBitmapSize, EGray2 ) );

    CFbsBitmapDevice* bitmapDev = CFbsBitmapDevice::NewL( bitmap );

    CleanupStack::PushL( bitmapDev );

    CFbsBitGc* bitmapGc = NULL;

    User::LeaveIfError( bitmapDev->CreateContext( bitmapGc ) );

    CleanupStack::PushL( bitmapGc );

    // fill the whole bitmap with white color

    bitmapGc->SetBrushColor(KRgbWhite);

    bitmapGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    bitmapGc->Clear();

    CleanupStack::PopAndDestroy(2); // bitmapDev, bitmapGc

    // create the mask (to be filled later)

    CFbsBitmap* mask = new (ELeave) CFbsBitmap();

    CleanupStack::PushL(mask);

    User::LeaveIfError( mask->Create( whiteBitmapSize, EGray2 ) );

    CFbsBitmapDevice* maskDev = CFbsBitmapDevice::NewL( mask );

    CleanupStack::PushL( maskDev );

    CFbsBitGc* maskGc = NULL;

    User::LeaveIfError( maskDev->CreateContext( maskGc ) );

    // fill the whole are of mask with white color

    maskGc->SetBrushColor(KRgbWhite);

    maskGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    maskGc->Clear();

    CleanupStack::Pop(3); // bitmap, mask, maskDev

    aBitmap = bitmap;

    aMask = mask;

    aMaskBitmapDevice = maskDev;

    aMaskGc = maskGc;

    }

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

// AknPictographFactory::GetArrayIndexForHeight

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

//

TInt AknPictographFactory::GetArrayIndexForHeight(

            TAknPictographHeight aHeight,

            TUint& aIndex

            )

    {

    TInt ret = KErrNotSupported;

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

        {

        if (TAknPictographSupportedHeights[i] == aHeight)

            {

            aIndex = i;

            ret = KErrNone;

            break;

            }

        }

    return ret;

    }

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

// AknPictographFactory::SelectPictographHeightForFont

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

//

TInt AknPictographFactory::SelectPictographHeightForFont(

            const CFont& aFont,

            TAknPictographHeight& aHeight

            )

    {

    TInt ret = KErrNotSupported;

    TInt fontHeight = aFont.HeightInPixels();

    TInt i;

    // Search for the first height that is bigger

    // Note: TAknPictographSupportedHeightsNumbers should contain height numbers

    // ascending order

    for (i = 0; i < KAknPictographSupportedHeightsCount; i++)

        {

        if ((TUint)fontHeight < TAknPictographSupportedHeightsNumbers[i])

            {

            break;

            }

        }

    // The previous height should be the best match

    // Use the biggest supported pictograph height in case the font height is

    // bigger

    TInt index = i-1;

    if (index >= 0)

        {

        aHeight = TAknPictographSupportedHeights[index];

        ret = KErrNone;

        }

    return ret;

    }

//  End of File