--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappsupport/vcardandvcal/src/VCAL.CPP Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,1007 @@
+// Copyright (c) 1997-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:
+//
+
+#include <vcal.h>
+#include <vutil.h>
+#include <utf.h>
+#include <charconv.h>
+#include "verror.h"
+#include <vstaticutils.h>
+#include <vobserv.h>
+
+#include <s32mem.h>
+
+
+//
+// CParserVCal
+//
+
+EXPORT_C CParserVCal* CParserVCal::NewL()
+/** Allocates and constructs a vCalendar parser.
+
+@return Pointer to the newly created vCalendar parser. */
+ {
+ CParserVCal* self=new(ELeave) CParserVCal();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+CParserVCal::CParserVCal() :CVersitParser(ESupportsVersion)
+ {
+ iDefaultVersion = KVersitTokenVCalVersionNo;
+ }
+
+EXPORT_C void CParserVCal::InternalizeL(RReadStream& aStream)
+/** Internalises a vCalendar entity from a read stream.
+
+The presence of this function means that the standard templated operator>>()
+(defined in s32strm.h) is available to internalise objects of this class.
+
+@param aStream Stream from which the vCalendar should be internalised.
+@see CVersitParser::InternalizeL() */
+ {
+ CVersitParser::InternalizeL(aStream);
+ }
+
+
+EXPORT_C void CParserVCal::ExternalizeL(RWriteStream& aStream)
+/** Externalises a vCalendar entity (and all sub-entities) to a write stream.
+
+Sets the entity name to KVersitVarTokenVCALENDAR if it hasn't already been
+set.
+
+Adds a version property to the start of the current entity's array of properties
+if the entity supports this. (If there isn't an array of properties then one
+is made).
+
+The presence of this function means that the standard templated operator<<()
+(defined in s32strm.h) is available to externalise objects of this class.
+
+@param aStream Stream to which the vCalendar should be externalised.
+@see CVersitParser::ExternalizeL() */
+ {
+ if (!iEntityName)
+ SetEntityNameL(KVersitVarTokenVCALENDAR);
+ CVersitParser::ExternalizeL(aStream);
+ }
+
+EXPORT_C CVersitParser* CParserVCal::MakeEntityL(TInt aEntityUid,HBufC* aEntityName)
+// From CVersitParser
+ {
+ CVersitParser* newEntity = NULL;
+
+ switch (aEntityUid)
+ {
+ case KVCalEntityUidVEvent:
+ case KVCalEntityUidVTodo:
+ newEntity=CParserVCalEntity::NewL();
+ CleanupStack::PushL(newEntity);
+ break;
+ default: //Allows it to read (and ignore) additional iCalendar entities
+ newEntity = new(ELeave) CVersitParser(ENoVersionProperty);
+ CleanupStack::PushL(newEntity);
+ newEntity->ConstructL();
+ break;
+ }
+ if (iObserver)
+ iObserver->NewParser(newEntity);
+ newEntity->SetAutoDetect(iFlags&EUseAutoDetection,iAutoDetectCharSets);
+ if (iFlags&EImportSyncML)
+ newEntity->SetFlags(EImportSyncML);
+
+ // make child entries aware of default char set
+ if (iFlags&EUseDefaultCharSetForAllProperties)
+ newEntity->SetFlags(EUseDefaultCharSetForAllProperties);
+ newEntity->SetDefaultCharSet(DefaultCharSet());
+
+ if (iPlugIn)
+ {
+ newEntity->SetPlugIn(iPlugIn);
+ }
+
+ newEntity->InternalizeL(aEntityName, iLineReader);
+
+ CleanupStack::Pop(newEntity);
+ return newEntity;
+ }
+
+EXPORT_C TUid CParserVCal::RecognizeToken(const TDesC8& aToken) const
+// From CVersitParser
+/** Returns a UID that identifies a specified token's type.
+
+For example, if aToken contains the property name DAYLIGHT the function returns
+KVersitPropertyDaylightUid. If the token is not recognized as vCalendar-specific,
+the function calls CVersitParser::RecognizeToken(), which recognizes generic Versit
+tokens.
+
+@param aToken The token to be recognized.
+@return A defined UID value if the token has been recognized, KVersitTokenUnknownUid
+otherwise. */
+ {
+ TUid uid = KNullUid;
+ TChar firstChar(aToken.Ptr()[0]);
+ firstChar=firstChar.GetUpperCase();
+ switch (firstChar)
+ {
+ case 'D':
+ if (!aToken.CompareF(KVersitTokenDAYLIGHT))
+ uid.iUid = KVersitPropertyDaylightUid;
+ break;
+ case 'P':
+ if (!aToken.CompareF(KVersitTokenPRODID))
+ uid.iUid = KVersitPropertyHBufCUid;
+ break;
+ case 'T':
+ if (!aToken.CompareF(KVersitTokenTZ))
+ uid.iUid = KVersitPropertyTimeZoneUid;
+ break;
+ case 'V':
+ if (!aToken.CompareF(KVersitTokenVERSION))
+ uid.iUid = KVersitTokenVersionUid;
+ break;
+ default:
+ break;
+ }
+ if (uid == KNullUid)
+ return CVersitParser::RecognizeToken(aToken);
+ return uid;
+ }
+
+EXPORT_C TInt CParserVCal::RecognizeEntityName() const
+// From CVersitParser
+/** Tests the current value to see if it a vEvent or vTodo entity.
+
+@return KVCalEntityUidVEvent if it is a vEvent entity; KVersitVarTokenVTODO
+if it is a vTodo entity; zero if there is no current property or it has no value. */
+ {
+ if (iCurrentProperty && iCurrentProperty->Value())
+ {
+ TPtrC entityName=STATIC_CAST(CParserPropertyValueHBufC*,iCurrentProperty->Value())->Value();
+ if (entityName==KVersitVarTokenVEVENT)
+ return KVCalEntityUidVEvent;
+ else if (entityName==KVersitVarTokenVTODO)
+ return KVCalEntityUidVTodo;
+ }
+ return 0;
+ }
+
+EXPORT_C void CParserVCal::Reserved1()
+ {}
+
+EXPORT_C void CParserVCal::Reserved2()
+ {}
+
+//
+// CParserVCalEntity
+//
+
+EXPORT_C CParserVCalEntity* CParserVCalEntity::NewL()
+/** Allocates and constructs a vCalendar sub-entity parser.
+
+@return A pointer to the new vCalendar sub-entity parser. */
+ {
+ CParserVCalEntity* self=new(ELeave) CParserVCalEntity();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CParserVCalEntity::CParserVCalEntity()
+ : CRecurrenceParser(EFalse)
+/** Constructs a vCalendar sub-entity parser. */
+ {}
+
+EXPORT_C CParserVCalEntity::~CParserVCalEntity()
+/** The destructor is empty. */
+ {
+ }
+
+EXPORT_C void CParserVCalEntity::ExternalizeL(RWriteStream& aStream)
+/** Externalises a vTodo or vEvent to a write stream.
+
+Sets the entity's name to KVersitVarTokenVEVENT if it hasn't already been
+set.
+
+Converts all date/time values from machine-local into universal time.
+
+The presence of this function means that the standard templated operator<<()
+(defined in s32strm.h) is available to externalise objects of this class.
+
+@param aStream Stream to which the vTodo or vEvent should be externalised. */
+ {
+ if (!iEntityName)
+ SetEntityNameL(KVersitVarTokenVEVENT);
+ CVersitParser::ExternalizeL(aStream);
+ }
+
+EXPORT_C CParserPropertyValue* CParserVCalEntity::MakePropertyValueL(const TUid& aPropertyUid,HBufC16*& aValue)
+// From CVersitParser
+ {
+ if(!aValue && !iLargeDataBuf)
+ return NULL;
+
+ switch (aPropertyUid.iUid)
+ {
+ case KVCalPropertyAlarmUid: // won't be recognized except by subclass
+ {
+ CVersitAlarm* alarm = MakePropertyValueAlarmL(aValue->Des());
+ CleanupStack::PushL(alarm);
+ CParserPropertyValue* value = new(ELeave) CParserPropertyValueAlarm(alarm);
+ CleanupStack::Pop(alarm);
+ return value;
+ }
+ case KVCalPropertyExtendedAlarmUid: // won't be recognized except by subclass
+ {
+ CVersitExtendedAlarm* richAlarm = NULL;
+ if (aValue)
+ {
+ richAlarm = MakePropertyValueExtendedAlarmL(aValue->Des());
+ }
+ else
+ {
+ richAlarm = MakePropertyValueExtendedAlarmL(*iLargeDataBuf);
+ }
+ CleanupStack::PushL(richAlarm);
+ CParserPropertyValue* value = new(ELeave) CParserPropertyValueExtendedAlarm(richAlarm);
+ CleanupStack::Pop(richAlarm);
+ return value;
+ }
+ case KVCalPropertyRecurrenceUid:
+ {
+ TPtr val=aValue->Des();
+ return MakePropertyValueRecurrenceL(val);
+ }
+ default:
+ break;
+ };
+ return CVersitParser::MakePropertyValueL(aPropertyUid,aValue);
+ }
+
+EXPORT_C CVersitAlarm* CParserVCalEntity::MakePropertyValueAlarmL(TPtr16 aAlarmValue)
+//Make an Alarm property from stream
+ {
+ TPtrC8 propName=iCurrentProperty->Name();
+ TPtr16 field(NULL,0);
+
+ FindFirstField(field,aAlarmValue);
+ TVersitDateTime* runTime=NULL;
+ if(field.Length()>0)
+ runTime = DecodeDateTimeL(field);
+ CleanupStack::PushL(runTime);
+
+ FindFirstField(field,aAlarmValue);
+ TTime* snoozeTime = NULL;
+ if(field.Length()>0)
+ snoozeTime = DecodeTimePeriodL(field);
+ CleanupStack::PushL(snoozeTime);
+
+ FindFirstField(field,aAlarmValue);
+ TInt repeatCount=0;
+ if(field.Length()>0)
+ Val(field, repeatCount);
+
+ if (propName==KVersitTokenAALARM || propName==KVersitTokenMALARM)
+ FindFirstField(field,aAlarmValue);
+ else
+ field.Zero();
+
+ TPtr16 note(NULL,0);
+ if (propName!=KVersitTokenAALARM)
+ FindFirstField(note,aAlarmValue);
+
+ CVersitAlarm* alarm = CVersitAlarm::NewL(runTime, snoozeTime, repeatCount, field, note);
+
+ CleanupStack::Pop(2,runTime);
+ return alarm; //alarm takes ownership of runTime and snoozeTime
+ }
+
+/** Create a new extended alarm from a stream.
+The MIME type is set to the creating object's MIME type.
+The disposition is set to the creating object's disposition.
+@param aAlarmValue a pointer to a buffer containing the assocaited data for the alarm. Should not point to an empty
+descriptor.
+@return The newly created extended alarm. */
+EXPORT_C CVersitExtendedAlarm* CParserVCalEntity::MakePropertyValueExtendedAlarmL(TPtr16 aAlarmValue)
+ {
+ TPtrC8 propName=iCurrentProperty->Name();
+ TPtr16 field(NULL,0);
+
+
+ // Note: the presence of this property means that
+ // the parameters VALUE and X-CONTENTTYPE should be present; if not
+ // present, then INLINE rich data shall be assumed
+
+ TPtrC8 mimeType(NULL,0);
+ TPtrC8 dispositionField(NULL,0);
+
+ // content-value-type assumes default is INLINE if parameter not present
+ CVersitExtendedAlarm::TDisposition disposition = CVersitExtendedAlarm::EDispositionInline;
+
+ // read in data content-type
+ CParserParam* alarmParameter = iCurrentProperty->Param(KVersitTokenCONTENTTYPE);
+
+ if (alarmParameter)
+ {
+ mimeType.Set(alarmParameter->Value());
+ }
+
+ // read in data content-value-type
+ alarmParameter = iCurrentProperty->Param(KVersitTokenVALUE);
+
+ if (alarmParameter)
+ {
+ dispositionField.Set(alarmParameter->Value());
+
+ // if there is a value, convert from text to enum
+ if (dispositionField.Length())
+ {
+ disposition = DecodeDisposition(dispositionField);
+ }
+ }
+
+ FindRemainingField(field,aAlarmValue);
+ CVersitExtendedAlarm* alarm = CVersitExtendedAlarm::NewL(field.Collapse(), mimeType, disposition);
+
+ return alarm;
+ }
+
+/** Create a new extended alarm from a buffer.
+The MIME type is set to the creating object's MIME type.
+The disposition is set to the creating object's disposition.
+@param aAlarmValue a reference to a buffer containing the assocaited data for the alarm. Should not be an empty
+buffer.
+@return The newly created extended alarm. */
+EXPORT_C CVersitExtendedAlarm* CParserVCalEntity::MakePropertyValueExtendedAlarmL(CBufSeg& aAlarmValue)
+ {
+ TPtrC8 propName=iCurrentProperty->Name();
+ TPtr16 field(NULL,0);
+
+
+ // Note: the presence of this property means that
+ // the parameters VALUE and CONTENTTYPE should be present; if not
+ // present, then MIME rich data shall be assumed
+
+ TPtrC8 mimeType(NULL,0);
+ TPtrC8 dispositionField(NULL,0);
+
+ // content-value-type assumes INLINE if parameter not present
+ CVersitExtendedAlarm::TDisposition disposition = CVersitExtendedAlarm::EDispositionInline;
+
+ // read in data content-type
+ CParserParam* alarmParameter = iCurrentProperty->Param(KVersitTokenCONTENTTYPE);
+
+ if (alarmParameter)
+ {
+ mimeType.Set(alarmParameter->Value());
+ }
+
+ // read in disposition
+ alarmParameter = iCurrentProperty->Param(KVersitTokenVALUE);
+
+ if (alarmParameter)
+ {
+ dispositionField.Set(alarmParameter->Value());
+
+ // if there is a value, convert from text to enum
+ if (dispositionField.Length())
+ {
+ disposition = DecodeDisposition(dispositionField);
+ }
+ }
+
+ // read in rich data content
+ // For this version of MakePropertyValueExtendedAlarmL, we have the
+ // data in a CBufSeg that should already have been decoded from BASE64
+ // (assuming everything else works properly). So we need to get it into
+ // a TBufC8
+ TInt segSize = aAlarmValue.Size();
+ HBufC8* content = HBufC8::NewLC(segSize);
+ TPtr8 ptrContent(content->Des());
+ aAlarmValue.Read(0, ptrContent, segSize);
+
+ CVersitExtendedAlarm* alarm = CVersitExtendedAlarm::NewL(ptrContent, mimeType, disposition);
+ CleanupStack::PopAndDestroy(content);
+
+ return alarm;
+ }
+
+/** Used to find the type of the content disposition: inline, URL, or unknown.
+Converts content-value-type token field to content-value-type enum.
+@param aContentDisposition The disposition of the data for the alarm action.
+@return decoded disposition type */
+EXPORT_C CVersitExtendedAlarm::TDisposition CParserVCalEntity::DecodeDisposition(const TDesC8& aContentDisposition) const
+ {
+ if (!aContentDisposition.CompareF(KVersitTokenINLINE))
+ {
+ return CVersitExtendedAlarm::EDispositionInline;
+ };
+
+ if (!aContentDisposition.CompareF(KVersitTokenURL))
+ {
+ return CVersitExtendedAlarm::EDispositionUrl;
+ };
+
+ return CVersitExtendedAlarm::EDispositionUnknown;
+ }
+
+
+/*
+ * Try to recognize aToken and return a UID for it.
+ * Call <code>CVersitParser::RecognizeToken()</code>
+ * which recognizes generic Versit tokens if the token has not been
+ * recognized in this function
+ *
+ * @param " const TDesC8& aToken "
+ * The token to be recognized
+ * @return " TUid "
+ * a defined UID value if the token has been recognized,
+ * <code>KVersitTokenUnknownUid</code>, otherwise
+ */
+
+EXPORT_C TUid CParserVCalEntity::RecognizeToken(const TDesC8& aToken) const
+// From CVersitParser
+ {
+ TUid uid = KNullUid;
+ TChar firstChar(aToken.Ptr()[0]);
+ firstChar=firstChar.GetUpperCase();
+ switch (firstChar)
+ {
+ case 'A':
+ if (!aToken.CompareF(KVersitTokenAALARM))
+ uid.iUid = KVCalPropertyAlarmUid;
+ else if (!aToken.CompareF(KVersitTokenATTENDEE))
+ uid.iUid = KVersitPropertyHBufCUid;
+ else if (!aToken.CompareF(KVersitTokenATTACH))
+ {
+ if(iCurrentProperty)
+ {//If it is internalising, iCurrentProperty is set
+ uid.iUid = KVersitPropertyBinaryUid;//In vCal standard, default value is binary
+ CParserParam* valueParam = iCurrentProperty->Param(KVersitTokenVALUE);
+ if (valueParam)
+ {
+ TPtrC8 pParameterValue(valueParam->Value());
+
+ if (pParameterValue.CompareF(KVersitTokenINLINE) && pParameterValue.CompareF(KVersitTokenBINARY))
+ {//If VALUE isn't specified as INLINE or BINARY, value is text type.
+ uid.iUid = KVersitPropertyHBufCUid;
+ }
+ }
+ }
+ }
+ break;
+ case 'C':
+ if (!aToken.CompareF(KVersitTokenCATEGORIES))
+ uid.iUid = KVersitPropertyCDesCArrayUid;
+ else if (!aToken.CompareF(KVersitTokenCLASS))
+ uid.iUid = KVersitPropertyHBufCUid;
+ else if (!aToken.CompareF(KVersitTokenCOMPLETED))
+ uid.iUid = KVersitPropertyDateTimeUid;
+ break;
+ case 'D':
+ if (!aToken.CompareF(KVersitTokenDALARM))
+ uid.iUid = KVCalPropertyAlarmUid;
+ else if (!aToken.CompareF(KVersitTokenDCREATED) ||
+ !aToken.CompareF(KVersitTokenDTEND) ||
+ !aToken.CompareF(KVersitTokenDTSTART) ||
+ !aToken.CompareF(KVersitTokenDUE))
+ uid.iUid = KVersitPropertyDateTimeUid;
+ else if(!aToken.CompareF(KVersitTokenDESCRIPTION))
+ uid.iUid = KVersitPropertyHBufCUid;
+ break;
+ case 'E':
+ if (!aToken.CompareF(KVersitTokenEXDATE))
+ uid.iUid = KVersitPropertyMultiDateTimeUid;
+ else if (!aToken.CompareF(KVersitTokenEXRULE))
+ uid.iUid = KVCalPropertyRecurrenceUid;
+ break;
+ case 'G':
+ if (!aToken.CompareF(KVersitTokenGEO))
+ uid.iUid = KVersitPropertyHBufCUid;
+ break;
+ case 'L':
+ if (!aToken.CompareF(KVersitTokenLASTMODIFIED))
+ uid.iUid = KVersitPropertyDateTimeUid;
+ else if(!aToken.CompareF(KVersitTokenLOCATION))
+ uid.iUid = KVersitPropertyHBufCUid;
+ break;
+ case 'M':
+ if (!aToken.CompareF(KVersitTokenMALARM))
+ uid.iUid = KVCalPropertyAlarmUid;
+ break;
+ case 'P':
+ if (!aToken.CompareF(KVersitTokenPALARM))
+ uid.iUid = KVCalPropertyAlarmUid;
+ else if (!aToken.CompareF(KVersitTokenPRIORITY))
+ uid.iUid = KVersitPropertyIntUid;
+ break;
+ case 'R':
+ if(!aToken.CompareF(KVersitTokenRDATE))
+ uid.iUid = KVersitPropertyMultiDateTimeUid;
+ else if (!aToken.CompareF(KVersitTokenRELATEDTO))
+ uid.iUid = KVersitPropertyHBufCUid;
+ else if (!aToken.CompareF(KVersitTokenRESOURCES))
+ uid.iUid = KVersitPropertyCDesCArrayUid;
+ else if (!aToken.CompareF(KVersitTokenRNUM))
+ uid.iUid = KVersitPropertyIntUid;
+ else if (!aToken.CompareF(KVersitTokenRRULE))
+ uid.iUid = KVCalPropertyRecurrenceUid;
+ break;
+ case 'S':
+ if (!aToken.CompareF(KVersitTokenSEQUENCE))
+ uid.iUid = KVersitPropertyIntUid;
+ else if (!aToken.CompareF(KVersitTokenSTATUS) ||
+ !aToken.CompareF(KVersitTokenSUMMARY))
+ uid.iUid = KVersitPropertyHBufCUid;
+ break;
+ case 'T':
+ if(!aToken.CompareF(KVersitTokenTRANSP))
+ uid.iUid = KVersitPropertyIntUid;
+ break;
+ case 'U':
+ if (!aToken.CompareF(KVersitTokenURL) ||
+ !aToken.CompareF(KVersitTokenUID))
+ uid.iUid = KVersitPropertyHBufCUid;
+ break;
+ case 'X':
+ if (!aToken.CompareF(KVersitTokenXRECURRENCEID) ||
+ !aToken.CompareF(KVersitTokenXDTSTAMP))
+ {
+ uid.iUid = KVersitPropertyDateTimeUid;
+ }
+ else if (!aToken.CompareF(KVersitTokenXALARM))
+ {
+ uid.iUid = KVCalPropertyExtendedAlarmUid;
+ }
+ else if (!aToken.CompareF(KVersitTokenXLOCALUID))
+ {
+ uid.iUid = KVersitPropertyIntUid;
+ }
+ break;
+ }
+ if (uid == KNullUid)
+ return CVersitParser::RecognizeToken(aToken);
+ return uid;
+ }
+
+EXPORT_C void CParserVCalEntity::Reserved1()
+ {}
+
+EXPORT_C void CParserVCalEntity::Reserved2()
+ {}
+
+
+//
+// CVersitAlarm
+//
+
+CVersitAlarm::CVersitAlarm(TInt aRepeatCount)
+ : iRepeatCount(aRepeatCount)
+ {
+ }
+
+void CVersitAlarm::ConstructL(const TDesC& aAudioContent, const TDesC& aNote, TVersitDateTime* aRunTime, TTime* aSnoozeTime)
+ {
+ if (aAudioContent.Size())
+ {
+ iAudioContent = aAudioContent.AllocL();
+ }
+ if (aNote.Size())
+ {
+ iNote = aNote.AllocL();
+ }
+ iRunTime = aRunTime;
+ iSnoozeTime = aSnoozeTime;
+ }
+
+EXPORT_C CVersitAlarm* CVersitAlarm::NewL(TVersitDateTime* aRunTime, TTime* aSnoozeTime, TInt aRepeatCount, const TDesC& aAudioContent, const TDesC& aNote)
+/** Allocates and constructs a new alarm.
+
+Ownership of aRunTime and aSnoozeTime is taken in the end.
+
+@param aRunTime Pointer to the alarm time.
+@param aSnoozeTime Pointer to the snooze time (may be NULL).
+@param aRepeatCount The repeat count.
+@param aAudioContent A binary buffer containing the sound data. May be an empty
+descriptor.
+@param aNote A descriptor containing text to display when the alarm is executing.
+May be an empty descriptor.
+@return Pointer to the newly created alarm. */
+ {
+ CVersitAlarm* self = new(ELeave) CVersitAlarm(aRepeatCount);
+ CleanupStack::PushL(self);
+ self->ConstructL(aAudioContent, aNote, aRunTime, aSnoozeTime);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+EXPORT_C CVersitAlarm::~CVersitAlarm()
+/** Frees all resources owned by the alarm, prior to its destruction. */
+ {
+ delete iRunTime;
+ delete iSnoozeTime;
+ delete iAudioContent;
+ delete iNote;
+ }
+
+CVersitExtendedAlarm::CVersitExtendedAlarm()
+ {
+ }
+
+void CVersitExtendedAlarm::ConstructL(const TDesC8& aContent, const TDesC8& aContentMimeType, CVersitExtendedAlarm::TDisposition aContentDisposition)
+ {
+ if (aContent.Size())
+ {
+ iContent = aContent.AllocL();
+ }
+ else
+ {
+ iContent = NULL;
+ }
+
+ if (aContentMimeType.Size())
+ {
+ iMimeType = aContentMimeType.AllocL();
+ }
+ else
+ {
+ iMimeType = NULL;
+ }
+ iDisposition = aContentDisposition;
+ }
+
+/** Allocates and constructs a new extended alarm (X-EPOCALARM).
+@param aContent A binary buffer containing the assocaited data for the alarm. Should not be empty
+descriptor.
+@param aContentMimeType The MIME type of the data describing the action for the alarm.
+@param aContentDisposition The disposition of the data for the alarm action.
+@return Pointer to the newly created extended alarm. */
+EXPORT_C CVersitExtendedAlarm* CVersitExtendedAlarm::NewL(const TDesC8& aContent, const TDesC8& aContentMimeType,
+ CVersitExtendedAlarm::TDisposition aContentDisposition)
+ {
+ CVersitExtendedAlarm * self = new(ELeave) CVersitExtendedAlarm();
+ CleanupStack::PushL(self);
+ self->ConstructL(aContent, aContentMimeType, aContentDisposition);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+EXPORT_C CVersitExtendedAlarm::~CVersitExtendedAlarm()
+/** Frees all resources owned by the alarm, prior to its destruction. */
+ {
+ delete iContent;
+ delete iMimeType;
+ }
+
+//
+// CParserPropertyValueAlarm
+//
+EXPORT_C CParserPropertyValueAlarm::CParserPropertyValueAlarm(CVersitAlarm* aValue)
+: CParserTimePropertyValue(TUid::Uid(KVCalPropertyAlarmUid))
+ ,iValue(aValue)
+/** Constructs a new alarm property value with a pointer to a CVersitAlarm.
+
+@param aValue Pointer to the alarm. The property value takes ownership of
+the pointer. */
+ {}
+
+
+EXPORT_C CParserPropertyValueAlarm::~CParserPropertyValueAlarm()
+/** Frees all resources owned by the property value, prior to its destruction. */
+ {
+ delete iValue;
+ }
+
+EXPORT_C void CParserPropertyValueAlarm::ConvertAllDateTimesToUTCL(const TTimeIntervalSeconds& aIncrement, const CVersitDaylight* aDaylight)
+/** Converts the alarm time into universal time.
+
+The date/time of the alarm is checked against the daylight saving information
+provided in aDaylight. If it falls inside the daylight saving period then
+the daylight saving offset is subtracted from the time to convert it to universal
+time. Otherwise aIncrement is added to the date/time of the alarm to convert
+it to universal time.
+
+Note that the daylight savings offset will adjust the time both for the daylight
+saving and for the time zone.
+
+The function has no effect if the value is already stored as universal time.
+
+If aDaylight is a NULL pointer then aIncrement is used.
+
+@param aIncrement A time interval in seconds which represents the negative
+of the time zone of the originating machine. For instance, if the time zone
+is +04:30, aIncrement should be set to -04:30.
+@param aDaylight Pointer to the specification for daylight saving. If the alarm's
+time value is within the period for daylight saving, the value is modified
+by the daylight saving offset (which accounts for both the time zone and daylight
+saving rule).
+@deprecated since 9.1
+*/
+ {
+ if (iValue && iValue->iRunTime && (iValue->iRunTime->iRelativeTime != TVersitDateTime::EIsUTC) && !iValue->iRunTime->IsFlagSet(TVersitDateTime::EExportLeaveAsLocalTime))
+ {
+ ConvertDateTime(&iValue->iRunTime->iDateTime,aIncrement, aDaylight);
+ iValue->iRunTime->iRelativeTime = TVersitDateTime::EIsUTC;
+ }
+ }
+
+EXPORT_C void CParserPropertyValueAlarm::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& aIncrement)
+/** Converts the alarm time to machine-local time.
+
+This involves adjusting the alarm's date/time by the offset in aIncrement.
+
+The function has no effect if the value is already stored as machine-local
+time.
+
+@param aIncrement A time interval which represents the number of seconds which
+is to be added to the date/time value. This should normally be the universal
+time offset for the machine's locale.
+@deprecated since 9.1
+*/
+ {
+ if (iValue && iValue->iRunTime && (iValue->iRunTime->iRelativeTime == TVersitDateTime::EIsUTC))
+ {
+ ConvertDateTime(&iValue->iRunTime->iDateTime, aIncrement,NULL);
+ iValue->iRunTime->iRelativeTime = TVersitDateTime::EIsMachineLocal;
+ }
+ }
+
+EXPORT_C void CParserPropertyValueAlarm::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& aEncodingCharset,TInt aLengthOutput)
+ // From CParserProperty
+/** Externalises the alarm property value into aStream.
+
+@param aStream Stream to which the value should be externalised.
+@param aEncodingCharset Contains the character set and encoding into which the
+property value should be converted.
+@param aLengthOutput The amount of text that has been outputted on the line
+so far, which needs to be taken into account when calculating if and where
+any line break should occur. */
+ {
+ if (!iValue)
+ return;
+
+ TInt bufLen=64; //This should cover the Date/Time, Duration, Repeat Count and semi colons
+ if (iValue->iAudioContent)
+ bufLen+=iValue->iAudioContent->Length();
+ if (iValue->iNote)
+ bufLen+=iValue->iNote->Length();
+ HBufC* outputStringBuf=HBufC::NewLC(bufLen);
+ TPtr outputString=outputStringBuf->Des();
+ TBuf8<KVersitDefaultBufferSize> buf;
+ if (iValue->iRunTime)
+ {
+ EncodeVersitDateTimeL(buf,*iValue->iRunTime);
+ Append(outputString,buf);
+ }
+ outputString.Append(KVersitTokenSemiColonUnicode);
+ if (iValue->iSnoozeTime)
+ {
+ EncodeTimePeriodL(buf,*iValue->iSnoozeTime);
+ Append(outputString,buf);
+ }
+ outputString.Append(KVersitTokenSemiColonUnicode);
+ __ASSERT_DEBUG(iValue->iRepeatCount < 100000, User::Invariant());
+ if(iValue->iRepeatCount>0)
+ {
+ outputString.AppendNum(iValue->iRepeatCount);
+ }
+ outputString.Append(KVersitTokenSemiColonUnicode);
+
+ if (iValue->iAudioContent)
+ {
+ outputString.Append(*iValue->iAudioContent);
+ if (iValue->iNote)
+ outputString.Append(KVersitTokenSemiColonUnicode);
+ }
+ if (iValue->iNote)
+ outputString.Append(*iValue->iNote);
+ FoldAndWriteValueToStreamL(aStream,outputString,aEncodingCharset,aLengthOutput);
+ CleanupStack::PopAndDestroy(outputStringBuf);
+ }
+
+EXPORT_C TBool CParserPropertyValueAlarm::IsAsciiCharacterSetSufficient()
+/** Tests whether the property value can be represented using the ASCII character
+set.
+
+@return ETrue if the property value can be represented using the ASCII character
+set. If not, EFalse. */
+ {
+ if (!iValue)
+ return ETrue;
+ if (iValue->iAudioContent && !VersitUtils::DescriptorContainsOnlySevenBitCharacters(*iValue->iAudioContent))
+ return EFalse;
+ if (iValue->iNote && !VersitUtils::DescriptorContainsOnlySevenBitCharacters(*iValue->iNote))
+ return EFalse;
+ return ETrue;
+ }
+
+//
+// CParserPropertyValueExtendedAlarm.
+//
+EXPORT_C CParserPropertyValueExtendedAlarm::CParserPropertyValueExtendedAlarm(CVersitExtendedAlarm* aValue)
+: CParserTimePropertyValue(TUid::Uid(KVCalPropertyExtendedAlarmUid))
+ ,iValue(aValue)
+/** Constructs a new extended alarm property value with a pointer to a CVersitExtendedAlarm.
+
+@param aValue Pointer to the alarm. The property value takes ownership of
+the pointer. */
+ {}
+
+EXPORT_C CParserPropertyValueExtendedAlarm::~CParserPropertyValueExtendedAlarm()
+/** Frees all resources owned by the property value, prior to its destruction. */
+ {
+ delete iValue;
+ }
+
+EXPORT_C void CParserPropertyValueExtendedAlarm::ConvertAllDateTimesToUTCL(const TTimeIntervalSeconds& /* aIncrement */, const CVersitDaylight* /* aDaylight */)
+/** Converts the extended alarm time into universal time.
+
+@param aIncrement A time interval in seconds which represents the negative
+of the time zone of the originating machine. For instance, if the time zone
+is +04:30, aIncrement should be set to -04:30.
+@param aDaylight Pointer to the specification for daylight saving. If the alarm's
+time value is within the period for daylight saving, the value is modified
+by the daylight saving offset (which accounts for both the time zone and daylight
+saving rule).
+@deprecated since 9.1
+*/
+ {
+ }
+
+EXPORT_C void CParserPropertyValueExtendedAlarm::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& /*aIncrement */)
+/** Converts the extended alarm time to machine-local time.
+
+@param aIncrement A time interval which represents the number of seconds which
+is to be added to the date/time value. This should normally be the universal
+time offset for the machine's locale.
+@deprecated since 9.1
+*/
+ {
+ }
+
+EXPORT_C void CParserPropertyValueExtendedAlarm::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& aEncodingCharset,TInt aLengthOutput)
+// From CParserProperty
+/** Externalises the extended alarm property value into aStream.
+
+@param aStream Stream to which the value should be externalised.
+@param aEncodingCharset Contains the character set and encoding into which the
+property value should be converted.
+@param aLengthOutput The amount of text that has been outputted on the line
+so far, which needs to be taken into account when calculating if and where
+any line break should occur. */
+ {
+ if (!iValue)
+ {
+ return;
+ }
+ // There are two encoding possibilities for this value. If it is a URL, then we expand the 8 bit string,
+ // which we know is US ASCII into Unicode and append it. If it is INLINE data, then we must encode it as
+ // 64 bit data
+ switch (iValue->iDisposition)
+ {
+ case CVersitExtendedAlarm::EDispositionUrl:
+ ExternalizeUrlL(aStream, aEncodingCharset, aLengthOutput);
+ break;
+ case CVersitExtendedAlarm::EDispositionInline:
+ default: //intentional fall through, we'll treat any unknown as INLINE data
+ ExternalizeInlineL(aStream, aEncodingCharset, aLengthOutput);
+ break;
+ }
+
+ }
+
+void CParserPropertyValueExtendedAlarm::ExternalizeUrlL(RWriteStream& aStream,const Versit::TEncodingAndCharset& aEncodingCharset,TInt aLengthOutput)
+ {
+ TInt bufLen = 0;
+ if (iValue->iContent)
+ {
+ bufLen+=iValue->iContent->Size();
+ }
+
+ HBufC* outputStringBuf=HBufC::NewLC(bufLen);
+
+ TPtr outputString=outputStringBuf->Des();
+
+ HBufC* bufferUrl = NULL;
+
+ CVersitUnicodeUtils* vUtils = new(ELeave)CVersitUnicodeUtils();
+ vUtils->CreateConverterL();
+
+ bufferUrl = vUtils->WidenL(*(iValue->iContent));
+
+ TPtrC desUrl(bufferUrl->Des());
+ CleanupStack::PushL(bufferUrl);
+
+ outputString.Append(desUrl);
+
+ FoldAndWriteValueToStreamL(aStream,outputString,aEncodingCharset,aLengthOutput);
+
+ CleanupStack::PopAndDestroy(2,outputStringBuf);
+
+ }
+
+const TInt KBase64MaxLineLength = 64; // chars
+
+void CParserPropertyValueExtendedAlarm::ExternalizeInlineL(RWriteStream& aStream,const Versit::TEncodingAndCharset& /*aEncodingCharset*/,TInt /*aLengthOutput*/)
+ {
+ if (iValue->iContent)
+ {
+ const TInt length = iValue->iContent->Size();
+ if (length >0)
+ {
+ CBufSeg* target = CBufSeg::NewL(length);
+ CleanupStack::PushL(target);
+
+ //get the Data Content into a usable buffer
+ CBufSeg* source = CBufSeg::NewL(length+1);
+ source->Reset();
+ source->InsertL(0, *(iValue->iContent));
+ source->Compress();
+ CleanupStack::PushL(source);
+
+
+ //Do the BASE64 Encoding
+ RBufReadStream readStream;
+ readStream.Open(*source);
+ VersitUtils::ConArcEncodeL(readStream, *target,
+ VersitUtils::ConArcEncodingUid(Versit::EBase64Encoding));
+ readStream.Close();
+
+ // make sure the line lengths are appropriate
+ VersitUtils::WrapLinesL(*target, KBase64MaxLineLength);
+
+ // write to output stream
+ TInt pos=0;
+ TInt len=target->Size();
+ while (pos < len)
+ {
+ TPtr8 ptr = target->Ptr(pos);
+ aStream.WriteL(ptr);
+ pos+=ptr.Length();
+ }
+ CleanupStack::PopAndDestroy(2, target);
+ }
+ }
+ aStream.WriteL(KVersitTokenCRLF);
+ }
+
+
+EXPORT_C TBool CParserPropertyValueExtendedAlarm::IsAsciiCharacterSetSufficient()
+/** Tests whether the property value can be represented using the ASCII character
+set.
+
+@return ETrue if the property value can be represented using the ASCII character
+set. If not, EFalse. */
+ {
+ if (!iValue)
+ {
+ return ETrue;
+ }
+
+ if (!iValue->iContent)
+ {
+ return ETrue;
+ }
+
+ if (iValue->iDisposition == CVersitExtendedAlarm::EDispositionUrl)
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+