/*

* Copyright (c) 2002-2005 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:  

*

*/

// INCLUDES

#include <SyncMLTransportProperties.h>

#include "aspfilter.h"

#include "aspprofile.h"

#include "AspResHandler.h"

#include "AspDialogUtil.h"

// ============================ MEMBER FUNCTIONS ===============================

/*******************************************************************************

 * class CAspFilterList

 *******************************************************************************/

// -----------------------------------------------------------------------------

// CAspFilterList::NewL

//

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CAspFilterList* CAspFilterList::NewL(const TAspParam& aParam, RPointerArray<CSyncMLFilter>& aArray)

    {

    CAspFilterList* self = new(ELeave) CAspFilterList(aParam, aArray);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

    }

// -----------------------------------------------------------------------------

// CAspFilterList::~CAspFilterList

//

// -----------------------------------------------------------------------------

//

CAspFilterList::~CAspFilterList()

    {

    iFilterList.ResetAndDestroy();

    iFilterList.Close();

    }

// -----------------------------------------------------------------------------

// CAspFilterList::ConstructL

//

// -----------------------------------------------------------------------------

//

void CAspFilterList::ConstructL()

    {

    InitFiltersL();

    }

// -----------------------------------------------------------------------------

// CAspFilterList::CAspFilterList

//

// -----------------------------------------------------------------------------

//

CAspFilterList::CAspFilterList(const TAspParam& aParam, RPointerArray<CSyncMLFilter>& aArray)

	{

	iApplicationId = aParam.iApplicationId;

	//iAspTask = aParam.iSyncTask;

	iArray = aArray;

	}

// -----------------------------------------------------------------------------

// CAspFilterList::InitFiltersL

//

// -----------------------------------------------------------------------------

//

void CAspFilterList::InitFiltersL()

	{

	//TSyncMLFilterChangeInfo changeInfo = ESyncMLDefault;

	//RPointerArray<CSyncMLFilter>& arr = iAspTask->Task().SupportedServerFiltersL(changeInfo);

	TInt count = iArray.Count();

	for (TInt i=0; i<count; i++)

		{

		CSyncMLFilter* filter = iArray[i];

		CAspFilter* aspFilter = CAspFilter::NewLC(filter, i);

		iFilterList.AppendL(aspFilter);

		CleanupStack::Pop(aspFilter);

		}

	}

// -----------------------------------------------------------------------------

// CAspFilterList::Count

//

// -----------------------------------------------------------------------------

//

TInt CAspFilterList::Count()

	{

	return iFilterList.Count();

	}

// -----------------------------------------------------------------------------

// CAspFilterList::FiltersEnabled

//

// -----------------------------------------------------------------------------

//

TBool CAspFilterList::FiltersEnabled()

	{

    TInt count = iFilterList.Count();

    for (TInt i=0; i<count; i++)

    	{

    	CAspFilter* filter = iFilterList[i];

    	if (filter->Enabled())

    		{

    		return ETrue;

    		}

    	}

    return EFalse;

	}

// -----------------------------------------------------------------------------

// CAspFilterList::SetFiltersEnabledL

//

// -----------------------------------------------------------------------------

//

void CAspFilterList::SetFiltersEnabledL(TBool aEnable)

	{

    TInt count = iFilterList.Count();

    for (TInt i=0; i<count; i++)

    	{

    	CAspFilter* filter = iFilterList[i];

    	filter->SetEnabledL(aEnable);

    	}

	}

// -----------------------------------------------------------------------------

// CAspFilterList::SaveL

//

// -----------------------------------------------------------------------------

//

void CAspFilterList::SaveL()

	{

	}

// -----------------------------------------------------------------------------

// CAspFilterList::Item

// 

// -----------------------------------------------------------------------------

//

CAspFilter* CAspFilterList::Item(TInt aIndex)

	{

	if (aIndex < 0 || aIndex >= iFilterList.Count())

	    {

		TUtil::Panic(KErrArgument);

	    }

	return iFilterList[aIndex];

	}

// -----------------------------------------------------------------------------

// CAspFilterList::ItemForIdL

// 

// -----------------------------------------------------------------------------

//

CAspFilter* CAspFilterList::ItemForId(TInt aId)

	{

    TInt count = iFilterList.Count();

    for (TInt i=0; i<count; i++)

    	{

    	CAspFilter* filter = iFilterList[i];

    	if (filter->Id() == aId)

    		{

    		return filter;

    		}

    	}

	return NULL;

	}

/*******************************************************************************

 * class CAspFilter

 *******************************************************************************/

// -----------------------------------------------------------------------------

// CAspFilter::NewLC

//

// -----------------------------------------------------------------------------

//

CAspFilter* CAspFilter::NewLC(CSyncMLFilter* aSyncFilter, TInt aId)

    {

    CAspFilter* self = new(ELeave) CAspFilter(aSyncFilter, aId);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

    }

// -----------------------------------------------------------------------------

// CAspFilter::~CAspFilter

//

// -----------------------------------------------------------------------------

//

CAspFilter::~CAspFilter()

    {

    iFilterItemList.ResetAndDestroy();

    iFilterItemList.Close();

    }

// -----------------------------------------------------------------------------

// CAspFilter::ConstructL

//

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CAspFilter::ConstructL()

    {

    InitFilterItemsL();

    }

// -----------------------------------------------------------------------------

// CAspFilter::CAspFilter

//

// -----------------------------------------------------------------------------

//

CAspFilter::CAspFilter(CSyncMLFilter* aSyncFilter, TInt aId)

	{

	iId = KFilterBaseId + aId;

	iSyncFilter = aSyncFilter;

    __ASSERT_ALWAYS(iSyncFilter, TUtil::Panic(KErrGeneral));		

	}

