/*

* Copyright (c) 2007-2009 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:  Definition of the class CESMRNcsPopupListBox

*

*/

#include "emailtrace.h"

#include "cesmrncspopuplistbox.h"

#include <eikclbd.h>

#include <AknsLayeredBackgroundControlContext.h>

#include <StringLoader.h>                       // StringLoader

#include <ct/rcpointerarray.h>

//text truncation

#include <AknBidiTextUtils.h>//line wrapping and mirroring

#include <aknlayoutscalable_apps.cdl.h> //xml layout data for applications

#include <aknlayoutscalable_avkon.cdl.h> //xml layout data of avkon components

#include <esmrgui.rsg>

#include "cesmrncsemailaddressobject.h"

#include "cesmrcontacthandler.h"

#include "cesmrlayoutmgr.h"

namespace { // codescanner::namespace

const TInt KItemExtraHeight = 8;

const TInt KEdge (8);

const TInt KScrollbarWidth (6);

const TInt KListBoxDrawMargin (4);

//drop down list colors since we have no official LAF

#define KWhite TRgb( 255,255,255 )

#define KGraySelectable TRgb( 30,30,30 )

#define KGrayNoEmail TRgb( 215,215,215 )

#define KGrayBackground TRgb( 140,140,140 )

#define KSelectorFallbackColor TRgb( 0,200,200 )

}

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

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

// CESMRNcsPopupListBox::NewL

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

//

CESMRNcsPopupListBox* CESMRNcsPopupListBox::NewL( const CCoeControl* aParent,

                                                  CESMRContactHandler& aContactHandler )

    {

    FUNC_LOG;

    CESMRNcsPopupListBox* self = new (ELeave) CESMRNcsPopupListBox( aContactHandler );

    CleanupStack::PushL(self);

    self->ConstructL( aParent );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRNcsPopupListBox::CESMRNcsPopupListBox

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

//

CESMRNcsPopupListBox::CESMRNcsPopupListBox( CESMRContactHandler& aContactHandler )

    :

    iContactHandler( aContactHandler )

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRNcsPopupListBox::ConstructL

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

//

void CESMRNcsPopupListBox::ConstructL( const CCoeControl* aParent )

    {

    FUNC_LOG;

    CEikTextListBox::ConstructL( aParent, CEikListBox::EPopout );

    CEikTextListBox::SetBorder( TGulBorder::EWithOutline|

                                TGulBorder::EAddTwoPixels|

                                TGulBorder::EAddOneRoundingPixel );

    CreateScrollBarFrameL();

    const CFont* font = AknLayoutUtils::FontFromId( EAknLogicalFontPrimarySmallFont );

    CEikTextListBox::SetItemHeightL( font->HeightInPixels() + KItemExtraHeight );

    iBaseBackroundContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQgnFsGrafEmailContent,

        Rect(),

        EFalse );

    }

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

// CESMRNcsPopupListBox::InitAndSearchL

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

//

void CESMRNcsPopupListBox::InitAndSearchL( const TDesC& aText )

    {

    FUNC_LOG;

    RCPointerArray<CESMRClsItem> matchingArray; // Empty array

    CleanupClosePushL( matchingArray );

    SetSearchTextL( aText );

    OperationCompleteL( ESearchContacts, &matchingArray );

    CleanupStack::PopAndDestroy( &matchingArray );

    }

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

// CESMRNcsPopupListBox::~CESMRNcsPopupListBox

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

//

CESMRNcsPopupListBox::~CESMRNcsPopupListBox()

    {

    FUNC_LOG;

    delete iBaseBackroundContext;

    iMatchingArray.ResetAndDestroy();

    delete iItemTextsArray;

    delete iCurrentSearchText;

    }

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

// CESMRNcsPopupListBox::CreateItemDrawerL

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

//

void CESMRNcsPopupListBox::CreateItemDrawerL()

    {

    FUNC_LOG;

    CESMRNcsListItemDrawer* drawer = new (ELeave) CESMRNcsListItemDrawer( *this );

    iItemDrawer = drawer;

    }

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

