|
1 /* |
|
2 * Copyright (c) 2008-2009 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:Implementation of preview thumbnail binding for the |
|
15 * list view |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 #include <mul/mulvisualitem.h> |
|
23 #include <mglxmedialist.h> |
|
24 #include <glxthumbnailcontext.h> |
|
25 #include <glxfilterfactory.h> // For TGlxFilterFactory |
|
26 #include <glxthumbnailattributeinfo.h> |
|
27 #include "glxpreviewthumbnailbinding.h" |
|
28 #include "glxuiutility.h" |
|
29 #include "glxmulthumbnailvarianttype.h" |
|
30 #include "glxgeneraluiutilities.h" |
|
31 |
|
32 #include <glxtracer.h> |
|
33 #include <glxlog.h> |
|
34 |
|
35 #include <glxuistd.h> // Fetch context priority def'ns |
|
36 |
|
37 const TInt KThumbnailStartTimeDelay(2000000); |
|
38 const TInt KThumbnailIntervalTimeDelay(2000000); |
|
39 const TInt KPreviewThumbnailProgressiveCount(14); // iterates from -1 to < 14 thumbnail |
|
40 const TInt KPreviewThumbnailFetchCount(15); // const that is used to fetch fifteen thumbnail |
|
41 // attributes |
|
42 const TInt KPotraitSlot(1); |
|
43 const TInt KLandscapeSlot(3); |
|
44 |
|
45 using namespace Alf; |
|
46 |
|
47 // ---------------------------------------------------------------------------- |
|
48 // NewL |
|
49 // ---------------------------------------------------------------------------- |
|
50 // |
|
51 CGlxPreviewThumbnailBinding* CGlxPreviewThumbnailBinding::NewL() |
|
52 { |
|
53 TRACER("CGlxPreviewThumbnailBinding::NewL"); |
|
54 CGlxPreviewThumbnailBinding* self = CGlxPreviewThumbnailBinding::NewLC(); |
|
55 CleanupStack::Pop(self); |
|
56 return self; |
|
57 } |
|
58 |
|
59 // ---------------------------------------------------------------------------- |
|
60 // NewLC |
|
61 // ---------------------------------------------------------------------------- |
|
62 // |
|
63 CGlxPreviewThumbnailBinding* CGlxPreviewThumbnailBinding::NewLC() |
|
64 { |
|
65 TRACER("CGlxPreviewThumbnailBinding::NewLC"); |
|
66 CGlxPreviewThumbnailBinding* self = new(ELeave)CGlxPreviewThumbnailBinding; |
|
67 self->ConstructL(); |
|
68 CleanupStack::PushL(self); |
|
69 return self; |
|
70 } |
|
71 |
|
72 // ---------------------------------------------------------------------------- |
|
73 // Constructor |
|
74 // ---------------------------------------------------------------------------- |
|
75 // |
|
76 CGlxPreviewThumbnailBinding::CGlxPreviewThumbnailBinding() |
|
77 { |
|
78 |
|
79 } |
|
80 |
|
81 // ---------------------------------------------------------------------------- |
|
82 // ConstructL |
|
83 // ---------------------------------------------------------------------------- |
|
84 // |
|
85 void CGlxPreviewThumbnailBinding::ConstructL() |
|
86 { |
|
87 TRACER("CGlxPreviewThumbnailBinding::ConstructL"); |
|
88 iUiUtility = CGlxUiUtility::UtilityL(); |
|
89 iTimer = CPeriodic::NewL( CActive::EPriorityStandard ); |
|
90 } |
|
91 |
|
92 |
|
93 // ---------------------------------------------------------------------------- |
|
94 // Destructor |
|
95 // ---------------------------------------------------------------------------- |
|
96 // |
|
97 CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding() |
|
98 { |
|
99 TRACER("CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding"); |
|
100 // close any medialist that exist |
|
101 if( iMediaList ) |
|
102 { |
|
103 iMediaList->RemoveMediaListObserver( this ); |
|
104 iMediaList->RemoveContext(iThumbnailContext); |
|
105 delete iThumbnailContext; |
|
106 iMediaList->Close(); |
|
107 iMediaList = NULL; |
|
108 } |
|
109 if ( iUiUtility) |
|
110 { |
|
111 iUiUtility->Close (); |
|
112 } |
|
113 // cancel any outstanding request of the timer |
|
114 if(iTimer->IsActive()) |
|
115 { |
|
116 iTimer->Cancel(); |
|
117 } |
|
118 delete iTimer; |
|
119 iTimer = NULL; |
|
120 iPreviewItemCount.Close(); |
|
121 |
|
122 } |
|
123 |
|
124 |
|
125 // ---------------------------------------------------------------------------- |
|
126 // CreateThumbnail |
|
127 // ---------------------------------------------------------------------------- |
|
128 // |
|
129 std::auto_ptr< GlxThumbnailVariantType > CGlxPreviewThumbnailBinding::CreateThumbnailL( TInt aIndex )const |
|
130 { |
|
131 TRACER("CGlxPreviewThumbnailBinding::CreateThumbnailL"); |
|
132 const TGlxMedia& media = iMediaList->Item( aIndex ); |
|
133 return auto_ptr< GlxThumbnailVariantType >( GlxThumbnailVariantType::NewL( media, |
|
134 iUiUtility->GetGridIconSize() ) ); |
|
135 } |
|
136 |
|
137 // ---------------------------------------------------------------------------- |
|
138 // PopulateT |
|
139 // ---------------------------------------------------------------------------- |
|
140 // |
|
141 void CGlxPreviewThumbnailBinding::PopulateT(Alf::MulVisualItem& aItem, const TGlxMedia& aMedia, |
|
142 TBool aIsFocused )const |
|
143 { |
|
144 TRACER("CGlxPreviewThumbnailBinding::PopulateT"); |
|
145 //T is used for throws as per C++ standard.Hence used instead of "L" |
|
146 //Ignoring this for code scanner warnings - Leaving functions called in non-leaving functions. |
|
147 if ( aMedia.Properties() && aIsFocused && iStartedShowingThumbnails && iProgressIndex != KErrNotFound ) |
|
148 { |
|
149 if( !iCurrentOrientationLandscape ) |
|
150 { |
|
151 |
|
152 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1, |
|
153 CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, 0 ) ).release() ); |
|
154 } |
|
155 |
|
156 // if orientation is landscape |
|
157 else |
|
158 { |
|
159 // shows thumbnials with an interval of 2 sec at different slot |
|
160 if( iMediaList->Count() > iSlots && iPreviewItemCount.Count() >= iSlots && iTimerTicked ) |
|
161 { |
|
162 GLX_LOG_INFO("inside if( iTimerTicked && iMediaList->Count() > KLandscapeSlot)"); |
|
163 SetThumbnailAttributeL(aItem); |
|
164 } |
|
165 else |
|
166 { |
|
167 // shows thumbnail simultaneously |
|
168 GLX_LOG_INFO("inside else"); |
|
169 SetInitialThumbnailAttributeL(aItem, iSlots ); |
|
170 } |
|
171 |
|
172 } // end of else |
|
173 |
|
174 |
|
175 } // end of if |
|
176 |
|
177 } |
|
178 |
|
179 // ---------------------------------------------------------------------------- |
|
180 // SetInitialThumbnailAttribute: setting initial thumbnails to slot to show |
|
181 // simutaneously |
|
182 // ---------------------------------------------------------------------------- |
|
183 // |
|
184 void CGlxPreviewThumbnailBinding::SetInitialThumbnailAttributeL(Alf::MulVisualItem& aItem, |
|
185 TInt aSlots ) const |
|
186 { |
|
187 TRACER("CGlxPreviewThumbnailBinding::SetInitialThumbnailAttribute"); |
|
188 aSlots = Min( iPreviewItemCount.Count(),aSlots ); |
|
189 switch( aSlots ) |
|
190 { |
|
191 case 1: |
|
192 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1, |
|
193 CreateThumbnailL( iPreviewItemCount[0] ).release() ); |
|
194 break; |
|
195 |
|
196 case 2: |
|
197 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon2, |
|
198 CreateThumbnailL( iPreviewItemCount[0] ).release() ); |
|
199 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1, |
|
200 CreateThumbnailL( iPreviewItemCount[1] ).release() ); |
|
201 break; |
|
202 |
|
203 case 3: |
|
204 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon3, |
|
205 CreateThumbnailL( iPreviewItemCount[0] ).release() ); |
|
206 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon2, |
|
207 CreateThumbnailL( iPreviewItemCount[1] ).release() ); |
|
208 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1, |
|
209 CreateThumbnailL( iPreviewItemCount[2] ).release() ); |
|
210 break; |
|
211 } |
|
212 } |
|
213 |
|
214 |
|
215 // function that sets the thumbnail to different slots |
|
216 // ---------------------------------------------------------------------------- |
|
217 // SetThumbnailAttribute: setting thumbnial to visual item at appropriate slot |
|
218 // ---------------------------------------------------------------------------- |
|
219 // |
|
220 void CGlxPreviewThumbnailBinding::SetThumbnailAttributeL(Alf::MulVisualItem& aItem ) const |
|
221 { |
|
222 TRACER("CGlxPreviewThumbnailBinding::SetThumbnailAttribute"); |
|
223 switch( iSlotIndex ) |
|
224 { |
|
225 case 0: |
|
226 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon3, |
|
227 CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, iSlotIndex ) ).release() ); |
|
228 |
|
229 PreviewSlotIndex( iSlots, iSlotIndex ); |
|
230 break; |
|
231 |
|
232 case 1: |
|
233 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon2, |
|
234 CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, iSlotIndex ) ).release() ); |
|
235 |
|
236 PreviewSlotIndex( iSlots, iSlotIndex ); |
|
237 break; |
|
238 |
|
239 case 2: |
|
240 aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1, |
|
241 CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, iSlotIndex ) ).release() ); |
|
242 |
|
243 PreviewSlotIndex( iSlots, iSlotIndex ); |
|
244 break; |
|
245 } |
|
246 } |
|
247 |
|
248 // ---------------------------------------------------------------------------- |
|
249 // PreviewSlotIndex: returns the next index where thumbails to be shown |
|
250 // ---------------------------------------------------------------------------- |
|
251 // |
|
252 void CGlxPreviewThumbnailBinding::PreviewSlotIndex( TInt aSlot, TInt aSlotIndex ) const |
|
253 { |
|
254 TRACER("CGlxPreviewThumbnailBinding::PreviewSlotIndex"); |
|
255 if(aSlot > aSlotIndex + 1) |
|
256 { |
|
257 iSlotIndex++; |
|
258 } |
|
259 else |
|
260 { |
|
261 iSlotIndex = 0; |
|
262 } |
|
263 } |
|
264 |
|
265 // ---------------------------------------------------------------------------- |
|
266 // MediaIndexBySlotIndex: returns the index for which to retrieve thumbnail |
|
267 // ---------------------------------------------------------------------------- |
|
268 // |
|
269 TInt CGlxPreviewThumbnailBinding::MediaIndexBySlotIndex(TInt aProgressIndex, |
|
270 TInt /*aSlotIndex*/ ) const |
|
271 { |
|
272 TRACER("CGlxPreviewThumbnailBinding::MediaIndexBySlotIndex"); |
|
273 |
|
274 return aProgressIndex; |
|
275 } |
|
276 |
|
277 |
|
278 // ---------------------------------------------------------------------------- |
|
279 // TimerTicked: we need to update only when required i.e, when the thumbnail count |
|
280 // has not reached till the max limit to be shown |
|
281 // ---------------------------------------------------------------------------- |
|
282 // |
|
283 void CGlxPreviewThumbnailBinding::TimerTicked() |
|
284 { |
|
285 //iTimerTicked = ETrue; |
|
286 TRACER("CGlxPreviewThumbnailBinding::TimerTicked"); |
|
287 iCurrentOrientationLandscape = GlxGeneralUiUtilities::IsLandscape(); |
|
288 |
|
289 if(iMediaList) |
|
290 { |
|
291 iSlots = Min( iMediaList->Count(), |
|
292 iCurrentOrientationLandscape ? KLandscapeSlot : KPotraitSlot ); |
|
293 if( iPreviewItemCount.Count() >= iSlots && iProgressIndex < KPreviewThumbnailProgressiveCount |
|
294 && iProgressIndex < iMediaList->Count()-1) |
|
295 { |
|
296 iTimerTicked = ETrue; |
|
297 iProgressIndex++; |
|
298 Update(); |
|
299 //iTimerTicked = EFalse; |
|
300 } |
|
301 else |
|
302 { |
|
303 iProgressIndex = KErrNotFound; |
|
304 //iStartedShowingThumbnails = EFalse; |
|
305 } |
|
306 } |
|
307 |
|
308 } |
|
309 |
|
310 |
|
311 // ---------------------------------------------------------------------------- |
|
312 // IsTime callback function invoked when timer expires |
|
313 // ---------------------------------------------------------------------------- |
|
314 // |
|
315 TInt CGlxPreviewThumbnailBinding::IsTime( TAny* aSelf ) |
|
316 { |
|
317 TRACER("CGlxPreviewThumbnailBinding::IsTime"); |
|
318 if (aSelf) |
|
319 { |
|
320 TRACER("CGlxPreviewThumbnailBinding::IsTime"); |
|
321 CGlxPreviewThumbnailBinding* self = static_cast<CGlxPreviewThumbnailBinding*>(aSelf); |
|
322 if(self) |
|
323 { |
|
324 self->TimerTicked(); |
|
325 } |
|
326 |
|
327 |
|
328 } |
|
329 return KErrNone; |
|
330 } |
|
331 |
|
332 // ---------------------------------------------------------------------------- |
|
333 // HandleFocusChanged |
|
334 // This function resets any existing timer and starts a new timer tick |
|
335 // ---------------------------------------------------------------------------- |
|
336 // |
|
337 |
|
338 CGlxBinding::TResponse CGlxPreviewThumbnailBinding::HandleFocusChanged( TBool aIsGained ) |
|
339 { |
|
340 TRACER("CGlxPreviewThumbnailBinding::HandleFocusChanged"); |
|
341 if(aIsGained) |
|
342 { |
|
343 if(iTimer) |
|
344 { |
|
345 iTimer->Cancel(); |
|
346 } |
|
347 |
|
348 if(!iTimer->IsActive() ) |
|
349 { |
|
350 iTimer->Start(KThumbnailStartTimeDelay, KThumbnailIntervalTimeDelay, |
|
351 TCallBack(IsTime,this)); |
|
352 |
|
353 } |
|
354 } |
|
355 //return EUpdateRequested; |
|
356 return ENoUpdateNeeded; |
|
357 } |
|
358 |
|
359 |
|
360 // ---------------------------------------------------------------------------- |
|
361 // HandleItemChangedL |
|
362 // This function basically closes the old medialist if any for ex. Tags, |
|
363 // Captured.. and then opens a new medialist with teh required filter. |
|
364 // ---------------------------------------------------------------------------- |
|
365 // |
|
366 void CGlxPreviewThumbnailBinding::HandleItemChangedL(const CMPXCollectionPath& aPath ) |
|
367 { |
|
368 TRACER("CGlxPreviewThumbnailBinding::HandleItemChangedL"); |
|
369 iStartedShowingThumbnails = EFalse; |
|
370 iTimerTicked = EFalse; |
|
371 iProgressIndex = KErrNotFound; |
|
372 iPreviewItemCount.Close(); |
|
373 // remove and close old medialist |
|
374 if( iMediaList ) |
|
375 { |
|
376 iMediaList->RemoveMediaListObserver( this ); |
|
377 iMediaList->RemoveContext(iThumbnailContext); |
|
378 delete iThumbnailContext; |
|
379 iMediaList->Close(); |
|
380 iMediaList = NULL; |
|
381 } |
|
382 |
|
383 // Filter that filters out any GIF, corrupted images |
|
384 CMPXFilter* filter = NULL; |
|
385 filter = TGlxFilterFactory::CreatePreviewFilterL(); |
|
386 CleanupStack::PushL( filter ); |
|
387 // create new medialist with the required filter which filters out all DRM, GIFS and corrupt |
|
388 // thumbnial |
|
389 iMediaList = MGlxMediaList::InstanceL( aPath ,KGlxIdNone, filter); |
|
390 iThumbnailContext = CGlxThumbnailContext::NewL( &iThumbnailIterator ); // set the thumbnail context |
|
391 iThumbnailIterator.SetRange( KPreviewThumbnailFetchCount ); // request for fifiteen thumbnails |
|
392 iThumbnailContext->SetDefaultSpec( iUiUtility->GetGridIconSize().iWidth,iUiUtility->GetGridIconSize().iHeight ); |
|
393 iMediaList->AddContextL(iThumbnailContext ,KGlxFetchContextPriorityNormal ); |
|
394 // adding the medialist to observ any changes or updates done |
|
395 iMediaList->AddMediaListObserverL(this); |
|
396 CleanupStack::PopAndDestroy( filter ); |
|
397 } |
|
398 |
|
399 |
|
400 // ---------------------------------------------------------------------------- |
|
401 // HasFirstThumbnail |
|
402 // ---------------------------------------------------------------------------- |
|
403 // |
|
404 TBool CGlxPreviewThumbnailBinding::HasFirstThumbnail( const RArray< TMPXAttribute >& aAttributes ) |
|
405 { |
|
406 TRACER("CGlxPreviewThumbnailBinding::HasFirstThumbnail"); |
|
407 TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail, |
|
408 GlxFullThumbnailAttributeId( ETrue, |
|
409 iUiUtility->GetGridIconSize().iWidth,iUiUtility->GetGridIconSize().iHeight) ); |
|
410 |
|
411 TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match ); |
|
412 return ( KErrNotFound != aAttributes.Find( thumbnailAttribute, match ) ); |
|
413 } |
|
414 // ---------------------------------------------------------------------------- |
|
415 // HandleItemAddedL |
|
416 // ---------------------------------------------------------------------------- |
|
417 // |
|
418 void CGlxPreviewThumbnailBinding::HandleItemAddedL( TInt aStartIndex, TInt |
|
419 aEndIndex, MGlxMediaList* /*aList*/ ) |
|
420 { |
|
421 TRACER("CGlxPreviewThumbnailBinding::HandleItemAddedL"); |
|
422 TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail, |
|
423 GlxFullThumbnailAttributeId( ETrue, iUiUtility->GetGridIconSize().iWidth, iUiUtility->GetGridIconSize().iHeight ) ); |
|
424 for(TInt i = aStartIndex; i <= aEndIndex; i++) |
|
425 { |
|
426 const TGlxMedia& item = iMediaList->Item( i ); |
|
427 const CGlxThumbnailAttribute* value = item.ThumbnailAttribute( thumbnailAttribute ); |
|
428 if (value) |
|
429 { |
|
430 iPreviewItemCount.AppendL( i ); |
|
431 iStartedShowingThumbnails = ETrue; |
|
432 iProgressIndex = 0; |
|
433 } |
|
434 } |
|
435 if(!iTimer->IsActive() && iMediaList && iMediaList->Count()) |
|
436 { |
|
437 GLX_LOG_INFO("CGlxPreviewThumbnailBinding::HandleItemAddedL start timer"); |
|
438 iTimer->Start(KErrNone, KThumbnailIntervalTimeDelay, TCallBack(IsTime,this)); |
|
439 } |
|
440 |
|
441 } |
|
442 |
|
443 // ---------------------------------------------------------------------------- |
|
444 // HandleItemRemoved |
|
445 // ---------------------------------------------------------------------------- |
|
446 // |
|
447 void CGlxPreviewThumbnailBinding::HandleItemRemovedL( TInt /*aStartIndex*/, TInt |
|
448 /*aEndIndex*/, MGlxMediaList* /*aList*/ ) |
|
449 { |
|
450 |
|
451 } |
|
452 |
|
453 // ---------------------------------------------------------------------------- |
|
454 // HandleAttributesAvailableL |
|
455 // Inside this function we are going to append the index for which we have valid |
|
456 // thumbnails and when the number of available thumbnails become equal to the |
|
457 // number of slots where thumbnail to be shown we go for updating them to visual |
|
458 // item. |
|
459 // ---------------------------------------------------------------------------- |
|
460 // |
|
461 void CGlxPreviewThumbnailBinding::HandleAttributesAvailableL( TInt aItemIndex, |
|
462 const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* /*aList*/ ) |
|
463 { |
|
464 TRACER("CGlxPreviewThumbnailBinding::HandleAttributesAvailableL"); |
|
465 GLX_LOG_INFO1("CGlxPreviewThumbnailBinding::HandleAttributesAvailableL aItemIndex %d ", aItemIndex); |
|
466 TInt count = aAttributes.Count(); |
|
467 // whether orientation is landscape or portrait |
|
468 iCurrentOrientationLandscape = GlxGeneralUiUtilities::IsLandscape(); |
|
469 // islots has number as to how many slots need to be filled |
|
470 iSlots = Min( iMediaList->Count(), |
|
471 iCurrentOrientationLandscape ? KLandscapeSlot : KPotraitSlot ); |
|
472 |
|
473 for(TInt i = 0; i< count; i++) |
|
474 { |
|
475 TMPXAttribute attribute = aAttributes[i]; |
|
476 } |
|
477 if( !iStartedShowingThumbnails ) |
|
478 { |
|
479 GLX_LOG_INFO(" inside if( !iStartedShowingThumbnails )"); |
|
480 iStartedShowingThumbnails = HasFirstThumbnail(aAttributes); |
|
481 if( iStartedShowingThumbnails ) |
|
482 { |
|
483 //if relevent thumbnial then add the index to an array |
|
484 GLX_LOG_INFO("inside if( iStartedShowingThumbnails"); |
|
485 iStartedShowingThumbnails = EFalse; |
|
486 iPreviewItemCount.AppendL( aItemIndex ); |
|
487 iProgressIndex++; |
|
488 // checks if the number of thumbnials are ready to display |
|
489 if(iPreviewItemCount.Count() == iSlots ) |
|
490 { |
|
491 GLX_LOG_INFO("inside if(iPreviewItemCount.Count() >= iSlots && iTimerTicked )"); |
|
492 // update the thumbnails and set the flag iStartShowingThumbnails which willbe |
|
493 // checked at the time of populating teh visual item. |
|
494 iStartedShowingThumbnails = ETrue; |
|
495 Update(); |
|
496 |
|
497 }// end of if(iPreviewItemCount.Count() == iSlots ) |
|
498 }// end of if(iStartedShowingThumbnails) |
|
499 } |
|
500 } |
|
501 |
|
502 // ---------------------------------------------------------------------------- |
|
503 // HandleFocusChangedL |
|
504 // ---------------------------------------------------------------------------- |
|
505 // |
|
506 void CGlxPreviewThumbnailBinding::HandleFocusChangedL( NGlxListDefs:: |
|
507 TFocusChangeType /*aType*/, TInt /*aNewIndex*/, TInt /*aOldIndex*/, MGlxMediaList* /*aList*/ ) |
|
508 { |
|
509 // HandleFocusChanged(ETrue); |
|
510 TRACER("CGlxPreviewThumbnailBinding::HandleFocusChangedL"); |
|
511 } |
|
512 |
|
513 // ---------- ------------------------------------------------------------------ |
|
514 // HandleItemSelected |
|
515 // ---------------------------------------------------------------------------- |
|
516 // |
|
517 void CGlxPreviewThumbnailBinding::HandleItemSelectedL(TInt /*aIndex*/, |
|
518 TBool /*aSelected*/, MGlxMediaList* /*aList*/ ) |
|
519 { |
|
520 |
|
521 } |
|
522 |
|
523 // ---------------------------------------------------------------------------- |
|
524 // HandleMessageL |
|
525 // ---------------------------------------------------------------------------- |
|
526 // |
|
527 void CGlxPreviewThumbnailBinding::HandleMessageL( const CMPXMessage& /*aMessage*/, |
|
528 MGlxMediaList* /*aList*/ ) |
|
529 { |
|
530 |
|
531 } |
|
532 |
|
533 // ---------------------------------------------------------------------------- |
|
534 // HandleError |
|
535 // ---------------------------------------------------------------------------- |
|
536 // |
|
537 void CGlxPreviewThumbnailBinding::HandleError( TInt /*aError*/ ) |
|
538 { |
|
539 |
|
540 } |
|
541 |
|
542 // ---------------------------------------------------------------------------- |
|
543 // HandleCommandCompleteL |
|
544 // ---------------------------------------------------------------------------- |
|
545 // |
|
546 void CGlxPreviewThumbnailBinding::HandleCommandCompleteL( CMPXCommand* /*aCommandResult*/, |
|
547 TInt /*aError*/, MGlxMediaList* /*aList*/ ) |
|
548 { |
|
549 |
|
550 } |
|
551 |
|
552 // ---------------------------------------------------------------------------- |
|
553 // HandleMediaL |
|
554 // ---------------------------------------------------------------------------- |
|
555 // |
|
556 void CGlxPreviewThumbnailBinding::HandleMediaL( TInt /*aListIndex*/, MGlxMediaList* /*aList*/ ) |
|
557 { |
|
558 |
|
559 } |
|
560 |
|
561 // ---------------------------------------------------------------------------- |
|
562 // HandleItemModifiedL |
|
563 // ---------------------------------------------------------------------------- |
|
564 // |
|
565 void CGlxPreviewThumbnailBinding::HandleItemModifiedL( const RArray<TInt>& /*aItemIndexes*/, |
|
566 MGlxMediaList* /*aList*/ ) |
|
567 { |
|
568 |
|
569 } |