/*

* Copyright (c) 2007 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:  test case

 *

*/

#include <w32std.h>

#include <coecntrl.h>   

#include <eikenv.h>

#include <aknsconstants.h>

#include <aknsdrawutils.h>

#include <aknsimageattributedata.h>

#include <aknseffectanim.h>

#include <aknsitemdef.h>

#include <aknspkgid.h>

#include <aknspointerstore.h>

#include <aknsrendererwrapper.h>

#include <aknsskinuid.h>

#include <aknssrvchunklookup.h>

#include <aknssrvclient.h>

#include <aknssrvskininformationpkg.h>

#include "bctestdomskincase.h"

#include "bctestdomfntlaycontainer.h"

#include "bctestdomfntlay.hrh"

class CAknsEffectAnimObserver : public CBase ,public MAknsEffectAnimObserver

    {

    void AnimFrameReady( TInt aError, TInt aAnimId );

    } ;

void CAknsEffectAnimObserver::AnimFrameReady( TInt aError, TInt /* aAnimId */ )

    {

    TBuf<16> strError;

    _LIT( KTxtError, "CAknsEffectAnim Error :" );

    strError.Append( KTxtError );

    strError.AppendNum( aError ) ;

    RDebug::Print( strError );

    }

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

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

// Symbian 2nd static Constructor

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

//

CBCTestDomSkinCase* CBCTestDomSkinCase::NewL( )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ default constructor

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

//

CBCTestDomSkinCase::CBCTestDomSkinCase()

   {    

   }

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

// Destructor

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

//

CBCTestDomSkinCase::~CBCTestDomSkinCase()

    {  

    }

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

// Symbian 2nd Constructor

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

//

void CBCTestDomSkinCase::ConstructL()

    {    

    BuildScriptL();    

    }

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

// CBCTestDomSkinCase::BuildScriptL

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

//

void CBCTestDomSkinCase::BuildScriptL()

    { 

    // Add script as your need.   

    AddTestL( DELAY(1),

              LeftCBA, REP(Down,1), LeftCBA, LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,1), LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,2), LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,3), LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,4), LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,5), LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,6), LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,7), LeftCBA,

              LeftCBA, REP(Down,1), LeftCBA, REP(Down,8), LeftCBA,

              TEND );    

    }

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

// CBCTestDomSkinCase::RunL

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

//

void CBCTestDomSkinCase::RunL( TInt aCmd )

    {

    if ( aCmd < EBCTestDomCmdOutline04 || aCmd > EBCTestDomCmdOutline12 )

        {

        return;

        }

    switch ( aCmd )

        {

        case EBCTestDomCmdOutline04: //AknsEffectAnim.h  22

            {

            TestEffectAnimL();

            break;

            }

        case EBCTestDomCmdOutline05: //AknsItemDef.h

            {

            TestItemDefL();

            break;

            }

        case EBCTestDomCmdOutline06: //AknsItemDef.h

            {

            TestItemDef2L();

            break;

            }

        case EBCTestDomCmdOutline07: //AknsPkgID.h 3

            {

            TestPkgIDL();

            break;

            }

        case EBCTestDomCmdOutline08: //AknsPointerStore.h 3

            {

            TestPointerStoreL();

            break;

            }

        case EBCTestDomCmdOutline09: //AknsRendererWrapper.h 1

            {

            TestRendererWrapperL();

            break;

            }

        case EBCTestDomCmdOutline10: //AknsSrvChunkLookup.h

            {

            TestSrvChunkLookupL();

            break;

            }

        case EBCTestDomCmdOutline11: //AknsSrvClient.h 25

            {

            TestSrvClientL();

            break;

            }

        case EBCTestDomCmdOutline12: //AknsSrvSkinInformationPkg.h 15

            {

            TestSrvSkinInformationPkgL();

            break;

            }

        default:

            break;

        }

    }

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

// CBCTestDomSkinCase::TestEffectAnimL

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

//

