/*
* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Container class for Events Management UI startup view.
*
*/
// SYSTEM INCLUDES
#include <avkon.hrh>
#include <avkon.mbg>
#include <barsread.h>
#include <aknlists.h>
#include <AknIconArray.h> // Icon Array
#include <eikclbd.h> // Column Listbox
#include <gulicon.h> // Gul Icon
#include <barsread.h> // TResourceReader
#include <eikspane.h> // Status pane
#include <akntitle.h> // CAknTitlePane
#include <StringLoader.h> // String Loader
#include <evtmgmtui.rsg>
#include <csxhelp/loc.hlp.hrh>
#include <AknUtils.h>
#include <evtmgmtui.mbg>
#include <featmgr.h>
#include <data_caging_path_literals.hrh>
#include <AknUtils.h>
#include <eikmenup.h>
#include <AknsConstants.h> // Skin Ids
#include <AknIconUtils.h>
#include <AknLayout.lag> // AVKON LAF layouts
#include <AknLayoutDef.h>
#include <aknsfld.h> // For SearchField
// USER INCLUDES
#include "evtmgmtui.hrh"
#include "evtmgmtuiuid.hrh"
#include "evtmgmtuiappui.h"
#include "evtmgmtuimodel.h"
#include "evtmgmtuistartupcontainer.h"
#include "evtmgmtuilistbox.h"
#include "evtmgmtuilistboxmodel.h"
#include "evtdebug.h"
// CONSTANT DEFINITIONS
const TInt KIconArrayGranularity = 5; // The number of default icons
const TInt KFindBoxTextLength = 32; // Find Box text length.
const TInt KMinCountForFilter = 2;
_LIT( KEvtMgmtUiIconFileName, "evtmgmtui.mif" );
// ----------------- Member funtions for CEvtMgmtUiStartupContainer class ------------------
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::CEvtMgmtUiStartupContainer
// ---------------------------------------------------------------------------
//
CEvtMgmtUiStartupContainer::CEvtMgmtUiStartupContainer( MEvtMgmtUiCmdHdlr& aCmdHandler )
:iCmdHandler(aCmdHandler)
{
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::~CEvtMgmtUiStartupContainer
// ---------------------------------------------------------------------------
//
CEvtMgmtUiStartupContainer::~CEvtMgmtUiStartupContainer()
{
// Delete the List box
delete iListBox;
delete iFindBox;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::NewL
// ---------------------------------------------------------------------------
//
CEvtMgmtUiStartupContainer* CEvtMgmtUiStartupContainer::NewL(
const TRect& aRect, CEvtMgmtUiModel* aModel,
MEvtMgmtUiCmdHdlr& aCmdHandler )
{
CEvtMgmtUiStartupContainer* self = new ( ELeave ) CEvtMgmtUiStartupContainer( aCmdHandler );
CleanupStack::PushL( self );
self->ConstructL( aRect, aModel );
CleanupStack::Pop();
return self;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::CEvtMgmtUiStartupContainer
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::ConstructL( const TRect& aRect, CEvtMgmtUiModel* aModel )
{
// This is the cheif control for this application. This has to be made a
// Window owning control
CreateWindowL();
// Create the List box
EVTUIDEBUG( "Listbox creation" );
CreateListboxL(aModel);
CreateFindBoxL();
// Check for FindBox Visiblity
HandleFindBoxVisibility();
// Get the Help context
iContextName = KHLP_LOC_EVENTS_VIEW();
// Set Title
MakeTitleL();
SetRect(aRect);
ActivateL();
}
// ---------------------------------------------------------------------------
// void CEvtMgmtUiStartupContainer::GetHelpContext
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::GetHelpContext( TCoeHelpContext& aContext ) const
{
aContext.iContext = iContextName;
aContext.iMajor = TUid::Uid( KEvtMgmtUiUid );
}
// --------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::FocusChanged
// --------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::FocusChanged( TDrawNow aDrawNow )
{
if ( iListBox )
{
iListBox->SetFocus( IsFocused(), aDrawNow );
}
if ( iFindBox && iFindBox->IsVisible() )
{
iFindBox->SetFocus( IsFocused(), aDrawNow );
if ( aDrawNow == EDrawNow && IsFocused() )
{
iFindBox->DrawDeferred();
}
}
}
// ---------------------------------------------------------------------------
// void CEvtMgmtUiStartupContainer::SizeChanged
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::SizeChanged()
{
EVTUIDEBUG("+ CEvtMgmtUiStartupContainer::SizeChanged()" );
const TRect rect( Rect() );
TAknLayoutRect controlRect;
// Since iFindBox->IsVisible() returns EFalse if Adaptive Chars are shown,
// We check on FilteredNumberOfItems meaning the FindBox should be visible when
// FilteredNumberOfItems is greater than 1
if( iListBox && iFindBox &&
( iFindBox->IsVisible() || iListBox->Model()->Filter()->FilteredNumberOfItems() > 1 ) )
{
controlRect.LayoutRect(rect, AknLayout::list_gen_pane( 1 ) );
iListBox->SetRect( controlRect.Rect() );
controlRect.LayoutRect(rect, AknLayout::find_pane() );
iFindBox->SetRect( controlRect.Rect() );
}
else if( iListBox )
{
controlRect.LayoutRect(rect, AknLayout::list_gen_pane( 0 ) );
iListBox->SetRect( controlRect.Rect() );
}
EVTUIDEBUG("- CEvtMgmtUiStartupContainer::SizeChanged()" );
}
// ---------------------------------------------------------------------------
// TInt CEvtMgmtUiStartupContainer::CountComponentControls
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiStartupContainer::CountComponentControls() const
{
TInt count = 0;
CCoeControl* controls[] = { iListBox, iFindBox };
for ( TUint i = 0; i < sizeof( controls ) / sizeof( CCoeControl* ); i++ )
{
if ( controls[i] ) // Test for valid controls
{
count++;
}
}
return count;
}
// ---------------------------------------------------------------------------
// CCoeControl* CEvtMgmtUiStartupContainer::CEvtMgmtUiStartupContainer
// ---------------------------------------------------------------------------
//
CCoeControl* CEvtMgmtUiStartupContainer::ComponentControl(TInt aIndex ) const
{
CCoeControl* controls[] = { iListBox,
iFindBox};
for ( TUint i = 0; i < sizeof( controls ) / sizeof( CCoeControl* ); i++ )
{
// Index is decremented only if control is not NULL
if ( controls[i] && aIndex-- == 0 )
{
return controls[i];
}
}
return NULL;
}
// ---------------------------------------------------------------------------
// TKeyResponse CEvtMgmtUiStartupContainer::OfferKeyEventL
// ---------------------------------------------------------------------------
//
TKeyResponse CEvtMgmtUiStartupContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,
TEventCode aType )
{
TKeyResponse keyresponse;
TBool needRefresh = EFalse;
TInt keyConsumed = iFindBox->TextLength();
// Key is first offered to the Find box based on the key press.
keyresponse = AknFind::HandleFindOfferKeyEventL(aKeyEvent, aType,
this, iListBox, iFindBox, EFalse, needRefresh);
// Handle the ListBox Filter count changed event
iCmdHandler.HandleCmdL( MEvtMgmtUiCmdHdlr::EListBoxFilterCountChanged );
// This is to avoid the Mark for the First item of the list box.
// We reset the modifier attribute
TKeyEvent& keyEvent = const_cast<TKeyEvent&>(aKeyEvent);
TInt index = CurrentItemIndex();
if(index == 0 ||
(index == iListBox->Model()->NumberOfItems() - 1) && aKeyEvent.iScanCode == EStdKeyDownArrow ||
(index == 1) && aKeyEvent.iScanCode == EStdKeyUpArrow )
{
if(keyEvent.iModifiers & EModifierShift)
keyEvent.iModifiers&= ~EModifierShift;
if(keyEvent.iModifiers & EModifierLeftShift)
keyEvent.iModifiers&= ~EModifierLeftShift;
if(keyEvent.iModifiers & EModifierRightShift)
keyEvent.iModifiers&= ~EModifierRightShift;
if(keyEvent.iModifiers & EModifierCtrl)
keyEvent.iModifiers&= ~EModifierCtrl;
if(keyEvent.iModifiers & EModifierRightCtrl)
keyEvent.iModifiers&= ~EModifierRightCtrl;
}
// Now handle the Key Event based on the Key type
switch ( aKeyEvent.iScanCode )
{
case EStdKeyUpArrow:
case EStdKeyDownArrow:
{
keyresponse = iListBox->OfferKeyEventL( aKeyEvent, aType );
iCmdHandler.HandleCmdL( MEvtMgmtUiCmdHdlr::EListBoxItemFocused );
return keyresponse;
}
case EStdKeyBackspace:
case EStdKeyDelete:
{
if(aType == EEventKey && !keyConsumed )
{
keyresponse = iListBox->OfferKeyEventL( aKeyEvent, aType );
iCmdHandler.HandleCmdL( MEvtMgmtUiCmdHdlr::EListBoxItemDeleted );
}
return keyresponse;
}
case EStdKeyHash:
{
if(!index)
{
keyresponse = EKeyWasConsumed;
}
else
{
TBool shiftKeyPressed = ( aKeyEvent.iModifiers & EModifierShift );
keyresponse = iListBox->OfferKeyEventL( aKeyEvent, aType );
if( aType == EEventKeyUp && ( EKeyWasConsumed == keyresponse || !shiftKeyPressed ) )
iCmdHandler.HandleCmdL( MEvtMgmtUiCmdHdlr::EListBoxItemFocused );
}
return keyresponse;
}
default:
{
break;
}
}
// Now it's List box's job to process the key event
return iListBox->OfferKeyEventL( aKeyEvent, aType );
}
// ---------------------------------------------------------------------------
// void CEvtMgmtUiStartupContainer::HandleResourceChange
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::HandleResourceChange( TInt aType )
{
// Pass the event to the base class
CCoeControl::HandleResourceChange(aType);
switch( aType )
{
case KAknsMessageSkinChange:
{
TRAPD( error, UpdateIconsL() );
if ( error != KErrNone )
{
iEikonEnv->HandleError( error );
}
DrawDeferred();
break;
}
// Dynamic Layout switch
case KEikDynamicLayoutVariantSwitch:
{
// Handle the screen change event
// Trap and Ignore the error
TRAP_IGNORE(
iCmdHandler.HandleCmdL( MEvtMgmtUiCmdHdlr::EScreenSizeChanged ));
break;
}
default:
{
break;
}
}
}
// ---------------------------------------------------------------------------
// void CEvtMgmtUiStartupContainer::HandleListBoxEventL
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::HandleListBoxEventL(
CEikListBox* /* aListBox */,
TListBoxEvent aEventType )
{
switch (aEventType)
{
// List box Item Selection
case EEventEnterKeyPressed:
case EEventItemSingleClicked:
{
iCmdHandler.HandleCmdL( MEvtMgmtUiCmdHdlr::EListBoxItemDoubleClicked );
break;
}
case EEventItemClicked:
{
iCmdHandler.HandleCmdL( MEvtMgmtUiCmdHdlr::EListBoxItemFocused);
break;
}
default:
break;
}
}
// ---------------------------------------------------------------------------
// void CEvtMgmtUiStartupContainer::CreateListboxL
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::CreateListboxL( CEvtMgmtUiModel* aModel )
{
EVTUIDEBUG("+ CEvtMgmtUiStartupContainer::CreateListboxL()" );
// Create the List box
iListBox = new ( ELeave ) CEvtMgmtUiListBox();
iListBox->ConstructL( this, EAknListBoxStylusMarkableList );
iListBox->SetContainerWindowL( *this );
iListBox->SetListBoxObserver( this );
iListBox->CreateScrollBarFrameL(ETrue);
iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
CEikScrollBarFrame::EAuto );
UpdateIconsL();
// Create the Listbox model
CEvtMgmtUiListBoxModel* model = static_cast<CEvtMgmtUiListBoxModel*>(iListBox->Model());
model->SetItemTextArray( aModel );
model->SetOwnershipType( ELbmDoesNotOwnItemArray );
model->SetItemTextArrayToFilterModel();
iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );
iListBox->ActivateL();
EVTUIDEBUG("- CEvtMgmtUiStartupContainer::CreateListboxL()" );
}
// -----------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::CreateFindBoxL()
//
// Creates the member iFindBox
// -----------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::CreateFindBoxL()
{
EVTUIDEBUG("+ CEvtMgmtUiStartupContainer::CreateFindBoxL()" );
// Create the findbox.
iFindBox = CAknSearchField::NewL( *this, CAknSearchField::EAdaptiveSearch,
NULL, KFindBoxTextLength );
// Set default input mode to Katakana if current UI language is Japanese
if (FeatureManager::FeatureSupported(KFeatureIdJapanese) &&
(User::Language() == ELangJapanese))
{
iFindBox->Editor().SetAknEditorInputMode(EAknEditorKatakanaInputMode);
}
else
{
iFindBox->Editor().SetAknEditorCurrentInputMode(EAknEditorTextInputMode);
}
// Set Column mask
iFindBox->SetListColumnFilterFlags(2); // This is set to search only "Subject" column
STATIC_CAST(CAknFilteredTextListBoxModel*, iListBox->Model())->CreateFilterL(iListBox,iFindBox);
STATIC_CAST(CAknFilteredTextListBoxModel*, iListBox->Model())->Filter()->SetParentControl( this );
iListBox->Model()->SetFindToFilterModel(iFindBox);
iFindBox->ActivateL();
EVTUIDEBUG("- CEvtMgmtUiStartupContainer::CreateFindBoxL()" );
}
// -----------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::MakeFindBoxVisible()
//
// Deletes the member iFindBox
// -----------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::HandleFindBoxVisibility()
{
if( iListBox && iFindBox )
{
if(iListBox->Model()->Filter()->FilteredNumberOfItems() < KMinCountForFilter )
{
iFindBox->SetFocusing( EFalse );
iFindBox->MakeVisible( EFalse );
iListBox->SetFocusing( ETrue );
}
else
{
iFindBox->SetFocusing( ETrue );
iFindBox->MakeVisible( ETrue );
iListBox->SetFocusing( EFalse );
}
SizeChanged();
DrawNow();
}
}
// -----------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::UpdateIconsL
// -----------------------------------------------------------------------------
void CEvtMgmtUiStartupContainer::UpdateIconsL()
{
EVTUIDEBUG( "+ CEvtMgmtUiStartupContainer::UpdateIconsL()" );
CAknIconArray* icons = new( ELeave ) CAknIconArray( KIconArrayGranularity );
CleanupStack::PushL( icons );
TFileName *iconFile = IconFileNameLC();
//mark
AddColorIconL( *icons,
AknIconUtils::AvkonIconFileName(),
KAknsIIDQgnIndiMarkedAdd,
EMbmAvkonQgn_indi_marked_add, EMbmAvkonQgn_indi_marked_add_mask );
//Create new event
AddIconL( *icons,
*iconFile,
KAknsIIDQgnPropLocevNew,
EMbmEvtmgmtuiQgn_prop_locev_new, EMbmEvtmgmtuiQgn_prop_locev_new_mask);
//active
AddIconL( *icons,
*iconFile,
KAknsIIDQgnPropLocevTrigger,
EMbmEvtmgmtuiQgn_prop_locev_trigger, EMbmEvtmgmtuiQgn_prop_locev_trigger_mask);
//draft
AddIconL( *icons,
*iconFile,
KAknsIIDQgnPropLocevDraft,
EMbmEvtmgmtuiQgn_prop_locev_draft, EMbmEvtmgmtuiQgn_prop_locev_draft_mask);
//completed
AddIconL( *icons,
*iconFile,
KAknsIIDQgnPropLocevCompleted,
EMbmEvtmgmtuiQgn_prop_locev_completed, EMbmEvtmgmtuiQgn_prop_locev_completed_mask);
// repeat
AddColorIconL( *icons,
*iconFile,
KAknsIIDQgnIndiRepeatAdd,
EMbmEvtmgmtuiQgn_indi_repeat_add, EMbmEvtmgmtuiQgn_indi_repeat_add_mask);
CleanupStack::PopAndDestroy(iconFile);
//get old icons and delete those
CAknIconArray* oldIcons = static_cast<CAknIconArray*>(
iListBox->ItemDrawer()->ColumnData()->IconArray() );
delete oldIcons;
//set new icons to array
iListBox->ItemDrawer()->ColumnData()->SetIconArray( icons );
CleanupStack::Pop(icons);
EVTUIDEBUG( "- CEvtMgmtUiStartupContainer::UpdateIconsL()" );
}
// -----------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::AddIconL
// -----------------------------------------------------------------------------
void CEvtMgmtUiStartupContainer::AddIconL( CAknIconArray& aIcons,
const TDesC& aIconFileWithPath,
TAknsItemID aSkinID,
TInt aIconGraphicsIndex,
TInt aIconGraphicsMaskIndex )
{
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
EVTUIDEBUG( "AknsUtils::SkinInstance" );
CFbsBitmap* bitmap = NULL;
CFbsBitmap* bitmapMask = NULL;
TRAPD( err, AknsUtils::CreateIconL( skin,
aSkinID,
bitmap,
bitmapMask,
aIconFileWithPath,
aIconGraphicsIndex,
aIconGraphicsMaskIndex ) );
EVTUIDEBUG1( "AknsUtils::CreateIconL - %d", err );
if(err != KErrNone)
{
TRAP( err, AknIconUtils::CreateIconL( bitmap,
bitmapMask,
aIconFileWithPath,
aIconGraphicsIndex,
aIconGraphicsMaskIndex ) );
EVTUIDEBUG1( "AknIconUtils::CreateIconL - %d", err );
}
User::LeaveIfError( err );
CleanupStack::PushL( bitmap );
CleanupStack::PushL( bitmapMask );
CGulIcon* icon = CGulIcon::NewL( bitmap, bitmapMask );
// Remove the Bitmap and the Bitmap Icon from the Clean up stack since
// the ownership is taken over by the icon
CleanupStack::Pop( bitmapMask );
CleanupStack::Pop( bitmap );
CleanupStack::PushL( icon );
aIcons.AppendL( icon );
CleanupStack::Pop( icon ); // icon
}
// -----------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::AddColorIconL
// -----------------------------------------------------------------------------
void CEvtMgmtUiStartupContainer::AddColorIconL( CAknIconArray& aIcons,
const TDesC& aIconFileWithPath,
TAknsItemID aSkinID,
TInt aIconGraphicsIndex,
TInt aIconGraphicsMaskIndex )
{
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
// Repeat icon. Color skinned with day view icon color
// FIXME: highlight coloring in lists doesn't work for icons.
// When Avkon suplies some method to do that, change these
TAknsItemID colorGroup = KAknsIIDQsnIconColors;
TInt colorIndex = EAknsCIQsnIconColorsCG19;
TRgb nonSkinColor = AKN_LAF_COLOR(215);
CFbsBitmap* bitmap = NULL;
CFbsBitmap* bitmapMask = NULL;
AknsUtils::CreateColorIconLC( skin,
aSkinID,
colorGroup,
colorIndex,
bitmap,
bitmapMask,
aIconFileWithPath,
aIconGraphicsIndex,
aIconGraphicsMaskIndex,
nonSkinColor );
CGulIcon* icon = CGulIcon::NewL( bitmap, bitmapMask );
// Remove the Bitmap and the Bitmap Icon from the Clean up stack since
// the ownership is taken over by the icon
CleanupStack::Pop( bitmapMask );
CleanupStack::Pop( bitmap );
CleanupStack::PushL( icon );
aIcons.AppendL( icon );
CleanupStack::Pop( icon ); // icon
}
// -----------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::IconFileNameLC
// -----------------------------------------------------------------------------
TFileName* CEvtMgmtUiStartupContainer::IconFileNameLC() const
{
TFileName* fileName = new(ELeave) TFileName;
CleanupStack::PushL( fileName );
TFileName* tmpName = new(ELeave) TFileName;
CleanupStack::PushL( tmpName );
tmpName->Append( KDC_BITMAP_DIR );
tmpName->Append( KEvtMgmtUiIconFileName );
CEikAppUi *appUi = ( CEikAppUi *)( CEikonEnv::Static()->AppUi());
TFileName appDrive = appUi->Application()->AppFullName();
TParse parse;
User::LeaveIfError( parse.Set( appDrive, NULL, NULL ) );
User::LeaveIfError( parse.Set( parse.Drive(), tmpName, NULL ) );
fileName->Copy(parse.FullName());
CleanupStack::PopAndDestroy( tmpName );
return fileName;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::UpdateListBoxL()
// It will update listbox
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::UpdateListBoxL(TInt aSelectedItemIndex)
{
iListBox->Model()->Filter()->ResetFilteringL();
iFindBox->ResetL();
iListBox->ClearSelection();
TInt count = iListBox->Model()->NumberOfItems();
if( iPrevCount > count )
{
iListBox->HandleItemRemovalL();
iListBox->DrawNow();
}
else
{
iListBox->HandleItemAdditionL();
}
iPrevCount = count;
if( aSelectedItemIndex >= count )
aSelectedItemIndex = count-1;
if(aSelectedItemIndex<0)
aSelectedItemIndex = 0;
iListBox->SetCurrentItemIndexAndDraw( aSelectedItemIndex );
// Check for FindBox Visiblity
HandleFindBoxVisibility();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::CurrentItemIndex()
// It will return the index of the selected item
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiStartupContainer::CurrentItemIndex()
{
return iListBox->Model()->Filter()->FilteredItemIndex( iListBox->CurrentItemIndex() );
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::HandleMarkCmd()
// It will handle mark functionality.
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::HandleMarkCmdL( TInt aIndex, TBool aIsMarked )
{
CListBoxView* listBoxView = iListBox->View();
CAknFilteredTextListBoxModel* model = iListBox->Model();
if( aIndex != KErrNotFound )
{
TInt visibleIndex = model->Filter()->VisibleItemIndex(aIndex);
if (aIsMarked)
{
listBoxView->SelectItemL(visibleIndex);
}
else
{
listBoxView->DeselectItem(visibleIndex);
}
}
else
{
TInt itemCount = model->NumberOfItems();
for (TUint i = 1; i < itemCount; i++)
{
TInt visibleIndex = model->Filter()->VisibleItemIndex(i);
if (aIsMarked)
{
listBoxView->SelectItemL(i);
}
else
{
listBoxView->DeselectItem(i);
}
}
}
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::HandleMarkableListDynInitMenuPane()
// It will display mark menu items dynamically
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::HandleMarkableListDynInitMenuPane( TInt /*ResourceId */, CEikMenuPane *aMenuPane )
{
TInt pos;
if( !aMenuPane->MenuItemExists(EAknCmdMark, pos) )
return;
TInt markItems = iListBox->SelectionIndexes()->Count();
if( iListBox->CurrentItemIndex() == 0 ) //if 'Create New Event'
{
aMenuPane->SetItemDimmed( EAknCmdMark, ETrue );
aMenuPane->SetItemDimmed( EAknCmdUnmark, ETrue );
}
else
{
if(iListBox->View()->ItemIsSelected(iListBox->CurrentItemIndex()) )
{
aMenuPane->SetItemDimmed( EAknCmdMark, ETrue );
aMenuPane->SetItemDimmed( EAknCmdUnmark, EFalse );
}
else
{
aMenuPane->SetItemDimmed( EAknCmdMark, EFalse );
aMenuPane->SetItemDimmed( EAknCmdUnmark, ETrue );
}
}
if( markItems < 1 )// if no item is selected
{
aMenuPane->SetItemDimmed( EAknUnmarkAll, ETrue );
}
else
{
aMenuPane->SetItemDimmed( EAknUnmarkAll, EFalse );
}
if( markItems == iListBox->Model()->NumberOfItems()-1 )// if all items are selected
{
aMenuPane->SetItemDimmed( EAknMarkAll, ETrue );
}
else
{
aMenuPane->SetItemDimmed( EAknMarkAll, EFalse );
}
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::NumberOfMarkedItems()
// It will return count of marked items
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiStartupContainer::NumberOfMarkedItems()
{
return iListBox->SelectionIndexes()->Count();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::MarkItems()
// It will return marked items
// ---------------------------------------------------------------------------
//
const CArrayFix<TInt>* CEvtMgmtUiStartupContainer::MarkItems()
{
return iListBox->SelectionIndexes();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::FilteredIndex()
// It will return marked items
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiStartupContainer::FilteredIndex(TInt aIndex)
{
return iListBox->Model()->Filter()->FilteredItemIndex( aIndex );
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::FilteredCount()
// It will return count of marked items
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiStartupContainer::FilteredCount()
{
return iListBox->Model()->Filter()->FilteredNumberOfItems();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupContainer::MakeTitleL()
// Set the Title Text
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiStartupContainer::MakeTitleL()
{
// Obtain the title from the Status Pane
CAknTitlePane* title = static_cast<CAknTitlePane*>( iEikonEnv->AppUiFactory()->
StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle )));
// Set the Title's buffer
HBufC* buf = StringLoader::LoadL( R_EVTUI_TITLE );
title->SetText( buf ); // Takes ownership of buf
}
// End of File