1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   

    15 *

    16 */

    17 

    18 

    19 #ifndef __CALENDARENTRY_H

    20 #define __CALENDARENTRY_H

    21 

    22 #include <calentry.h>

    23 #include <calrrule.h>

    24 

    25 class CCalUser;

    26 

    27 class CAttendeeInfo : public CBase

    28 	{

    29 	public:

    30 	

    31 		/**

    32 	     * Two-phased constructor.

    33 	     * @param aAddress The address of the attendee

    34 	     * @return An instance of CAttendeeInfo

    35 	    */

    36 		IMPORT_C static CAttendeeInfo* NewL( const TDesC& aAddress );

    37 		

    38 		/** 

    39 	     * Destructor.

    40 	    */

    41 		~CAttendeeInfo();

    42 		

    43 		/**

    44 		 * Sets the iCalender-defined common name of the user

    45 		 * @param aName It is the common name of the user

    46 		*/ 

    47 		IMPORT_C void SetCommonNameL( const TDesC& aName );

    48 

    49 		/**

    50 		 * Set the role of this attendee

    51 		 * @param aRole The role

    52 		*/ 

    53 		IMPORT_C void SetRoleL( const TDesC& aRole );

    54 		

    55 		/**

    56 		 * Set the status of this attendee

    57 		 * @param aStatus The status

    58 		*/ 

    59 		IMPORT_C void SetStatusL( const TDesC& aStatus );

    60 		

    61 		/**

    62 		 * Sets whether or not a response was requested for this attendee

    63 		 * @param aResponse ETrue if a response was requested, EFalse if not

    64 		*/ 

    65 		IMPORT_C void SetRsvp( const TBool aResponse );

    66 		

    67 		/**

    68 		 * Gets the address of the attendee.

    69 		 * @return The address of the attendee.

    70 		*/ 

    71 		IMPORT_C TPtrC Address();

    72 		

    73 		/**

    74 		 * Gets the iCalender-defined common name of the user.

    75 		 * @return The common name of the user.

    76 		*/ 

    77 		IMPORT_C TPtrC CommonName();

    78 		

    79 		/**

    80 		 * Get the role of this attendee

    81 		 * @return The role

    82 		*/ 

    83 		IMPORT_C TPtrC Role();

    84 

    85 		/**

    86 		 * Get the status of this attendee

    87 		 * @return The status

    88 		*/ 

    89 		IMPORT_C TPtrC Status();

    90 		

    91 		/**

    92 		 * Gets whether or not a response was requested for this attendee. 

    93 		 * @return ETrue if a response was requested, EFalse if not. 

    94 		*/ 

    95 		IMPORT_C TBool ResponseRequested();

    96 		

    97         

    98 	private:

    99 	 

   100 	    /**

   101 		 * Constructor

   102 		*/ 

   103 		CAttendeeInfo();

   104 		

   105 		/**

   106 		 * Constructor

   107 		*/ 

   108 		void ConstructL( const TDesC& aAddress );

   109 		

   110 	private:

   111 	

   112 

   113 		/**

   114 		 * Repeat type: can be daily, weekly, monthly or yearly

   115 	  	*/ 

   116 		HBufC* iAddress;

   117 		

   118 		/**

   119 		 * Repeat type: can be daily, weekly, monthly or yearly

   120 	  	*/ 

   121 		HBufC* iRole;

   122 		

   123 		/**

   124 		 * Until time of the repeat rule

   125 	  	*/ 

   126 		HBufC* iStatus;

   127 		

   128 		/**

   129 		 * Start time of the repeat rule

   130 	  	*/ 

   131 		HBufC* iCommonName;

   132 		

   133 		/**

   134 		 * Interval for the repeat rule

   135 	  	*/ 

   136 		TBool iResponse;

   137 		

   138 		

   139 	

   140 	};

   141 	

   142 class CRepeatInfo : public CBase

   143 	{

   144 	

   145 	public:

   146 		/**

   147 	     * Two-phased constructor.

   148 	     * @param 

   149 	     * @return An instance of CRepeatInfo

   150 	    */

   151 		IMPORT_C static CRepeatInfo* NewL( const TInt aType );

   152 		

   153 		/** 

   154 	     * Destructor.

   155 	    */

   156 		~CRepeatInfo();

   157 

   158 		/**

   159 		 * Sets the until time for the repeat rule

   160 		 * @param aUntilTime It is the time until which we want this rule to

   161 		 *				 repeat

   162 		*/ 

   163 		IMPORT_C void SetUntilTimeL( const TTime& aUntilTime );

   164 

   165 		/**

   166 		 * Sets the number of instances for the repeat rule

   167 		 * @param aCount It is the number of instances we want this rule to

   168 		 *				 repeat

   169 		*/ 

   170 		IMPORT_C void SetCount( const TUint aCount );

   171 

   172 		/**

   173 		 * Sets the start time for the repeat rule

   174 		 * @param aStartTime It is the start time for the repeat rule

   175 		*/ 

   176 		IMPORT_C void SetStartTimeL( const TTime& aStartTime );

   177 		

   178 		/**

   179 		 * Sets the interval for the repeat rule

   180 		 * @param aInterval It is the interval between two successive repeats

   181 		*/ 

   182 		IMPORT_C void SetInterval( const TInt aInterval );

   183 		

   184 		/**

   185 		 * Sets all week days on which this rule is repeated, applicable only

   186 		 *				 for weekly repeat rule

   187 		 * @param aDay It specifies the day of the week on which this rule

   188 		 *               repeats. 

   189 		*/ 

   190 		IMPORT_C void SetDaysInWeek( const RArray<TDay>& aDays );

   191 		

   192 		/**

   193 		 * Sets all dates of the month on which this rule is repeated, applicable 

   194 		 *				 only for monthly repeat rule

   195 		 * @param aDay It specifies the day of the month on which this rule

   196 		 *               repeats. 

   197 		*/ 

   198 		IMPORT_C void SetMonthDates( const RArray<TInt>& aMonthDates );

   199 		

   200 		/**

   201 		 * Sets all days of the month on which this rule is repeated, applicable 

   202 		 *				 only for monthly and yearly repeat rule

   203 		 * @param aDay It specifies the day of the week on which this rule

   204 		 *               repeats. 

   205 		 * @param  aWeekNum  The week number in the month i.e.1, 2, 3, 4 for the 1st, 

   206 		 				 2nd, 3rd and 4th week of the month, or -1 for the last week 

   207 		 				 of the month.

   208 		*/ 

   209 		IMPORT_C void SetMonthDays( const RArray<TCalRRule::TDayOfMonth>& aDays );

   210 

   211 		/**

   212 		 * Sets the month of the year for this repeat rule

   213 		 * @param aMonthNum It is the month number in which we want the rule to repeat

   214 		*/ 

   215 		IMPORT_C void SetMonth( const TInt aMonthNum );

   216 		

   217 	

   218        	/**

   219 		 * Sets the first day of the week for this repeat rule.

   220 		 * @param aDay The weekday to be the first

   221 		*/ 

   222 		IMPORT_C void SetWeekStart( const TInt aDay );

   223 	

   224 		/**

   225 		 * Gets the month of the year for this repeat rule

   226 		 * @return The month of the yearly repeat

   227 		*/ 

   228 		IMPORT_C TMonth Month();

   229 		

   230 		/**

   231 		 * Gets all weekdays on which this rule is repeated

   232 		 * @return Array containing all weekdays that are to be set

   233 		*/ 

   234 		IMPORT_C RArray< TDay >& DaysInWeek();

   235 

   236 		/**

   237 		 * Gets all days in the month on which this rule is repeated

   238 		 * @return Array containing all days in the month that are to be set

   239 		*/ 

   240 		IMPORT_C RArray< TCalRRule::TDayOfMonth >& DaysInMonth();

   241 		

   242 		/**

   243 		 * Gets all dates in the month on which this rule is repeated

   244 		 * @return Array containing all dates in the month that are to be set

   245 		*/ 

   246 		IMPORT_C RArray< TInt >& DatesInMonth();

   247 		

   248 		/**

   249 		 * Gets the repeat interval.

   250 		 * @return The repeat interval

   251 		*/ 

   252 		IMPORT_C TInt Interval();

   253 		

   254 		/**

   255 		 * Gets the repeat interval.

   256 		 * @return The end date, as a TCalTime so it may be accessed in utc or system local time

   257 		*/ 

   258 	    IMPORT_C TCalTime& UntilDate();

   259 	    

   260 	    /**

   261 		 * Gets the repeat definition's type.

   262 		 * @return The repeat definition's type

   263 		*/ 

   264 		IMPORT_C TCalRRule::TType Type();

   265 		

   266 		/**

   267 		 * Gets the first day of the week for this repeat rule.

   268 		 * @return The first day of the week for this repeat rule.

   269 		*/ 

   270 		IMPORT_C TDay WeekStart();

   271 		

   272 		/**

   273 		 * Gets the repeat rule

   274 		 * @return The repeat rule.

   275 		*/ 

   276 	    IMPORT_C TCalRRule& GetRepeatRule();

   277 	private:

   278 	 

   279 	    /**

   280 		 * Constructor

   281 		*/ 

   282 		CRepeatInfo();

   283 		

   284 		/**

   285 		 * Constructor

   286 		*/ 

   287 		void ConstructL( const TInt aType );	

   288 	private:

   289 	

   290 		

   291 		/**

   292 		 * Repeat type: can be daily, weekly, monthly or yearly

   293 	  	*/ 

   294 		TCalRRule::TType iType;

   295 		

   296 		/**

   297 		 * Until time of the repeat rule

   298 	  	*/ 

   299 		TCalTime iUntilTime;

   300 		

   301 		/**

   302 		 * Start time of the repeat rule

   303 	  	*/ 

   304 		TCalTime iStartTime;

   305 		

   306 		/**

   307 		 * Interval for the repeat rule

   308 	  	*/ 

   309 		TInt iInterval;

   310 		

   311 		/**

   312 		 * Month for the yearly repeat rule

   313 	  	*/ 

   314 		TMonth iMonth;

   315 		

   316 		/**

   317 		 * Array of month days for the monthly/yearly repeat rule

   318 	  	*/ 

   319 		RArray<TCalRRule::TDayOfMonth> iMonthDays;

   320 		

   321 		/**

   322 		 * Array of month dates for the monthly repeat rule

   323 	  	*/ 

   324 		RArray<TInt> iMonthDates;

   325 		

   326 		/**

   327 		 * Array of weekdays for the weekly repeat rule

   328 	  	*/ 

   329 		RArray<TDay> iWeekDays;

   330 		

   331 		TDay iWkSt;

   332 		

   333 		TCalRRule iRule;

   334 		

   335 	};

   336 

   337 /**

   338  * This class provides function to set and get various attributes

   339  * associated with a calendar entry.

   340  */	

   341 class CEntryAttributes : public CBase

   342 	{

   343 	public:

   344 	

   345 	/**

   346 	 * TModifiedParameters enum for indicating which entry fields have new values

   347 	 * for modification

   348 	*/

   349 	enum TModifiedParameters

   350 		{

   351 		ESummary		=0x00001,

   352 		ESeqNum			=0x00002,

   353 		EStartTime		=0x00004,

   354 		EEndTime		=0x00008,

   355 		EReplication	=0x00010,

   356 		EDescription	=0x00020,

   357 		EPriority		=0x00040,

   358 		EMethod			=0x00080,

   359 		EAlarmTime		=0x00100,

   360 		ELocation		=0x00200,

   361 		EStatus			=0x00400,

   362 		ERepeatRule		=0x00800,

   363 		EExDates		=0x01000,

   364 		ERepeatDates	=0x02000,

   365 		EPhoneOwner		=0x04000,

   366 		EOrganizer		=0x08000,

   367 		EAttendees		=0x10000,

   368 		ELocalUid		=0x20000,

   369 		EEntryType		=0x40000,

   370 		EInsStartTime	=0x80000,

   371 		};

   372 				

   373 	public:

   374 		

   375 		/**

   376 	     * Two-phased constructor.

   377 	     * @param aType It is the type of calendar entry and can be an appointment,

   378 	     *              to-do item, reminder, event or anniversary  

   379 	     * @return An instance of CEntryAttributes

   380 	    */

   381 		IMPORT_C static CEntryAttributes* NewL( const TDesC& aType );

   382 		

   383 		/**

   384 	     * Two-phased constructor.

   385 	     * @return An instance of CEntryAttributes

   386 	    */

   387 		IMPORT_C static CEntryAttributes* CEntryAttributes::NewL();

   388 		/** 

   389 	     * Destructor.

   390 	    */

   391 		~CEntryAttributes();

   392 		

   393 		/**

   394 		 * Sets the start time for the calendar entry

   395 		 * @param aStartTime It is the start time that we want to set to the 

   396 		 *               calendar entry. 

   397 		 * @return void

   398 		*/ 

   399 		IMPORT_C void SetTypeL( const TDesC& aType );

   400 		

   401 		/**

   402 		 * Sets the start time for the calendar entry

   403 		 * @param aStartTime It is the start time that we want to set to the 

   404 		 *               calendar entry. 

   405 		 * @return void

   406 		*/ 

   407 		IMPORT_C void SetStartTimeL( const TTime& aStartTime );

   408 		

   409 		/**

   410 		 * Sets the end time for the calendar entry

   411 		 * @param aEndTime It is the start time that we want to set to the 

   412 		 *               calendar entry.  

   413 		 * @return void

   414 		*/ 

   415 		IMPORT_C void SetEndTimeL( const TTime& aEndTime );

   416 		

   417 		/**

   418 		 * Sets the instance start time for the calendar entry, valid for "Update"

   419 		 * opration

   420 		 * @param aEndTime It is the start time that we want to set to the 

   421 		 *               calendar entry.  

   422 		 * @return void

   423 		*/ 

   424 		IMPORT_C void SetInstanceStartTimeL( const TTime& aStartTime );

   425 

   426 		/**

   427 		 * Sets the sequence number for the calendar entry

   428 		 * @param aSeqNum It is the sequence number that we want to set to the 

   429 		 *               calendar entry.  

   430 		 * @return void

   431 		*/ 

   432 		IMPORT_C void SetSequenceNumber( const TInt aSeqNum );

   433 		

   434 		/**

   435 		 * Sets the status of the calendar entry

   436 		 * @param aStatus It specifies the current status of the calendar entry.

   437 		 * @return void

   438 		*/ 

   439 		IMPORT_C void SetEntryStatusL( const TDesC& aStatus );

   440 		

   441 		/**

   442 		 * Sets the phone owner for a calendar entry 

   443 		 * @param aCommonName It is the common name of the calendar user

   444 		 * @param aEmailAddress It is the email address of the calendar user

   445 		 * @return void

   446 		*/ 

   447 		IMPORT_C void SetPhoneOwnerDataL( const TDesC& aPhoneOwner ); 

   448 		/**

   449 		

   450 		 * Sets the organizer of a calendar entry of type appointment

   451 		 * @param aCommonName It is the common name of the group to which

   452 		 *                  this user belongs.

   453 		 * @param aEmailAddress It is the email address of the meeting organizer

   454 		 * @return void

   455 		*/ 

   456 		IMPORT_C void SetOrganizerDataL( CAttendeeInfo* aPhoneOwner );

   457 		

   458 		/**

   459 		 * Adds the attendees of a calendar entry of type appointment

   460 		 * @param aAttendee attendee for the appointment. Ownership is transfered

   461 		 * @return void

   462 		*/ 

   463 		IMPORT_C void AddAttendeeL( CAttendeeInfo* aAttendee );

   464 		

   465 		/**

   466 		 * Adds the out-of-sequence dates on which this entry occurs.

   467 		 * @param aRepeatDate date that we want to add to the original schedule. 

   468 		 * @return void

   469 		*/ 

   470 		IMPORT_C void AddRepeatDateL( const TTime& aRepeatDate );

   471 		

   472 		/**

   473 		 * Adds the date that is to be exceptioned in the original schedule.

   474 		 * @param aExDate It is the date that we want to remove 

   475 		 *                  from the original schedule. 

   476 		 * @return void

   477 		*/ 

   478 		IMPORT_C void AddExceptionDateL( const TTime& aExDate );

   479 		

   480 		/**

   481 		 * Sets the summary for the calendar entry.

   482 		 * @param aSummary It is the summary that we want to set for the

   483 		 *					calendar entry.

   484 		 * @return void

   485 		*/ 

   486 		IMPORT_C void SetSummaryL( const TDesC& aSummary );

   487 		

   488 		/**

   489 		 * Sets the description for the calendar entry.

   490 		 * @param aDescription It is the description that we want to set for the

   491 		 *					calendar entry.

   492 		 * @return void

   493 		*/ 

   494 		IMPORT_C void SetDescriptionL( const TDesC& aDescription );

   495 		

   496 		/**

   497 		 * Sets the location for the calendar entry.

   498 		 * @param aLocation It is the location that we want to set for the

   499 		 *					meeting entry.

   500 		 * @return void

   501 		*/ 

   502 		IMPORT_C void SetLocationL( const TDesC& aLocation );

   503 		

   504 		/**

   505 		 * Sets the method for the calendar entry.

   506 		 * @param aMethod It is the method that we want to set for the

   507 		 *					meeting entry.

   508 		 * @return void

   509 		*/ 

   510 		IMPORT_C void SetMethodL( const TDesC& aMethod );

   511 		

   512 		/**

   513 		 * Sets the replication for the calendar entry.

   514 		 * @param aLocation It is the location that we want to set for the

   515 		 *					meeting entry.

   516 		 * @return void

   517 		*/ 

   518 		IMPORT_C void SetReplicationL( const TDesC& aRepStatus );

   519 		

   520 		/**

   521 		 * Sets the priority for the calendar entry.

   522 		 * @param aLocation It is the location that we want to set for the

   523 		 *					meeting entry.

   524 		 * @return Error code

   525 		*/ 

   526 		IMPORT_C int SetPriority(const TInt aPriority );

   527 		

   528 		/**

   529 		 * Sets the alarm for the calendar entry.

   530 		 * @param aAlarmTime It is the time that we want to set for the

   531 		 *					entry alarm.

   532 		 * @return void

   533 		*/ 

   534 		IMPORT_C void SetAlarm( const TTime& aAlarmTime);

   535 		

   536 		/**

   537 		 * Sets the local uid for the calendar entry.

   538 		 * @param aLocation It is the location that we want to set for the

   539 		 *					meeting entry.

   540 		 * @return void

   541 		*/ 

   542 		IMPORT_C void SetLocalUid( const TCalLocalUid aLUid);

   543 

   544 		/**

   545 		 * Gets the start time for the calendar entry.

   546 		 * @param aLocation It is the location that we want to set for the

   547 		 *					meeting entry.

   548 		 * @return void

   549 		*/ 

   550 		

   551 	    

   552 		IMPORT_C TCalTime& StartTime();

   553        

   554         /**

   555 		 * Sets the entry's repeat rule

   556 		 * @param aRptInfo It is the repeat rule information for this entry

   557 		*/ 	

   558 		IMPORT_C  void SetRepeatRule( CRepeatInfo* aRptInfo);

   559 		

   560 		/**

   561 		 * Gets the end time for the calendar entry.

   562 		 * @return The end time for the calendar entry.

   563 		*/ 

   564 		IMPORT_C TCalTime& EndTime();

   565 		

   566 		/**

   567 		 * Gets the instance start time.

   568 		 * @return void The instance start time.

   569 		*/ 

   570 		IMPORT_C TCalTime& InstanceStartTime();

   571 		

   572 		/**

   573 		 * Gets the entry type for the calendar entry.

   574 		 * @return void The entry type for the calendar entry.

   575 		*/ 

   576 	    IMPORT_C CCalEntry::TType EntryType();

   577 	    

   578 	    /**

   579 		 * Gets the sequence number for the calendar entry.

   580 		 * @return void The sequence number for the calendar entry.

   581 		*/ 

   582 		IMPORT_C TInt SequenceNumber();

   583 		

   584 		/**

   585 		 * Gets the entry status for the calendar entry.

   586 		 * @return void The entry status for the calendar entry.

   587 		*/ 

   588 		IMPORT_C CCalEntry::TStatus EntryStatus();

   589 		

   590 		/**

   591 		 * Gets the alarm time for the calendar entry.

   592 		 * @return void The alarm time for the calendar entry.

   593 		*/ 

   594 		IMPORT_C TTime AlarmTime();

   595 		

   596 		/**

   597 		 * Gets the phone owner for the calendar entry.

   598 		 * @return void The phone owner for the calendar entry.

   599 		*/ 

   600 		IMPORT_C TPtrC PhoneOwner();

   601 		

   602 		/**

   603 		 * Gets the method for the calendar entry.

   604 		 * @return void The method for the calendar entry

   605 		*/ 

   606 		IMPORT_C CCalEntry::TMethod Method();

   607 		

   608 		/**

   609 		 * Gets the organizer for the calendar entry.

   610 		 * @return void The organizer for the calendar entry.

   611 		*/ 

   612 		IMPORT_C CCalUser* Organizer();

   613 		

   614 		/**

   615 		 * Gets the list of attendees for the calendar entry.

   616 		 * @return RPointerArray<CCalAttendee>&

   617 		*/ 

   618 		IMPORT_C RPointerArray<CCalAttendee>& AttendeeList();

   619 		

   620 		/**

   621 		 * Gets the list of repeat dates for the calendar entry.

   622 		 * @return void

   623 		*/ 

   624 		IMPORT_C RArray<TCalTime>& RepeatDates();

   625 		

   626 		/**

   627 		 * Gets the exception dates for the calendar entry.

   628 		 * @return void

   629 		*/ 

   630 		IMPORT_C RArray<TCalTime>& ExceptionDates();

   631 		

   632 		/**

   633 		 * Gets the summary for the calendar entry.

   634 		 * @return void

   635 		*/ 

   636 		IMPORT_C TPtrC Summary();

   637 		

   638 		/**

   639 		 * Gets the description for the calendar entry.

   640 		 * @return void

   641 		*/ 

   642 		IMPORT_C TPtrC Description();

   643 		

   644 		/**

   645 		 * Gets the location for the calendar entry.

   646 		 * @return void

   647 		*/ 

   648 		IMPORT_C TPtrC Location();

   649 		

   650 		/**

   651 		 * Gets the priority for the calendar entry.

   652 		 * @return void

   653 		*/ 

   654 		IMPORT_C TInt Priority();

   655 		

   656 		/**

   657 		 * Gets the replication status for the calendar entry.

   658 		 * @return void

   659 		*/ 

   660 		IMPORT_C CCalEntry::TReplicationStatus ReplicationStatus();

   661 		

   662 		/**

   663 		 * Gets the repeat rule for the calendar entry.

   664 		 * @return void

   665 		*/ 

   666 		IMPORT_C TCalRRule& RepeatRuleL();

   667 		

   668 		/**

   669 		 * Gets the local uid for the calendar entry.

   670 		 * @return void

   671 		*/ 

   672 		IMPORT_C TCalLocalUid LocalUid();

   673 		

   674 		/**

   675 		 * Gets the attributes that have changed for the calendar entry.

   676     	 * @return A 32-bit integer indicating which attributes have been modified.

   677 		*/ 

   678 		IMPORT_C TInt32 ModifiedAttributes();

   679 	

   680 	private:

   681 	 

   682 	    /**

   683 		 * Constructor

   684 		*/ 

   685 		CEntryAttributes();

   686 		

   687 		/**

   688 		 * Constructor

   689 		*/ 

   690 		void ConstructL( const TDesC& aType );		

   691 	private:

   692 	

   693 		

   694 		/**

   695 		 * Entry type: can be an appointment, to-do item, reminder, event or anniversary

   696 	  	*/ 

   697 		CCalEntry::TType iType;

   698 		

   699 		/**

   700 		 * Start time of the entry

   701 	  	*/ 

   702 		TCalTime iStartTime;

   703 		

   704 		/**

   705 		 * End time of the entry

   706 	  	*/ 

   707 		TCalTime iEndTime;

   708 

   709         /**

   710 		 * Start time of the instance to be modified

   711 	  	*/ 

   712 		TCalTime iInstanceStartTime;

   713 

   714 		/**

   715 		 * Sequence number for the entry

   716 	  	*/ 

   717 		TInt iSequenceNum;

   718 		

   719 		/**

   720 		 * Summary for the entry

   721 	  	*/ 

   722 		HBufC* iSummary;

   723 		

   724 		/**

   725 		 * Description for the entry

   726 	  	*/ 

   727 		HBufC* iDescription;

   728 		

   729 		/**

   730 		 * Location for entry of appointment type

   731 	  	*/ 

   732 		HBufC* iLocation;

   733 		

   734 		/**

   735 		 * Alarm time for the entry

   736 	  	*/ 

   737 		TTime iAlarmTime;

   738 		

   739 		/**

   740 		 * Status of the entry: valid for entries of "appointment" and "todo" type

   741 	  	*/ 

   742 		CCalEntry::TStatus iEntryStatus;

   743 		

   744 		/**

   745 		 * Entry's method property for group scheduling

   746 	  	*/ 

   747 		CCalEntry::TMethod iMethod;

   748 		

   749 		/**

   750 		 * Replication status of the entry

   751 	  	*/ 

   752 		CCalEntry::TReplicationStatus iRepStatus;

   753 		

   754 		/**

   755 		 * Phone owner data for the entry: applicable only for entries of "appointment" type

   756 	  	*/ 

   757 		HBufC* iPhoneOwner;

   758 		

   759 		/**

   760 		 * Organizer of an appointment entry

   761 	  	*/ 

   762 		CCalUser* iOrganizer;

   763 		

   764 		/**

   765 		 * An array of out-of-sequence dates on which this entry repeats

   766 	  	*/ 

   767 		RArray<TCalTime> iRepeatDates;

   768 		

   769 		/**

   770 		 * An array of exception dates i.e occurrences in the original schedule that 

   771 		 * have been removed and may be replaced with a different occurrence

   772 	  	*/ 

   773 		RArray<TCalTime> iExDates;

   774 		

   775 		/**

   776 		 * Array of attendees of an appointment entry

   777 	  	*/ 	

   778 		RPointerArray<CCalAttendee> iAttendees;

   779 		

   780 		/**

   781 		 * The entry's repeat definition: valid for repeating entries of "appointment" type

   782 	  	*/ 

   783 		TCalRRule iRepeatRule;

   784 		

   785 		/**

   786 		 * Priority of the entry

   787 	  	*/ 

   788 		TInt iPriority;

   789 		

   790 		/**

   791 		 * Local Uid of an entry which can uniquely identify entries having the same Global Uid

   792 	  	*/ 

   793 		TCalLocalUid iLocal;

   794 		

   795 		/**

   796 		 * Indicates which entries have new values for the update operation

   797 	  	*/ 

   798 		TInt32 iSetAttributes;

   799 	};

   800 	

   801 #endif __CALENDARENTRY_H