/*

* 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 <coecntrl.h>

#include <aknenv.h> 

#include <aknconsts.h>

#include <bctestdomaiwakn.rsg>

#include <ecom.h>

#include <finditemmenu.rsg>

#include <aknjavalists.h>       // for testing APIs in aknjavalists.h

#include <akninputblock.h>      // for testing APIs in AknInputBlock.h

#include <aknindicator.h>       // for testing APIs in aknindicator.h    

#include <aknindicatorplugin.h> // for testing APIs in aknindicatorplugin.h

#include <aknindicatorpluginimpluids.hrh>

#include <aknincallbubblenotify.h>      

#include <aknfilefilterfactory.h> 

#include <aknglobalpopupprioritycontroller.h> 

#include <aknappgrid.h> // for testing APIs in aknappgrid.h

#include "bctestdomaknctrlcase.h" 

#include "bctestdomaiwakncontainer.h" 

#include "bctestdomaiwakn.hrh"

#include "bctestdomaiwaknview.h"

#include "bctestdomaknanimview.h"  // for testing APIs in aknanimview.h

#include "bctestdomaknindicatorcontainer.h" 

#include "bctestdomakncharmap.h" // for testing APIs in akncharmap.h

#include "bctestdomaknbatterypane.h" 

#include "bctestdomaknanimdata.h" 

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

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

// Symbian 2nd static Constructor

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

//

CBCTestDomAknCtrlCase* CBCTestDomAknCtrlCase::NewL( 

    CBCTestDomAiwAknContainer*  aContainer )

    {

    CBCTestDomAknCtrlCase* self = new( ELeave ) CBCTestDomAknCtrlCase( 

        aContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ default constructor

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

//

CBCTestDomAknCtrlCase::CBCTestDomAknCtrlCase( 

    CBCTestDomAiwAknContainer* aContainer )

    : iContainer( aContainer )

    {    

    }

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

// Destructor

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

//

CBCTestDomAknCtrlCase::~CBCTestDomAknCtrlCase()

    {  

    }

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

// Symbian 2nd Constructor

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

//

void CBCTestDomAknCtrlCase::ConstructL()

    { 

    BuildScriptL();

    }

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

// CBCTestDomAknCtrlCase::BuildScriptL

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

//

void CBCTestDomAknCtrlCase::BuildScriptL()

    { 

    // Add script as your need.   

    AddTestL( DELAY(1), 

              //  EBCTestDomCmdOutline3

              LeftCBA,REP( Down, 2 ), LeftCBA,

              TEND );    

    }

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

// CBCTestDomAknCtrlCase::RunL

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

//

void CBCTestDomAknCtrlCase::RunL( TInt aCmd )

    {

    if ( aCmd != EBCTestDomCmdOutline3 )

        {

        return;

        }        

    switch ( aCmd )  

        {

        case EBCTestDomCmdOutline3:    

            {   

            // test Ctrl classes         

            TestAknBattery();//Ctrl 

            TestAknCharMap(); //Ctrl  

            TestAknFileFilterFactory(); //Not Ctrl  

            TestAknGlobalPopupPriorityController(); // Not Ctrl                 

            TestAknIncallBubbleNotify();//Not Ctrl            

            TestAknIndicator();  //Ctrl           

            TestAknInputBlock();  //Ctrl     

            TestListBox(); ////Ctrl ,skip 1 API   

            }

            break;                                            

        default:            

            break;

        }

    }

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

// From class MEikMenuObserver.

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

//

void CBCTestDomAknCtrlCase::ProcessCommandL(TInt /*aCommandId*/) 

    {    

    }

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

// From class MEikMenuObserver.

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

//

void CBCTestDomAknCtrlCase::SetEmphasis(

    CCoeControl* /*aMenuControl*/,

    TBool /*aEmphasis*/)

    {    

    }    

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

// CBCTestDomAknCtrlCase::TestAknBattery()

// Indirectly test APIs in aknbattery.h through bctestdomaknbatterypane.h

// Test Result: OK,SKIP 1 private API which can NOT be test.

//           

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

//      

