1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <s32mem.h>

    17 #include <vtzrules.h>

    18 #include <utf.h>

    19 #include <tz.h>

    20 

    21 #include <calentry.h>

    22 #include <calcontent.h>

    23 #include <calrrule.h>

    24 #include <caluser.h>

    25 #include <calalarm.h>

    26 #include <calattachment.h>

    27 

    28 #include "agmvcal.h"

    29 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    30 #include <vpropbinaryfile.h>

    31 #endif

    32 

    33 

    34 /** Specifies number of years backward from current year for which DAYLIGHT properties are exported.*/

    35 const TInt KDaylightPropertyYearsBackwards(2);

    36 

    37 /** Specifies number of years forward from current year, or the repeat start year, for which DAYLIGHT properties are exported.*/

    38 const TInt KDaylightPropertyYearsForwards(5);

    39 

    40 

    41 // Utility method to ensure proper cleanup in OOM 

    42 //

    43 void CAgendaEntryToVCalConverter::ResetAndDestroyArrayOfParams(TAny* aObject)

    44 	{

    45 	CArrayPtr<CParserParam>* array=reinterpret_cast<CArrayPtr<CParserParam>*>(aObject);

    46 	if (array)

    47 		{

    48 		array->ResetAndDestroy();

    49 		}

    50 	delete array;

    51 	}

    52 

    53 void CAgendaEntryToVCalConverter::ResetAndDestroyArrayOfVersitDateTime(TAny* aObject)

    54 	{

    55 	CArrayPtr<TVersitDateTime>* array=reinterpret_cast<CArrayPtr<TVersitDateTime>*>(aObject);

    56 	if (array)

    57 		{

    58 		array->ResetAndDestroy();

    59 		}

    60 	delete array;

    61 	}

    62 

    63 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

    64  *	Public

    65  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    66 

    67 // Export agenda entry aEntry to the given parser

    68 //

    69 void CAgendaEntryToVCalConverter::ExportEntryL(CCalEntry* aEntry, CVersitParser& aParser)

    70 	{

    71 	CParserVCalEntity* entity = CParserVCalEntity::NewL();

    72 	CleanupStack::PushL(entity);

    73 

    74 	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

    75 		{

    76 		entity->SetEntityNameL(KVersitVarTokenVTODO);

    77 		}

    78 	else

    79 		{

    80 		entity->SetEntityNameL(KVersitVarTokenVEVENT);

    81 		}

    82 

    83 	if ((aEntry->StartTimeL()).TimeMode() == TCalTime::EFloating)

    84 		{

    85 		iTimeType = TVersitDateTime::EIsMachineLocal;

    86 		iTimeFlag = TVersitDateTime::EExportLeaveAsLocalTime;

    87 		}

    88 	else 

    89 		{

    90 		iTimeType=TVersitDateTime::EIsUTC;

    91 		iTimeFlag=TVersitDateTime::EExportTimeZoneDesignator;

    92 		}

    93 

    94 	AddEntryPropertiesL(aEntry, *entity);

    95 	CleanupStack::Pop(); // entity

    96 	aParser.AddEntityL(entity); // takes ownership

    97 	}

    98 

    99 CAgendaEntryToVCalConverter::~CAgendaEntryToVCalConverter()

   100 	{

   101 	}

   102 	

   103 

   104 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

   105  *	Private

   106  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

   107 	

   108 /** AddTzPropertyL()

   109  *

   110  *	Adds TZ property to aParser.

   111  *

   112  *	@param aParser		- a vCal entity or sub-entity (VEVENT or VTODO);

   113  *	@param aStdOffset	- standard time zone offset from UTC in seconds.

   114  */

   115 void CAgendaEntryToVCalConverter::AddTzPropertyL(CVersitParser& aParser, 

   116 												 TTimeIntervalSeconds aStdOffsetInSeconds)

   117 	{

   118 	if (!iAddedTzProperty)

   119 		{

   120 		CParserPropertyValue* vValue = new (ELeave) CParserPropertyValueTimeZone(aStdOffsetInSeconds);

   121 		CleanupStack::PushL(vValue);

   122 

   123 		CParserProperty* vProp = CParserProperty::NewL(*vValue, KVersitTokenTZ, NULL); 

   124 		CleanupStack::Pop(vValue);

   125 

   126 		aParser.AddPropertyL(vProp);

   127 		}

   128 	iAddedTzProperty = ETrue;

   129 	}

   130 

   131 

   132 /** MapToRelativeTime()

   133  *

   134  *	Provides mapping between iTimeReference of TVTzActualisedRule and iRelativeTime of TVersitDateTime. 

   135  *

   136  *	CTzRules::AddActualisedRulesL() guarantees that TVTzActualisedRule is always UTC or 

   137  *	local(ETzWallTimeReference), and is never STD. The func maps everything to 

   138  *	TVersitDateTime::EIsMachineLocal, unless iTimeReference is ETzUtcTimeReference, which is mapped

   139  *  to TVersitDateTime::EIsUTC.

   140  *

   141  *	This is local helper function.

   142  *	Used exclusively by CAgendaEntryToVCalConverter::AddTimeZonePropertiesL() to export DAYLIGHT properties.

   143  */

   144 static inline TVersitDateTime::TRelativeTime MapToRelativeTime(TTzTimeReference& aTzTimeRef)

   145 	{

   146 	return (aTzTimeRef==ETzUtcTimeReference) ? (TVersitDateTime::EIsUTC) : (TVersitDateTime::EIsMachineLocal);

   147 	}

   148 

   149 /*	AddDaylightPropertyL()

   150  *

   151  *	Export a DAYLIGHT property to describe the daylight saving period and its offset.

   152  *	There can be more than one DAYLIGHT property for a year (depenging on number of DST rules for the year).  

   153  *	Time designators (i.e EST, EDT) are not exported.

   154  *

   155  *	@param aParser		- a vCal entity or sub-entity (VEVENT or VTODO);

   156  *	@param aOffsetInSeconds	 - offset in seconds from UTC (i.e. STD + DST) for the period when the 

   157  					 	  daylight saving rule is in effect, 

   158  						  for instance, for time zone "Vancouver/America (PST)" aOffsetInSeconds is

   159  						  -480*60=-28800 secs in winter time, and -420*60=-25200 secs when DST is observed; 

   160  *	@param aStartTime	- exact time when a rule starts (usually 02:00:00 local time);

   161  *	@param aEndTime		- time when rule ends (usually 03:00:00 local time).

   162  */

   163 void CAgendaEntryToVCalConverter::AddDaylightPropertyL(CVersitParser& aParser, 

   164 													   TTimeIntervalSeconds aOffsetInSeconds,

   165 													   TTimeWithReference aStartTime,

   166 													   TTimeWithReference aEndTime)

   167 	{

   168 	TVersitDateTime* vStartTime = new(ELeave) TVersitDateTime(aStartTime.iTime.DateTime(),

   169 															  MapToRelativeTime(aStartTime.iTimeReference));

   170 	CleanupStack::PushL(vStartTime);

   171 

   172 	TVersitDateTime* vEndTime = new (ELeave) TVersitDateTime(aEndTime.iTime.DateTime(),

   173 															  MapToRelativeTime(aEndTime.iTimeReference));

   174 	CleanupStack::PushL(vEndTime);

   175 

   176 	CVersitDaylight* vDaylight = CVersitDaylight::NewL(ETrue, 

   177 													  aOffsetInSeconds, 

   178 													  vStartTime, 

   179 													  vEndTime, 

   180 													  KNullDesC(), 

   181 													  KNullDesC());

   182 	

   183 	CleanupStack::Pop(vEndTime);   // CVersitDaylight takes ownership.

   184 	CleanupStack::Pop(vStartTime); // CVersitDaylight takes ownership.

   185 

   186 	CleanupStack::PushL(vDaylight);

   187 	CParserPropertyValue* vValue = new (ELeave) CParserPropertyValueDaylight(vDaylight);

   188 	CleanupStack::Pop(vDaylight);

   189 

   190 	CleanupStack::PushL(vValue);

   191 	CParserProperty* vProp = CParserProperty::NewL(*vValue, KVersitTokenDAYLIGHT, NULL); 

   192 	CleanupStack::Pop(vValue);

   193 

   194 	aParser.AddPropertyL(vProp);

   195 	}

   196 

   197 

   198 /**	Adds DAYLIGHT properties for a range of years from aStartYear to aEndYear inclusive to 

   199  *	a vCalendar entity (aParser).

   200  *	

   201  *	@param aParser		- a vCalendar object where properties added

   202  *	@param aRules		- time zone rules used to retrieve DST information

   203  *	@param aRepeatStartTime		- start of entry range, including the repeat rule

   204  *	@param aRepeatEndTime		- end of entry range, including the repeat rule

   205  *

   206  */

   207 void CAgendaEntryToVCalConverter::AddDaylightPropertiesL(CVersitParser& aParser, const CTzRules* aRules, TInt aStdOffset, TTime aRepeatStartTime, TTime aRepeatEndTime)

   208 	{

   209 	const TInt KRepeatStartYear = aRepeatStartTime.DateTime().Year();

   210 	const TInt KRepeatEndYear = aRepeatEndTime.DateTime().Year();

   211 	

   212  	// actualise the rules starting a year before our period of interest

   213 	CVTzActualisedRules* actRules = CVTzActualisedRules::NewL(KRepeatStartYear - 1, KRepeatEndYear + 1);

   214 	

   215 	if (actRules)

   216 		{

   217 		CleanupStack::PushL(actRules);

   218 		aRules->GetActualisedRulesL(*actRules);

   219 		

   220 		TTime now;

   221 		now.HomeTime();

   222 		const TInt KThisYear = now.DateTime().Year();

   223 		

   224 		// Set up the time range for exported DAYLIGHT properties

   225 		const TInt KRangeBeginYear(Max(KThisYear - KDaylightPropertyYearsBackwards, KRepeatStartYear));

   226 		const TInt KRangeEndYear(Min(Max(KThisYear + KDaylightPropertyYearsForwards, KRepeatStartYear + KDaylightPropertyYearsForwards), KRepeatEndYear + 1));

   227 		const TTime KRangeBeginTime(TDateTime(KRangeBeginYear, EJanuary, 0, 0, 0, 0, 0));

   228 		const TTime KRangeEndTime(TDateTime(KRangeEndYear, EJanuary, 0, 0, 0, 0, 0));

   229 		

   230 		const TInt KRulesCount(actRules->Count());

   231 		for (TInt i(0) ; i < KRulesCount - 1 ; ++i)

   232 			{

   233 			TVTzActualisedRule& actRule = (*actRules)[i];

   234 			

   235 			if (aStdOffset < actRule.iNewOffset)		// work with DST rules only

   236 				{

   237 				// End time of a rule is start time of the next rule

   238 				TVTzActualisedRule& actRuleNext = (*actRules)[i+1];

   239 				

   240 				TTimeWithReference ruleStart(TTimeWithReference(actRule.iTimeOfChange, actRule.iTimeReference));

   241 				TTimeWithReference ruleEnd(TTimeWithReference(actRuleNext.iTimeOfChange, actRuleNext.iTimeReference));

   242 				

   243 				TTime ruleStartTime = ruleStart.iTime;

   244 				TTime ruleEndTime = ruleEnd.iTime;

   245 				

   246 				if (actRule.iTimeReference == ETzStdTimeReference)

   247 					{

   248 					ruleStartTime -= TTimeIntervalMinutes(aRules->InitialStdTimeOffset());

   249 					}

   250 				else if (actRule.iTimeReference == ETzWallTimeReference)

   251 					{

   252 					ruleStartTime -= TTimeIntervalMinutes(actRule.iNewOffset);

   253 					}						

   254 

   255 				if (actRule.iTimeReference == ETzStdTimeReference)

   256 					{

   257 					ruleEndTime -= TTimeIntervalMinutes(aRules->InitialStdTimeOffset());

   258 					}

   259 				else if (actRule.iTimeReference == ETzWallTimeReference)

   260 					{

   261 					ruleEndTime -= TTimeIntervalMinutes(actRule.iNewOffset);

   262 					}	

   263 				

   264 				// Export rule if the first instance occours when dst is on

   265 				// or if the rule covers the range defined above

   266 				if ( (aRepeatStartTime >= ruleStartTime) && (aRepeatStartTime <= ruleEndTime) || (ruleEndTime >= KRangeBeginTime) && (ruleStartTime <= KRangeEndTime) )

   267 					{

   268 					// Export DAYLIGHT property for concrete DST rule

   269 					AddDaylightPropertyL(aParser, actRule.iNewOffset * 60, ruleStart, ruleEnd);

   270 					}

   271 				}

   272 			}

   273 		CleanupStack::PopAndDestroy(actRules);

   274 		}

   275 	}

   276 

   277 void CAgendaEntryToVCalConverter::NextVCalendarL()

   278 	{

   279 	iAddedTzProperty = EFalse;

   280 	}

   281 

   282 /**	CAgendaEntryToVCalConverter::AddTimeZonePropertiesL()

   283  *	 	

   284  *	Adds TZ and DAYLIGHT properties to a vCalendar entity. 

   285  *

   286  *	@param aEntry 	- an agenda entry which supplies timezone and tz rules information 

   287  *						(has to have a repeat definition, otherwise function will do nothing);

   288  *	@param aParser	- a vCalendar object to which the properties are added. 

   289  *	

   290  *	aParser can be 1) a vCalendar object (also referrred to as "vCalendar entity"), 

   291  *		as well as 2) a vEvent or vTodo objects (also referred to as "vCalendar sub-entities").

   292  *	

   293  *	TZ and DAYLIGHT properties (as per vCalendar v1.0 spec) apply to the vCalendar object as a whole; UNLESS 

   294  *	overriden by a property within the scope of an event or todo entity.

   295  *	

   296  *	@internalComponent

   297  */

   298 void CAgendaEntryToVCalConverter::AddTimeZonePropertiesL(CVersitParser& aParser, CCalEntry* aEntry)

   299 	{

   300 	TCalRRule rrule;

   301 	

   302   	if (aEntry->GetRRuleL(rrule) && aEntry->StartTimeL().TimeMode() != TCalTime::EFloating)

   303 		{

   304 		// Only export the TZ property when the entry is repeating.

   305 		// Do not export TZ rules for floating entry.

   306 		CTzRules* rules = aEntry->TzRulesL();

   307 		

   308 		if (rules)

   309 			{

   310     		CleanupStack::PushL( rules );

   311 

   312             // find the standard offset for this time zone

   313             // which is the lowest offset from the rules for the entry's repeat range

   314             CVTzActualisedRules* actRules = CVTzActualisedRules::NewL(rrule.DtStart().TimeUtcL().DateTime().Year() - 1, rrule.Until().TimeUtcL().DateTime().Year() + 1);

   315         	CleanupStack::PushL(actRules);

   316         	rules->GetActualisedRulesL(*actRules);

   317         	

   318         	TInt stdOffset(KMaxTInt);

   319         	

   320         	const TInt KRulesCount = actRules->Count();

   321         	for (TInt i(0) ; i < KRulesCount ; ++i)

   322         		{

   323         		if ((*actRules)[i].iNewOffset < stdOffset)

   324         			{

   325         			stdOffset = (*actRules)[i].iNewOffset;

   326         			}

   327         		}

   328         	

   329         	if (stdOffset == KMaxTInt)

   330         		{

   331         		// there were no offsets found so use the current system utc offset

   332         		stdOffset = (User::UTCOffset().Int() / 60);

   333         		}

   334         	

   335         	CleanupStack::PopAndDestroy(actRules);

   336 			AddTzPropertyL(aParser, stdOffset * 60);

   337 			AddDaylightPropertiesL(aParser, rules, stdOffset, rrule.DtStart().TimeUtcL(), rrule.Until().TimeUtcL());

   338             

   339 			CleanupStack::PopAndDestroy(rules);	

   340 			}

   341 		}

   342 	}

   343 

   344 // This function specifies the ordering of the vCalendar properties as exported by Versit.

   345 //

   346 // The UID property should be the first property. 

   347 //

   348 // The following three properties of a vCalendar should be DESCRIPTION, DTSTART and DTEND for appointments, 

   349 // anniversaries & events. To-do entries should have DESCRIPTION and DUE as the following two properties.

   350 // This is to assist processing by Connectivity (as requested by Time Technology)

   351 //

   352 void CAgendaEntryToVCalConverter::AddEntryPropertiesL(CCalEntry* aEntry, CVersitParser& aParser)

   353 	{

   354 	// UID 

   355 

   356 	HBufC* guid16 = HBufC::NewLC(aEntry->UidL().Length());

   357 	TPtr ptr16 = guid16->Des();

   358 	CnvUtfConverter::ConvertToUnicodeFromUtf8(ptr16, aEntry->UidL());

   359 	AddDesPropertyL(aParser, KVersitTokenUID, guid16->Des());

   360 	CleanupStack::PopAndDestroy(guid16);

   361 		

   362 	// CAgnEntry::RichTextL()	=> SUMMARY 

   363 	// CAgnEntry::NotesTextL()	=> DESCRIPTION 

   364 

   365 	if (aEntry->DescriptionL().Length() > 0)

   366 		{

   367 		AddDesPropertyL(aParser, KVersitTokenDESCRIPTION, aEntry->DescriptionL());					

   368 		}

   369 		

   370 	if (aEntry->SummaryL().Length() > 0)

   371 		{

   372 		AddDesPropertyL(aParser, KVersitTokenSUMMARY, aEntry->SummaryL());

   373 		}

   374 

   375 	// Add DTSTART and DTEND (or DUE, PRIORITY and todo list information for to-do items), then add X-EPOCAGENDAENTRYTYPE

   376 	switch (aEntry->EntryTypeL())

   377 		{

   378 		case CCalEntry::EAppt:

   379 			{

   380 			AddEventPropertiesL(aParser, aEntry);

   381 			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeAPPT);	

   382 			break;

   383 			}

   384 		case CCalEntry::EReminder:

   385 			{

   386 			AddEventPropertiesL(aParser, aEntry);

   387 			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeREMINDER);	

   388 			break;

   389 			}

   390 		case CCalEntry::EAnniv:

   391 			{

   392 			AddEventPropertiesL(aParser, aEntry);

   393 			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeANNIV);

   394 			break;

   395 			}

   396 		case CCalEntry::EEvent:

   397 			{

   398 			AddEventPropertiesL(aParser, aEntry);

   399 			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeEVENT);

   400 			break;

   401 			}

   402 		case CCalEntry::ETodo:

   403 			{

   404 			AddTodoPropertiesL(aParser, aEntry);

   405 			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeTODO);

   406 			break;

   407 			}

   408 		default: break;

   409 		}

   410 

   411 	// Class

   412 	CCalEntry::TReplicationStatus status = aEntry->ReplicationStatusL();

   413 	switch(status)

   414 		{

   415 		case CCalEntry::EOpen:

   416 			AddDesPropertyL(aParser, KVersitTokenCLASS, KVCalTokenPUBLIC);

   417 			break;

   418 		case CCalEntry::EPrivate:

   419 			AddDesPropertyL(aParser, KVersitTokenCLASS, KVCalTokenPRIVATE);

   420 			break;

   421 		case CCalEntry::ERestricted:

   422 			AddDesPropertyL(aParser, KVersitTokenCLASS, KVCalTokenCONFIDENTIAL);

   423 			break;

   424 		}

   425 

   426 	// Location

   427 	const TDesC& location = aEntry->LocationL();

   428 	if (location.Length() != 0)

   429 		{

   430 		AddDesPropertyL(aParser, KVersitTokenLOCATION, location);

   431 		}

   432 

   433 	// DTSTAMP

   434 	TCalTime dTStamp = aEntry->DTStampL();

   435 		

   436    	if ( dTStamp.TimeUtcL() != Time::NullTTime() )

   437       	{	

   438 		AddDateTimePropertyL(aParser, KVersitTokenXDTSTAMP, dTStamp.TimeUtcL(), TVersitDateTime::EIsUTC, iTimeFlag);

   439       	}

   440 	

   441 	// Sequence Number

   442 	AddIntegerPropertyL(aParser, KVersitTokenSEQUENCE, aEntry->SequenceNumberL());

   443 

   444 	//X-Method property

   445 	CCalEntry::TMethod methodStatus = aEntry->MethodL();

   446 	TPtrC methodStr;

   447 	switch(methodStatus)

   448 		{

   449 		case  CCalEntry::EMethodNone:

   450 			methodStr.Set(KVCalTokenMethodStatusENone);

   451 			break;

   452 		case CCalEntry::EMethodPublish:

   453 			methodStr.Set(KVCalTokenMethodStatusEPublish);

   454 			break;

   455 		case CCalEntry::EMethodRequest:

   456 			methodStr.Set(KVCalTokenMethodStatusERequest);

   457 			break;

   458 		case CCalEntry::EMethodReply:

   459 			methodStr.Set(KVCalTokenMethodStatusEReply);

   460 			break;

   461 		case CCalEntry::EMethodAdd:

   462 			methodStr.Set(KVCalTokenMethodStatusEAdd);

   463 			break;

   464 		case CCalEntry::EMethodCancel:

   465 			methodStr.Set(KVCalTokenMethodStatusECancel);

   466 			break;

   467 		case CCalEntry::EMethodRefresh:

   468 			methodStr.Set(KVCalTokenMethodStatusERefresh);

   469 			break;

   470 		case CCalEntry::EMethodCounter:

   471 			methodStr.Set(KVCalTokenMethodStatusECounter);

   472 			break;

   473 		case CCalEntry::EMethodDeclineCounter:

   474 			methodStr.Set(KVCalTokenMethodStatusEDeclineCounter);

   475 			break;	

   476 		default:

   477 			User::Leave(KErrArgument);	

   478 		}

   479 

   480 	AddDesPropertyL(aParser, KVersitTokenXMETHOD, methodStr);

   481 	// X-Recurrence-ID

   482 	TCalTime recurrenceDate = aEntry->RecurrenceIdL();

   483 	

   484 	if (recurrenceDate.TimeUtcL() != Time::NullTTime())

   485 		{

   486 		TTime recId;

   487 		if(iTimeType==TVersitDateTime::EIsUTC)

   488 			{

   489 			recId = recurrenceDate.TimeUtcL();

   490 			}

   491 		else

   492 			{

   493 			recId = recurrenceDate.TimeLocalL();

   494 			}

   495 		AddDateTimePropertyL(aParser, KVersitTokenXRECURRENCEID, recId, iTimeType, iTimeFlag);	

   496 		}

   497 		

   498 	// Attendees

   499 	RPointerArray<CCalAttendee> attendees = aEntry->AttendeesL();

   500 

   501 	TInt count=attendees.Count();

   502 	CCalUser* phoneowner=aEntry->PhoneOwnerL();

   503 	for (TInt ii=0; ii<count; ii++)

   504 		{

   505 		if(phoneowner==attendees[ii])

   506 			{

   507 			AddAttendeePropertyL(aParser, attendees[ii],ETrue, EFalse);

   508 			}

   509 		else

   510 			{

   511 			AddAttendeePropertyL(aParser, attendees[ii],EFalse, EFalse);

   512 			}

   513 		

   514 		}

   515 

   516 	CCalUser* organizer=aEntry->OrganizerL();

   517 	if(organizer)

   518 		{

   519 		if(phoneowner==organizer)

   520 			{

   521 			AddAttendeePropertyL(aParser, organizer,ETrue, ETrue);

   522 			}

   523 		else

   524 			{

   525 			AddAttendeePropertyL(aParser, organizer,EFalse, ETrue);

   526 			}

   527 		}

   528 

   529 	// Recurrence details

   530 	TCalRRule rule;

   531 	TBool isrepeat = aEntry->GetRRuleL(rule);

   532 	if (isrepeat)

   533 		{

   534 		CTzRules* repeatRule = aEntry->TzRulesL();

   535 		CleanupStack::PushL(repeatRule);

   536 		AddRepeatPropertiesL(aParser, rule, repeatRule);

   537 		CleanupStack::PopAndDestroy(repeatRule);

   538 		}

   539 		

   540 	// RDates

   541 	RArray<TCalTime>rdates;

   542 	CleanupClosePushL(rdates);

   543 	aEntry->GetRDatesL(rdates);

   544 

   545 	if (rdates.Count()>0)

   546 		{

   547 		AddRDatePropertyL(aParser, rdates);

   548 		isrepeat = ETrue;

   549 		}

   550 		

   551 	CleanupStack::PopAndDestroy(&rdates);

   552 

   553 	if (isrepeat)

   554 		{

   555 		// Recurrence Exception details

   556 		RArray<TCalTime> exceptions;

   557 		CleanupClosePushL(exceptions);

   558 		aEntry->GetExceptionDatesL(exceptions);

   559 

   560 		if (exceptions.Count()>0)

   561 			{

   562 			AddRepeatExceptionPropertiesL(aParser, exceptions);

   563 			}

   564 		CleanupStack::PopAndDestroy(&exceptions);

   565 		}

   566 		

   567 	// Alarm

   568 	CCalAlarm* alarm = aEntry->AlarmL();

   569 	if (alarm)

   570 		{

   571 		TCalTime alarmOrigin;

   572 		CleanupStack::PushL(alarm);

   573 		if(aEntry->EntryTypeL()==CCalEntry::ETodo && (aEntry->EndTimeL()).TimeUtcL()!=Time::NullTTime())

   574 			{

   575 			alarmOrigin = aEntry->EndTimeL();

   576 			}

   577 		else

   578 			{

   579 			alarmOrigin = aEntry->StartTimeL();

   580 			}

   581 		

   582 		TTime alarmtime;

   583 		if (aEntry->StartTimeL().TimeMode() != TCalTime::EFloating)

   584 			{

   585 			alarmtime = alarmOrigin.TimeUtcL() - TTimeIntervalMinutes(alarm->TimeOffset());

   586 			}

   587 		else

   588 			{

   589 			alarmtime = alarmOrigin.TimeLocalL() - TTimeIntervalMinutes(alarm->TimeOffset());

   590 			}

   591 		AddAlarmPropertyL(aParser, KVersitTokenAALARM, alarmtime, alarm->AlarmSoundNameL());

   592 		

   593 

   594 		CCalContent* alarmAction = alarm->AlarmAction();

   595 		if (alarmAction != NULL)

   596 			{

   597 			AddExtendedAlarmPropertyL(aParser, KVersitTokenXALARM, *alarmAction);

   598 			}

   599 		CleanupStack::PopAndDestroy(alarm);

   600 		}

   601 

   602 	// Add Last Changed Date

   603 	AddDateTimePropertyL(aParser, KVersitTokenLASTMODIFIED, (aEntry->LastModifiedDateL()).TimeUtcL(), TVersitDateTime::EIsUTC, iTimeFlag);

   604 

   605 	// Category Support

   606 	const RPointerArray<CCalCategory>& categories = aEntry->CategoryListL();

   607 

   608 	if (categories.Count()>0)

   609 		{

   610 		AddCategoryPropertyL(aParser, categories);

   611 		}

   612 

   613 	// ADDITION FOR VERSIT COMPLIANCE 

   614 	// Merged priorities into one place - ToDo priority was previously in AddTodoPropertiesL()

   615 	TInt priority = aEntry->PriorityL();

   616 	AddIntegerPropertyL(aParser, KVersitTokenPRIORITY, priority);

   617 	if (aEntry->EntryTypeL() != CCalEntry::ETodo)

   618 		{

   619 		AddStatusPropertyL(aParser, aEntry);

   620 		}

   621 	AddIntegerPropertyL(aParser, KVersitTokenXLOCALUID, aEntry->LocalUidL());

   622 	AddIntegerPropertyL(aParser, KVersitTokenTRANSP, aEntry->TimeTransparencyL());

   623 	

   624 	// Add GEO

   625 	CCalGeoValue* geoValue = aEntry->GeoValueL();

   626 	

   627 	// Check that the GEO values are not NULL

   628 	if(geoValue)

   629 		{

   630 		CleanupStack::PushL(geoValue);

   631 		

   632 		TReal geoLatitude;

   633 		TReal geoLongitude;

   634 		

   635 		// Extract latitude and longitude values

   636 		// Check if it returns EFalse

   637 		geoValue->GetLatLong(geoLatitude,geoLongitude);

   638 		

   639 		// Convert the geo values from numbers to string

   640 		// Create GEO string buffer to be constructed from a latitude, delimiter and a longitude value

   641 		TBuf<KGEOMaxWidthOfGeoValue*2+1> geoString;

   642 		TBuf<KGEOMaxWidthOfGeoValue> geoLatString;

   643 		TBuf<KGEOMaxWidthOfGeoValue> geoLongString;

   644 		

   645 		// Maximum width of a GEO value and max number of decimal places

   646 		TRealFormat geoFormat(KGEOMaxWidthOfGeoValue,KCalGEOMaxDecimalPlaces);

   647 		

   648 		_LIT(KGeoStringFormat,"%S%c%S");

   649 		

   650 		// Ensure correct conversion from stored numeric values to descriptors

   651 		if((geoLatString.Num(geoLatitude,geoFormat)>0) && (geoLongString.Num(geoLongitude,geoFormat)>0))

   652 			{

   653 			geoString.AppendFormat(KGeoStringFormat,&geoLatString,KVersitTokenCommaVal,&geoLongString);

   654 			

   655 			// Add the GEO property

   656 			AddDesPropertyL(aParser,KVersitTokenGEO,geoString);

   657 			}

   658 		

   659 		CleanupStack::PopAndDestroy(geoValue);

   660 		}

   661 		

   662 	TUint attachCount = aEntry->AttachmentCountL();

   663 	for(TInt ii = 0; ii<attachCount; ++ii)

   664 		{

   665 		CCalAttachment* attach = aEntry->AttachmentL(ii);

   666 		AddAttachmentPropertyL(aParser, *attach);

   667 		}

   668 	}

   669 

   670 

   671 // Add appointment properties to parser

   672 //

   673 void CAgendaEntryToVCalConverter::AddEventPropertiesL(CVersitParser& aParser, CCalEntry* aEntry)

   674 	{

   675 	//If this is an untimed appt the start time will be the default start time

   676  	//If the alarm time is *after* this time we need to move the start time to the alarm time

   677 	TTime startTime; 

   678 	TTime endTime; 

   679 	if((aEntry->StartTimeL()).TimeMode() == TCalTime::EFloating )

   680 		{

   681 		startTime = (aEntry->StartTimeL()).TimeLocalL();

   682 		if(aEntry->EntryTypeL()==CCalEntry::EReminder)

   683 			{

   684 			endTime = startTime;

   685 			}

   686 		else

   687 			{

   688 			endTime =(aEntry->EndTimeL()).TimeLocalL();

   689 			}

   690 

   691 		}

   692 	else 	

   693 		{

   694 		startTime = (aEntry->StartTimeL()).TimeUtcL();

   695 		if(aEntry->EntryTypeL()==CCalEntry::EReminder)

   696 			{

   697 			endTime = startTime;

   698 			}

   699 		else

   700 			{

   701 			endTime = (aEntry->EndTimeL()).TimeUtcL();

   702 			}

   703 

   704 		}

   705 	

   706 	iStartTime=startTime.DateTime();

   707 

   708 

   709 	AddDateTimePropertyL(aParser, KVersitTokenDTSTART, startTime, iTimeType, iTimeFlag);

   710 	AddDateTimePropertyL(aParser, KVersitTokenDTEND, endTime, iTimeType, iTimeFlag);

   711 	}

   712 

   713 // Add todo properties

   714 //

   715 void CAgendaEntryToVCalConverter::AddTodoPropertiesL(CVersitParser& aParser, CCalEntry* aEntry)

   716 	{

   717 	TBool isUtc = ETrue;

   718 	if ((aEntry->EndTimeL()).TimeUtcL() != Time::NullTTime())

   719 		{

   720 		if ((aEntry->StartTimeL()).TimeMode() == TCalTime::EFloating)

   721 			{

   722 			isUtc = EFalse;

   723 			AddDateTimePropertyL(aParser, KVersitTokenDUE, (aEntry->EndTimeL()).TimeLocalL(), iTimeType, iTimeFlag);

   724 			}

   725 		else

   726 			{

   727 			AddDateTimePropertyL(aParser, KVersitTokenDUE, (aEntry->EndTimeL()).TimeUtcL(), iTimeType, iTimeFlag);

   728 			}

   729 		}

   730 

   731 	// Add todo name list is now done with rest of category implementation	

   732 	TTime startDate; 

   733 	

   734 	if (isUtc)

   735 		{

   736 		startDate = aEntry->StartTimeL().TimeUtcL();

   737 		}

   738 	else

   739 		{

   740 		startDate = aEntry->StartTimeL().TimeLocalL();

   741 		}

   742 	iStartTime=startDate.DateTime();

   743 	

   744 	// We have already checked the start and end times so we do not need 

   745 	// further checks here. After discussion with MV.

   746 	if (startDate != Time::NullTTime())

   747 		{

   748 		AddDateTimePropertyL(aParser, KVersitTokenDTSTART, startDate, iTimeType, iTimeFlag);

   749 		}

   750 

   751 	// Is the entry completed - if so export completed date/time and COMPLETED status

   752 	if ((aEntry->CompletedTimeL()).TimeUtcL() != Time::NullTTime())

   753 		{

   754 		AddDateTimePropertyL(aParser,KVCalTokenCOMPLETED, (aEntry->CompletedTimeL()).TimeUtcL(), TVersitDateTime::EIsUTC, iTimeFlag);

   755 		AddDesPropertyL(aParser, KVCalTokenSTATUS, KVCalStatusCOMPLETED);

   756 		}

   757 	else

   758 		{

   759 		if (aEntry->StatusL()==CCalEntry::ETodoCompleted)

   760 			{

   761 			// If entry status is COMPLETED, ensure COMPLETED date is exported too

   762 			if ((aEntry->EndTimeL()).TimeUtcL()!= Time::NullTTime())

   763 				{

   764 				aEntry->SetCompletedL(ETrue,aEntry->EndTimeL());

   765 				}

   766 			else

   767 				{

   768 				//No valid due date, set the completed date to the today's date

   769 				TTime today;

   770 				today.UniversalTime();

   771 				TCalTime caltime;

   772 				caltime.SetTimeUtcL(today);

   773 				aEntry->SetCompletedL(ETrue, caltime);

   774 				}

   775 			AddDateTimePropertyL(aParser,KVCalTokenCOMPLETED, (aEntry->CompletedTimeL()).TimeUtcL(), TVersitDateTime::EIsUTC, iTimeFlag);

   776 			AddDesPropertyL(aParser, KVCalTokenSTATUS, KVCalStatusCOMPLETED);

   777 			}

   778 		else

   779 			{

   780 			// Entry is not completed and doesn't have status==Completed

   781 			// So, add status property as normal

   782 			AddStatusPropertyL(aParser,aEntry);

   783 			}

   784 

   785 		}

   786 		

   787 	}

   788 

   789 // Construct an integer property

   790 //

   791 void CAgendaEntryToVCalConverter::AddIntegerPropertyL(CVersitParser& aParser, const TDesC8& aToken, TCalLocalUid aInt)

   792 	{

   793 	CParserPropertyValue* value = new(ELeave)CParserPropertyValueInt(aInt);

   794 	CleanupStack::PushL(value);

   795 	CParserProperty* prop = CParserProperty::NewL(*value, aToken, NULL); 

   796 	CleanupStack::Pop(value);	

   797 	// Add to the parser

   798 	aParser.AddPropertyL(prop);

   799 	}

   800 

   801 void CAgendaEntryToVCalConverter::AddDateTimePropertyL(CVersitParser& aParser, const TDesC8& aToken, const TTime& aTime, const TVersitDateTime::TRelativeTime aRelativeTime, TVersitDateTime::TVersitDateTimeFlags aTimeFlag)

   802 	{

   803 	// Construct a date-time property

   804 	TVersitDateTime* versitDateTime = new(ELeave)TVersitDateTime(aTime.DateTime(), aRelativeTime);

   805 	CleanupStack::PushL(versitDateTime);

   806 	CParserPropertyValue* value = new(ELeave)CParserPropertyValueDateTime(versitDateTime);

   807 	CleanupStack::Pop(versitDateTime);

   808 	versitDateTime->SetFlag(aTimeFlag);

   809 	

   810 	CleanupStack::PushL(value);

   811 	CParserProperty* prop = CParserProperty::NewL(*value, aToken, NULL);

   812 	CleanupStack::Pop(value);

   813 	// Add to the parser

   814 	aParser.AddPropertyL(prop);

   815 

   816 	}

   817 

   818 void CAgendaEntryToVCalConverter::AddDesPropertyL(CVersitParser& aParser, const TDesC8& aToken, const TDesC& aDes)

   819 	{

   820 	HBufC* buf=AgnConvertUtil::EncodeL(aDes,KUidEtextToText);

   821 	CleanupStack::PushL(buf);

   822 	CParserPropertyValue* value = CParserPropertyValueHBufC::NewL(buf->Des());

   823 	CleanupStack::PopAndDestroy(buf);

   824 	CleanupStack::PushL(value);

   825 	CParserProperty* prop = CParserProperty::NewL(*value, aToken, NULL);

   826 	CleanupStack::Pop(value);

   827 	// Add to the parser

   828 	aParser.AddPropertyL(prop);

   829 	}

   830 

   831 void CAgendaEntryToVCalConverter::AddAlarmPropertyL(CVersitParser& aParser, const TDesC8& aToken, const TTime& aAlarmTime, const TDesC& aAlarmName)

   832 	{

   833 	// Create an array of paramaters for this property

   834 	CArrayPtr<CParserParam>* arrayOfParams = new(ELeave)CArrayPtrFlat<CParserParam>(4);

   835 	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfParams,arrayOfParams));

   836 

   837 	CParserParam* typeParam = CParserParam::NewL(KVCalToken8TYPE, KNullDesC8);

   838 	CleanupStack::PushL(typeParam);

   839 	typeParam->SetValueL(KVCalValue8EPOCSOUND);

   840 	arrayOfParams->AppendL(typeParam); // takes ownership

   841 	CleanupStack::Pop(typeParam);

   842 

   843 	// Construct a date-time property

   844 	

   845 	TVersitDateTime* versitDateTime = new(ELeave)TVersitDateTime(aAlarmTime.DateTime(), iTimeType);

   846 	CleanupStack::PushL(versitDateTime);

   847 

   848 	CVersitAlarm* alarm = CVersitAlarm::NewL(versitDateTime, NULL, 0, aAlarmName, TPtrC());

   849 	CleanupStack::Pop(versitDateTime);

   850 	versitDateTime->SetFlag(iTimeFlag);

   851 	CleanupStack::PushL(alarm);

   852 	CParserPropertyValue* value = new(ELeave)CParserPropertyValueAlarm(alarm);

   853 	CleanupStack::Pop(alarm);

   854 	CleanupStack::PushL(value);

   855 

   856 	CParserProperty* prop = CParserProperty::NewL(*value, aToken, arrayOfParams);

   857 	CleanupStack::Pop(2,arrayOfParams); // value, arrayOfParams

   858 

   859 	// Add to the parser

   860 	aParser.AddPropertyL(prop);

   861 	}

   862 

   863 void CAgendaEntryToVCalConverter::AddExtendedAlarmPropertyL(CVersitParser& aParser, const TDesC8& aToken, const CCalContent& aAlarmAction)

   864 	{

   865 	// Create an array of parameters for this property

   866 	CArrayPtr<CParserParam>* arrayOfParams = new(ELeave)CArrayPtrFlat<CParserParam>(4);

   867 	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfParams,arrayOfParams));

   868 	

   869 	// Create content disposition parameter

   870 	CParserParam* dispositionParam = CParserParam::NewL(KVersitTokenVALUE, KNullDesC8);

   871 	CleanupStack::PushL(dispositionParam);

   872 	CCalContent::TDisposition disposition = aAlarmAction.Disposition();

   873 	switch (disposition)

   874 		{

   875 		case CCalContent::EDispositionUrl:

   876 			{

   877 			dispositionParam->SetValueL(KVCalContentValueUrl);

   878 			break;

   879 			}

   880 		case CCalContent::EDispositionInline:

   881 			{

   882 			dispositionParam->SetValueL(KVCalContentValueInline);

   883 			break;

   884 			}

   885 		default:

   886 			{

   887 			// In the default case, the property is unsupported. So we'll clean up

   888 			// and then return

   889 			CleanupStack::PopAndDestroy(2); //arrayOfParams, dispositionParam

   890 			return;

   891 			}

   892 		}

   893 	arrayOfParams->AppendL(dispositionParam); // takes ownership

   894 	CleanupStack::Pop(dispositionParam);

   895 

   896 	// Create content MIME type parameter

   897 	CParserParam* mimeTypeParam = CParserParam::NewL(KVersitTokenCONTENTTYPE, KNullDesC8);

   898 	CleanupStack::PushL(mimeTypeParam);

   899 	TPtrC8 mimeType(aAlarmAction.MimeType());

   900 	mimeTypeParam->SetValueL(mimeType);

   901   	arrayOfParams->AppendL(mimeTypeParam);

   902   	CleanupStack::Pop(mimeTypeParam);

   903   	

   904   	

   905 	// Construct X-EPOC-ALARM property and initialise with parameters and content

   906 	CVersitExtendedAlarm* alarm = CVersitExtendedAlarm::NewL(aAlarmAction.Content(), aAlarmAction.MimeType(), static_cast<CVersitExtendedAlarm::TDisposition>(aAlarmAction.Disposition()));

   907 	CleanupStack::PushL(alarm);

   908 	CParserPropertyValue* value = new(ELeave)CParserPropertyValueExtendedAlarm(alarm);

   909 	CleanupStack::Pop(alarm);

   910 	CleanupStack::PushL(value);

   911 	CParserProperty* prop = CParserProperty::NewL(*value, aToken, arrayOfParams);

   912 	CleanupStack::Pop(2,arrayOfParams); // value, arrayOfParams

   913 

   914 	// Add to the parser

   915 	aParser.AddPropertyL(prop); // takes ownership of prop

   916 	}

   917 

   918 void CAgendaEntryToVCalConverter::AddAttachmentPropertyL(CVersitParser& aParser, CCalAttachment& aAttachment)

   919 	{

   920 	// Create an array of parameters for this property

   921 	CArrayPtr<CParserParam>* arrayOfParams = new(ELeave)CArrayPtrFlat<CParserParam>(4);

   922 	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfParams,arrayOfParams));

   923 	

   924 	// Create value parameter

   925 	CParserParam* valueType = CParserParam::NewL(KVersitTokenVALUE, KNullDesC8);

   926 	CleanupStack::PushL(valueType);

   927 	CCalAttachment::TType type = aAttachment.Type();

   928 	TBool exportBinaryData = EFalse;

   929 	switch (type)

   930 		{

   931 		case CCalAttachment::EUri:

   932 			{

   933 			valueType->SetValueL(KVCalContentValueUrl);

   934 			break;

   935 			}

   936 		case CCalAttachment::EFile:

   937 			{

   938 			if (aAttachment.FileAttachment()->ContentId().Length() > 0)

   939 				{

   940 				valueType->SetValueL(KVCalContentValueContentId);

   941 				}

   942 			else if (aAttachment.IsAttributeSet(CCalAttachment::EExportInline))

   943 				{

   944 				valueType->SetValueL(KVCalContentValueInline);

   945 				exportBinaryData = ETrue;

   946 				}

   947 			break;

   948 			}

   949 		default:

   950 			// Do nothing. In this case the value will not be set

   951 			break;

   952 		}

   953 	if (valueType->Value().Length() == 0)

   954 		{

   955 		// The property is unsupported. So we'll clean up and then return

   956 		CleanupStack::PopAndDestroy(2, arrayOfParams); //arrayOfParams, valueType

   957 		return;

   958 		}

   959 	arrayOfParams->AppendL(valueType); // takes ownership

   960 	CleanupStack::Pop(valueType);

   961 

   962 	// Create content MIME type parameter

   963 	TPtrC8 mimeType(aAttachment.MimeType());

   964 	if(mimeType != KNullDesC8)

   965 		{

   966 		CParserParam* mimeTypeParam = CParserParam::NewL(KVersitAttachMimeType, mimeType);

   967 		CleanupStack::PushL(mimeTypeParam);

   968 	  	arrayOfParams->AppendL(mimeTypeParam);

   969 	  	CleanupStack::Pop(mimeTypeParam);

   970 		}

   971   

   972   	const TPtrC fileName(aAttachment.Label());

   973   	if(fileName != KNullDesC)

   974   		{

   975 		HBufC8* filenameUtf8 = HBufC8::NewLC(2 * fileName.Length()); // need room to convert from 16 bit to 8 bit (x2)

   976 		TPtr8 pfileName(filenameUtf8->Des());

   977 		User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(pfileName, fileName));					 

   978 		CParserParam* fileNameParameter = CParserParam::NewL(KVersitAttachLabel, pfileName);

   979 		CleanupStack::PopAndDestroy(filenameUtf8);  

   980 		CleanupStack::PushL(fileNameParameter);

   981 	  	arrayOfParams->AppendL(fileNameParameter);

   982 	  	CleanupStack::Pop(fileNameParameter);

   983   		}

   984 	 	// Create File Date parameter

   985 	TTime lastModifiedFileTime = Time::NullTTime();

   986 	if (aAttachment.FileAttachment())

   987 		{

   988 		lastModifiedFileTime = aAttachment.FileAttachment()->LastModifiedTimeUtc();

   989 		}

   990 	if(lastModifiedFileTime != Time::NullTTime())

   991 		{

   992 		_LIT(KStringFormat, "%F%Y%M%DT%H%T%SZ"); // locale-independent formatting YYMMDD"T"HHMMSS"Z" (day,month,year,hour,minute,second)

   993 		TBuf<KMaxTimeStringSize> dateString;

   994 		lastModifiedFileTime.FormatL(dateString,KStringFormat);

   995 		TBuf8<KMaxTimeStringSize> dateString8;

   996 		dateString8.Copy(dateString);

   997 		CParserParam* fileDate = CParserParam::NewL(KVCalAttachFileDate, dateString8);

   998 		CleanupStack::PushL(fileDate);

   999 	  	arrayOfParams->AppendL(fileDate);

  1000 	  	CleanupStack::Pop(fileDate);

  1001 		}

  1002 	  	

  1003   	CParserPropertyValue* propertyValue = NULL;

  1004 

  1005  	if (exportBinaryData)

  1006  		{

  1007  		RFile file;

  1008 	 	TRAPD(err,aAttachment.FileAttachment()->FetchFileHandleL(file));

  1009 		if(err == KErrNone)

  1010 			{

  1011 			CleanupClosePushL(file);

  1012 			propertyValue = CParserPropertyValueBinaryFile::NewL(file);

  1013 			CleanupStack::PopAndDestroy(&file);

  1014 			}

  1015 		else if(err == KErrArgument)

  1016 			{//FetchFileHandleL leaves with KErrArgument if there is no file handle has been set, eg. the entry hasn't been saved to Calendar file which isn't common user case

  1017 			TRAP(err, aAttachment.FileAttachment()->LoadBinaryDataL());

  1018 

  1019 			if(err != KErrNone)

  1020 				{//The user can keep synching if, e.g. it is out of memory, or the attachment file is on a drive where the media has been removed, or the attachment has been deleted from the calendar store by other clients.

  1021 				CleanupStack::PopAndDestroy(arrayOfParams);	

  1022 				return;

  1023 				}

  1024 

  1025 			propertyValue = CParserPropertyValueBinary::NewL(aAttachment.Value());

  1026 			}

  1027 		else

  1028 			{

  1029 			User::Leave(err);

  1030 			}

  1031 		}

  1032  	else 

  1033  		{

  1034  		TPtrC8 attach8;

  1035  		if (type == CCalAttachment::EFile)

  1036  			{

  1037  			attach8.Set(aAttachment.FileAttachment()->ContentId());	

  1038  			}

  1039  		else

  1040  			{

  1041  			attach8.Set(aAttachment.Value());	

  1042  			}

  1043  		

  1044  		HBufC* attach16 = HBufC::NewLC(attach8.Length());

  1045 		attach16->Des().Copy(attach8);

  1046  		propertyValue = CParserPropertyValueHBufC::NewL(attach16->Des());

  1047 		CleanupStack::PopAndDestroy(attach16);		

  1048   		}

  1049 	CleanupStack::PushL(propertyValue);

  1050 	CParserProperty* property = CParserProperty::NewL(*propertyValue, KVersitTokenATTACH, arrayOfParams);

  1051 	aParser.AddPropertyL(property);

  1052 	CleanupStack::Pop(2,arrayOfParams);		// propertyValue, arrayOfParams

  1053 	}

  1054 

  1055 void CAgendaEntryToVCalConverter::AddAttendeeParameterL(CArrayPtr<CParserParam>* aArrayOfParams, CCalAttendee* aAttendee)

  1056 	{

  1057 	// Create an array of paramaters for this property

  1058 	CParserParam* expectParam = CParserParam::NewL(KVCalAttendee8EXPECT, KNullDesC8);

  1059 	CleanupStack::PushL(expectParam);

  1060 	switch (aAttendee->VCalExpect())

  1061 		{

  1062 		case CCalAttendee::EVCalFyi:

  1063 			expectParam->SetValueL(KVCalAttendeeExpect8FYI);

  1064 			break;

  1065 		case CCalAttendee::EVCalRequire:

  1066 			expectParam->SetValueL(KVCalAttendeeExpect8REQUIRE);

  1067 			break;

  1068 		case CCalAttendee::EVCalRequest:

  1069 			expectParam->SetValueL(KVCalAttendeeExpect8REQUEST);

  1070 			break;

  1071 		case CCalAttendee::EVCalImmediate:

  1072 			expectParam->SetValueL(KVCalAttendeeExpect8IMMEDIATE);

  1073 			break;

  1074 		default:

  1075 			break;

  1076 		}

  1077 	aArrayOfParams->AppendL(expectParam); // takes ownership

  1078 	CleanupStack::Pop(expectParam); 

  1079 	

  1080 	CParserParam* rsvpParam = CParserParam::NewL(KVCalAttendee8RSVP, KNullDesC8);

  1081 	CleanupStack::PushL(rsvpParam);

  1082 	switch (aAttendee->ResponseRequested())

  1083 		{

  1084 		case ETrue:

  1085 			rsvpParam->SetValueL(KVCalAttendeeRsvp8YES);

  1086 			break;

  1087 		case EFalse:

  1088 			rsvpParam->SetValueL(KVCalAttendeeRsvp8NO);

  1089 			break;

  1090 		default:

  1091 			break;

  1092 		}

  1093 	aArrayOfParams->AppendL(rsvpParam); // takes ownership

  1094 	CleanupStack::Pop(rsvpParam); 

  1095 	

  1096 	CParserParam* calroleParam = CParserParam::NewL(KICalAttendeeCalRole8, KNullDesC8);

  1097 	CleanupStack::PushL(calroleParam);

  1098 	

  1099 	CParserParam* vcalroleParam = CParserParam::NewL(KICalAttendeeCalRole8, KNullDesC8);

  1100 	CleanupStack::PushL(vcalroleParam);

  1101 	

  1102 	switch (aAttendee->RoleL())

  1103 		{

  1104 		case CCalAttendee::EChair:

  1105 			calroleParam->SetValueL(KICalAttendeeCalRole8CHAIR);

  1106 			break;

  1107 		case CCalAttendee::EReqParticipant:

  1108 			calroleParam->SetValueL(KICalAttendeeCalRole8REQUIRED);

  1109 			break;

  1110 		case CCalAttendee::EOptParticipant: 

  1111 			calroleParam->SetValueL(KICalAttendeeCalRole8OPTIONAL);

  1112 			break;

  1113 		case CCalAttendee::ENonParticipant:

  1114 			calroleParam->SetValueL(KICalAttendeeCalRole8NONPARTICIPANT);

  1115 			break;

  1116 			

  1117 		case CCalAttendee::EVCalAttendee:

  1118 			vcalroleParam->SetValueL(KVCalAttendeeRole8ATTENDEE);

  1119 			break;

  1120 		case CCalAttendee::EVCalDelegate:

  1121 			vcalroleParam->SetValueL(KVCalAttendeeRole8DELEGATE);

  1122 			break;

  1123 		case CCalAttendee::EVCalOwner:

  1124 			vcalroleParam->SetValueL(KVCalAttendeeRole8OWNER);

  1125 			break;

  1126 		default:

  1127 			break;

  1128 		}

  1129 	if (calroleParam->Value().Length() > 0)

  1130 		{

  1131 		aArrayOfParams->AppendL(calroleParam); // takes ownership

  1132 		CleanupStack::PopAndDestroy(vcalroleParam); // delete the vCal role as it is not used

  1133 		CleanupStack::Pop(calroleParam);

  1134 		}