|
1 /* |
|
2 * Copyright (c) 2007-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 "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: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <mmf/common/mmfcontrollerpluginresolver.h> |
|
20 |
|
21 #include "hnmdsuite.h" |
|
22 #include "hnmditem.h" |
|
23 #include "hnmdmodel.h" |
|
24 #include "hnstringhandler.h" |
|
25 #include "hnsuitemodelcontainer.h" |
|
26 #include "hnitemsorder.h" |
|
27 #include "hnconvutils.h" |
|
28 #include "hnliwutils.h" |
|
29 #include "hnutils.h" |
|
30 #include "hnfilter.h" |
|
31 #include "menudebug.h" |
|
32 #include "hnactionmodel.h" |
|
33 #include "hnmdaction.h" |
|
34 #include "hnmdservicecommand.h" |
|
35 #include "hnmdlocalization.h" |
|
36 #include "hnmdqueries.h" |
|
37 #include "hnmdquery.h" |
|
38 #include "hnrepositorymanager.h" |
|
39 #include "hnmdbasekey.h" |
|
40 #include "hninterface.h" |
|
41 #include "hnservicehandler.h" |
|
42 #include "hnmdeventmapping.h" |
|
43 |
|
44 |
|
45 // ======== MEMBER FUNCTIONS ======== |
|
46 |
|
47 // --------------------------------------------------------------------------- |
|
48 // |
|
49 // --------------------------------------------------------------------------- |
|
50 // |
|
51 EXPORT_C CLiwGenericParamList& CHnMdSuite::GetSuiteParameters() |
|
52 { |
|
53 return *iSuiteParams; |
|
54 } |
|
55 |
|
56 // --------------------------------------------------------------------------- |
|
57 // |
|
58 // --------------------------------------------------------------------------- |
|
59 // |
|
60 EXPORT_C void CHnMdSuite::SetSuiteParametersL(CLiwGenericParamList& aParams) |
|
61 { |
|
62 iSuiteParams->Reset(); |
|
63 iSuiteParams->AppendL( aParams ); |
|
64 } |
|
65 |
|
66 // --------------------------------------------------------------------------- |
|
67 // |
|
68 // --------------------------------------------------------------------------- |
|
69 // |
|
70 void CHnMdSuite::ConstructL( TXmlEngElement aElement ) |
|
71 { |
|
72 DEBUG(("_MM_: CHnMdSuite::ConstructL IN")); |
|
73 |
|
74 // append localization elements |
|
75 iCmnPtrs->iLocalization->AppendLocalizationsL( aElement ); |
|
76 |
|
77 RXmlEngNodeList<TXmlEngElement> elements; |
|
78 CleanupClosePushL( elements ); |
|
79 aElement.GetChildElements( elements ); |
|
80 |
|
81 // suite element was found |
|
82 TBool suiteFound( EFalse ); |
|
83 |
|
84 // one suite per file |
|
85 TXmlEngElement suiteElement; |
|
86 while ( elements.HasNext() ) |
|
87 { |
|
88 suiteElement = elements.Next(); |
|
89 if ( !suiteElement.Name().Compare( KSuiteElementName8 ) ) |
|
90 { |
|
91 suiteFound = ETrue; |
|
92 break; |
|
93 } |
|
94 } |
|
95 |
|
96 if ( suiteFound ) |
|
97 { |
|
98 // set event mapping |
|
99 iEventMapping = CHnMdEventMapping::NewL( suiteElement, iCmnPtrs ); |
|
100 |
|
101 // set genre |
|
102 SetGenreL( suiteElement.AttributeNodeL( KGenreAttrName8 ) ); |
|
103 |
|
104 // set widget type |
|
105 // widget needs to be set before template will be set |
|
106 SetWidgetTypeL( suiteElement.AttributeNodeL( KWidgetTypeAttrName8 ) ); |
|
107 |
|
108 // set template |
|
109 SetTemplateL( suiteElement.AttributeNodeL( KTemplateAttrName8 ) ); |
|
110 |
|
111 // set name |
|
112 SetTitleL( suiteElement.AttributeNodeL( KTitleAttrName8 ) ); |
|
113 |
|
114 // set empty text |
|
115 SetEmptyTextL( suiteElement.AttributeNodeL( KEmptyTextAttrName8 ) ); |
|
116 |
|
117 // set custom identifier |
|
118 SetCustomIdL( suiteElement ); |
|
119 |
|
120 // set entries |
|
121 CreateItemsL( suiteElement, iCmnPtrs ); |
|
122 |
|
123 // set queries |
|
124 iQueries = CHnMdQueries::NewL( suiteElement ); |
|
125 |
|
126 // set cached parameters |
|
127 iSuiteParams = CLiwGenericParamList::NewL(); |
|
128 } |
|
129 else |
|
130 { |
|
131 // definiotion of the suite was not found! |
|
132 DEBUG(("_MM_: CHnMdSuite::ConstructL Suite definition not found!")); |
|
133 User::Leave( KErrNotFound ); |
|
134 } |
|
135 |
|
136 CleanupStack::PopAndDestroy( &elements ); |
|
137 DEBUG(("_MM_: CHnMdSuite::ConstructL OUT")); |
|
138 } |
|
139 |
|
140 // --------------------------------------------------------------------------- |
|
141 // |
|
142 // --------------------------------------------------------------------------- |
|
143 // |
|
144 CHnMdSuite* CHnMdSuite::NewL(TXmlEngElement aElement, |
|
145 THnMdCommonPointers* aCmnPtrs) |
|
146 { |
|
147 CHnMdSuite* self = CHnMdSuite::NewLC( aElement, aCmnPtrs ); |
|
148 CleanupStack::Pop( self ); |
|
149 return self; |
|
150 } |
|
151 |
|
152 // --------------------------------------------------------------------------- |
|
153 // |
|
154 // --------------------------------------------------------------------------- |
|
155 // |
|
156 CHnMdSuite* CHnMdSuite::NewLC(TXmlEngElement aElement, |
|
157 THnMdCommonPointers* aCmnPtrs) |
|
158 { |
|
159 CHnMdSuite* self = new( ELeave ) CHnMdSuite( aCmnPtrs ); |
|
160 CleanupStack::PushL( self ); |
|
161 self->ConstructL( aElement ); |
|
162 return self; |
|
163 } |
|
164 |
|
165 // --------------------------------------------------------------------------- |
|
166 // |
|
167 // --------------------------------------------------------------------------- |
|
168 // |
|
169 CHnMdSuite::CHnMdSuite( THnMdCommonPointers* aCmnPtrs ) |
|
170 : iCmnPtrs( aCmnPtrs ), iAllowableTemplate(NULL) |
|
171 { |
|
172 } |
|
173 |
|
174 // --------------------------------------------------------------------------- |
|
175 // |
|
176 // --------------------------------------------------------------------------- |
|
177 // |
|
178 CHnMdSuite::~CHnMdSuite() |
|
179 { |
|
180 iAllowableWidgetType.Close(); |
|
181 delete iAllowableTemplate; |
|
182 delete iEventMapping; |
|
183 iSuiteName.Close(); |
|
184 iItems.ResetAndDestroy(); |
|
185 iTemplate.Close(); |
|
186 iTitle.Close(); |
|
187 iEmptyText.Close(); |
|
188 iCustomId8.Close(); |
|
189 delete iQueries; |
|
190 delete iSuiteParams; |
|
191 iAllowedTypes.Close(); |
|
192 delete iQc; |
|
193 } |
|
194 |
|
195 // --------------------------------------------------------------------------- |
|
196 // |
|
197 // --------------------------------------------------------------------------- |
|
198 // |
|
199 TInt CHnMdSuite::EvaluateL( CHnSuiteModel & aSuiteModel ) |
|
200 { |
|
201 MMPERF(("CHnMdSuite::EvaluateL - START")); |
|
202 aSuiteModel.GetItemsOrder()->DefineModelItemCountL( iItems.Count() ); |
|
203 if( iEvaluationNeeded ) |
|
204 { |
|
205 EvaluateSuiteItselfL( aSuiteModel ); |
|
206 MMPERF(("CHnMdSuite::EvaluateL - suite evaluated")); |
|
207 iEvaluationNeeded = EFalse; |
|
208 } |
|
209 for( TInt i( 0 ); i < iItems.Count(); i++ ) |
|
210 { |
|
211 CHnMdItem * item = iItems[i]; |
|
212 item->SetAlternativeTemplateL( GetAlternativeWidgetNumber() ); |
|
213 item->EvaluateItemL( aSuiteModel, GetSuiteParameters(), i ); |
|
214 } |
|
215 |
|
216 MMPERF(("CHnMdSuite::EvaluateL - items evaluated - DONE")); |
|
217 return KErrNone; |
|
218 } |
|
219 |
|
220 // --------------------------------------------------------------------------- |
|
221 // |
|
222 // --------------------------------------------------------------------------- |
|
223 // |
|
224 void CHnMdSuite::MarkEvaluationL( CHnFilter& aFilter, CHnSuiteModel& aSuiteModel ) |
|
225 { |
|
226 if (aFilter.HasSuiteId()) |
|
227 { |
|
228 if (aSuiteModel.CustomId() == aFilter.SuiteId() ) |
|
229 { |
|
230 if ( aFilter.IsEvaluateSuite() ) |
|
231 { |
|
232 iEvaluationNeeded = ETrue; |
|
233 } |
|
234 for (TInt item(0); item < iItems.Count(); item++) |
|
235 { |
|
236 iItems[item]->MarkEvaluationL( aFilter ); |
|
237 } |
|
238 } |
|
239 else |
|
240 { |
|
241 for (TInt itemIter(0); itemIter < iItems.Count(); itemIter++) |
|
242 { |
|
243 RArray< TInt > ids; |
|
244 CleanupClosePushL( ids ); |
|
245 aSuiteModel.GetItemsOrder()->GetIdsForL( itemIter, ids); |
|
246 for (TInt idsIter(0); idsIter < ids.Count(); idsIter++) |
|
247 { |
|
248 if (aFilter.SuiteId() == ids[idsIter]) |
|
249 { |
|
250 iItems[itemIter]->MarkEvaluationL( aFilter ); |
|
251 if (aFilter.IsEvaluateSuite()) |
|
252 { |
|
253 iEvaluationNeeded = ETrue; |
|
254 } |
|
255 } |
|
256 } |
|
257 CleanupStack::PopAndDestroy( &ids ); |
|
258 } |
|
259 } |
|
260 } |
|
261 else if( aFilter.HasSuiteName() ) |
|
262 { |
|
263 if( !SuiteName().Compare( aFilter.SuiteName()) ) |
|
264 { |
|
265 if ( aFilter.IsEvaluateSuite() ) |
|
266 { |
|
267 iEvaluationNeeded = ETrue; |
|
268 } |
|
269 for( TInt i( 0 ); i < iItems.Count(); i++ ) |
|
270 { |
|
271 iItems[i]->MarkEvaluationL( aFilter ); |
|
272 } |
|
273 } |
|
274 } |
|
275 else |
|
276 { |
|
277 if( aFilter.IsEvaluateSuite() ) |
|
278 { |
|
279 iEvaluationNeeded = ETrue; |
|
280 } |
|
281 for( TInt i( 0 ); i < iItems.Count(); i++ ) |
|
282 { |
|
283 iItems[i]->MarkEvaluationL( aFilter ); |
|
284 } |
|
285 } |
|
286 } |
|
287 // --------------------------------------------------------------------------- |
|
288 // |
|
289 // --------------------------------------------------------------------------- |
|
290 // |
|
291 void CHnMdSuite::CreateItemsL( TXmlEngElement aElement, |
|
292 THnMdCommonPointers* aCmnPtrs ) |
|
293 { |
|
294 ASSERT( aElement.Name() == KSuiteElementName8 ); |
|
295 |
|
296 // construction... |
|
297 RXmlEngNodeList< TXmlEngElement > elements; |
|
298 CleanupClosePushL( elements ); |
|
299 aElement.GetChildElements( elements ); |
|
300 |
|
301 TInt elementsCount = elements.Count(); |
|
302 |
|
303 for (TInt j = 0; j < elementsCount; j++ ) |
|
304 { |
|
305 TXmlEngElement element = elements.Next(); |
|
306 if ( !element.Name().Compare( KItemElementName8 ) ) |
|
307 { |
|
308 CHnMdItem *item = CHnMdItem::NewL( element, aCmnPtrs ); |
|
309 CleanupStack::PushL( item ); |
|
310 iItems.AppendL( item ); |
|
311 CleanupStack::Pop( item ); |
|
312 } |
|
313 } |
|
314 CleanupStack::PopAndDestroy( &elements ); |
|
315 } |
|
316 |
|
317 // --------------------------------------------------------------------------- |
|
318 // |
|
319 // --------------------------------------------------------------------------- |
|
320 // |
|
321 void CHnMdSuite::SetGenreL(const TDesC& aGenre) |
|
322 { |
|
323 iSuiteName.Close(); |
|
324 iSuiteName.CreateL( aGenre ); |
|
325 iSuiteName.LowerCase(); |
|
326 DEBUG16(("\t_MM_: suite attribute (genre): %S", &aGenre )); |
|
327 } |
|
328 |
|
329 // --------------------------------------------------------------------------- |
|
330 // |
|
331 // --------------------------------------------------------------------------- |
|
332 // |
|
333 void CHnMdSuite::SetGenreL(TXmlEngAttr aGenre) |
|
334 { |
|
335 HBufC* genre = HnConvUtils::Str8ToStrLC( aGenre.Value() ); |
|
336 SetGenreL(*genre); |
|
337 // clean up |
|
338 CleanupStack::PopAndDestroy(genre); |
|
339 } |
|
340 |
|
341 // --------------------------------------------------------------------------- |
|
342 // |
|
343 // --------------------------------------------------------------------------- |
|
344 // |
|
345 void CHnMdSuite::SetTemplateL( TXmlEngAttr aTemplate ) |
|
346 { |
|
347 SetTemplateL( aTemplate.Value() ); |
|
348 } |
|
349 |
|
350 // --------------------------------------------------------------------------- |
|
351 // |
|
352 // --------------------------------------------------------------------------- |
|
353 // |
|
354 void CHnMdSuite::SetTemplateL( const TDesC8& aTemplate ) |
|
355 { |
|
356 delete iAllowableTemplate; |
|
357 iAllowableTemplate = NULL; |
|
358 iAllowableTemplate = new ( ELeave ) CDesC8ArrayFlat( 3 ); |
|
359 |
|
360 for (int i = 0; i < HnUtils::GetColumnTextColumnCount( aTemplate ); i++) |
|
361 { |
|
362 HBufC8* templateBuf = HnUtils::GetColumnTextLC( i, aTemplate ); |
|
363 templateBuf->Des().Trim(); |
|
364 iAllowableTemplate->AppendL( *templateBuf ); |
|
365 CleanupStack::PopAndDestroy(templateBuf); |
|
366 } |
|
367 SetAlternativeTemplateL( GetAlternativeWidgetNumber() ); |
|
368 } |
|
369 |
|
370 // --------------------------------------------------------------------------- |
|
371 // |
|
372 // --------------------------------------------------------------------------- |
|
373 // |
|
374 void CHnMdSuite::AddInternalStateL( CLiwGenericParamList& aParamList ) |
|
375 { |
|
376 TLiwGenericParam param; |
|
377 param.PushL(); |
|
378 |
|
379 CLiwDefaultMap* suiteMap = CLiwDefaultMap::NewL(); |
|
380 suiteMap->PushL(); |
|
381 |
|
382 TLiwVariant suiteWidgetTypeVariant; |
|
383 suiteWidgetTypeVariant.PushL(); |
|
384 |
|
385 CLiwDefaultMap* widgetTypeMap = CLiwDefaultMap::NewL(); |
|
386 widgetTypeMap->PushL(); |
|
387 |
|
388 if ( iWidgetType == EGridWidget ) |
|
389 { |
|
390 widgetTypeMap->InsertL( KWidgetType8(), KWidgetTypeGrid8() ); |
|
391 } |
|
392 else if ( iWidgetType == EListWidget ) |
|
393 { |
|
394 widgetTypeMap->InsertL( KWidgetType8(), KWidgetTypeList8() ); |
|
395 } |
|
396 else if ( iWidgetType == ECoverFlowWidget ) |
|
397 { |
|
398 widgetTypeMap->InsertL( KWidgetType8(), KWidgetTypeCoverFlow8() ); |
|
399 } |
|
400 |
|
401 widgetTypeMap->InsertL( KAllowedTypes8(), iAllowedTypes ); |
|
402 |
|
403 suiteWidgetTypeVariant.Set( widgetTypeMap ); |
|
404 |
|
405 // add suite widget type |
|
406 suiteMap->InsertL( KSuite8(), suiteWidgetTypeVariant ); |
|
407 aParamList.Remove( KMm8 ); |
|
408 |
|
409 // set internal state |
|
410 param.SetNameAndValueL( KMm8, TLiwVariant( suiteMap ) ); |
|
411 aParamList.AppendL( param ); |
|
412 |
|
413 CleanupStack::PopAndDestroy( widgetTypeMap ); |
|
414 CleanupStack::PopAndDestroy( &suiteWidgetTypeVariant ); |
|
415 CleanupStack::PopAndDestroy( suiteMap ); |
|
416 CleanupStack::PopAndDestroy( ¶m ); |
|
417 } |
|
418 |
|
419 // --------------------------------------------------------------------------- |
|
420 // |
|
421 // --------------------------------------------------------------------------- |
|
422 // |
|
423 void CHnMdSuite::DoSetWidgetTypeL( TDesC8 & aConfDes ) |
|
424 { |
|
425 if ( !aConfDes.Compare( KWidgetTypeGrid8 )) |
|
426 { |
|
427 iAllowableWidgetType.AppendL( EGridWidget ); |
|
428 } |
|
429 else if ( !aConfDes.Compare( KWidgetTypeList8 ) ) |
|
430 { |
|
431 iAllowableWidgetType.AppendL( EListWidget ); |
|
432 } |
|
433 else if ( !aConfDes.Compare( KWidgetTypeCoverFlow8 ) ) |
|
434 { |
|
435 iAllowableWidgetType.AppendL( ECoverFlowWidget ); |
|
436 } |
|
437 } |
|
438 |
|
439 // --------------------------------------------------------------------------- |
|
440 // |
|
441 // --------------------------------------------------------------------------- |
|
442 // |
|
443 EXPORT_C TInt CHnMdSuite::GetAlternativeWidgetNumber() |
|
444 { |
|
445 return iAllowableWidgetType.Find( iWidgetType ); |
|
446 } |
|
447 |
|
448 // --------------------------------------------------------------------------- |
|
449 // |
|
450 // --------------------------------------------------------------------------- |
|
451 // |
|
452 void CHnMdSuite::SetAlternativeTemplateL( TInt aOption ) |
|
453 { |
|
454 iTemplate.Close(); |
|
455 if (aOption >= 0 && aOption < iAllowableTemplate->Count()) |
|
456 { |
|
457 const TDesC8 & val = (*iAllowableTemplate)[aOption]; |
|
458 iTemplate.CreateL(val.Length()); |
|
459 iTemplate.Copy(val); |
|
460 iTemplate.Trim(); |
|
461 } |
|
462 else |
|
463 { |
|
464 iTemplate.CreateL( KNullDesC8() ); |
|
465 } |
|
466 } |
|
467 |
|
468 // --------------------------------------------------------------------------- |
|
469 // |
|
470 // --------------------------------------------------------------------------- |
|
471 // |
|
472 void CHnMdSuite::SetAlternativeTemplateL( CLiwGenericParamList& aParams ) |
|
473 { |
|
474 RBuf8 logicalTemplate; |
|
475 logicalTemplate.CleanupClosePushL(); |
|
476 if ( KErrNone == HnLiwUtils::GetStringL( |
|
477 aParams, KTemplatePath8, logicalTemplate ) && |
|
478 KErrNone != logicalTemplate.Compare( KTemplatePath8 ) && |
|
479 logicalTemplate.Length() ) |
|
480 { |
|
481 SetTemplateL( logicalTemplate ); |
|
482 } |
|
483 else |
|
484 { |
|
485 SetAlternativeTemplateL( GetAlternativeWidgetNumber() ); |
|
486 } |
|
487 CleanupStack::PopAndDestroy( &logicalTemplate ); |
|
488 } |
|
489 |
|
490 // --------------------------------------------------------------------------- |
|
491 // |
|
492 // --------------------------------------------------------------------------- |
|
493 // |
|
494 TBool CHnMdSuite::ReadWidgetTypeFromServiceL( CLiwGenericParamList& aParams, |
|
495 RBuf8& aWidgetType ) |
|
496 { |
|
497 return |
|
498 HnLiwUtils::GetStringL( aParams, KWidgetTypePath8, aWidgetType ) == KErrNone |
|
499 && aWidgetType.Compare( KWidgetTypePath8 ) != KErrNone |
|
500 && aWidgetType.Length(); |
|
501 } |
|
502 |
|
503 // --------------------------------------------------------------------------- |
|
504 // |
|
505 // --------------------------------------------------------------------------- |
|
506 // |
|
507 void CHnMdSuite::SetAlternativeWidgetL( CLiwGenericParamList& aParams ) |
|
508 { |
|
509 RBuf8 widget; |
|
510 widget.CleanupClosePushL(); |
|
511 if ( ReadWidgetTypeFromServiceL( aParams, widget ) ) |
|
512 { |
|
513 iAllowableWidgetType.Reset(); |
|
514 SetWidgetTypeL( widget ); |
|
515 } |
|
516 else |
|
517 { |
|
518 ReadWidgetTypeL(); |
|
519 } |
|
520 CleanupStack::PopAndDestroy( &widget ); |
|
521 } |
|
522 |
|
523 // --------------------------------------------------------------------------- |
|
524 // |
|
525 // --------------------------------------------------------------------------- |
|
526 // |
|
527 void CHnMdSuite::SetWidgetTypeL( TXmlEngAttr aWidgetType ) |
|
528 { |
|
529 TPtrC8 widgetType = aWidgetType.Value(); |
|
530 DEBUG8(("\t_MM_: suite attribute (widget type): %S", &widgetType)); |
|
531 |
|
532 SaveWidgetTypeL( widgetType ); |
|
533 } |
|
534 |
|
535 // --------------------------------------------------------------------------- |
|
536 // |
|
537 // --------------------------------------------------------------------------- |
|
538 // |
|
539 void CHnMdSuite::SetWidgetTypeL(TDesC8& aWidgetType) |
|
540 { |
|
541 iAllowedTypes.Close(); |
|
542 iAllowedTypes.CreateL(aWidgetType); |
|
543 const TInt columnCount(HnUtils::GetColumnTextColumnCount(aWidgetType)); |
|
544 for (TInt i = 0; i < columnCount; i++) |
|
545 { |
|
546 HBufC8* type = HnUtils::GetColumnTextLC(i, aWidgetType); |
|
547 type->Des().Trim(); |
|
548 DoSetWidgetTypeL(*type); |
|
549 CleanupStack::PopAndDestroy(type); |
|
550 } |
|
551 if (iAllowableWidgetType.Count() <= 0) |
|
552 { |
|
553 User::Leave(KErrCorrupt); |
|
554 } |
|
555 iWidgetType = iAllowableWidgetType[0]; |
|
556 } |
|
557 |
|
558 // --------------------------------------------------------------------------- |
|
559 // |
|
560 // --------------------------------------------------------------------------- |
|
561 // |
|
562 void CHnMdSuite::SaveWidgetTypeL( TDesC8& aWidgetType ) |
|
563 { |
|
564 SetWidgetTypeL( aWidgetType ); |
|
565 CHnRepositoryManager* repMan = CHnRepositoryManager::NewLC(); |
|
566 |
|
567 if ( iAllowableWidgetType.Count() > 0 ) |
|
568 { |
|
569 THnSuiteWidgetType crWidgetType( EUnspecified ); |
|
570 TInt err( repMan->ReadSuiteWidgetTypeL( iSuiteName, crWidgetType ) ); |
|
571 if( !err || err == KErrNotFound ) |
|
572 { |
|
573 TInt found = iAllowableWidgetType.Find( crWidgetType ); |
|
574 if ( crWidgetType != EUnspecified && found != KErrNotFound ) |
|
575 { |
|
576 iWidgetType = crWidgetType; |
|
577 } |
|
578 else |
|
579 { |
|
580 err = repMan->StoreSuiteWidgetTypeL( iSuiteName, iWidgetType ); |
|
581 } |
|
582 } |
|
583 } |
|
584 |
|
585 CleanupStack::PopAndDestroy( repMan ); |
|
586 } |
|
587 |
|
588 |
|
589 // --------------------------------------------------------------------------- |
|
590 // |
|
591 // --------------------------------------------------------------------------- |
|
592 // |
|
593 void CHnMdSuite::SetModeL( TMdMode aMode ) |
|
594 { |
|
595 if ( iMode != aMode ) |
|
596 { |
|
597 for( TInt i( 0 ); i < iItems.Count() ; i++ ) |
|
598 { |
|
599 if( iItems[i]->HasAlternativeModeItem() ) |
|
600 { |
|
601 CHnMdItem * currentItem = iItems[i]; |
|
602 CHnMdItem * newItem = currentItem->TakeAlternativeModeItem(); |
|
603 newItem->SetAlternativeModeItem( currentItem ); |
|
604 iItems.InsertL( newItem, i ); |
|
605 iItems.Remove( i+1 ); |
|
606 } |
|
607 } |
|
608 iMode = aMode; |
|
609 } |
|
610 } |
|
611 |
|
612 // --------------------------------------------------------------------------- |
|
613 // |
|
614 // --------------------------------------------------------------------------- |
|
615 // |
|
616 TMdMode CHnMdSuite::Mode() |
|
617 { |
|
618 return iMode; |
|
619 } |
|
620 |
|
621 // --------------------------------------------------------------------------- |
|
622 // |
|
623 // --------------------------------------------------------------------------- |
|
624 // |
|
625 void CHnMdSuite::SetTitleL( TXmlEngAttr aTitle ) |
|
626 { |
|
627 iTitle.Close(); |
|
628 iTitle.CreateL( aTitle.Value().Length() ); |
|
629 iTitle.Copy( aTitle.Value() ); |
|
630 DEBUG8(("\t_MM_: suite attribute (name): %S", &iTitle)); |
|
631 } |
|
632 |
|
633 // --------------------------------------------------------------------------- |
|
634 // |
|
635 // --------------------------------------------------------------------------- |
|
636 // |
|
637 void CHnMdSuite::SetEmptyTextL( TXmlEngAttr aEmptyText ) |
|
638 { |
|
639 iEmptyText.Close(); |
|
640 iEmptyText.CreateL( aEmptyText.Value().Length() ); |
|
641 iEmptyText.Copy( aEmptyText.Value() ); |
|
642 DEBUG8(("\t_MM_: suite attribute (name): %S", &iEmptyText)); |
|
643 } |
|
644 |
|
645 // --------------------------------------------------------------------------- |
|
646 // |
|
647 // --------------------------------------------------------------------------- |
|
648 // |
|
649 // |
|
650 void CHnMdSuite::EvaluateSuiteItselfL( CHnSuiteModel & aSuiteModel ) |
|
651 { |
|
652 |
|
653 DEBUG(("_MM_: CHnMdSuite::EvaluateSuiteItselfL IN")); |
|
654 iSuiteModel = &aSuiteModel; |
|
655 //delete old query collector and create new one |
|
656 //currently running evaluations will be cancelled |
|
657 delete iQc; |
|
658 iQc = NULL; |
|
659 iQc = CHnQueryResultCollector::NewL( *iQueries, GetSuiteParameters() ); |
|
660 iQc->StartAsynchL( this ); |
|
661 } |
|
662 // --------------------------------------------------------------------------- |
|
663 // |
|
664 // --------------------------------------------------------------------------- |
|
665 // |
|
666 EXPORT_C const TDesC& CHnMdSuite::SuiteName() |
|
667 { |
|
668 return iSuiteName; |
|
669 } |
|
670 |
|
671 // --------------------------------------------------------------------------- |
|
672 // |
|
673 // --------------------------------------------------------------------------- |
|
674 // |
|
675 TInt CHnMdSuite::SaveWidgetTypeL() const |
|
676 { |
|
677 CHnRepositoryManager *repManager = CHnRepositoryManager::NewLC(); |
|
678 DEBUG8(("\t_MM_: Saving '%S' widget type to CR: %d", &iSuiteName, iWidgetType)); |
|
679 TInt ret( repManager->StoreSuiteWidgetTypeL( iSuiteName, iWidgetType ) ); |
|
680 CleanupStack::PopAndDestroy(repManager); |
|
681 return ret; |
|
682 } |
|
683 |
|
684 // --------------------------------------------------------------------------- |
|
685 // |
|
686 // --------------------------------------------------------------------------- |
|
687 // |
|
688 TInt CHnMdSuite::ReadWidgetTypeL() |
|
689 { |
|
690 TInt ret = KErrNone; |
|
691 |
|
692 if (iAllowableWidgetType.Count() <= 1) |
|
693 { |
|
694 DEBUG8(("\t_MM_: Suite '%S' is allowed to have just one widget: %d ", &iSuiteName, iWidgetType)); |
|
695 return ret; |
|
696 } |
|
697 |
|
698 CHnRepositoryManager* repManager = CHnRepositoryManager::NewLC(); |
|
699 THnSuiteWidgetType widgetType( EUnspecified ); |
|
700 TInt err( repManager->ReadSuiteWidgetTypeL( iSuiteName, widgetType ) ); |
|
701 if( ( !err || err == KErrNotFound ) && widgetType != EUnspecified ) |
|
702 { |
|
703 if ( widgetType == EChangeWidget ) |
|
704 { |
|
705 ASSERT( iAllowableWidgetType.Find( iWidgetType ) >= 0 ); |
|
706 TInt index = (iAllowableWidgetType.Find( iWidgetType ) + 1) |
|
707 % iAllowableWidgetType.Count(); |
|
708 iWidgetType = iAllowableWidgetType[index]; |
|
709 DEBUG8(("\t_MM_: Suite '%S' widget change invoked: %d", &iSuiteName, widgetType)); |
|
710 SaveWidgetTypeL(); |
|
711 } |
|
712 else if ( iAllowableWidgetType.Find( widgetType ) != KErrNotFound ) |
|
713 { |
|
714 DEBUG8(("\t_MM_: Suite '%S' sets widget: %d from CR", &iSuiteName, widgetType)); |
|
715 iWidgetType = widgetType; |
|
716 } |
|
717 } |
|
718 CleanupStack::PopAndDestroy( repManager ); |
|
719 return ret; |
|
720 } |
|
721 |
|
722 // --------------------------------------------------------------------------- |
|
723 // |
|
724 // --------------------------------------------------------------------------- |
|
725 // |
|
726 void CHnMdSuite::ResultsCollectedL( CLiwGenericParamList* aResults ) |
|
727 { |
|
728 CLiwGenericParamList* queriesResultsList = CLiwGenericParamList::NewLC(); |
|
729 queriesResultsList->AppendL( *aResults ); |
|
730 queriesResultsList->AppendL( GetSuiteParameters() ); |
|
731 |
|
732 RBuf title; |
|
733 CleanupClosePushL( title ); |
|
734 HnLiwUtils::GetStringL( *queriesResultsList, iTitle, title ); |
|
735 |
|
736 RBuf suiteTitle; |
|
737 CleanupClosePushL( suiteTitle ); |
|
738 HnStringHandler::LocaliseL( suiteTitle, title, iCmnPtrs ); |
|
739 |
|
740 DEBUG16( ( "\t_MM_: SetTitleL: %S", &suiteTitle ) ); |
|
741 iSuiteModel->SetTitleL( suiteTitle ); |
|
742 |
|
743 CleanupStack::PopAndDestroy( &suiteTitle ); |
|
744 CleanupStack::PopAndDestroy( &title ); |
|
745 |
|
746 RBuf emptyText; |
|
747 CleanupClosePushL( emptyText ); |
|
748 HnLiwUtils::GetStringL( *queriesResultsList, iEmptyText, emptyText ); |
|
749 |
|
750 RBuf emptyTextLoc; |
|
751 CleanupClosePushL( emptyTextLoc ); |
|
752 HnStringHandler::LocaliseL( emptyTextLoc, emptyText, iCmnPtrs ); |
|
753 |
|
754 DEBUG16(("\t_MM_: SetEmptyTestL: %S", &emptyTextLoc)); |
|
755 iSuiteModel->SetEmptyTextL( emptyTextLoc ); |
|
756 |
|
757 CleanupStack::PopAndDestroy( &emptyTextLoc ); |
|
758 CleanupStack::PopAndDestroy( &emptyText ); |
|
759 |
|
760 // set widget type |
|
761 SetAlternativeWidgetL( *queriesResultsList ); |
|
762 iSuiteModel->SetWidgetType( iWidgetType ); |
|
763 |
|
764 // set custom id |
|
765 SetCustomIdL( iSuiteModel, *queriesResultsList, 0 ); |
|
766 |
|
767 // set exit mode |
|
768 SetExitModeL(); |
|
769 |
|
770 // set template |
|
771 SetAlternativeTemplateL( *queriesResultsList ); |
|
772 iSuiteModel->SetTemplateL( iTemplate ); |
|
773 |
|
774 // add widget type to aParams |
|
775 AddInternalStateL( GetSuiteParameters() ); |
|
776 DEBUG(("\t_MM_: WidgetType: %d", iSuiteModel->WidgetType())); |
|
777 |
|
778 // evaluate actions |
|
779 iEventMapping->FillActionsL( iSuiteModel->GetActions(), |
|
780 *queriesResultsList ); |
|
781 |
|
782 CleanupStack::PopAndDestroy( queriesResultsList ); |
|
783 |
|
784 iSuiteModel->RefreshMulModelL( iSuiteModel->GetItemsOrder()->Count() ); |
|
785 TBool observersNotified = iSuiteModel->SuiteEvaluationFinishedL(); |
|
786 if ( observersNotified ) |
|
787 { |
|
788 iCmnPtrs->iModel->SuiteModelReadyToShowL( iSuiteModel ); |
|
789 } |
|
790 |
|
791 // set uri based highlight |
|
792 SetUriBasedHighlightL(); |
|
793 |
|
794 //DEBUG16(("\t\t_MM_: SetTemplate: ")); |
|
795 DEBUG(("_MM_: CHnMdSuite::ResultsCollectedL OUT")); |
|
796 } |
|
797 |
|
798 // --------------------------------------------------------------------------- |
|
799 // |
|
800 // --------------------------------------------------------------------------- |
|
801 // |
|
802 void CHnMdSuite::SetUriBasedHighlightL() |
|
803 { |
|
804 RBuf tmp; |
|
805 CleanupClosePushL( tmp ); |
|
806 HnLiwUtils::GetStringL( *iSuiteParams, KParamsUriHighlightSuite, tmp ); |
|
807 |
|
808 if ( !tmp.Compare( this->iSuiteName ) ) |
|
809 { |
|
810 tmp.Close(); |
|
811 HnLiwUtils::GetStringL( *iSuiteParams, KParamsUriHighlight, tmp ); |
|
812 |
|
813 TLex lexFrag( tmp ); |
|
814 TInt highLight( 0 ); |
|
815 if( !( lexFrag.Val( highLight ) ) ) |
|
816 { |
|
817 iSuiteModel->SetSuiteHighlightL( highLight ); |
|
818 } |
|
819 } |
|
820 |
|
821 CleanupStack::PopAndDestroy( &tmp ); |
|
822 } |
|
823 |
|
824 // --------------------------------------------------------------------------- |
|
825 // |
|
826 // --------------------------------------------------------------------------- |
|
827 // |
|
828 void CHnMdSuite::SetCustomIdL( TXmlEngElement aElement ) |
|
829 { |
|
830 iCustomId8.Close(); |
|
831 |
|
832 if ( aElement.HasAttributeL( KCustomId8 ) ) |
|
833 { |
|
834 TPtrC8 av = aElement.AttributeValueL( KCustomId8 ); |
|
835 iCustomId8.CreateL( av ); |
|
836 } |
|
837 else |
|
838 { |
|
839 iCustomId8.CreateL( KItemTypeUnknown8 ); |
|
840 } |
|
841 } |
|
842 |
|
843 // --------------------------------------------------------------------------- |
|
844 // |
|
845 // --------------------------------------------------------------------------- |
|
846 // |
|
847 void CHnMdSuite::SetCustomIdL( CHnSuiteModel* aSuiteModel, |
|
848 const CLiwGenericParamList& aParams, TInt aPos ) |
|
849 { |
|
850 TInt64 customId( KErrNotFound ); |
|
851 if ( KErrNone == HnLiwUtils::GetInt64L( |
|
852 aParams, iCustomId8, aPos, customId ) ) |
|
853 { |
|
854 aSuiteModel->SetCustomId( customId ); |
|
855 } |
|
856 } |
|
857 |
|
858 // --------------------------------------------------------------------------- |
|
859 // |
|
860 // --------------------------------------------------------------------------- |
|
861 // |
|
862 void CHnMdSuite::SetExitModeL() |
|
863 { |
|
864 RBuf exitMode; |
|
865 CleanupClosePushL( exitMode ); |
|
866 HnLiwUtils::GetStringL( *iSuiteParams, KExitModeParams, exitMode ); |
|
867 |
|
868 if ( !exitMode.Compare( KExitModeHide ) ) |
|
869 { |
|
870 iSuiteModel->SetExitMode( EExitModeHide ); |
|
871 } |
|
872 else |
|
873 { |
|
874 iSuiteModel->SetExitMode( EExitModeNormal ); |
|
875 } |
|
876 |
|
877 CleanupStack::PopAndDestroy( &exitMode ); |
|
878 } |
|
879 |
|
880 |
|
881 // End of file |