/*

* Copyright (c) 2007-2008 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:  CoverFlow templates Implementation

 *

*/

//  Include Files

// Class Headers 

#include "mulcoverflowcontrol.h"

// DUI headers for xml parser

#include <uimodel/duinode.h>

#include <dui/duiproperty.h>

#include <uimodel/duixmlattributelist.h>

// Local Headers

#include "mulutility.h"

#include "mulbaseelement.h"

#include "mulcoverflowenhancedtemplate.h"

#include "mulcoverflowdefinitions.h"     //defines all the strings 

#include "mullog.h"

using namespace duiuimodel;

namespace Alf

    {

struct TMulCoverFlowEnhancedTemplateImpl

    {

    TMulCoverFlowEnhancedTemplateImpl()

    	{

    	}

    //Structure used to store the position and sizes of the counter.

    TMulCoverFlowItem mEnhancedMinSize;  // minimum size of images in enhanced mode

    TMulCoverFlowItem mEnhancedMaxSize;  // maximum size of images in enhanced mode

    TMulCoverFlowItem mEnhacedCounterPos; // The position and size of the counter in enhaced mode

    UString mEnhancedBorderImagePath;

    ~TMulCoverFlowEnhancedTemplateImpl()

    	{

    	}    

    };

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

// MulCoverFlowEnhancedTemplate

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

//

MulCoverFlowEnhancedTemplate::MulCoverFlowEnhancedTemplate(MulCoverFlowControl &aControl,

			UString &aTemplateID, MulXmlUtility& aMulXmlUtility,DuiNode* aRootNode):MulCoverFlowBaseTemplate( 

				    aControl, aTemplateID, aMulXmlUtility,aRootNode )

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::MulCoverFlowEnhancedTemplate");

    mData.reset(new (EMM)TMulCoverFlowEnhancedTemplateImpl);

    // Parses the xml from the oreientation node.

    ParseNode( *GetOrientationNode() );

    }

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

// ~MulCoverFlowWidget

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

//

MulCoverFlowEnhancedTemplate::~MulCoverFlowEnhancedTemplate()

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::~MulCoverFlowEnhancedTemplate");       

    //Nothing to delete .

    }

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

// EnhancedMaxSize

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

//

const TMulCoverFlowItem& MulCoverFlowEnhancedTemplate::EnhancedMaxSize()

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::EnhancedMaxSize");

    return mData->mEnhancedMaxSize;

    }

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

// EnhancedMinSize

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

//

const TMulCoverFlowItem& MulCoverFlowEnhancedTemplate::EnhancedMinSize()

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::EnhancedMinSize");

    return mData->mEnhancedMinSize;

    }

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

// EnhacedCounterPos

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

//

const TMulCoverFlowItem& MulCoverFlowEnhancedTemplate::EnhacedCounterPos()

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::EnhacedCounterPos");

    return mData->mEnhacedCounterPos;

    }

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

// EnhancedBorderImagePath

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

//

const UString& MulCoverFlowEnhancedTemplate::EnhancedBorderImagePath()

    {

    MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::EnhancedBorderImagePath");

    return mData->mEnhancedBorderImagePath; 

    }

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

// ParseNode

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

//

void MulCoverFlowEnhancedTemplate::ParseNode( DuiNode& aNode )

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::ParseNode");

    int nChildCount = aNode.childCount ();

	for (int index = 0; index < nChildCount; index++)

		{

		DuiNode& item = aNode.child (index);

        //parse the elements 

		if ( !item.type().compare(KElement) )

			{

		    if( !item.nodeId().compare(KEnhancedSize) )

				{

				ParseEnhancedTag( item );

				}

			else if( !item.nodeId().compare(KCounter) )

				{

				ParseCounterTag( item );	

				}

			}

		}

	}

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

// ParseEnhancedTag

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

//

void MulCoverFlowEnhancedTemplate::ParseEnhancedTag( DuiNode& aNode )

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::ParseEnhancedTag");

	int totalitems = aNode.childCount();

	for( int index = 0; index < totalitems; index++ )

		{

	     DuiNode& childItem = aNode.child(index);

		 if( !childItem.type().compare(KSize) )

		 	{

		 	// for enhanced mode xmls.

		 	ProcessSizeTag( childItem );

		 	} 

		 else

		 	{

			bool pathFound = GetStaticImagePath(childItem, mData->mEnhancedBorderImagePath);

			TPtrC8 src((TUint8*)mData->mEnhancedBorderImagePath.getUtf8());

			}

		}

	}

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

// ParseCounterTag

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

//

void MulCoverFlowEnhancedTemplate::ParseCounterTag( DuiNode& aNode )

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::ParseCounterTag");

	int totalItems = aNode.childCount();

	for( int index = 0; index < totalItems; index++ )

		{

	     DuiNode& childItem = aNode.child(index);

		 if( !childItem.type().compare(KSize) )

		 	{

		 	// for enhanced mode xmls.

		 	ProcessSizeTag( childItem );

		 	} 

		}

	}

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

// ProcessSizeTag

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

//   				

void MulCoverFlowEnhancedTemplate::ProcessSizeTag( DuiNode& aNode )

	{

	MUL_LOG_ENTRY_EXIT("aakash::MulCoverFlowEnhancedTemplate::ProcessSizeTag");

	int totalitems = aNode.childCount();

	auto_ptr<TMulCoverFlowItem> itemstruct = ProcessItemPos( aNode );

	if( !aNode.nodeId().compare(KMinSize) )

		{

		// Store the maximum and minimum sizes for enhanced mode.

		mData->mEnhancedMinSize = *itemstruct;

	 	}

 	else if( !aNode.nodeId().compare(KMaxSize) )

		{

		// Store the maximum and minimum sizes for enhanced mode.

	    mData->mEnhancedMaxSize = *itemstruct;

	 	}

	else if( !aNode.nodeId().compare(KCounterSize) )

		{

		// Store the position and sizes for the counter in enhanced mode.

	    mData->mEnhacedCounterPos = *itemstruct;

	 	}

 	//delete itemstruct;

	}

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

// GetStaticImagePath

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

//

bool MulCoverFlowEnhancedTemplate::GetStaticImagePath(DuiNode& aNode, UString& aPath)

	{

	 MUL_LOG_ENTRY_EXIT("aakash::MulXmlTemplate::GetStaticImagePath");

	int aAttrSetterCount = aNode.childCount ();

	for (int index = 0; index < aAttrSetterCount; index++)

	    {

	    DuiNode& attrSetterNode = aNode.child (index);

		const UString& aNodeType = attrSetterNode.type ();

		DuiXmlAttributeList& attSetterList = attrSetterNode.attributeList ();

		const UString& attrName = attSetterList.attributeValue (UString (attributesetter::KName));

		const UString& category = attSetterList.attributeValue (UString (KCategory));

	    if ( aNodeType == nodetypes::KAttributeSetter )

		    {

		    if ( attrName == duiuimodel::imagevisualattributes::KImagePath && category == attributesetter::typevalues::KStatic )

		    	{

		    	aPath = attSetterList.attributeValue(UString(attributesetter::KTargetValue));

		    	MulUtility::AbsolutePath(aPath);

		    	return true;

		    	}

		    }

	    }

	return false;

	}

	}//namespace Alf

// End of file.