/*

* 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:  Provides static information about todo lists and creates

 *                todo list adapters.

 *

*/

// CLASS HEADER

#include "cpimtodoadaptermanager.h"

// INTERNAL INCLUDES

#include "mpimitem.h"

#include "cpimtodolistadapter.h"

#include "pimlocalizationids.h"

#include "logger.h"

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

// CPIMToDoAdapterManager::CPIMToDoAdapterManager

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPIMToDoAdapterManager::CPIMToDoAdapterManager()

{

    JELOG2(EPim);

}

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

// CPIMToDoAdapterManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPIMToDoAdapterManager::ConstructL(const TDesC& aListName)

{

    JELOG2(EPim);

    iListName = aListName.AllocL();

}

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

// CPIMToDoAdapterManager::NewL

// Two-phased constructor.

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

//

CPIMToDoAdapterManager* CPIMToDoAdapterManager::NewL(const TDesC& aListName)

{

    JELOG2(EPim);

    CPIMToDoAdapterManager* self = new(ELeave) CPIMToDoAdapterManager;

    CleanupStack::PushL(self);

    self->ConstructL(aListName);

    CleanupStack::Pop(self);

    return self;

}

// Destructor

CPIMToDoAdapterManager::~CPIMToDoAdapterManager()

{

    JELOG2(EPim);

    delete iSupportedToDoFields;

    delete iEmptyToDoAttributeArray;

    delete iListName;

}

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

// CPIMToDoAdapterManager::GetAdapterManager

// Provides access to the MPIMAdapterManager representation of this object.

// Returns: MPIMAdapterManager representation of this object.

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

MPIMAdapterManager* CPIMToDoAdapterManager::GetAdapterManager()

{

    JELOG2(EPim);

    return this;

}

const TDesC& CPIMToDoAdapterManager::ListNameL()

{

    JELOG2(EPim);

    return *iListName;

}

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

// CPIMToDoAdapterManager::MaxCategories

// Returns: The maximum number of categories that this list can have.

//          0 indicates no category support,

//         -1 indicates there is no limit on the number of categories that this

//            list can have

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

//

TInt CPIMToDoAdapterManager::MaxCategories()

{

    JELOG2(EPim);

    return 0;

}

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

// CPIMToDoAdapterManager::IsSupportedField

// Returns: ETrue if supported in this list, EFalse otherwise. Invalid fields

//          return false.

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

//

TBool CPIMToDoAdapterManager::IsSupportedField(TPIMField aField)

{

    JELOG2(EPim);

    for (TInt index = 0; index < KPIMSupportedToDoFieldsCount; index++)

    {

        if (aField == KPIMSupportedToDoFields[index])

        {

            return ETrue;

        }

    }

    return EFalse;

}

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

// CPIMToDoAdapterManager::GetSupportedFieldsL

// Returns: An int array containing all fields supported by this list.

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

//

const CArrayFix<TPIMField>& CPIMToDoAdapterManager::GetSupportedFieldsL()

{

    JELOG2(EPim);

    if (!iSupportedToDoFields)

    {

        iSupportedToDoFields

        = new(ELeave) CArrayFixFlat<TPIMField> (KPIMSupportedToDoFieldsCount);  // codescanner::leave

        iSupportedToDoFields->AppendL(KPIMSupportedToDoFields, // codescanner::leave

                                      KPIMSupportedToDoFieldsCount);

    }

    return *iSupportedToDoFields;

}

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

// CPIMToDoAdapterManager::IsSupportedAttribute

// Returns: EFalse for every other attribute than KPIMAttrNone

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

//

TBool CPIMToDoAdapterManager::IsSupportedAttribute(TPIMField /* aField */,

        TPIMAttribute /* aAttribute */)

{

    JELOG2(EPim);

    return EFalse; // No attributes supported

}

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

// CPIMToDoAdapterManager::GetSupportedAttributesL

// Returns: An empty array meaning no supported attributes.

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

//

const CArrayFix<TPIMAttribute>&

CPIMToDoAdapterManager::GetSupportedAttributesL(TPIMField aField)

{

    JELOG2(EPim);

    if (!IsSupportedField(aField))

    {

        User::Leave(KErrArgument);

    }

    if (!iEmptyToDoAttributeArray)

    {

        iEmptyToDoAttributeArray

        = new(ELeave) CArrayFixFlat<TPIMAttribute> (1);

    }

    return *iEmptyToDoAttributeArray;

}

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

// CPIMToDoAdapterManager::GetSupportedAttributesCombinedL

// Returns: KPIMAttrNone meaning no supported attributes.

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

//

TPIMAttribute CPIMToDoAdapterManager::GetSupportedAttributesCombinedL(

    TPIMField aField) // The field to check the supported attributes from

{

    JELOG2(EPim);

    if (!IsSupportedField(aField))

    {

        User::Leave(KErrArgument); // Field was not a valid field

    }

    return KPIMAttrNone;

}

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

// CPIMToDoAdapterManager::GetAllSupportedAttributesCombined

// Returns: KPIMAttrNone meaning no supported attributes.

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

//

TPIMAttribute CPIMToDoAdapterManager::GetAllSupportedAttributesCombined()

{

    JELOG2(EPim);

    return KPIMAttrNone;

}

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

// CPIMToDoAdapterManager::IsSupportedArrayElement

// Returns: EFalse, as there are no supported array elements in ToDo list.

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

//

TBool CPIMToDoAdapterManager::IsSupportedArrayElement(

    TPIMField /* aStringArrayField */, TPIMArrayElement /* aArrayElement */)

{

    JELOG2(EPim);

    return EFalse; // No attributes supported

}

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

// CPIMToDoAdapterManager::GetSupportedArrayElementsL

// Returns: An integer array containing all of the supported elements of a

