pimappservices/calendar/client/src/calentryimpl.cpp
branchRCL_3
changeset 66 bd7edf625bdd
parent 65 12af337248b1
child 74 97232defd20e
equal deleted inserted replaced
65:12af337248b1 66:bd7edf625bdd
   214 	}
   214 	}
   215 
   215 
   216 
   216 
   217 void CCalEntryImpl::AddAttendeeL(CCalAttendee* aAttendee)
   217 void CCalEntryImpl::AddAttendeeL(CCalAttendee* aAttendee)
   218 	{
   218 	{
   219 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
   219     if (!aAttendee)
   220 						User::Leave(KErrNotSupported));
   220         {
   221 
   221         User::Leave( KErrArgument );
   222 	if (!aAttendee)
   222         }
   223 		{
       
   224 		User::Leave( KErrArgument );
       
   225 		}
       
   226 
   223 
   227 	CleanupStack::PushL(aAttendee);
   224 	CleanupStack::PushL(aAttendee);
   228 	__ASSERT_ALWAYS(aAttendee != NULL, User::Leave(KErrArgument));
   225 	__ASSERT_ALWAYS(aAttendee != NULL, User::Leave(KErrArgument));
   229 	PopulateAttendeeListL();
   226 	PopulateAttendeeListL();
   230 
   227 
   263 	iFullEntry->DeleteAttendee(aIndex);
   260 	iFullEntry->DeleteAttendee(aIndex);
   264 	}
   261 	}
   265 
   262 
   266 void CCalEntryImpl::SetOrganizerL(CCalUser* aUser)
   263 void CCalEntryImpl::SetOrganizerL(CCalUser* aUser)
   267 	{
   264 	{
   268 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   269 							User::Leave(KErrNotSupported));
       
   270 
       
   271 	CleanupStack::PushL(aUser);
   265 	CleanupStack::PushL(aUser);
   272 	__ASSERT_ALWAYS(aUser != NULL, User::Leave(KErrArgument));
   266 	__ASSERT_ALWAYS(aUser != NULL, User::Leave(KErrArgument));
   273 	LoadFullEntryL();
   267 	LoadFullEntryL();
   274 	
   268 	
   275 	aUser->Impl()->SetOwnsCAgnAttendee(EFalse);
   269 	aUser->Impl()->SetOwnsCAgnAttendee(EFalse);
   280 	CleanupStack::Pop(aUser);
   274 	CleanupStack::Pop(aUser);
   281 	}
   275 	}
   282 
   276 
   283 void CCalEntryImpl::SetPhoneOwnerL(const CCalUser* aOwner)
   277 void CCalEntryImpl::SetPhoneOwnerL(const CCalUser* aOwner)
   284 	{
   278 	{
   285 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   286 							User::Leave(KErrNotSupported));
       
   287 	__ASSERT_ALWAYS(aOwner != NULL, User::Leave(KErrArgument));
   279 	__ASSERT_ALWAYS(aOwner != NULL, User::Leave(KErrArgument));
   288 	LoadFullEntryL();
   280 	LoadFullEntryL();
   289 	CCalUserImpl* userImpl = aOwner->Impl();
   281 	CCalUserImpl* userImpl = aOwner->Impl();
   290 	iFullEntry->SetPhoneOwnerL(userImpl->Attendee());
   282 	iFullEntry->SetPhoneOwnerL(userImpl->Attendee());
   291 	}
   283 	}
   355 	return rptDef->CloneTzRulesL();
   347 	return rptDef->CloneTzRulesL();
   356 	}
   348 	}
   357 
   349 
   358 void CCalEntryImpl::SetTzRulesL(const CTzRules& aTzRules)
   350 void CCalEntryImpl::SetTzRulesL(const CTzRules& aTzRules)
   359 	{
   351 	{
   360 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   361 								User::Leave(KErrNotSupported));
       
   362 	LoadFullEntryL();
   352 	LoadFullEntryL();
   363 	
   353 	
   364 	if (TimeMode() == MAgnCalendarTimeMode::EFloating)
   354 	if (TimeMode() == MAgnCalendarTimeMode::EFloating)
   365 		{
   355 		{
   366 		User::Leave(KErrArgument);
   356 		User::Leave(KErrArgument);
   376 	rptDef->SetTimeZoneL(aTzRules); // rptDef doesn't take ownership of aTzRules
   366 	rptDef->SetTimeZoneL(aTzRules); // rptDef doesn't take ownership of aTzRules
   377 	}
   367 	}
   378 
   368 
   379 void CCalEntryImpl::SetTzRulesL()
   369 void CCalEntryImpl::SetTzRulesL()
   380 	{
   370 	{
   381 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   382 							   User::Leave(KErrNotSupported));
       
   383 	LoadFullEntryL();
   371 	LoadFullEntryL();
   384 	
   372 	
   385 	if (TimeMode() == MAgnCalendarTimeMode::EFloating)
   373 	if (TimeMode() == MAgnCalendarTimeMode::EFloating)
   386 		{
   374 		{
   387 		User::Leave(KErrArgument);
   375 		User::Leave(KErrArgument);
   395 	rptDef->SetTimeZoneL();
   383 	rptDef->SetTimeZoneL();
   396 	}
   384 	}
   397 
   385 
   398 void CCalEntryImpl::SetRDatesL(const RArray<TCalTime>& aRDates)
   386 void CCalEntryImpl::SetRDatesL(const RArray<TCalTime>& aRDates)
   399 	{
   387 	{
   400 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   401 								User::Leave(KErrNotSupported));
       
   402 	LoadFullEntryL();
   388 	LoadFullEntryL();
   403 	SetDatesL(ETrue, aRDates);
   389 	SetDatesL(ETrue, aRDates);
   404 	}
   390 	}
   405 
   391 
   406 void CCalEntryImpl::SetExceptionDatesL(const RArray<TCalTime>& aExDates)
   392 void CCalEntryImpl::SetExceptionDatesL(const RArray<TCalTime>& aExDates)
   407 	{
   393 	{
   408 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   409 								User::Leave(KErrNotSupported));
       
   410 	LoadFullEntryL();
   394 	LoadFullEntryL();
   411 	
   395 	
   412 	if (iFullEntry->RptDef() == NULL)
   396 	if (iFullEntry->RptDef() == NULL)
   413 		{
   397 		{
   414 		User::Leave(KErrNotFound);
   398 		User::Leave(KErrNotFound);
   574 	return *iCalCategoryList;
   558 	return *iCalCategoryList;
   575 	}
   559 	}
   576 
   560 
   577 void CCalEntryImpl::AddCategoryL(CCalCategory* aCategory)
   561 void CCalEntryImpl::AddCategoryL(CCalCategory* aCategory)
   578 	{
   562 	{
   579 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   580 						User::Leave(KErrNotSupported));
       
   581 
       
   582 	CleanupStack::PushL(aCategory);
   563 	CleanupStack::PushL(aCategory);
   583 	__ASSERT_ALWAYS(aCategory != NULL, User::Leave(KErrArgument));
   564 	__ASSERT_ALWAYS(aCategory != NULL, User::Leave(KErrArgument));
   584 	
   565 	
   585  	PopulateCategoryListL();
   566  	PopulateCategoryListL();
   586 
   567 
   603  	aCategory->Impl()->SetOwnAgnCategory(EFalse);
   584  	aCategory->Impl()->SetOwnAgnCategory(EFalse);
   604 	}
   585 	}
   605 
   586 
   606 void CCalEntryImpl::DeleteCategoryL(TInt aIndex)
   587 void CCalEntryImpl::DeleteCategoryL(TInt aIndex)
   607 	{
   588 	{
   608 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   609 						User::Leave(KErrNotSupported));
       
   610 	LoadFullEntryL();
   589 	LoadFullEntryL();
   611 	
   590 	
   612 	if (aIndex < 0 || aIndex >= iFullEntry->CategoryCount())
   591 	if (aIndex < 0 || aIndex >= iFullEntry->CategoryCount())
   613 		{
   592 		{
   614 		User::Leave(KErrArgument);
   593 		User::Leave(KErrArgument);
   849 	iFullEntry->SetCollectionId(collectionId);
   828 	iFullEntry->SetCollectionId(collectionId);
   850 	}
   829 	}
   851 
   830 
   852 void CCalEntryImpl::SetAlarmL(CCalAlarm* aAlarm)
   831 void CCalEntryImpl::SetAlarmL(CCalAlarm* aAlarm)
   853 	{
   832 	{
   854 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   855 						User::Leave(KErrNotSupported));
       
   856 
       
   857 	LoadFullEntryL();
   833 	LoadFullEntryL();
   858 	
   834 	
   859 	if ( aAlarm == NULL ) 
   835 	if ( aAlarm == NULL ) 
   860 		{
   836 		{
   861 		// if aAlarm is NULL, clear the alarm data
   837 		// if aAlarm is NULL, clear the alarm data
   960     	}
   936     	}
   961 	}
   937 	}
   962 
   938 
   963 void CCalEntryImpl::SetRRuleL(const TCalRRule& aRpt)
   939 void CCalEntryImpl::SetRRuleL(const TCalRRule& aRpt)
   964 	{
   940 	{
   965 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
   966 						User::Leave(KErrNotSupported));
       
   967 
       
   968 	if (aRpt.Until().TimeLocalL() != Time::NullTTime() && aRpt.DtStart().TimeLocalL() >= aRpt.Until().TimeLocalL())
   941 	if (aRpt.Until().TimeLocalL() != Time::NullTTime() && aRpt.DtStart().TimeLocalL() >= aRpt.Until().TimeLocalL())
   969 		{
   942 		{
   970 		// if Until time is set to earlier than the start time and is non-NULL, leave
   943 		// if Until time is set to earlier than the start time and is non-NULL, leave
   971 		User::Leave(KErrArgument);
   944 		User::Leave(KErrArgument);
   972 		}
   945 		}
  1231 	return dTStampTime;
  1204 	return dTStampTime;
  1232 	}
  1205 	}
  1233 
  1206 
  1234 void CCalEntryImpl::SetLocationL(const TDesC& aLocation)
  1207 void CCalEntryImpl::SetLocationL(const TDesC& aLocation)
  1235 	{
  1208 	{
  1236 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
  1237 						User::Leave(KErrNotSupported));
       
  1238 	LoadFullEntryL();
  1209 	LoadFullEntryL();
  1239 	iFullEntry->SetLocationL(aLocation);
  1210 	iFullEntry->SetLocationL(aLocation);
  1240 	}
  1211 	}
  1241 
  1212 
  1242 const TDesC& CCalEntryImpl::LocationL()
  1213 const TDesC& CCalEntryImpl::LocationL()
  1245 	return iFullEntry->Location();
  1216 	return iFullEntry->Location();
  1246 	}
  1217 	}
  1247 
  1218 
  1248 void CCalEntryImpl::SetPriorityL(TUint aPriority)
  1219 void CCalEntryImpl::SetPriorityL(TUint aPriority)
  1249 	{
  1220 	{
  1250 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
  1251 						User::Leave(KErrNotSupported));
       
  1252 	LoadFullEntryL();
  1221 	LoadFullEntryL();
  1253 	iFullEntry->SetPriority(aPriority);
  1222 	iFullEntry->SetPriority(aPriority);
  1254 	}
  1223 	}
  1255 
  1224 
  1256 TUint CCalEntryImpl::PriorityL()
  1225 TUint CCalEntryImpl::PriorityL()
  1273 	return calEndTime;
  1242 	return calEndTime;
  1274 	}
  1243 	}
  1275 
  1244 
  1276 void CCalEntryImpl::SetStartAndEndTimeL(const TCalTime& aStartTime, const TCalTime& aEndTime)
  1245 void CCalEntryImpl::SetStartAndEndTimeL(const TCalTime& aStartTime, const TCalTime& aEndTime)
  1277 	{
  1246 	{
  1278 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
  1279 						User::Leave(KErrNotSupported));
       
  1280 	LoadFullEntryL();
  1247 	LoadFullEntryL();
  1281 	TCalTime::TTimeMode mode = aStartTime.TimeMode();
  1248 	TCalTime::TTimeMode mode = aStartTime.TimeMode();
  1282 	if (aEndTime.TimeUtcL() != Time::NullTTime())
  1249 	if (aEndTime.TimeUtcL() != Time::NullTTime())
  1283 		{
  1250 		{
  1284 		if (aStartTime.TimeUtcL() != Time::NullTTime())
  1251 		if (aStartTime.TimeUtcL() != Time::NullTTime())
  1377 		}
  1344 		}
  1378 	}
  1345 	}
  1379 
  1346 
  1380 void CCalEntryImpl::SetSummaryL(const TDesC& aSummary)
  1347 void CCalEntryImpl::SetSummaryL(const TDesC& aSummary)
  1381 	{
  1348 	{
  1382 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
  1383 			User::Leave(KErrNotSupported));
       
  1384 	LoadFullEntryL();
  1349 	LoadFullEntryL();
  1385 	HBufC* summ = aSummary.AllocL();
  1350 	HBufC* summ = aSummary.AllocL();
  1386 	iFullEntry->SetSummary(summ); // takes ownership of aSummary
  1351 	iFullEntry->SetSummary(summ); // takes ownership of aSummary
  1387 	}
  1352 	}
  1388 
  1353 
  1463 	iFullEntry->SetStatus(aStatus);
  1428 	iFullEntry->SetStatus(aStatus);
  1464 	}
  1429 	}
  1465 
  1430 
  1466 void CCalEntryImpl::SetReplicationStatusL(CCalEntry::TReplicationStatus aReplicationStatus)
  1431 void CCalEntryImpl::SetReplicationStatusL(CCalEntry::TReplicationStatus aReplicationStatus)
  1467 	{
  1432 	{
  1468 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
  1469 				User::Leave(KErrNotSupported));
       
  1470 	LoadFullEntryL();
  1433 	LoadFullEntryL();
  1471 	iFullEntry->SetReplicationStatusL(aReplicationStatus);
  1434 	iFullEntry->SetReplicationStatusL(aReplicationStatus);
  1472 	}
  1435 	}
  1473 
  1436 
  1474 CCalEntry::TReplicationStatus CCalEntryImpl::ReplicationStatusL()
  1437 CCalEntry::TReplicationStatus CCalEntryImpl::ReplicationStatusL()
  1496 	
  1459 	
  1497 void CCalEntryImpl::SetLastModifiedDateL(const TCalTime& aModifiedTime)
  1460 void CCalEntryImpl::SetLastModifiedDateL(const TCalTime& aModifiedTime)
  1498 	{
  1461 	{
  1499 	LoadFullEntryL();
  1462 	LoadFullEntryL();
  1500 	iFullEntry->SetLastModifiedDateUtc(aModifiedTime.TimeUtcL());
  1463 	iFullEntry->SetLastModifiedDateUtc(aModifiedTime.TimeUtcL());
  1501 
  1464 	}
  1502 	// for entry type ENote,set the modified time as the start/end time
  1465 	
  1503 	if(EntryTypeL() == CCalEntry::ENote)
       
  1504 		{
       
  1505 		TAgnCalendarTime agnModifiedTime =
       
  1506 				CalUtils::TCalTimeToTAgnCalendarTimeL(aModifiedTime);
       
  1507 		iFullEntry->SetStartAndEndTimeL(agnModifiedTime, agnModifiedTime);
       
  1508 		}
       
  1509 	}
       
  1510 
       
  1511 void CCalEntryImpl::SetDTStampL(const TCalTime& aDTStampTime)
  1466 void CCalEntryImpl::SetDTStampL(const TCalTime& aDTStampTime)
  1512 	{
  1467 	{
  1513 	LoadFullEntryL();
  1468 	LoadFullEntryL();
  1514 	iFullEntry->SetDTStampUtcL(aDTStampTime.TimeUtcL());
  1469 	iFullEntry->SetDTStampUtcL(aDTStampTime.TimeUtcL());
  1515 	}
  1470 	}
  1544 		return iLiteEntry->LiteEntry().CollectionId();
  1499 		return iLiteEntry->LiteEntry().CollectionId();
  1545 		}
  1500 		}
  1546 	else
  1501 	else
  1547 		{
  1502 		{
  1548 		return iFullEntry->CollectionId();
  1503 		return iFullEntry->CollectionId();
  1549 		}
  1504 		}	
  1550 	}
  1505 	}
  1551 
  1506 
  1552 CCalEntry::TTransp CCalEntryImpl::BusyStatusL()
  1507 CCalEntry::TTransp CCalEntryImpl::BusyStatusL()
  1553 	{
  1508 	{
  1554 	LoadFullEntryL();
  1509 	LoadFullEntryL();
  1555 	return iFullEntry->BusyStatus();
  1510 	return iFullEntry->BusyStatus();
  1556 	}
  1511 	}
  1557 
  1512 
  1558 void CCalEntryImpl::SetBusyStatusL(CCalEntry::TTransp aBusyStatus)
  1513 void CCalEntryImpl::SetBusyStatusL(CCalEntry::TTransp aBusyStatus)
  1559 	{
  1514 	{
  1560 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
  1561 					User::Leave(KErrNotSupported));
       
  1562 	LoadFullEntryL();
  1515 	LoadFullEntryL();
  1563 	iFullEntry->SetBusyStatusL(aBusyStatus);
  1516 	iFullEntry->SetBusyStatusL(aBusyStatus);
  1564 	}
  1517 	}
  1565 
  1518 
  1566 CCalGeoValue* CCalEntryImpl::GeoValueL()
  1519 CCalGeoValue* CCalEntryImpl::GeoValueL()
  1575 		CleanupStack::PushL(geoValue);
  1528 		CleanupStack::PushL(geoValue);
  1576 		geoValue->SetLatLongL(geoLatitude,geoLongitude);
  1529 		geoValue->SetLatLongL(geoLatitude,geoLongitude);
  1577 		CleanupStack::Pop(geoValue);
  1530 		CleanupStack::Pop(geoValue);
  1578 		return geoValue;
  1531 		return geoValue;
  1579 		}
  1532 		}
  1580 	return NULL;
  1533 	return NULL;		
  1581 	}
  1534 	}
  1582 
  1535 
  1583 void CCalEntryImpl::SetGeoValueL(const CCalGeoValue& aGeoValue)
  1536 void CCalEntryImpl::SetGeoValueL(const CCalGeoValue& aGeoValue)
  1584 	{
  1537 	{
  1585 	__ASSERT_ALWAYS( EntryTypeL() != CCalEntry::ENote,
       
  1586 					User::Leave(KErrNotSupported));
       
  1587 
       
  1588 	LoadFullEntryL();
  1538 	LoadFullEntryL();
  1589 	TReal geoLatitude;
  1539 	TReal geoLatitude;
  1590 	TReal geoLongitude;
  1540 	TReal geoLongitude;
  1591 	aGeoValue.GetLatLong(geoLatitude,geoLongitude);
  1541 	aGeoValue.GetLatLong(geoLatitude,geoLongitude);
  1592 	iFullEntry->SetGeoValueL(geoLatitude,geoLongitude);
  1542 	iFullEntry->SetGeoValueL(geoLatitude,geoLongitude);
  1705 		}
  1655 		}
  1706 	return iFullEntry;
  1656 	return iFullEntry;
  1707 	}
  1657 	}
  1708 
  1658 
  1709 void CCalEntryImpl::SetUserIntL( TUint32 aUserInt )
  1659 void CCalEntryImpl::SetUserIntL( TUint32 aUserInt )
  1710 	{
  1660     {
  1711 	SimpleEntry()->SetUserInt(aUserInt);
  1661     SimpleEntry()->SetUserInt(aUserInt);
  1712 	}
  1662     }
  1713 
  1663 
  1714 TUint32 CCalEntryImpl::UserIntL()
  1664 TUint32 CCalEntryImpl::UserIntL()
  1715 	{
  1665     {
  1716 	return SimpleEntry()->UserInt();
  1666     return SimpleEntry()->UserInt();
  1717 	}
  1667     }
  1718 
  1668 
  1719 
  1669 
  1720 //  CCalEntryIdImpl //
  1670 //  CCalEntryIdImpl //
  1721 
  1671 
  1722 CCalEntryIdImpl* CCalEntryIdImpl::NewL(TDesC8* aFlatData)
  1672 CCalEntryIdImpl* CCalEntryIdImpl::NewL(TDesC8* aFlatData)