/*

* 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 for list view and item drawer classes

*

*/

#include <w32std.h>

#include <eikenv.h>

#include <aknlists.h>

#include <barsread.h>

#include <akndef.h>

#include <eiktxlbm.h>

#include <eikclbd.h>

#include "bctestlistcolumnbasecase.h"

#include "bctestlistcontainer.h"

#include "bctestlist.hrh"

#include <bctestlist.rsg>

_LIT( KColumnBaseCreate, "Create CEikColumnListBox" );

_LIT( KColumnListTest1, "CEikColumnListBox::EditItemL" );

_LIT( KColumnListTest2, "CEikColumnListBox::GetColorUseListL" );

_LIT( KColumnListTest3, "CEikColumnListBox::HandleResourceChange" );

_LIT( KColumnListTest4, "CEikColumnListBox::FocusChanged" );

_LIT( KColumnListTest5, "CAknColumnListBox::MakeViewClassInstanceL" );

_LIT( KColumnListTest6, "CEikColumnListBox::MakeViewClassInstanceL" );

_LIT( KColumnItemDrawerTest1, "CColumnListBoxItemDrawer::ClearAllPropertiesL" );

_LIT( KColumnItemDrawerTest2, "CColumnListBoxItemDrawer::SetPropertiesL" );

_LIT( KColumnItemDrawerTest3, "CColumnListBoxItemDrawer::ItemWidthInPixels" );

_LIT( KColumnItemDrawerTest4, "CColumnListBoxItemDrawer::DrawItemMark" );

_LIT( KColumnEditorTest1, "CEikColumnListBoxEditor::ConstructL" );

_LIT( KColumnEditorTest2, "CEikColumnListBoxEditor::ItemText" );

_LIT( KColumnEditorTest3, "CEikColumnListBoxEditor::UpdateModelL" );

_LIT( KColumnEditorTest4, "CEikColumnListBoxEditor::Column" );

_LIT( KColumnEditorTest5, "CEikColumnListBoxEditor::HandlePointerEventL" );

_LIT( KColumnDataTest1, "CColumnListBoxData::SetSkinEnabledL" );

_LIT( KColumnDataTest2, "CColumnListBoxData::SetSkinHighlightFrame" );

_LIT( KColumnDataTest3, "CColumnListBoxData::EnableMarqueeL" );

_LIT( KColumnDataTest4, "CColumnListBoxData::SetColumnHorizontalGapL" );

_LIT( KColumnDataTest5, "CColumnListBoxData::ColumnHorizontalGap" );

_LIT( KColumnDataTest6, "CColumnListBoxData::MakeColumnRect" );

_LIT( KColumnDataTest7, "CColumnListBoxData::SetColumnFontForRowL" );

_LIT( KColumnDataTest8, "CColumnListBoxData::SetMarqueeParams" );

_LIT( KColumnDataTest9, "CColumnListBoxData::SetColumnUnderlined" );

_LIT( KColumnDataTest10, "CColumnListBoxData::HighlightAnim" );

_LIT( KColumnDataTest11, "CColumnListBoxData::SetHighlightAnimBackgroundDrawer" );

_LIT( KColumnDataTest12, "CColumnListBoxData::AboutToDrawHighlightAnim" );

_LIT( KColumnDataTest13, "CColumnListBoxData::ConstructLD" );

_LIT( KColumnDataTest14, "CColumnListBoxData::DrawText" );

_LIT( KColumnDataText, "Test text for DrawText" );

_LIT( KClippedText, "Test text" );

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

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

// Symbian 2nd static Constructor

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

//

