/*
* 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:
* Container for main view.
* Derived from CMceOneRowMessageListContainer.
*
*/
// INCLUDE FILES
#include "mceui.h"
#include <aknlists.h>
#include <aknsinglecolumnstyletreelist.h>
#include <AknsBasicBackgroundControlContext.h>
#include <akntreelist.h> // CAknTreeList::ESaveFocus
#include <AknIconUtils.h>
#include <avkon.mbg> // bitmap enums
#include <muiu.mbg> // bitmap enums
#include <data_caging_path_literals.hrh>
#include "MceOneRowMessageListBitmapResolver.h"
#include "MceOneRowMessageListContainer.h"
#include "MceOneRowMessageListArray.h"
#include "MceOneRowMessageListArrayLoader.h" // For CMceOneRowListItemArrayLoader::EHListItemSubtitle
#include "MceMessageListView.h"
#include <msvids.h>
#include <msvuids.h>
#include <SenduiMtmUids.h> // mtm uids
#include "MceIds.h" // KMceApplicationUid
#include "MceLogText.h"
#include <StringLoader.h> // stringloader
#include "MceCommands.hrh"
#include <bldvariant.hrh>
#include <csxhelp/mce.hlp.hrh>
#include <csxhelp/mbxs.hlp.hrh>
#include <PtiEngine.h>
#include <featmgr.h>
#include <commonphoneparser.h>
#include <muiumsvuiserviceutilitiesinternal.h>
#include <mce.rsg>
// CONSTANTS
const TInt KMceListContainerGranuality = 4;
const TInt KMceTextBufferLength = 10; // text buffer length
const TInt KMceFocusOffsetTopView = 0; // Set focused item top of view
const TInt KMceTextItemSize = 75; // Subtitle text buffer size
const TInt KMceColumn1 = 1;
const TInt KMceColumn2 = 2;
const TInt KMceColumn3 = 3;
const TInt KMceFirstItemIndex = 0;
// The position of the middle soft key
const TInt KMSKPosition = 3;
const TInt KMSKLabel = 20;
//cmail update
#define KUidMsgTypeCmailMtmVal 0x2001F406
// ================= MEMBER FUNCTIONS =======================
// ----------------------------------------------------
// Constructor
// ----------------------------------------------------
//
CMceOneRowMessageListContainer::CMceOneRowMessageListContainer( CMceMessageListView& aParentView ) :
CMceMessageListContainerBase( aParentView ),
iEmailFramework(EFalse)
{
}
// ----------------------------------------------------
// Destructor
// ----------------------------------------------------
//
CMceOneRowMessageListContainer::~CMceOneRowMessageListContainer()
{
delete iT9Interface;
delete iT9Timer;
delete iListItems;
delete iBitmapResolver;
delete iBgContext;
delete iSelectedEntries;
delete iTreeListBox;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::NewL
// ----------------------------------------------------
//
CMceOneRowMessageListContainer* CMceOneRowMessageListContainer::NewL(
CMceMessageListView& aParentView,
const TRect& aRect,
CMsvSessionPtr aSession,
MMtmUiDataRegistryObserver& aRegObserver )
{
CMceOneRowMessageListContainer* self = new (ELeave)
CMceOneRowMessageListContainer( aParentView );
CleanupStack::PushL(self);
self->ConstructL( aRect, aSession, aRegObserver );
CleanupStack::Pop(); // self
return self;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::AddDefaultIconsL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::AddDefaultIconsL()
{
CFbsBitmap* bitmap = NULL;
CFbsBitmap* bitmapMask = NULL;
TInt treeIconIndex = KErrNotFound;
for ( TInt i = EMceBitmapIndexUnknown; i < EMceBitmapIndexLastIconIndex; i++ )
{
if ( iBitmapResolver->GetBitmapL( (TMceBitmapArrayIndexes)i, bitmap, bitmapMask ) < 0 )
{
treeIconIndex = iTreeListBox->AddIconL(
bitmap,
bitmapMask,
EFalse,
EAspectRatioPreserved );
iBitmapResolver->SetTreeIconId( (TMceBitmapArrayIndexes)i, treeIconIndex );
}
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::ConstructL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::ConstructL(
const TRect& aRect,
CMsvSessionPtr aSession,
MMtmUiDataRegistryObserver& aRegObserver )
{
FeatureManager::InitializeLibL();
if ( FeatureManager::FeatureSupported( KFeatureIdFfEmailFramework ) )
{
iEmailFramework = ETrue;
}
FeatureManager::UnInitializeLib();
CreateWindowL();
InitComponentArrayL();
Components().SetControlsOwnedExternally( ETrue );
// Construct list.
CAknSingleColumnStyleTreeList* list =
CAknSingleColumnStyleTreeList::NewL( *this );
iSelectedEntries = new (ELeave) CMsvEntrySelection;
iContainerFlags.ClearMceFlag( EMceOneRowFlagOptionsMenuOpen );
iContainerFlags.ClearMceFlag( EMceOneRowFlagFirstSubtitleOpen );
// Use list as a component control of the view.
Components().AppendLC( list, KCoeNoControlId );
CleanupStack::Pop( list );
iTreeListBox = list;
iTreeListBox->EnableTabModeFunctionIndicatorsL( ETrue );
iTreeListBox->SetFlags( iTreeListBox->Flags() ^ KAknTreeListLooping ^ KAknTreeListMarkable );
iTreeListBox->AddObserverL( this );
iBgContext = CAknsBasicBackgroundControlContext::NewL(
KAknsIIDQsnBgAreaMain, iAvkonAppUi->ApplicationRect(), EFalse );
iBitmapResolver = CMceOneRowBitmapResolver::NewL( aSession, aRegObserver );
AddDefaultIconsL();
iListItems = CMceOneRowListItemArray::NewL( aSession, 0x1000 );
iListItems->SetListItemArrayObserver( this );
iTreeListBox->Sort( iListItems, EFalse );
SetRect( aRect );
TLocale locale;
iStartOfWeek = locale.StartOfWeek();
iDialerEvent = EFalse ;
}
// ----------------------------------------------------
// CMceMessageListContainer::MceListId
// ----------------------------------------------------
TInt CMceOneRowMessageListContainer::MceListId() const
{
return EMceListTypeOneRow;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::CountComponentControls
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::CountComponentControls() const
{
return 1; // always only listbox
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::ComponentControl
// ----------------------------------------------------
//
CCoeControl* CMceOneRowMessageListContainer::ComponentControl(TInt /*aIndex*/) const
{
return iTreeListBox;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SetFolderL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::SetFolderL( TMsvId aFolderId )
{
if ( iListItems )
{
ResetListbox();
iContainerFlags.ClearMceFlag( EMceOneRowFlagFirstSubtitleOpen );
iListItems->SetFolderL( aFolderId );
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SizeChanged
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::SizeChanged()
{
TRect rect = Rect();
if (iTreeListBox)
{
iTreeListBox->SetRect( rect );
}
if ( iBgContext )
{
iBgContext->SetRect( rect );
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::HandleResourceChange
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::HandleResourceChange( TInt aType )
{
CCoeControl::HandleResourceChange( aType );
if( aType == KAknsMessageSkinChange )
{
// change skin bitmap
TRAP_IGNORE( iBitmapResolver->SkinChangedL( iTreeListBox ) );
ResetListbox();
TRAP_IGNORE( iListItems->RefreshArrayL() );
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::HandleTreeListEvent
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::HandleTreeListEvent( CAknTreeList& aList,
TAknTreeItemID /* aItem */, TEvent aEvent )
{
if ( &aList != iTreeListBox )
{
return KErrNone;
}
switch ( aEvent )
{
// One of the nodes in the list is being expanded.
case ENodeExpanded:
// TRAP_IGNORE( AddChildrenL( aItem ) );
ChangeMskCommand( R_MCE_QTN_MSK_COLLAPSE );
break;
// One of the nodes in the list is being collapsed.
case ENodeCollapsed:
// RemoveChildren( aItem );
ChangeMskCommand( R_MCE_QTN_MSK_EXPAND );
break;
// Simple data row or core data row is selected.
case EItemSelected:
TRAP_IGNORE( iOwningView.HandleCommandL(EAknCmdOpen) );
break;
// Focused item changes
case EItemFocused:
if ( !iMarkingModeEnabled
&& !iContainerFlags.MceFlag( EMceOneRowFlagOptionsMenuOpen ) )
{
TRAP_IGNORE( iOwningView.SetMSKButtonL() );
}
else if ( iContainerFlags.MceFlag( EMceOneRowFlagOptionsMenuOpen ) )
{
iContainerFlags.ClearMceFlag( EMceOneRowFlagOptionsMenuOpen );
}
break;
// Item is being removed from the list.
case EItemRemoved:
break;
// Hierarchical list has entered in marking mode
case EMarkingModeEnabled:
iMarkingModeEnabled = ETrue;
break;
// hierarchical list exits the marking mode
case EMarkingModeDisabled:
iMarkingModeEnabled = EFalse;
break;
case EItemUnmarked:
case EItemMarked:
if ( !iMarkingModeEnabled )
{
TRAP_IGNORE( iOwningView.SetMSKButtonL() );
}
break;
default:
break;
}
return KErrNone;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::ResetListbox
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::ResetListbox()
{
iTreeListBox->RemoveItem( KAknTreeIIDRoot, EFalse );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::MceListItemArrayChangedL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::MceListItemArrayChangedL(
CArrayFixFlat<TInt>& aChangedItems )
{
const TInt count = aChangedItems.Count();
for ( TInt i = 0 ; i < count; i++ )
{
TInt itemIndex = aChangedItems[i];
if ( iListItems->HCItemType(itemIndex) == CMceOneRowListItemArrayLoader::EHListItemSubtitle )
{
TBuf<KMceTextItemSize> subTitle;
TInt itemType = iListItems->GetSubtitleTextL( itemIndex, subTitle );
if ( itemType > EHCListTypeNone )
{
TUint32 flags = CAknSingleColumnStyleTreeList::EPersistent;
if ( !iContainerFlags.MceFlag( EMceOneRowFlagFirstSubtitleOpen ) )
{
flags |= CAknSingleColumnStyleTreeList::EExpanded;
iContainerFlags.SetMceFlag( EMceOneRowFlagFirstSubtitleOpen );
}
else
{
flags &= CAknSingleColumnStyleTreeList::EExpanded;
}
iNodeId = iTreeListBox->AddSubtitleRowL( KAknTreeIIDRoot,
subTitle, flags, EFalse );
iListItems->SetTreeItemId( itemIndex, iNodeId );
iTreeListBox->SetNonEmpty( iNodeId, ETrue, EFalse );
UpdateSubtitleIconL( iNodeId, EFalse );
}
}
else
{
AddEntryL( itemIndex );
}
}
// current item id haven't been set due list is not ready yet
if ( iSelectedItemWaitingIndex )
{
SetCurrentItemIdL( iSelectedItemWaitingIndex );
}
iTreeListBox->Sort( iListItems, CAknTreeList::ESaveFocus, ETrue );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::GetSubtitleIcon
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::GetSubtitleIcon ( TBool setUnread )
{
TMceBitmapArrayIndexes treeIconId = EMceBitmapIndexUnknown;
TMsvSelectionOrdering sortType = iListItems->SortType();
switch ( sortType.Sorting() )
{
case EMsvSortByDate:
case EMsvSortByDateReverse:
if ( setUnread )
{
treeIconId = EMceBitmapIndexSubTimeUnread;
}
else
{
treeIconId = EMceBitmapIndexSubTime;
}
break;
case EMsvSortByDetails:
case EMsvSortByDetailsReverse:
if ( setUnread )
{
treeIconId = EMceBitmapIndexSubSenderUnread;
}
else
{
treeIconId = EMceBitmapIndexSubSender;
}
break;
case EMsvSortByDescription:
case EMsvSortByDescriptionReverse:
if ( setUnread )
{
treeIconId = EMceBitmapIndexSubSubjectUnread;
}
else
{
treeIconId = EMceBitmapIndexSubSubject;
}
break;
default:
treeIconId = EMceBitmapIndexSubTime;
break;
}
return iBitmapResolver->TreeIconId( treeIconId );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::AddChildrenL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::AddChildrenL( TAknTreeItemID aParentId )
{
TInt index = iListItems->ItemIndexTreeId( aParentId );
const TInt count = iListItems->GetSubfolderItemCount( aParentId );
for ( TInt i = index ; i <= index + count ; i++ )
{
TBuf<KMceTextItemSize> subTitle;
TInt itemType = iListItems->GetSubtitleTextL( i, subTitle );
if ( iListItems->ParentItemId( i ) == aParentId &&
itemType == 0 )
{
AddEntryL( i );
}
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::AddEntryL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::AddEntryL( TInt aEntryIndex )
{
TMsvEntry entry;
User::LeaveIfError( iListItems->GetEntry( aEntryIndex, entry ) );
TInt foundIcon = KErrNotFound;
TUint32 flags;
CFbsBitmap* bitmap = NULL;
CFbsBitmap* bitmapMask = NULL;
foundIcon = iBitmapResolver->GetBitmapL( entry, bitmap, bitmapMask );
if ( foundIcon < 0 )
{
foundIcon = iTreeListBox->AddIconL(
bitmap,
bitmapMask,
EFalse,
EAspectRatioPreserved );
iBitmapResolver->AddTreeIconIdL( bitmap, foundIcon, entry.iMtm );
}
TAknTreeItemID parentId = iListItems->ParentItemId( aEntryIndex );
TBuf<KMceTextItemSize> bufferC1;
TBuf<KMceTextItemSize> bufferC2;
TBuf<KMceTextItemSize> bufferC3;
iListItems->GetColumnTextL( aEntryIndex, KMceColumn1, bufferC1 );
iListItems->GetColumnTextL( aEntryIndex, KMceColumn2, bufferC2 );
iListItems->GetColumnTextL( aEntryIndex, KMceColumn3, bufferC3 );
TAknTreeItemID itemId = 0;
if ( IsItemFolder( entry.Id() ))
{
// Set folders not markable
flags = CAknSingleColumnStyleTreeList::EPersistent
| CAknSingleColumnStyleTreeList::EMarkingDisabled;
// Add two column core data row for folders
itemId = iTreeListBox->AddCoreDataRowL(
parentId,
bufferC1,
bufferC3,
flags,
EFalse );
}
else
{
flags = CAknSingleColumnStyleTreeList::EPersistent;
// Add three column core data row for entries
itemId = iTreeListBox->AddCoreDataRowL(
parentId,
bufferC1,
bufferC2,
bufferC3, //subTitle,
flags,
EFalse );
if ( iListItems->GetItemMarkStatusL( entry.Id()) )
{
iTreeListBox->SetMarked( itemId, ETrue, ETrue );
}
iTreeListBox->EnableThirdColumn( itemId, bufferC3.Length(), EFalse );
}
iListItems->SetTreeItemId( aEntryIndex, itemId );
if ( foundIcon >= 0 )
{
iTreeListBox->SetIcon(
itemId,
CAknSingleColumnStyleTreeList::ELeaf,
foundIcon,
EFalse );
TBool attachmentIcon = EFalse;
if ( entry.Attachment() && entry.iMtm != KSenduiMtmMmsUid )
{
iTreeListBox->SetIcon(
itemId,
CAknSingleColumnStyleTreeList::EOptionalIcon1,
iBitmapResolver->TreeIconId( EMceBitmapIndexAttachment ),
EFalse );
iTreeListBox->SetIcon(
itemId,
CAknSingleColumnStyleTreeList::EHighlightedOptionalIcon1,
iBitmapResolver->TreeIconId( EMceBitmapIndexAttachmentFocus ),
EFalse );
attachmentIcon = ETrue;
}
if ( entry.iType == KUidMsvMessageEntry )
{
TMsvPriority entryPrio = entry.Priority();
if ( entryPrio != EMsvMediumPriority )
{
TInt prioIcon = 0;
TInt prioIconFocus = 0;
if ( entryPrio == EMsvHighPriority )
{
prioIcon = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityHigh );
prioIconFocus = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityHighFocus );
}
else
{
prioIcon = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityLow );
prioIconFocus = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityLowFocus );
}
if ( attachmentIcon )
{
iTreeListBox->SetIcon(
itemId,
CAknSingleColumnStyleTreeList::EOptionalIcon2,
prioIcon,
EFalse );
iTreeListBox->SetIcon(
itemId,
CAknSingleColumnStyleTreeList::EHighlightedOptionalIcon2,
prioIconFocus,
EFalse );
}
else
{
iTreeListBox->SetIcon(
itemId,
CAknSingleColumnStyleTreeList::EOptionalIcon1,
prioIcon,
EFalse );
iTreeListBox->SetIcon(
itemId,
CAknSingleColumnStyleTreeList::EHighlightedOptionalIcon1,
prioIconFocus,
EFalse );
}
}
}
}
// If unread message update subtitle icon
if ( iTreeListBox->Parent( itemId ) > KAknTreeIIDRoot && entry.Unread() )
{
UpdateSubtitleIconL( parentId, ETrue );
}
iTreeListBox->SetEmphasis( itemId, entry.Unread(), EFalse );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::RemoveChildren
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::RemoveChildren( TAknTreeItemID aParentId )
{
const TInt count = iTreeListBox->ChildCount( aParentId );
for ( TInt i = 0; i < count; i++ )
{
TAknTreeItemID removedItem = iTreeListBox->Child( aParentId, 0);
iTreeListBox->RemoveItem( removedItem, EFalse );
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::MopSupplyObject
// ----------------------------------------------------
//
TTypeUid::Ptr CMceOneRowMessageListContainer::MopSupplyObject( TTypeUid aId )
{
if ( aId.iUid == MAknsControlContext::ETypeId && iBgContext )
{
return MAknsControlContext::SupplyMopObject( aId, iBgContext );
}
return CCoeControl::MopSupplyObject( aId );
}
// ----------------------------------------------------
// CMceMainViewListContainer::ItemIndex
// ----------------------------------------------------
TInt CMceOneRowMessageListContainer::ItemIndex( TMsvId aId ) const
{
return iListItems->ItemIndex( aId );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::Draw
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::Draw( const TRect& /*aRect*/ ) const
{
// Get the standard graphics context.
CWindowGc& gc = SystemGc();
// Gets the control's extent.
TRect rect = Rect();
// Clears the screen.
gc.Clear( rect );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::Count
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::Count() const
{
return iListItems->MdcaCount();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::MessageCount
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::MessageCount() const
{
return iListItems->MessageCount();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::FolderCount
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::FolderCount() const
{
return iListItems->FolderCount();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::CurrentFolderId
// ----------------------------------------------------
//
TMsvId CMceOneRowMessageListContainer::CurrentFolderId() const
{
TMsvId folderId = 0;
if ( iListItems )
{
folderId = iListItems->FolderId();
}
return folderId;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SetCurrentItemIdL
// ----------------------------------------------------
TBool CMceOneRowMessageListContainer::SetCurrentItemIdL( TMsvId aEntryId )
{
const TInt selectedIndex = ItemIndex( aEntryId );
if ( selectedIndex != KErrNotFound )
{
TAknTreeItemID selectedTreeID = iListItems->TreeItemId( selectedIndex );
if ( selectedTreeID )
{
TAknTreeItemID parentId = iListItems->ParentItemId( selectedIndex );
if ( !iTreeListBox->IsExpanded( parentId ) )
{
iTreeListBox->ExpandNode( parentId, ETrue );
}
iTreeListBox->SetFocusedItem( selectedTreeID );
}
iSelectedItemWaitingIndex = NULL;
}
// Current entry not yet added to the list
else if ( selectedIndex == KErrNotFound && aEntryId > 0 )
{
iSelectedItemWaitingIndex = aEntryId;
}
return (selectedIndex != KErrNotFound);
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::RefreshListbox
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::RefreshListbox()
{
iTreeListBox->DrawDeferred();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::ItemCountChangedL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::ItemCountChangedL( TBool /* aItemsAdded */ )
{
ResetListbox();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::FolderEntry
// ----------------------------------------------------
//
const TMsvEntry& CMceOneRowMessageListContainer::FolderEntry() const
{
return iListItems->FolderEntry();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::CurrentItemId
// ----------------------------------------------------
//
TMsvId CMceOneRowMessageListContainer::CurrentItemId() const
{
return iListItems->MsvItemId( iTreeListBox->FocusedItem() );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::CurrentItemSelectionL
// ----------------------------------------------------
//
CMsvEntrySelection* CMceOneRowMessageListContainer::CurrentItemSelectionL()
{
return iSelectedEntries->CopyL();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::CurrentItemSelectionRefreshL
// ----------------------------------------------------
//
CMsvEntrySelection* CMceOneRowMessageListContainer::CurrentItemSelectionRefreshL()
{
MarkItemSelectionL();
return CurrentItemSelectionL();
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::CurrentItemSelectionCount
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::CurrentItemSelectionCount() const
{
if ( iListItems->MdcaCount() == 0 )
{
return 0;
}
TInt markedCount = 0;
TRAP_IGNORE( markedCount = GetMarkedItemsCountL() );
return Max( 1, markedCount );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SelectionCount
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::SelectionCount() const
{
TInt markedCount = 0;
TRAP_IGNORE( markedCount = GetMarkedItemsCountL() );
return markedCount;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::ClearSelection
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::ClearSelection()
{
if ( iTreeListBox )
{
iTreeListBox->SetMarked( KAknTreeIIDRoot, EFalse, ETrue );
iListItems->SetItemMarked( KAknTreeIIDRoot, EFalse);
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::MarkItemSelectionL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::MarkItemSelectionL()
{
RArray<TAknTreeItemID> selection;
CleanupClosePushL( selection );
iTreeListBox->GetMarkedItemsL( selection );
TInt count( selection.Count() );
iSelectedEntries->Reset();
// If subtitle is only marked item and focused item is different then add focused item to selection
if ( count == 0 || ( count == 1 && iTreeListBox->IsNode( selection[0] ) ) )
{
TMsvId id = CurrentItemId();
TAknTreeItemID focused = iTreeListBox->FocusedItem();
if ( id != KErrNotFound )
{
// nothing in selection so add item under "cursor"
iSelectedEntries->AppendL( id );
}
else if ( focused > KAknTreeIIDNone && iTreeListBox->IsNode( focused ) ) // Focused item is subtitle
{
TInt index = iListItems->ItemIndexTreeId( focused );
const TInt childCount = iListItems->GetSubfolderItemCount( focused );
// Add all items under subtitle
for (TInt loop = index + 1 ; loop <= childCount + index ; loop++ )
{
id = iListItems->MsvItemId( iListItems->TreeItemId( loop ) );
if ( id != KErrNotFound )
{
iSelectedEntries->AppendL( id );
}
}
}
}
else if ( count != 0 )
{
for (TInt loop=0; loop < count; loop++ )
{
TMsvId id = iListItems->MsvItemId( selection[ loop ] );
if ( id != KErrNotFound )
{
iSelectedEntries->AppendL( id );
}
}
}
CleanupStack::PopAndDestroy( &selection );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SaveMarkingL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::SaveMarkingL()
{
RArray<TAknTreeItemID> selection;
CleanupClosePushL( selection );
iTreeListBox->GetMarkedItemsL( selection );
TInt count( selection.Count() );
if ( count > 0 )
{
iListItems->SaveMarkingL( selection );
}
CleanupStack::PopAndDestroy( &selection );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::ResetCurrentItemL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::ResetCurrentItemL()
{
iSelectedItemWaitingIndex = NULL;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::FindEntry
// ----------------------------------------------------
//
TMsvId CMceOneRowMessageListContainer::FindEntry( const TDesC& aMatchString ) const
{
TMsvId foundEntry = KErrNotFound;
TInt index = iListItems->FindEntryIndex( aMatchString );
if ( index >= 0 )
{
foundEntry = iListItems->ItemId( index );
}
return foundEntry;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::FindFirstUnreadMessageL
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::FindFirstUnreadMessageL( TMsvId& aEntryId ) const
{
return iListItems->FindFirstUnreadMessageL( aEntryId );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::AddCurrentItemToSelectionL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::AddCurrentItemToSelectionL()
{
TAknTreeItemID focused = iTreeListBox->FocusedItem();
if ( iTreeListBox && focused != KAknTreeIIDNone )
{
iTreeListBox->SetMarked( focused, ETrue, ETrue );
iListItems->SetItemMarked( focused, ETrue);
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::RemoveCurrentItemFromSelection
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::RemoveCurrentItemFromSelection()
{
TAknTreeItemID focused = iTreeListBox->FocusedItem();
if ( iTreeListBox && focused != KAknTreeIIDNone )
{
iTreeListBox->SetMarked( iTreeListBox->FocusedItem(),
EFalse, ETrue );
iListItems->SetItemMarked( focused, EFalse );
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::RefreshSelectionIndexesL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::RefreshSelectionIndexesL( TBool aForceUpdate )
{
RArray<TInt> selection;
CleanupClosePushL( selection );
iTreeListBox->GetMarkedItemsL( selection );
TInt count( selection.Count() );
if ( count > 0 || aForceUpdate )
{
CArrayFixFlat<TInt>* newSelection = new ( ELeave )
CArrayFixFlat<TInt>( KMceListContainerGranuality );
CleanupStack::PushL( newSelection );
const TInt count = iSelectedEntries->Count();
for ( TInt loop = count; loop >0; loop--)
{
TInt index = ItemIndex( (*iSelectedEntries)[loop-1] );
if ( index > KErrNotFound )
{
newSelection->AppendL( index );
}
else
{
iSelectedEntries->Delete( loop-1 );
}
}
CleanupStack::PopAndDestroy( newSelection );
}
CleanupStack::PopAndDestroy( &selection );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::AddAllToSelectionL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::AddAllToSelectionL()
{
if ( iTreeListBox )
{
// The marking can be removed from every list item by specifying
// the tree root as the unmarked item.
iTreeListBox->SetMarked( KAknTreeIIDRoot, ETrue, ETrue );
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::MarkAllReadMessagesL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::MarkAllReadMessagesL()
{
if ( iTreeListBox )
{
// do not mark folders.
const TInt count = iListItems->MdcaCount();
for (TInt i=0; i<count;i++)
{
TMsvEntry entry;
if ( iListItems->GetEntry( i, entry ) == KErrNone &&
entry.iType == KUidMsvMessageEntry &&
!entry.Unread() )
{
TAknTreeItemID treeItemId = iListItems->TreeItemId( i );
iTreeListBox->SetMarked( treeItemId, ETrue, ETrue );
}
}
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::IsItemSelected
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::IsItemSelected( TMsvId aItemId )
{
if ( aItemId > 0 )
{
TInt itemIndex = ItemIndex( aItemId );
TAknTreeItemID treeIndex = iListItems->TreeItemId( itemIndex );
return ( iTreeListBox->IsMarked( treeIndex ) );
}
else // Node selected
{
TAknTreeItemID treeIndex = iTreeListBox->FocusedItem();
return ( iTreeListBox->IsMarked( treeIndex ) );
}
}
// ----------------------------------------------------
// CMceMessageListContainer::SetAnchorItemIdL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::SetAnchorItemIdL(
TMessageListOperationType aOperationType )
{
if ( iListItems->MdcaCount() == 0 )
{
iAnchorItemId = KErrNotFound;
iAnchorItemIndex = KErrNotFound;
if ( aOperationType != EMessageListOperationCompleted )
{
iLastOperationType = aOperationType;
}
return;
}
switch ( aOperationType )
{
case EMessageListOperationGeneral:
iAnchorItemIndex = iListItems->ItemIndexTreeId(iTreeListBox->FocusedItem());
iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
break;
case EMessageListOperationConnect:
iAnchorItemIndex = iListItems->ItemIndexTreeId(iTreeListBox->FocusedItem());
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 = ItemIndex( iAnchorItemId );
}
else
{
iAnchorItemIndex = iListItems->ItemIndexTreeId(iTreeListBox->FocusedItem());
iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
}
break;
case EMessageListOperationFetchNew:
iAnchorItemIndex = iListItems->ItemIndexTreeId(iTreeListBox->FocusedItem());
iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
break;
case EMessageListOperationDelete:
iAnchorItemIndex = iListItems->ItemIndexTreeId(iTreeListBox->FocusedItem());
iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
break;
case EMessageListOperationCompleted:
HandleOperationCompletedL();
break;
default:
break;
}
#ifdef _DEBUG
RDebug::Print(_L("CMceMessageListContainer1: iAnchorItemId 0x%x, iAnchorItemIndex %d"), iAnchorItemId, iAnchorItemIndex);
#endif
if ( aOperationType != EMessageListOperationCompleted )
{
iLastOperationType = aOperationType;
}
}
// ----------------------------------------------------
// CMceMessageListContainer::HandleMsvSessionEventL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::HandleMsvSessionEventL(
MMsvSessionObserver::TMsvSessionEvent aEvent,
CMsvEntrySelection& aSelection,
TBool aDraw )
{
switch ( aEvent )
{
case MMsvSessionObserver::EMsvEntriesDeleted:
{
EntryDeletedL( aSelection, aDraw );
}
break;
case MMsvSessionObserver::EMsvEntriesCreated:
{
EntryCreatedL( aSelection, aDraw );
}
break;
case MMsvSessionObserver::EMsvEntriesChanged:
{
TInt count = aSelection.Count();
for (TInt i=0; i<count; i++)
{
UpdateEntryL( aSelection[i] );
}
}
break;
default:
break;
};
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::FocusChanged
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::FocusChanged(TDrawNow /*aDrawNow*/)
{
if ( iTreeListBox )
{
iTreeListBox->SetFocus( IsFocused() );
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::MarkedItemsCount
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::MarkedItemsCount()
{
TInt count = 0;
TRAP_IGNORE( count = GetMarkedItemsCountL() );
return count;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::GetMarkedItemsCountL
// ----------------------------------------------------
//
TInt CMceOneRowMessageListContainer::GetMarkedItemsCountL() const
{
RArray<TInt> selection;
CleanupClosePushL( selection );
iTreeListBox->GetMarkedItemsL( selection );
TInt count( selection.Count() );
CleanupStack::PopAndDestroy( &selection );
return count;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::OfferKeyEventL
// ----------------------------------------------------
//
TKeyResponse CMceOneRowMessageListContainer::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 ( iTreeListBox )
{
if ( aType == EEventKeyUp)
{
iDialerEvent = EFalse ;
}
if ( aType == EEventKeyDown && iDialerEvent )
{
iDialerEvent = EFalse ;
}
if ( aType == EEventKey )
{
iOwningView.CancelMailboxTimer();
if ( aKeyEvent.iCode == EKeyLeftArrow || aKeyEvent.iCode == EKeyRightArrow )
{
return EKeyWasNotConsumed;
}
if ( aKeyEvent.iCode == EKeyBackspace )
{
MarkItemSelectionL();
SetAnchorItemIdL(
CMceMessageListContainerBase::EMessageListOperationGeneral );
TMsvId currentId = CurrentItemId();
const TInt itemCount = CurrentItemSelectionCount();
if ( itemCount != 0 &&
( itemCount != 1 ||
currentId != KMceTemplatesEntryIdValue )
)
{
if ( currentId == KErrNotFound || // subtitle is selected, allow delete
!iListItems->DeleteDiscard( currentId ) )
{
//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() )
{
// 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;
TPhCltTelephoneNumber number;
TBuf<KMceVisibleTextLength> recipientstring;
CMceUi* mceUi = static_cast<CMceUi*>( CCoeEnv::Static()->AppUi() );
if (id != -1)
{
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 // Enable Sendkey in Mail List
{
iAvkonAppUi->SetKeyEventFlags( CAknAppUiBase::EDisableSendKeyShort | CAknAppUiBase::EDisableSendKeyLong );
TMsvId id = CurrentItemId();
if ( id != -1)
{
iOwningView.HandleSendkeyInMailboxL( id );
}
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 ( iOwningView.IsMSKMailBox() ||
iOwningView.IsMSKSyncMlMailBox() ||
iListItems->FolderId() == KMsvGlobalInBoxIndexEntryId )
{
}
}
if ( iListItems->MdcaCount() > 0 && SelectionCount() == 0 )
{
iOwningView.SetHideExitCommand( EFalse );
}
TKeyResponse ret = iTreeListBox->OfferKeyEventL(aKeyEvent, aType);
iOwningView.SetCurrentItemId();
SetAnchorItemIdL(
CMceMessageListContainerBase::EMessageListOperationGeneral );
if ( iOwningView.IsMSKMailBox() &&
( aKeyEvent.iCode == EKeyUpArrow || aKeyEvent.iCode == EKeyDownArrow ) )
{
iOwningView.SetMSKButtonL();
}
return ret;
}
else
{
return EKeyWasNotConsumed;
}
}
//-------------------------------------------------------------------------------
//CMceMessageListContainer::IsValidSearchKey(const TKeyEvent& aKeyEvent)
//-------------------------------------------------------------------------------
//
TBool CMceOneRowMessageListContainer::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::StateCanBeChangedByStarKeyL() const
// Exam if it is the situation that * key can change message state
// Returns ETrue if it can
// Public
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::StateCanBeChangedByStarKeyL() const
{
TMsvId folderId = iListItems->FolderId();
TBool isRemoteFolder = iListItems->IsFolderRemote();
if ( ( iListItems->MessageCount() > 0
&& SelectionCount() == 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;
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::IsCurrentItemFolder
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::IsCurrentItemFolder() const
{
TBool isCurrentFolder = EFalse;
const TMsvId id = CurrentItemId();
if ( id != KErrNotFound )
{
isCurrentFolder = IsItemFolder( id );
}
return isCurrentFolder;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::IsItemFolder
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::IsItemFolder( TMsvId aItemId ) const
{
return iListItems->IsItemFolder( aItemId );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::IsItemFolder
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::IsItemFolder( TInt aIndex ) const
{
TBool isCurrentFolder = EFalse;
const TMsvId id = iListItems->MsvItemId( aIndex );
if ( id != KErrNotFound )
{
isCurrentFolder = iListItems->IsItemFolder( id );
}
return isCurrentFolder;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::IsItemRemote
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::IsItemRemote( TMsvId aItemId ) const
{
return iListItems->IsItemRemote( aItemId );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::IsOpenedFolder
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::IsOpenedFolder( TMsvId aFolderId ) const
{
return ( iListItems->FolderId() == aFolderId );
}
// ----------------------------------------------------
// CMceMessageListContainer::DisplayOptionsMenuFromSelectionKey
// ----------------------------------------------------
//
TBool CMceOneRowMessageListContainer::DisplayOptionsMenuFromSelectionKey() const
{
TInt itemCount = 0;
TRAP_IGNORE( itemCount = GetMarkedItemsCountL() );
return ( (iListItems->MessageCount() + iListItems->FolderCount()) == 0 || itemCount );
}
// ----------------------------------------------------
// CMceMessageListContainer::GetHelpContext
// returns helpcontext as aContext
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::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;
}
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SetSortTypeL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::SetSortTypeL( TInt aSortType, TBool aOrdering )
{
SaveMarkingL();
ResetListbox();
iListItems->SetOrderingL( aSortType, aOrdering );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SetMtmUiDataRegistry
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::SetMtmUiDataRegistry( MMtmUiDataRegistryObserver* aRegistryObserver )
{
iListItems->SetRegistryObserver( aRegistryObserver );
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::TMessageListItemType
// ----------------------------------------------------
//
CMceMessageListContainerBase::TMessageListItemType CMceOneRowMessageListContainer::CurrentItemType() const
{
if ( iTreeListBox &&
( iListItems->MessageCount() || iListItems->FolderCount() )
)
{
TAknTreeItemID focusedItem = iTreeListBox->FocusedItem();
if ( iListItems->MsvItemId( focusedItem ) > KErrNotFound )
{
return CMceMessageListContainerBase::EMessageListItemMsvItem;
}
else if ( focusedItem == KAknTreeIIDNone )
{
return CMceMessageListContainerBase::EMessageListItemUnknown;
}
else
{
return CMceMessageListContainerBase::EMessageListItemSubtitle;
}
}
return CMceMessageListContainerBase::EMessageListItemUnknown;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::ProcessCommandL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::ProcessCommandL(TInt /*aCommand*/)
{
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::SetListEmptyTextL
// ----------------------------------------------------
//
void CMceOneRowMessageListContainer::SetListEmptyTextL(const TDesC& aText )
{
iTreeListBox->SetEmptyTextL( aText );
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::ChangeMskCommand
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::ChangeMskCommand( TInt aLabelResourceId )
{
// The MSK commands should not be changed when controlled by the list.
__ASSERT_DEBUG( !iMarkingModeEnabled, User::Invariant() );
// Get cba and set MSK command
CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
if ( cba )
{
TBuf<KMSKLabel> label;
TRAP_IGNORE( cba->SetCommandL( KMSKPosition, aLabelResourceId ) );
cba->DrawDeferred();
}
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::OptionsCommandSupported
// ----------------------------------------------------
TUint CMceOneRowMessageListContainer::OptionsCommandSupported() const
{
TUint listCommand = TMessageListCommandNone;
if ( iTreeListBox )
{
TAknTreeItemID focused = iTreeListBox->FocusedItem();
if ( focused )
{
if ( focused != KAknTreeIIDNone )
{
TAknTreeItemID parent = iTreeListBox->Parent( focused );
// Focused item is a node and it is collapsed
if ( iTreeListBox->IsNode( focused )
&& !( iTreeListBox->IsExpanded( focused ) ) )
{
listCommand = TMessageListCommandExpand;
}
// Focused item is expanded node or data row of the expanded node
if ( ( iTreeListBox->IsNode( focused ) && iTreeListBox->IsExpanded( focused ) ) )
{
listCommand = TMessageListCommandCollapse1;
}
else if ( iTreeListBox->IsLeaf( focused ) && parent != KAknTreeIIDRoot )
{
listCommand = TMessageListCommandCollapse2;
}
}
}
else
{
// No item is focused
}
}
return listCommand;
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::HandleOptionsCommandL
// ----------------------------------------------------
void CMceOneRowMessageListContainer::HandleOptionsCommandL( TInt aCommand )
{
// Handle list specific options command
iContainerFlags.ClearMceFlag( EMceOneRowFlagOptionsMenuOpen );
switch( aCommand)
{
case TMessageListCommandCollapse1:
case TMessageListCommandCollapse2:
CollapseFocusedNode();
break;
case TMessageListCommandExpand:
ExpandFocusedNode();
break;
default:
break;
}
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::ExpandFocusedNode
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::ExpandFocusedNode()
{
if ( iTreeListBox )
{
// Get focused item ID.
TAknTreeItemID focused = iTreeListBox->FocusedItem();
// Check that focused item is a node and then expand it.
if ( focused != KAknTreeIIDNone && iTreeListBox->IsNode( focused ) )
{
iTreeListBox->ExpandNode( focused, ETrue );
}
}
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::CollapseFocusedNode
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::CollapseFocusedNode()
{
if ( iTreeListBox )
{
// Get focused item ID.
TAknTreeItemID focused = iTreeListBox->FocusedItem();
// Check that focused item is a node or a leaf
if ( focused != KAknTreeIIDNone && iTreeListBox->IsNode( focused ) )
{
iTreeListBox->CollapseNode( focused, ETrue );
}
if ( iTreeListBox->IsLeaf( focused ) )
{
iTreeListBox->CollapseNode( iTreeListBox->Parent( focused ), ETrue );
}
}
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::DateTimeFormatChangedL
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::DateTimeFormatChangedL( TInt aChangeFlag )
{
TInt change = aChangeFlag;
if ( ( change & EChangesMidnightCrossover ))
{
ResetListbox();
iListItems->RefreshArrayL();
}
else if ( ( change & EChangesLocale ))
{
TLocale locale;
TDay startOfWeek = locale.StartOfWeek();
if ( startOfWeek != iStartOfWeek )
{
iStartOfWeek = startOfWeek;
ResetListbox();
iListItems->RefreshArrayL();
return;
}
TMsvSelectionOrdering listType = iListItems->SortType();
TInt timeColumn = KMceColumn2;
if ( listType.Sorting() == EMsvSortByDate ||
listType.Sorting() == EMsvSortByDateReverse )
{
timeColumn = KMceColumn3;
}
TInt count = iListItems->MdcaCount();
for (TInt i=0; i<count; i++)
{
TAknTreeItemID treeItemId = iListItems->TreeItemId( i );
TMsvId itemId = iListItems->MsvItemId( treeItemId );
if ( itemId > KErrNotFound && treeItemId > KAknTreeIIDNone )
{
// this is message, update time/date
TBuf<KMceTextItemSize> buffer;
iListItems->GetColumnTextL( i, timeColumn, buffer );
iTreeListBox->SetTextL(
treeItemId,
buffer,
timeColumn-1,
EFalse );
}
}
}
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::SetSpecialMskL
// ---------------------------------------------------------------------------
//
TInt CMceOneRowMessageListContainer::SetSpecialMskL()
{
TInt resourceId = R_MCE_MSK_BUTTON_EMPTY;
TAknTreeItemID focusedItem = iTreeListBox->FocusedItem();
if ( GetMarkedItemsCountL() == 0 )
{
// Determine the MSK command depending on the focused item type and state.
if ( focusedItem == KAknTreeIIDNone )
{
// No item focused.
}
else if ( iTreeListBox->IsNode( focusedItem ) )
{
if ( iTreeListBox->IsExpanded( focusedItem ) )
{
resourceId = R_MCE_QTN_MSK_COLLAPSE;
}
else
{
resourceId = R_MCE_QTN_MSK_EXPAND;
}
}
else if ( iTreeListBox->IsLeaf( focusedItem ) )
{
resourceId = R_MCE_MSK_BUTTON_OPEN;
}
}
else
{
resourceId = R_MCE_MSK_BUTTON_CONTEXT_OPTIONS;
}
return resourceId;
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::UpdateEntryL
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::UpdateEntryL( TMsvId aEntryId )
{
MCELOGGER_ENTERFN("CMceOneRowMessageListContainer::UpdateEntryL");
TInt itemIndex = iListItems->ItemIndex( aEntryId );
MCELOGGER_WRITE_FORMAT("aEntryId: 0x%x", aEntryId );
MCELOGGER_WRITE_FORMAT("itemIndex : %d", itemIndex );
if ( itemIndex < 0 )
{
TMsvEntry entry;
if ( iListItems->GetEntry( aEntryId, entry ) == KErrNone )
{
MCELOGGER_WRITE("entry found, try to add it");
CMsvEntrySelection* selection = new(ELeave) CMsvEntrySelection();
CleanupStack::PushL( selection );
selection->AppendL( aEntryId );
EntryCreatedL( *selection, ETrue );
CleanupStack::PopAndDestroy( selection );
}
MCELOGGER_LEAVEFN("CMceOneRowMessageListContainer::UpdateEntryL1");
return;
}
TAknTreeItemID treeItemId = iListItems->TreeItemId( itemIndex );
TMsvEntry entry;
User::LeaveIfError( iListItems->GetEntry( aEntryId, entry ) );
TInt foundIcon = KErrNotFound;
CFbsBitmap* bitmap = NULL;
CFbsBitmap* bitmapMask = NULL;
foundIcon = iBitmapResolver->GetBitmapL( entry, bitmap, bitmapMask );
if ( foundIcon < 0 )
{
foundIcon = iTreeListBox->AddIconL(
bitmap,
bitmapMask,
EFalse,
EAspectRatioPreserved );
iBitmapResolver->AddTreeIconIdL( bitmap, foundIcon, entry.iMtm );
}
TBuf<KMceTextItemSize> bufferC1;
TBuf<KMceTextItemSize> bufferC2;
TBuf<KMceTextItemSize> bufferC3;
iListItems->GetColumnTextL( itemIndex, KMceColumn1, bufferC1 );
iListItems->GetColumnTextL( itemIndex, KMceColumn2, bufferC2 );
iListItems->GetColumnTextL( itemIndex, KMceColumn3, bufferC3 );
iTreeListBox->SetTextL(
treeItemId,
bufferC1,
0,
EFalse );
if ( IsItemFolder( entry.Id() ))
{
iTreeListBox->SetTextL(
treeItemId,
bufferC3,
3,
EFalse );
}
else
{
iTreeListBox->SetTextL(
treeItemId,
bufferC2,
1,
EFalse );
iTreeListBox->SetTextL(
treeItemId,
bufferC3,
2,
EFalse );
}
if ( foundIcon >= 0 )
{
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::ELeaf,
foundIcon,
EFalse );
TBool attachmentIcon = EFalse;
if ( entry.Attachment() && entry.iMtm != KSenduiMtmMmsUid )
{
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::EOptionalIcon1,
iBitmapResolver->TreeIconId( EMceBitmapIndexAttachment ),
EFalse );
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::EHighlightedOptionalIcon1,
iBitmapResolver->TreeIconId( EMceBitmapIndexAttachmentFocus ),
EFalse );
attachmentIcon = ETrue;
}
if ( entry.iType == KUidMsvMessageEntry )
{
TMsvPriority entryPrio = entry.Priority();
if ( entryPrio != EMsvMediumPriority )
{
TInt prioIcon = 0;
TInt prioIconFocus = 0;
if ( entryPrio == EMsvHighPriority )
{
prioIcon = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityHigh );
prioIconFocus = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityHighFocus );
}
else
{
prioIcon = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityLow );
prioIconFocus = iBitmapResolver->TreeIconId( EMceBitmapIndexPriorityLowFocus );
}
if ( attachmentIcon )
{
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::EOptionalIcon2,
prioIcon,
EFalse );
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::EHighlightedOptionalIcon2,
prioIconFocus,
EFalse );
}
else
{
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::EOptionalIcon1,
prioIcon,
EFalse );
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::EHighlightedOptionalIcon1,
prioIconFocus,
EFalse );
}
}
}
}
iTreeListBox->EnableThirdColumn( treeItemId, bufferC3.Length(), EFalse );
iTreeListBox->SetEmphasis( treeItemId, entry.Unread(), EFalse );
TAknTreeItemID parentId = iTreeListBox->Parent( treeItemId );
if ( parentId > KAknTreeIIDRoot )
{
UpdateSubtitleIconL( parentId, EFalse );
}
MCELOGGER_LEAVEFN("CMceOneRowMessageListContainer::UpdateEntryL2");
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::EntryCreatedL
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::EntryCreatedL(
CMsvEntrySelection& aSelection,
TBool aDraw )
{
MCELOGGER_ENTERFN("CMceOneRowMessageListContainer::EntryCreatedL");
TBool tFocus = false;
for ( TInt i = 0; i < aSelection.Count(); i++ )
{
TMsvId itemId = aSelection[i];
TMsvEntry tentry;
iListItems->GetEntry( itemId, tentry);
if ( iEmailFramework &&
( tentry.iMtm == KSenduiMtmImap4Uid ||
tentry.iMtm == KSenduiMtmPop3Uid ||
tentry.iMtm == KSenduiMtmSmtpUid ||
tentry.iMtm.iUid == KUidMsgTypeCmailMtmVal ) )
{
continue;
}
MCELOGGER_WRITE_FORMAT("itemId: 0x%x", itemId );
TInt itemsAdded = iListItems->EntryCreatedL( itemId );
MCELOGGER_WRITE_FORMAT("itemsAdded: %d", itemsAdded );
if ( itemsAdded < 1 )
{
// item is hidden or otherwise we cound not find it, just ignore.
break;
}
TInt itemIndex = iListItems->ItemIndex( itemId );
MCELOGGER_WRITE_FORMAT("itemIndex: %d", itemIndex );
TAknTreeItemID parentId = iListItems->ParentItemId( itemIndex );
if ( itemsAdded == 2 && parentId == KAknTreeIIDNone )
{
TInt parentIndex = iListItems->ParentItemIndex( itemIndex );
TBuf<KMceTextItemSize> subTitle;
TInt itemType = iListItems->GetSubtitleTextL( parentIndex, subTitle );
if ( itemType > EHCListTypeNone )
{
TUint32 flags = CAknSingleColumnStyleTreeList::EPersistent
| CAknSingleColumnStyleTreeList::EExpanded;
iNodeId = iTreeListBox->AddSubtitleRowL( KAknTreeIIDRoot,
subTitle, flags, EFalse );
iListItems->SetTreeItemId( parentIndex, iNodeId );
UpdateSubtitleIconL( iNodeId, EFalse );
MCELOGGER_WRITE_FORMAT("Added subtitle row : 0x%x", iNodeId );
iTreeListBox->SetNonEmpty( iNodeId, ETrue, EFalse );
}
itemsAdded--;
}
if ( itemsAdded == 1 )
{
AddEntryL( itemIndex );
TMsvEntry entry;
if ( iListItems->GetEntry( itemId, entry ) == KErrNone )
{
if (entry.Unread())
{
iAnchorItemId = itemId;
tFocus = true;
}
else
{
tFocus = false;
}
}
MCELOGGER_WRITE_FORMAT("Added entry itemIndex: %d", itemIndex );
}
}
iTreeListBox->Sort( iListItems, CAknTreeList::ESaveFocus, ETrue );
if (tFocus == true)
{
SetCurrentItemIdL( iAnchorItemId );
}
if ( aDraw )
{
RefreshListbox();
}
MCELOGGER_LEAVEFN("CMceOneRowMessageListContainer::EntryCreatedL");
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::EntryDeletedL
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::EntryDeletedL(
CMsvEntrySelection& aSelection,
TBool aDraw )
{
TInt count = aSelection.Count();
for (TInt i=0; i<count; i++)
{
TAknTreeItemID treeItemId = KAknTreeIIDNone;
TAknTreeItemID parentTreeItemId = KAknTreeIIDNone;
TBool deleteParent = iListItems->EntryDeletedL( aSelection[i], treeItemId, parentTreeItemId );
if ( deleteParent )
{
// this removes node and child
iTreeListBox->RemoveItem( parentTreeItemId, EFalse );
}
else if ( treeItemId > KAknTreeIIDRoot )
{
// delete only one child, there are other children left so leave node untouched
iTreeListBox->RemoveItem( treeItemId, EFalse );
if ( parentTreeItemId > KAknTreeIIDRoot )
{
UpdateSubtitleIconL( parentTreeItemId, EFalse );
}
}
}
if ( aDraw )
{
RefreshListbox();
}
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::UpdateSubtitleIconL
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::UpdateSubtitleIconL( TAknTreeItemID aSubtitleID, TBool aReadStatusKnown )
{
TBool hasUnread = EFalse;
if ( aReadStatusKnown )
{
hasUnread = aReadStatusKnown;
}
else
{
hasUnread = iListItems->FindUnreadMessageUnderSubtitleL( aSubtitleID );
}
TInt iconID = GetSubtitleIcon( hasUnread );
iTreeListBox->SetIcon(
aSubtitleID,
CAknSingleColumnStyleTreeList::EExpandedNode,
iconID,
EFalse );
iTreeListBox->SetIcon(
aSubtitleID,
CAknSingleColumnStyleTreeList::ECollapsedNode,
iconID,
EFalse );
}
//-------------------------------------------------------------------------------
//CMceOneRowMessageListContainer::HandleShortcutForSearchL( const TKeyEvent& aKeyEvent )
//-------------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::HandleShortcutForSearchL( const TKeyEvent& aKeyEvent )
{
// in remote mailbox key has been pressed, find item if sorted
// by subject or sender
TBuf<KMceTextBufferLength> text;
text.Zero();
if ( iT9Interface->LastEnteredKey() != ( TInt ) aKeyEvent.iScanCode )
{
iT9Interface->ClearCurrentWord();
}
iT9Interface->AppendKeyPress( (TPtiKey)aKeyEvent.iScanCode );
text = iT9Interface->CurrentWord();
iOwningView.FindAndSelectEntryL( text );
iT9Timer->Start();
}
//-------------------------------------------------------------------------------
//CMceOneRowMessageListContainer::HasHandleStarKeyDoneL()
//-------------------------------------------------------------------------------
//
TBool CMceOneRowMessageListContainer::HasHandleStarKeyDoneL()
{
TBool starkeyIsHandled = EFalse;
if ( StateCanBeChangedByStarKeyL() )
{
if ( IsSortByDate() )
{
MarkReadUnreadWithStarKeyL();
}
else
{
// if sort by anything else other than by Date, handle focus change
TAknTreeItemID subtitle = iTreeListBox->Parent(
iTreeListBox->FocusedItem() );
if ( subtitle > KAknTreeIIDRoot )
{
TInt itemIndex = iTreeListBox->VisibleItemIndex( subtitle );
if ( itemIndex < 0 )
{
iTreeListBox->SetFocusedItem( subtitle,
KMceFocusOffsetTopView, ETrue );
}
else
{
iTreeListBox->SetFocusedItem( subtitle, itemIndex , ETrue );
}
}
else if ( subtitle == KAknTreeIIDRoot )
{
TAknTreeItemID firstItem = iTreeListBox->Child(
KAknTreeIIDRoot, KMceFirstItemIndex );
iTreeListBox->SetFocusedItem( firstItem,
KMceFocusOffsetTopView, ETrue );
}
}
starkeyIsHandled = ETrue;
}
return starkeyIsHandled;
}
//-------------------------------------------------------------------------------
//CMceOneRowMessageListContainer::MarkReadUnreadWithStarKeyL()
//-------------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::MarkReadUnreadWithStarKeyL()
{
if ( CurrentItemType() == EMessageListItemMsvItem )
{
MarkItemSelectionL();
if( iOwningView.IsItemUnread( CurrentItemId() ) )
{
iOwningView.HandleCommandL( EMceCmdMarkAsRead );
}
else
{
iOwningView.HandleCommandL( EMceCmdMarkAsUnread );
}
}
}
//-------------------------------------------------------------------------------
//CMceOneRowMessageListContainer::IsSortByDate()
//-------------------------------------------------------------------------------
//
TBool CMceOneRowMessageListContainer::IsSortByDate()
{
TMsvSelectionOrdering ordering = iListItems->SortType();
return ( ( ordering.Sorting() == EMsvSortByDateReverse) || ( ordering.Sorting() == EMsvSortByDate ) );
}
//-------------------------------------------------------------------------------
// CMceOneRowMessageListContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )
//-------------------------------------------------------------------------------
void CMceOneRowMessageListContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )
{
if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
{
iOwningView.SetMSKButtonL();
iOwningView.SetCurrentItemId();
if ( ( iOwningView.IsMSKMailBox() ||
iListItems->FolderId() == KMsvDraftEntryId ) &&
iTreeListBox->ChildCount( KAknTreeIIDRoot ) == 0 )
{
iOwningView.ProcessCommandL( EAknSoftkeyContextOptions );
}
}
if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
{
if ( iOwningView.IsMSKMailBox() )
{
iOwningView.CancelMailboxTimer();
}
}
iTreeListBox->HandlePointerEventL( aPointerEvent );
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::SetContainerFlag
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::SetContainerFlag( TMceContainerFlags aFlag, TBool aState )
{
switch ( aFlag )
{
case EMceOneRowFlagOptionsMenuOpen:
if ( !aState )
{
iContainerFlags.ClearMceFlag( EMceOneRowFlagOptionsMenuOpen );
}
else
{
iContainerFlags.SetMceFlag( EMceOneRowFlagOptionsMenuOpen );
}
break;
case EMceOneRowFlagFirstSubtitleOpen:
if ( !aState )
{
iContainerFlags.ClearMceFlag( EMceOneRowFlagFirstSubtitleOpen );
}
else
{
iContainerFlags.SetMceFlag( EMceOneRowFlagFirstSubtitleOpen );
}
break;
default:
break;
}
}
// ---------------------------------------------------------------------------
// CMceOneRowMessageListContainer::UpdateIconArrayL
// ---------------------------------------------------------------------------
//
void CMceOneRowMessageListContainer::UpdateIconArrayL( )
{
MCELOGGER_ENTERFN("CMceOneRowMessageListContainer::UpdateIconsInListL");
iBitmapResolver->UpdateIconArrayL( iTreeListBox );
const TInt count = iListItems->MdcaCount();
for ( TInt i = 0; i < count; i++ )
{
TMsvId entryId = iListItems->ItemId(i);
if ( entryId > KErrNotFound ) // If KErrNotFound, then this is subtitle?
{
TAknTreeItemID treeItemId = iListItems->TreeItemId( i );
TMsvEntry entry;
// TODO: do not leave here
User::LeaveIfError( iListItems->GetEntry( entryId, entry ) );
TInt foundIcon = KErrNotFound;
CFbsBitmap* bitmap = NULL;
CFbsBitmap* bitmapMask = NULL;
foundIcon = iBitmapResolver->GetBitmapL( entry, bitmap, bitmapMask );
if ( foundIcon < 0 )
{
foundIcon = iTreeListBox->AddIconL(
bitmap,
bitmapMask,
EFalse,
EAspectRatioPreserved );
iBitmapResolver->AddTreeIconIdL( bitmap, foundIcon, entry.iMtm );
}
if ( foundIcon >= 0 )
{
iTreeListBox->SetIcon(
treeItemId,
CAknSingleColumnStyleTreeList::ELeaf,
foundIcon,
EFalse );
}
}
}
MCELOGGER_LEAVEFN("CMceOneRowMessageListContainer::UpdateIconsInListL");
}
// ----------------------------------------------------
// CMceOneRowMessageListContainer::HandleOperationCompletedL
// ----------------------------------------------------
void CMceOneRowMessageListContainer::HandleOperationCompletedL()
{
if(iLastOperationType == EMessageListOperationConnect )
{
TInt selectedIndex =1;
iAnchorItemIndex=1;
iAnchorItemId = iListItems->ItemId( iAnchorItemIndex );
SetCurrentItemIdL( iAnchorItemId );
}
}
// End of File