/*
* Copyright (c) 2007-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:
*
*/
#include <liwservicehandler.h>
#include "hnmdquery.h"
#include "hnmdqueries.h"
#include "hnconditioninterface.h"
#include "hnmdmenuitem.h"
#include "hnbuttonmodel.h"
#include "hnmdbutton.h"
#include "hnmdeventmapping.h"
#include "hnmduimapping.h"
#include "hnitemid.h"
#include "hnmdlocalization.h"
#include "hnmdsuite.h"
#include "hnxmlmodelprovider.h"
#include "hnmdaction.h"
#include "hnfilter.h"
#include "hnmdtoolbar.h"
#include "hnmdnotifyrequests.h"
#include "hnmditem.h"
#include "hninterface.h"
#include "hnconditionfactory.h"
#include "hnattributetext.h"
#include "hnsuitemodelcontainer.h"
#include "hnmenuitemmodel.h"
#include "hnitemsorder.h"
#include "hnactionmodel.h"
#include "hnitemmodel.h"
#include "hntoolbarmodel.h"
#include "hnconvutils.h"
#include "hnutils.h"
#include "hnmdbasekey.h"
#include "hnmdservicecommand.h"
#include "hnliwutils.h"
#include "hnstringhandler.h"
#include "hnglobals.h"
#include "menudebug.h"
using namespace LIW;
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::ConstructL(TXmlEngElement aElement,
THnMdCommonPointers* aCmnPtrs)
{
ASSERT( !aElement.Name().Compare( KItemElementName8 )
|| !aElement.Name().Compare( KEditModeItem8 ) );
iCmnPtrs = aCmnPtrs;
// set count
SetCountL( aElement );
// set template
SetTemplateL( aElement.AttributeNodeL( KTemplateAttrName8 ) );
// set condition
if( aElement.AttributeValueL( KMenuConditionAttrName8 ).Length() )
{
iCondition = HnConditionFactory::NewL(
aElement.AttributeNodeL( KMenuConditionAttrName8 ) );
}
//set item id
SetItemIdL( aElement );
// sets the alternative layout for edit mode
SetEditModeItemL( aElement );
// sets move_locked and delete_locked attributes
SetAttributesL( aElement );
// sets type of the item
SetTypeL( aElement );
// sets uid of the item
SetUidL( aElement );
// sets custom id
SetCustomIdL( aElement );
// sets msk
SetMiddleSoftKeyL( aElement, aCmnPtrs );
//set queries
iQueries = CHnMdQueries::NewL( aElement );
//set notify requests
iNotifyRequests = CHnMdNotifyRequests::NewL( aElement, *iItemId,
iCmnPtrs );
//set event mapping
iEventMapping = CHnMdEventMapping::NewL( aElement, iCmnPtrs );
//set ui mapping
iUiMapping = CHnMdUiMapping::NewL( aElement, iCmnPtrs );
//set menu items
iMenu = CHnMdMenuItem::NewL( aElement, iCmnPtrs );
//set toolabr element
iToolbar = CHnMdToolbar::NewL( aElement, iCmnPtrs );
iQueriesResultsList = CLiwGenericParamList::NewL();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetAlternativeModeItem(CHnMdItem* aAlternativeModeItem)
{
iAlternativeModeItem = aAlternativeModeItem;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdItem* CHnMdItem::TakeAlternativeModeItem()
{
CHnMdItem * ret = iAlternativeModeItem;
iAlternativeModeItem = NULL;
return ret;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CHnMdItem::HasAlternativeModeItem() const
{
return (iAlternativeModeItem != NULL) ? ETrue : EFalse;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetEditModeItemL( TXmlEngElement aElement )
{
RXmlEngNodeList< TXmlEngElement> children;
CleanupClosePushL ( children );
aElement.GetChildElements ( children );
TInt count = children.Count();
for (TInt j = 0; j < count ; j++ )
{
TXmlEngElement item = children.Next();
if ( !item.Name().Compare( KEditModeItem8 ) )
{
iAlternativeModeItem = CHnMdItem::NewL( item, iCmnPtrs );
iAlternativeModeItem->iItemId->UpdateL( *iItemId );
break;
}
}
CleanupStack::PopAndDestroy ( &children );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdItem* CHnMdItem::NewL(TXmlEngElement aElement,
THnMdCommonPointers* aCmnPtrs)
{
CHnMdItem* self = CHnMdItem::NewLC(aElement, aCmnPtrs);
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdItem* CHnMdItem::NewLC(TXmlEngElement aElement,
THnMdCommonPointers* aCmnPtrs)
{
CHnMdItem* self = new( ELeave ) CHnMdItem;
CleanupStack::PushL( self );
self->ConstructL(aElement, aCmnPtrs);
return self;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdItem::CHnMdItem() : iAlternativeModeItem(NULL), iAllowableTemplate(NULL)
{
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdItem::~CHnMdItem()
{
if ( iNotifyRequests )
{
CLiwGenericParamList* empty = NULL;
TRAP_IGNORE( iNotifyRequests->SendAllRequestsL( *empty, KLiwOptCancel ) );
}
delete iNotifyRequests;
delete iAlternativeModeItem;
delete iAllowableTemplate;
iTemplate.Close();
delete iMenu;
delete iQueries;
delete iEventMapping;
delete iUiMapping;
delete iItemId;
delete iToolbar;
iRemoveLocked8.Close();
iRunning8.Close();
iDrmProtection8.Close();
iMoveLocked8.Close();
iType8.Close();
iUid8.Close();
iCustomId8.Close();
iCount8.Close();
delete iQueriesResultsList;
delete iQc;
delete iCondition;
delete iMsk;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::EvaluateItemItselfL(CHnSuiteModel & aSuiteModel,
CLiwGenericParamList& aParams, TInt aItemPosition )
{
DEBUG16(("_MM_: CHnMdItem::EvaluateItemL IN"));
iSuiteModel = &aSuiteModel;
if ( !iNotifyRequests->Sent() )
{
iNotifyRequests->SendAllRequestsL( aParams );
}
iItemPosition = aItemPosition;
//allocate memory for new results
iQueriesResultsList->Reset();
iQueriesResultsList->AppendL( aParams );
//delete old query collector and create new one
//currently running evaluations will be cancelled
delete iQc;
iQc = NULL;
iQc = CHnQueryResultCollector::NewL( *iQueries , aParams );
iQc->StartAsynchL( this );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CHnMdItem::AddItemL( CHnSuiteModel& aSuiteModel, TInt aItemId,
const CLiwGenericParamList& aQueriesResultsList, TInt aItemModelNumber,
TInt aItemPos )
{
TInt err( KErrNone );
CHnItemModel* itemModel = CHnItemModel::NewL();
CleanupStack::PushL( itemModel );
TBool result = FillItemModelL( itemModel, aQueriesResultsList, aItemPos );
if ( result )
{
if ( !itemModel->GetTemplate().Compare( KTemplateEmpty8 ) )
{
CHnItemModel* empty = aSuiteModel.GetItemModel( aSuiteModel.IdByIndex( -1 ) );
// empty has been already added
if ( empty )
{
err = KErrAlreadyExists;
}
}
}
else
{
err = KErrGeneral;
}
if( KErrNone == err )
{
aSuiteModel.AddItemL( aItemId, itemModel, aItemModelNumber, aItemPos );
CleanupStack::Pop( itemModel );
}
else
{
CleanupStack::PopAndDestroy( itemModel );
itemModel = NULL;
}
return err;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CHnMdItem::UpdateItemL( CHnSuiteModel & aSuiteModel, TInt aItemId,
const CLiwGenericParamList& aQueriesResultsList, TInt aItemPos )
{
TBool result = ETrue;
CHnItemModel* itemModel = aSuiteModel.GetItemModel( aItemId );
itemModel->ClearAttributesL();
result = FillItemModelL( itemModel, aQueriesResultsList, aItemPos );
if( result )
{
aSuiteModel.UpdateItemTemplateL( aItemId );
}
return result ? KErrNone : KErrGeneral;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::RemoveItemL( CHnSuiteModel & aSuiteModel, TInt aId )
{
//TInt id = iIds[ aPosition ];
//iIds.Remove( aPosition );
aSuiteModel.RemoveItemL( aId );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::EvaluateItemL( CHnSuiteModel & aSuiteModel,
CLiwGenericParamList& aParamList,
TInt aItemPosition )
{
if( iEvaluationNeeded )
{
EvaluateItemItselfL( aSuiteModel, aParamList, aItemPosition );
iEvaluationNeeded = EFalse;
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::MarkEvaluationL( CHnFilter& aFilter )
{
if( aFilter.HasItemIds() )
{
aFilter.ResetIterator();
while( aFilter.HasNextItemId() && !iEvaluationNeeded )
{
const CHnItemId* item = aFilter.GetNextItemId();
if( iItemId->Compare( *item ) )
{
iEvaluationNeeded = ETrue;
}
}
}
else
{
iEvaluationNeeded = ETrue;
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CHnMdItem::EvaluateItemL( CHnSuiteModel & aSuiteModel,
const CHnItemId* aItemId, CLiwGenericParamList& aParamList,
TInt aItemPosition )
{
DEBUG(("_MM_: CHnMdItem::EvaluateItemL IN")); //TO CHANGE LATER (id : %S)", iItemId->Id()));
TInt result( KErrNotFound );
if( iItemId->Compare( *aItemId ) )
{
EvaluateItemItselfL( aSuiteModel, aParamList, aItemPosition );
result = KErrNone;
}
DEBUG(("_MM_: CHnMdItem::EvaluateItemL OUT"));
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CHnMdItem::GetIndexValuesFromOutputsL( RPointerArray < HBufC8 > &aValues,
TXmlEngElement aElement )
{
RXmlEngNodeList < TXmlEngElement > children;
CleanupClosePushL( children );
aElement.GetChildElements( children );
TInt amount = children.Count();
TPtrC8 n = aElement.Name();
for( TInt j( 0 ); j < amount; j++ )
{
TXmlEngElement item = children.Next();
if ( !item.Name().Compare( KOutputElementItem8 ) )
{
if ( item.HasAttributeL( KValueAttrName8 ) &&
item.AttributeValueL( KValueAttrName8 ).Find( KIndex8 ) >= 0 &&
item.HasAttributeL( KAliasAttrName8 ) &&
!item.AttributeValueL( KAliasAttrName8 ).Compare( KTitle8 ) )
{
TInt pos = item.AttributeValueL( KValueAttrName8 ).Find( KIndexWithBrackets8 ) - 1;
TInt siz = KCount().Length();
TInt len = pos + siz;
TInt len0 = item.AttributeValueL( KValueAttrName8 ).Length() + KCount().Length();
HBufC8* buf = HBufC8::NewL( len0 );
buf->Des().Copy( item.AttributeValueL( KValueAttrName8 ) );
buf->Des().Replace( pos, siz, KCount() );
buf->Des().SetLength( len );
aValues.Append( buf );
}
}
}
CleanupStack::PopAndDestroy( &children );
return aValues.Count();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetCountL( TXmlEngElement aElement )
{
TXmlEngAttr aAttr = aElement.AttributeNodeL( KCountAttrName8 );
iCount8.Close();
iCount8.CreateL( aAttr.Value() );
// replace "*"
if ( !iCount8.Compare( KStar8 ) )
{
RPointerArray<HBufC8> values;
CleanupClosePushL( values );
if( GetIndexValuesFromOutputsL( values, aElement ) > 0 )
{
for( TInt i = 0; i < values.Count(); i++ )
{
HBufC8* buf = values[i];
iCount8.Close();
iCount8.CreateL( buf->Length() );
iCount8.Copy( *buf );
}
}
else
{
iCount8.Close();
iCount8.CreateL( KDefaultCount8().Length() );
iCount8.Copy( KDefaultCount8 );
}
values.ResetAndDestroy();
CleanupStack::PopAndDestroy( &values );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetTemplateL( TXmlEngAttr aAttr )
{
iAllowableTemplate = new ( ELeave ) CDesC8ArrayFlat( 3 );
for (int i = 0; i < HnUtils::GetColumnTextColumnCount(aAttr.Value()); i++)
{
HBufC8* templateBuf = HnUtils::GetColumnTextLC( i, aAttr.Value() );
templateBuf->Des().Trim();
iAllowableTemplate->AppendL( *templateBuf );
CleanupStack::PopAndDestroy(templateBuf);
}
if (iAllowableTemplate->Count() > 0 )
{
const TDesC8 & val = (*iAllowableTemplate)[0];
iTemplate.Close();
iTemplate.CreateL( val.Length() + 1 );
iTemplate.Copy( val );
}
else
iTemplate.CreateL( KNullDesC8() );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetTemplateL( CHnItemModel* aItemModel )
{
ASSERT( aItemModel );
CHnAttributeText* templateAttr = CHnAttributeText::NewL();
templateAttr->SetNameL( KTemplate8 );
templateAttr->SetValueL( iTemplate );
aItemModel->SetAttributeL( templateAttr );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetAlternativeTemplateL( TInt aOption )
{
if ( !iTemplate.Compare( KTemplateEmpty8 ) )
{
return;
}
iTemplate.Close();
if (aOption >=0 && aOption < iAllowableTemplate->Count())
{
const TDesC8 & val = (*iAllowableTemplate)[aOption];
iTemplate.CreateL( val.Length() + 1 );
iTemplate.Copy( val );
}
else
{
iTemplate.CreateL( KNullDesC8() );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetItemIdL( TXmlEngElement aItemElement )
{
HBufC* suiteName = HnConvUtils::Str8ToStrLC(
aItemElement.AttributeNodeL( KSuiteElementName8 ).Value() );
HBufC* itemId = HnConvUtils::Str8ToStrLC(
aItemElement.AttributeNodeL( KItemIdAttrName8 ).Value() );
iItemId = CHnItemId::NewL( *suiteName, *itemId );
CleanupStack::PopAndDestroy( itemId );
CleanupStack::PopAndDestroy( suiteName );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetDeleteMoveAttributesL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
{
aItemModel->ClearFlags();
TLiwVariant moveLocked;
moveLocked.PushL();
HnLiwUtils::GetVariantL( aQueriesResultsList, iMoveLocked8, aPos, moveLocked );
if ( moveLocked == TLiwVariant( (TBool) ETrue ) )
{
aItemModel->SetFlag( EItemFlagMoveLocked );
}
CleanupStack::PopAndDestroy( &moveLocked );
TLiwVariant deleteLocked;
deleteLocked.PushL();
HnLiwUtils::GetVariantL( aQueriesResultsList, iRemoveLocked8, aPos, deleteLocked );
if ( deleteLocked == TLiwVariant( (TBool) ETrue ) )
{
aItemModel->SetFlag( EItemFlagRemoveLocked );
}
CleanupStack::PopAndDestroy( &deleteLocked );
TLiwVariant running;
running.PushL();
HnLiwUtils::GetVariantL( aQueriesResultsList, iRunning8, aPos, running );
if ( running == TLiwVariant( (TBool) ETrue ) )
{
aItemModel->SetFlag( EItemFlagRunning );
}
CleanupStack::PopAndDestroy( &running );
TLiwVariant drm;
drm.PushL();
HnLiwUtils::GetVariantL( aQueriesResultsList, iDrmProtection8, aPos, drm );
TPtrC drmRights;
drm.Get( drmRights );
if ( !drmRights.Compare( KMenuDrmRightsExpired ) )
{
aItemModel->SetFlag( EItemFlagDrmExpired );
}
CleanupStack::PopAndDestroy( &drm );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetTypeL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
{
RBuf8 type;
CleanupClosePushL( type );
HnLiwUtils::GetStringL( aQueriesResultsList, iType8, aPos, type );
aItemModel->SetType( type );
CleanupStack::PopAndDestroy( &type );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetUidL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
{
RBuf8 uid;
CleanupClosePushL( uid );
HnLiwUtils::GetStringL( aQueriesResultsList, iUid8, aPos, uid );
aItemModel->SetItemUidL( uid );
CleanupStack::PopAndDestroy( &uid );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetCustomIdL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aParams, TInt aPos )
{
TInt64 customId( KErrNotFound );
if ( KErrNone == HnLiwUtils::GetInt64L(
aParams, iCustomId8, aPos, customId ) )
{
aItemModel->SetCustomId( customId );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CHnMdItem::FillItemModelL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
{
TBool result( EFalse );
// set template for item
SetTemplateL( aItemModel );
// set delete/move locked attributes
SetDeleteMoveAttributesL( aItemModel, aQueriesResultsList, aPos );
// set type of an item
SetTypeL( aItemModel, aQueriesResultsList, aPos );
// set uid of an item
SetUidL( aItemModel, aQueriesResultsList, aPos );
// set custom id
SetCustomIdL( aItemModel, aQueriesResultsList, aPos );
// fills mul item
TRAP_IGNORE( result = iUiMapping->FillGraphicalItemL(
aItemModel, aQueriesResultsList, aPos ) );
if ( result )
{
// fills item model
FillItemModelWithMenuItemsL( aItemModel, aQueriesResultsList, aPos );
FillItemModelWithToolbarL( aItemModel, aQueriesResultsList, aPos );
FillItemModelWithMiddleSoftKeyL( aItemModel, aQueriesResultsList,
aPos );
aItemModel->DeleteAllActionModels();
iEventMapping->FillActionsL( aItemModel->GetActions(),
aQueriesResultsList, aPos );
}
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::FillItemModelWithMenuItemsL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
{
CHnMenuItemModel* menu = CHnMenuItemModel::NewL( KMenuItemName() );
CleanupStack::PushL( menu );
iMenu->EvaluateL( menu, aQueriesResultsList, aPos );
aItemModel->SetMenuItemModel( menu );
CleanupStack::Pop( menu );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::FillItemModelWithToolbarL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
{
CHnToolbarModel* toolbar = CHnToolbarModel::NewLC();
iToolbar->EvaluateL( toolbar, aQueriesResultsList, aPos );
aItemModel->SetToolbarModel( toolbar );
CleanupStack::Pop( toolbar );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::FillItemModelWithMiddleSoftKeyL( CHnItemModel* aItemModel,
const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
{
if ( iMsk )
{
CHnButtonModel* msk = CHnButtonModel::NewLC( iMsk->GetIndex() );
const TDesC& helpText = iMsk->EvaluateButtonTextL(
aQueriesResultsList, aPos );
msk->SetHelpTextL( helpText );
aItemModel->SetMiddleSoftKey( msk );
CleanupStack::Pop( msk );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CHnMdItem::IsValidL( const CLiwGenericParamList& aQueryResults,
TInt aPos )
{
TBool ret( EFalse );
if( !iCondition || iCondition->ResultL( aQueryResults, aPos ) )
{
ret = ETrue;
}
return ret;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CHnMdItem::CompareItems( CHnItemId* aSearchCriteria )
{
return iItemId->Compare( *aSearchCriteria );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetAttributesL( TXmlEngElement aElement )
{
iMoveLocked8.Close();
iRemoveLocked8.Close();
iRunning8.Close();
iDrmProtection8.Close();
if ( aElement.HasAttributeL( KMoveLocked8 ) )
{
TPtrC8 av = aElement.AttributeValueL( KMoveLocked8 );
iMoveLocked8.CreateL( av );
}
else
{
iMoveLocked8.CreateL( KStringFalse8 );
}
if ( aElement.HasAttributeL( KRemoveLocked8 ) )
{
TPtrC8 av = aElement.AttributeValueL( KRemoveLocked8 );
iRemoveLocked8.CreateL( av );
}
else
{
iRemoveLocked8.CreateL( KStringFalse8 );
}
if ( aElement.HasAttributeL( KRunning8 ) )
{
TPtrC8 av = aElement.AttributeValueL( KRunning8 );
iRunning8.CreateL( av );
}
else
{
iRunning8.CreateL( KStringFalse8 );
}
if ( aElement.HasAttributeL( KDrmProtection8 ) )
{
TPtrC8 av = aElement.AttributeValueL( KDrmProtection8 );
iDrmProtection8.CreateL( av );
}
else
{
iDrmProtection8.CreateL( KMenuDrmUnknown8 );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetTypeL( TXmlEngElement aElement )
{
iType8.Close();
if ( aElement.HasAttributeL( KItemType8 ) )
{
TPtrC8 av = aElement.AttributeValueL( KItemType8 );
iType8.CreateL( av );
}
else
{
iType8.CreateL( KItemTypeUnknown8 );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetUidL( TXmlEngElement aElement )
{
iUid8.Close();
if ( aElement.HasAttributeL( KItemUid8 ) )
{
TPtrC8 av = aElement.AttributeValueL( KItemUid8 );
iUid8.CreateL( av );
}
else
{
iUid8.CreateL( TUid::Null().Name().Length() );
iUid8.Append( TUid::Null().Name() );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetCustomIdL( TXmlEngElement aElement )
{
iCustomId8.Close();
if ( aElement.HasAttributeL( KCustomId8 ) )
{
TPtrC8 av = aElement.AttributeValueL( KCustomId8 );
iCustomId8.CreateL( av );
}
else
{
iCustomId8.CreateL( KItemTypeUnknown8 );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::SetMiddleSoftKeyL( TXmlEngElement aElement,
THnMdCommonPointers* aCmnPtrs )
{
RXmlEngNodeList< TXmlEngElement> children;
CleanupClosePushL ( children );
aElement.GetChildElements ( children );
TInt count = children.Count();
for (TInt i = 0; i < count; i++ )
{
TXmlEngElement item = children.Next();
if ( !item.Name().Compare( KMiddleSoftKey8 ) )
{
iMsk = CHnMdButton::NewLC( item, aCmnPtrs );
CleanupStack::Pop( iMsk );
break;
}
}
CleanupStack::PopAndDestroy( &children );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C TDesC8& CHnMdItem::Template()
{
return iTemplate;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C TDesC8& CHnMdItem::Type()
{
return iType8;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C TDesC8& CHnMdItem::Uid()
{
return iUid8;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CHnMdItem::GetItemsMaxCountL()
{
TInt ret( KErrNotFound );
// check if iCount8 equals "*"
if ( !iCount8.Compare( KStar8() ) )
{
ret = KErrUnknown;
}
// check if iCount8 is a number
else if ( HnConvUtils::Str8ToInt( iCount8, ret ) >= 0 )
{
; // ret contains a number
}
// try to retrieve number of items from given paths
else
{
TInt columnsCount( HnUtils::GetColumnTextColumnCount( iCount8 ) );
for (int i = 0; i < columnsCount; i++)
{
HBufC8* tmpCountBuf = HnUtils::GetColumnTextLC( i, iCount8 );
TInt pos = tmpCountBuf->Des().Find( KCount() );
if ( pos >= 0 )
{
tmpCountBuf->Des().Replace( pos, KCount().Length(), KNullDesC8 );
TLiwVariant variant;
variant.PushL();
HnLiwUtils::GetVariantL( *iQueriesResultsList, *tmpCountBuf, variant );
const CLiwList* list = variant.AsList();
CLiwIterable* iterable = variant.AsIterable();
TInt count = KErrNotFound;
if ( list )
{
count = list->Count();
}
else if ( iterable )
{
count = HnLiwUtils::GetIterableItemCountL( *iterable );
}
if ( count != KErrNotFound )
{
if ( ( i == 0 ) || ( ( i > 0 ) && ( count < ret ) ) )
{
ret = count;
}
}
CleanupStack::PopAndDestroy( &variant );
}
CleanupStack::PopAndDestroy( tmpCountBuf );
}
}
return ret;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdItem::ResultsCollectedL( CLiwGenericParamList* aResults )
{
iQueriesResultsList->AppendL( *aResults );
RArray< TInt > ids;
CleanupClosePushL( ids );
iSuiteModel->GetItemsOrder()->GetIdsForL( iItemPosition, ids );
TInt startCount = ids.Count();
TInt visibleItemsBeforeEvaluation = iSuiteModel->GetItemsOrder()->Count();
TInt id( 0 );
TBool result = ETrue;
TInt itemCounter = 0;
TInt maxCount( GetItemsMaxCountL() );
for ( TInt i(0); result; i++, itemCounter++)
{
result = ( maxCount != KErrUnknown ) ? i < maxCount && result : result;
if ( !result )
{
continue;
}
id = (ids.Count() > 0 && i < ids.Count()) ? ids[itemCounter]
: KErrNotFound;
if( id == KErrNotFound )
{
id = iCmnPtrs->iIdGenerator->GetNextId();
TInt err = AddItemL( *iSuiteModel, id, *iQueriesResultsList,
iItemPosition, itemCounter );
if ( KErrAlreadyExists == err )
{
// update empty item which is identified by "-1"
TInt err = UpdateItemL( *iSuiteModel, iSuiteModel->IdByIndex(-1), *iQueriesResultsList, i );
result = ( KErrNone == err ) ? ETrue : EFalse;
}
else if ( KErrNone != err )
{
result = EFalse;
}
}
else
{
TInt err = UpdateItemL( *iSuiteModel, id, *iQueriesResultsList, i );
result = ( KErrNone == err ) ? ETrue : EFalse;
}
if ( !IsValidL( *iQueriesResultsList, i ) )
{
RemoveItemL( *iSuiteModel, id );
itemCounter--;
continue;
}
}
for( TInt it(startCount - 1); it >= itemCounter -1 && it >= 0; it-- )
{
RemoveItemL( *iSuiteModel, ids[it] );
}
CleanupStack::PopAndDestroy( &ids );
iSuiteModel->RefreshMulModelL( visibleItemsBeforeEvaluation );
TBool observersNotified =
iSuiteModel->ItemEvaluationFinishedL( iItemPosition );
if ( observersNotified )
{
iCmnPtrs->iModel->SuiteModelReadyToShowL( iSuiteModel );
}
DEBUG(("_MM_: CHnMdItem::ResultsCollectedL OUT"));
}
// End of file