MCL/sf/app/photos: comparison photosgallery/viewframework/views/gridview/src/glxgridviewmlobserver.cpp

equal deleted inserted replaced

-:b023a8d2866a
+:ea65f74e6de4
 /*
 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 // ---------------------------------------------------------------------------
 // Two-phased constructor.
 // ---------------------------------------------------------------------------
 //
 EXPORT_C CGlxGridViewMLObserver* CGlxGridViewMLObserver::NewL(
+MHgScrollBufferObserver& aHgScrollBufferObs,
 MGlxMediaList& aMediaList, CHgGrid* aHgGrid,
 TGlxFilterItemType aFilterType)
 {
 TRACER("CGlxGridViewMLObserver::NewL()");
 CGlxGridViewMLObserver* self = new (ELeave) CGlxGridViewMLObserver(
-aMediaList, aHgGrid, aFilterType);
+aHgScrollBufferObs, aMediaList, aHgGrid, aFilterType);
 CleanupStack::PushL(self);
 self->ConstructL();
 CleanupStack::Pop(self);
 return self;
 }
 // ---------------------------------------------------------------------------
 // C++ default constructor can NOT contain any code, that
 // might leave.
 // ---------------------------------------------------------------------------
 //
-CGlxGridViewMLObserver::CGlxGridViewMLObserver(MGlxMediaList& aMediaList,
+CGlxGridViewMLObserver::CGlxGridViewMLObserver(
-CHgGrid* aHgGrid, TGlxFilterItemType aFilterType) :
+MHgScrollBufferObserver& aHgScrollBufferObs,
-iMediaList(aMediaList), iHgGrid(aHgGrid), iFilterType(aFilterType)
+MGlxMediaList& aMediaList, CHgGrid* aHgGrid,
+TGlxFilterItemType aFilterType) :
+iHgScrollBufferObs(aHgScrollBufferObs), iMediaList(aMediaList), iHgGrid(
+aHgGrid), iFilterType(aFilterType)
 {
 TRACER("CGlxGridViewMLObserver::CGlxGridViewMLObserver()");
 }
 // ---------------------------------------------------------------------------
 // Symbian 2nd phase constructor can leave.
 // ---------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::ConstructL()
 {
 TRACER("CGlxGridViewMLObserver::ConstructL()");
 iMediaList.AddMediaListObserverL(this);
 // For DRm Utility
 CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();
 CleanupClosePushL(*uiUtility);
 iGridIconSize = uiUtility->GetGridIconSize();
 iItemsPerPage = uiUtility->VisibleItemsInPageGranularityL();
 CleanupStack::PopAndDestroy(uiUtility);
 iQualityTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail,
 GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth,
 iGridIconSize.iHeight ) );
 iSpeedTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail,
 GlxFullThumbnailAttributeId( EFalse,  iGridIconSize.iWidth,
 iGridIconSize.iHeight ) );
 iIconsFileName.Append(KDC_APP_BITMAP_DIR);
 iIconsFileName.Append(KGlxIconsFilename);
 iIsDefaultIconSet = EFalse;
 iDiskErrorIntimated = EFalse;
 }
 // ---------------------------------------------------------------------------
 // Destructor
 }
 // ----------------------------------------------------------------------------
 // HandleItemAddedL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleItemAddedL( TInt aStartIndex, TInt aEndIndex,
 MGlxMediaList* aList )
 {
 TRACER("CGlxGridViewMLObserver::HandleItemAddedL()");
 GLX_DEBUG3("CGlxGridViewMLObserver::HandleItemAddedL() aStartIndex(%d),"
 " aEndIndex(%d)", aStartIndex, aEndIndex);
 {
 #ifdef _DEBUG
 TTime startTime;
 GLX_LOG_INFO("CGlxGridViewMLObserver::HandleItemAddedL - ResizeL(+)");
 startTime.HomeTime();
 #endif
 iHgGrid->ResizeL(aList->Count());
 #ifdef _DEBUG
 TTime stopTime;
 stopTime.HomeTime();
 GLX_DEBUG2("CGlxGridViewMLObserver::HandleItemAddedL - ResizeL(-) took <%d> us",
 (TInt)stopTime.MicroSecondsFrom(startTime).Int64());
 #endif
 }
 else
 {
 for (TInt i = aStartIndex; i <= aEndIndex; i++)
 {
 }
 // ----------------------------------------------------------------------------
 // HandleItemRemoved
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleItemRemovedL( TInt aStartIndex,
 TInt aEndIndex, MGlxMediaList* aList )
 {
 TRACER("CGlxGridViewMLObserver::HandleItemRemovedL()");
+GLX_DEBUG3("CGlxGridViewMLObserver::HandleItemRemovedL() aStartIndex(%d), aEndIndex(%d)",
+aStartIndex, aEndIndex);
 if (iHgGrid)
 {
 TInt mediaCount = aList->Count();
+// If the last item is also deleted, refresh the view
-for (TInt i = aEndIndex; i>= aStartIndex; i--)
+if (mediaCount <= 0)
 {
-iHgGrid->RemoveItem(i);
+if (iMediaList.VisibleWindowIndex() > iMediaList.Count())
-}
-	    // If the last item is also deleted, this refreshes the view
-	    if (mediaCount <=0)
-	        {
-if(iMediaList.VisibleWindowIndex() > iMediaList.Count())
 {
 iMediaList.SetVisibleWindowIndexL(0);
 }
-			//This is done since the Hg doesnot refresh the screen
+//This is done since the Hg doesnot refresh the screen
-			//when we remove all the items from the grid
+//when we remove all the items from the grid
-	        iHgGrid->DrawDeferred();
+GLX_LOG_INFO("CGlxGridViewMLObserver::HandleItemRemovedL - Hg Reset");
-	        iHgGrid->Reset();
+iHgGrid->DrawDeferred();
-			return;
+iHgGrid->Reset();
-	        }
+return;
-	    else if (iMediaList.VisibleWindowIndex() > iMediaList.Count())
+}
-{
-iMediaList.SetVisibleWindowIndexL(iMediaList.Count()-1);
+if (aStartIndex == aEndIndex)
-}
+{
-iHgGrid->RefreshScreen(iHgGrid->FirstIndexOnScreen());
+iHgGrid->RemoveItem(aStartIndex);
+}
+else
+{
+GLX_LOG_INFO("CGlxGridViewMLObserver::HandleItemRemovedL - Hg RemoveItems(+)");
+// Need to disable the buffering support until HgGrid data model
+// is synced with Medialist; Otherwise, RequestL would result in
+// requesting same index for the no of items removed.
+iHgGrid->DisableScrollBuffer();
+for (TInt i = aEndIndex; i >= aStartIndex; i--)
+{
+iHgGrid->RemoveItem(i);
+}
+// Enable Buffer support
+iHgGrid->EnableScrollBufferL(iHgScrollBufferObs, (KNoOfPages
+* iItemsPerPage), KBufferTresholdSize);
+GLX_LOG_INFO("CGlxGridViewMLObserver::HandleItemRemovedL - Hg RemoveItems(-)");
+}
+if (iMediaList.VisibleWindowIndex() > iMediaList.Count())
+{
+iMediaList.SetVisibleWindowIndexL(iMediaList.Count() - 1);
+}
+iHgGrid->RefreshScreen(iHgGrid->FirstIndexOnScreen());
 }
 }
 // ----------------------------------------------------------------------------
 // HandleAttributesAvailableL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleAttributesAvailableL( TInt aItemIndex,
 const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* /*aList*/ )
 {
 TRACER("CGlxGridViewMLObserver::HandleAttributesAvailableL()");
 GLX_LOG_INFO1("CGlxGridViewMLObserver::HandleAttributesAvailableL "
 "aItemIndex(%d)", aItemIndex);
 SetIconL(aItemIndex, EMbmGlxiconsQgn_prop_image_corrupted,
 EMbmGlxiconsQgn_prop_image_corrupted_mask,
 					CHgItem::EHgItemFlagsNone);
 }
 }
 //Now Update the items with the DRM/video icon and  date/time
 UpdateItemsL(aItemIndex,aAttributes);
 //Now refresh the screen based on the attributes available index
 RefreshScreenL(aItemIndex,aAttributes);
 }
 // ----------------------------------------------------------------------------
 // HandleFocusChangedL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleFocusChangedL( NGlxListDefs::
 TFocusChangeType /*aType*/, TInt aNewIndex, TInt aOldIndex,
 MGlxMediaList* /*aList*/ )
 {
 TRACER("CGlxGridViewMLObserver::HandleFocusChangedL()");
 if (aOldIndex != KErrNotFound)
 {
 }
 // ----------------------------------------------------------------------------
 // HandleItemSelected
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleItemSelectedL(TInt /*aIndex*/,
 TBool /*aSelected*/, MGlxMediaList* /*aList*/ )
 {
 TRACER("CGlxGridViewMLObserver::HandleItemSelectedL()");
 }
 // ----------------------------------------------------------------------------
 // HandleMessageL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleMessageL( const CMPXMessage& /*aMessage*/,
 MGlxMediaList* /*aList*/ )
 {
 TRACER("CGlxGridViewMLObserver::HandleMessageL()");
 }
 // ----------------------------------------------------------------------------
 // HandleError
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleError( TInt /*aError*/ )
 {
 TRACER("CGlxGridViewMLObserver::HandleError()");
 TRAP_IGNORE(HandleErrorL());
 }
 void CGlxGridViewMLObserver::HandleErrorL()
 {
 TRACER("CGlxGridViewMLObserver::HandleErrorL()");
 TInt bitmapId  = EMbmGlxiconsQgn_prop_image_corrupted;
 TInt maskId = EMbmGlxiconsQgn_prop_image_corrupted_mask;
 TInt flags     = CHgItem::EHgItemFlagsNone ;
 for ( TInt i = 0; i < iMediaList.Count(); i++ )
 {
 const TGlxMedia& item = iMediaList.Item( i );
 TInt thumbnailError = GlxErrorManager::HasAttributeErrorL(
 item.Properties(), KGlxMediaIdThumbnail );
 if (KErrNone != thumbnailError)
 {
 switch (thumbnailError)
 {
 case KErrCANoRights:;   // Err id = -17452
 maskId = EMbmGlxiconsQgn_prop_image_corrupted_mask;
 	flags = CHgItem::EHgItemFlagsNone;
 					    }
 }
 break;
 }
 SetIconL(i, bitmapId, maskId, flags);
 }
 }
 iHgGrid->RefreshScreen(iHgGrid->FirstIndexOnScreen());
 }
 // ----------------------------------------------------------------------------
 // SetIconL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::SetIconL(TInt aItemIndex, TInt aBitmapId,
 TInt aMaskId, TInt aFlags)
 {
 TRACER("CGlxGridViewMLObserver::SetIconL()");
 CFbsBitmap* bitmap = NULL;
 }
 // ----------------------------------------------------------------------------
 // HandleCommandCompleteL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleCommandCompleteL( CMPXCommand* /*aCommandResult*/,
 TInt /*aError*/, MGlxMediaList* /*aList*/ )
 {
 TRACER("CGlxGridViewMLObserver::HandleCommandCompleteL()");
 }
 // ----------------------------------------------------------------------------
 // HandleMediaL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleMediaL( TInt /*aListIndex*/, MGlxMediaList* /*aList*/ )
 {
 TRACER("CGlxGridViewMLObserver::HandleMediaL()");
 }
 CleanupStack::PopAndDestroy(emptyText);
 }
 GLX_DEBUG2("GridMLObserver::HandlePopulatedL() iMediaList.Count()=%d",
 iMediaList.Count());
 if (iMediaList.Count() <= 0)
 {
 GLX_DEBUG1("GridMLObserver::HandlePopulatedL() - SetEmptyTextL()");
 iHgGrid->DrawNow();
 }
 GLX_DEBUG1("GridMLObserver::HandlePopulatedL() - SetDefaultIconL()");
 SetDefaultIconL(ETrue);
 }
 }
 // ----------------------------------------------------------------------------
 // HandleItemModifiedL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::HandleItemModifiedL(const RArray<TInt>& aItemIndexes,
 MGlxMediaList* /*aList*/)
 {
 TRACER("CGlxGridViewMLObserver::HandleItemModifiedL()");
 for(TInt index = 0;index<aItemIndexes.Count();index++)
 {
 TInt modifiedIndex = aItemIndexes[index];
 iModifiedIndexes.AppendL(modifiedIndex);
 }
 }
 // ----------------------------------------------------------------------------
 // HasRelevantThumbnailAttribute
 // ----------------------------------------------------------------------------
 //
 TBool CGlxGridViewMLObserver::HasRelevantThumbnail(TInt aIndex)
 iQualityTnAttrib );
 const CGlxThumbnailAttribute* speedTn = item.ThumbnailAttribute(
 iSpeedTnAttrib );
 if ( qualityTn || speedTn )
 {
 GLX_DEBUG1("GridMLObserver::HasRelevantThumbnail() - TN avail");
 return ETrue;
 }
 return EFalse;
 }
 // ----------------------------------------------------------------------------
 // RefreshScreenL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::RefreshScreenL(TInt aItemIndex,
 const RArray<TMPXAttribute>& aAttributes)
 {
 TRACER("CGlxGridViewMLObserver::RefreshScreenL()");
 GLX_DEBUG2("CGlxGridViewMLObserver::RefreshScreenL(%d)", aItemIndex);
 {
 if (HasRelevantThumbnail(lastOnScreen) && HasRelevantThumbnail(
 firstIndex))
 {
 GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 " RefreshScreen - aItemIndex(%d)", aItemIndex);
 iHgGrid->RefreshScreen(aItemIndex);
 }
 }
 if (!iIsDefaultIconSet)
 {
 GLX_DEBUG1("GridMLObserver::HandleAttributesAvailableL()"
 " SetDefaultIconL() - 1");
 SetDefaultIconL(EFalse);
 if ( HasRelevantThumbnail(firstIndex) )
 {
 if ( HasRelevantThumbnail(lastOnScreen) )
 {
 GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 " RefreshScreen - aItemIndex(%d)", aItemIndex);
 iHgGrid->RefreshScreen(aItemIndex);
 }
 else if (aItemIndex == lastOnScreen)
 {
 GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 " RefreshScreen - lastOnScreen(%d)", lastOnScreen);
 iHgGrid->RefreshScreen(lastOnScreen);
 }
 }
 if (!iIsDefaultIconSet)
 {
 GLX_DEBUG1("GridMLObserver::HandleAttributesAvailableL()"
 " SetDefaultIconL() - 2");
 SetDefaultIconL(EFalse);
 }
 }
 }
 if (iModifiedIndexes.Count() > 0)
 {
 for(TInt index = 0;index<iModifiedIndexes.Count();index++)
 {
 if (iModifiedIndexes[index] == aItemIndex &&
 			                     HasRelevantThumbnail(aItemIndex))
 {
 GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 " RefreshScreen - modified index(%d)", aItemIndex);
 iHgGrid->RefreshScreen(aItemIndex);
 iModifiedIndexes.Compress();
 }
 }
 }
 }
 // ----------------------------------------------------------------------------
 // UpdateItemsL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::UpdateItemsL(TInt aItemIndex,
 const RArray<TMPXAttribute>& aAttributes)
 {
 TRACER("CGlxGridViewMLObserver::UpdateItemsL()");
 TInt mediaCount = iMediaList.Count();
 const TGlxMedia& item = iMediaList.Item( aItemIndex );
 TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 if (aAttributes.Find(KMPXMediaDrmProtected, match) != KErrNotFound)
 {
 if (item.IsDrmProtected())
 {
 const TDesC& uri = item.Uri();
 {
 /*
 * fix for EABI-7RKHDG
 * to show the invalid DRM icon
 */
 TMPXGeneralCategory  cat = item.Category();
 TBool checkViewRights = (cat==EMPXImage);
 if(iDRMUtility->ItemRightsValidityCheckL(uri, checkViewRights))
 {
 iHgGrid->ItemL(aItemIndex).SetFlags(
 CHgItem::EHgItemFlagsDrmRightsValid);
 }
 {
 iHgGrid->ItemL(aItemIndex).SetFlags(
 CHgItem::EHgItemFlagsDrmRightsExpired);
 }
 }
 else
 {
 TMPXGeneralCategory  cat = item.Category();
 TBool checkViewRights = (cat==EMPXImage);
 if(iDRMUtility->ItemRightsValidityCheckL(uri, checkViewRights))
 {
 iHgGrid->ItemL(aItemIndex).SetFlags(
 CHgItem::EHgItemFlagsDrmRightsValid);
 }
 }
 }
 }
 }
 }
 if (aAttributes.Find(KMPXMediaGeneralDate, match) != KErrNotFound)
 {
 TTime time(0);
 if (item.GetDate(time))
 {
 iHgGrid->ItemL(aItemIndex).SetTime(time);
 }
 }
 if (aAttributes.Find(KMPXMediaGeneralCategory, match) != KErrNotFound)
 {
 if (item.Category() == EMPXVideo)
 {
 iHgGrid->ItemL(aItemIndex).SetFlags(CHgItem::EHgItemFlagsVideo);
 }
 }
 }
 // ----------------------------------------------------------------------------
 // DisplayErrorNoteL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::DisplayErrorNoteL(TInt aError)
 {
 TRACER("CGlxGridViewMLObserver::DisplayErrorNoteL()");
 GLX_LOG_INFO1("CGlxGridViewMLObserver::DisplayErrorNoteL() "
 " aError(%d)", aError);
 }
 // ----------------------------------------------------------------------------
 // SetDefaultIconL
 // ----------------------------------------------------------------------------
 //
 void CGlxGridViewMLObserver::SetDefaultIconL(TBool aTransparent)
 {
 TRACER("CGlxGridViewMLObserver::SetDefaultIconL()");
 GLX_LOG_INFO1("CGlxGridViewMLObserver::SetDefaultIconL() "
 " aTransparent(%d)", aTransparent);
 CFbsBitmap* mask = new (ELeave) CFbsBitmap();
 		CleanupStack::PushL(mask);
 TSize bmpSize = CHgGrid::PreferredImageSize();
 bitmap->Create(bmpSize, EColor16M);
 mask->Create(bmpSize, EGray256); // Gray mask
 const TInt scanlineLength = bmpSize.iWidth; // 1 byte per pixel
 RBuf8 maskData;
 maskData.Create(scanlineLength);
 maskData.FillZ(scanlineLength); // Init with zero
 mask->BeginDataAccess();
 maskData.Close();
 mask->EndDataAccess();
 iHgGrid->SetDefaultIconL(CGulIcon::NewL(bitmap, mask));
 CleanupStack::Pop(mask);
 CleanupStack::Pop(bitmap);
 }
 else if (!iIsDefaultIconSet)
 {
 CFbsBitmap* bitmap = NULL;
 CFbsBitmap* mask = NULL;

branch	RCL_3
changeset 24	ea65f74e6de4
parent 21	f9e827349359