/*

* 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:  Base class for the Agenda Model event adapter managers

 *

*/

// CLASS HEADER

#include "cpimeventadaptermanager.h"

#include "logger.h"

// INTERNAL INCLUDES

#include "mpimitem.h"

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

// CPIMApptAdapterManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPIMEventAdapterManager::ConstructL(const TDesC& aListName)

{

    JELOG2(EPim);

    iListName = aListName.AllocL();

}

// Destructor

CPIMEventAdapterManager::~CPIMEventAdapterManager()

{

    JELOG2(EPim);

    delete iRepeatRuleFieldArray;

    delete iRepeatRuleFieldArrayEmpty;

    delete iRepeatRuleIntervalArray;

    delete iRepeatRuleIntervalArrayEmpty;

    delete iEventAttributeArray;

    delete iListName;

}

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

// CPIMEventAdapterManager::GetSupportedRepeatRuleFields

// Provides the supported repeat rule fields for a given frequency.

// Returns: Supported repeat rule fields for \a aFrequency. If no

// fields are supported for the frequency, an empty array is returned.

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

//

const CArrayFix<TPIMField>&

CPIMEventAdapterManager::GetSupportedRepeatRuleFieldsL(

    const TPIMRepeatRuleFrequency& aFrequency)

{

    JELOG2(EPim);

    const CArrayFix<TPIMField>* retVal = NULL;

    switch (aFrequency)

    {

    case EPIMRepeatRuleDaily:

    case EPIMRepeatRuleMonthly:

    case EPIMRepeatRuleYearly:

    {

        // Return a one item array with the item frequency

        if (!iRepeatRuleFieldArrayEmpty)

        {

            iRepeatRuleFieldArrayEmpty

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

            iRepeatRuleFieldArrayEmpty->AppendL(EPIMRepeatRuleFrequency);

        }

        retVal = iRepeatRuleFieldArrayEmpty;

        break;

    }

    case EPIMRepeatRuleWeekly:

    {

        if (!iRepeatRuleFieldArray)

        {

            iRepeatRuleFieldArray

            = new(ELeave) CArrayFixFlat<TPIMField> (KPIMSupportedRepeatRuleFieldsCount);

            iRepeatRuleFieldArray->AppendL(KPIMSupportedRepeatRuleFields,

                                           KPIMSupportedRepeatRuleFieldsCount);

        }

        retVal = iRepeatRuleFieldArray;

        break;

    }

    default:

    {

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

    }

    }

    return *retVal;

}

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

// CPIMEventAdapterManager::GetSupportedIntervals

// Provides the supported interval values for given frequency.

// Returns: Supported interval values for given frequency. If the

// interval field is not supported for given frequency,

// an empty array is returned.

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

//

const CArrayFix<TInt>& CPIMEventAdapterManager::GetSupportedIntervalsL(

    const TPIMRepeatRuleFrequency& aFrequency)

{

    JELOG2(EPim);

    const CArrayFix<TInt>* retVal = NULL;

    switch (aFrequency)

    {

    case EPIMRepeatRuleDaily:

    case EPIMRepeatRuleMonthly:

    case EPIMRepeatRuleYearly:

    {

        // Return an empty array indicating no supported fields

        if (!iRepeatRuleIntervalArrayEmpty)

        {

            iRepeatRuleIntervalArrayEmpty

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

        }

        retVal = iRepeatRuleIntervalArrayEmpty;

        break;

    }

    case EPIMRepeatRuleWeekly:

    {

        if (!iRepeatRuleIntervalArray)

        {

            iRepeatRuleIntervalArray

            = new(ELeave) CArrayFixFlat<TPIMField> (KPIMSupportedRepeatRuleIntervalsCount);

            iRepeatRuleIntervalArray->AppendL(KPIMSupportedRepeatRuleIntervals,

                                              KPIMSupportedRepeatRuleIntervalsCount);

        }

        retVal = iRepeatRuleIntervalArray;

        break;

    }

    default:

    {

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

    }

    }

    return *retVal;

}

const TDesC& CPIMEventAdapterManager::ListNameL()

{

    JELOG2(EPim);

    return *iListName;

}

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

// CPIMEventAdapterManager::MaxCategories

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

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

//

TInt CPIMEventAdapterManager::MaxCategories()

{

    JELOG2(EPim);

    return 0;

}

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

// CPIMEventAdapterManager::IsSupportedField

// Returns: ETrue if supported in this list, EFalse if not supported or invalid.

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

//

TBool CPIMEventAdapterManager::IsSupportedField(TPIMField aField) // The field to check

{

    JELOG2(EPim);

    TInt fieldFinder;

    TInt fetchIndex = 0;

    TKeyArrayFix key(0, ECmpTInt);

    fieldFinder = iSupportedFields->Find(aField, key, fetchIndex);

    if (fieldFinder != 0) // 0 means that the element was found

    {

        return EFalse;

    }

    return ETrue;

}

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

