/*
* 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:    Fetch context to retrieve thumbnails
*
*/




#ifndef C_GLXTHUMBNAILCONTEXT_H
#define C_GLXTHUMBNAILCONTEXT_H

#include <e32std.h>
#include "mglxfetchcontext.h"
#include "glxmedialistiterator.h"
#include <mglxresolutionchangeobserver.h>

// Forward declarations

class CGlxAttributeContext;
class CGlxDRMUtility;
class CGlxResolutionUtility;
class MGlxCache;
class MGlxMediaList;
class TGlxMedia;

/**
 *  CGlxThumbnailContext
 *
 *  Fetch context to retrieve thumbnails
 *
 *  @lib glxmedialists.lib
 */
class CGlxThumbnailContext : public CBase, public MGlxFetchContext,
        public MGlxResolutionChangeObserver
	{
public:
    /**
	 * Constructor
	 * @param aIterator Iterator that determines the order of thumbnail 
	 *  	  retrieval and for which items thumbnails are and are not retrieved
	 */
	IMPORT_C static CGlxThumbnailContext* NewL(MGlxMediaListIterator* aIterator);

	/**
	 * Constructor
	 * @param aIterator Iterator that determines the order of thumbnail 
	 *  	  retrieval and for which items thumbnails are and are not retrieved
	 */
	IMPORT_C CGlxThumbnailContext(MGlxMediaListIterator* aIterator);
	IMPORT_C ~CGlxThumbnailContext();

	/**
	 * Adds a fetch specification for an individual item
	 * @param aWidth the width of required bitmap. The context
	 *				 may retrieve first a thumbnail of difference size
	 *				 if it thinks it helps user experience.
	 * @param aHeight the width of required bitmap. 
	 * @param aFocusOffset Delta to focus. 0 means focus.
	 */
	IMPORT_C void AddSpecForItemL(TInt aWidth, TInt aHeight, TInt aFocusOffset);

	/**
	 * Sets the default fetch specification. The context uses this
	 * for all items that do not have a specific spec added.
	 * @param aWidth the width of required bitmap. The context
	 *				 may retrieve first a thumbnail of difference size
	 *				 if it thinks it helps user experience.
	 * @param aHeight the heigth of required bitmap. 
	 */
	IMPORT_C void SetDefaultSpec(TInt aWidth, TInt aHeight);

    /**
     * Set whether only high quality thumbnails are wanted.
     * @param aHighQualityOnly ETrue to skip fetching low quality thumbnails.
     */
    IMPORT_C void SetHighQualityOnly( TBool aHighQualityOnly );

public: // From MGlxFetchContext
    /// See @ref MGlxFetchContext::AttributeRequestL
    TInt AttributeRequestL(const MGlxMediaList* aList, RArray<TInt>& aItemIndices, 
    	RArray<TMPXAttribute>& aAttributes, CMPXAttributeSpecs*& aDetailedSpecs) const;

    /// See @ref MGlxFetchContext::AllAttributesL
    void AllAttributesL(const MGlxMediaList* aList, TInt aListIndex, 
    	RArray<TMPXAttribute>& aAttributes) const;

    /// See @ref MGlxFetchContext::RequestCountL
    TInt RequestCountL(const MGlxMediaList* aList) const;

protected:
    /**
    * 2nd phase construction
    */
    void ConstructL();

private:    // From MGlxResolutionChangeObserver
    void HandleResolutionChangedL();

private: 
        /**
         * Select the best thumbnail for processing
         *
         * @param aList pointer to media list
         * @param aError indication of any errors encountered when selecting item
         */
        TInt SelectItemL(const MGlxMediaList* aList, TInt& aError) const;

        /**
         * Calculates a score for thumbnail retrieval
         *
         * @param aIndexInList index of the item in the list
         * @param aList pointer to media list
         * @param aDistance Distance from highest priority index
         * @param aError indication of any errors encountered when calculating score
         *
         * @returns a score of how important processing this item's
         * 			thumbnail is. The higher, the more important.
         */
	TUint GetThumbnailScoreL(TInt aIndexInList, const MGlxMediaList* aList,
		TInt aDistance, TInt& aError) const;

    /** Item to specify what kind of thumbnail is needed */
    struct TFetchSpec
        {
        inline TFetchSpec() { iPossWidth = 0; iPossHeight = 0; };

        /** Width of the thumbnail */
        TReal32 iPossWidth;

        /** Height of the thumbnail */
        TReal32 iPossHeight;
        };

    /** 
    * Item to specify what kind of thumbnail is needed 
    * for which item (compared to focus)
    */
    struct TAssignedFetchSpec : public TFetchSpec
        {
        inline TAssignedFetchSpec() { iFocusOffset = 0; };

        /** Compares two specs by focus offset. Used for RArray::Find() */
        static TBool Match( const TAssignedFetchSpec& aSpec1,
                            const TAssignedFetchSpec& aSpec2 );

        /** Delta to focus. If zero, then focused item */
        TInt iFocusOffset;
        };

    /**
     * Get the fetch spec to be used for a given media item.
     * @param aListIndex Index of current item
     * @param aList Pointer to media list
     * @return Reference to fetch spec to use for the given item.
     */
    const TFetchSpec& SpecForIndex(TInt aListIndex,
                                    const MGlxMediaList* aList) const;

    /**
     * Get the size in pixels for a fetch spec.
     * @param aSpec Reference to fetch spec.
     * @return Size in pixels for the current screen resolution.
     */
    TSize SizeFromSpec( const TFetchSpec& aSpec ) const;

    /**
     * Check whether a given item has any full thumbnail attributes.
     * @param aItem Media item to check.
     * @return ETrue if a full thumbnail attribute is present.
     */
    TBool HasFullThumbnail( const TGlxMedia& aItem ) const;

    /**
     * Check DRM status of item at given index. Updates the fetch spec
     * for an item with invalid DRM
     * @param aListIndex index of current item
     * @param aList pointer to media list
     * @param aSpec reference to fetch spec
	 * @return ETrue if the item at index is not protected or has valid rights
     */
    TBool CheckDRMStatusL( TInt aListIndex, const MGlxMediaList* aList,
                                        TSize& aSize ) const;           

private:
    /** Specs applies to individual items */
    RArray<TAssignedFetchSpec> iSpecs;

    /** Request spec that is applied to all other items than in iSpecs */
    TFetchSpec iDefaultSpec;

    /** Whether to skip fetching low quality thumbnails */
    TBool iHighQualityOnly;

    /** Iterator for traversing the list */
    MGlxMediaListIterator* iIterator;	

    /** Cache manager interface (owned) */
    MGlxCache* iCache;

    /** Utility to translate between pixels and poss units */
    CGlxResolutionUtility* iResolutionUtility;

    /** DRM utility for checking rights */
    CGlxDRMUtility* iDrmUtility;

    /** Attribute context to fetch DRM attributes */
    CGlxAttributeContext* iDrmFetchContext;
    
    /** Size of the default spec */
    TSize iDefaultSpecSize;
    };

/**
 *  CGlxDefaultAttributeContext
 *
 *  Fetch context to retrieve MPX attributes starting from focus outward
 *
 *  @lib glxmedialists.lib
 */
class CGlxDefaultThumbnailContext : public CGlxThumbnailContext
	{
public:
	IMPORT_C static CGlxDefaultThumbnailContext* NewL();
	IMPORT_C ~CGlxDefaultThumbnailContext();

	/**
	 * Set the range offsets. These determine the outer limits
	 * of attributes to be retrieved, compared to current focus in
	 * the list
	 * If ranges not defined, retrieves the attributes for focused item only
	 */
    IMPORT_C void SetRangeOffsets(TInt aFrontOffset, TInt aRearOffset);

private:
	CGlxDefaultThumbnailContext();

private:
	TGlxFromFocusOutwardIterator iFromFocusIterator;	
	};

#endif // C_GLXTHUMBNAILCONTEXT_H