/*

* 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:    Layout blender

*

*/

#include "glxblendlayout.h" 

#include <glxpanic.h> // Panic codes

// LOCAL METHODS

namespace

	{

	// helper method to calculate coefficiency for given field

	TReal32 GetCoefficiency(

		TGlxLayoutInfo& aBaseInfo, 

		TGlxLayoutInfo& aDeltaInfo, 

		TGlxLayoutInfo::TLayoutType aType, 

		TInt aIndex )

		{

		/*

		// position, get coefficients

		//TReal32 new_coeff = aDeltaInfo.Coefficient( aType );

		//TReal32 combined_coeff = aBaseInfo.Coefficient( aType );

		// check if this is the first layout chain in the blender

		// and full coefficiency has not been yet reached

		if( aIndex == 0 && combined_coeff < 1.0 )

			{

			// increase the coefficient to reach 1.0

			new_coeff = 1.0 - combined_coeff;

			aBaseInfo.SetCoefficient( aType, 1.0 );

			}

		// if the coefficient was bigger than zero

		// and full coefficiency has not been yet reached

		else if( new_coeff > 0.0 && combined_coeff < 1.0 )

			{

			// dont allow coefficient to exceed 1.0

			if( new_coeff > ( 1.0 - combined_coeff ) )

				{

				new_coeff = 1.0 - combined_coeff;

				}

			// increase the coefficient

			aBaseInfo.SetCoefficient( aType, combined_coeff + new_coeff );

			}

		else

			{

			// coefficient over or underflow

			new_coeff = 0;

			}

		return new_coeff;*/

		} 

	}

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

// Constructor

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

EXPORT_C TGlxBlendLayout::TGlxBlendLayout()

	: iChanged( EFalse )	// blender not is changed by default

	{

	__DEBUG_ONLY( _iName = _L( "TGlxBlendLayout" ) );

	}

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

// Destructor

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

EXPORT_C TGlxBlendLayout::~TGlxBlendLayout () 

	{

	iLayouts.Close();

	}

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

// AddLayoutL

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

EXPORT_C void TGlxBlendLayout::AddLayoutL( MGlxLayout* aLayout )

	{

	// layout must not be null

	__ASSERT_DEBUG( aLayout, Panic( EGlxPanicNullLayout ) );

	// create layout struct

	TLayout cache;

	cache.iLayout = aLayout;

	__ASSERT_DEBUG( 

		iLayouts.Find( cache, TLayout::Match ) == KErrNotFound, 

		Panic( EGlxPanicAlreadyAdded ) );

	// cant set anything sane to layout info at this point

	iLayouts.AppendL( cache );

	iChanged = ETrue;

	}

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

// RemoveLayout

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

EXPORT_C void TGlxBlendLayout::RemoveLayout( const MGlxLayout* aLayout )

	{

	TInt count = iLayouts.Count();

	for( TInt i = 0; i < count; i++ )

		{

		if( iLayouts[ i ].iLayout == aLayout )

			{

			// Found it, remove

			iLayouts.Remove( i );

			iChanged = ETrue;

			return;

			}

		}

	// its ok to remove a layout that was already gone, no harm done there

	}

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

// RemoveAllLayouts

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

EXPORT_C void TGlxBlendLayout::RemoveAllLayouts()

	{

	iLayouts.Close();

	}

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

// MapValue

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