// CESMRNcsPopupListBox::MopSupplyObject

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

//

TTypeUid::Ptr CESMRNcsPopupListBox::MopSupplyObject(TTypeUid aId)

    {

    FUNC_LOG;

    if ( aId.iUid == MAknsControlContext::ETypeId )

        {

        return MAknsControlContext::SupplyMopObject( aId, iBaseBackroundContext );

        }

    return CCoeControl::MopSupplyObject( aId );

    }

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

// CESMRNcsPopupListBox::SizeChanged

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

//

void CESMRNcsPopupListBox::SizeChanged()

    {

    FUNC_LOG;

    CEikTextListBox::SizeChanged();

    iBaseBackroundContext->SetRect( Rect() );

    }

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

// CNcsPopupListBox::OfferKeyEventL

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

//

TKeyResponse CESMRNcsPopupListBox::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse ret( EKeyWasNotConsumed );

    if( aKeyEvent.iCode == EKeyDownArrow )

        {

        MoveRemoteLookupItemL( ERemoteLookupItemDown );

        iView->MoveCursorL( CListBoxView::ECursorNextItem, CListBoxView::ENoSelection );

        ret = EKeyWasConsumed;

        }

    else if( aKeyEvent.iCode == EKeyUpArrow )

        {

        TBool stay = EFalse;

        // Move cursor separator line over

        if( CurrentItemIndex() - 1 > 0 && CurrentItemIndex() - 1 == iRMLUItemPosition )

            {

            MoveRemoteLookupItemL( ERemoteLookupItemUp );

            iView->MoveCursorL( CListBoxView::ECursorPreviousItem, CListBoxView::ENoSelection );

            stay = ETrue;

            }

        MoveRemoteLookupItemL( ERemoteLookupItemUp );

        iView->MoveCursorL( CListBoxView::ECursorPreviousItem, CListBoxView::ENoSelection );

        if( stay )

            {

            MoveRemoteLookupItemL( ERemoteLookupItemDown );

            iView->MoveCursorL( CListBoxView::ECursorNextItem, CListBoxView::ENoSelection );

            }

        ret = EKeyWasConsumed;

        }

    if( ret == EKeyWasNotConsumed )

        {

        ret = CEikListBox::OfferKeyEventL( aKeyEvent, aType );

        }

    // call HandleItemAdditionL just in case. There might be changes on remote lookup item place.

    // The call is here, because we don't want to have extra redraw events when the popuplist

    // is not fully updated.

    HandleItemAdditionL();

    return ret;

    }

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

// CESMRNcsPopupListBox::OperationCompleteL

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

//

void CESMRNcsPopupListBox::OperationCompleteL(

        TContactHandlerCmd /*aCmd*/,

        const RPointerArray<CESMRClsItem>* aMatchingItems )

    {

    FUNC_LOG;

    if ( aMatchingItems )

        {

        iMatchingArray.ResetAndDestroy();

        // Replace old matcing items.

        for ( TInt ii = 0; ii < aMatchingItems->Count(); ++ii )

         {

         if ( (*aMatchingItems)[ii] )

            {

            CESMRClsItem* item = (*aMatchingItems)[ii]->CloneLC();

            iMatchingArray.AppendL( item );

            CleanupStack::Pop( item );

            }

         }

        SetListItemsFromArrayL();

        }

    }

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

// CESMRNcsPopupListBox::OperationErrorL

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

//

void CESMRNcsPopupListBox::OperationErrorL( TContactHandlerCmd /*aCmd*/,

                                            TInt /*aError*/ )

    {

    FUNC_LOG;

    //no errors handled here

    }

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

// CESMRNcsPopupListBox::SetSearchTextL

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

//

