/*

* Copyright (c) 2006-2007 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:    Stubs for thumbnail and attribute context

 *

*/

#include "stub_glxfetchcontexts.h"

// this flag defines the return value for CGlxThumbnailContext::RequestCountL

extern TInt gThumbnailContextRequestCount = 1;

// this flag defines the return value for CGlxAttributeContext::RequestCountL

extern TInt gAttributeContextRequestCount = 1;

// this flag defines the return value for GlxAttributeRetriever::RetrieveL

extern TInt gGlxAttributeRetrieverRetrieveL = 1;

// this flag defines the return value for TGlxMedia::GetDimensions

extern TBool gTGlxMediaGetDimensions = ETrue;

// this flag defines if the test is meant to be an alloc test

extern TBool gFetchContextAllocTest = EFalse;

// helper macro to do an alloc if we are in alloc test

#define MAKE_ALLOC_L \

	if( gFetchContextAllocTest ) \

		{ TInt* alloc = new( ELeave ) TInt; \

		delete alloc; }

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

// Stub for GlxAttributeRetriever -->

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

EXPORT_C TInt GlxAttributeRetriever::RetrieveL(

    const MGlxFetchContext& /*aContext*/, 

    MGlxMediaList& /*aList*/, 

    TBool /*aShowDialog*/ )

    {

    return gGlxAttributeRetrieverRetrieveL;

    }

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

// <-- Stub for GlxAttributeRetriever

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

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

// Stub for TGlxMedia -->

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

EXPORT_C TBool TGlxMedia::GetDimensions( TSize& /*aSize*/ ) const

    {

    return gTGlxMediaGetDimensions;

    }

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

// <-- Stub for TGlxMedia

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

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

// Stub for CGlxThumbnailContext  -->

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

CGlxThumbnailContext* CGlxThumbnailContext::NewL(

	MGlxMediaListIterator* aIterator )

	{

	return new( ELeave ) CGlxThumbnailContext( aIterator );

	}

CGlxThumbnailContext::CGlxThumbnailContext(

	MGlxMediaListIterator* /*aIterator*/ )

	{

	}

CGlxThumbnailContext::~CGlxThumbnailContext()

	{

	}

void CGlxThumbnailContext::AddSpecForItemL(

	TInt /*aWidth*/, TInt /*aHeight*/, TInt /*aFocusOffset*/ )

	{

	MAKE_ALLOC_L

	}

void CGlxThumbnailContext::SetDefaultSpec( 

	TInt /*aWidth*/, TInt /*aHeight*/ )

	{

	}

void CGlxThumbnailContext::SetHighQualityOnly( TBool /*aHighQualityOnly*/ )

    {

    }

// From MGlxFetchContext

void CGlxThumbnailContext::AllAttributesL(

	const MGlxMediaList* /*aList*/, 

	TInt /*aListIndex*/, 

	RArray<TMPXAttribute>& /*aAttributes*/ ) const

	{

	MAKE_ALLOC_L

	}

TInt CGlxThumbnailContext::AttributeRequestL(

	const MGlxMediaList* /*aList*/, 

	RArray<TInt>& /*aItemIndices*/, 

	RArray<TMPXAttribute>& /*aAttributes*/, 

	CMPXAttributeSpecs*& /*aDetailedSpecs*/ ) const

	{

	MAKE_ALLOC_L

	return 0;

	}

TInt CGlxThumbnailContext::RequestCountL(

	const MGlxMediaList* /*aList*/) const

	{

	MAKE_ALLOC_L

	return gThumbnailContextRequestCount;

	}

void CGlxThumbnailContext::HandleResolutionChanged()

    {

    }

TInt CGlxThumbnailContext::SelectItemL(

	const MGlxMediaList* /*aList*/, 

	TInt& /*aError*/) const

	{

	MAKE_ALLOC_L

	return 0;

	}

TUint CGlxThumbnailContext::GetThumbnailScoreL(

	TInt /*aIndexInList*/, 

	const MGlxMediaList* /*aList*/, 

	TInt /*aDistance*/, 

	TInt& /*aError*/) const

	{

	MAKE_ALLOC_L

	return 0;

	}

const CGlxThumbnailContext::TFetchSpec& CGlxThumbnailContext::SpecForIndex(

	TInt /*aListIndex*/, const MGlxMediaList* /*aList*/ ) const

	{

    return iDefaultSpec;

	}

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

// <-- Stub for CGlxThumbnailContext

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

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

// Stub for CGlxDefaultThumbnailContext -->

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

