--- /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;
+ }
+