/*

* 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 TN filter object with one thumbnail

// ---------------------------------------------------------------------------

//   

EXPORT_C CMPXFilter* TGlxFilterFactory::CreatePreviewTNFilterL()

    {

    TGlxFilterProperties filterProperties;

    // Exclude empty containers

    filterProperties.iMinCount = 1;

    // If sorting on date, override sort direction to descending

    filterProperties.iSortDirection = EGlxFilterSortDirectionOverrideToDescendingIfDate;

    // Request only one item

    filterProperties.iMaxCount = 1;

    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

// ---------------------------------------------------------------------------

//   

    TGlxFilterProperties filterProperties;

    filterProperties.iItemType = EGlxFilterImage;

    filterProperties.iPath = aSelectedListPath;

    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);

        }

    TInt maxCount = aFilterProperties.iMaxCount;    

    if( aOriginalFilter->IsSupported(KGlxFilterGeneralMaxCount) )

        {

        if( !aOverrideOriginal || ( 0 == aFilterProperties.iMaxCount ) )

            {

            maxCount = aOriginalFilter->ValueTObjectL<TInt>(KGlxFilterGeneralMaxCount);

            }

        }

    if( !(maxCount == 0) )

        {

        filter->SetTObjectValueL<TInt>(KGlxFilterGeneralMaxCount, maxCount);

        }

    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;

	TBool deletePath = EFalse;

	if( aOriginalFilter->IsSupported(KGlxFilterGeneralMPXCollectionPath) )

        {

        if( !aOverrideOriginal || !aFilterProperties.iPath )

        	{

        	path = aOriginalFilter->ValueCObjectL<CMPXCollectionPath>(KGlxFilterGeneralMPXCollectionPath);

        	CleanupStack::PushL(path);

        	deletePath = ETrue;

        	}

        }

    if( path )

        {

		// SetCObjectValueL creates a copy of path, so safe to destroy path after this call.

        filter->SetCObjectValueL<CMPXCollectionPath>(KGlxFilterGeneralMPXCollectionPath, path);    

        }

    if(deletePath)

        {

        CleanupStack::PopAndDestroy(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;