void CBCTestDomSkinCase::TestEffectAnimL()//AknsEffectAnim.h  22

    {

    CAknsEffectAnimObserver* observer =

        new (ELeave) CAknsEffectAnimObserver(); 

    CleanupStack::PushL( observer );

    CAknsEffectAnim* effictAnim = CAknsEffectAnim::NewL( observer );

    CleanupStack::PushL( effictAnim );

    _LIT( KTxtNewL, "CAknsEffectAnim::NewL" );

    AssertTrueL( ETrue, KTxtNewL );

    TBool isSuc = effictAnim->ConstructFromSkinL(

        KAknsIIDQgnIndiTpDialler );//

    _LIT( KTxtConstructFromSkinL,

        "CAknsEffectAnim::ConstructFromSkinL" );

    AssertTrueL( ETrue, KTxtConstructFromSkinL );

    TInt ret = effictAnim->Start();

    _LIT( KTxtStart, "CAknsEffectAnim::Start" );

    AssertTrueL( ETrue, KTxtStart );

    ret = effictAnim->Pause();

    _LIT( KTxtPause, "CAknsEffectAnim::Pause" );

    AssertTrueL( ETrue, KTxtPause );

    ret = effictAnim->Continue();

    _LIT( KTxtContinue, "CAknsEffectAnim::Continue" );

    AssertTrueL( ETrue, KTxtContinue );

    ret = effictAnim->Stop();

    _LIT( KTxtStop, "CAknsEffectAnim::Stop" );

    AssertTrueL( ETrue, KTxtStop );

    ret = effictAnim->State();

    _LIT( KTxtState, "CAknsEffectAnim::State" );

    AssertTrueL( ETrue, KTxtState );

    CFbsBitGc* fbsBitgc = CFbsBitGc::NewL(); 

    CleanupStack::PushL( fbsBitgc );

    isSuc = effictAnim->Render( *fbsBitgc, TRect( 50, 50, 10, 10 ) );

    _LIT( KTxtRender, "CAknsEffectAnim::Render" );

    AssertTrueL( ETrue, KTxtRender );

    CWindowGc& gc = CCoeEnv::Static()->SystemGc();

    isSuc = effictAnim->Render( gc, TRect( 50, 50, 10, 10 ) );

    _LIT( KTxtRender2, "CAknsEffectAnim::Render2" );

    AssertTrueL( ETrue, KTxtRender2 );

    CBitmapContext& bitmapGc = gc;

    isSuc = effictAnim->Render( bitmapGc, TRect( 50, 50, 10, 10 ) );

    _LIT( KTxtRender3, "CAknsEffectAnim::Render3" );

    AssertTrueL( ETrue, KTxtRender3 );

    const CFbsBitmap* fbcBitmap = effictAnim->OutputRgb();

    _LIT( KTxtOutputRgb, "CAknsEffectAnim::OutputRgb" );

    AssertTrueL (ETrue, KTxtOutputRgb );

    fbcBitmap = effictAnim->OutputAlpha();

    _LIT( KTxtOutputAlpha, "CAknsEffectAnim::OutputAlpha" );

    AssertTrueL( ETrue, KTxtOutputAlpha );

    TSize minSize = effictAnim->MinimumSize();

    _LIT( KTxtMinimumSize, "CAknsEffectAnim::MinimumSize" );

    AssertTrueL( ETrue, KTxtMinimumSize );

    minSize = effictAnim->Size();

    _LIT( KTxtSize, "CAknsEffectAnim::Size" );

    AssertTrueL( ETrue, KTxtSize );

    isSuc = effictAnim->NeedsInputLayer();

    _LIT( KTxtNeedsInputLayer, "CAknsEffectAnim::NeedsInputLayer" );

    AssertTrueL( ETrue, KTxtNeedsInputLayer );

    effictAnim->BeginConfigInputLayersL( TSize( 10, 20 ), EFalse );

    _LIT( KTxtBeginConfigInputLayersL,

        "CAknsEffectAnim::BeginConfigInputLayersL" );

    AssertTrueL( ETrue, KTxtBeginConfigInputLayersL );

    CFbsBitGc* fbGc = effictAnim->InputRgbGc();

    _LIT( KTxtInputRgbGc, "CAknsEffectAnim::InputRgbGc" );

    AssertTrueL( ETrue, KTxtInputRgbGc ); 

    fbGc = effictAnim->InputAlphaGc();

    _LIT( KTxtInputAlphaGc, "CAknsEffectAnim::InputAlphaGc" );

    AssertTrueL( ETrue, KTxtInputAlphaGc );

    effictAnim->EndConfigInputLayersL();

    _LIT( KTxtEndConfigInputLayersL,

        "CAknsEffectAnim::EndConfigInputLayersL" );

    AssertTrueL( ETrue, KTxtEndConfigInputLayersL );

    ret = effictAnim->UpdateOutput();

    _LIT( KTxtUpdateOutput, "CAknsEffectAnim::UpdateOutput" );

    AssertTrueL( ETrue, KTxtUpdateOutput );

    effictAnim->SetIdling( 5 );

    _LIT( KTxtSetIdling, "CAknsEffectAnim::SetIdling" );

    AssertTrueL( ETrue, KTxtSetIdling );

    TBool isidling = effictAnim->IsIdling();

    _LIT( KTxtIsIdling, "CAknsEffectAnim::IsIdling" );

    AssertTrueL( ETrue, KTxtIsIdling );

    CleanupStack::PopAndDestroy( fbsBitgc );

    CleanupStack::PopAndDestroy( effictAnim );

    _LIT( KTxtDelete, "CAknsEffectAnim::~CAknsEffectAnim" );

    AssertTrueL( ETrue, KTxtDelete );

    CleanupStack::PopAndDestroy( observer );    

    }

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