CBCTestListColumnBaseCase* CBCTestListColumnBaseCase::NewL( 

    CBCTestListContainer* aContainer, CEikonEnv* aEikEnv )

    {

    CBCTestListColumnBaseCase* self = new( ELeave ) CBCTestListColumnBaseCase( 

        aContainer, aEikEnv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ default constructor

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

//

CBCTestListColumnBaseCase::CBCTestListColumnBaseCase( CBCTestListContainer* aContainer,

    CEikonEnv* aEikEnv )

    : CBCTestListBaseCase( aContainer, aEikEnv )

    {    

    }

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

// Destructor

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

//

CBCTestListColumnBaseCase::~CBCTestListColumnBaseCase()

    {      

    delete iBCData;

    }

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

// Symbian 2nd Constructor

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

//

void CBCTestListColumnBaseCase::ConstructL()

    {    

    BuildScriptL(); 

    iBCData = new( ELeave ) CBCTestColumnListBoxData();

    }

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

// CBCTestListColumnBaseCase::BuildScriptL

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

//

void CBCTestListColumnBaseCase::BuildScriptL()

    {    

    for ( TInt i=0; i <= EBCTestCmdOutline47 - EBCTestCmdOutline45; i++ )

        {

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

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

        }      

    }

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

// CBCTestListColumnBaseCase::RunL

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

//

void CBCTestListColumnBaseCase::RunL( TInt aCmd )

    {

    if ( aCmd < EBCTestCmdOutline45 || aCmd > EBCTestCmdOutline47 )

        {

        return;

        }

    ReleaseCase();

    PrepareCaseL( aCmd );

    switch ( aCmd )

        {

        case EBCTestCmdOutline45:

            TestColumnListL();

            break;

        case EBCTestCmdOutline46:

            TestColumnItemDrawerAndEditorL();

            break;

        case EBCTestCmdOutline47:

            TestColumnListDataL();

            break;

        default:

            break;    

        }

    }

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

// CBCTestListColumnBaseCase::PrepareCaseL

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

//

void CBCTestListColumnBaseCase::PrepareCaseL( TInt )

    {

    iListBox = new( ELeave ) CAknSingleStyleListBox();

    AssertNotNullL( iListBox, KColumnBaseCreate );

    TInt resourceId = R_BCTESTLIST_SINGLE_1_ADD_RM;

    SetListBoxFromResourceL( iListBox, resourceId );    

    iContainer->SetControl( iListBox );

    }

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

// CBCTestListColumnBaseCase::ReleaseCaseL

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

//   

void CBCTestListColumnBaseCase::ReleaseCase()

    {

    iContainer->ResetControl();

    iListBox = NULL;

    }    

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

// CBCTestListColumnBaseCase::TestColumnListL

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

// 

void CBCTestListColumnBaseCase::TestColumnListL()

    {    

    TInt maxLength = 3;

    iListBox->EditItemL( 0, maxLength );

    iListBox->StopEditingL( 0 );

    AssertTrueL( ETrue, KColumnListTest1 );

    TInt granularity = 4;

    CArrayFixFlat<TCoeColorUse>* colorUseList = new( ELeave ) 

        CArrayFixFlat<TCoeColorUse>( granularity );

    CleanupStack::PushL( colorUseList );

    iListBox->GetColorUseListL( *colorUseList );

    AssertTrueL( ( colorUseList->Count() > 0 ),  KColumnListTest2 );

    colorUseList->Reset();

    CleanupStack::PopAndDestroy( colorUseList );

    iListBox->HandleResourceChange( KAknsMessageSkinChange );    

    iListBox->HandleResourceChange( KEikDynamicLayoutVariantSwitch );

    AssertTrueL( ETrue, KColumnListTest3 );

    iListBox->FocusChanged( EDrawNow );

    iListBox->FocusChanged( ENoDrawNow );

    AssertTrueL( ETrue, KColumnListTest4 );    

    CListBoxView* view = iListBox->MakeViewClassInstanceL();

    AssertNotNullL( view, KColumnListTest5 );

    delete view;

    CEikColumnListBox* columnList = new( ELeave ) CEikColumnListBox();

    CleanupStack::PushL( columnList );

    TInt resourceId = R_BCTESTLIST_SINGLE_1_ADD_RM;

    SetListBoxFromResourceL( columnList, resourceId );    

    view = columnList->MakeViewClassInstanceL();

    AssertNotNullL( view, KColumnListTest6 );    

    delete view;

    columnList->EditItemL( 0, 1 );

    columnList->StopEditingL( EFalse );

    CleanupStack::PopAndDestroy( columnList );

    CEikColumnListBox* listBox = new( ELeave ) CEikColumnListBox();

    CleanupStack::PushL( listBox );

    listBox->ConstructL( iContainer );

    view = listBox->MakeViewClassInstanceL();

    delete view;

    CleanupStack::PopAndDestroy( listBox );

    }

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

// CBCTestListColumnBaseCase::TestColumnItemDrawerAndEditorL

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

// 

void CBCTestListColumnBaseCase::TestColumnItemDrawerAndEditorL()

    {

    // for column item drawer    

    CColumnListBoxItemDrawer* itemDrawer = iListBox->ItemDrawer();

    itemDrawer->ClearAllPropertiesL();

    AssertTrueL( ETrue, KColumnItemDrawerTest1 );    

    TListItemProperties itemProp;

    itemProp.SetBold( ETrue );

    itemProp.SetItalics( ETrue );

    itemProp.SetUnderlined( ETrue );

    itemProp.SetDimmed( ETrue );

    itemProp.SetColor( KRgbGray );

    itemProp.SetSeparatorAfter( ETrue ); 

    itemDrawer->SetPropertiesL( 0, itemProp );

    AssertTrueL( ETrue, KColumnItemDrawerTest2 );    

    TInt width = itemDrawer->ItemWidthInPixels( 0 );

    AssertTrueL( ETrue, KColumnItemDrawerTest3 );    

    TPoint pt( 0, 0 );

    itemDrawer->DrawItemMark( ETrue, EFalse, pt );

    AssertTrueL( ETrue, KColumnItemDrawerTest4 );

    // for column list editor

    CBCTestColumnListBoxEditor* editor = new( ELeave ) 

        CBCTestColumnListBoxEditor( iListBox->Model() );

    CleanupStack::PushL( editor );

    editor->ConstructL( 0 );

    AssertTrueL( ETrue, KColumnEditorTest1 );

    TPtrC text = editor->ItemText();

    AssertTrueL( ETrue, KColumnEditorTest2 );

    TBool update = editor->UpdateModelL();

    AssertTrueL( ETrue, KColumnEditorTest3 );

    TInt column = editor->Column();

    AssertTrueL( ETrue, KColumnEditorTest4 );

    TPointerEvent event;

    event.iType = TPointerEvent::EButton1Down;

    event.iModifiers = 0;

    TPoint eventPos(0, 30);

    event.iPosition = eventPos;

    event.iParentPosition = eventPos;

    editor->HandlePointerEventL( event );

    AssertTrueL( ETrue, KColumnEditorTest5 );    

    CleanupStack::PopAndDestroy( editor ); 

    }

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

// CBCTestListColumnBaseCase::TestColumnListDataL

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

// 

void CBCTestListColumnBaseCase::TestColumnListDataL()

    {

    CColumnListBoxData* data = iListBox->ItemDrawer()->ColumnData();

    data->SetSkinEnabledL( ETrue );

    AssertTrueL( ETrue, KColumnDataTest1 );

    TAknsItemID id;

    id.Set( KAknsIIDDefault );

    data->SetSkinHighlightFrame( &id, &id );

    AssertTrueL( ETrue, KColumnDataTest2 );

    data->EnableMarqueeL( ETrue );

    AssertTrueL( ETrue, KColumnDataTest3 );

#ifdef __S60_32__     

    iListBox->SetCurrentItemIndex( 0 );//item 1

    TUint32 tInt = data->CurrentItemTextWasClipped();

    _LIT( KColumnDataTest35, "Test CurrentItemTextWasClipped() at long item" ); 

    AssertTrueL( ETrue, KColumnDataTest35 );

    iListBox->SetCurrentItemIndex( 1 );//item 2

    tInt = data->CurrentItemTextWasClipped();

    _LIT( KColumnDataTest36, "Test CurrentItemTextWasClipped() at short item" ); 

    AssertTrueL( ETrue, KColumnDataTest36 );    

    iListBox->DrawNow();

#endif //__S60_32__

    TInt setGap = 5;

    data->SetColumnHorizontalGapL( 0, setGap );

    AssertTrueL( ETrue, KColumnDataTest4 );

    TInt gap = data->ColumnHorizontalGap( 0 );

    AssertIntL( setGap, gap, KColumnDataTest5 );

    TRect rect = iContainer->Rect();

    rect.iBr.iX /= 2;

    TBool setRect = data->MakeColumnRect( 0, rect );

    AssertTrueL( setRect, KColumnDataTest6 );

    data->SetColumnFontForRowL( 0, 0, iEikEnv->NormalFont() );

    AssertTrueL( setRect, KColumnDataTest7 );

    data->SetMarqueeParams( 1, 6, 1000000 );

    data->SetMarqueeParams( 2, 8, 1000000, 100000 );

    AssertTrueL( setRect, KColumnDataTest8 );

    TBitFlags32 flags;

    data->SetColumnUnderlined( flags );

    AssertTrueL( setRect, KColumnDataTest9 );

    data->HighlightAnim();

    AssertTrueL( setRect, KColumnDataTest10 );

    data->SetHighlightAnimBackgroundDrawer( &iDrawer );

    AssertTrueL( setRect, KColumnDataTest11 );

    data->AboutToDrawHighlightAnim();

    AssertTrueL( setRect, KColumnDataTest12 );

    iBCData->TestConstructLD( id );

    AssertTrueL( setRect, KColumnDataTest13 );

    iContainer->ActivateGc();

    CWindowGc& gc = iContainer->SystemGc();

    gc.UseFont( iEikEnv->NormalFont() );

    rect = iContainer->Rect();

    rect.iBr.iX = rect.iTl.iX + 

        iListBox->ItemDrawer()->ItemCellSize().iWidth;

    rect.iBr.iY = rect.iTl.iY + 

        iListBox->ItemDrawer()->ItemCellSize().iHeight;        

    iBCData->SetControl( iListBox );

    iBCData->TestDrawText( gc, rect,  KColumnDataText, KClippedText, 

        0, CGraphicsContext::ELeft, *iEikEnv->NormalFont(), ETrue, EFalse ); 

    AssertTrueL( ETrue, KColumnDataTest14 );

    iContainer->DeactivateGc();

    }

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

// CBCTestColumnListBoxData

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

// Constructor

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

//

CBCTestColumnListBoxData::CBCTestColumnListBoxData()

    {    

    }

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

// Destructor

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

//

CBCTestColumnListBoxData::~CBCTestColumnListBoxData()

    {    

    }

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

// CBCTestColumnListBoxData::ConstructLD

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

//

void CBCTestColumnListBoxData::TestConstructLD( 

    const TAknsItemID& aAnimationIID )

    {

    CColumnListBoxData::ConstructLD( aAnimationIID );

    }

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

// CBCTestColumnListBoxData::TestDrawText

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

//

void CBCTestColumnListBoxData::TestDrawText( 

    CWindowGc& aGc, const TRect& aTextRect, 

    const TDesC& aText, const TDesC& aClippedText, const TInt aBaselineOffset,

	const CGraphicsContext::TTextAlign aAlign, const CFont& aFont,

	const TBool aHighlight, const TBool aIsTextClipped )

    {

    DrawText( aGc, aTextRect, aText, aClippedText, 

            aBaselineOffset, aAlign, aFont, aHighlight, aIsTextClipped );    

    }

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

// TBCTestListBoxAnimBgDrawer

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

// TBCTestListBoxAnimBgDrawer::DrawHighlightAnimBackground

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

//

TBool TBCTestListBoxAnimBgDrawer::

    DrawHighlightAnimBackground( CFbsBitGc& ) const

    {

    return ETrue;

    }

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

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

// CBCTestListBoxAnimBgDrawer::DrawHighlightAnimBackground

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

//

CBCTestColumnListBoxEditor::CBCTestColumnListBoxEditor( 

    MListBoxModel* aModel ): CEikColumnListBoxEditor( aModel )

    {    

    }