Mercurial Mercurial > oss > FCL > sf > app > photos / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
photosgallery/viewframework/views/gridview/src/glxgridviewmlobserver.cpp
branchRCL_3
changeset 32 78ad99c24f08
parent 30 a60acebbbd9d
child 35 420f6808bf21
equal deleted inserted replaced
30:a60acebbbd9d 32:78ad99c24f08 
    89     iMediaList.AddMediaListObserverL(this);
 
    89     iMediaList.AddMediaListObserverL(this);
 
    90     // For DRm Utility
 
    90     // For DRm Utility
 
    91     iDRMUtility = CGlxDRMUtility::InstanceL();
 
    91     iDRMUtility = CGlxDRMUtility::InstanceL();
 
    92 
    92 
    93     CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();
 
    93     CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();
 
       
    94     CleanupClosePushL(*uiUtility);
 
    94     iGridIconSize = uiUtility->GetGridIconSize();
 
    95     iGridIconSize = uiUtility->GetGridIconSize();
 
    95     iItemsPerPage = uiUtility->VisibleItemsInPageGranularityL();
 
    96     iItemsPerPage = uiUtility->VisibleItemsInPageGranularityL();
 
    96     uiUtility->Close() ;
 
    97     CleanupStack::PopAndDestroy(uiUtility);
 
    97     
    98     
    98     iQualityTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail, 
    99     iQualityTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail, 
    99         GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth, 
   100         GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth, 
   100                 iGridIconSize.iHeight ) );
 
   101                 iGridIconSize.iHeight ) );
 
   101 
   102 
   102     iSpeedTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail, 
   103     iSpeedTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail, 
   103         GlxFullThumbnailAttributeId( EFalse,  iGridIconSize.iWidth, 
   104         GlxFullThumbnailAttributeId( EFalse,  iGridIconSize.iWidth, 
   104                 iGridIconSize.iHeight ) );
 
   105                 iGridIconSize.iHeight ) );
 
   105     
   106     
   106     iDiskErrorIntimated = EFalse ;
 
   107     iIconsFileName.Append(KDC_APP_BITMAP_DIR);
 
       
   108     iIconsFileName.Append(KGlxIconsFilename);
 
       
   109     iIsDefaultIconSet = EFalse;
 
       
   110     
       
   111     iDiskErrorIntimated = EFalse;
 
   107     }
 
   112     }
 
   108 
   113 
   109 // ---------------------------------------------------------------------------
 
   114 // ---------------------------------------------------------------------------
 
   110 // Destructor
 
   115 // Destructor
 
   111 // ---------------------------------------------------------------------------
 
   116 // ---------------------------------------------------------------------------
 
   137         return;
 
   142         return;
 
   138         }
 
   143         }
 
   139 
   144 
   140     if ((aEndIndex - aStartIndex) > KRecreateGridSize)
 
   145     if ((aEndIndex - aStartIndex) > KRecreateGridSize)
 
   141         {
 
   146         {
 
       
   147 #ifdef _DEBUG
 
       
   148         TTime startTime;
 
       
   149         GLX_LOG_INFO("CGlxGridViewMLObserver::HandleItemAddedL - ResizeL(+)");
 
       
   150         startTime.HomeTime();
 
       
   151 #endif    
   142         iHgGrid->ResizeL(aList->Count());
 
   152         iHgGrid->ResizeL(aList->Count());
 
       
   153 #ifdef _DEBUG
 
       
   154         TTime stopTime;
 
       
   155         stopTime.HomeTime();
 
       
   156         GLX_DEBUG2("CGlxGridViewMLObserver::HandleItemAddedL - ResizeL(-) took <%d> us",
 
       
   157                 (TInt)stopTime.MicroSecondsFrom(startTime).Int64());
 
       
   158 #endif         
   143         }
 
   159         }
 
   144     else
 
   160     else
 
   145         {
 
   161         {
 
   146         for (TInt i = aStartIndex; i <= aEndIndex; i++)
 
   162         for (TInt i = aStartIndex; i <= aEndIndex; i++)
 
   147             {
 
   163             {
 
   211     TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 
   227     TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 
   212     if (KErrNotFound != aAttributes.Find( iQualityTnAttrib, match ) ||
 
   228     if (KErrNotFound != aAttributes.Find( iQualityTnAttrib, match ) ||
 
   213         KErrNotFound != aAttributes.Find( iSpeedTnAttrib, match ))
 
   229         KErrNotFound != aAttributes.Find( iSpeedTnAttrib, match ))
 
   214         {
 
   230         {
 
   215         const TGlxMedia& item = iMediaList.Item( aItemIndex );
 
   231         const TGlxMedia& item = iMediaList.Item( aItemIndex );
 
   216         TFileName resFile(KDC_APP_BITMAP_DIR);
 
       
   217         resFile.Append(KGlxIconsFilename);
 
       
   218         TSize setSize = CHgGrid::PreferredImageSize();
 
   232         TSize setSize = CHgGrid::PreferredImageSize();
 
   219 
   233 
   220         const CGlxThumbnailAttribute* qualityTn = item.ThumbnailAttribute(
 
   234         const CGlxThumbnailAttribute* qualityTn = item.ThumbnailAttribute(
 
   221                                                           iQualityTnAttrib );
 
   235                                                           iQualityTnAttrib );
 
   222 
   236 
   248                             KErrArgument != tnError )
 
   262                             KErrArgument != tnError )
 
   249             {
 
   263             {
 
   250             CFbsBitmap* bitmap = NULL;
 
   264             CFbsBitmap* bitmap = NULL;
 
   251             CFbsBitmap* mask = NULL;
 
   265             CFbsBitmap* mask = NULL;
 
   252             AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
 
   266             AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
 
   253                     bitmap, mask, resFile,
 
   267                     bitmap, mask, iIconsFileName,
 
   254                     EMbmGlxiconsQgn_prop_image_corrupted,
 
   268                     EMbmGlxiconsQgn_prop_image_corrupted,
 
   255                     EMbmGlxiconsQgn_prop_image_corrupted_mask);
 
   269                     EMbmGlxiconsQgn_prop_image_corrupted_mask);
 
   256             __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
 
   270             __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
 
   257             __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));
 
   271             __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));
 
   258             
   272             
   259             AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize(),
 
   273             AknIconUtils::SetSize(bitmap, setSize,
 
   260                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   274                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   261             AknIconUtils::SetSize(mask, CHgGrid::PreferredImageSize(),
 
   275             AknIconUtils::SetSize(mask, setSize,
 
   262                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   276                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   263 
   277 
   264             iHgGrid->ItemL(aItemIndex).SetIcon(CGulIcon::NewL(bitmap, mask));
 
   278             iHgGrid->ItemL(aItemIndex).SetIcon(CGulIcon::NewL(bitmap, mask));
 
   265             CleanupStack::Pop(mask);
 
   279             CleanupStack::Pop(mask);
 
   266             CleanupStack::Pop(bitmap);
 
   280             CleanupStack::Pop(bitmap);
 
   332     TRACER("CGlxGridViewMLObserver::HandleErrorL()");
 
   346     TRACER("CGlxGridViewMLObserver::HandleErrorL()");
 
   333 
   347 
   334     TInt bitmapId  = EMbmGlxiconsQgn_prop_image_corrupted;
 
   348     TInt bitmapId  = EMbmGlxiconsQgn_prop_image_corrupted;
 
   335     TInt maskId = EMbmGlxiconsQgn_prop_image_corrupted_mask;	
   349     TInt maskId = EMbmGlxiconsQgn_prop_image_corrupted_mask;	
   336     TInt flags     = CHgItem::EHgItemFlagsNone ;
 
   350     TInt flags     = CHgItem::EHgItemFlagsNone ;
 
       
   351     TSize setSize = CHgGrid::PreferredImageSize();
 
   337     
   352     
   338     for ( TInt i = 0; i < iMediaList.Count(); i++ )
 
   353     for ( TInt i = 0; i < iMediaList.Count(); i++ )
 
   339         {
 
   354         {
 
   340         const TGlxMedia& item = iMediaList.Item( i );
 
   355         const TGlxMedia& item = iMediaList.Item( i );
 
   341         TInt thumbnailError = GlxErrorManager::HasAttributeErrorL(
 
   356         TInt thumbnailError = GlxErrorManager::HasAttributeErrorL(
 
   364 					maskId = EMbmGlxiconsQgn_prop_image_corrupted_mask;
 
   379 					maskId = EMbmGlxiconsQgn_prop_image_corrupted_mask;
 
   365                     flags     = CHgItem::EHgItemFlagsNone ;
 
   380                     flags     = CHgItem::EHgItemFlagsNone ;
 
   366                     break;  
   381                     break;  
   367                 }
 
   382                 }
 
   368             
   383             
   369             TFileName resFile(KDC_APP_BITMAP_DIR);
 
       
   370             resFile.Append(KGlxIconsFilename);
 
       
   371 
       
   372             CFbsBitmap* bitmap = NULL;
 
   384             CFbsBitmap* bitmap = NULL;
 
   373             CFbsBitmap* mask = NULL;
 
   385             CFbsBitmap* mask = NULL;
 
   374             AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
 
   386             AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
 
   375                     bitmap, mask, resFile, bitmapId, maskId);
 
   387                     bitmap, mask, iIconsFileName, bitmapId, maskId);
 
   376             __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
 
   388             __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
 
   377             __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));
 
   389             __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));
 
   378 
   390 
   379             AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize(),
 
   391             AknIconUtils::SetSize(bitmap, setSize,
 
   380                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   392                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   381             AknIconUtils::SetSize(mask, CHgGrid::PreferredImageSize(),
 
   393             AknIconUtils::SetSize(mask, setSize,
 
   382                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   394                     EAspectRatioPreservedAndUnusedSpaceRemoved);
 
   383 
   395 
   384             iHgGrid->ItemL(i).SetIcon(CGulIcon::NewL(bitmap, mask), flags);
 
   396             iHgGrid->ItemL(i).SetIcon(CGulIcon::NewL(bitmap, mask), flags);
 
   385             CleanupStack::Pop(mask); 
   397             CleanupStack::Pop(mask); 
   386             CleanupStack::Pop(bitmap); 
   398             CleanupStack::Pop(bitmap); 
   445         if (iMediaList.Count() <= 0)
 
   457         if (iMediaList.Count() <= 0)
 
   446             {
 
   458             {
 
   447             GLX_DEBUG1("GridMLObserver::HandlePopulatedL() - SetEmptyTextL()");
 
   459             GLX_DEBUG1("GridMLObserver::HandlePopulatedL() - SetEmptyTextL()");
 
   448             iHgGrid->DrawNow();
 
   460             iHgGrid->DrawNow();
 
   449             }
 
   461             }
 
       
   462         
       
   463         GLX_DEBUG1("GridMLObserver::HandlePopulatedL() - SetDefaultIconL()");
 
       
   464         SetDefaultIconL(ETrue);
 
   450         }
 
   465         }
 
   451     }
 
   466     }
 
   452   
   467   
   453 // ----------------------------------------------------------------------------
 
   468 // ----------------------------------------------------------------------------
 
   454 // HandleItemModifiedL
 
   469 // HandleItemModifiedL
 
   516                 {
 
   531                 {
 
   517                 GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 
   532                 GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 
   518                         " RefreshScreen - aItemIndex(%d)", aItemIndex);					
   533                         " RefreshScreen - aItemIndex(%d)", aItemIndex);					
   519                 iHgGrid->RefreshScreen(aItemIndex);
 
   534                 iHgGrid->RefreshScreen(aItemIndex);
 
   520                 }
 
   535                 }
 
       
   536             }
 
       
   537         
       
   538         if (!iIsDefaultIconSet)
 
       
   539             {
 
       
   540             GLX_DEBUG1("GridMLObserver::HandleAttributesAvailableL()"
 
       
   541                      " SetDefaultIconL() - 1");
 
       
   542             SetDefaultIconL(EFalse);
 
   521             }
 
   543             }
 
   522         }
 
   544         }
 
   523     else if (aItemIndex > firstIndex && aItemIndex <= lastOnScreen)
 
   545     else if (aItemIndex > firstIndex && aItemIndex <= lastOnScreen)
 
   524         {
 
   546         {
 
   525         TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 
   547         TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 
   539                     GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 
   561                     GLX_DEBUG2("GridMLObserver::HandleAttributesAvailableL()"
 
   540                            " RefreshScreen - lastOnScreen(%d)", lastOnScreen); 
   562                            " RefreshScreen - lastOnScreen(%d)", lastOnScreen); 
   541                     iHgGrid->RefreshScreen(lastOnScreen);
 
   563                     iHgGrid->RefreshScreen(lastOnScreen);
 
   542                     }
 
   564                     }
 
   543                 }
 
   565                 }
 
       
   566             
       
   567             if (!iIsDefaultIconSet)
 
       
   568                 {
 
       
   569                 GLX_DEBUG1("GridMLObserver::HandleAttributesAvailableL()"
 
       
   570                          " SetDefaultIconL() - 2");
 
       
   571                 SetDefaultIconL(EFalse);
 
       
   572                 }
 
   544             }
 
   573             }
 
   545         }
 
   574         }
 
   546     
   575     
   547     if (iModifiedIndexes.Count() > 0)        
   576     if (iModifiedIndexes.Count() > 0)        
   548         {
 
   577         {
 
   558                 iModifiedIndexes.Compress();
 
   587                 iModifiedIndexes.Compress();
 
   559                 }
 
   588                 }
 
   560             }
 
   589             }
 
   561         }
 
   590         }
 
   562     }
 
   591     }
 
   563     
       
   564     
   592     
   565 // ----------------------------------------------------------------------------
 
   593 // ----------------------------------------------------------------------------
 
   566 // UpdateItemsL
 
   594 // UpdateItemsL
 
   567 // ----------------------------------------------------------------------------
 
   595 // ----------------------------------------------------------------------------
 
   568 // 
   596 // 
   650             " aError(%d)", aError);
 
   678             " aError(%d)", aError);
 
   651     GlxGeneralUiUtilities::ShowErrorNoteL(aError);
 
   679     GlxGeneralUiUtilities::ShowErrorNoteL(aError);
 
   652     iDiskErrorIntimated = ETrue;
 
   680     iDiskErrorIntimated = ETrue;
 
   653     return;
 
   681     return;
 
   654     }
 
   682     }
 
       
   683 
       
   684 // ----------------------------------------------------------------------------
 
       
   685 // SetDefaultIconL
 
       
   686 // ----------------------------------------------------------------------------
 
       
   687 // 
       
   688 void CGlxGridViewMLObserver::SetDefaultIconL(TBool aTransparent)
 
       
   689     {
 
       
   690     TRACER("CGlxGridViewMLObserver::SetDefaultIconL()");
 
       
   691     GLX_LOG_INFO1("CGlxGridViewMLObserver::SetDefaultIconL() "
 
       
   692             " aTransparent(%d)", aTransparent);
 
       
   693     if (aTransparent)
 
       
   694         {
 
       
   695         CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();
 
       
   696 		CleanupStack::PushL(bitmap);
 
       
   697         CFbsBitmap* mask = new (ELeave) CFbsBitmap();
 
       
   698 		CleanupStack::PushL(mask);
 
       
   699         TSize bmpSize = CHgGrid::PreferredImageSize();
 
       
   700         bitmap->Create(bmpSize, EColor16M);
 
       
   701         mask->Create(bmpSize, EGray256); // Gray mask
 
       
   702         const TInt scanlineLength = bmpSize.iWidth; // 1 byte per pixel 
       
   703         RBuf8 maskData;
 
       
   704         maskData.Create(scanlineLength);
 
       
   705         maskData.FillZ(scanlineLength); // Init with zero
 
       
   706 
       
   707         mask->BeginDataAccess();
 
       
   708         for (TInt y = 0; y < bmpSize.iHeight; y++)
 
       
   709             {
 
       
   710             mask->SetScanLine(maskData, y);
 
       
   711             }
 
       
   712 
       
   713         maskData.Close();
 
       
   714         mask->EndDataAccess();
 
       
   715         iHgGrid->SetDefaultIconL(CGulIcon::NewL(bitmap, mask));
 
       
   716         CleanupStack::Pop(mask);
 
       
   717         CleanupStack::Pop(bitmap);		
       
   718         }
 
       
   719     else if (!iIsDefaultIconSet)
 
       
   720         {
 
       
   721         CFbsBitmap* bitmap = NULL;
 
       
   722         CFbsBitmap* mask = NULL;
 
       
   723         TSize setSize = CHgGrid::PreferredImageSize();
 
       
   724 
       
   725         AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
 
       
   726                 bitmap, mask, iIconsFileName,
 
       
   727                 EMbmGlxiconsQgn_prop_image_notcreated,
 
       
   728                 EMbmGlxiconsQgn_prop_image_notcreated_mask);
 
       
   729         __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
 
       
   730         __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));
 
       
   731 
       
   732         AknIconUtils::SetSize(bitmap, setSize,
 
       
   733                 EAspectRatioPreservedAndUnusedSpaceRemoved);
 
       
   734         AknIconUtils::SetSize(mask, setSize,
 
       
   735                 EAspectRatioPreservedAndUnusedSpaceRemoved);
 
       
   736 
       
   737         iHgGrid->SetDefaultIconL(CGulIcon::NewL(bitmap, mask));
 
       
   738         CleanupStack::Pop(mask);
 
       
   739         CleanupStack::Pop(bitmap);
 
       
   740         iIsDefaultIconSet = ETrue;
 
       
   741         }
 
       
   742     }
FCL/sf/app/photos