// CBCTestDomSkinCase::TestItemDefL

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

//

void CBCTestDomSkinCase::TestItemDefL() //AknsItemDef.h

    {

    //CAknsItemDef

    CAknsItemDef* itemDef = CAknsItemDef::NewL(

        KAknsIIDQgnIndiTpDialler );

    CleanupStack::PushL( itemDef );                 

    _LIT( KTxtNewL, "CAknsItemDef::NewL" );

    AssertTrueL( ETrue, KTxtNewL );

    TAknsItemType itemType = itemDef->Type();

    _LIT (KTxtType, "CAknsItemDef::Type" );

    AssertTrueL( ETrue, KTxtType );

    TAknsItemID itemID = itemDef->ID();

    _LIT( KTxtID, "CAknsItemDef::ID" );

    AssertTrueL( ETrue, KTxtID ); 

    TInt ret = CAknsItemDef::LinearOrder( *itemDef, *itemDef );

    _LIT( KTxtLinearOrder, "CAknsItemDef::LinearOrder" );

    AssertTrueL( ETrue, KTxtLinearOrder ); 

    CleanupStack::PopAndDestroy( itemDef );

    _LIT( KTxtDelete, "CAknsItemDef::~CAknsItemDef" );

    AssertTrueL( ETrue, KTxtDelete );  

    //CAknsImageItemDef

    CAknsImageItemDef* imageItemDef = 

        CAknsImageItemDef::NewL( KAknsIIDQgnIndiTpDialler );

    CleanupStack::PushL (imageItemDef );                    

    _LIT( KTxtImageNewL, "CAknsImageItemDef::NewL" );

    AssertTrueL( ETrue, KTxtImageNewL );

    TAknsImageAttributeData attributeData;

    imageItemDef->SetAttributesL( attributeData );

    _LIT( KTxtSetAttributesL, "CAknsImageItemDef::SetAttributesL" );

    AssertTrueL( ETrue, KTxtSetAttributesL );

    const TAknsImageAttributeData* attriData = 

        imageItemDef->Attributes();

    _LIT( KTxtAttributes, "CAknsImageItemDef::Attributes" );

    AssertTrueL( ETrue, KTxtAttributes );

    CleanupStack::PopAndDestroy( imageItemDef );

    //CAknsBitmapItemDef

    _LIT( KTxtFilename, "\\resource\\apps\\BCTestDomfntlay.mbm" );

    CAknsBitmapItemDef* bitmapItemDef =

        CAknsBitmapItemDef::NewL(

        KAknsIIDQgnIndiTpDialler, KTxtFilename, 1 );    

    CleanupStack::PushL( bitmapItemDef );                   

    _LIT( KTxtBitmapNewL ,"CAknsBitmapItemDef::NewL" );

    AssertTrueL( ETrue, KTxtBitmapNewL );

    CAknsBitmapItemDef* bitmapItemDef2 = 

        CAknsBitmapItemDef::NewL( KAknsIIDQgnIndiTpDialler );   

    CleanupStack::PushL( bitmapItemDef2 );                  

    _LIT( KTxtBitmapNewL2, "CAknsBitmapItemDef::NewL2" );

    AssertTrueL( ETrue, KTxtBitmapNewL2 );

    CleanupStack::PopAndDestroy( bitmapItemDef2 );

    _LIT( KFileName, "abc.bmp" );

    bitmapItemDef->SetFilename( KFileName );

    _LIT( KTxtSetFilename, "CAknsBitmapItemDef::SetFilename" );

    AssertTrueL( ETrue, KTxtSetFilename );  

    bitmapItemDef->SetFilenameL( KFileName );

    _LIT( KTxtSetFilenameL, "CAknsBitmapItemDef::SetFilenameL" );

    AssertTrueL( ETrue, KTxtSetFilenameL ); 

    const TDesC& filename = bitmapItemDef->Filename();

    _LIT( KTxtBitmapFilename, "CAknsBitmapItemDef::Filename" );

    AssertTrueL( ETrue, KTxtBitmapFilename );   

    bitmapItemDef->SetIndex( 1 );

    _LIT( KTxtSetIndex, "CAknsBitmapItemDef::Filename" );

    AssertTrueL( ETrue, KTxtSetIndex );   

    TInt index = bitmapItemDef->Index();

    _LIT( KTxtIndex, "CAknsBitmapItemDef::Index" );

    AssertTrueL( ETrue, KTxtIndex );    

    CleanupStack::PopAndDestroy( bitmapItemDef );

    //CAknsMaskedBitmapItemDef

    CAknsMaskedBitmapItemDef* mbItemDef =

        CAknsMaskedBitmapItemDef::NewL(

        KAknsIIDQgnIndiTpDialler, KTxtFilename, 1, 2 );         

    CleanupStack::PushL( mbItemDef );                   

    _LIT( KTxtMbitmapNewL ,"CAknsMaskedBitmapItemDef::NewL" );

    AssertTrueL( ETrue, KTxtMbitmapNewL );

    CAknsMaskedBitmapItemDef* mbItemDef2 = 

        CAknsMaskedBitmapItemDef::NewL( KAknsIIDQgnIndiTpDialler ); 

    CleanupStack::PushL( mbItemDef2 );                  

    _LIT( KTxtMbitmapNewL2, "CAknsMaskedBitmapItemDef::NewL2" );

    AssertTrueL( ETrue, KTxtMbitmapNewL2 );

    CleanupStack::PopAndDestroy( mbItemDef2 );

    mbItemDef->SetMaskIndex( 2 );

    _LIT( KTxtSetMaskIndex, "CAknsMaskedBitmapItemDef::SetMaskIndex" );

    AssertTrueL( ETrue, KTxtSetMaskIndex );

    TInt mIndex = mbItemDef->MaskIndex();

    _LIT( KTxtMaskIndex, "CAknsMaskedBitmapItemDef::MaskIndex" );

    AssertTrueL( ETrue, KTxtMaskIndex );

    CleanupStack::PopAndDestroy( mbItemDef );

    //CAknsColorTableItemDef

    TAknsColorTableEntry ctEntry;

    ctEntry.iIndex = 8 ;

    CAknsColorTableItemDef* ctItemDef = CAknsColorTableItemDef::NewL(

        KAknsIIDQgnIndiTpDialler,1,&ctEntry);

    CleanupStack::PushL( ctItemDef );                   

    _LIT( KTxtCtNewL ,"CAknsColorTableItemDef::NewL" );

    AssertTrueL( ETrue, KTxtCtNewL );

    CAknsColorTableItemDef* ctItemDef2 = 

        CAknsColorTableItemDef::NewL( KAknsIIDQgnIndiTpDialler );   

    CleanupStack::PushL( ctItemDef2 );                  

    _LIT( KTxtCtNewL2, "CAknsColorTableItemDef::NewL2" );

    AssertTrueL( ETrue, KTxtCtNewL2 );

    CleanupStack::PopAndDestroy( ctItemDef2 );

    TAknsColorTableEntry ctSetEntry;

    ctSetEntry.iIndex = 18 ;

    ctItemDef->SetColors( 1, &ctSetEntry );

    _LIT( KTxtSetColors, "CAknsColorTableItemDef::SetColors" );

    AssertTrueL( ETrue, KTxtSetColors );

    ctItemDef->SetColorsL( 1, &ctSetEntry );

    _LIT( KTxtSetColorsL, "CAknsColorTableItemDef::SetColorsL" );

    AssertTrueL( ETrue, KTxtSetColorsL );

    const TAknsColorTableEntry* colorTabEntry = ctItemDef->Colors();

    _LIT( KTxtColors, "CAknsColorTableItemDef::Colors" );

    AssertTrueL( ETrue, KTxtColors );

    TInt counter = ctItemDef->NumberOfColors();

    _LIT( KTxtNumberOfColors, 

        "CAknsColorTableItemDef::NumberOfColors" );

    AssertTrueL( ETrue, KTxtNumberOfColors ); 

    CleanupStack::PopAndDestroy( ctItemDef );   

    //CAknsImageTableItemDef

    TAknsItemID itemId;

    itemId.Set( KAknsIIDQgnPropSetAppsLoc );

    CAknsImageTableItemDef* itItemDef = CAknsImageTableItemDef::NewL(

        KAknsIIDQgnIndiTpDialler,1,&itemId);

    CleanupStack::PushL( itItemDef );                   

    _LIT( KTxtItNewL ,"CAknsImageTableItemDef::NewL" );

    AssertTrueL( ETrue, KTxtItNewL );

    CAknsImageTableItemDef* itItemDef2 = 

        CAknsImageTableItemDef::NewL( KAknsIIDQgnIndiTpDialler );   

    CleanupStack::PushL( itItemDef2 );                  

    _LIT( KTxtItNewL2, "CAknsImageTableItemDef::NewL2" );

    AssertTrueL( ETrue, KTxtItNewL2 );

    CleanupStack::PopAndDestroy( itItemDef2 ); 

    itItemDef->SetImages( 1, &itemId );

    _LIT( KTxtSetImages, "CAknsImageTableItemDef::SetImages" );

    AssertTrueL( ETrue, KTxtSetImages );

    itItemDef->SetImagesL( 1, &itemId );

    _LIT( KTxtSetImagesL, "CAknsImageTableItemDef::SetImagesL" );

    AssertTrueL( ETrue, KTxtSetImagesL );

    const TAknsItemID* imgItemID = itItemDef->Images();

    _LIT( KTxtImages, "CAknsImageTableItemDef::Images" );

    AssertTrueL( ETrue, KTxtImages );

    TInt numImage = itItemDef->NumberOfImages();

    _LIT( KTxtNumberOfImages, 

        "CAknsImageTableItemDef::NumberOfImages" );

    AssertTrueL( ETrue, KTxtNumberOfImages ); 

    CleanupStack::PopAndDestroy( itItemDef );      

    }

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

