/*

* 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:  Event item implementation.

 *

*/

// CLASS HEADER

#include "cpimeventitem.h"

// INTERNAL INCLUDES

#include "cpimitemdata.h"

#include "pimevent.h"

#include "mpimeventadaptermanager.h"

#include "mpimeventlistadapter.h"

#include "cpimrepeatrule.h"

#include "cpimeventvalidator.h"

#include "cpimmanager.h"

#include "pimpanics.h"

#include "logger.h"

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

// C++ constructor

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

//

CPIMEventItem::CPIMEventItem(const CPIMEventValidator& aValidator) :

        CPIMItem(aValidator), iIsRepeating(EFalse), iIsRepeatRuleOwned(ETrue)

{

    JELOG2(EPim);

}

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

// CPIMEventItem::ConstructL

// Second phase constructor

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

//

void CPIMEventItem::ConstructL()

{

    JELOG2(EPim);

    CPIMItem::ConstructL();

    iRepeatRule = CPIMRepeatRule::NewL();

}

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

// CPIMEventItem::NewL

// Two-phase constructor

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

//

CPIMEventItem* CPIMEventItem::NewL(const CPIMEventValidator& aValidator)

{

    JELOG2(EPim);

    CPIMEventItem* self = NewLC(aValidator);

    CleanupStack::Pop(self);

    return self;

}

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

// CPIMEventItem::NewLC

// Two-phase constructor. Leaves item to the cleanup stack

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

//

CPIMEventItem* CPIMEventItem::NewLC(const CPIMEventValidator& aValidator)