// -----------------------------------------------------------------------------

// CAspFilter::SaveL

//

// -----------------------------------------------------------------------------

//

void CAspFilter::SaveL()

    {

    }

// -----------------------------------------------------------------------------

// CAspFilter::InitFilterItemsL

//

// -----------------------------------------------------------------------------

//

void CAspFilter::InitFilterItemsL()

	{

	RPointerArray<CSyncMLFilterProperty>& arr = iSyncFilter->FilterProperties();

	TInt count = arr.Count();

	for (TInt i=0; i<count; i++)

		{

		CSyncMLFilterProperty* property = arr[i];

		CAspFilterItem* item = CAspFilterItem::NewLC(property, i);

		iFilterItemList.AppendL(item);

		CleanupStack::Pop(item);

		}

	}

// -----------------------------------------------------------------------------

// CAspFilter::DisplayName

// 

// -----------------------------------------------------------------------------

//

const TDesC& CAspFilter::DisplayName()

	{

	return iSyncFilter->DisplayName();

	}

// -----------------------------------------------------------------------------

// CAspFilter::GetDisplayValueL

// 

// -----------------------------------------------------------------------------

//

void CAspFilter::GetDisplayValueL(TDes& aText)

	{

	aText = KNullDesC;

	if (!Enabled())

		{

		CAspResHandler::ReadL(aText, R_ASP_NOT_DEFINED);

		}

	else if (iFilterItemList.Count() == 1)

		{

	    CAspFilterItem* item = iFilterItemList[0];

	    item->GetDisplayValueL(aText);

		}

	else if (iFilterItemList.Count() > 1)

		{

		CAspResHandler::ReadL(aText, R_ASP_MULTIPLE_SELECTION);

		}

	}

// -----------------------------------------------------------------------------

// CAspFilter::Id

// 

// -----------------------------------------------------------------------------

//

TInt CAspFilter::Id()

	{

	return iId;

	}

// -----------------------------------------------------------------------------

// CAspFilter::ItemCount

// 

// -----------------------------------------------------------------------------

//

TInt CAspFilter::ItemCount()

	{

	return iFilterItemList.Count();

	}

// -----------------------------------------------------------------------------

// CAspFilter::Item

// 

// -----------------------------------------------------------------------------

//

CAspFilterItem* CAspFilter::Item(TInt aIndex)

	{

	if (aIndex < 0 || aIndex >= ItemCount())

	    {

		TUtil::Panic(KErrArgument);

	    }

	return iFilterItemList[aIndex];

	}

// -----------------------------------------------------------------------------

// CAspFilter::ItemForIdL

// 

// -----------------------------------------------------------------------------

//

CAspFilterItem* CAspFilter::ItemForId(TInt aId)

	{

    TInt count = ItemCount();

    for (TInt i=0; i<count; i++)

    	{

    	CAspFilterItem* item = Item(i);

    	if (item->Id() == aId)

    		{

    		return item;

    		}

    	}

	return NULL;

	}

// -----------------------------------------------------------------------------

// CAspFilter::Enabled

// 

// -----------------------------------------------------------------------------

//

TBool CAspFilter::Enabled()

	{

	return iSyncFilter->Enabled();

	}

// -----------------------------------------------------------------------------

// CAspFilter::SetEnabledL

// 

// -----------------------------------------------------------------------------

//

void CAspFilter::SetEnabledL(TBool aEnable)

	{

	iSyncFilter->SetEnabledL(aEnable);

	}

/*******************************************************************************

 * class CAspFilterItem

 *******************************************************************************/

// -----------------------------------------------------------------------------

// CAspFilterItem::NewLC

//

// -----------------------------------------------------------------------------

//

CAspFilterItem* CAspFilterItem::NewLC(CSyncMLFilterProperty* aProperty, TInt aId)

    {

    CAspFilterItem* self = new(ELeave) CAspFilterItem(aProperty, aId);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

    }

// -----------------------------------------------------------------------------

// CAspFilterItem::NewL

//

// -----------------------------------------------------------------------------

//

CAspFilterItem* CAspFilterItem::NewL(CSyncMLFilterProperty* aProperty, TInt aId)

    {

    CAspFilterItem* self = new(ELeave) CAspFilterItem(aProperty, aId);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

    }

// -----------------------------------------------------------------------------

// CAspFilterItem::~CAspFilterItem

//

// -----------------------------------------------------------------------------

//

CAspFilterItem::~CAspFilterItem()

    {

    }

// -----------------------------------------------------------------------------

// CAspFilterItem::ConstructL

//

// -----------------------------------------------------------------------------

//

void CAspFilterItem::ConstructL()

    {

    InitListTypeL();

    InitDataTypeL();

    }

// -----------------------------------------------------------------------------

// CAspFilterItem::CAspFilterItem

// -----------------------------------------------------------------------------

//

CAspFilterItem::CAspFilterItem(CSyncMLFilterProperty* aProperty, TInt aId)

	{

	iId = aId + KFilterItemBaseId;

	iProperty = aProperty;

	__ASSERT_ALWAYS(iProperty, TUtil::Panic(KErrGeneral));

	}

// -----------------------------------------------------------------------------

// CAspFilterItem::ListType

//

// -----------------------------------------------------------------------------

//

TInt CAspFilterItem::ListType()

	{

	return iListType;

	}

// -----------------------------------------------------------------------------

// CAspFilterItem::DataType

//

// -----------------------------------------------------------------------------

//

TInt CAspFilterItem::DataType()

	{

	return iDataType;

	}

// -----------------------------------------------------------------------------

// CAspFilterItem::InitListType

//

// -----------------------------------------------------------------------------

//

void CAspFilterItem::InitListTypeL()

	{

	TInt defaultValueCount = iProperty->DefaultValueCount();