/*
* Copyright (c) 2002 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:  
*     List container user by message view.
*     Derived from CMceMessageListContainer.
*
*/



// INCLUDE FILES

#include "mceui.h"
#include "MceMessageListContainer.h"
#include "MceMessageListbox.h"
#include "MceMessageListView.h"
#include "MceMessageListItemArray.h"
#include "MceBitmapResolver.h"
#include "MceCommands.hrh"
#include "MceIds.hrh"
#include <mce.rsg>
#include "McePropertySubscriber.h"
#include <PtiEngine.h>
#include <AvkonInternalCRKeys.h> // KCRUidAvkon

#include <msvids.h>
#include <msvuids.h>      // KUidMsvMessageEntry

#include <bldvariant.hrh>

#include <csxhelp/mce.hlp.hrh>
#include <csxhelp/mbxs.hlp.hrh>
#include "MceIds.h"
#include <MuiuMsvUiServiceUtilities.h>

#include <commonphoneparser.h>
#include <featmgr.h>

// For Muiu split
#include <muiumsvuiserviceutilitiesinternal.h>

// CONSTANTS

const TInt KMceTextBufferLength        = 10; // text buffer length
const TInt KMceListContainerGranuality = 4;
// ================= MEMBER FUNCTIONS =======================

// ----------------------------------------------------
// Constructor
// ----------------------------------------------------
CMceMessageListContainer::CMceMessageListContainer( 
    CMceMessageListView& aParentView ) 
    :
    CMceMessageListContainerBase( aParentView )
    {
    }

// ----------------------------------------------------
// Destructor
// ----------------------------------------------------
CMceMessageListContainer::~CMceMessageListContainer()
    {
    delete iT9Interface;
    delete iT9Timer;      
    
    if (iQwertyModeStatusSubscriber)
        {
        iQwertyModeStatusSubscriber->StopSubscribe();
        }
    iQwertyModeStatusProperty.Close();
    delete iQwertyModeStatusSubscriber;
    
    if ( iListBox )
        {
        // icon array is deleted by CMceUi class
        iListBox->ItemDrawer()->FormattedCellData()->SetIconArray( NULL );
        }
    
    delete iListBox;
    delete iListItems;
    delete iSelectedEntries;
    delete iAddedMsvIds;
    }

// ----------------------------------------------------
// CMceMessageListContainer::NewL
// ----------------------------------------------------
CMceMessageListContainer* CMceMessageListContainer::NewL(
    const TRect& aRect,
    CMsvSessionPtr aSession,
    TMsvId aFolderId,
    CMceBitmapResolver& aBitmapResolver,
    CMceMessageListView& aParentView )
    {
    CMceMessageListContainer* self = new (ELeave) CMceMessageListContainer(
        aParentView );
    CleanupStack::PushL(self);
    self->ConstructL( aRect, aSession, aBitmapResolver, aFolderId );
    CleanupStack::Pop(); // self
    return self;
    }

// ----------------------------------------------------
// CMceMessageListContainer::ConstructL
// ----------------------------------------------------
void CMceMessageListContainer::ConstructL(
    const TRect& aRect,
    CMsvSessionPtr aSession,
    CMceBitmapResolver& aBitmapResolver,
    TMsvId aFolderId )
    {
    CreateWindowL();
    SetRect( aRect );

    iListBox = new (ELeave) CMceMessageListBox( *this );
    if(aFolderId == KMsvGlobalOutBoxIndexEntryIdValue) 
        iListBox->ConstructL( this, EAknListBoxStylusMarkableList|EAknListBoxItemSpecificMenuDisabled );
    else
    	iListBox->ConstructL( this, EAknListBoxStylusMarkableList );
		
    iListBox->ItemDrawer()->SetItemMarkReverse( ETrue );
    iListBox->EnableMSKObserver( EFalse );

    iListItems = CMceMessageListItemArray::NewL(
        aSession, aFolderId, EMceListTypeMessage, aBitmapResolver );

    iListBox->Model()->SetItemTextArray( iListItems );
    iListBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );
    
    iListBox->SetListBoxObserver( &iOwningView );
    iListBox->SetMarkingModeObserver( this );
    iSelectedEntries = new (ELeave) CMsvEntrySelection;
    
    iListBox->CreateScrollBarFrameL( ETrue );
    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(
        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    iListBox->ItemDrawer()->FormattedCellData()
        ->SetIconArray( aBitmapResolver.IconArray() );
    
    iPreviousInputMethod = EFalse;
    
    iAddedMsvIds = new (ELeave) CMsvEntrySelection;
    
    User::LeaveIfError( iQwertyModeStatusProperty.Attach( 
        KCRUidAvkon, KAknQwertyInputModeActive ));
  
    HandleQwertyModeChangeNotification();
    iQwertyModeStatusSubscriber = CMcePropertySubscriber::NewL(
        TCallBack( QwertyModeChangeNotification, this ), iQwertyModeStatusProperty );

    iQwertyModeStatusSubscriber->SubscribeL();
    iDialerEvent = EFalse ;

    }
    
// ----------------------------------------------------
// CMceMessageListContainer::MceListId
// ----------------------------------------------------
TInt CMceMessageListContainer::MceListId() const
    {
    return EMceListTypeTwoRow;
    }
    

// ----------------------------------------------------
// CMceMessageListContainer::CountComponentControls
// ----------------------------------------------------
TInt CMceMessageListContainer::CountComponentControls() const
    {
    return 1; // always only listbox
    }

// ----------------------------------------------------
// CMceMessageListContainer::ComponentControl
// ----------------------------------------------------
CCoeControl* CMceMessageListContainer::ComponentControl(TInt /*aIndex*/) const
    {
    return iListBox;
    }

