diff -r 000000000000 -r 96612d01cf9f videocollection/mpxmyvideoscollection/src/vcxmyvideoscategories.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videocollection/mpxmyvideoscollection/src/vcxmyvideoscategories.cpp	Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,919 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:    Categories related functionality*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <mpxlog.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxmediageneraldefs.h>
+#include <mpxcollectionpluginobserver.h>
+#include <mpxmessagegeneraldefs.h>
+#include <mpxcommandgeneraldefs.h>
+#include <mpxcollectioncommanddefs.h>
+#include <mpxmessagecontainerdefs.h>
+#include "vcxmyvideoscollectionplugin.h"
+#include "vcxmyvideoscategories.h"
+#include "vcxmyvideoscollectionutil.h"
+#include "vcxmyvideosvideocache.h"
+#include "vcxmyvideosmessagelist.h"
+
+_LIT(KVcxMyVideosAllVideosCategoryText, "All videos");
+_LIT(KVcxMyVideosDownloadsCategoryText, "Downloads");
+_LIT(KVcxMyVideosTvRecordingsCategoryText, "TV recordings");
+_LIT(KVcxMyVideosCapturedVideosCategoryText, "Captured videos");
+_LIT(KVcxMyVideosOtherCategoryText, "Other");
+
+const TInt KVcxMyVideosAllVideosCategoryIndex    = 0;
+const TInt KVcxMyVideosDownloadsCategoryIndex    = 1;
+const TInt KVcxMyVideosTvRecordingsCategoryIndex = 2;
+const TInt KVcxMyVideosCapturedCategoryIndex     = 3;
+const TInt KVcxMyVideosOtherCategoryIndex        = 4;
+
+
+// ============================ MEMBER FUNCTIONS ==============================
+
+// ----------------------------------------------------------------------------
+// Two-phased constructor.
+// ----------------------------------------------------------------------------
+//
+CVcxMyVideosCategories* CVcxMyVideosCategories::NewL(
+    CVcxMyVideosCollectionPlugin& aCollection )
+    {
+    MPX_FUNC("CVcxMyVideosCategories::NewL");
+
+    CVcxMyVideosCategories* self = new (ELeave) CVcxMyVideosCategories( aCollection );
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+// ----------------------------------------------------------------------------
+// Destructor.
+// ----------------------------------------------------------------------------
+//
+CVcxMyVideosCategories::~CVcxMyVideosCategories()
+    {
+    MPX_FUNC("CVcxMyVideosCategories::~CVcxMyVideosCategories");
+    
+    delete iList;
+    iModifiedCategories.Close();
+    }
+
+// ----------------------------------------------------------------------------
+// Constructor.
+// ----------------------------------------------------------------------------
+//
+CVcxMyVideosCategories::CVcxMyVideosCategories( CVcxMyVideosCollectionPlugin& aCollection )
+: iCollection( aCollection )
+    {
+    MPX_FUNC("CVcxMyVideosCategories::CVcxMyVideosCategories");
+    }
+
+// ----------------------------------------------------------------------------
+// Symbian 2nd phase constructor can leave.
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::ConstructL ()
+    {
+    MPX_FUNC("CVcxMyVideosCategories::ConstructL");
+    iList      = CreateCategoryListL();
+    iListArray = iList->Value<CMPXMediaArray>( KMPXMediaArrayContents );   
+
+    TInt categoryCount = iListArray->Count();
+    for ( TInt i = 0; i < categoryCount; i++ )
+        {
+        iModifiedCategories.Append( EFalse );
+        }
+
+    }
+    
+// ----------------------------------------------------------------------------------------------------------
+// CVcxMyVideosCategories::CreateCategoryListL
+// ----------------------------------------------------------------------------------------------------------
+//
+CMPXMedia* CVcxMyVideosCategories::CreateCategoryListL()
+    {
+    //first level
+
+    CMPXMedia* entries = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();
+    CleanupStack::PushL( entries ); // 1->
+    entries->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, 0 /*aPath.Id( 0 )*/);
+    CMPXMediaArray* entryArray = entries->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+
+    AppendCategoryToArrayL( KVcxMyVideosAllVideosCategoryText,
+            TMPXItemId( KVcxMvcCategoryIdAll, 1), *entryArray );
+
+    AppendCategoryToArrayL( KVcxMyVideosDownloadsCategoryText,
+            TMPXItemId( KVcxMvcCategoryIdDownloads, 1 ), *entryArray );
+
+    AppendCategoryToArrayL( KVcxMyVideosTvRecordingsCategoryText,
+            TMPXItemId( KVcxMvcCategoryIdTvRecordings, 1 ), *entryArray );
+
+    AppendCategoryToArrayL( KVcxMyVideosCapturedVideosCategoryText,
+            TMPXItemId( KVcxMvcCategoryIdCaptured, 1), *entryArray );
+
+    AppendCategoryToArrayL( KVcxMyVideosOtherCategoryText,
+            TMPXItemId( KVcxMvcCategoryIdOther, 1 ), *entryArray );
+
+    entries->SetTObjectValueL( KMPXMediaArrayCount, entryArray->Count() );
+
+    CleanupStack::Pop( entries ); // <-1
+
+    return entries;
+    }
+
+// ----------------------------------------------------------------------------------------------------------
+// CVcxMyVideosCategories::AppendCategoryToArrayL
+// ----------------------------------------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::AppendCategoryToArrayL( const TDesC& aTitle, TMPXItemId aId,
+        CMPXMediaArray& aCategoryArray )
+    {
+    RArray<TInt> supportedIds;
+    CleanupClosePushL( supportedIds ); // 1->
+    supportedIds.AppendL( KMPXMediaIdGeneral );
+
+    CMPXMedia* category = CMPXMedia::NewL( supportedIds.Array() );
+    CleanupStack::PushL( category ); // 2->
+    category->SetTextValueL( KMPXMediaGeneralTitle, aTitle );
+    category->SetTObjectValueL( KMPXMediaGeneralId, aId );
+    category->SetTObjectValueL( KMPXMediaGeneralType, EMPXGroup );
+    category->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXNoCategory );
+    category->SetTObjectValueL( KVcxMediaMyVideosCategoryItemCount, 0 );
+    category->SetTObjectValueL( KVcxMediaMyVideosCategoryNewItemCount, 0 );
+    aCategoryArray.AppendL( category );
+    CleanupStack::Pop( category );                // <-2
+    CleanupStack::PopAndDestroy( &supportedIds ); // <-1
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::UpdateCategoriesL
+// Called by iCollection when fetching the video list from mds incrementally.
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::UpdateCategoriesL( CMPXMedia& aVideoList,
+        TInt aNewItemsStartIndex )
+    {    
+    CMPXMediaArray* categoryArray = iList->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+    TInt categoryCount            = categoryArray->Count();
+
+    RArray<TInt> videosIncrements;
+    videosIncrements.Reset();
+    CleanupClosePushL( videosIncrements ); // 1->
+
+    RArray<TInt> newVideosIncrements;
+    newVideosIncrements.Reset();
+    CleanupClosePushL( newVideosIncrements ); // 2->
+
+    TInt i;
+    for ( i = 0; i < categoryCount; i++ )
+        {
+        videosIncrements.AppendL( 0 );
+        newVideosIncrements.Append( 0 );
+        }
+
+    CMPXMediaArray* videoListArray = aVideoList.Value<CMPXMediaArray>( KMPXMediaArrayContents );
+    TInt videoListCount            = videoListArray->Count();
+
+    videosIncrements[KVcxMyVideosAllVideosCategoryIndex] = videoListCount - aNewItemsStartIndex;
+    
+    CMPXMedia* media;
+    for ( i = aNewItemsStartIndex; i < videoListCount; i++ )
+        {
+        TUint8 origin = EVcxMyVideosOriginOther;
+        
+        media = videoListArray->AtL( i );
+        
+        if ( media->IsSupported( KVcxMediaMyVideosOrigin ) )
+            {
+            origin = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosOrigin );                
+            }
+        
+        TBool newVideo = EFalse;
+        TUint32 flags  = 0;
+        
+        if ( media->IsSupported( KMPXMediaGeneralFlags ) )
+            {
+            flags = media->ValueTObjectL<TUint32>( KMPXMediaGeneralFlags );
+            if ( flags & EVcxMyVideosVideoNew )
+                {
+                newVideo = ETrue;
+                newVideosIncrements[KVcxMyVideosAllVideosCategoryIndex]++;
+                }
+            }
+        
+        switch ( origin )
+            {
+            case EVcxMyVideosOriginDownloaded:
+                videosIncrements[KVcxMyVideosDownloadsCategoryIndex]++;
+                if ( newVideo )
+                    {
+                    newVideosIncrements[KVcxMyVideosDownloadsCategoryIndex]++;
+                    }
+                break;
+                
+            case EVcxMyVideosOriginCapturedWithCamera:
+                videosIncrements[KVcxMyVideosCapturedCategoryIndex]++;
+                if ( newVideo )
+                    {
+                    newVideosIncrements[KVcxMyVideosCapturedCategoryIndex]++;
+                    }
+                break;
+                                
+            case EVcxMyVideosOriginTvRecording:
+                videosIncrements[KVcxMyVideosTvRecordingsCategoryIndex]++;
+                if ( newVideo )
+                    {
+                    newVideosIncrements[KVcxMyVideosTvRecordingsCategoryIndex]++;
+                    }
+                break;
+
+            case EVcxMyVideosOriginSideLoaded:                
+            case EVcxMyVideosOriginOther:
+            default:
+                videosIncrements[KVcxMyVideosOtherCategoryIndex]++;
+                if ( newVideo )
+                    {
+                    newVideosIncrements[KVcxMyVideosOtherCategoryIndex]++;
+                    }
+                break;
+            }
+        }
+
+    // Update videos counts
+    UpdateVideosCountL( *categoryArray, videosIncrements, newVideosIncrements );
+
+    CleanupStack::PopAndDestroy( &newVideosIncrements ); // <-1
+    CleanupStack::PopAndDestroy( &videosIncrements ); // <-1
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::UpdateVideosCountL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::UpdateVideosCountL( CMPXMediaArray& aCategoryArray,
+    RArray<TInt>& aVideosIncrements, RArray<TInt>& aNewVideosIncrements )
+    {
+    TBool modified = EFalse;
+    TInt categoryCount = aCategoryArray.Count();
+    CMPXMedia* category;
+    
+    for ( TInt i = 0; i < categoryCount; i++ )
+        {
+        if ( aVideosIncrements[i] != 0 )
+            {
+            category = aCategoryArray.AtL( i );
+
+            UpdateVideosCountL( *category, aVideosIncrements[i], KVcxMediaMyVideosCategoryItemCount,
+                    EVcxMyVideosListNoInfo );
+
+            modified = ETrue;
+            }
+
+        if ( aNewVideosIncrements[i] != 0 )
+            {
+            category = aCategoryArray.AtL( i );
+
+            UpdateVideosCountL( *category, aNewVideosIncrements[i], KVcxMediaMyVideosCategoryNewItemCount,
+                    EVcxMyVideosListNoInfo );
+
+            modified = ETrue;
+            }
+
+        }
+    if ( modified )
+        {
+        iCollection.iMessageList->SendL();
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::UpdateVideosCountL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::UpdateVideosCountL( CMPXMedia& aCategory,
+    TInt aIncrement, TMPXAttributeData aCountAttribute, TInt aEventInfo )
+    {
+    if ( aIncrement != 0 )
+        {
+        AddToTUint32AttributeL( aCategory, aIncrement, aCountAttribute );
+                
+        iCollection.iMessageList->AddEventL( aCategory.ValueTObjectL<TMPXItemId>(
+                KMPXMediaGeneralId ), EMPXItemModified, aEventInfo );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideosAddedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideosAddedL( RArray<TUint32>& aIds )
+    {
+    VideosAddedOrRemovedL( aIds, ETrue );
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideosRemovedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideosRemovedL( RArray<TUint32>& aIds )
+    {
+    VideosAddedOrRemovedL( aIds, EFalse );
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideoAddedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideoAddedL( TUint32 aMdsId )
+    {
+    TInt pos( KErrNotFound );
+    CMPXMedia* video = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );
+    if ( pos != KErrNotFound )
+        {
+        VideoAddedOrRemovedL( *video, ETrue );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideoAddedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideoAddedL( CMPXMedia& aVideo )
+    {
+    VideoAddedOrRemovedL( aVideo, ETrue );
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideoRemovedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideoRemovedL( TUint32 aMdsId )
+    {
+    TInt pos( KErrNotFound );
+    CMPXMedia* video = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );
+    if ( pos != KErrNotFound )
+        {
+        VideoAddedOrRemovedL( *video, EFalse );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideoRemovedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideoRemovedL( CMPXMedia& aVideo )
+    {
+    VideoAddedOrRemovedL( aVideo, EFalse );
+    }
+    
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideosAddedOrRemovedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideosAddedOrRemovedL(
+        RArray<TUint32>& aIds, TBool aAdded )
+    {
+    TInt count = aIds.Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        VideoAddedOrRemovedL( aIds[i], aAdded );
+        }
+    }
+    
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideoAddedOrRemovedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideoAddedOrRemovedL( TUint32 aMdsId, TBool aAdded )
+    {    
+    TInt pos( KErrNotFound );
+    CMPXMedia* video = iCollection.iCache->FindVideoByMdsIdL( aMdsId, pos );
+    if ( pos != KErrNotFound )
+        {
+        VideoAddedOrRemovedL( *video, aAdded );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::VideoAddedOrRemovedL
+// All remove&add calls eventually come here.
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::VideoAddedOrRemovedL( CMPXMedia& aVideo, TBool aAdded )
+    {
+    MPX_FUNC("CVcxMyVideosCategories::VideoAddedOrRemovedL()");
+
+    ResetModifiedCategoriesArray();
+
+    TInt categoryIndex  = CategoryIndex( TVcxMyVideosCollectionUtil::OriginL( aVideo ) );
+    CMPXMedia* category = iListArray->AtL( categoryIndex );
+    // every event updates always 2 categories, all and something else
+    UpdateCategoryL( *category, categoryIndex, aVideo, aAdded );
+
+    //iMessageArray will discard duplicates
+    AddEventsFromModifiedCategoriesArrayL();
+    }
+    
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::UpdateCategoryL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::UpdateCategoryL( CMPXMedia& aCategory, TInt aCategoryIndex,
+        CMPXMedia& aVideo, TBool aAdded )
+    {
+    MPX_FUNC("CVcxMyVideosCategories::UpdateCategoryL");
+
+    TInt addition = 0;
+    
+    if ( aAdded )
+        {
+        MPX_DEBUG1("CVcxMyVideosCategories:: video added");
+        if ( TVcxMyVideosCollectionUtil::FlagsL( aVideo ) & EVcxMyVideosVideoNew )
+            {
+            TInt64 newItemsDate( 0 );
+            if ( aVideo.IsSupported( KMPXMediaGeneralDate ) )
+                {
+                newItemsDate = aVideo.ValueTObjectL<TInt64>( KMPXMediaGeneralDate );
+                }
+            TInt64 prevNewDate( 0 );
+            if ( aCategory.IsSupported( KMPXMediaGeneralDate ) )
+                {
+                prevNewDate = aCategory.ValueTObjectL<TInt64>( KMPXMediaGeneralDate );
+                }
+
+            if ( static_cast<TInt64>(newItemsDate) > static_cast<TInt64>(prevNewDate) )
+                {                    
+                MPX_DEBUG1("CVcxMyVideosCategories:: EMPXItemInserted -> changing new video name");
+                aCategory.SetTextValueL( KVcxMediaMyVideosCategoryNewItemName,
+                        aVideo.ValueText( KMPXMediaGeneralTitle ) );
+                aCategory.SetTObjectValueL( KMPXMediaGeneralDate, newItemsDate ); 
+                iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex)->SetTextValueL(
+                        KVcxMediaMyVideosCategoryNewItemName,
+                        aVideo.ValueText( KMPXMediaGeneralTitle ) );
+                iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex)->SetTObjectValueL(
+                        KMPXMediaGeneralDate, newItemsDate );
+                iModifiedCategories[aCategoryIndex]                     = ETrue;
+                iModifiedCategories[KVcxMyVideosAllVideosCategoryIndex] = ETrue;
+                }
+            }
+        addition = 1;
+        }
+    else
+        {
+        MPX_DEBUG1("CVcxMyVideosCategories:: video deleted");
+
+        TBool modified = EFalse;
+        RArray<TUint32> ignoredIds;
+        ignoredIds.Reset();
+        CleanupClosePushL( ignoredIds ); // 1->
+        if ( !aAdded )
+            {
+            ignoredIds.AppendL( TVcxMyVideosCollectionUtil::IdL( aVideo ) );
+            }
+        UpdateCategoryNewVideoNameAndDateL( -1 /* -1 origin resolves to All category */,
+                modified, ignoredIds );
+        UpdateCategoryNewVideoNameAndDateL( TVcxMyVideosCollectionUtil::OriginL( aVideo ),
+                modified, ignoredIds );
+        CleanupStack::PopAndDestroy( &ignoredIds ); // <-1
+
+        if ( modified )
+            {
+            iModifiedCategories[aCategoryIndex]                     = ETrue;
+            iModifiedCategories[KVcxMyVideosAllVideosCategoryIndex] = ETrue;
+            }
+            
+        addition = -1;
+        }
+        
+    
+    if ( addition != 0 )
+        {
+        AddToTUint32AttributeL( aCategory, addition, KVcxMediaMyVideosCategoryItemCount );
+        AddToTUint32AttributeL( *(iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex) ),
+                addition, KVcxMediaMyVideosCategoryItemCount );
+        if ( TVcxMyVideosCollectionUtil::FlagsL( aVideo ) & EVcxMyVideosVideoNew )
+            {
+            AddToTUint32AttributeL( aCategory, addition, KVcxMediaMyVideosCategoryNewItemCount );
+            AddToTUint32AttributeL( *(iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex) ),
+                    addition, KVcxMediaMyVideosCategoryNewItemCount );
+            }
+        iModifiedCategories[aCategoryIndex]                     = ETrue;
+        iModifiedCategories[KVcxMyVideosAllVideosCategoryIndex] = ETrue;
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::AddToTUint32AttributeL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::AddToTUint32AttributeL( CMPXMedia& aCategory, TInt aAddition,
+        TMPXAttributeData aAttribute )
+    {
+    TUint32 previousCount = 0;
+    if ( aCategory.IsSupported( aAttribute ) )
+        {
+        previousCount = aCategory.ValueTObjectL<TUint32>( aAttribute );
+        }
+    
+    TInt totalCount = previousCount + aAddition;
+    if ( totalCount < 0 )
+        {
+        totalCount = 0;
+        }
+    aCategory.SetTObjectValueL<TUint32>( aAttribute, totalCount );
+
+    MPX_DEBUG2("CVcxMyVideosCategories::AddToTUint32AttributeL() attribute(%x): ", aAttribute );
+    MPX_DEBUG3("CVcxMyVideosCategories::AddToTUint32AttributeL() %d -> %d", previousCount, totalCount);
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::CategoryIndex
+// ----------------------------------------------------------------------------
+//
+TInt CVcxMyVideosCategories::CategoryIndex( TInt aOrigin )
+    {
+    switch ( aOrigin )
+        {
+        case -1:
+            return KVcxMyVideosAllVideosCategoryIndex;
+            
+        case EVcxMyVideosOriginDownloaded:
+            return KVcxMyVideosDownloadsCategoryIndex;
+            
+        case EVcxMyVideosOriginCapturedWithCamera:
+            return KVcxMyVideosCapturedCategoryIndex;
+                            
+        case EVcxMyVideosOriginTvRecording:
+            return KVcxMyVideosTvRecordingsCategoryIndex;
+
+        case EVcxMyVideosOriginSideLoaded:                
+        case EVcxMyVideosOriginOther:
+        default:
+            return KVcxMyVideosOtherCategoryIndex;
+        }
+    }     
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::NewVideoFlagChangedL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::NewVideoFlagChangedL( TUint32 aOldFlag, TUint32 aNewFlag,
+        TUint8 aOrigin, TBool& aModified )
+    {
+    CMPXMedia* categoryAll;
+    CMPXMedia* categoryByOrigin;
+    TBool modified = EFalse;
+    
+    if ( (aOldFlag & EVcxMyVideosVideoNew) && !(aNewFlag & EVcxMyVideosVideoNew) )
+        {
+        // new flag cleared -> update counters
+        categoryByOrigin = iListArray->AtL( CategoryIndex( aOrigin ) );
+        AddToTUint32AttributeL( *categoryByOrigin, -1, KVcxMediaMyVideosCategoryNewItemCount );
+        categoryAll = iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex );
+        AddToTUint32AttributeL( *categoryAll, -1, KVcxMediaMyVideosCategoryNewItemCount );
+        aModified = ETrue;
+        modified  = ETrue;
+        } 
+    else if ( !(aOldFlag & EVcxMyVideosVideoNew) && (aNewFlag & EVcxMyVideosVideoNew) )
+        {
+        // new flag set -> update counters
+        categoryByOrigin = iListArray->AtL( CategoryIndex( aOrigin ) );
+        AddToTUint32AttributeL( *categoryByOrigin, 1, KVcxMediaMyVideosCategoryNewItemCount );
+        categoryAll = iListArray->AtL( KVcxMyVideosAllVideosCategoryIndex );
+        AddToTUint32AttributeL( *categoryAll, 1, KVcxMediaMyVideosCategoryNewItemCount );
+        aModified = ETrue;
+        modified  = ETrue;
+        }
+        
+    if ( modified )
+        {
+        TMPXItemId mpxId( categoryByOrigin->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+        iCollection.iMessageList->AddEventL( mpxId, EMPXItemModified );
+
+        mpxId = categoryAll->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+        iCollection.iMessageList->AddEventL( mpxId, EMPXItemModified );
+        } 
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::ResetVideoCountersL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::ResetVideoCountersL()
+    {
+    TInt count = iListArray->Count();
+    
+    for ( TInt i = 0; i < count; i++ )
+        {
+        iListArray->AtL( i )->SetTObjectValueL<TUint32>(
+                KVcxMediaMyVideosCategoryNewItemCount, 0 );
+        iListArray->AtL( i )->SetTObjectValueL<TUint32>(
+                KVcxMediaMyVideosCategoryItemCount, 0 );
+        }
+    }
+
+/*
+
+New video name generation:
+
+1. When new video list is created: calculate new video names from scratch at the end of list creation.
+2. Item is removed (mds remove event): calculate from scratch to the categories which are affected.
+3. Item is added (mds add event): If new item && date is newer than previous -> put it to categories which are affected.
+4. Items new flag is modified: calculate from scratch to the categories which are affected.
+5. Items title is modified: calculate from scratch to the categories which are affected.
+*/
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::UpdateCategoriesNewVideoNamesL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::UpdateCategoriesNewVideoNamesL()
+    {
+    MPX_FUNC("CVcxMyVideosCategories::UpdateCategoriesNewVideoNamesL");
+    
+    RArray<TUint32> ignoredIds;
+    ignoredIds.Reset();
+    CleanupClosePushL( ignoredIds ); // 1->
+    TBool modified = EFalse;
+    UpdateCategoryNewVideoNameAndDateL( -1 /* all category */, modified, ignoredIds );
+    UpdateCategoryNewVideoNameAndDateL( EVcxMyVideosOriginCapturedWithCamera, modified,
+            ignoredIds );
+    UpdateCategoryNewVideoNameAndDateL( EVcxMyVideosOriginDownloaded, modified, ignoredIds );
+    UpdateCategoryNewVideoNameAndDateL( EVcxMyVideosOriginTvRecording, modified, ignoredIds );
+    UpdateCategoryNewVideoNameAndDateL( EVcxMyVideosOriginOther, modified, ignoredIds );
+    CleanupStack::PopAndDestroy( &ignoredIds ); // <-1
+    
+    if ( modified )
+        {
+        // flush event list
+        MPX_DEBUG1("CVcxMyVideosCategories:: sending event list");
+        iCollection.iMessageList->SendL();
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::UpdateCategoryNewVideoNameAndDateL
+// ----------------------------------------------------------------------------
+//    
+void CVcxMyVideosCategories::UpdateCategoryNewVideoNameAndDateL( TInt aOrigin, TBool& aModified,
+        RArray<TUint32>& aIgnoredIds )
+    {   
+    MPX_FUNC("CVcxMyVideosCategories::UpdateCategoryNewVideoNameAndDateL");
+
+    TPtrC prevNewVideoName;
+    TPtrC currentNewVideoName;
+    
+    CMPXMedia* videoList = iCollection.iCache->iVideoList;
+    
+    TInt categoryIndex = CategoryIndex( aOrigin );
+     
+    prevNewVideoName.Set( iListArray->AtL( categoryIndex )->ValueText(
+            KVcxMediaMyVideosCategoryNewItemName ) );
+    CMPXMedia* newVideo;
+    currentNewVideoName.Set( CalculateNewVideoNameL( *videoList, aOrigin, aIgnoredIds, newVideo ) );
+    if ( currentNewVideoName.CompareF( prevNewVideoName ) != 0 )
+        {
+        iListArray->AtL( categoryIndex )->SetTextValueL(
+                KVcxMediaMyVideosCategoryNewItemName, currentNewVideoName );
+        MPX_DEBUG3("CVcxMyVideosCategories:: Category[%d] New Video Name changed to %S",
+                categoryIndex, &currentNewVideoName);
+
+        if ( newVideo )
+            {
+            TInt64 newDate( 0 );
+            if ( newVideo->IsSupported( KMPXMediaGeneralDate ) )
+                {
+                newDate = newVideo->ValueTObjectL<TInt64>( KMPXMediaGeneralDate );
+                }
+                
+            iListArray->AtL( categoryIndex )->SetTObjectValueL( KMPXMediaGeneralDate, newDate );
+            }
+        else
+            {
+            iListArray->AtL( categoryIndex )->SetTObjectValueL( KMPXMediaGeneralDate, 0 );
+            }
+            
+        MPX_DEBUG1("CVcxMyVideosCategories:: adding event");
+        
+        TMPXItemId mpxId = iListArray->AtL( categoryIndex )->ValueTObjectL<TMPXItemId>(
+                KMPXMediaGeneralId );
+        iCollection.iMessageList->AddEventL( mpxId, EMPXItemModified );
+
+        aModified = ETrue;
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::CalculateNewVideoNameL
+// ----------------------------------------------------------------------------
+//    
+const TDesC& CVcxMyVideosCategories::CalculateNewVideoNameL( CMPXMedia& aVideoList,
+        TInt aOrigin, RArray<TUint32>& aIgnoredIds, CMPXMedia*& aNewVideo )
+    {
+    MPX_FUNC("CVcxMyVideosCategories::CalculateNewVideoNameL");
+
+    if ( aOrigin == EVcxMyVideosOriginSideLoaded )
+        {
+        aOrigin = EVcxMyVideosOriginOther;
+        }
+        
+    CMPXMediaArray* videoArray = aVideoList.Value<CMPXMediaArray>(
+            KMPXMediaArrayContents );
+    
+    TInt64 latestCreationDate = 0;
+    TInt64 currentItemsCreationDate;
+    TInt currentLatestItemIndex   = -1;
+    TUint8 origin;
+    TUint32 flags;
+    CMPXMedia* video;
+    TInt count = videoArray->Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        video = videoArray->AtL( i );
+
+        // Handle only items which are not on ignore list (aIgnoredIds).
+        // Items on ignore list are going to be deleted, they just hang around
+        // on the list at this point.
+        if ( aIgnoredIds.Find( video->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ).iId1 )
+                == KErrNotFound )
+            {
+            // IsSupported check omitted since this value should be set always
+            flags = video->ValueTObjectL<TUint32>( KMPXMediaGeneralFlags );
+            if ( flags & EVcxMyVideosVideoNew )
+                {
+                origin = TVcxMyVideosCollectionUtil::OriginL( *video );
+                if ( aOrigin == -1 || aOrigin == origin )
+                    {
+                    currentItemsCreationDate = video->ValueTObjectL<TInt64>(
+                            KMPXMediaGeneralDate ); 
+                    if ( latestCreationDate < currentItemsCreationDate )
+                        {
+                        latestCreationDate     = currentItemsCreationDate;
+                        currentLatestItemIndex = i;
+                        aNewVideo              = video;
+                        }
+                    }
+                }
+            }
+        else
+            {
+            MPX_DEBUG1("CVcxMyVideosCategories:: item is on ignore list, skipping");
+            }
+        }
+
+    if ( currentLatestItemIndex == -1 )
+        {
+        aNewVideo = NULL;
+        return KNullDesC;
+        }
+    else
+        {
+        MPX_DEBUG2("CVcxMyVideosCategories:: returning %S",
+                &videoArray->AtL( currentLatestItemIndex )->ValueText( KMPXMediaGeneralTitle ) );
+        return videoArray->AtL( currentLatestItemIndex )->ValueText( KMPXMediaGeneralTitle );
+        }
+        
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::UpdateCategoryNewVideoNameAndDateL
+// Called when video is updated in a way that it affects category new
+// video name.
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::UpdateCategoryNewVideoNameAndDateL( CMPXMedia& aVideo,
+        TBool& aModified )
+    {
+    //       mpx items for current category new video names should be saved and used to
+    //       speed up this func
+    
+    TBool modified = EFalse;
+    RArray<TUint32> ignoredIds;
+    ignoredIds.Reset();
+    CleanupClosePushL( ignoredIds ); // 1->
+    UpdateCategoryNewVideoNameAndDateL( -1 /* -1 origin resolves to All category */, modified,
+            ignoredIds );
+    UpdateCategoryNewVideoNameAndDateL( TVcxMyVideosCollectionUtil::OriginL( aVideo ), modified,
+            ignoredIds );
+
+    if ( modified )
+        {
+        aModified = ETrue;
+        }
+    CleanupStack::PopAndDestroy( &ignoredIds ); // <-1
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::GenerateCategoryModifiedEventL
+// Called when video is updated in a way that it modifies categories in a way
+// that event is sent.
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::GenerateCategoryModifiedEventL( CMPXMedia& aMedia,
+        TBool aFlushMessageList, TInt32 aExtraInfo )
+    {
+    TMPXItemId mpxId = iListArray->AtL( 0 /* All category*/ )->ValueTObjectL<TMPXItemId>(
+            KMPXMediaGeneralId );
+    
+    MPX_DEBUG2("CVcxMyVideosCategories:: adding modify event for category[0], extra info = %d", aExtraInfo );
+    iCollection.iMessageList->AddEventL( mpxId, EMPXItemModified, aExtraInfo );
+    mpxId = iListArray->AtL( CategoryIndex(
+            TVcxMyVideosCollectionUtil::OriginL( aMedia ) ) )->ValueTObjectL<TMPXItemId>(
+            KMPXMediaGeneralId );
+
+    MPX_DEBUG3("CVcxMyVideosCategories:: adding modify event for category[%d], extra info = %d", mpxId.iId1, aExtraInfo );
+    iCollection.iMessageList->AddEventL( mpxId, EMPXItemModified, aExtraInfo );
+
+    if ( aFlushMessageList )
+        {
+        iCollection.iMessageList->SendL();
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::OriginChangedL
+// Called when videos origin is changed (Video moves from one category to other).
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::OriginChangedL( CMPXMedia& aVideo, TUint8 aPrevOrigin,
+        TUint8 aNewOrigin )
+    {
+    CMPXMediaArray* categoryArray = iList->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+
+    UpdateVideosCountL( *(categoryArray->AtL( CategoryIndex( aPrevOrigin ) )),
+            -1, KVcxMediaMyVideosCategoryItemCount, EVcxMyVideosVideoListOrderChanged ); //event added but not sent
+
+    UpdateVideosCountL( *(categoryArray->AtL( CategoryIndex( aNewOrigin ) )),
+            1, KVcxMediaMyVideosCategoryItemCount, EVcxMyVideosVideoListOrderChanged ); //event added but not sent
+
+    if ( TVcxMyVideosCollectionUtil::FlagsL( aVideo ) & EVcxMyVideosVideoNew )
+        {
+        UpdateVideosCountL( *(categoryArray->AtL( CategoryIndex( aPrevOrigin ) )),
+                -1, KVcxMediaMyVideosCategoryNewItemCount, EVcxMyVideosVideoListOrderChanged ); //this event will be optimized away at iCollection.iMessageList
+
+        UpdateVideosCountL( *(categoryArray->AtL( CategoryIndex( aNewOrigin ) )),
+                1, KVcxMediaMyVideosCategoryNewItemCount, EVcxMyVideosVideoListOrderChanged ); //this event will be optimized away at iCollection.iMessageList
+        }
+    
+    RArray<TUint32> ignoredIds;
+    ignoredIds.Reset();
+    CleanupClosePushL( ignoredIds ); // 1->
+    TBool modified = EFalse;
+    UpdateCategoryNewVideoNameAndDateL( aPrevOrigin, modified, ignoredIds );
+    UpdateCategoryNewVideoNameAndDateL( aNewOrigin, modified, ignoredIds );
+
+    CleanupStack::PopAndDestroy( &ignoredIds ); // <-1
+    iCollection.iMessageList->SendL();
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::ResetModifiedCategoriesArray
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::ResetModifiedCategoriesArray()
+    {
+    TInt count = iModifiedCategories.Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        iModifiedCategories[i] = EFalse;
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CVcxMyVideosCategories::AddEventsFromModifiedCategoriesArrayL
+// ----------------------------------------------------------------------------
+//
+void CVcxMyVideosCategories::AddEventsFromModifiedCategoriesArrayL()
+    {
+    TMPXItemId mpxId;
+    TInt count = iModifiedCategories.Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        if ( iModifiedCategories[i] )
+            {
+            MPX_DEBUG2("CVcxMyVideosCategories:: category[%d] modified, adding event.", i);
+            mpxId = iListArray->AtL(i)->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+            iCollection.iMessageList->AddEventL( mpxId, EMPXItemModified );
+            }
+        }
+    }
+
+// End of file
+