diff -r 000000000000 -r 4e91876724a2 photosgallery/common/src/glxfilterfactory.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/photosgallery/common/src/glxfilterfactory.cpp	Thu Dec 17 08:45:44 2009 +0200
@@ -0,0 +1,557 @@
+/*
+* 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".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:    Command object factory
+*
+*/
+
+
+
+#include <glxlog.h>
+#include "glxfilterfactory.h"
+
+// ---------------------------------------------------------------------------
+// Creates a General filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateItemTypeFilterL(TGlxFilterItemType aItemType)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iItemType = aItemType;
+    return CreateCombinedFilterL(filterProperties);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates a URI filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateURIFilterL(const TDesC& aURI)
+    {
+    GLX_FUNCL("TGlxFilterFactory::CreateURIFilterL()");
+    
+    TGlxFilterProperties filterProperties;
+    filterProperties.iUri = &aURI;
+    return CreateCombinedFilterL(filterProperties);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates an alpabetic sort filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateAlphabeticSortFilterL(const TGlxFilterSortDirection aSortDirection)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iSortOrder = EGlxFilterSortOrderAlphabetical;
+    filterProperties.iSortDirection = aSortDirection;
+    return CreateCombinedFilterL(filterProperties);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates an item count sort filter object. The containers with the greatest
+// number of items are listed first
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateItemCountSortFilterL(const TGlxFilterSortDirection aSortDirection)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iSortOrder = EGlxFilterSortOrderItemCount;
+    filterProperties.iSortDirection = aSortDirection;
+    return CreateCombinedFilterL(filterProperties);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates a capture date sort filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateCaptureDateSortFilterL(const TGlxFilterSortDirection aSortDirection)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;
+    filterProperties.iSortDirection = aSortDirection;
+    return CreateCombinedFilterL(filterProperties);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates a modified date sort filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateModifiedDateFilterL(const TGlxFilterSortDirection aSortDirection)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iSortOrder = EGlxFilterSortOrderModifiedDate;
+    filterProperties.iSortDirection = aSortDirection;
+    return CreateCombinedFilterL(filterProperties);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates a camera album exclusion filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateCameraAlbumExclusionFilterL()
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iIncludeCameraAlbum = EFalse;
+    return CreateCombinedFilterL(filterProperties);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates an empty container exclusion filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateIncludeEmptyContainersFilterL(CMPXMedia* aOriginalFilter)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iMinCount = -1;
+    return CreateCombinedFilterL(filterProperties, aOriginalFilter, ETrue);
+    }
+
+// ---------------------------------------------------------------------------
+// Creates aa filter that excludes all caontainers that does not contain a
+// specified item id.
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateExcludeContainersWithoutItemFilterL(TGlxMediaId aItemId)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iContainsItem = aItemId;
+    return CreateCombinedFilterL(filterProperties);
+    }
+
+// ---------------------------------------------------------------------------
+// Creates a last capture date filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateLastCaptureDateFilterL()
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;
+    filterProperties.iSortDirection = EGlxFilterSortDirectionAscending;
+    filterProperties.iLastCaptureDate = ETrue;
+    return CreateCombinedFilterL(filterProperties);
+    }
+
+// ---------------------------------------------------------------------------
+// Creates a preview filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreatePreviewFilterL()
+    {
+    TGlxFilterProperties filterProperties;
+    // Exclude empty containers
+    filterProperties.iMinCount = 1;
+    // If sorting on date, override sort direction to descending
+    filterProperties.iSortDirection = EGlxFilterSortDirectionOverrideToDescendingIfDate;
+    return CreateCombinedFilterL(filterProperties);
+    }
+
+
+// ---------------------------------------------------------------------------
+// Creates a preview filter object for container items (album, tags)
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateContainerPreviewFilterL()
+    {
+    TGlxFilterProperties filterProperties;
+    // If sorting on date, override sort direction to descending
+    filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;
+    filterProperties.iSortDirection = EGlxFilterSortDirectionOverrideToDescendingIfDate;
+    return CreateCombinedFilterL(filterProperties);
+    }
+
+
+// ---------------------------------------------------------------------------
+// Creates a last capture date filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateExcludeAnimationFilterL(const TGlxFilterSortDirection aSortDirection)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iItemType = EGlxFilterImage;
+    filterProperties.iExcludeAnimation = ETrue;
+    filterProperties.iSortDirection = aSortDirection;
+    return CreateCombinedFilterL(filterProperties);
+    }
+
+// ---------------------------------------------------------------------------
+// Creates a thumbnail loadibility filter object
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateThumbnailLoadabilityFilterL(TSize aSize)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iThumbnailLoadability = aSize;
+    return CreateCombinedFilterL(filterProperties);
+    }
+
+// ---------------------------------------------------------------------------
+// Creates a filter most suited for the SlideShow
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateSlideShowFilterL( CMPXCollectionPath* aSelectedListPath,
+                                                                TGlxFilterSortDirection aSortDirection,
+                                                                TGlxFilterSortOrder aSortFilter)
+    {
+    TGlxFilterProperties filterProperties;
+    filterProperties.iSortOrder = aSortFilter;
+    filterProperties.iSortDirection = aSortDirection;
+    filterProperties.iItemType = EGlxFilterImage;
+    filterProperties.iPath = aSelectedListPath;
+    filterProperties.iNoDRM = ETrue;;
+    filterProperties.iExcludeAnimation = ETrue;
+    return CreateCombinedFilterL(filterProperties);
+    }
+
+// ---------------------------------------------------------------------------
+// Creates a filter most suited for the SlideShow
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateSlideShowFilterFromExistingFilterL(   CMPXFilter* aOriginalFilter,
+                                                                                    CMPXCollectionPath* aSelectedListPath,
+                                                                                    TBool aReverseSortDirection)
+    {     
+    TGlxFilterProperties filterProperties;
+    filterProperties.iSortDirection = aReverseSortDirection ? EGlxFilterSortDirectionReverse : EGlxFilterSortDirectionNotUsed;
+    filterProperties.iItemType = EGlxFilterImage;
+    filterProperties.iPath = aSelectedListPath;
+    filterProperties.iNoDRM = ETrue;;
+    filterProperties.iExcludeAnimation = ETrue;;
+    return CreateCombinedFilterL(filterProperties, aOriginalFilter);
+    }
+    
+// ---------------------------------------------------------------------------
+// Creates a combined filter object.
+// ---------------------------------------------------------------------------
+//   
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateCombinedFilterL(  const TGlxFilterProperties& aFilterProperties,
+                                                                CMPXFilter* aOriginalFilter,
+                                                                TBool aOverrideOriginal)
+    {
+    GLX_FUNCL("TGlxFilterFactory::CreateCombinedFilterL()");
+    
+    CMPXFilter* filter = CMPXFilter::NewL();
+    CleanupStack::PushL(filter);
+
+    // to prevent needing to check if aOriginalFilter is not NULL each time,
+    // if it is we point it to filter, which supports nothing (support is checked only before setting)
+    if( !aOriginalFilter )
+    	{
+    	aOriginalFilter = filter;
+    	}
+    	
+    TGlxFilterItemType itemType = aFilterProperties.iItemType;
+    if( ( EGlxFilterMediaTypeSuppliedInFilter == aFilterProperties.iItemType ) || !aOverrideOriginal )
+        {
+        if( aOriginalFilter->IsSupported(KGlxFilterGeneralItemType) )
+            {
+            itemType = aOriginalFilter->ValueTObjectL<TGlxFilterItemType>(KGlxFilterGeneralItemType);
+            }
+        }
+                                                                                              
+    filter->SetTObjectValueL<TGlxFilterItemType>(KGlxFilterGeneralItemType, itemType);
+        
+
+	TGlxFilterSortOrder sortFilter = aFilterProperties.iSortOrder;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralSortType) )
+        {
+        if( !aOverrideOriginal || ( EGlxFilterSortOrderNotUsed == aFilterProperties.iSortOrder ) )
+        	{
+        	sortFilter = aOriginalFilter->ValueTObjectL<TGlxFilterSortOrder>(KGlxFilterGeneralSortType);
+        	}
+        }
+    if( EGlxFilterSortOrderNotUsed != sortFilter )
+        {
+        filter->SetTObjectValueL<TGlxFilterSortOrder>(KGlxFilterGeneralSortType, sortFilter);
+        }
+
+       
+ 	TGlxFilterSortDirection sortDirection = aFilterProperties.iSortDirection;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralSortDirection) )
+        {
+        if( !aOverrideOriginal || ( EGlxFilterSortDirectionNotUsed == aFilterProperties.iSortDirection ) )
+        	{
+        	sortDirection = aOriginalFilter->ValueTObjectL<TGlxFilterSortDirection>(KGlxFilterGeneralSortDirection);
+        	TBool descendIfDate = ( EGlxFilterSortDirectionOverrideToDescendingIfDate == sortDirection ) && ( ( EGlxFilterSortOrderCaptureDate == sortFilter ) || ( EGlxFilterSortOrderModifiedDate == sortFilter ) );
+        	if( EGlxFilterSortDirectionReverse == sortDirection )
+        		{
+        		if( EGlxFilterSortDirectionDescending == aFilterProperties.iSortDirection )
+        			{
+        			sortDirection = EGlxFilterSortDirectionAscending;
+        			}
+        		else if( EGlxFilterSortDirectionAscending == aFilterProperties.iSortDirection )
+        			{
+         			sortDirection = EGlxFilterSortDirectionDescending;
+        			}
+        		}
+        	else if( descendIfDate )
+        	    {
+         		sortDirection = EGlxFilterSortDirectionDescending;
+        	    }
+        	else if( EGlxFilterSortDirectionOverrideToDescendingIfDate == sortDirection )
+        	    {
+        	    sortDirection = aFilterProperties.iSortDirection;
+        	    }
+        	}
+        else if( aOverrideOriginal && ( EGlxFilterSortDirectionReverse == aFilterProperties.iSortDirection ) )
+        	{
+        	switch(aOriginalFilter->ValueTObjectL<TGlxFilterSortDirection>(KGlxFilterGeneralSortDirection))
+        		{
+        		case EGlxFilterSortDirectionNotUsed:
+        		case EGlxFilterSortDirectionReverse:
+        			{
+        			sortDirection = EGlxFilterSortDirectionReverse;
+        			break;
+        			}
+        		case EGlxFilterSortDirectionAscending:
+         			{
+        			sortDirection = EGlxFilterSortDirectionDescending;
+        			break;
+        			}
+	       		case EGlxFilterSortDirectionDescending:
+        			{
+        			sortDirection = EGlxFilterSortDirectionAscending;
+        			break;
+        			}
+        		}
+        	}
+        }
+ 	if( EGlxFilterSortDirectionNotUsed != sortDirection )
+        {
+        filter->SetTObjectValueL<TGlxFilterSortDirection>(KGlxFilterGeneralSortDirection, sortDirection);        
+        }
+  
+	TBool cameraAlbumFilter = aFilterProperties.iIncludeCameraAlbum;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralIncludeCameraAlbum) )
+        {
+        if( !aOverrideOriginal || !aFilterProperties.iIncludeCameraAlbum )
+        	{
+        	cameraAlbumFilter = aOriginalFilter->ValueTObjectL<TBool>(KGlxFilterGeneralIncludeCameraAlbum);
+        	}
+        }
+    if( !cameraAlbumFilter )
+        {
+        filter->SetTObjectValueL<TBool>(KGlxFilterGeneralIncludeCameraAlbum, cameraAlbumFilter);        
+        }
+
+        
+    TInt minCount = aFilterProperties.iMinCount;    
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralMinCount) )
+        {
+        if( !aOverrideOriginal || ( 0 == aFilterProperties.iMinCount ) )
+        	{
+	        minCount = aOriginalFilter->ValueTObjectL<TInt>(KGlxFilterGeneralMinCount);
+        	}
+        }
+    if( !(minCount == 0) )
+        {
+        filter->SetTObjectValueL<TInt>(KGlxFilterGeneralMinCount, minCount);
+        }
+   
+    
+    TGlxMediaId itemId = aFilterProperties.iContainsItem;    
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralItemId) )
+        {
+        if( !aOverrideOriginal || ( TGlxMediaId(0) == aFilterProperties.iContainsItem ) )
+        	{
+	        itemId = (TGlxMediaId)(TUint32)aOriginalFilter->ValueTObjectL<TMPXItemId>(KGlxFilterGeneralItemId);
+        	}
+        }
+    if( TGlxMediaId(0) != itemId )
+        {
+        filter->SetTObjectValueL<TMPXItemId>(KGlxFilterGeneralItemId, itemId.Value());        
+        }
+        
+        
+	TBool lastCaptureDateFilter = aFilterProperties.iLastCaptureDate;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralLastCaptureDate) )
+        {
+        if( !aOverrideOriginal || !aFilterProperties.iLastCaptureDate )
+        	{
+        	lastCaptureDateFilter = aOriginalFilter->ValueTObjectL<TBool>(KGlxFilterGeneralLastCaptureDate);
+        	}
+        }
+    if( lastCaptureDateFilter )
+        {
+        filter->SetTObjectValueL<TBool>(KGlxFilterGeneralLastCaptureDate, lastCaptureDateFilter);        
+        }
+        
+	TBool excludeAnimation = aFilterProperties.iExcludeAnimation;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralExcludeAnimation) )
+        {
+        if( !aOverrideOriginal || !aFilterProperties.iExcludeAnimation )
+        	{
+        	excludeAnimation = aOriginalFilter->ValueTObjectL<TBool>(KGlxFilterGeneralExcludeAnimation);
+        	}
+        }
+    if( excludeAnimation )
+        {
+        filter->SetTObjectValueL<TBool>(KGlxFilterGeneralExcludeAnimation, excludeAnimation);
+        }
+        
+	TBool noDRM = aFilterProperties.iNoDRM;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralNoDRM) )
+        {
+        if( !aOverrideOriginal || !aFilterProperties.iNoDRM )
+        	{
+        	noDRM = aOriginalFilter->ValueTObjectL<TBool>(KGlxFilterGeneralNoDRM);
+        	}
+        }
+    if( noDRM )
+        {
+        filter->SetTObjectValueL<TBool>(KGlxFilterGeneralNoDRM, noDRM);
+        }
+        
+	TSize thumbnailLoadability = aFilterProperties.iThumbnailLoadability;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralThumbnailLoadability) )
+        {
+        if( !aOverrideOriginal || ( TSize(0,0) == aFilterProperties.iThumbnailLoadability ) )
+        	{
+        	thumbnailLoadability = aOriginalFilter->ValueTObjectL<TSize>(KGlxFilterGeneralThumbnailLoadability);
+        	}
+        }
+    if( TSize(0,0) != thumbnailLoadability )
+        {
+        filter->SetTObjectValueL<TSize>(KGlxFilterGeneralThumbnailLoadability, thumbnailLoadability);    
+        }
+        
+	CMPXCollectionPath* path = aFilterProperties.iPath;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralMPXCollectionPath) )
+        {
+        if( !aOverrideOriginal || !aFilterProperties.iPath )
+        	{
+        	path = aOriginalFilter->ValueCObjectL<CMPXCollectionPath>(KGlxFilterGeneralMPXCollectionPath);
+        	}
+        }
+    if( path )
+        {
+        filter->SetCObjectValueL<CMPXCollectionPath>(KGlxFilterGeneralMPXCollectionPath, path);    
+        }
+   
+	TBool promoteSystemItems = aFilterProperties.iPromoteSystemItems;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralSortOrderPromoteSystemItems) )
+        {
+        if( !aOverrideOriginal || !aFilterProperties.iPromoteSystemItems )
+        	{
+        	promoteSystemItems = aOriginalFilter->ValueTObjectL<TBool>(KGlxFilterGeneralSortOrderPromoteSystemItems);
+        	}
+        }
+    if( promoteSystemItems )
+        {
+        filter->SetTObjectValueL<TBool>(KGlxFilterGeneralSortOrderPromoteSystemItems, promoteSystemItems);
+        }
+   
+	TGlxFilterOrigin origin = aFilterProperties.iOrigin;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralOrigin) )
+        {
+        if( !aOverrideOriginal || ( EGlxFilterOriginNotUsed == aFilterProperties.iOrigin ) )
+        	{
+        	origin = aOriginalFilter->ValueTObjectL<TGlxFilterOrigin>(KGlxFilterGeneralOrigin);
+        	}
+        }
+    if( EGlxFilterOriginNotUsed != origin )
+        {
+        filter->SetTObjectValueL<TGlxFilterOrigin>(KGlxFilterGeneralOrigin, origin);
+        }
+ 
+	const TDesC* uri = aFilterProperties.iUri;
+	if( aOriginalFilter->IsSupported(KGlxFilterGeneralUri) )
+        {
+        if( !aOverrideOriginal || ( !aFilterProperties.iUri ) )
+        	{
+        	uri = &aOriginalFilter->ValueText(KGlxFilterGeneralUri);
+        	}
+        }
+    if( uri )
+        {
+        filter->SetTextValueL(KGlxFilterGeneralUri, *uri);    
+        }
+   
+    CleanupStack::Pop(filter);
+    return filter;
+    }
+     
+// ---------------------------------------------------------------------------
+// Creates an empty container(for albums with no images) exclusion filter object
+// ---------------------------------------------------------------------------
+//    
+EXPORT_C CMPXFilter* TGlxFilterFactory::CreateExcludeEmptyContainersFilterL(CMPXMedia* aOriginalFilter)
+	{
+	TGlxFilterProperties filterProperties;
+	filterProperties.iMinCount = 1;
+	return CreateCombinedFilterL(filterProperties, aOriginalFilter, ETrue);
+	}
+	
+	
+EXPORT_C TGlxFilterProperties TGlxFilterFactory::ExtractAttributes(CMPXFilter* aFilter)
+    {
+    TGlxFilterProperties filterProperties;
+    // Now get the KGlxFilterGeneralibutes specified in the filter
+    if (aFilter->IsSupported(KGlxFilterGeneralItemType))
+        {
+        filterProperties.iItemType = aFilter->ValueTObjectL<TGlxFilterItemType>(KGlxFilterGeneralItemType);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralSortType))
+        {
+        filterProperties.iSortOrder = aFilter->ValueTObjectL<TGlxFilterSortOrder>(KGlxFilterGeneralSortType);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralSortDirection))
+        {
+        filterProperties.iSortDirection = aFilter->ValueTObjectL<TGlxFilterSortDirection>(KGlxFilterGeneralSortDirection);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralIncludeCameraAlbum))
+        {
+        filterProperties.iIncludeCameraAlbum = aFilter->ValueTObjectL<TBool>(KGlxFilterGeneralIncludeCameraAlbum);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralMinCount))
+        {
+        filterProperties.iMinCount = aFilter->ValueTObjectL<TInt>(KGlxFilterGeneralMinCount);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralItemId))
+        {
+        filterProperties.iContainsItem = (TGlxMediaId)(TUint32)aFilter->ValueTObjectL<TMPXItemId>(KGlxFilterGeneralItemId);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralExcludeAnimation))
+        {
+        filterProperties.iExcludeAnimation =  aFilter->ValueTObjectL<TBool>(KGlxFilterGeneralExcludeAnimation);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralNoDRM))
+        {
+        filterProperties.iNoDRM =  aFilter->ValueTObjectL<TBool>(KGlxFilterGeneralNoDRM);
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralLastCaptureDate))
+        {
+        filterProperties.iLastCaptureDate = aFilter->ValueTObjectL<TBool>(KGlxFilterGeneralLastCaptureDate);
+        }
+    if ( aFilter->IsSupported( KGlxFilterGeneralThumbnailLoadability ) )
+        {
+        filterProperties.iThumbnailLoadability = aFilter->ValueTObjectL<TSize>(
+                                    KGlxFilterGeneralThumbnailLoadability );
+        }
+    if (aFilter->IsSupported(KGlxFilterGeneralMPXCollectionPath))
+        {
+        filterProperties.iPath = aFilter->ValueCObjectL<CMPXCollectionPath>(KGlxFilterGeneralMPXCollectionPath);
+        }
+    if( aFilter->IsSupported(KGlxFilterGeneralSortOrderPromoteSystemItems) )
+        {
+        filterProperties.iPromoteSystemItems = aFilter->ValueTObjectL<TBool>(KGlxFilterGeneralSortOrderPromoteSystemItems);
+        }
+    if( aFilter->IsSupported(KGlxFilterGeneralOrigin) )
+        {
+        filterProperties.iOrigin = aFilter->ValueTObjectL<TGlxFilterOrigin>(KGlxFilterGeneralOrigin);
+        }
+    if( aFilter->IsSupported(KGlxFilterGeneralUri) )
+        {
+        filterProperties.iUri = &aFilter->ValueText(KGlxFilterGeneralUri);
+        }
+    return filterProperties;
+    }
+