void CESMRNcsPopupListBox::SetSearchTextL( const TDesC& aText )

    {

    FUNC_LOG;

    delete iCurrentSearchText;

    iCurrentSearchText = NULL; // to remove code scanner warning

    iCurrentSearchText = aText.AllocL();

    iContactHandler.SearchMatchesL( aText, this );

    if(!iRemoteLookupSupported)

        {

        iRemoteLookupSupported = iContactHandler.RemoteLookupSupportedL();

        }

    }

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

// CESMRNcsPopupListBox::ReturnCurrentEmailAddressLC

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

//

CESMRNcsEmailAddressObject* CESMRNcsPopupListBox::ReturnCurrentEmailAddressLC()

    {

    FUNC_LOG;

    CESMRNcsEmailAddressObject* addressObject = NULL;

    if( iMatchingArray.Count() > 0 )

        {

        CESMRClsItem* clsItem = NULL;

        if( iRemoteLookupSupported )

            {

            clsItem =iMatchingArray[CurrentItemIndex()-1];  // -1 because of iRMLUItemPosition

            }

        else

            {

            clsItem =iMatchingArray[CurrentItemIndex()]; // no iRMLUItemPosition

            }

        addressObject= CESMRNcsEmailAddressObject::NewL( clsItem->DisplayName(), clsItem->EmailAddress() );

        CleanupStack::PushL( addressObject );

        if ( clsItem->MultipleEmails() )

            {

            addressObject->SetDisplayFull( ETrue );

            }

        }

    return addressObject;

    }

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

// CESMRNcsPopupListBox::SetPopupMaxRectL

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

//

void CESMRNcsPopupListBox::SetPopupMaxRectL( const TRect& aPopupMaxRect )

    {

    FUNC_LOG;

    iPopupMaxRect = aPopupMaxRect;

    SetPopupHeightL();

    }

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

// CESMRNcsPopupListBox::IsPopupEmpty

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

//

TBool CESMRNcsPopupListBox::IsPopupEmpty() const

    {

    FUNC_LOG;

    if( Model()->NumberOfItems() > 0 )

        {

        return EFalse;

        }

    return ETrue;

    }

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

// CESMRNcsPopupListBox::IsRemoteLookupItemSelected

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

//

TBool CESMRNcsPopupListBox::IsRemoteLookupItemSelected() const

    {

    FUNC_LOG;

    if( CurrentItemIndex() == iRMLUItemPosition && iRemoteLookupSupported )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CESMRNcsPopupListBox::CurrentPopupClsItemsArray

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

//

const RPointerArray<CESMRClsItem>& CESMRNcsPopupListBox::CurrentPopupClsItemsArray() const

    {

    return iMatchingArray;

    }

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

// CESMRNcsPopupListBox::RMLUItemPosition

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

//

TInt CESMRNcsPopupListBox::RMLUItemPosition() const

    {

    FUNC_LOG;

    return iRMLUItemPosition;

    }

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

// CESMRNcsPopupListBox::SetListItemsFromArrayL

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

//

void CESMRNcsPopupListBox::SetListItemsFromArrayL()

    {

    FUNC_LOG;

    // Create totally new text array

    Reset();

    CreateTextArrayAndSetToTheListboxL();

    // append texts to text array

    for( TInt i=0; i < iMatchingArray.Count(); i++ )

        {

        iItemTextsArray->AppendL( iMatchingArray[i]->FullTextL() );

        }

    // Update rmlu item

    SetRemoteLookupItemFirstToTheListL();

    HandleItemAdditionL();

    if( iItemTextsArray && iItemTextsArray->Count() > 0 )

        {

        SetCurrentItemIndex( 0 );

        }

    if ( Observer() )

        {

        Observer()->HandleControlEventL( this,

                MCoeControlObserver::EEventStateChanged );

        }

    if( IsVisible() )

        {

        SetPopupHeightL();

        DrawDeferred();

        }

    }

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

// CESMRNcsPopupListBox::SetPopupHeightL

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

//

void CESMRNcsPopupListBox::SetPopupHeightL()

    {

    FUNC_LOG;

    TInt totalHeight = CalcHeightBasedOnNumOfItems( Model()->NumberOfItems() );

    TRect rect = iPopupMaxRect;

    ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOn );

    //shrink listbox if less than max area needed to show items

    if( rect.Height() >= totalHeight )

        {

        ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff );

        //latch listbox on top of the editorfield

        TRect fieldArea = Parent()->Rect();

        if ( rect.iBr.iY < fieldArea.iBr.iY )

             {

             rect.Move(0, (rect.Height() - totalHeight) );

             }

        rect.SetHeight( totalHeight );

        }

    UpdateScrollBarsL();

    SetRect( rect );

    }

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