// CPIMEventAdapterManager::GetSupportedFieldsL

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

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

//

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

{

    JELOG2(EPim);

    return *iSupportedFields;

}

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

// CPIMEventAdapterManager::IsSupportedAttribute

// Returns: EFalse, as there are no supported attributes in Event list.

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

//

TBool CPIMEventAdapterManager::IsSupportedAttribute(TPIMField /* aField */, // The field to check the supported attribute from

        TPIMAttribute /* aAttribute */) // The attribute to check

{

    JELOG2(EPim);

    return EFalse;

}

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

// CPIMEventAdapterManager::GetSupportedAttributesL

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

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

//

const CArrayFix<TPIMAttribute>&

CPIMEventAdapterManager::GetSupportedAttributesL(TPIMField aField) // The field to check the supported attributes from

{

    JELOG2(EPim);

    if (!IsSupportedField(aField))

    {

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

    }

    if (!iEventAttributeArray)

    {

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

    }

    return *iEventAttributeArray;

}

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

// CPIMEventAdapterManager::GetSupportedAttributesCombinedL

// Returns: An integer holding the combination of all attributes

//          supported for aField (KPIMAttrNone meaning no supported attributes).

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

TPIMAttribute CPIMEventAdapterManager::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;

}

TPIMAttribute CPIMEventAdapterManager::GetAllSupportedAttributesCombined()

{

    JELOG2(EPim);

    return KPIMAttrNone;

}

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

// CPIMEventAdapterManager::IsSupportedArrayElement

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

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

//

TBool CPIMEventAdapterManager::IsSupportedArrayElement(

    TPIMField /* aStringArrayField */, // The field where array element belongs

    TPIMArrayElement /* aArrayElement */) // The array element to check

{

    JELOG2(EPim);

    return EFalse;

}

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

// CPIMEventAdapterManager::GetSupportedArrayElementsL

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

//          string array for the given field.

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

//

const CArrayFix<TPIMArrayElement>&

CPIMEventAdapterManager::GetSupportedArrayElementsL(TPIMField /* aField */) // The field to check the supported array elements

{

    JELOG2(EPim);

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

    // Even this method leaves always, the compiler requires it to return an

    // array.

    // The next line is only because of that, and actually it is never executed.

    const CArrayFix<TPIMArrayElement>* temp = NULL;

    return *temp;

}

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

// CPIMEventAdapterManager::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 CPIMEventAdapterManager::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 Event field

    }

    else

    {

        return 0;

    }

}

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

// CPIMEventAdapterManager::StringArraySizeL

// Returns: Int the size of the array.

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

//

TInt CPIMEventAdapterManager::StringArraySizeL(TPIMField /* aStringArrayField */) // The field to check the array size

{

    JELOG2(EPim);

    User::Leave(KErrArgument);

    // Even this method leaves always, the compiler requires it to return an

    // array.

    // The next line is only because of that, and actually it is never executed.

    return 0;

}

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

// CPIMEventAdapterManager::ItemOrder

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

//            determines the order of two items.

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

//

TPIMItemComparisonFunc CPIMEventAdapterManager::ItemOrder()

{

    JELOG2(EPim);

    return ItemComparisonFunc;

}

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

// CPIMEventAdapterManager::ItemComparisonFunc

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

// start times, and secondary on the summary strings (if start times are equal).

// Returns: < 0: aFirst < aSecond

//          0: aFirst == aSecond

//          > 0: aFirst > aSecond

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

//

TInt CPIMEventAdapterManager::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;

}

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

// CPIMEventAdapterManager::ItemComparisonFuncL

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

// start times, and secondary on the summary strings (if start times are equal).

// Returns: < 0: aFirst < aSecond

//          0: aFirst == aSecond

//          > 0: aFirst > aSecond

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

//

TInt CPIMEventAdapterManager::ItemComparisonFuncL(const MPIMItem& aFirst,

        const MPIMItem& aSecond)

{

    JELOG2(EPim);

    TInt firstPresent = aFirst.CountValuesL(EPIMEventStart);

    TInt secondPresent = aSecond.CountValuesL(EPIMEventStart);

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

        // 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(EPIMEventStart, 0);

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

        if (dateFirst < dateSecond)

        {

            return -1;

        }

        else if (dateFirst > dateSecond)

        {

            return 1;

        }

    }

    // In this point either none of the items have start time field, or

    // the other possibility is that the start time fields are exactly equal.

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

    firstPresent = aFirst.CountValuesL(EPIMEventSummary);

    secondPresent = aSecond.CountValuesL(EPIMEventSummary);

    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

    {

        return aFirst.GetStringL(EPIMEventSummary, 0).CompareC(

                   aSecond.GetStringL(EPIMEventSummary, 0));

    }

    // If start time AND summary are missing in both items, they are equal.

    return 0;

}

//  End of File