//          string array for the given field.

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

//

const CArrayFix<TPIMArrayElement>&

CPIMToDoAdapterManager::GetSupportedArrayElementsL(TPIMField /* aField */) // The field to check for supported array elements

{

    JELOG2(EPim);

    User::Leave(KErrArgument); // No array elements in ToDo list.

    // satisfy the compiler

    const CArrayFix<TPIMArrayElement>* temp = NULL;

    return *temp;

}

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

// CPIMToDoAdapterManager::MaxValues

// Returns: Number of values supported for the field

//          -1 : The field supports having an unlimited number of values in it.

//           0 : The field is not supported by this list.

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

//

TInt CPIMToDoAdapterManager::MaxValues(TPIMField aField) // The field to check for multiple value support

{

    JELOG2(EPim);

    if (IsSupportedField(aField))

    {

        return 1; // Only one value is supported for any valid ToDo field

    }

    else

    {

        return 0;

    }

}

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

// CPIMToDoAdapterManager::StringArraySizeL

// Returns: Int the size of the array of a single data instance of a string

//          array field.

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

//

TInt CPIMToDoAdapterManager::StringArraySizeL(TPIMField /* aStringArrayField */)

{

    JELOG2(EPim);

    User::Leave(KErrArgument); // no string array fields

    // satisfy the compiler

    return 0;

}

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

// CPIMToDoAdapterManager::ItemOrder

// Returns: pointer to a function which implements an algorithm that

//          determines the order of two items.

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

//

TPIMItemComparisonFunc CPIMToDoAdapterManager::ItemOrder()

{

    JELOG2(EPim);

    return ItemComparisonFunc;

}

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

// CPIMToDoAdapterManager::ItemComparisonFuncL

// Compares two MPIMItemData objects. The comparision is based primarily on the

// completion of the item, secondly on the due date of the item, and thirdly

// on the priority of the item.

// Returns: < 0: aFirst < aSecond

//          0: aFirst == aSecond

//          > 0: aFirst > aSecond

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

//

TInt CPIMToDoAdapterManager::ItemComparisonFunc(const MPIMItem& aFirst,

        const MPIMItem& aSecond)

{

    JELOG2(EPim);

    TInt retVal = 0;

    TRAPD(err, retVal = ItemComparisonFuncL(aFirst, aSecond));

    if (err != KErrNone)

    {

        // The comparison function does not actually leave as it is used with

        // correct PIM field parameters, so this assert here is just for debug

        __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory, EPIMPanicGeneral));

    }

    return retVal;

}

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

// CPIMToDoAdapterManager::ItemComparisonFuncL

// Compares two MPIMItemData objects. The comparision is based primarily on the

// completion of the item, secondly on the due date of the item, and thirdly

// on the priority of the item.

// Returns: < 0: aFirst < aSecond

//          0: aFirst == aSecond

//          > 0: aFirst > aSecond

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

//

TInt CPIMToDoAdapterManager::ItemComparisonFuncL(const MPIMItem& aFirst,

        const MPIMItem& aSecond)

{

    JELOG2(EPim);

    TInt firstPresent = aFirst.CountValuesL(EPIMToDoCompleted);

    TInt secondPresent = aSecond.CountValuesL(EPIMToDoCompleted);

    if ((firstPresent == 0) ^(secondPresent == 0))

        // Only one of the fields is present

    {

        return firstPresent - secondPresent;

    }

    else if (firstPresent > 0 && secondPresent > 0)

        // Both fields are present

    {

        TBool completedFirst = aFirst.GetBooleanL(EPIMToDoCompleted, 0);

        TBool completedSecond = aSecond.GetBooleanL(EPIMToDoCompleted, 0);

        if (!completedFirst && completedSecond)

        {

            return 1;

        }

        else if (completedFirst && !completedSecond)

        {

            return -1;

        }

    }

    // In this point either none of the items have the completed field,

    // or both of the items have the field and also have the same value in it.

    // Continue the comparision based on the 2nd criteria, the due date field.

    firstPresent = aFirst.CountValuesL(EPIMToDoDue);

    secondPresent = aSecond.CountValuesL(EPIMToDoDue);

    if ((firstPresent == 0) ^(secondPresent == 0))  // xor

        // Only one of the fields is present

    {

        return secondPresent - firstPresent;

    }

    else if (firstPresent > 0 && secondPresent > 0)

        // Both fields are present

    {

        const TPIMDate dateFirst = aFirst.GetDateL(EPIMToDoDue, 0);

        const TPIMDate dateSecond = aSecond.GetDateL(EPIMToDoDue, 0);

        if (dateFirst < dateSecond)

        {

            return -1;

        }

        else if (dateFirst > dateSecond)

        {

            return 1;

        }

    }

    // In this point either none of the items have due date field, or

    // the other possibility is that the due date fields are exactly equal.

    // Continue the comparision based on the 3rd criteria, the priority field.

    firstPresent = aFirst.CountValuesL(EPIMToDoPriority);

    secondPresent = aSecond.CountValuesL(EPIMToDoPriority);

    if ((firstPresent == 0) ^(secondPresent == 0))  // xor

        // Only one of the fields is present

    {

        return secondPresent - firstPresent;

    }

    else if (firstPresent > 0 && secondPresent > 0)

        // Both fields are present

    {

        TInt priorityFirst = aFirst.getInt(EPIMToDoPriority, 0);

        TInt prioritySecond = aSecond.getInt(EPIMToDoPriority, 0);

        if (priorityFirst < prioritySecond)

        {

            return -1;

        }

        if (priorityFirst > prioritySecond)

        {

            return 1;

        }

        // The third option is that the priorities are equal as well : return 0

        return 0;

    }

    // If all 3 comparision fields are missing in both items, they are equal

    return 0;

}

//  End of File