// CESMRNcsPopupListBox::SetRemoteLookupItemFirstToTheListL

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

//

void CESMRNcsPopupListBox::SetRemoteLookupItemFirstToTheListL()

    {

    FUNC_LOG;

    if( iRemoteLookupSupported )

        {

        HBufC* rmluText = StringLoader::LoadLC( R_MEET_REQ_EDITOR_ADDRESS_LIST_REMOTE_LOOKUP_SEARCH, *iCurrentSearchText );

        iItemTextsArray->InsertL( 0, *rmluText );

        CleanupStack::PopAndDestroy( rmluText );

        iRMLUItemPosition = 0;

        }

    else

        {

        iRMLUItemPosition = -1;

        }

    }

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

// CESMRNcsPopupListBox::MoveRemoteLookupItemL

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

//

void CESMRNcsPopupListBox::MoveRemoteLookupItemL( TRemoteLookupItemMoveDirection aDirection )

    {

    FUNC_LOG;

    if( iRemoteLookupSupported )

        {

        TInt newRMLUItemIndex = -1;

        TInt newCurrentItem = -1;

        if( aDirection == ERemoteLookupItemUp &&

             iView->CurrentItemIndex() == iView->TopItemIndex() )

            {

            newRMLUItemIndex = iRMLUItemPosition - 1;

            newCurrentItem = CurrentItemIndex() - 1;

            }

        else if( aDirection == ERemoteLookupItemDown &&

                 iView->CurrentItemIndex() == iView->BottomItemIndex() )

            {

            newRMLUItemIndex = iRMLUItemPosition + 1;

            newCurrentItem = CurrentItemIndex() + 1;

            }

        if( ItemExists ( newCurrentItem ) )

            {

            iItemTextsArray->Delete( iRMLUItemPosition );

            HBufC* rmluText = StringLoader::LoadLC( R_MEET_REQ_EDITOR_ADDRESS_LIST_REMOTE_LOOKUP_SEARCH, *iCurrentSearchText );

            iItemTextsArray->InsertL( newRMLUItemIndex, *rmluText );

            CleanupStack::PopAndDestroy( rmluText );

            iRMLUItemPosition = newRMLUItemIndex;

            }

        }

    }

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

// CESMRNcsPopupListBox::CreateTextArrayAndSetToTheListboxL

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

//

void CESMRNcsPopupListBox::CreateTextArrayAndSetToTheListboxL()

    {

    FUNC_LOG;

    if( iItemTextsArray )

        {

        delete iItemTextsArray;

        iItemTextsArray = NULL;

        }

    const TInt KItemTextArrayLen = 8;

    if( !iItemTextsArray )

        {

        iItemTextsArray = new ( ELeave ) CDesCArraySeg( KItemTextArrayLen );

        // Set the popup list data

        Model()->SetItemTextArray( iItemTextsArray );

        Model()->SetOwnershipType( ELbmDoesNotOwnItemArray  );

        }

    }

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

// CESMRNcsPopupListBox::InitialiseL

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

//

void CESMRNcsPopupListBox::Initialise(CESMRLayoutManager* aLayout)

    {

    FUNC_LOG;

    static_cast<CESMRNcsListItemDrawer*>( iItemDrawer )->SetLayoutManager(aLayout);

    }

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