void TGlxBlendLayout::DoSetLayoutValues( TGlxLayoutInfo& aInfo )

	{

	/*

	TInt count = iLayouts.Count();

	// first set each layouts info fields correctly

	for( TInt i = 0; i < count; i++ )

		{

		// reset the values for the layout info

		//iLayouts[ i ].iLayoutInfo.Reset( aInfo.Index() );

		//iLayouts[ i ].iLayoutInfo.SetVisual( aInfo.Visual() );

		//iLayouts[ i ].iLayoutInfo.SetScreenInfo( aInfo.ScreenInfo() );

		}

	// process each layout

	for( TInt i = 0; i < count; i++ )

		{

		// call the layout (chain) to perform the processing for their own info

		iLayouts[ i ].iLayout->SetLayoutValues( iLayouts[ i ].iLayoutInfo );

		}

	// reset completely the aInfo fields and its coefficients

	// we use the coefficient fields to know when we have enough values for

	// certain field (coefficient reaches 1.0)

	// we need to reset the base values as the cached values in layout chains

	// had default values (which may not ne 0 for all fields)

	aInfo.iPosition.iX = 0;

	aInfo.iPosition.iY = 0;

	aInfo.SetCoefficient( TGlxLayoutInfo::EPosition, 0 );

	aInfo.iSize.iX = 0;

	aInfo.iSize.iY = 0;

	aInfo.SetCoefficient( TGlxLayoutInfo::ESize, 0 );

	aInfo.iOpacity = 0;

	aInfo.SetCoefficient( TGlxLayoutInfo::EOpacity, 0 );

	aInfo.iRotation = 0;

	aInfo.SetCoefficient( TGlxLayoutInfo::ERotation, 0 );

	// then merge the values according to coefficients

	// need to process in reverse order since layout in index 0

	// has the strongest effect

	for( TInt i = count - 1; i >= 0; i-- )

		{

		// position, get coefficient

		TReal32 new_coeff = GetCoefficiency( 

				aInfo, iLayouts[ i ].iLayoutInfo, 

				TGlxLayoutInfo::EPosition, i );

		// if the coefficient was bigger than zero

		if( new_coeff > 0.0 )

			{

			// add new position, multiplied with the coefficient

			aInfo.iPosition.iX += 

				iLayouts[ i ].iLayoutInfo.iPosition.iX * new_coeff;

			aInfo.iPosition.iY += 

				iLayouts[ i ].iLayoutInfo.iPosition.iY * new_coeff;

			}

		// size, get coefficient

		new_coeff = GetCoefficiency( 

				aInfo, iLayouts[ i ].iLayoutInfo, 

				TGlxLayoutInfo::ESize, i );

		// if the coefficient was bigger than zero

		if( new_coeff > 0.0 )

			{

			// add new size, multiplied with the coefficient

			aInfo.iSize.iX += 

				iLayouts[ i ].iLayoutInfo.iSize.iX * new_coeff;

			aInfo.iSize.iY += 

				iLayouts[ i ].iLayoutInfo.iSize.iY * new_coeff;

			}

		// opacity, get coefficient

		new_coeff = GetCoefficiency( 

				aInfo, iLayouts[ i ].iLayoutInfo, 

				TGlxLayoutInfo::EOpacity, i );

		if( new_coeff > 0.0 )

			{

			// add new opacity, multiplied with the coefficient

			aInfo.iOpacity += 

				iLayouts[ i ].iLayoutInfo.iOpacity * new_coeff;

			}

		// rotation, get coefficient

		new_coeff = GetCoefficiency( 

				aInfo, iLayouts[ i ].iLayoutInfo, 

				TGlxLayoutInfo::ERotation, i );

		if( new_coeff > 0.0 )

			{

			// add new rotation, multiplied with the coefficient

			aInfo.iRotation += 

				iLayouts[ i ].iLayoutInfo.iRotation * new_coeff;

			}

		} */

	}

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

// DoChanged

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

TBool TGlxBlendLayout::DoChanged() const

	{

	// See if even one layout has changed

	/// @todo consider adding the index of current visual to the Changed call

/*	TInt count = iLayouts.Count();

	for( TInt i = 0; i < count; i++ )

		{

		if( iLayouts[ i ].iLayout->Changed() )

			{

			return ETrue;

			}

		}

	return iChanged;

*/	}

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

// DoClearChanged

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

void TGlxBlendLayout::DoClearChanged() 

	{

	TInt count = iLayouts.Count();

	for( TInt i = 0; i < count; i++ )

		{

//		iLayouts[ i ].iLayout->ClearChanged();

		}

	iChanged = EFalse;

	}

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

// TLayout::Match

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

TBool TGlxBlendLayout::TLayout::Match( const TLayout& aLhs, const TLayout& aRhs )

	{

	return aLhs.iLayout == aRhs.iLayout;

	}