|
1 /* |
|
2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the License "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: The client side connection to the FeedsSever. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "FeedsEntity.h" |
|
20 #include "FeedsMap.h" |
|
21 #include "PackedAttributes.h" |
|
22 #include "FeedAttributes.h" |
|
23 #include <FolderAttributes.h> |
|
24 #include "Packed.h" |
|
25 #include "PackedFeed.h" |
|
26 #include "PackedFolder.h" |
|
27 #include "FeedsInterface.h" |
|
28 |
|
29 // Constant definitions |
|
30 _LIT(KNew, "new"); |
|
31 _LIT(KRead, "read"); |
|
32 _LIT(KUnread, "unread"); |
|
33 |
|
34 // ----------------------------------------------------------------------------- |
|
35 // CFeedsEntity::ChangeValueL |
|
36 // |
|
37 // Changes attribute/Property values based on passed Map |
|
38 // ----------------------------------------------------------------------------- |
|
39 // |
|
40 EXPORT_C TInt CFeedsEntity::ChangeValueL(const CFeedsMap& aNewValues) |
|
41 { |
|
42 return iFeedInterface->SetAttributeL(*this, aNewValues); |
|
43 } |
|
44 // ----------------------------------------------------------------------------- |
|
45 // CFeedsEntity::GetStringValue |
|
46 // |
|
47 // Returns String value based on passed attribute. |
|
48 // ----------------------------------------------------------------------------- |
|
49 // |
|
50 |
|
51 EXPORT_C TInt CFeedsEntity::GetStringValue(TUint anAttribute, TPtrC& aValue) const |
|
52 { |
|
53 return iAttrProp->GetStringAttribute(anAttribute, aValue); |
|
54 } |
|
55 // ----------------------------------------------------------------------------- |
|
56 // CFeedsEntity::GetIntegerValue |
|
57 // |
|
58 // Initialises aValue with integer value of passed anAttribute. |
|
59 // ----------------------------------------------------------------------------- |
|
60 // |
|
61 |
|
62 EXPORT_C TInt CFeedsEntity::GetIntegerValue(TUint anAttribute, TInt& aValue) const |
|
63 { |
|
64 if(EFeedAttributeFeedId == anAttribute) |
|
65 { |
|
66 aValue = iFeedId; |
|
67 return KErrNone; |
|
68 } |
|
69 else |
|
70 return iAttrProp->GetIntegerAttribute(anAttribute, aValue); |
|
71 } |
|
72 // ----------------------------------------------------------------------------- |
|
73 // CFeedsEntity::GetTimeValue |
|
74 // |
|
75 // Initialises aValue with time value of passed anAttribute. |
|
76 // ----------------------------------------------------------------------------- |
|
77 // |
|
78 |
|
79 EXPORT_C TInt CFeedsEntity::GetTimeValue(TUint anAttribute, TTime& aValue) const |
|
80 { |
|
81 return iAttrProp->GetTimeAttribute(anAttribute, aValue); |
|
82 } |
|
83 |
|
84 // ----------------------------------------------------------------------------- |
|
85 // CFeedsEntity::NewL |
|
86 // |
|
87 // Two-phased constructor. |
|
88 // ----------------------------------------------------------------------------- |
|
89 // |
|
90 CFeedsEntity* CFeedsEntity::NewL(RFeedsInterface* aFeedsInterface) |
|
91 { |
|
92 CFeedsEntity* self = new (ELeave) CFeedsEntity(); |
|
93 |
|
94 CleanupStack::PushL (self); |
|
95 self->ConstructL (); |
|
96 self->SetFeedInterface (aFeedsInterface); |
|
97 CleanupStack::Pop (); |
|
98 |
|
99 return self; |
|
100 } |
|
101 |
|
102 // ----------------------------------------------------------------------------- |
|
103 // CFeedsEntity::NewL |
|
104 // |
|
105 // Two-phased constructor. |
|
106 // ----------------------------------------------------------------------------- |
|
107 // |
|
108 CFeedsEntity* CFeedsEntity::NewL(CPackedFolder* aPackedFolder, |
|
109 RFeedsInterface* aFeedsInterface) |
|
110 { |
|
111 CFeedsEntity* self = new (ELeave) CFeedsEntity(aPackedFolder); |
|
112 |
|
113 CleanupStack::PushL (self); |
|
114 self->SetFeedInterface (aFeedsInterface); |
|
115 self->ConstructL (*aPackedFolder); |
|
116 CleanupStack::Pop (); |
|
117 |
|
118 return self; |
|
119 } |
|
120 |
|
121 // ----------------------------------------------------------------------------- |
|
122 // CFeedsEntity::NewL |
|
123 // |
|
124 // Two-phased constructor. |
|
125 // ----------------------------------------------------------------------------- |
|
126 // |
|
127 CFeedsEntity* CFeedsEntity::NewL(CPackedFeed* aPackedFeed, |
|
128 RFeedsInterface* aFeedsInterface) |
|
129 { |
|
130 CFeedsEntity* self = new (ELeave) CFeedsEntity(aPackedFeed); |
|
131 |
|
132 CleanupStack::PushL (self); |
|
133 self->SetFeedInterface (aFeedsInterface); |
|
134 self->ConstructL (*aPackedFeed); |
|
135 CleanupStack::Pop (); |
|
136 |
|
137 return self; |
|
138 } |
|
139 |
|
140 // ----------------------------------------------------------------------------- |
|
141 // CFeedsEntity::NewFolderL |
|
142 // |
|
143 // Two-phased constructor. |
|
144 // ----------------------------------------------------------------------------- |
|
145 // |
|
146 CFeedsEntity* CFeedsEntity::NewFolderL(const TDesC& aTitle, TInt aEntryId, TInt aStatusCode) |
|
147 { |
|
148 CFeedsEntity* self = new (ELeave) CFeedsEntity(); |
|
149 |
|
150 CleanupStack::PushL (self); |
|
151 self->ConstructL (); |
|
152 CleanupStack::Pop (); |
|
153 |
|
154 self->iId = aEntryId; |
|
155 self->iType = EFolder; |
|
156 self->iAttrProp->SetStringAttribute (EFolderAttributeTitle, aTitle); |
|
157 self->iAttrProp->SetIntegerAttribute(EFolderAttributeStatus,aStatusCode); |
|
158 |
|
159 return self; |
|
160 } |
|
161 |
|
162 // ----------------------------------------------------------------------------- |
|
163 // CFeedsEntity::NewFeedL |
|
164 // |
|
165 // Two-phased constructor. |
|
166 // ----------------------------------------------------------------------------- |
|
167 // |
|
168 CFeedsEntity* CFeedsEntity::NewFeedL( const TDesC& aTitle, const TDesC& aUrl, |
|
169 TInt aEntryId, TInt aFeedId, const TTime& aTimestamp, TInt aStatusCode, TInt aFreq, |
|
170 const TInt& aUnreadCount) |
|
171 { |
|
172 CFeedsEntity* self = new (ELeave) CFeedsEntity(); |
|
173 |
|
174 CleanupStack::PushL (self); |
|
175 self->ConstructL (); |
|
176 CleanupStack::Pop (); |
|
177 |
|
178 self->iId = aEntryId; |
|
179 self->iType = EFeed; |
|
180 self->iAttrProp->SetStringAttribute (EFeedAttributeTitle, aTitle); |
|
181 self->iAttrProp->SetStringAttribute (EFeedAttributeLink, aUrl); |
|
182 self->iAttrProp->SetTimeAttribute (EFeedAttributeTimestamp, aTimestamp); |
|
183 self->iAttrProp->SetIntegerAttribute (EFeedAttributeAutoUpdateFreq, aFreq); |
|
184 self->iAttrProp->SetIntegerAttribute (EFolderAttributeUnreadCount, |
|
185 aUnreadCount); |
|
186 self->iFeedId = aFeedId; |
|
187 self->iAttrProp->SetIntegerAttribute(EFolderAttributeStatus,aStatusCode); |
|
188 return self; |
|
189 } |
|
190 |
|
191 // ----------------------------------------------------------------------------- |
|
192 // CFeedsEntity::NewMiniItemL |
|
193 // |
|
194 // Two-phased constructor. |
|
195 // ----------------------------------------------------------------------------- |
|
196 // |
|
197 CFeedsEntity* CFeedsEntity::NewMiniItemL() |
|
198 { |
|
199 CFeedsEntity* self = new (ELeave) CFeedsEntity(); |
|
200 |
|
201 CleanupStack::PushL (self); |
|
202 self->ConstructL (); |
|
203 CleanupStack::Pop (); |
|
204 |
|
205 self->iType = EMiniItem; |
|
206 |
|
207 return self; |
|
208 } |
|
209 |
|
210 // ----------------------------------------------------------------------------- |
|
211 // CFeedsEntity::CFeedsEntity |
|
212 // C++ default constructor can NOT contain any code, that |
|
213 // might leave. aPackedFolder is adopted |
|
214 // ----------------------------------------------------------------------------- |
|
215 // |
|
216 CFeedsEntity::CFeedsEntity(CPackedFolder* aPackedFolder) : |
|
217 iPacked((CPacked*)aPackedFolder) |
|
218 { |
|
219 } |
|
220 |
|
221 // ----------------------------------------------------------------------------- |
|
222 // CFeedsEntity::CFeedsEntity |
|
223 // C++ default constructor can NOT contain any code, that |
|
224 // might leave. aPackedFolder is adopted |
|
225 // ----------------------------------------------------------------------------- |
|
226 // |
|
227 CFeedsEntity::CFeedsEntity(CPackedFeed* aPackedFeed) : |
|
228 iPacked((CPacked*)aPackedFeed) |
|
229 { |
|
230 } |
|
231 |
|
232 // ----------------------------------------------------------------------------- |
|
233 // CFeedsEntity::CFeedsEntity |
|
234 // C++ default constructor can NOT contain any code, that |
|
235 // might leave. |
|
236 // ----------------------------------------------------------------------------- |
|
237 // |
|
238 CFeedsEntity::CFeedsEntity() |
|
239 { |
|
240 } |
|
241 |
|
242 // ----------------------------------------------------------------------------- |
|
243 // CFeedsEntity::ConstructL |
|
244 // Symbian 2nd phase constructor can leave. |
|
245 // by this method. |
|
246 // ----------------------------------------------------------------------------- |
|
247 // |
|
248 void CFeedsEntity::ConstructL() |
|
249 { |
|
250 iAttrProp = CFeedsMap::NewL (); |
|
251 } |
|
252 |
|
253 CFeedsEntity::~CFeedsEntity() |
|
254 { |
|
255 delete iAttrProp; |
|
256 iAttrProp = NULL; |
|
257 iChildren.ResetAndDestroy (); |
|
258 } |
|
259 |
|
260 // ----------------------------------------------------------------------------- |
|
261 // CFeedsEntity::ConstructL |
|
262 // Symbian 2nd phase constructor can leave. |
|
263 // by this method. |
|
264 // ----------------------------------------------------------------------------- |
|
265 // |
|
266 void CFeedsEntity::ConstructL(const CPackedFolder& aPackedFolder) |
|
267 { |
|
268 CFeedsEntity* rootFolder = NULL; |
|
269 CFeedsEntity* currentFolder = NULL; |
|
270 CFeedsEntity* folderItem = NULL; |
|
271 CFeedsEntity* miniItem = NULL; |
|
272 TPtrC title; |
|
273 TPtrC url; |
|
274 TInt entryId; |
|
275 TInt feedId; |
|
276 TTime timestamp; |
|
277 TInt freq; |
|
278 TInt unreadCount; |
|
279 TInt status; |
|
280 TBool isMiniItem = EFalse; |
|
281 TUint attribute; |
|
282 // CItemMini* miniItem = NULL; |
|
283 TPtrC attributeValue; |
|
284 |
|
285 ConstructL (); |
|
286 |
|
287 // Unpack the packed folder. |
|
288 while (aPackedFolder.HasNextToken ()) |
|
289 { |
|
290 TUint token; |
|
291 |
|
292 token = aPackedFolder.NextToken (); |
|
293 |
|
294 switch (token) |
|
295 { |
|
296 case EFolderTokenFolderBegin: |
|
297 // Get the folder item's attributes. |
|
298 aPackedFolder.ExtractAttributes (title, url, entryId, feedId, |
|
299 timestamp, unreadCount, status, freq); |
|
300 |
|
301 // CPackedFolders contain a single root folder. Because of this |
|
302 // the first folder should be treated as the root. "this" |
|
303 // becomes the root CFeedsEntity. |
|
304 if ( rootFolder == NULL) |
|
305 { |
|
306 iId = entryId; |
|
307 iType = EFolder; |
|
308 iParent = NULL; |
|
309 iAttrProp->SetStringAttribute (EFolderAttributeTitle, title); |
|
310 iAttrProp->SetIntegerAttribute(EFolderAttributeStatus,status); |
|
311 rootFolder = this; |
|
312 currentFolder = this; |
|
313 } |
|
314 |
|
315 // Otherwise create a subfolder and set its parent. |
|
316 else |
|
317 { |
|
318 folderItem = CFeedsEntity::NewFolderL (title, entryId, status); |
|
319 folderItem->SetFeedInterface (iFeedInterface); |
|
320 // Add the folder to the parent. |
|
321 User::LeaveIfError (currentFolder->iChildren.Append (folderItem)); |
|
322 folderItem->iParent = currentFolder; |
|
323 |
|
324 // Set this folder as the active folder. |
|
325 currentFolder = folderItem; |
|
326 } |
|
327 break; |
|
328 |
|
329 case EFolderTokenFolderEnd: |
|
330 // Set the current folder to its parent. |
|
331 currentFolder = const_cast<CFeedsEntity*>(currentFolder->iParent); |
|
332 break; |
|
333 |
|
334 case EFolderTokenFeed: |
|
335 // Get the folder item's attributes. |
|
336 aPackedFolder.ExtractAttributes (title, url, entryId, feedId, |
|
337 timestamp, unreadCount, status, freq); |
|
338 |
|
339 // Create the new feed and add it to the current folder. |
|
340 // folderListId is shared by all feeds/folders |
|
341 folderItem = CFeedsEntity::NewFeedL (title, url, entryId, |
|
342 feedId, timestamp, status, freq, unreadCount ); |
|
343 folderItem->SetFeedInterface (iFeedInterface); |
|
344 // Add the folder to the parent. |
|
345 User::LeaveIfError (currentFolder->iChildren.Append (folderItem)); |
|
346 folderItem->iParent = currentFolder; |
|
347 break; |
|
348 |
|
349 case EFolderTokenItemBegin: |
|
350 miniItem = CFeedsEntity::NewMiniItemL(); |
|
351 // miniItem->iType = EMiniItem; |
|
352 CleanupStack::PushL(miniItem); |
|
353 isMiniItem = ETrue; |
|
354 break; |
|
355 |
|
356 case EFolderTokenItemEnd: |
|
357 isMiniItem = EFalse; |
|
358 miniItem->SetFeedInterface (iFeedInterface); |
|
359 // folderItem->AddMiniItem(miniItem); |
|
360 User::LeaveIfError (currentFolder->iChildren.Append (miniItem)); |
|
361 // CleanupStack::Pop(miniItem); |
|
362 break; |
|
363 |
|
364 case EPackedTokenAttribute: |
|
365 aPackedFolder.ExtractAttributeValue(attribute, attributeValue); |
|
366 |
|
367 if (isMiniItem) |
|
368 { |
|
369 miniItem->SetAttribute(attribute, attributeValue); |
|
370 } |
|
371 else |
|
372 { |
|
373 // TODO: Panic. |
|
374 } |
|
375 break; |
|
376 |
|
377 |
|
378 } |
|
379 } |
|
380 } |
|
381 |
|
382 // ----------------------------------------------------------------------------- |
|
383 // CFeedsEntity::ConstructL |
|
384 // Symbian 2nd phase constructor can leave. |
|
385 // by this method. |
|
386 // ----------------------------------------------------------------------------- |
|
387 // |
|
388 void CFeedsEntity::ConstructL(const CPackedFeed& aPackedFeed) |
|
389 { |
|
390 TBool isFeed = EFalse; |
|
391 TBool isItem = EFalse; |
|
392 TBool isEnclosure = EFalse; |
|
393 |
|
394 CFeedsEntity* item = NULL; |
|
395 CFeedsEntity* enclosure = NULL; |
|
396 TUint attribute; |
|
397 TPtrC attributeValue; |
|
398 ConstructL (); |
|
399 |
|
400 // Unpack the packed feed. |
|
401 while (aPackedFeed.HasNextToken ()) |
|
402 { |
|
403 TUint token; |
|
404 |
|
405 token = aPackedFeed.NextToken (); |
|
406 |
|
407 switch (token) |
|
408 { |
|
409 case EFeedTokenFeedBegin: |
|
410 isFeed = ETrue; |
|
411 break; |
|
412 |
|
413 case EFeedTokenItemBegin: |
|
414 item = CFeedsEntity::NewL (iFeedInterface); |
|
415 item->iType = EFeedsItem; |
|
416 item->iParent = this; |
|
417 CleanupStack::PushL (item); |
|
418 isItem = ETrue; |
|
419 break; |
|
420 |
|
421 case EFeedTokenEnclosureBegin: |
|
422 enclosure = CFeedsEntity::NewL (iFeedInterface); |
|
423 enclosure->iType = EFeedsEnclosure; |
|
424 enclosure->iParent = item; |
|
425 CleanupStack::PushL (enclosure); |
|
426 isEnclosure = ETrue; |
|
427 break; |
|
428 |
|
429 case EFeedTokenFeedEnd: |
|
430 isFeed = EFalse; |
|
431 break; |
|
432 |
|
433 case EFeedTokenItemEnd: |
|
434 isItem = EFalse; |
|
435 User::LeaveIfError (iChildren.Append (item)); |
|
436 CleanupStack::Pop (item); |
|
437 break; |
|
438 |
|
439 case EFeedTokenEnclosureEnd: |
|
440 isEnclosure = EFalse; |
|
441 User::LeaveIfError (item->iChildren.Append (enclosure)); |
|
442 CleanupStack::Pop (enclosure); |
|
443 break; |
|
444 |
|
445 case EPackedTokenAttribute: |
|
446 aPackedFeed.ExtractAttributeValue (attribute, attributeValue); |
|
447 if ( isEnclosure) |
|
448 { |
|
449 enclosure->SetAttribute (attribute, attributeValue); |
|
450 } |
|
451 else |
|
452 if ( isItem) |
|
453 { |
|
454 item->SetAttribute (attribute, attributeValue); |
|
455 } |
|
456 else |
|
457 if ( isFeed) |
|
458 { |
|
459 SetAttribute (attribute, attributeValue); |
|
460 } |
|
461 else |
|
462 { |
|
463 // TODO: Panic. |
|
464 } |
|
465 break; |
|
466 |
|
467 case EFeedTokenOtherTitle: |
|
468 //iOtherTitles++; |
|
469 break; |
|
470 |
|
471 case EFeedTokenOtherDescription: |
|
472 //iOtherDescriptions++; |
|
473 break; |
|
474 |
|
475 case EFeedTokenOtherLink: |
|
476 //iOtherLinks++; |
|
477 break; |
|
478 |
|
479 default: |
|
480 // Ignore |
|
481 break; |
|
482 }; |
|
483 } |
|
484 } |
|
485 |
|
486 // ----------------------------------------------------------------------------- |
|
487 // CFeedsEntity::SetAttribute |
|
488 // |
|
489 // adds given attribute in iAttrProp Map |
|
490 // ----------------------------------------------------------------------------- |
|
491 // |
|
492 void CFeedsEntity::SetAttribute(TUint aAttribute, const TPtrC& aAttributeValue) |
|
493 { |
|
494 switch(iType) |
|
495 { |
|
496 case EFeed: |
|
497 { |
|
498 switch(aAttribute) |
|
499 { |
|
500 case EFeedAttributeUnused: |
|
501 case EFeedAttributeTitle: |
|
502 case EFeedAttributeLink: |
|
503 case EFeedAttributeDescription: |
|
504 case EFeedAttributeTimestamp: |
|
505 case EFeedAttributeImage: |
|
506 case EFeedAttributeTTL: |
|
507 case EFeedAttributeSkipHours: |
|
508 case EFeedAttributeSkipDays: |
|
509 case EFeedAttributeLanguage: |
|
510 case EFeedAttributeCopyright: |
|
511 case EFeedAttributeEditor: |
|
512 case EFeedAttributeWebMaster: |
|
513 case EFeedAttributePubDate: |
|
514 case EFeedAttributeCategory: |
|
515 case EFeedAttributeGenerator: |
|
516 case EFeedAttributeDocs: |
|
517 case EFeedAttributeCloud: |
|
518 case EFeedAttributeRating: |
|
519 case EFeedAttributeTextInput: |
|
520 case EFeedAttributeAssociatedUrl: |
|
521 case EFeedAttributeFeedUrl: |
|
522 iAttrProp->SetStringAttribute (aAttribute, aAttributeValue); |
|
523 break; |
|
524 case EFeedAttributeFeedId: |
|
525 { |
|
526 TLex lex(aAttributeValue); |
|
527 lex.Val (iFeedId); |
|
528 break; |
|
529 } |
|
530 case EFeedAttributeAutoUpdateFreq: |
|
531 { |
|
532 iAttrProp->SetStringAttribute (aAttribute, aAttributeValue); |
|
533 break; |
|
534 } |
|
535 } |
|
536 break; |
|
537 } |
|
538 case EFeedsItem: |
|
539 { |
|
540 switch(aAttribute) |
|
541 { |
|
542 case EItemAttributeTitle: |
|
543 case EItemAttributeLink: |
|
544 case EItemAttributeDescription: |
|
545 case EItemAttributeIdStr: |
|
546 case EItemAttributeEnclosure: |
|
547 case EItemAttributeTimestamp: |
|
548 case EItemAttributeImage: |
|
549 case EItemAttributeAuthor: |
|
550 case EItemAttributeCategory: |
|
551 case EItemAttributeComments: |
|
552 case EItemAttributeSource: |
|
553 iAttrProp->SetStringAttribute (aAttribute, aAttributeValue); |
|
554 break; |
|
555 |
|
556 case EItemAttributeStatus: |
|
557 { |
|
558 TInt itemStatus(EItemStatusUndefined); |
|
559 if ( aAttributeValue.CompareF (KNew)== 0) |
|
560 { |
|
561 itemStatus = EItemStatusNew; |
|
562 } |
|
563 else |
|
564 if ( aAttributeValue.CompareF (KRead)== 0) |
|
565 { |
|
566 itemStatus = EItemStatusRead; |
|
567 } |
|
568 else |
|
569 if ( aAttributeValue.CompareF (KUnread)== 0) |
|
570 { |
|
571 itemStatus = EItemStatusUnread; |
|
572 } |
|
573 iAttrProp->SetIntegerAttribute (aAttribute, itemStatus); |
|
574 } |
|
575 break; |
|
576 |
|
577 case EItemAttributeItemId: |
|
578 { |
|
579 TLex lex(aAttributeValue); |
|
580 lex.Val (iId); |
|
581 break; |
|
582 } |
|
583 } |
|
584 break; |
|
585 } |
|
586 case EFeedsEnclosure: |
|
587 { |
|
588 switch(aAttribute) |
|
589 { |
|
590 case EEnclosureAttributeContentType: |
|
591 case EEnclosureAttributeSize: |
|
592 case EEnclosureAttributeLink: |
|
593 case EEnclosureAttributeTitle: |
|
594 iAttrProp->SetStringAttribute (aAttribute, aAttributeValue); |
|
595 break; |
|
596 } |
|
597 break; |
|
598 } |
|
599 case EMiniItem: |
|
600 { |
|
601 switch(aAttribute) |
|
602 { |
|
603 case EFolderAttributeMiniItemTitle: |
|
604 iAttrProp->SetStringAttribute (aAttribute, aAttributeValue); |
|
605 break; |
|
606 case EFolderAttributeMiniItemId: |
|
607 { |
|
608 TLex16 lex(aAttributeValue); |
|
609 lex.Val(iId); |
|
610 break; |
|
611 } |
|
612 } |
|
613 break; |
|
614 } |
|
615 case EFolder: |
|
616 default: |
|
617 { |
|
618 switch(aAttribute) |
|
619 { |
|
620 case EFolderAttributeUnreadCount: |
|
621 case EFolderAttributeTitle: |
|
622 iAttrProp->SetStringAttribute (aAttribute, aAttributeValue); |
|
623 break; |
|
624 } |
|
625 break; |
|
626 } |
|
627 } |
|
628 } |
|
629 |
|
630 |
|
631 // ----------------------------------------------------------------------------- |
|
632 // CFeedsEntity::GetType |
|
633 //@return TFeedsEntityType enum |
|
634 // Gets type of CFeedsEntity (Where this represents folder/feeds/items/enclosures) |
|
635 // ----------------------------------------------------------------------------- |
|
636 // |
|
637 EXPORT_C TFeedsEntityType CFeedsEntity::GetType() const |
|
638 { |
|
639 return iType; |
|
640 } |
|
641 |
|
642 // ----------------------------------------------------------------------------- |
|
643 // CFeedsEntity::GetType |
|
644 // |
|
645 //Gets ID of feeds entity (This ID is actually unique integer value) |
|
646 // ----------------------------------------------------------------------------- |
|
647 // |
|
648 EXPORT_C TInt CFeedsEntity::GetId() const |
|
649 { |
|
650 return iId; |
|
651 } |
|
652 |
|
653 // ----------------------------------------------------------------------------- |
|
654 // CFeedsEntity::GetParent |
|
655 // |
|
656 // Returns Parent of this feeds entity (NULL if it is root folder) |
|
657 // ----------------------------------------------------------------------------- |
|
658 // |
|
659 EXPORT_C CFeedsEntity* CFeedsEntity::GetParent() const |
|
660 { |
|
661 return iParent; |
|
662 } |
|
663 |
|
664 // ----------------------------------------------------------------------------- |
|
665 // CFeedsEntity::GetChildren |
|
666 // |
|
667 // Returns RPointerArray containing all children of this CFeedsEntity |
|
668 // ----------------------------------------------------------------------------- |
|
669 // |
|
670 EXPORT_C const RPointerArray<CFeedsEntity>& CFeedsEntity::GetChildren() const |
|
671 { |
|
672 return iChildren; |
|
673 } |