void CBCTestDomAknCtrlCase::TestAknBattery()

    {

    CBCTestDomAknBatteryPane*  batteryPane = 

        new( ELeave ) CBCTestDomAknBatteryPane();

    CleanupStack::PushL( batteryPane );

    _LIT( 

        KCAknBatteryPane, 

        "CAknBatteryPane() test" );

    AssertNotNullL( batteryPane,  KCAknBatteryPane);      

    batteryPane->SetContainerWindowL( *iContainer );

    TResourceReader resourceReader;

    CCoeEnv::Static()->CreateResourceReaderLC( 

        resourceReader, 

        R_BCTESTDOMAIWAKN_AKNBATTERY_BATTERY_PANE );

    batteryPane->ConstructFromResourceL(resourceReader);  

    CleanupStack::PopAndDestroy(); // resourceReader

    _LIT( 

        KCAknBatteryPaneConstructL, 

        "CAknBatteryPane::ConstructL() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneConstructL );     

    _LIT( 

        KCAknBatteryPaneConstructFromResourceL, 

        "CAknBatteryPane::ConstructFromResourceL() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneConstructFromResourceL );     

    batteryPane->SetBatteryLevel( 0 ); 

    _LIT( 

        KCAknBatteryPaneSetBatteryLevel, 

        "CAknBatteryPane::SetBatteryLevel() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneSetBatteryLevel );     

    TRect  listboxRect( 0,0,20,20 );    

    batteryPane->SetRect( listboxRect );

    _LIT( 

        KCAknBatteryPaneSizeChanged, 

        "CAknBatteryPane::SizeChanged() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneSizeChanged ); 

    TPoint  newPosition( 1,1 );

    batteryPane->SetPosition( newPosition );

    _LIT( 

        KCAknBatteryPanePositionChanged, 

        "CAknBatteryPane::PositionChanged() test" );

    AssertTrueL( ETrue,  KCAknBatteryPanePositionChanged ); 

    batteryPane->HandleResourceChange( KEikColorResourceChange ); 

    _LIT( 

        KCAknBatteryPaneHandleResourceChange, 

        "CAknBatteryPane::HandleResourceChange() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneHandleResourceChange ); 

    batteryPane->CountComponentControls(); 

    _LIT( 

        KCAknBatteryPaneCountComponentControls, 

        "CAknBatteryPane::CountComponentControls() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneCountComponentControls ); 

    batteryPane->ComponentControl( 0 ) ; 

    _LIT( 

        KCAknBatteryPaneComponentControl, 

        "CAknBatteryPane::ComponentControl() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneComponentControl ); 

    batteryPane->DrawDeferred( ) ;

    _LIT( 

        KCAknBatteryPaneDraw, 

        "CAknBatteryPane::Draw() test" );

    AssertTrueL( ETrue,  KCAknBatteryPaneDraw ); 

    CleanupStack::PopAndDestroy( batteryPane );           

    _LIT( 

        KDelCAknBatteryPane, 

        "~CAknBatteryPane() test" );

    AssertTrueL( ETrue,  KDelCAknBatteryPane );     

    }

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

// CBCTestDomAknCtrlCase::TestAknCharMap()

// test APIs in AknCharMap.h

// Test Result: OK

//              

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

//        

void   CBCTestDomAknCtrlCase::TestAknCharMap()

    {   

    CBCTestDomCAknCharMap*  charMap = 

        new( ELeave ) CBCTestDomCAknCharMap();// create CAknCharMap

    CleanupStack::PushL( charMap ) ;       

    _LIT( 

        KCAknCharMap, 

        "CAknCharMap() test" );

    AssertNotNullL( charMap,  KCAknCharMap);             

    RWindow* window = (RWindow*)iContainer->DrawableWindow();

    charMap->SetContainerWindowL( *window ); 

    charMap->ConstructMenuSctRowFromDialogL( 

        R_AVKON_EMAIL_ADDR_SPECIAL_CHARACTER_TABLE_DIALOG );

    _LIT( 

        KConstructMenuSctRowFromDialogL, 

        "CAknCharMap::ConstructMenuSctRowFromDialogL() test" );

    AssertTrueL( ETrue,  KConstructMenuSctRowFromDialogL );         

    charMap->SetCharacterCaseL( EAknSCTUpperCase  );

    _LIT( 

        KCAknCharMapSetCharacterCaseL, 

        "CAknCharMap::SetCharacterCaseL() test" );

    AssertTrueL( ETrue,  KCAknCharMapSetCharacterCaseL );         

    TBuf<4> specialChars;

    charMap->SetBuffer( specialChars );

    _LIT( 

        KCAknCharMapSetBuffer, 

        "CAknCharMap::SetBuffer() test" );

    AssertTrueL( ETrue,  KCAknCharMapSetBuffer );         

    const TRect menuSctRect( 0, 0, 200, 200 );    

    charMap->SetMenuSctRect( menuSctRect );

    _LIT( 

        KCAknCharMapSetMenuSctRect, 

        "CAknCharMap::SetMenuSctRect() test" );

    AssertTrueL( ETrue,  KCAknCharMapSetMenuSctRect ); 

    charMap->HeightInRows();

     _LIT( 

        KCAknCharMapHeightInRows, 

        "CAknCharMap::HeightInRows() test" );

    AssertTrueL( ETrue,  KCAknCharMapHeightInRows );         

    charMap->MinimumSize();

    _LIT( 

        KCAknCharMapMinimumSize, 

        "CAknCharMap::MinimumSize() test" );

    AssertTrueL( ETrue,  KCAknCharMapMinimumSize );         

    TKeyEvent keyEvent;

    keyEvent.iCode = '5' ;

    charMap->OfferKeyEventL( keyEvent, EEventNull );

    _LIT( 

        KCAknCharMapOfferKeyEventL, 

        "CAknCharMap::OfferKeyEventL() test" );

    AssertTrueL( ETrue,  KCAknCharMapOfferKeyEventL );         

    charMap->InputCapabilities();

    _LIT( 

        KCAknCharMapInputCapabilities, 

        "CAknCharMap::InputCapabilities() test" );

    AssertTrueL( ETrue,  KCAknCharMapInputCapabilities );         

    charMap->ActivateL();

    _LIT( 

        KCAknCharMapActivateL, 

        "CAknCharMap::ActivateL() test" );

    AssertTrueL( ETrue,  KCAknCharMapActivateL );         

    charMap->SizeChanged();

    _LIT( 

        KCAknCharMapSizeChanged, 

        "CAknCharMap::SizeChanged() test" );

    AssertTrueL( ETrue,  KCAknCharMapSizeChanged );         

    charMap->HandleResourceChange( KAknsMessageSkinChange );

    _LIT( 

        KCAknCharMapHandleResourceChange, 

        "CAknCharMap::HandleResourceChange() test" );

    AssertTrueL( ETrue,  KCAknCharMapHandleResourceChange );         

    charMap->CountComponentControls();  

    _LIT( 

        KCAknCharMapCountComponentControls, 

        "CAknCharMap::CountComponentControls() test" );

    AssertTrueL( ETrue,  KCAknCharMapCountComponentControls );         

    const TInt controlIndex = 0;

    charMap->ComponentControl( controlIndex  );

    _LIT( 

        KCAknCharMapComponentControl, 

        "CAknCharMap::ComponentControl() test" );

    AssertTrueL( ETrue,  KCAknCharMapComponentControl );         

    TPointerEvent pointerEvent;

    pointerEvent.iType  = TPointerEvent::EButton1Up ;

    charMap->HandlePointerEventL( pointerEvent );

    _LIT( 

        KCAknCharMapHandlePointerEventL, 

        "CAknCharMap::HandlePointerEventL() test" );

    AssertTrueL( ETrue,  KCAknCharMapHandlePointerEventL );         

    charMap->SetObserver( NULL );  

    _LIT( 

        KCAknCharMapSetObserver, 

        "CAknCharMap::SetObserver() test" );

    AssertTrueL( ETrue,  KCAknCharMapSetObserver );         

    charMap->HighlightSctRow( EFalse );

    _LIT( 

        KCAknCharMapHighlightSctRow, 

        "CAknCharMap::HighlightSctRow() test" );

    AssertTrueL( ETrue,  KCAknCharMapHighlightSctRow );     

    CleanupStack::PopAndDestroy( charMap ); // delete charMap

    _LIT(KDelCAknCharMap, 

        "~CAknCharMap() test" );

    AssertTrueL( ETrue,  KDelCAknCharMap ); 

    charMap = new( ELeave ) CBCTestDomCAknCharMap();

    CleanupStack::PushL( charMap ); 

    window = (RWindow*)iContainer->DrawableWindow();

    charMap->SetContainerWindowL( *window );                 

    TResourceReader resourceReader;

    CCoeEnv::Static()->CreateResourceReaderLC( 

        resourceReader, //

        R_AVKON_MENU_SCT_ROW_DEFAULT_CONTENTS_CHINESE ); 

     charMap->ConstructFromResourceL( resourceReader ); 

    CleanupStack::PopAndDestroy(); // resourceReader       

    _LIT( 

        KAnimDataConstructFromResourceL, 

        "CAknCharMap::ConstructFromResourceL() test" );

    AssertTrueL( ETrue,  KAnimDataConstructFromResourceL );         

    CleanupStack::PopAndDestroy( charMap ); // delete charMap, 2nd time

    charMap = new( ELeave ) CBCTestDomCAknCharMap();

    CleanupStack::PushL( charMap );

    window = (RWindow*)iContainer->DrawableWindow();

    charMap->SetContainerWindowL( *window );          

    charMap->ConstructMenuSctRowL( 

        R_AVKON_MENU_SCT_ROW_DEFAULT_CONTENTS_CHINESE );

    _LIT( 

        KConstructMenuSctRowLResourceId, 

        "CAknCharMap::ConstructMenuSctRowL(aResourceId) test" );

    AssertTrueL( ETrue,  KConstructMenuSctRowLResourceId );         

    CleanupStack::PopAndDestroy( charMap ); // delete charMap, 2rd time

    charMap = new( ELeave ) CBCTestDomCAknCharMap();

    CleanupStack::PushL( charMap );

    window = (RWindow*)iContainer->DrawableWindow();

    charMap->SetContainerWindowL( *window );          

    charMap->ConstructMenuSctRowL();      

    _LIT( 

        KConstructMenuSctRowL, 

        "CAknCharMap::ConstructMenuSctRowL() test" );

    AssertTrueL( ETrue,  KConstructMenuSctRowL );         

    CleanupStack::PopAndDestroy( charMap ); 

    }

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

// CBCTestDomAknCtrlCase::TestAknFileFilterFactory()

// test APIs in AknFileFilterFactory.h 

// Test Result: OK

//           

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

//   

void CBCTestDomAknCtrlCase::TestAknFileFilterFactory()

    {

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC( 

        reader, 

        R_BCTESTDOMAIWAKN_AKNFILEFILTERFACTORY_FILTER );// RESOURCE  FILTER 

    AknFileFilterFactory::CreateFilterLC( reader ); //static function 

    _LIT( KCreateFilterLC, "CreateFilterLC() test" );

    AssertTrueL( ETrue,  KCreateFilterLC );     

    CleanupStack::PopAndDestroy(2); // reader and Filter

    }

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

// CBCTestDomAknCtrlCase::TestAknGlobalPopupPriorityController()

// test static APIs in aknglobalpopupprioritycontroller.h ..

// Test Result: OK

//           

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

//   

void CBCTestDomAknCtrlCase::TestAknGlobalPopupPriorityController()

    {

    AknGlobalPopupPriorityController::EnablePriorityControlL();

    _LIT( 

        KEnablePriorityControlL, 

        "EnablePriorityControlL() test" );

    AssertTrueL( ETrue,  KEnablePriorityControlL ); 

    RWindowGroup & rootWinGroup = CCoeEnv::Static()->RootWin() ;       

    TInt ordinalPosition = rootWinGroup.OrdinalPosition();

    AknGlobalPopupPriorityController::SetRootWinOrdinalPosition( 

        ordinalPosition );

    _LIT( 

        KSetRootWinOrdinalPosition, 

        "SetRootWinOrdinalPosition() test" );

    AssertTrueL( ETrue,  KSetRootWinOrdinalPosition );   

    AknGlobalPopupPriorityController::SetPopupPriorityL( *iContainer, 0);

    _LIT( 

        KSetPopupPriorityL, 

        "SetPopupPriorityL() test" );

    AssertTrueL( ETrue,  KSetPopupPriorityL );      

    AknGlobalPopupPriorityController::RemovePopupPriority( *iContainer );

    _LIT( 

        KRemovePopupPriority, 

        "RemovePopupPriority() test" );

    AssertTrueL( ETrue,  KRemovePopupPriority );      

    }

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

// CBCTestDomAknCtrlCase::TestAknIncallBubbleNotify()

// test APIs in   AknIncallBubbleNotify.h                            

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

//  

void CBCTestDomAknCtrlCase::TestAknIncallBubbleNotify()

    {    

    CAknIncallBubble*  incallBubble = CAknIncallBubble::NewL();

    CleanupStack::PushL( incallBubble );

    _LIT( KlBubbleNewL, "CAknIncallBubble::NewL() test" );

    AssertNotNullL( incallBubble, KlBubbleNewL );     

    CleanupStack::PopAndDestroy( incallBubble );   

    _LIT( 

        KDestructor, 

        "~CAknIncallBubble() test" );

    AssertTrueL( ETrue, KDestructor );          

    incallBubble = CAknIncallBubble::NewLC();

    _LIT( 

        KlBubbleNewLC, 

        "CAknIncallBubble::NewLC() test" );

    AssertNotNullL( incallBubble, KlBubbleNewLC );     

    TInt bubbleflags = -1;

    incallBubble->SetIncallBubbleFlagsL( bubbleflags );

    _LIT( 

        KSetIncallBubbleFlagsL, 

        "CAknIncallBubble::SetIncallBubbleFlagsL() test" );

    AssertTrueL( ETrue,  KSetIncallBubbleFlagsL );     

    incallBubble->SetIncallBubbleAllowedInIdleL( EFalse );

    _LIT( 

        KSetIncallBubbleAllowedInIdleL, 

        "CAknIncallBubble::SetIncallBubbleFlagsL() test" );

    AssertTrueL( ETrue,  KSetIncallBubbleAllowedInIdleL );      

    incallBubble->SetIncallBubbleAllowedInUsualL( EFalse );