// ----------------------------------------------------
// CMceMessageListContainer::SetFolderL
// ----------------------------------------------------
void CMceMessageListContainer::SetFolderL( TMsvId aFolderId )
    {
    if ( iListItems )
        {
        iListItems->SetFolderL( aFolderId );
        }
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::Count
// ----------------------------------------------------
TInt CMceMessageListContainer::Count() const
    {
    return iListItems->MdcaCount();
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::MessageCount
// ----------------------------------------------------
TInt CMceMessageListContainer::MessageCount() const
    {
    return iListItems->MessageCount();
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::FolderCount
// ----------------------------------------------------
TInt CMceMessageListContainer::FolderCount() const
    {
    return iListItems->FolderCount();
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::CurrentFolderId
// ----------------------------------------------------
TMsvId CMceMessageListContainer::CurrentFolderId() const
    {
    TMsvId folderId = 0;
    if ( iListItems )
        {
        folderId = iListItems->FolderId();
        }
    return folderId;
    }

// ----------------------------------------------------
// CMceMessageListContainer::SetCurrentItemIdL
// ----------------------------------------------------
TBool CMceMessageListContainer::SetCurrentItemIdL( TMsvId aEntryId )
    {
    const TInt selectedIndex = ItemIndex( aEntryId );
    if ( selectedIndex != KErrNotFound )
        {
        iAnchorItemIndex = selectedIndex; 
        iAnchorItemId = aEntryId;
        
		//calulate the top item index
		TInt topIndex = iListBox->View()->CalcNewTopItemIndexSoItemIsVisible( selectedIndex );
		iListBox->SetTopItemIndex( topIndex );
		iListBox->SetCurrentItemIndex( selectedIndex );
		iListBox->UpdateScrollBarsL();
		iListBox->DrawDeferred();
//        iListBox->SetCurrentItemIndex( selectedIndex );
        }
    return (selectedIndex != KErrNotFound);
        
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::RefreshListbox
// ----------------------------------------------------
void CMceMessageListContainer::RefreshListbox()
    {
    iListBox->DrawDeferred();     
    }

// ----------------------------------------------------
// CMceMessageListContainer::ItemCountChangedL
// ----------------------------------------------------
void CMceMessageListContainer::ItemCountChangedL( TBool aItemsAdded,
        CArrayFix<TInt>* aAddedIndexes )
    {
    if ( aItemsAdded )
        {
        if( aAddedIndexes )
            {
            iListBox->HandleItemAdditionL( *aAddedIndexes );
            }
        else
            {
            iListBox->HandleItemAdditionL();
            }        
        }
    else
        {
        iListBox->HandleItemRemovalL();
        if( iOwningView.MarkingMode() && iListItems->MessageCount() <= 0 )
            {
            SetMarkingModeOff();
            }
        }
    }
    
    
// ----------------------------------------------------
// CMceMessageListContainer::FolderEntry
// ----------------------------------------------------
const TMsvEntry& CMceMessageListContainer::FolderEntry() const
    {
    return iListItems->FolderEntry();
    }

// ----------------------------------------------------
// CMceMessageListContainer::CurrentItemIndex
// ----------------------------------------------------
TInt CMceMessageListContainer::CurrentItemIndex() const
    {
    return iListBox->CurrentItemIndex();
    }

// ----------------------------------------------------
// CMceMessageListContainer::CurrentItemId
// ----------------------------------------------------
TMsvId CMceMessageListContainer::CurrentItemId() const
    {
    return iListItems->ItemId( CurrentItemIndex() );
    }

// ----------------------------------------------------
// CMceMessageListContainer::CurrentItemListItem
// ----------------------------------------------------
TMceListItem CMceMessageListContainer::CurrentItemListItem() const
    {
    return iListItems->Item( CurrentItemIndex() );
    }


// ----------------------------------------------------
// CMceMessageListContainer::CurrentItemSelectionL
// ----------------------------------------------------
CMsvEntrySelection* CMceMessageListContainer::CurrentItemSelectionL()
    {
    return iSelectedEntries->CopyL();
    }

// ----------------------------------------------------
// CMceMessageListContainer::CurrentItemSelectionRefreshL
// ----------------------------------------------------
CMsvEntrySelection* CMceMessageListContainer::CurrentItemSelectionRefreshL()
    {
    MarkItemSelectionL();
    return CurrentItemSelectionL();
    }

// ----------------------------------------------------
// CMceMessageListContainer::CurrentItemSelectionCount
// ----------------------------------------------------
TInt CMceMessageListContainer::CurrentItemSelectionCount() const
    {
    if ( iListItems->MdcaCount() == 0 )
        {
        return 0;
        }
    return Max( 1, iListBox->View()->SelectionIndexes()->Count() );
    }


// ----------------------------------------------------
// CMceOneRowMessageListContainer::SelectionCount
// ----------------------------------------------------
TInt CMceMessageListContainer::SelectionCount() const
    {
    return iListBox->View()->SelectionIndexes()->Count();
    }

// ----------------------------------------------------
// CMceMessageListContainer::ClearSelection
// ----------------------------------------------------
void CMceMessageListContainer::ClearSelection()
    {
    iSelectedEntries->Reset();
    iListBox->View()->ClearSelection();
    }

// ----------------------------------------------------
// CMceMessageListContainer::ItemIndex
// ----------------------------------------------------
TInt CMceMessageListContainer::ItemIndex( TMsvId aId ) const
    {
    return iListItems->ItemIndex( aId );
    }


// ----------------------------------------------------
// CMceMessageListContainer::MarkItemSelectionL
// ----------------------------------------------------
void CMceMessageListContainer::MarkItemSelectionL()
    {
    const CListBoxView::CSelectionIndexArray* selection =
        iListBox->View()->SelectionIndexes();
    TInt count = selection->Count();
    iSelectedEntries->Reset();
    if ( count != 0 )
        {
        for (TInt loop=0; loop < count; loop++ )
            {
            TMsvId id = iListItems->ItemId( (*selection)[loop] );
            if ( id != KErrNotFound )
                {
                iSelectedEntries->AppendL( id );
                }
            }
        }
    else
        {
        TMsvId id = CurrentItemId();
        if ( id != KErrNotFound )
            {
            // nothing in selection so add item under "cursor"
            iSelectedEntries->AppendL( id );
            }
        }
    }

// ----------------------------------------------------
// CMceMessageListContainer::AddItemToSelectionL
// ----------------------------------------------------
void CMceMessageListContainer::AddItemToSelectionL( TMsvId aEntryId )
    {
    if ( aEntryId > KMsvRootIndexEntryId )
        {
        iSelectedEntries->AppendL( aEntryId );
        }
    }
// ----------------------------------------------------
// CMceMessageListContainer::AddCurrentItemToSelectionL
// ----------------------------------------------------
void CMceMessageListContainer::AddCurrentItemToSelectionL()
    {
    iListBox->View()->SelectItemL( CurrentItemIndex() );
    AddItemToSelectionL( CurrentItemId() );
    }

// ----------------------------------------------------
// CMceMessageListContainer::RemoveItemFromSelection
// ----------------------------------------------------
void CMceMessageListContainer::RemoveItemFromSelection( TMsvId aEntryId )
    {
    TInt index = iSelectedEntries->Find( aEntryId );
    if ( index >= 0 )
        {
        iSelectedEntries->Delete( index );
        }
    }

// ----------------------------------------------------
// CMceMessageListContainer::RemoveCurrentItemFromSelection
// ----------------------------------------------------
void CMceMessageListContainer::RemoveCurrentItemFromSelection()
    {
    iListBox->View()->DeselectItem( CurrentItemIndex() );
    RemoveItemFromSelection( CurrentItemId() );
    }

// ----------------------------------------------------
// CMceMessageListContainer::RefreshSelectionIndexesL
// ----------------------------------------------------
void CMceMessageListContainer::RefreshSelectionIndexesL( TBool /*aForceUpdate*/ )
    {

    
    }

// ----------------------------------------------------
// CMceMessageListContainer::AddAllToSelectionL
// ----------------------------------------------------
void CMceMessageListContainer::AddAllToSelectionL()
    {
    CArrayFixFlat<TInt>* indexArray = new( ELeave ) CArrayFixFlat<TInt>(
        KMceListContainerGranuality );
    CleanupStack::PushL( indexArray );
    iSelectedEntries->Reset();
    const TInt count = iListItems->MdcaCount();
    for ( TInt loop = 0; loop < count; loop++ )
        {
        TMsvId id = iListItems->ItemId( loop );
        if ( !iListItems->IsItemFolder( id ) )
            {
            indexArray->AppendL( loop );
            iSelectedEntries->AppendL( id );
            }
        }
    iListBox->SetSelectionIndexesL( indexArray );
    CleanupStack::PopAndDestroy( indexArray );
    }
    

// ----------------------------------------------------
// CMceMessageListContainer::MarkAllReadMessagesL
// ----------------------------------------------------
void CMceMessageListContainer::MarkAllReadMessagesL()
    {
    CArrayFixFlat<TInt>* msgIndexArray = new( ELeave ) CArrayFixFlat<TInt>( 4 );
    CleanupStack::PushL( msgIndexArray );
    iSelectedEntries->Reset();
    iListBox->View()->ClearSelection();

    const TInt count = iListItems->MdcaCount();
    for ( TInt loop = 0; loop < count; loop++ )
        {
        TMsvEntry entry;
        TMsvId entryId = iListItems->ItemId( loop );
        if ( iListItems->GetEntry( entryId, entry ) == KErrNone )
            {
            if ( entry.iType == KUidMsvMessageEntry &&
                 !entry.Unread() )
                {
                msgIndexArray->AppendL( loop );
                }
            }
        }
      
    if ( msgIndexArray->Count() > 0 )
        {
        iListBox->SetSelectionIndexesL( msgIndexArray );        
        iListBox->DrawDeferred();
        }    
    CleanupStack::PopAndDestroy( msgIndexArray );
    }


// ----------------------------------------------------
// CMceMessageListContainer::IsItemSelected
// ----------------------------------------------------
TBool CMceMessageListContainer::IsItemSelected( TMsvId aItemId )
    {
    // Find selected items
    const CListBoxView::CSelectionIndexArray* items =
         iListBox->SelectionIndexes();
    TInt itemIndex = iListItems->ItemIndex( aItemId );
    TKeyArrayFix key(0, ECmpTInt);
    TInt pos;

    // Is item in selection array
    if ( items->Find(itemIndex, key, pos) != KErrNone )
        {
        return EFalse;
        }
    else
        {
        return ETrue;        
        }
    }


// ----------------------------------------------------
// CMceMessageListContainer::SetMskL
// ----------------------------------------------------
void CMceMessageListContainer::SetMskL()
    {
    TInt currentItem = CurrentItemIndex();
    TInt resourceId = currentItem == 0 ?
        R_MCE_MSK_BUTTON_SELECT:R_MCE_MSK_BUTTON_OPEN;

    if ( resourceId != iCurrMskResource )
        {
        iCurrMskResource = resourceId;
        CEikButtonGroupContainer* cba;
        cba = CEikButtonGroupContainer::Current();
        const TInt KMSKPosition = 3;
        cba->SetCommandL( KMSKPosition, iCurrMskResource );
        cba->DrawDeferred();
        }
    }


// ----------------------------------------------------
// CMceMessageListContainer::FocusChanged
// ----------------------------------------------------
void CMceMessageListContainer::FocusChanged(TDrawNow /*aDrawNow*/)
    {
    if (iListBox)
        {
        iListBox->SetFocus(IsFocused());
        }
    }


// ----------------------------------------------------
//  CMceMessageListContainer::MarkedItemsCount()
// ----------------------------------------------------
TInt CMceMessageListContainer::MarkedItemsCount()
    {
    return iListBox->View()->SelectionIndexes()->Count();
    }


// ----------------------------------------------------
// CMceMessageListContainer::OfferKeyEventL
// ----------------------------------------------------
TKeyResponse CMceMessageListContainer::OfferKeyEventL(
    const TKeyEvent& aKeyEvent,
    TEventCode aType )
    {

    if ( !iT9Interface )
        {        
        iT9Interface = CPtiEngine::NewL();
        if ( iInputMethodQwerty )
            {
            iT9Interface->SetInputMode( EPtiEngineQwerty );
            iT9Interface->ActivateLanguageL( User::Language(), EPtiEngineQwerty );        
            }
        else
            {
            iT9Interface->SetInputMode( EPtiEngineMultitapping );
        iT9Interface->ActivateLanguageL( User::Language(), EPtiEngineMultitapping );        
            }
        iPreviousInputMethod = iInputMethodQwerty;
        }
    else
        {
        if ( iInputMethodQwerty != iPreviousInputMethod )
            {
            if ( iInputMethodQwerty )
                {
                iT9Interface->SetInputMode( EPtiEngineQwerty );
                iT9Interface->ActivateLanguageL( User::Language(), EPtiEngineQwerty );        
                }
            else
                {
                iT9Interface->SetInputMode( EPtiEngineMultitapping );
                iT9Interface->ActivateLanguageL( User::Language(), EPtiEngineMultitapping );        
                }
            iPreviousInputMethod = iInputMethodQwerty;
            }
        }
    
    if ( !iT9Timer )
        {
        iT9Timer = CMceMessageListContainerKeyTimer::NewL( *iT9Interface );
        }

    if ( iListBox )
        {
  
        if ( aType == EEventKeyUp )
            {
            iOwningView.SetMSKButtonL();
            iDialerEvent = EFalse ; 
            }

        if ( aType == EEventKeyDown && iDialerEvent )
            {
            iDialerEvent = EFalse ;
            }
        if ( aType == EEventKey )
            {
            
            iOwningView.CancelMailboxTimer();

            if ( aKeyEvent.iCode == EKeyLeftArrow || aKeyEvent.iCode == EKeyRightArrow )
                {
                if( iOwningView.MarkingMode() )
                    {
                    return EKeyWasConsumed;
                    }
                return EKeyWasNotConsumed;
                }

            
			if ( ( iOwningView.MenuBar()->ItemSpecificCommandsEnabled() || SelectionCount() ) && aKeyEvent.iCode == EKeyBackspace )
                {
                MarkItemSelectionL();
                SetAnchorItemIdL( 
                    CMceMessageListContainerBase::EMessageListOperationGeneral );
                const TInt itemCount = CurrentItemSelectionCount();
                if ( itemCount != 0 &&
                     ( itemCount != 1 ||
                       CurrentItemId() != KMceTemplatesEntryIdValue )
                   )
                    {
                    if ( !iListItems->DeleteDiscard( CurrentItemId() ) )
                        {
                        //if outbox and mms/sms connected, not delete
                        iOwningView.HandleCommandL( EMceCmdDelete );
                        }
                    }
                return EKeyWasConsumed;
                }
            else if ( aKeyEvent.iCode == EKeyOK ||  aKeyEvent.iCode == EKeyEnter )
                {
                if ( aKeyEvent.iModifiers & EModifierShift ||
                       aKeyEvent.iModifiers & EModifierCtrl )
                    {
                    if ( iListItems->FolderId() != KMsvGlobalOutBoxIndexEntryIdValue &&
                         IsCurrentItemFolder() )
                        {
                        return EKeyWasNotConsumed;
                        }
                    }
                else
                    {
                    iOwningView.SetHideExitCommand( ETrue );
                    if ( iListItems->FolderId() == KMsvGlobalOutBoxIndexEntryIdValue ||
                        iOwningView.SyncMlOutboxInbox( KMsvGlobalOutBoxIndexEntryId ) ||
                        CurrentItemSelectionCount() == 0 ||
                        iOwningView.CheckMMSNotificationOpenL() )
                        {
                        if(iListItems->FolderId() == KMsvGlobalOutBoxIndexEntryIdValue)
                            {
                            iOwningView.SetContextCommandFlag(ETrue);
                            }
                        // list is empty, open options menu
                        iOwningView.ProcessCommandL( EAknSoftkeyOptions );
                        return EKeyWasConsumed;
                        }
                    }
                }

            else if ( aKeyEvent.iCode == EKeyYes )
                {
                if (!iDialerEvent && aKeyEvent.iRepeats == 0) 
	                {
                // send key has been pressed in Inbox or in Documents folder
                TMsvId folderId = iListItems->FolderId();
                if ( folderId != KMsvDraftEntryId &&
                    folderId != KMsvGlobalOutBoxIndexEntryId &&
                    folderId != KMsvSentEntryId &&       
                    folderId != KMceTemplatesEntryId                   
                    && ( CurrentItemSelectionCount() == 1 )  )
                    {       
                    if ( !( iListItems->IsFolderRemote() ) )
                        {
                        TMsvId id = CurrentItemId();
                        TBool validNumber = EFalse;
                        TBuf<KMceVisibleTextLength> recipientstring;
                        TPhCltTelephoneNumber number;
                        CMceUi* mceUi = static_cast<CMceUi*>( iEikonEnv->AppUi() );
                        validNumber = MceUtils::ValidPhoneNumberL( id, mceUi->Session(), number, &recipientstring );
                        if (KErrNotFound != number.Match( recipientstring ))
                            {
                            recipientstring = KNullDesC;
                            }

                        //
                        // Callback number is supported in CDMA mode. If there isn't a phone
                        // book match for the sender, it gets confusing to display the sender's
                        // number (contained in recipientstring) and the callback number
                        // (contained in the number field) via CallToSenderQueryL.
                        // Therefore, if the recipientstring differs from the phone number
                        // to be used to call the sender and recipientstring is also a phone
                        // number, we won't display recipientstring when running in CDMA mode.
                        //
                        if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )
                            {
                            if ( CommonPhoneParser::IsValidPhoneNumber( recipientstring, CommonPhoneParser::ESMSNumber ) )
                                {
                                recipientstring = KNullDesC;
                                }
                            }

                        if ( validNumber )
                            {                        
	                            iAvkonAppUi->SetKeyEventFlags( CAknAppUiBase::EDisableSendKeyShort | CAknAppUiBase::EDisableSendKeyLong ); 
                            MsvUiServiceUtilitiesInternal::CallToSenderQueryL( number, recipientstring, EFalse );
	                            iAvkonAppUi->SetKeyEventFlags( 0x00 ); 
                            }
                        }
                    else   //(iiListItems->IsFolderRemote()) Enable Sendkey in Mail List
                        {
                        iAvkonAppUi->SetKeyEventFlags( CAknAppUiBase::EDisableSendKeyShort | CAknAppUiBase::EDisableSendKeyLong );
                        iOwningView.HandleSendkeyInMailboxL( CurrentItemId() );  
                        iAvkonAppUi->SetKeyEventFlags( 0x00 );
                        }
                    }           
                SetAnchorItemIdL( 
                    CMceMessageListContainerBase::EMessageListOperationGeneral );
	                }
                return EKeyWasConsumed;
                }           

            else if ( IsValidSearchKey( aKeyEvent ) )
                {
                if ( !( FeatureManager::FeatureSupported(KFeatureIdJapanese) ||
		    FeatureManager::FeatureSupported(KFeatureIdChinese) )  )
                    {                
                    HandleShortcutForSearchL( aKeyEvent );
                    }   
                }
            else if (  aKeyEvent.iCode == (TUint)EPtiKeyStar )
                {              
                if ( HasHandleStarKeyDoneL() ) // * key
                    {
                    return EKeyWasConsumed;
                    }
                }  
            }

        if ( iListItems->MdcaCount() > 0 && iListBox->View()->SelectionIndexes()->Count() == 0 )
        	{
        	iOwningView.SetHideExitCommand( EFalse );
        	}
        TKeyResponse ret = iListBox->OfferKeyEventL(aKeyEvent, aType);
        iOwningView.SetCurrentItemId();
        SetAnchorItemIdL( 
            CMceMessageListContainerBase::EMessageListOperationGeneral );
        if ( ( aKeyEvent.iModifiers & EModifierShift ||
              aKeyEvent.iModifiers & EModifierCtrl ) &&
             ( aKeyEvent.iCode == EKeyOK || 
               aKeyEvent.iCode == EKeyEnter ||
               aKeyEvent.iCode == EKeyUpArrow ||
               aKeyEvent.iCode == EKeyDownArrow ) )
            {
            MarkItemSelectionL();
            iOwningView.SetMSKButtonL();
            }
        else if ( iOwningView.IsMSKMailBox() &&
             ( aKeyEvent.iCode == EKeyUpArrow || aKeyEvent.iCode == EKeyDownArrow ) )
            {
            iOwningView.SetMSKButtonL();                    
            }
        return ret;
        }
    else
        {
        return EKeyWasNotConsumed;
        }

    }

// ----------------------------------------------------
// CMceMessageListContainer::IsCurrentItemFolder
// ----------------------------------------------------
TBool CMceMessageListContainer::IsCurrentItemFolder() const
    {
    TBool isCurrentFolder = EFalse;
    const TMsvId id = CurrentItemId();
    if ( id != KErrNotFound )
        {
        isCurrentFolder = iListItems->IsItemFolder( id );
        }
    return isCurrentFolder;
    }
    
    
// ----------------------------------------------------
// CMceMessageListContainer::IsCurrentItemFolder
// ----------------------------------------------------
TBool CMceMessageListContainer::IsItemFolder( TMsvId aItemId ) const
    {
    return iListItems->IsItemFolder( aItemId );
    }


// ----------------------------------------------------
// CMceMessageListContainer::IsItemFolder
// ----------------------------------------------------
TBool CMceMessageListContainer::IsItemFolder(TInt aIndex) const
    {
    TBool isCurrentFolder = EFalse;
    const TMsvId id = iListItems->ItemId( aIndex );
    if ( id != KErrNotFound )
        {
        isCurrentFolder = iListItems->IsItemFolder( id );
        }
    return isCurrentFolder;
    }


// ----------------------------------------------------
// CMceOneRowMessageListContainer::IsItemRemote
// ----------------------------------------------------
TBool CMceMessageListContainer::IsItemRemote( TMsvId aItemId ) const
    {
    return iListItems->IsItemRemote( aItemId );
    }


// ----------------------------------------------------
// CMceMessageListContainer::IsOutboxOpened
// ----------------------------------------------------
TBool CMceMessageListContainer::IsOutboxOpened() const
    {
    return IsOpenedFolder( KMsvGlobalOutBoxIndexEntryIdValue );
    }


// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
TBool CMceMessageListContainer::IsOpenedFolder( TMsvId aFolderId ) const
    {
    return ( iListItems->FolderId() == aFolderId );
    }
    
    
// ----------------------------------------------------
// CMceMessageListContainer::DisplayOptionsMenuFromSelectionKey
// ----------------------------------------------------
TBool CMceMessageListContainer::DisplayOptionsMenuFromSelectionKey() const
    {
    return ( iListItems->MdcaCount() == 0 || iListBox->View()->SelectionIndexes()->Count() );
    }


// ----------------------------------------------------
// CMceMessageListContainer::GetHelpContext
// returns helpcontext as aContext
// ----------------------------------------------------
void CMceMessageListContainer::GetHelpContext
        (TCoeHelpContext& aContext) const
    {
    TMsvId folderId = iListItems->FolderId();
    aContext.iMajor = KMceApplicationUid;

    TBool isRemoteFolder = iListItems->IsFolderRemote();

    /*if ( iOwningView.SyncMlOutboxInbox( KMsvGlobalInBoxIndexEntryId ) )
        {
        aContext.iContext = KMCE_HLP_MESS_SYNCI;
        }
    else if ( iOwningView.SyncMlOutboxInbox( KMsvGlobalOutBoxIndexEntryId ) )
        {
        aContext.iContext = KMCE_HLP_MESS_SYNCO;
        }

    else if ( iOwningView.IsSyncMl() )
        {
        aContext.iContext = KMCE_HLP_MESS_SYNC;
        }

    else*/
    if ( folderId == KMsvDraftEntryId )
        {
        aContext.iContext = KMCE_HLP_DRAFTS;
        }
    else if ( folderId == KMsvGlobalOutBoxIndexEntryId )
        {
        aContext.iContext = KMCE_HLP_OUTBOX;
        }
    else if ( folderId == KMsvGlobalInBoxIndexEntryId )
        {
        aContext.iContext = KMCE_HLP_INBOX;
        }
    else if ( folderId == KMsvSentEntryId )
        {
        aContext.iContext = KMCE_HLP_SENT_ITEMS;
        }
    else if ( folderId == KMceDocumentsEntryId )
        {
        aContext.iContext = KMCE_HLP_DOCUMENTS;
        }
    else if ( folderId == KMceTemplatesEntryId )
        {
        aContext.iContext = KMCE_HLP_TEMPLATES;
        }
    else if ( !isRemoteFolder )
        {
        // own folder
        aContext.iContext = KMCE_HLP_FOLDER;
        }
    else
        {
        // remote account
        TBool isConnected = iListItems->IsConnected();
        if ( isConnected )
            {
            aContext.iContext = KMCE_HLP_MAILBOX_ONLINE;
            }
        else
            {
            aContext.iContext = KMCE_HLP_MAILBOX_OFFLINE;
            }
        }

    }

// ----------------------------------------------------
// CMceMessageListContainer::SyncMlOutboxOpened
// ----------------------------------------------------
TBool CMceMessageListContainer::SyncMlOutboxOpened() const
    {
    return ( iOwningView.SyncMlOutboxInbox( KMsvGlobalOutBoxIndexEntryId ) );
    }



// ----------------------------------------------------
// CMceMessageListContainer::HandleResourceChange
// ----------------------------------------------------
void CMceMessageListContainer::HandleResourceChange( TInt aType )
    {    
    CCoeControl::HandleResourceChange( aType );
    if ( iListBox && aType == KEikDynamicLayoutVariantSwitch )        
        {
        
	    iListBox->ItemDrawer()->SetItemMarkReverse( ETrue );
        SetRect( iOwningView.ClientRect() );
        }        
    }


// ----------------------------------------------------
// CMceMessageListContainer::SizeChanged
// ----------------------------------------------------
void CMceMessageListContainer::SizeChanged()
    {
    if (iListBox)
        {
        iListBox->SetRect( Rect() );
	    iListBox->ItemDrawer()->SetItemMarkReverse( ETrue );
        }
    }

// ----------------------------------------------------
// CMceMessageListContainer::ProcessCommandL
// ----------------------------------------------------
void CMceMessageListContainer::ProcessCommandL(TInt aCommand)
    {
    if ( aCommand == EAknSoftkeyShiftMSK )
        {
        // Pass the MSK marking command as a key event to controls
        const CListBoxView::CSelectionIndexArray* items =
            iListBox->SelectionIndexes();
        
        // check what state item under "cursor" is        
        TKeyArrayFix key(0, ECmpTInt);
        TInt pos;
        if ( !items->Find(CurrentItemIndex(), key, pos))
            {
            RemoveCurrentItemFromSelection();
            }
        else
            {
            AddCurrentItemToSelectionL();
            }
        iOwningView.SetMSKButtonL();            
        }
    }
    
 
// ----------------------------------------------------
// CMceMessageListContainer::StateCanBeChangedByStarKeyL() const
// Exam if it is the situation that * key can change message state
// Returns ETrue if it can
// Public
// ----------------------------------------------------  
TBool CMceMessageListContainer::StateCanBeChangedByStarKeyL() const
    {
    TMsvId folderId = iListItems->FolderId();
    TBool isRemoteFolder = iListItems->IsFolderRemote();
    
    if ( ( iListItems->MdcaCount() > 0 && 
        iListBox->View()->SelectionIndexes()->Count() == 0 && 
        !IsCurrentItemFolder() ) && 
        ( folderId == KMsvGlobalInBoxIndexEntryId ||  //Inbox
        folderId == KMceDocumentsEntryId ||     //Documents
        iListItems->GetParentFolderId() == KMceDocumentsEntryId || //Subfolder of Documents
        isRemoteFolder ) )  // Mailbox & SyncMl
        {
        if ( iOwningView.IsSyncMl() )
            {            
            return( iOwningView.ListContainer()->FolderEntry().iRelatedId  == KMsvGlobalInBoxIndexEntryId );//Inbox of SyncMail     
            }            
        return ETrue;
        }
     else 
        {                   
        return EFalse;           
        }                
    }
 
// TODO: maybe worth of adding new function for these listbox->ItemDrawer()->SetItemMarkXXX function?
//      MarkItemSelectionL(); does selection but not mark
//      AddCurrentItemToSelectionL(); selects and marks


//-------------------------------------------------------------------------------
// CMceMessageListContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )
//-------------------------------------------------------------------------------
void CMceMessageListContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )
    {
    if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
        {
        iOwningView.SetMSKButtonL();
        iOwningView.SetCurrentItemId();
        if ( ( iOwningView.IsMSKMailBox() || 
        		iListItems->FolderId() == KMsvDraftEntryId ) && 
        		iListBox->CurrentItemIndex() < 0 ) 
            {
            iOwningView.ProcessCommandL( EAknSoftkeyContextOptions );
            }
        }
    if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
        {
        if ( iOwningView.IsMSKMailBox() )
            {
            iOwningView.CancelMailboxTimer();
            }
        }
    iListBox->HandlePointerEventL( aPointerEvent );
    }


//-------------------------------------------------------------------------------
//CMceMessageListContainer::IsValidSearchKey(const TKeyEvent& aKeyEvent)
//-------------------------------------------------------------------------------
TBool CMceMessageListContainer::IsValidSearchKey( const TKeyEvent& aKeyEvent )
    {
    TBool response = EFalse;
    if ( iInputMethodQwerty )
        {
        response = ETrue;
        }
    if ((( aKeyEvent.iCode >= (TUint)EPtiKey0 && 
           aKeyEvent.iCode <= (TUint)EPtiKey9 ) ) 
           && !aKeyEvent.iRepeats )
        {
        response = ETrue;
        }
    if ( aKeyEvent.iCode == EKeyUpArrow || 
    	 aKeyEvent.iCode == EKeyDownArrow )
    	{
    	response = EFalse;
    	}
    return response;
    }


//-------------------------------------------------------------------------------
//CMceMessageListContainer::HandleQwertyModeChangeNotification()
//-------------------------------------------------------------------------------
TInt CMceMessageListContainer::HandleQwertyModeChangeNotification()
    {
    TInt err = iQwertyModeStatusProperty.Get( iInputMethodQwerty );
    if ( err )
        {
        // Set defaut inputmethod. 0 = No Qwerty -> EPtiEngineMultitapping
        iInputMethodQwerty = 0; 
        }
    return err;        
    }


//-------------------------------------------------------------------------------
//CMceMessageListContainer::QwertyModeChangeNotification(TAny* aObj)
//-------------------------------------------------------------------------------
TInt CMceMessageListContainer::QwertyModeChangeNotification( TAny* aObj )
    {
    TInt err = KErrArgument;
    if ( aObj != NULL )
        {
        err = static_cast<CMceMessageListContainer*>(aObj)->HandleQwertyModeChangeNotification();
        }
    return err;        
    }

// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
void CMceMessageListContainer::SetSortTypeL( TInt aSortType, TBool aOrdering )
    {
    iListItems->SetOrderingL( aSortType, aOrdering );
    }

// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
void CMceMessageListContainer::SetMtmUiDataRegistry( MMtmUiDataRegistryObserver* aRegistryObserver )
    {
    iListItems->SetRegistryObserver( aRegistryObserver );
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
TMsvId CMceMessageListContainer::FindEntry( const TDesC& aMatchString ) const
    {
    TMsvId foundEntry = KErrNotFound;
    TInt index = iListItems->FindEntryIndex( aMatchString );
    if ( index >= 0 )
        {
        foundEntry = iListItems->ItemId( index );
        }
    return foundEntry;
    
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
TBool CMceMessageListContainer::FindFirstUnreadMessageL( TMsvId& aEntryId ) const
    {
    return iListItems->FindFirstUnreadMessageL( aEntryId );
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
void CMceMessageListContainer::ResetCurrentItemL()
    {
    if ( iListItems->MdcaCount() )
        {
		//calulate the top item index
		TInt topIndex = iListBox->View()->CalcNewTopItemIndexSoItemIsVisible( 0 );
		iListBox->SetTopItemIndex( topIndex );
		iListBox->SetCurrentItemIndex( 0 );
        }
    iListBox->UpdateScrollBarsL();
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
CMceMessageListContainerBase::TMessageListItemType CMceMessageListContainer::CurrentItemType() const
    {
    if ( iListItems->MdcaCount() )
        {
        return CMceMessageListContainerBase::EMessageListItemMsvItem;
        }
    return CMceMessageListContainerBase::EMessageListItemUnknown;
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
void CMceMessageListContainer::SetListEmptyTextL(const TDesC& aText)
    {
    iListBox->View()->SetListEmptyTextL( aText );
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
void CMceMessageListContainer::SetAnchorItemIdL( 
    TMessageListOperationType aOperationType )  
    {
    if ( iListItems->MdcaCount() == 0 )
        {
        iAnchorItemId = KErrNotFound;
        iAnchorItemIndex = KErrNotFound;
        iLastOperationType = aOperationType;
        return;
        }
        
    switch ( aOperationType )
        {
        case EMessageListOperationGeneral:
            iAnchorItemIndex = iListBox->CurrentItemIndex(); 
            iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
        break;
        case EMessageListOperationConnect:
            iAnchorItemIndex = iListBox->CurrentItemIndex(); 
            iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
        break;
        case EMessageListOperationFetchSelected:
            // find first from the marked messages list...? What if that is deleted when connected???
            if ( iSelectedEntries->Count() )
                {
                // pick first one
                iAnchorItemId = (*iSelectedEntries)[0];
                iAnchorItemIndex = iListItems->ItemIndex( iAnchorItemId );
                }
            else
                {
                iAnchorItemIndex = iListBox->CurrentItemIndex(); 
                iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
                }
        break;
        case EMessageListOperationFetchNew:
            iAnchorItemIndex = iListBox->CurrentItemIndex(); 
            iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
        break;
        case EMessageListOperationDelete:
            iAnchorItemIndex = iListBox->CurrentItemIndex(); 
            iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
        break;
        case EMessageListOperationCompleted:
            HandleOperationCompletedL();
        break;
        default:
        // assert debug ?
        break;
        }
        
#ifdef _DEBUG
    RDebug::Print(_L("CMceMessageListContainer1: iAnchorItemId 0x%x, iAnchorItemIndex %d"), iAnchorItemId, iAnchorItemIndex);
#endif    
    if ( aOperationType != EMessageListOperationCompleted )        
        {
        iLastOperationType = aOperationType;
        }
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
void CMceMessageListContainer::HandleOperationCompletedL()
    {
    if ( /*iLastOperationType == EMessageListOperationConnect &&*/
         iAnchorItemIndex == KErrNotFound )
        {
        // set focus to first one...
        if ( iListItems->MdcaCount() )
            {
            iListBox->SetCurrentItemIndex( 0 );
            iAnchorItemIndex = 0;
            iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
            }
        RefreshListbox();
        }
    SetAnchorItemIdL( EMessageListOperationGeneral );
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::
// ----------------------------------------------------
void CMceMessageListContainer::HandleMsvSessionEventL( 
    MMsvSessionObserver::TMsvSessionEvent aEvent,
    CMsvEntrySelection& aSelection,
    TBool aDraw )
    {
#ifdef _DEBUG
    RDebug::Print(_L("CMceMessageListContainer2: iAnchorItemId 0x%x, iAnchorItemIndex %d"), iAnchorItemId, iAnchorItemIndex);
#endif
    // listitem addition handling when all the new item indexes can be resolved
    if( iOwningView.MarkingMode() && iAddedMsvIds->Count() > 0 )
        {
        TBool allItemsInTheList( ETrue );
        CArrayFix<TInt>* addedIndexes = new( ELeave ) CArrayFixFlat<TInt> (
                KMceListContainerGranuality );
        CleanupStack::PushL( addedIndexes );
        for( TInt i( 0 ); i < iAddedMsvIds->Count(); i++ )
            {
            TMsvId msvId = (*iAddedMsvIds)[i];                 
            TInt index = iListItems->ItemIndex( msvId );
            if ( index > KErrNotFound )
                {
                addedIndexes->AppendL( index );
                }
            else
                {
                allItemsInTheList = EFalse;
                break;
                }
            }
        if( allItemsInTheList )
            {
            ItemCountChangedL( ETrue, addedIndexes );
            iAddedMsvIds->Reset();
            }
        CleanupStack::PopAndDestroy( addedIndexes );
        addedIndexes = NULL;
        }
    else if( iAddedMsvIds->Count() > 0 )
        {
        iAddedMsvIds->Reset();
        }
    switch ( aEvent )
        {
        case MMsvSessionObserver::EMsvEntriesDeleted:
            {
/*            if ( iOwningView.IsMSKMailBox() ) // focus setting only for email
                {
                }
            else*/
                {
                ItemCountChangedL( EFalse ); 
                TInt selectedIndex = ItemIndex( iAnchorItemId );
                if ( selectedIndex == KErrNotFound )
                    {
                    // we could not find anchor item, lets try to set new focus using index
                    
                    if ( iAnchorItemIndex > iListItems->MdcaCount() - 1 )
                        {
                        iAnchorItemIndex = iListItems->MdcaCount() - 1;
                        }
                    iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
                    }
                if ( aDraw )
                    {
                    SetCurrentItemIdL( iAnchorItemId );
                    }
                iAnchorItemIndex = iListBox->CurrentItemIndex();
                }
            if ( aDraw )
                {
                RefreshListbox();
                }
            }
        break;
        case MMsvSessionObserver::EMsvEntriesCreated:    
            {
            if( iOwningView.MarkingMode() )
                {
                // list item count not updated fast enough in hw so let's 
                // collect added ids for future handling
                for( TInt i( 0 ); i < aSelection.Count(); i++ )
                    {
                    TMsvId msvId = (aSelection)[ i ];
                    if( iAddedMsvIds->Find( msvId ) == KErrNotFound  )
                        {
                        iAddedMsvIds->AppendL( msvId );
                        }
                    }
                }
            else
                {
                ItemCountChangedL( ETrue );
                }
            }
        case MMsvSessionObserver::EMsvEntriesChanged:
            {
            if( aEvent == MMsvSessionObserver::EMsvEntriesChanged  )
                {
                ItemCountChangedL( ETrue );
                }
            if ( iLastOperationType != EMessageListOperationConnect &&
                 iAnchorItemId != KErrNotFound )
                {
                if ( iOwningView.IsMSKMailBox() ) // focus setting only for email
                    {
                    TInt selectedIndex = ItemIndex( iAnchorItemId );
                    if ( selectedIndex == KErrNotFound )
                        {
                        // we could not find anchor item, lets try to set new focus using index
                        if ( iAnchorItemIndex > iListItems->MdcaCount() - 1 )
                            {
                            iAnchorItemIndex = iListItems->MdcaCount() - 1;
                            }
                        iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
                        }
                    if (selectedIndex != iListBox->CurrentItemIndex() && 
                  		aEvent == MMsvSessionObserver::EMsvEntriesChanged )
	                    {
	                    iAnchorItemIndex = iListBox->CurrentItemIndex();
	                    iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
	                    }
                    if(aEvent==MMsvSessionObserver::EMsvEntriesCreated)
                        {
                               iAnchorItemIndex=0;
                               iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
                        }
                    if ( aDraw )
                        {
                        SetCurrentItemIdL( iAnchorItemId );
                        }
                    iAnchorItemIndex = iListBox->CurrentItemIndex();
    #ifdef _DEBUG
                    RDebug::Print(_L("CMceMessageListContainer3: iAnchorItemId 0x%x, iAnchorItemIndex %d"), iAnchorItemId, iAnchorItemIndex);
    #endif
                    //SetCurrentItemIdL( iAnchorItemId );
                    }
                else
                    {
                    if ( aSelection.Count() )
                        {
                        // is this enough?
                        SetCurrentItemIdL( aSelection.At(0) );
                        }
                    }
                }
            }
        
        
        break;
        case MMsvSessionObserver::EMsvEntriesMoved:
        break;
        default:
        break;
        };
    }

// ----------------------------------------------------
// CMceMessageListContainer::OptionsCommandSupported
// ----------------------------------------------------
TUint CMceMessageListContainer::OptionsCommandSupported() const
    {
    return TMessageListCommandNone;
    }
    
// ----------------------------------------------------
// CMceMessageListContainer::HandleOptionsCommandL
// ----------------------------------------------------
void CMceMessageListContainer::HandleOptionsCommandL( TInt /*aCommand*/ )
    {
    // Should we use assert debug here?
    }

// ----------------------------------------------------
// CMceMessageListContainer::DateTimeFormatChangedL
// ----------------------------------------------------
void CMceMessageListContainer::DateTimeFormatChangedL( TInt /*aChangeFlag*/ )
    {
    RefreshListbox();
    }

// ---------------------------------------------------------------------------
// CMceMessageListContainer::SetMskL
// ---------------------------------------------------------------------------
//
TInt CMceMessageListContainer::SetSpecialMskL()
    {
    return NULL;
    }

//-------------------------------------------------------------------------------
//CMceMessageListContainer::HandleShortcutForSearch( const TKeyEvent& aKeyEvent )
//-------------------------------------------------------------------------------
void CMceMessageListContainer::HandleShortcutForSearchL( const TKeyEvent& aKeyEvent )
    {
   // in remote mailbox key has been pressed, find item if sorted
    // by subject or sender
    TInt Len = 0;
    TBuf<KMceTextBufferLength> text;
    text.Zero();
    if ( iT9Interface->LastEnteredKey() != ( TInt ) aKeyEvent.iScanCode )
        {                    
        iT9Interface->ClearCurrentWord();
        }      
    iT9Interface->AppendKeyPress( (TPtiKey)aKeyEvent.iScanCode );                
    Len = iT9Interface->CurrentWord().Length(); 
    if ( Len <  KMceTextBufferLength )
        {
        text = iT9Interface->CurrentWord();
        }
    else
        {
        text = iT9Interface->CurrentWord().Left(KMceTextBufferLength);
        }
    
    iOwningView.FindAndSelectEntryL( text );
    iT9Timer->Start();       
    }

//-------------------------------------------------------------------------------
//CMceMessageListContainer::HasHandleStarKeyDoneL()
//------------------------------------------------------------------------------- 
TBool CMceMessageListContainer::HasHandleStarKeyDoneL()
    {
    TBool starkeyIsHandled = EFalse;
    if ( StateCanBeChangedByStarKeyL() )
        {
        if ( IsSortByDate() )
            {
            MarkReadUnreadWithStarKeyL();
            }
        else
            {
            // if sort by anything else other than by Date, handle focus change
            iListBox->SetCurrentItemIndex( 0 );
            iListBox->DrawDeferred();            
            }
        starkeyIsHandled = ETrue;
        } 
    return starkeyIsHandled;
    }
    
//-------------------------------------------------------------------------------
//CMceMessageListContainer::MarkReadUnreadWithStarKeyL()
//------------------------------------------------------------------------------- 
void CMceMessageListContainer::MarkReadUnreadWithStarKeyL()
    {             
    MarkItemSelectionL();
    if( iOwningView.IsItemUnread( CurrentItemId() ) ) 
        {
        iOwningView.HandleCommandL( EMceCmdMarkAsRead );
        }
    else
        {
        iOwningView.HandleCommandL( EMceCmdMarkAsUnread );
        }   
    }

//-------------------------------------------------------------------------------
//CMceMessageListContainer::IsSortByDate()
//------------------------------------------------------------------------------- 
TBool CMceMessageListContainer::IsSortByDate()
    {                               
    TMsvSelectionOrdering ordering = iListItems->SortType();
    return ( ( ordering.Sorting() == EMsvSortByDateReverse) || ( ordering.Sorting() == EMsvSortByDate ) );
    }

// ---------------------------------------------------------------------------
// CMceMessageListContainer::SetContainerFlag
// ---------------------------------------------------------------------------
void CMceMessageListContainer::SetContainerFlag( TMceContainerFlags /*aFlag*/, TBool /*aState*/ )
    {
    }

void CMceMessageListContainer::UpdateIconArrayL()
    {
    // do nothing for two row list.
    }

void CMceMessageListContainer::SetMarkingModeOff()
    {
    if( iListBox )
        {
        iListBox->SetMarkingMode( EFalse );
        }
    }

//  End of File
