28 #include "cpimtodoitem.h"

    28 #include "cpimtodoitem.h"

    29 #include "cpimtodopropertyconverter.h"

    29 #include "cpimtodopropertyconverter.h"

    30 #include "cpimeventpropertyconverter.h"

    30 #include "cpimeventpropertyconverter.h"

    31 #include "fs_methodcall.h"

    31 #include "fs_methodcall.h"

    32 #include "logger.h"

    32 #include "logger.h"

    34 

    34 

    35 // EXTERNAL INCLUDES

    35 // EXTERNAL INCLUDES

    36 #include <vcal.h>

    36 #include <vcal.h>

    37 

    37 

    38 // ============================ MEMBER FUNCTIONS ===============================

    38 // ============================ MEMBER FUNCTIONS ===============================

   163 //

   163 //

   164 void CPIMCalendarConverter::StreamToItemL(RReadStream& aStream, // RReadStream to be converted.

   164 void CPIMCalendarConverter::StreamToItemL(RReadStream& aStream, // RReadStream to be converted.

   165         RPointerArray<CPIMItem>& aItemArray, Versit::TVersitCharSet aCharset)

   165         RPointerArray<CPIMItem>& aItemArray, Versit::TVersitCharSet aCharset)

   166 {

   166 {

   167     JELOG2(EPim);

   167     JELOG2(EPim);

   170     CParserVCal* parser = CParserVCal::NewL();

   168     CParserVCal* parser = CParserVCal::NewL();

   171     CleanupStack::PushL(parser);

   169     CleanupStack::PushL(parser);

   172     parser->SetDefaultCharSet(aCharset);

   170     parser->SetDefaultCharSet(aCharset);

   173     parser->InternalizeL(aStream);

   171     parser->InternalizeL(aStream);

   174 

   172 

   199                 static_cast<CParserVCalEntity*>(todoArray->At(i));

   197                 static_cast<CParserVCalEntity*>(todoArray->At(i));

   200             ParserToToDoL(*entity, aItemArray);

   198             ParserToToDoL(*entity, aItemArray);

   201         }

   199         }

   202     }

   200     }

   203     CleanupStack::PopAndDestroy(3, parser); // parser, eventArray, todoArray

   201     CleanupStack::PopAndDestroy(3, parser); // parser, eventArray, todoArray

   206 }

   202 }

   207 

   203 

   208 // -----------------------------------------------------------------------------

   204 // -----------------------------------------------------------------------------

   209 // CPIMCalendarConverter::CPIMCalendarConverter

   205 // CPIMCalendarConverter::CPIMCalendarConverter

   210 // C++ default constructor can NOT contain any code, that

   206 // C++ default constructor can NOT contain any code, that

   240 //

   236 //

   241 void CPIMCalendarConverter::ParserToEventL(CParserVCalEntity& aParser,

   237 void CPIMCalendarConverter::ParserToEventL(CParserVCalEntity& aParser,

   242         RPointerArray<CPIMItem>& aItemArray)

   238         RPointerArray<CPIMItem>& aItemArray)

   243 {

   239 {

   244     JELOG2(EPim);

   240     JELOG2(EPim);

   246     CPIMEventItem* item = CPIMEventItem::NewLC(iEventValidator);

   242     CPIMEventItem* item = CPIMEventItem::NewLC(iEventValidator);

   247     TPIMDate alarm(TInt64(0));

   243     TPIMDate alarm(TInt64(0));

   248     // We don't take the ownership of the propertyArray, so the properties

   244     // We don't take the ownership of the propertyArray, so the properties

   249     // are deleted when the parser is

   245     // are deleted when the parser is

   250     CArrayPtr<CParserProperty>* propertyArray = aParser.ArrayOfProperties(

   246     CArrayPtr<CParserProperty>* propertyArray = aParser.ArrayOfProperties(

   267             TTimeIntervalSeconds interval(0);

   263             TTimeIntervalSeconds interval(0);

   268             User::LeaveIfError(startDate.SecondsFrom(alarm, interval));

   264             User::LeaveIfError(startDate.SecondsFrom(alarm, interval));

   269             item->addInt(EPIMEventAlarm, KPIMAttrNone, interval.Int());

   265             item->addInt(EPIMEventAlarm, KPIMAttrNone, interval.Int());

   270         }

   266         }

   271     }

   267     }

   273     User::LeaveIfError(aItemArray.Append(item));

   268     User::LeaveIfError(aItemArray.Append(item));

   274     CleanupStack::Pop(item); // item

   269     CleanupStack::Pop(item); // item

   275     CleanupStack::Pop(&aItemArray);

   270     CleanupStack::Pop(&aItemArray);

   276 }

   271 }

   277 

   272 

   282 //

   277 //

   283 void CPIMCalendarConverter::ParserToToDoL(CParserVCalEntity& aParser,

   278 void CPIMCalendarConverter::ParserToToDoL(CParserVCalEntity& aParser,

   284         RPointerArray<CPIMItem>& aItemArray)

   279         RPointerArray<CPIMItem>& aItemArray)

   285 {

   280 {

   286     JELOG2(EPim);

   281     JELOG2(EPim);

   288     CPIMToDoItem* item = CPIMToDoItem::NewLC(iToDoValidator);

   283     CPIMToDoItem* item = CPIMToDoItem::NewLC(iToDoValidator);

   289     TPIMDate alarm(TInt64(0));

   284     TPIMDate alarm(TInt64(0));

   290     // We don't take the ownership of the propertyArray, so the properties

   285     // We don't take the ownership of the propertyArray, so the properties

   291     // are deleted when the parser is

   286     // are deleted when the parser is

   292     CArrayPtr<CParserProperty>* propertyArray = aParser.ArrayOfProperties(

   287     CArrayPtr<CParserProperty>* propertyArray = aParser.ArrayOfProperties(

   317     }

   312     }

   318     else

   313     else

   319     {

   314     {

   320         item->AddBooleanL(EPIMToDoCompleted, KPIMAttrNone, ETrue);

   315         item->AddBooleanL(EPIMToDoCompleted, KPIMAttrNone, ETrue);

   321     }

   316     }

   323     User::LeaveIfError(aItemArray.Append(item));

   317     User::LeaveIfError(aItemArray.Append(item));

   324     CleanupStack::Pop(item); // item

   318     CleanupStack::Pop(item); // item

   325     CleanupStack::Pop(&aItemArray);

   319     CleanupStack::Pop(&aItemArray);

   326 }

   320 }

   327 

   321