/*

* Copyright (c) 2007-2009 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:  Interface definition for ESMR calendar entry

*

*/

#ifndef MESMRCALENTRY_H

#define MESMRCALENTRY_H

//<cmail>

#include "esmrdef.h"

//</cmail>

class CCalEntry;

class CCalInstance;

/**

 * MESMRMeetingRequestEntry provides utility functions for handling MR Entry.

 *

 * @lib esmrservices.lib

 */

class MESMRCalEntry

    {

public: // Definitions

    /** 

     * Enumeration for cal entry type

     */

    enum TESMRCalEntryType

        {

        EESMRCalEntryNotSupported = -1, // Entry type not supported

        EESMRCalEntryMeetingRequest,    // Meeting request entry

        EESMRCalEntryMeeting,           // Meeting entry

        EESMRCalEntryTodo,              // TO-DO entry

        EESMRCalEntryMemo,              // Memo entry

        EESMRCalEntryReminder,          // Reminder entry

        EESMRCalEntryAnniversary        // Anniversary entry

        };

    /** 

     * Enumeration for recurrence modifying rule

     */

    enum TESMRRecurrenceModifyingRule

        {

        // Modify only this entry

        EESMRThisOnly,

        // Modification applies to all entries in the series

        EESMRAllInSeries

        };

    /** 

     * Enumeration for alarm type

     */

    enum TESMRAlarmType

        {

        /** 

         * Entry does not contain alarm 

         */

        EESMRAlarmNotFound,

        /** 

         * Alarm is absolute

         */

        EESMRAlarmAbsolute,

        /** 

         * Alarm is relative to meeting start time

         */

        EESMRAlarmRelative

        };

public: // Destruction

    /**

     * Virtual destructor.

     */

    virtual ~MESMRCalEntry() { }

public: // Interface

    /**

     * Fetches calendar entry type.

     * @return calendar entry type.

     */

    virtual TESMRCalEntryType Type() const = 0;

    /**

     * Fetches reference to this calendar entry.

     * @return Reference to this entry.

     */

    virtual MESMRCalEntry& MESMRCalEntryRef() = 0;

    /**

     * Fetches const reference to this calendar entry.

     * @return const reference to this calendar entry.

     */

    virtual const MESMRCalEntry& MESMRCalEntryRef() const = 0;

    /**

     * Fetches constant reference to CCalEntry.

     * @return const reference to CCalEntry.

     */

    virtual const CCalEntry& Entry() const = 0;

    /**

     * Fetches reference to CCalEntry.

     * @return reference to CCalEntry.

     */

    virtual CCalEntry& Entry() = 0;

    /**

     * Fetches calendar entry's instance. Ownership is transferred to caller.

     * @return Reference to calendar entry's instance.

     */

    virtual CCalInstance* InstanceL() const = 0;

    /**

     * Tests, if recurrence can be set.

     * @return ETrue, if recurrence can be set. EFalse otherwise.

     */

    virtual TBool CanSetRecurrenceL() const = 0;

    /**

     * Tests, if this is recurrent meeting request.

     * @return ETrue, if this is recurrent meeting request.

     */

   virtual TBool IsRecurrentEventL() const = 0;

    /**

     * Fetches entry's recurrence value.

     * @param aRecurrence On return contains entry's recurrence information

     * @param aUntil On return contains time in UTC until recurrence is valid.

     */

    virtual void GetRecurrenceL(

            TESMRRecurrenceValue& aRecurrence,

            TTime& aUntil ) const = 0;

    /**

     * Sets recurrence to ES MR entry. If until time is not set

     * (i.e, it is null time), then until time is implementation

     * dependent.

     * When recurrence is set to ERecurrenceNot, then aUntil parameter

     * is ignored.

     * @param aRecurrece Recurrece value.

     * @param aUntil Recurrence valid until in UTC format.

     * @error KErrNotSupported Entry cannot be recurrenced.

     */

    virtual void SetRecurrenceL(

            TESMRRecurrenceValue aRecurrence,

            TTime aUntil = Time::NullTTime() ) = 0;

    /**

     * Fetches recurrence modification rule.

     * @return Modification rule.

     */

    virtual TESMRRecurrenceModifyingRule RecurrenceModRule() const = 0;

    /**

    * Sets modifying rule role to meeting request.

    * @param aRule Recurrence modification rule.

    */

   virtual void SetModifyingRuleL(

           TESMRRecurrenceModifyingRule aRule ) = 0;

        /**

     * Sets the entry priority.

     * @param aPriority entry priority.

     */

    virtual void SetPriorityL(

            TUint aPriority ) = 0;

    /**

     * Fetches the entry priority.

     * @return entry priority.

     */

    virtual TUint GetPriorityL() const = 0;

    /**

     * Sets meeting to be all day event.

     * @param aStartDate Start date information

     * @param aEndDate End date information

     */

    virtual void SetAllDayEventL(

            TTime aStartDate,

            TTime aEndDate ) = 0;

    /**

     * Tests, if entry is all day event.

     * @return ETrue, if entry is all day event

     */

    virtual TBool IsAllDayEventL() const = 0;

    /**

     * Tests whether this entry has been stored to db or not.

     * @return ETrue, if entry is stored to calendar DB.

     */

    virtual TBool IsStoredL() const = 0;

    /**

     * Tests if this entry has been sent to attendees.

     * @return ETrue, if entry is sent to attendees

     */

    virtual TBool IsSentL() const = 0;

    /**

     * Tests, whether entry is edited.

     * @return ETrue, if entry is edited.

     */

    virtual TBool IsEntryEditedL() const = 0;

    /**

     * Fetches alarm information from entry.

     * @param aAlarmType On return contains alarm type.

     * @param aAlarmTime On return contains time when alarm occurs.

     */

    virtual void GetAlarmL(

            TESMRAlarmType& aAlarmType,

            TTime &aAlarmTime ) = 0;

    /**

     * Fetches unmodified entry instance.

     * @return CCalEntry original entry

     */

    virtual const CCalEntry& OriginalEntry() = 0;

    };

#endif // MESMRCALENTRY_H

// EOF