/*
* Copyright (c) 2008 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: Model class for Events management UI start-up view.
*
*/
// System Includes
#include <e32keys.h>
#include <barsread.h> // For TResourceReader
#include <bautils.h>
#include <StringLoader.h>
#include <evtmgmtui.rsg>
#include <eikenv.h>
#include <AknUtils.h>
// User Include
#include "evtmgmtuimodel.h"
#include "evtbasiceventinfo.h"
#include "evtdebug.h"
// Constants
const TInt KPreDefinedItems = 1;
const TInt KMaxConversionBufferLength = 0x200;
// ========================= MEMBER FUNCTIONS ================================
// ---------------------------------------------------------------------------
// CEvtMgmtUiStartupLBModel::CEvtMgmtUiStartupLBModel
// ---------------------------------------------------------------------------
//
CEvtMgmtUiModel::CEvtMgmtUiModel()
{
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::~CEvtMgmtUiModel
// ---------------------------------------------------------------------------
//
CEvtMgmtUiModel::~CEvtMgmtUiModel()
{
// Delete the Buffers
delete iBuffer;
iBuffer = NULL;
delete iCreateNew;
iCreateNew = NULL;
delete iUnnamed;
iUnnamed = NULL;
iEventsArray.ResetAndDestroy();
iEventsArray.Close();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel* CEvtMgmtUiModel::NewL
// ---------------------------------------------------------------------------
//
CEvtMgmtUiModel* CEvtMgmtUiModel::NewL()
{
CEvtMgmtUiModel* self = CEvtMgmtUiModel::NewLC();
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel* CEvtMgmtUiModel::NewLC
// ---------------------------------------------------------------------------
//
CEvtMgmtUiModel* CEvtMgmtUiModel::NewLC()
{
CEvtMgmtUiModel* self = new( ELeave )CEvtMgmtUiModel();
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// ---------------------------------------------------------------------------
// void CEvtMgmtUiModel::ConstructL
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiModel::ConstructL()
{
EVTUIDEBUG( "+ CEvtMgmtUiModel::ConstructL()" );
// Allocate the Conversion Buffer
iBuffer = HBufC16::NewL( KMaxConversionBufferLength );
// Open the Resource File
// OpenLocalizedResourceFileL( KEvtEngineResFileName, iResourceLoader );
// Allocate and set the access point title
iCreateNew = StringLoader::LoadL( R_EVTUI_CREATENEW_LIST );
iUnnamed = StringLoader::LoadL( R_EVTUI_UNNAMED );
iStatusFilter = CEvtMgmtUiEngine::EEvtFilterAll;
EVTUIDEBUG( "- CEvtMgmtUiModel::ConstructL()" );
}
// ---------------------------------------------------------------------------
// TInt CEvtMgmtUiModel::MdcaCount() const
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiModel::MdcaCount() const
{
// Return the Model count based on the Status Filter
switch( iStatusFilter )
{
case CEvtMgmtUiEngine::EEvtFilterAll:
return KPreDefinedItems + iActiveTriggers + iDraftTriggers + iCompletedTriggers;
case CEvtMgmtUiEngine::EEvtFilterActive:
return KPreDefinedItems + iActiveTriggers;
case CEvtMgmtUiEngine::EEvtFilterDraft:
return KPreDefinedItems + iDraftTriggers;
case CEvtMgmtUiEngine::EEvtFilterCompleted:
return KPreDefinedItems + iCompletedTriggers;
default:
return KPreDefinedItems + iActiveTriggers + iDraftTriggers + iCompletedTriggers;
}
}
// ---------------------------------------------------------------------------
// TPtrC16 CEvtMgmtUiModel::MdcaPoint() const
// ---------------------------------------------------------------------------
//
TPtrC16 CEvtMgmtUiModel::MdcaPoint( TInt aIndex ) const
{
// Zero the internal buffer
TPtr16 ptr( iBuffer->Des());
TPtrC subject(KNullDesC);
TPtrC place(KNullDesC);
ptr.Zero();
// Format "%d\t%S\t%S\t%d"
// Append the Icon ID
if( aIndex==0 )
ptr.AppendNum( 1 );
else
{
// Get the Index based on the Status Filter
aIndex = IndexBasedOnFilter( aIndex );
switch(iEventsArray[aIndex-1]->EventStatus())
{
case EActive:
{
ptr.AppendNum( 2 );
break;
}
case EDraft:
{
ptr.AppendNum( 3 );
break;
}
case ECompleted:
{
ptr.AppendNum( 4 );
break;
}
}
}
// Append the first tab
ptr.Append( EKeyTab );
// Subject
if(aIndex==0)
{
ptr.Append( *iCreateNew );
ptr.Append( EKeyTab );
ptr.Append( EKeyTab );
}
else
{
subject.Set(iEventsArray[aIndex-1]->Subject());
place.Set(iEventsArray[aIndex-1]->Place());
if(subject.Compare(KNullDesC)==0 && place.Compare(KNullDesC)==0)
{
ptr.Append(*iUnnamed);
}
else
ptr.Append(subject);
//Place
ptr.Append( EKeyTab );
{
HBufC* localPlace = place.Alloc();
if( localPlace )
{
TPtr placePtr = localPlace->Des();
ptr.Append(placePtr);
delete localPlace;
}
}
ptr.Append( EKeyTab );
if( iEventsArray[aIndex-1]->Repeat() )
ptr.AppendNum(5);
}
return *iBuffer;
}
// ---------------------------------------------------------------------------
// TInt CEvtMgmtUiModel::IndexBasedOnFilter() const
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiModel::IndexBasedOnFilter( TInt aIndex ) const
{
// We calculate the Index based on the Status Filter
// This is calculated based on the assumption of the Order of the Events
// which is in the order of Active->Draft->Completed
switch( iStatusFilter )
{
case CEvtMgmtUiEngine::EEvtFilterAll:
case CEvtMgmtUiEngine::EEvtFilterActive:
return aIndex;
case CEvtMgmtUiEngine::EEvtFilterDraft:
return iActiveTriggers + aIndex;
case CEvtMgmtUiEngine::EEvtFilterCompleted:
return iActiveTriggers + iDraftTriggers + aIndex;
default:
return aIndex;
}
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::IndexWithoutFilter()
// It will Index without filter provided the index based on filter.
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiModel::IndexWithoutFilter( TInt aIndex ) const
{
// The Actual Index in the model is calculated based on the Status Filter
switch( iStatusFilter )
{
case CEvtMgmtUiEngine::EEvtFilterAll:
case CEvtMgmtUiEngine::EEvtFilterActive:
return KPreDefinedItems + aIndex;
case CEvtMgmtUiEngine::EEvtFilterDraft:
return KPreDefinedItems + aIndex - iActiveTriggers;
case CEvtMgmtUiEngine::EEvtFilterCompleted:
return KPreDefinedItems + aIndex - ( iActiveTriggers + iDraftTriggers );
default:
return KPreDefinedItems + aIndex;
}
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::EventsArray()
// It will return Events array object reference.
// ---------------------------------------------------------------------------
//
RPointerArray<CEvtBasicEventInfo>& CEvtMgmtUiModel::EventsArray()
{
return iEventsArray;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::TotalEvents()
// It will return total events
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiModel::TotalEvents()
{
return iEventsArray.Count();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::StatusFilter()
// It will Show Events based on Filter
// ---------------------------------------------------------------------------
//
CEvtMgmtUiEngine::TEvtEventStatusFilter CEvtMgmtUiModel::StatusFilter( )
{
return iStatusFilter;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::SetStatusFilter()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiModel::SetStatusFilter( CEvtMgmtUiEngine::TEvtEventStatusFilter
aFilter )
{
iStatusFilter = aFilter;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::EventFromModel()
// It will return eventinfo object.
// ---------------------------------------------------------------------------
//
CEvtBasicEventInfo& CEvtMgmtUiModel::EventFromModel( TInt aIndex )
{
return *(iEventsArray[IndexBasedOnFilter( aIndex )-1]);
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::MandatoryFieldsFilled()
// ---------------------------------------------------------------------------
//
TBool CEvtMgmtUiModel::MandatoryFieldsFilled( TInt aIndex )
{
// Check the Array boundary conditions
if( aIndex == 0 || aIndex > iEventsArray.Count())
return EFalse;
// Check the Status of the event considering the current Status Filter
if( iEventsArray[IndexBasedOnFilter( aIndex )-1]->Subject().Compare(KNullDesC)==0 ||
iEventsArray[IndexBasedOnFilter( aIndex )-1]->Place().Compare(KNullDesC)==0 )
return EFalse;
else
return ETrue;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::EventId()
// It will return event id.
// ---------------------------------------------------------------------------
//
TEvtEventId CEvtMgmtUiModel::EventId( TInt aIndex )
{
// Check the Array boundary conditions
if(aIndex<1 || aIndex > iEventsArray.Count() )
return 0;
return iEventsArray[IndexBasedOnFilter( aIndex )-1]->EventId();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::EventStatus()
// It will return event status.
// ---------------------------------------------------------------------------
//
TEvtEventStatus CEvtMgmtUiModel::EventStatus( TInt aIndex )
{
// Check the Array boundary conditions
if(aIndex<1 || aIndex > iEventsArray.Count() )
return EActive;
return iEventsArray[IndexBasedOnFilter( aIndex )-1]->EventStatus();
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::UpdatedCurrentItemIndex()
// It will return updated current item index
// ---------------------------------------------------------------------------
//
TInt CEvtMgmtUiModel::UpdatedCurrentItemIndex( )
{
switch( iStatusFilter )
{
case CEvtMgmtUiEngine::EEvtFilterAll:
if(iCurrentEventIndex<0 || iCurrentEventIndex > (iActiveTriggers+iDraftTriggers+iCompletedTriggers) )
iCurrentEventIndex = KPreDefinedItems + iActiveTriggers + iDraftTriggers + iCompletedTriggers;
break;
case CEvtMgmtUiEngine::EEvtFilterActive:
if(iCurrentEventIndex<0 || iCurrentEventIndex > iActiveTriggers )
iCurrentEventIndex = KPreDefinedItems + iActiveTriggers;
break;
case CEvtMgmtUiEngine::EEvtFilterDraft:
if(iCurrentEventIndex<0 || iCurrentEventIndex > iDraftTriggers )
iCurrentEventIndex = KPreDefinedItems + iDraftTriggers;
break;
case CEvtMgmtUiEngine::EEvtFilterCompleted:
if(iCurrentEventIndex<0 || iCurrentEventIndex > iCompletedTriggers )
iCurrentEventIndex = KPreDefinedItems + iCompletedTriggers;
break;
default:
iCurrentEventIndex = 0;
break;
}
return iCurrentEventIndex;
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::SetCurrentItemId()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiModel::SetCurrentItemId( TInt aItemIndex )
{
if(aItemIndex > 0 && aItemIndex <= iEventsArray.Count() )
{
iCurrentEventId = iEventsArray[IndexBasedOnFilter( aItemIndex )-1]->EventId();
iCurrentEventIndex = aItemIndex - 1;
}
else
{
iCurrentEventId = 0; //if focus is on 'create new event'
iCurrentEventIndex = 0;
}
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::UpdateEventsStatus()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiModel::UpdateEventsStatus()
{
// Maintain the previous count to compare with the updated model
TInt prevCount = iActiveTriggers + iDraftTriggers + iCompletedTriggers;
iActiveTriggers = 0;
iDraftTriggers = 0;
iCompletedTriggers = 0;
TInt cnt = iEventsArray.Count();
TEvtModelUpdateState updateState;
// Get the update type based on the previous and current model count.
if( prevCount < cnt )
{
updateState = EEvtCreate;
}
else if( prevCount > cnt )
{
updateState = EEvtDelete;
iCurrentEventId = 0;
}
else
{
updateState = EEvtModify;
}
// Loop through the model to update the Event Status mask.
TInt index;
iEventsStatusMask = 0;
for( index = 0; index<cnt; index++ )
{
if( updateState == EEvtCreate && iCurrentEventId < iEventsArray[index]->EventId() )
{
iCurrentEventId = iEventsArray[index]->EventId();
iCurrentEventIndex = index;
}
if( updateState == EEvtModify && iCurrentEventId == iEventsArray[index]->EventId() )
{
iCurrentEventId = iEventsArray[index]->EventId();
iCurrentEventIndex = index;
}
// Append the Event status to Event status mask.
switch(iEventsArray[index]->EventStatus())
{
case EActive:
{
iActiveTriggers++;
iEventsStatusMask|= EEvtShowAttributeActive;
break;
}
case EDraft:
{
iDraftTriggers++;
iEventsStatusMask|= EEvtShowAttributeDraft;
break;
}
case ECompleted:
{
iCompletedTriggers++;
iEventsStatusMask|= EEvtShowAttributeCompleted;
break;
}
}
}
// If the current view(show) is empty, then switch to Filter All View
switch(iStatusFilter)
{
case CEvtMgmtUiEngine::EEvtFilterActive:
{
if( !iActiveTriggers )
iStatusFilter = CEvtMgmtUiEngine::EEvtFilterAll;
break;
}
case CEvtMgmtUiEngine::EEvtFilterDraft:
{
if( !iDraftTriggers )
iStatusFilter = CEvtMgmtUiEngine::EEvtFilterAll;
break;
}
case CEvtMgmtUiEngine::EEvtFilterCompleted:
{
if( !iCompletedTriggers )
iStatusFilter = CEvtMgmtUiEngine::EEvtFilterAll;
break;
}
}
// Update the index for create and modify
if( updateState == EEvtCreate || updateState == EEvtModify )
iCurrentEventIndex = IndexWithoutFilter( iCurrentEventIndex );
}
// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::EventsStatus()
// It will return type of events
// ---------------------------------------------------------------------------
//
TEvtEventsStatusMask CEvtMgmtUiModel::EventsStatus()
{
return iEventsStatusMask;
}