// CBCTestDomSkinCase::TestItemDef2L

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

//

void CBCTestDomSkinCase::TestItemDef2L() //AknsItemDef.h

    {

    //CAknsBmpAnimItemDef 13

    TAknsItemID itemId;

    itemId.Set( KAknsIIDQgnPropSetAppsLoc );

    TAknsBmpAnimFrameInfo frameInfo;

    frameInfo.iTime = 100;

    frameInfo.iPosX = 50;

    frameInfo.iPosY = 50;

    CAknsBmpAnimItemDef* bmpAnimDef = CAknsBmpAnimItemDef::NewL(

        KAknsIIDQgnIndiTpDialler, 1, &itemId, &frameInfo );

    CleanupStack::PushL( bmpAnimDef );                  

    _LIT( KTxtbmpAnimNewL ,"CAknsBmpAnimItemDef::NewL" );

    AssertTrueL( ETrue, KTxtbmpAnimNewL );

    CAknsBmpAnimItemDef* bmpAnimDef2 = 

        CAknsBmpAnimItemDef::NewL( KAknsIIDQgnIndiTpDialler );  

    CleanupStack::PushL( bmpAnimDef2 );                 

    _LIT( KTxtKTxtbmpAnimNewL2, "CAknsBmpAnimItemDef::NewL2" );

    AssertTrueL( ETrue, KTxtKTxtbmpAnimNewL2 );

    CleanupStack::PopAndDestroy( bmpAnimDef2 ); 

    bmpAnimDef->SetFrameInfos( &frameInfo );

    _LIT( KTxtSetFrameInfos, "CAknsBmpAnimItemDef::SetFrameInfos" );

    AssertTrueL( ETrue, KTxtSetFrameInfos );

    bmpAnimDef->SetFrameInfosL( &frameInfo );

    _LIT( KTxtSetFrameInfosL, "CAknsBmpAnimItemDef::SetFrameInfosL" );

    AssertTrueL( ETrue, KTxtSetFrameInfosL );

    const TAknsBmpAnimFrameInfo* bmpFrameInfo = 

        bmpAnimDef->FrameInfos();

    _LIT( KTxtFrameInfos, "CAknsBmpAnimItemDef::FrameInfos" );

    AssertTrueL( ETrue, KTxtFrameInfos );

    bmpAnimDef->SetLastFrameBackground( ETrue );

    _LIT( KTxtSetLastFrameBackground,

        "CAknsBmpAnimItemDef::SetLastFrameBackground" );

    AssertTrueL( ETrue, KTxtSetLastFrameBackground );

    TBool lastFrame = bmpAnimDef->LastFrameBackground();

    _LIT( KTxtLastFrameBackground,

        "CAknsBmpAnimItemDef::LastFrameBackground" );

    AssertTrueL( ETrue, KTxtLastFrameBackground );

    bmpAnimDef->SetFrameInterval( 8 );

    _LIT( KTxtSetFrameInterval,

        "CAknsBmpAnimItemDef::SetFrameInterval" );