/*

* Copyright (c) 2006 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 <avkon.hrh>

#include <AknsConstants.h> //

#include <eikbgfty.h>

#include <eikenv.h>

#include <eikcolib.h>

#include <eikbtgpc.h>

#include <eikcmbut.h>

#include <eikbutb.h>

#include <s32file.h>

#include <eikcba.h>

#include <eikcmbut.h>

#include <barsread.h>

#include <avkon.mbg>

#include <eiklbbut.h>

#include <coecntrl.h>

#include <eikmnbut.h>

#include <eikbtgps.h>

#include <eikbtgrp.h>

#include <akniconutils.h>

#include <bctestbuttons.rsg>

#include <bctestbuttons.mbg>

#include "bctestbuttonscase.h"

#include "bctestbuttonscontainer.h"

#include "bctestbuttons.hrh"

#include "streamlogger.h"

_LIT( KStreamName, "c:\\BCTestLog\\buttontest.txt" );

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

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

// Symbian 2nd static Constructor

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

//

CBCTestButtonsCase* CBCTestButtonsCase::NewL(

    CBCTestButtonsContainer* aContainer )

    {

    CBCTestButtonsCase* self = new( ELeave ) CBCTestButtonsCase(

        aContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ default constructor

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

//

CBCTestButtonsCase::CBCTestButtonsCase(

    CBCTestButtonsContainer* aContainer )

    : iContainer( aContainer )

    {

    }

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

// Destructor

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

//

CBCTestButtonsCase::~CBCTestButtonsCase()

    {

    }

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

// Symbian 2nd Constructor

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

//

void CBCTestButtonsCase::ConstructL()

    {

    BuildScriptL();

    iEnv = CEikonEnv::Static();

    }

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

// CBCTestButtonsCase::BuildScriptL

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

//

void CBCTestButtonsCase::BuildScriptL()

    {

    // Add script as your need.

	AddTestL( DELAY(1), TEND);

    TInt loop = EBCTestCmdMaxOutline - EBCTestCmdTestEikBgftyAndEikBtgpcL;

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

        {

        AddTestL( LeftCBA, REP( Down, i ), KeyOK, TEND );

        }

    }

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

// CBCTestButtonsCase::RunL

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

//

void CBCTestButtonsCase::RunL( TInt aCmd )

    {

    if ( aCmd < EBCTestCmdTestEikBgftyAndEikBtgpcL  || aCmd > EBCTestCmdMaxOutline )

        {

        return;

        }

    // Call release before prepare to let container has time to draw the

    // control created in PrepareCaseL.

    switch ( aCmd )

        {

        case EBCTestCmdTestEikBgftyAndEikBtgpcL:

            TestEikBgftyAndEikBtgpcL();

            break;

        case EBCTestCmdTestEikButbAndEikCbaL:

            TestEikButbAndEikCbaL();

            break;

        case EBCTestCEikCommandButtonL:

            TestCEikCommandButtonL();

            break;

        case EBCTestCEikTwoPictureCmdL:

            TestCEikTwoPictureCmdL();

            break;

        case EBCTestCEikInverterCmdL:

            TestCEikInverterCmdL();

            break;

        case EBCTestCEikTextBtnL:

            TestCEikTextBtnL();

            break;

        case EBCTestCEikBitmapBtnL:

            TestCEikBitmapBtnL();

            break;

        case EBCTestCEikLabeledBtnL:

            TestCEikLabeledBtnL();

            break;

        case EBCTestMnbutAndBtgpsAndBtgrpL:

            TestMnbutAndBtgpsAndBtgrpL();

            break;

        case EBCTestCba:

            TestCbaButtonL();

            break;

        default:

            break;

        }

    }

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

// CBCTestButtonsCase::TestEikBgftyAndEikBtgpcL

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

//

void CBCTestButtonsCase::TestEikBgftyAndEikBtgpcL()

    {

    // Test some API for class EikButtonGroupFactory

    TBCTestCommandObserver commandObserver;

    TInt resourceId = R_BCTESTBUTTONS_MENU;

    RWindowGroup& parentWg = iEnv->RootWin();

    TUint flags = 0;

    EikButtonGroupFactory::TCreationData creationData(

        CEikButtonGroupContainer::EView, &commandObserver,

        resourceId, &parentWg, flags,

        CEikButtonGroupContainer::EVertical );

    _LIT( KTCreationData, "TCreationData test" );

    AssertTrueL( ETrue, KTCreationData );

    // Test some API for class CEikButtonGroupFactoryArray

    CEikButtonGroupFactoryArray::AppendFactoryFunctionL(

        CEikCoCtlLibrary::ButtonGroupFactory() );

    _LIT( KAppendFactoryFunctionL, "AppendFactoryFunctionL test" );

    AssertTrueL( ETrue, KAppendFactoryFunctionL );

    CEikButtonGroupFactoryArray::RemoveFactoryFunction(

        CEikCoCtlLibrary::ButtonGroupFactory() );

    _LIT( KRemoveFactoryFunction, "RemoveFactoryFunction test" );

    AssertTrueL( ETrue, KRemoveFactoryFunction );

    // Test some API for class CEikButtonGroupContainer

    TInt resourceIdForToolbar = R_BCTESTBUTTONS_TOOLBAR;

    CEikButtonGroupContainer* buttonGroupContainer1 =

        CEikButtonGroupContainer::NewL( CEikButtonGroupContainer::EView,

        CEikButtonGroupContainer::EVertical, &commandObserver,

        resourceIdForToolbar, CEikButtonGroupContainer::EAddToStack );

    CleanupStack::PushL( buttonGroupContainer1 );

    _LIT( KNewL, "NewL test" );

    AssertTrueL( ETrue, KNewL );

    CleanupStack::PopAndDestroy( buttonGroupContainer1 );

    CEikButtonGroupContainer* buttonGroupContainer2 =

        CEikButtonGroupContainer::NewL( CEikButtonGroupContainer::EView,

        CEikButtonGroupContainer::EVertical, &commandObserver,

        resourceIdForToolbar, *iContainer,

        CEikButtonGroupContainer::EAddToStack);

    CleanupStack::PushL( buttonGroupContainer2 );

    _LIT( KNewLWithCCoeControl, "NewL WithCCoeControl test" );

    AssertTrueL( ETrue, KNewLWithCCoeControl );

    CleanupStack::PopAndDestroy( buttonGroupContainer2 );

    CEikButtonGroupContainer* buttonGroupContainer3 =

        CEikButtonGroupContainer::NewL( CEikButtonGroupContainer::EView,

        CEikButtonGroupContainer::EVertical, &commandObserver,

        resourceIdForToolbar, parentWg,

        CEikButtonGroupContainer::EAddToStack );

    CleanupStack::PushL( buttonGroupContainer3 );

    _LIT( KNewLWithRWindowGroup, "NewL With RWindowGroup test" );

    AssertTrueL( ETrue, KNewLWithRWindowGroup );

    CleanupStack::PopAndDestroy( buttonGroupContainer3 );

    CEikButtonGroupContainer* buttonGroupContainer4 =

        CEikButtonGroupContainer::Current();

    _LIT( KCurrent, "Current test" );

    AssertTrueL( ETrue, KCurrent );

    TInt resourceIdForCba = R_BCTESTBUTTONS_CBA_OPTIONS_NEXT;

    buttonGroupContainer4->SetCommandSetL( resourceIdForCba );

    _LIT( KSetCommandSetL, "SetCommandSetL test" );

    AssertTrueL( ETrue, KSetCommandSetL );

    buttonGroupContainer4->AddCommandSetToStackL( resourceIdForCba );

    _LIT( KAddCommandSetToStackL, "AddCommandSetToStackL test" );

    AssertTrueL( ETrue, KAddCommandSetToStackL );

    TInt commandId = EAknSoftkeyOptions;

    TInt position = buttonGroupContainer4->PositionById( commandId );

    _LIT( KPositionById, "PositionById test" );

    AssertTrueL( ETrue, KPositionById );

    buttonGroupContainer4->RemoveCommandFromStack( position, commandId);

    _LIT( KRemoveCommandFromStack, "RemoveCommandFromStack test" );

    AssertTrueL( ETrue, KRemoveCommandFromStack );

    buttonGroupContainer4->SetDefaultCommand( commandId );

    _LIT( KSetDefaultCommand, "SetDefaultCommand test" );

    AssertTrueL( ETrue, KSetDefaultCommand );

    TSize size1 = buttonGroupContainer4->CalcMinimumSizeL( resourceIdForCba );

    _LIT( KCalcMinimumSizeL, "CalcMinimumSizeL test" );

    AssertTrueL( ETrue, KCalcMinimumSizeL );

    buttonGroupContainer4->CleanupCommandPushL( position );

    _LIT( KCleanupCommandPushL, "CleanupCommandPushL test" );

    AssertTrueL( ETrue, KCleanupCommandPushL );

    TInt res( KErrNone );

    _LIT( KOfferCommandListL, "OfferCommandListL tested" );

    TRAP( res, buttonGroupContainer4->OfferCommandListL( resourceIdForCba ) );

    AssertTrueL( ETrue, KOfferCommandListL );

    RArray<TInt> arr;

    arr.Append( commandId );

    _LIT( KOfferCommandListLOverload, "OfferCommandListL overload tested" );

    TRAP( res, buttonGroupContainer4->OfferCommandListL( arr ) );

    AssertTrueL( ETrue, KOfferCommandListLOverload );

    arr.Close();

    TInt countForCleanupCommandPop = 1;

    buttonGroupContainer4->CleanupCommandPop( countForCleanupCommandPop );

    _LIT( KCleanupCommandPop, "CleanupCommandPop test" );

    AssertTrueL( ETrue, KCleanupCommandPop );

    TInt maxCommands = buttonGroupContainer4->MaxCommands();

    _LIT( KMaxCommands, "MaxCommands test" );

    AssertTrueL( ETrue, KMaxCommands );

    TInt buttonCount = buttonGroupContainer4->ButtonCount();

    _LIT( KButtonCount, "ButtonCount test" );

    AssertTrueL( ETrue, KButtonCount );

    TBool dimmed = ETrue;

    buttonGroupContainer4->DimCommand( commandId, dimmed );

    _LIT( KDimCommand, "DimCommand test" );

    AssertTrueL( ETrue, KDimCommand );

    TBool isCommandDimmed = buttonGroupContainer4->IsCommandDimmed( commandId );

    _LIT( KIsCommandDimmed, "IsCommandDimmed test" );

    AssertTrueL( ETrue, KIsCommandDimmed );

    TBool visible = ETrue;

    buttonGroupContainer4->MakeCommandVisible( commandId, visible );

     _LIT( KMakeCommandVisible, "MakeCommandVisible test" );

    AssertTrueL( ETrue, KMakeCommandVisible );

    TBool isCommandVisible = buttonGroupContainer4->IsCommandVisible( commandId );

    _LIT( KIsCommandVisible, "IsCommandVisible test" );

    AssertTrueL( ETrue, KIsCommandVisible );

    buttonGroupContainer4->AnimateCommand( commandId );

    _LIT( KAnimateCommand1, "AnimateCommand test" );

    AssertTrueL( ETrue, KAnimateCommand1 );

    CEikButtonGroupContainer::TLocation location =

        buttonGroupContainer4->Location();

    _LIT( KLocation, "Location test" );

    AssertTrueL( ETrue, KLocation );

#ifndef _DEBUG

    CEikCommandButton* commandButton1 =

        buttonGroupContainer4->CommandButtonOrNull( commandId );

    CleanupStack::PushL( commandButton1 );

    _LIT( KCommandButtonOrNull, "CommandButtonOrNull test" );

    AssertTrueL( ETrue, KCommandButtonOrNull );

    CleanupStack::PopAndDestroy( commandButton1 );

#endif

    TRect rect = iContainer->Rect();

    buttonGroupContainer4->SetBoundingRect( rect );

    _LIT( KSetBoundingRect, "SetBoundingRect test" );

    AssertTrueL( ETrue, KSetBoundingRect );

    buttonGroupContainer4->ReduceRect( rect );

    _LIT( KReduceRect, "ReduceRect test" );

    AssertTrueL( ETrue, KReduceRect );

    CCoeControl* coeControl =

        buttonGroupContainer4->ControlOrNull( commandId );

    _LIT( KControlOrNull, "ControlOrNull test" );

    AssertTrueL( ETrue, KControlOrNull );

#ifndef _DEBUG

    CEikCommandButton* commandbutton2 =

        buttonGroupContainer4->ButtonById( commandId );

    _LIT( KButtonById, "ButtonById test" );

    AssertTrueL( ETrue, KButtonById );

#endif

    TInt keyId = 1;

    buttonGroupContainer4->UpdateHotKey( commandId,

        CEikButtonGroupContainer::EShowHotKey, keyId);

    _LIT( KUpdateHotKey, "UpdateHotKey test" );

    AssertTrueL( ETrue, KUpdateHotKey );

    TInt pos = 1;

    buttonGroupContainer4->UpdateCommandObserverL( pos, commandObserver );

    _LIT( KUpdateCommandObserverL, "UpdateCommandObserverL test" );

    AssertTrueL( ETrue, KUpdateCommandObserverL );

    buttonGroupContainer4->RemoveCommandObserver( pos );

    _LIT( KRemoveCommandObserver, "RemoveCommandObserver test" );

    AssertTrueL( ETrue, KRemoveCommandObserver );

    TBool delayActivation = buttonGroupContainer4->DelayActivation();

    _LIT( KDelayActivation, "DelayActivation test" );

    AssertTrueL( ETrue, KDelayActivation );

    TSize minimumSize1 = buttonGroupContainer4->MinimumSize();

    _LIT( KMinimumSize1, "MinimumSize test" );

    AssertTrueL( ETrue, KMinimumSize1 );

    TKeyEvent keyEvent1 = { EKeyPause, EStdKeySpace, 0, 0  };

    TKeyResponse keyresponse =

        buttonGroupContainer4->OfferKeyEventL( keyEvent1, EEventKey );

    _LIT( KOfferKeyEventL1, "OfferKeyEventL test" );

    AssertTrueL( ETrue, KOfferKeyEventL1 );

    RFs& tempServer = iEnv->FsSession();

    tempServer.Delete( KStreamName );

    RFileWriteStream fWrite;

    User::LeaveIfError( fWrite.Create( tempServer,

        KStreamName, EFileWrite ) );

    CleanupClosePushL( fWrite );

    buttonGroupContainer4->WriteInternalStateL( fWrite );

    CleanupStack::PopAndDestroy( &fWrite );

    tempServer.Delete( KStreamName );

    _LIT( KWriteInternalStateL1, "WriteInternalStateLtest test" );

    AssertTrueL( ETrue, KWriteInternalStateL1);

    buttonGroupContainer4->Reserved_MtsmPosition();

    _LIT( KReserved_MtsmPosition, "Reserved_MtsmPosition" );

    AssertTrueL( ETrue, KReserved_MtsmPosition );

    buttonGroupContainer4->Reserved_MtsmObject();

     _LIT( KReserved_MtsmObject, "Reserved_MtsmObject test" );

    AssertTrueL( ETrue, KReserved_MtsmObject );

    TBool isCommandInGroup = buttonGroupContainer4->IsCommandInGroup( commandId );

    _LIT( KIsCommandInGroup, "IsCommandInGroup test" );

    AssertTrueL( ETrue, KIsCommandInGroup );

    buttonGroupContainer4->ReplaceCommand( commandId, resourceIdForCba );

    _LIT( KReplaceCommand, "ReplaceCommand test" );

    AssertTrueL( ETrue, KReplaceCommand );

    }

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

// TBCTestCommandObserver::ProcessCommandL

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

//

void TBCTestCommandObserver::ProcessCommandL( TInt )

    {

    }

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

// CBCTestButtonsCase::TestEikButbAndEikCbaL

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

//

void CBCTestButtonsCase::TestEikButbAndEikCbaL()

    {

    // Test some API for class TEikButtonCoordinator

    TEikButtonCoordinator coordinator;

    _LIT( KTEikButtonCoordinator, "TEikButtonCoordinator test" );

    AssertTrueL( ETrue, KTEikButtonCoordinator );

    CEikButtonBase* chosenButton = new( ELeave ) CEikButtonBase();

    CleanupStack::PushL( chosenButton );

    coordinator.SetChosenButton( chosenButton );

     _LIT( KSetChosenButton, "SetChosenButton test" );

    AssertTrueL( ETrue, KSetChosenButton );

    CleanupStack::PopAndDestroy( chosenButton );

    }

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

// CBCTestButtonsCase::SetupCommandBtnL

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

//

CEikCommandButton* CBCTestButtonsCase::SetupCommandBtnL()

    {

    //1. just new

    CEikCommandButton* commandButton = new( ELeave )CEikCommandButton();

    CleanupStack::PushL( commandButton );

    //2. construct from res

    TResourceReader reader1;

    iEnv->CreateResourceReaderLC( reader1, R_BCTESTBUTTONS_CMBUT );

    commandButton->ConstructFromResourceL( reader1 );

    _LIT( KConstructFromResourceL1, "ConstructFromResourceL test" );

    AssertTrueL( ETrue, KConstructFromResourceL1 );

    CleanupStack::PopAndDestroy(); //reader1

    return commandButton;

    }

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

// CBCTestButtonsCase::TeardownCommandBtnL

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

//

void CBCTestButtonsCase::TeardownCommandBtnL(CEikCommandButton* aBtn)

    {

    CleanupStack::PopAndDestroy( aBtn );

    _LIT( KDesCommandButton, "~CommandButton() test" );

    AssertTrueL( ETrue, KDesCommandButton );

    }

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

// CBCTestButtonsCase::TestSetBtnLayoutL

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

//

void CBCTestButtonsCase::TestSetBtnLayoutL()

    {

    CEikCommandButton* commandButton = SetupCommandBtnL();

    commandButton->SetButtonLayout( CEikCommandButton::ETextRightPictureLeft );

    _LIT( KSetButtonLayout, "TSetButtonLayout test" );

    AssertTrueL( ETrue, KSetButtonLayout);

    TeardownCommandBtnL(commandButton);

    }

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

// CBCTestButtonsCase::TestExcessSpace

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

//

void CBCTestButtonsCase::TestExcessSpace()

    {

    CEikCommandButton* commandButton = SetupCommandBtnL();

    commandButton->SetExcessSpace( CEikCommandButton::EShare );

    _LIT( KSetExcessSpace, "SetExcessSpace test" );

    AssertTrueL( ETrue, KSetExcessSpace );

    TeardownCommandBtnL(commandButton);

    }

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

// CBCTestButtonsCase::TestStuff

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

//

void CBCTestButtonsCase::TestStuff()

    {

    CEikCommandButton* commandButton = SetupCommandBtnL();

    _LIT( KText, "xxxxxxxxx" );

    commandButton->SetTextL( KText );

    _LIT( KSetTextL1, "SetTextL test" );

    AssertTrueL( ETrue, KSetTextL1 );

    CEikLabel* label = commandButton->Label();

    _LIT( KLabel1, "Label test" );

    AssertTrueL( ETrue, KLabel1 );

    commandButton->SetDisplayContent( CEikCommandButton::ETextOnly );

    _LIT( KSetDisplayContent, "SetDisplayContent test" );

    AssertTrueL( ETrue, KSetDisplayContent );

    TeardownCommandBtnL(commandButton);

    }

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

// CBCTestButtonsCase::TestImgBtnL()

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

//

void CBCTestButtonsCase::TestImgBtnL()

    {

    CEikCommandButton* commandButton = SetupCommandBtnL();

    _LIT( KButtonIconFile1, "z:\\resource\\apps\\BCTestButtons.mbm" );

    TInt normal1 = 1;

    CFbsBitmap * normalBitmap1 = AknIconUtils::CreateIconL( KButtonIconFile1, normal1 );

    CleanupStack::PushL( normalBitmap1 );

    commandButton->SetPictureL( normalBitmap1, NULL );

    _LIT( KSetPictureL1, "SetPictureL test" );

    AssertTrueL( ETrue, KSetPictureL1 );