{

    JELOG2(EPim);

    CPIMEventItem* self = new(ELeave) CPIMEventItem(aValidator);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

pimbaseitem* pimbaseitem::getEventItemInstance(pimbasemanager* aPimManager)

{

    JELOG2(EPim);

    CPIMManager* pimManager = reinterpret_cast<CPIMManager*>(aPimManager);

    CPIMEventItem* eventItem = NULL;

    TInt error = 0;

    TRAP(error,

    {

        const CPIMEventValidator& eventValidator = pimManager->EventValidator();

        eventItem = CPIMEventItem::NewL(eventValidator);

    }

        );

    if (error != KErrNone)

        throw KErrGeneral;

    return eventItem;

}

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

// Destructor

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

//

CPIMEventItem::~CPIMEventItem()

{

    JELOG2(EPim);

    if (iIsRepeatRuleOwned)

    {

        delete iRepeatRule;

    }

}

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

// CPIMEventItem::SetEventAdapterAssociation

// (other items were commented in a header)

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

//

void CPIMEventItem::SetEventAdapterAssociation(

    MPIMEventAdapterManager* aEventAdapterManager,

    MPIMEventListAdapter* aEventListAdapter)

{

    JELOG2(EPim);

    __ASSERT_DEBUG(aEventAdapterManager, User::Panic(KPIMPanicCategory,

                   EPIMPanicNullArgument));

    iEventAdapterManager = aEventAdapterManager;

    iEventListAdapter = aEventListAdapter;

    SetBaseAdapterAssociation(iEventAdapterManager->GetAdapterManager(),

                              iEventListAdapter ? iEventListAdapter->GetPimListAdapter() : NULL);

}

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

// CPIMEventItem::RemoveAdapterAssociation

// (other items were commented in a header)

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

//

void CPIMEventItem::RemoveAdapterAssociation()

{

    JELOG2(EPim);

    iEventAdapterManager = NULL;

    iEventListAdapter = NULL;

    CPIMItem::RemoveAdapterAssociation();

}

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

// CPIMEventItem::GetRepeatTransferOwnership

// (other items were commented in a header)

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

//

CPIMRepeatRule* CPIMEventItem::GetRepeatTransferOwnership()

{

    JELOG2(EPim);

    iIsRepeatRuleOwned = EFalse;

    return iRepeatRule;

}

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

// CPIMEventItem::ItemType

// (other items were commented in a header)

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

//

TPIMListType CPIMEventItem::ItemType() const

{

    JELOG2(EPim);

    return EPIMEventList;

}

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

// CPIMEventItem::commit

// (other items were commented in a header)

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

//

void CPIMEventItem::commit()

{

    JELOG2(EPim);

    TInt error = KErrNone;

    TRAP(error,

    {

        if (iEventAdapterManager)

        {

            // The item is associated with a list

            if (iEventListAdapter)

            {

                // The list is open

                if (iItemID->Compare(KPIMNullItemID) == 0)

                {

                    // The item does not have database entry

                    iEventListAdapter->CreateEventItemL(*this);

                }

                else

                {

                    iEventListAdapter->WriteEventItemL(*this);

                }

                SetModified(EFalse);

                UpdateUidFieldL(EPIMEventUid, iItemID->Des());

                UpdateRevisionFieldL(EPIMEventRevision, LastModified());

            }

            else

            {

                // The associated list is closed

                User::Leave(KErrDisconnected);   // codescanner::leave

            }

        }

        else

        {

            // The item is not associated with a list

            User::Leave(KErrDisMounted);   // codescanner::leave

        }

    }

        );

    if (error != KErrNone)

        throw error;

}

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

// CPIMEventItem::ListClosed

// (other items were commented in a header)

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

//

void CPIMEventItem::ListClosed()

{

    JELOG2(EPim);

    iEventListAdapter = NULL;

    CPIMItem::ListClosed();

}

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

// CPIMEventItem::SetEventItemIdL

// (other items were commented in a header)

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

//

void CPIMEventItem::SetEventItemIdL(const TPIMItemID& aEventItemId)

{

    JELOG2(EPim);

    // Set item id for the base class

    CPIMItem::SetIdL(aEventItemId);

    // Update UID field if it is supported

    if (iAdapterManager && iAdapterManager->IsSupportedField(

                EPIMEventUid))

    {

        UpdateUidFieldL(EPIMEventUid, aEventItemId);

    }

}

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

// CPIMEventItem::EventItemId

// (other items were commented in a header)

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

//

const TPIMItemID CPIMEventItem::EventItemId() const

{

    JELOG2(EPim);

    if (!iItemID)

    {

        return KPIMNullItemID();

    }

    return iItemID->Des();

}

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

// CPIMEventItem::SetLastModifiedL

// (other items were commented in a header)

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

//

void CPIMEventItem::SetLastModifiedL(TPIMDate aLastModified)

{

    JELOG2(EPim);

    CPIMItem::SetLastModifiedL(aLastModified);

    // Update revision field if it supported

    if (iAdapterManager && iAdapterManager->IsSupportedField(

                EPIMEventRevision))

    {

        UpdateRevisionFieldL(EPIMEventRevision, LastModified());

    }

}

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

// CPIMEventItem::PrepareForLoadL

// (other items were commented in a header)

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

//

void CPIMEventItem::PrepareForLoadL()

{

    JELOG2(EPim);

    // Prepare base class for loading from the database

    CPIMItem::PrepareForLoadL();

}

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

// CPIMEventItem::IsReadOnly

// (other items were commented in a header)

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

//

TBool CPIMEventItem::IsReadOnly(const TPIMField& aField)

{

    JELOG2(EPim);

    TBool retVal = EFalse;

    if (aField == EPIMEventUid || aField == EPIMEventRevision)

    {

        retVal = (iItemID->Compare(KPIMNullItemID) != 0);

    }

    return retVal;

}

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

// CPIMEventItem::GetItemData

// (other items were commented in a header)

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

//

MPIMItemData& CPIMEventItem::ItemData()

{

    JELOG2(EPim);

    return *iItemData;

}

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

// CPIMEventItem::GetItemData

// (other items were commented in a header)

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

//

const MPIMItemData& CPIMEventItem::ItemData() const

{

    JELOG2(EPim);

    return *iItemData;

}

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

// CPIMEventItem::GetRepeat

// (other items were commented in a header)

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

//

MPIMRepeatRuleData* CPIMEventItem::GetRepeat()

{

    JELOG2(EPim);

    return iRepeatRule;

}

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

// CPIMEventItem::GetRepeat

// (other items were commented in a header)

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

//

const MPIMRepeatRuleData* CPIMEventItem::GetRepeat() const

{

    JELOG2(EPim);

    return iRepeatRule;

}

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

// CPIMEventItem::IsRepeating

// (other items were commented in a header)

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

//

TBool CPIMEventItem::IsRepeating() const

{

    JELOG2(EPim);

    return iIsRepeating;

}

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

// CPIMEventItem::StaticIsRepeating

// (other items were commented in a header)

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

//

bool CPIMEventItem::isItemRepeating() const

{

    JELOG2(EPim);

    if (IsRepeating())

        return true;

    return false;

}

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

// CPIMEventItem::SetRepeating

// (other items were commented in a header)

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

//

void CPIMEventItem::SetRepeating(TBool aSetRepeating)

{

    JELOG2(EPim);

    iIsRepeating = aSetRepeating;

    SetModified();

}

void CPIMEventItem::setItemRepeating(jboolean aSetRepeating)

{

    JELOG2(EPim);

    SetRepeating(static_cast<TBool>(aSetRepeating));

}

int CPIMEventItem::getRepeatHandle()

{

    JELOG2(EPim);

    pimbaserepeatrule* repeatRule = NULL;

    repeatRule = GetRepeatTransferOwnership();

    // We now own the RepeatRule

    int repeatRuleHandle = reinterpret_cast<int>(repeatRule);

    return repeatRuleHandle;

}

int CPIMEventItem::getPreferredIndex(TPIMField /*aField*/) const

{

    JELOG2(EPim);

    // shouldnt reach this code

    return KErrGeneral;

}

//  End of File