CGlxDefaultThumbnailContext* CGlxDefaultThumbnailContext::NewL()

	{

	return new( ELeave ) CGlxDefaultThumbnailContext;

	}

CGlxDefaultThumbnailContext::~CGlxDefaultThumbnailContext()

	{

	}

void CGlxDefaultThumbnailContext::SetRangeOffsets(

	TInt /*aFrontOffset*/, TInt /*aRearOffset*/ )

	{

	}

CGlxDefaultThumbnailContext::CGlxDefaultThumbnailContext()

	 : CGlxThumbnailContext( NULL )

	{

	}

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

// <-- Stub for CGlxDefaultThumbnailContext

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

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

// Stub for TGlxFromFocusOutwardIterator -->

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

TGlxFromFocusOutwardIterator::TGlxFromFocusOutwardIterator()

	{

	}

TGlxFromFocusOutwardIterator::~TGlxFromFocusOutwardIterator()

	{

	}

void TGlxFromFocusOutwardIterator::SetToFirst(const MGlxMediaList* )

	{

	}

TInt TGlxFromFocusOutwardIterator::operator++(TInt)

	{

	return 0;

	}

TBool TGlxFromFocusOutwardIterator::InRange(TInt ) const

	{

	return EFalse;

	}

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

// <-- Stub for TGlxFromFocusOutwardBlockyIterator

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

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

// Stub for TGlxFromFocusOutwardIterator -->

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

TGlxFromFocusOutwardBlockyIterator::TGlxFromFocusOutwardBlockyIterator()

	{

	}

TGlxFromFocusOutwardBlockyIterator::~TGlxFromFocusOutwardBlockyIterator()

	{

	}

void TGlxFromFocusOutwardBlockyIterator::SetToFirst(const MGlxMediaList* )

	{

	}

TInt TGlxFromFocusOutwardBlockyIterator::operator++(TInt)

	{

	return 0;

	}

TBool TGlxFromFocusOutwardBlockyIterator::InRange(TInt ) const

	{

	return EFalse;

	}

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

// <-- Stub for TGlxFromFocusOutwardBlockyIterator

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

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

// Stub for CGlxAttributeContext -->

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

CGlxAttributeContext::CGlxAttributeContext(MGlxMediaListIterator* )

	{

	}

CGlxAttributeContext::~CGlxAttributeContext()

	{

	}

void CGlxAttributeContext::AddAttributeL(const TMPXAttribute& )

	{

	MAKE_ALLOC_L

	}

void CGlxAttributeContext::RemoveAttribute(const TMPXAttribute& )

	{

	}

void CGlxAttributeContext::SetGranularity(TUint )

	{

	}

TInt CGlxAttributeContext::AttributeRequestL(const MGlxMediaList* , RArray<TInt>& , 

	RArray<TMPXAttribute>& , CMPXAttributeSpecs*& ) const

	{

	MAKE_ALLOC_L

	return 0;

	}

void CGlxAttributeContext::AllAttributesL(const MGlxMediaList* , TInt , 

	RArray<TMPXAttribute>& ) const

	{

	MAKE_ALLOC_L

	}

TInt CGlxAttributeContext::RequestCountL(const MGlxMediaList* ) const

	{

	MAKE_ALLOC_L

	return gAttributeContextRequestCount;

	}

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

// <-- Stub for CGlxAttributeContext

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

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

// Stub for CGlxDefaultAttributeContext -->

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

CGlxDefaultAttributeContext* CGlxDefaultAttributeContext::NewL()

	{

	return new( ELeave ) CGlxDefaultAttributeContext;

	}

CGlxDefaultAttributeContext::~CGlxDefaultAttributeContext()

	{

	}

CGlxDefaultAttributeContext::CGlxDefaultAttributeContext()

	: CGlxAttributeContext( NULL )

	{

	}

void CGlxDefaultAttributeContext::SetRangeOffsets(

	TInt , TInt )

	{

	}

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

// <-- Stub for CGlxDefaultAttributeContext

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

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

// Stub for TMPXAttribute -->

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

EXPORT_C TMPXAttribute::TMPXAttribute(TInt , TUint )

	{

	}

EXPORT_C TMPXAttribute::TMPXAttribute(const TMPXAttributeData& /*aData*/)

    {

    }

EXPORT_C TBool TMPXAttribute::Match( const TMPXAttribute& , const TMPXAttribute&  )

	{

	return EFalse;

	}

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

// <-- Stub for TMPXAttribute

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