Mercurial Mercurial > oss > MCL > 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 13 bcb43dc84c44
parent 9 6b87b143d312
child 14 2dac0fdba72b
equal deleted inserted replaced
12:ce1c7ad1f18b 13:bcb43dc84c44 
    19 // INCLUDE FILES
 
    19 // INCLUDE FILES
 
    20 
    20 
    21 // Ganes Headers
 
    21 // Ganes Headers
 
    22 #include <ganes/HgItem.h>
 
    22 #include <ganes/HgItem.h>
 
    23 #include <ganes/HgGrid.h>                               //Hg Grid Widget
 
    23 #include <ganes/HgGrid.h>                               //Hg Grid Widget
 
    24 //#include <hg/hgcontextutility.h>
 
       
    25 #include <gulicon.h>
 
    24 #include <gulicon.h>
 
    26 
    25 
    27 //Photos Headers
 
    26 //Photos Headers
 
    28 #include <glxtracer.h>                                  // For Tracer
 
    27 #include <glxtracer.h>                                  // For Tracer
 
    29 #include <glxlog.h>                                     // For Glx Logging
 
    28 #include <glxlog.h>                                     // For Glx Logging
 
    89     // For DRm Utility
 
    88     // For DRm Utility
 
    90     iDRMUtility = CGlxDRMUtility::InstanceL();
 
    89     iDRMUtility = CGlxDRMUtility::InstanceL();
 
    91 
    90 
    92     CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();
 
    91     CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();
 
    93     iGridIconSize = uiUtility->GetGridIconSize();
 
    92     iGridIconSize = uiUtility->GetGridIconSize();
 
    94     //Get the HgContextUtility instance
 
       
    95 //    iContextUtility = uiUtility->ContextUtility();
 
       
    96     iItemsPerPage = uiUtility->VisibleItemsInPageGranularityL();
 
    93     iItemsPerPage = uiUtility->VisibleItemsInPageGranularityL();
 
    97     uiUtility->Close() ;
 
    94     uiUtility->Close() ;
 
    98     
    95     
    99     iQualityTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail, 
    96     iQualityTnAttrib = TMPXAttribute (KGlxMediaIdThumbnail, 
   100         GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth, 
    97         GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth, 
   207     if (!iHgGrid)
 
   204     if (!iHgGrid)
 
   208         {
 
   205         {
 
   209         return;
 
   206         return;
 
   210         }
 
   207         }
 
   211 
   208 
   212     TInt mediaCount = iMediaList.Count();
 
       
   213     const TGlxMedia& item = iMediaList.Item( aItemIndex );
 
       
   214     TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 
   209     TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
 
   215     
       
   216     if (KErrNotFound != aAttributes.Find( iQualityTnAttrib, match ) ||
 
   210     if (KErrNotFound != aAttributes.Find( iQualityTnAttrib, match ) ||
 
   217         KErrNotFound != aAttributes.Find( iSpeedTnAttrib, match ))
 
   211         KErrNotFound != aAttributes.Find( iSpeedTnAttrib, match ))
 
   218         {
 
   212         {
 
       
   213         const TGlxMedia& item = iMediaList.Item( aItemIndex );
 
   219         TFileName resFile(KDC_APP_BITMAP_DIR);
 
   214         TFileName resFile(KDC_APP_BITMAP_DIR);
 
   220         resFile.Append(KGlxIconsFilename);
 
   215         resFile.Append(KGlxIconsFilename);
 
   221         TSize setSize = CHgGrid::PreferredImageSize();
 
   216         TSize setSize = CHgGrid::PreferredImageSize();
 
   222         TIconInfo icon;
 
       
   223 
   217 
   224         const CGlxThumbnailAttribute* qualityTn = item.ThumbnailAttribute(
 
   218         const CGlxThumbnailAttribute* qualityTn = item.ThumbnailAttribute(
 
   225                                                           iQualityTnAttrib );
 
   219                                                           iQualityTnAttrib );
 
   226 
   220 
   227         const CGlxThumbnailAttribute* speedTn = item.ThumbnailAttribute(
 
   221         const CGlxThumbnailAttribute* speedTn = item.ThumbnailAttribute(
 
   228                                                             iSpeedTnAttrib );
 
   222                                                             iSpeedTnAttrib );
 
   229 
   223 
   230         TInt tnError = GlxErrorManager::HasAttributeErrorL(
 
   224         TInt tnError = GlxErrorManager::HasAttributeErrorL(
 
   231                           item.Properties(), KGlxMediaIdThumbnail );
 
   225                           item.Properties(), KGlxMediaIdThumbnail );
 
       
   226         GLX_DEBUG4("GlxGridMLObs::HandleAttributesAvailableL() tnError(%d)"
 
       
   227                 "qualityTn(%x) and speedTn(%x)", qualityTn, speedTn, tnError);
 
   232 
   228 
   233         if (qualityTn)
 
   229         if (qualityTn)
 
   234             {
 
   230             {
 
   235             CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
 
   231             CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
 
   236             bitmap->Duplicate( qualityTn->iBitmap->Handle());
 
   232             bitmap->Duplicate(qualityTn->iBitmap->Handle());
 
   237             AknIconUtils::SetSize(bitmap, setSize);
 
       
   238             iHgGrid->ItemL(aItemIndex).SetIcon(CGulIcon::NewL(bitmap));
 
   233             iHgGrid->ItemL(aItemIndex).SetIcon(CGulIcon::NewL(bitmap));
 
   239             GLX_LOG_INFO1("### CGlxGridViewMLObserver::HandleAttributesAvailableL"
 
   234             GLX_LOG_INFO1("### CGlxGridViewMLObserver::HandleAttributesAvailableL"
 
   240                     " qualityTn-Index is %d",aItemIndex);
 
   235                     " qualityTn-Index is %d",aItemIndex);
 
   241             }
 
   236             }
 
   242         else if (speedTn)
 
   237         else if (speedTn)
 
   243             {
 
   238             {
 
   244             CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
 
   239             CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
 
   245             bitmap->Duplicate( speedTn->iBitmap->Handle());
 
   240             bitmap->Duplicate(speedTn->iBitmap->Handle());
 
   246             AknIconUtils::SetSize(bitmap, setSize);
 
       
   247             iHgGrid->ItemL(aItemIndex).SetIcon(CGulIcon::NewL(bitmap));
 
   241             iHgGrid->ItemL(aItemIndex).SetIcon(CGulIcon::NewL(bitmap));
 
   248             GLX_LOG_INFO1("### CGlxGridViewMLObserver::HandleAttributesAvailableL"
 
   242             GLX_LOG_INFO1("### CGlxGridViewMLObserver::HandleAttributesAvailableL"
 
   249                     " speedTn-Index is %d",aItemIndex);
 
   243                     " speedTn-Index is %d",aItemIndex);
 
   250             }
 
   244             }
 
   251         else if ( KErrNone != tnError && KErrNotSupported != tnError &&
 
   245         else if ( KErrNone != tnError && KErrNotSupported != tnError &&
 
   342                 case KErrDiskFull:
 
   336                 case KErrDiskFull:
 
   343                     bitmapId  = EMbmGlxiconsQgn_prop_image_notcreated;
 
   337                     bitmapId  = EMbmGlxiconsQgn_prop_image_notcreated;
 
   344                     flags     = CHgItem::EHgItemFlagsNone ;
 
   338                     flags     = CHgItem::EHgItemFlagsNone ;
 
   345                     if (!iDiskErrorIntimated)
 
   339                     if (!iDiskErrorIntimated)
 
   346                         {
 
   340                         {
 
   347                         DisplayErrorNote(KErrDiskFull);
 
   341                         DisplayErrorNoteL(KErrDiskFull);
 
   348                         }
 
   342                         }
 
   349                     break;
 
   343                     break;
 
   350                 default:
 
   344                 default:
 
   351                     bitmapId  = EMbmGlxiconsQgn_prop_image_corrupted;
 
   345                     bitmapId  = EMbmGlxiconsQgn_prop_image_corrupted;
 
   352                     flags     = CHgItem::EHgItemFlagsNone ;
 
   346                     flags     = CHgItem::EHgItemFlagsNone ;
 
   496                     iHgGrid->RefreshScreen(lastOnScreen);
 
   490                     iHgGrid->RefreshScreen(lastOnScreen);
 
   497                     }
 
   491                     }
 
   498                 }
 
   492                 }
 
   499             }
 
   493             }
 
   500         }
 
   494         }
 
       
   495     
   501     if (iModifiedIndexes.Count() > 0)        
   496     if (iModifiedIndexes.Count() > 0)        
   502         {
 
   497         {
 
   503         for(TInt index = 0;index<iModifiedIndexes.Count();index++)
 
   498         for(TInt index = 0;index<iModifiedIndexes.Count();index++)
 
   504             {
 
   499             {
 
   505             if (iModifiedIndexes[index] == aItemIndex && 
   500             if (iModifiedIndexes[index] == aItemIndex && 
   542                      * to show the invalid DRM icon
 
   537                      * to show the invalid DRM icon
 
   543                      */
 
   538                      */
 
   544                     TMPXGeneralCategory  cat = item.Category();                  
   539                     TMPXGeneralCategory  cat = item.Category();                  
   545                     TBool checkViewRights = (cat==EMPXImage);
 
   540                     TBool checkViewRights = (cat==EMPXImage);
 
   546                     
   541                     
   547                     if(iDRMUtility->CheckOpenRightsL(uri, checkViewRights))
 
   542                     if(iDRMUtility->ItemRightsValidityCheckL(uri, checkViewRights))
 
   548                         {
 
   543                         {
 
   549                         iHgGrid->ItemL(aItemIndex).SetFlags(
 
   544                         iHgGrid->ItemL(aItemIndex).SetFlags(
 
   550                                 CHgItem::EHgItemFlagsDrmRightsValid);
 
   545                                 CHgItem::EHgItemFlagsDrmRightsValid);
 
   551                         }
 
   546                         }
 
   552                      else
 
   547                      else
 
   558                 else 
   553                 else 
   559                     {
 
   554                     {
 
   560                     TMPXGeneralCategory  cat = item.Category();                  
   555                     TMPXGeneralCategory  cat = item.Category();                  
   561                     TBool checkViewRights = (cat==EMPXImage);
 
   556                     TBool checkViewRights = (cat==EMPXImage);
 
   562                     
   557                     
   563                     if(iDRMUtility->CheckOpenRightsL(uri, checkViewRights))
 
   558                     if(iDRMUtility->ItemRightsValidityCheckL(uri, checkViewRights))
 
   564                         {
 
   559                         {
 
   565                         iHgGrid->ItemL(aItemIndex).SetFlags(
 
   560                         iHgGrid->ItemL(aItemIndex).SetFlags(
 
   566                                 CHgItem::EHgItemFlagsDrmRightsValid);
 
   561                                 CHgItem::EHgItemFlagsDrmRightsValid);
 
   567                         }
 
   562                         }
 
   568                      else
 
   563                      else
 
   591             iHgGrid->ItemL(aItemIndex).SetFlags(CHgItem::EHgItemFlagsVideo);
 
   586             iHgGrid->ItemL(aItemIndex).SetFlags(CHgItem::EHgItemFlagsVideo);
 
   592             }
 
   587             }
 
   593         }    
   588         }    
   594     }
 
   589     }
 
   595     
   590     
   596     
   591 // ----------------------------------------------------------------------------
 
   597 // ----------------------------------------------------------------------------
 
   592 // DisplayErrorNoteL
 
   598 // DisplayErrorNote
 
       
   599 // ----------------------------------------------------------------------------
 
   593 // ----------------------------------------------------------------------------
 
   600 // 
   594 // 
   601 void CGlxGridViewMLObserver::DisplayErrorNote(TInt aError)
 
   595 void CGlxGridViewMLObserver::DisplayErrorNoteL(TInt aError)
 
   602     {
 
   596     {
 
   603     TRACER("CGlxGridViewMLObserver::DisplayErrorNote()");
 
   597     TRACER("CGlxGridViewMLObserver::DisplayErrorNoteL()");
 
   604     GLX_LOG_INFO1("CGlxGridViewMLObserver::DisplayErrorNote Error note "
 
   598     GLX_LOG_INFO1("CGlxGridViewMLObserver::DisplayErrorNoteL() "
 
   605                 "displayed corresponging to [d]", aError);
 
   599             " aError(%d)", aError);
 
   606     GlxGeneralUiUtilities::ShowErrorNoteL(aError);
 
   600     GlxGeneralUiUtilities::ShowErrorNoteL(aError);
 
   607     iDiskErrorIntimated = ETrue;
 
   601     iDiskErrorIntimated = ETrue;
 
   608     return ;
 
   602     return;
 
   609     }
 
   603     }
MCL/sf/app/photos