/*

* Copyright (c) 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:

*

*/

#include "mmtemplatelibrary.h"

#include "mmlctutils.h"

#include "mmwidgetsconstants.h"

#include <hnutils.h>

#include <gdi.h>

#include <hnconvutils.h>

#include "menudebug.h"

#include <hnglobals.h>

#include <AknUtils.h>

#include <AknDef.hrh>

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

//

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

//

TUint32 HBuf16Hash( HBufC8* const &  aBuf )

    {

    return DefaultHash::Des8(*aBuf);

    }

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

//

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

//

TBool HBuf16Ident( HBufC8* const & aL, HBufC8* const & aR )

    {

    return DefaultIdentity::Des8(*aL, *aR);

    }

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

//

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

//:

CMmTemplateLibrary::CMmTemplateLibrary()

	: iWidgetType(EWidgetTypeNone),

	iTemplateSizesMap( &HBuf16Hash, &HBuf16Ident ),

	iTemplateChildrenMap( &HBuf16Hash, &HBuf16Ident ),

	iMoveIndicatorRectsMap( &HBuf16Hash, &HBuf16Ident )

	{

	// No implementation required

	}

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

//

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

//

CMmTemplateLibrary::~CMmTemplateLibrary()

	{

	CleanAndClearCache();

	}

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

//

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

//

void CMmTemplateLibrary::CleanAndClearCache( )

    {

	THashMapIter<HBufC8*, TSize> iter( iTemplateSizesMap );

	while ( HBufC8* const * ptr = iter.NextKey() )

		{

		delete *ptr;

		}

	iTemplateSizesMap.Close();

	THashMapIter<HBufC8*, RArray<TTemplateChild> > iter2( iTemplateChildrenMap );

	while ( HBufC8* const * ptr = iter2.NextKey() )

		{

		iter2.CurrentValue()->Close();

		delete *ptr;

		}

	iTemplateChildrenMap.Close();

	THashMapIter<HBufC8*, TRect> iter4( iMoveIndicatorRectsMap );

	while ( HBufC8* const * ptr = iter4.NextKey() )

		{

		delete *ptr;

		}

	iMoveIndicatorRectsMap.Close();

    }

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

//

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

//

EXPORT_C CMmTemplateLibrary* CMmTemplateLibrary::NewL()

	{

	CMmTemplateLibrary* self = CMmTemplateLibrary::NewLC();

	CleanupStack::Pop( self );

	return self;

	}

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

//

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

//

EXPORT_C CMmTemplateLibrary* CMmTemplateLibrary::NewLC()

    {

    CMmTemplateLibrary* self = new( ELeave ) CMmTemplateLibrary();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

void CMmTemplateLibrary::ConstructL()

	{

	//No implementation needed.

	}

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

//

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

//

TSize CMmTemplateLibrary::GetSize(  TMmWidgetType aWidgetType, const TDesC8& aTemplate,

		TBool aLandscapeOrientation, TBool aHighlighted, TRect aParentRect )

	{

	TSize result;

	GetSize(result, aWidgetType, aTemplate, aLandscapeOrientation,

			aHighlighted, aParentRect );

	return result;

	}

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

//

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

//

TInt CMmTemplateLibrary::GetSize(  TSize& aItemSize,

        TMmWidgetType aWidgetType, const TDesC8& aTemplate,

        TBool aLandscapeOrientation, TBool aHighlighted, TRect aParentRect )

    {

    if ( KNullDesC8()== aTemplate || aParentRect == TRect(TPoint(0,0), TPoint(0,0))

    		|| !aTemplate.Compare( KEmpty8 ) )

        {

        return KErrNotFound;

        }

    UpdateParentRect( aParentRect, aLandscapeOrientation );

    TInt err( KErrNone );

    HBufC8* lookup_string = LookupText( aTemplate, aWidgetType,

        aLandscapeOrientation, aHighlighted );

    TSize* itemSize = iTemplateSizesMap.Find( lookup_string );

    if ( !itemSize )

        {

        TRAP( err, LoadTemplateL( aWidgetType, aTemplate, aLandscapeOrientation ) );

        if ( err == KErrNone )

            {

            itemSize = iTemplateSizesMap.Find( lookup_string );

        	if( !itemSize )

        		{

                User::Panic( KMtlPanic, KErrNotFound );

        		}

            aItemSize = *itemSize;

            }

        }

    else

        {

        iWidgetType = aWidgetType;

        TSize layoutSize;

        TInt err( KErrNone );

        TRAP( err, layoutSize = GetLayoutSizeL( iWidgetType, aTemplate,

                aLandscapeOrientation ) );

        if( err == KErrNone )

            {

            AdjustItemSize( *itemSize, layoutSize, aLandscapeOrientation );

            }

        aItemSize = *itemSize;

        }

	delete lookup_string;

    return err;

    }

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

//

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

//

TSize CMmTemplateLibrary::GetLayoutSizeL( TMmWidgetType aWidgetType, const TDesC8& aTemplate,

		TBool aLandscapeOrientation )

	{

	if ( KNullDesC8()== aTemplate )

		{

		User::Leave( -1 );

		}

	TSize* layoutSize = NULL;

	switch ( aWidgetType )

		{

		case EGrid:

			{

		    HBufC8* lookup_string = LookupLayoutText( aWidgetType,

                aTemplate, aLandscapeOrientation );

			CleanupStack::PushL( lookup_string );

		    layoutSize = iTemplateSizesMap.Find( lookup_string );

		    if (!layoutSize)

		        {

		        LoadTemplateL( aWidgetType, aTemplate, aLandscapeOrientation );

		        layoutSize = iTemplateSizesMap.Find( lookup_string );

		        if( !layoutSize )

		            User::Panic( KMtlPanic, -1);

		        }

			CleanupStack::PopAndDestroy( lookup_string );

			}

			break;

		case EListbox:

			return TSize( MmListBox::KCols,0 );

		default:

			User::Panic( KMtlPanic, -1);

		}

	return *layoutSize;

	}

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

//

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

//

TRect CMmTemplateLibrary::GetMoveIndicatorRect(TMmWidgetType aWidgetType,

		const TDesC8& aTemplate, TBool aLandscapeOrientation,

		TBool aHighlighted)

	{

	ASSERT( KNullDesC8() != aTemplate && aTemplate.Compare( KEmpty8 ) );

	HBufC8* lookup_string = LookupText(aTemplate, aWidgetType,

        aLandscapeOrientation, aHighlighted );

	HBufC8* lookup_indicator_string = LookupIndicatorText( *lookup_string );

	TRect* itemRect = iMoveIndicatorRectsMap.Find( lookup_indicator_string );

    if (!itemRect)

        {

    	TSize itemSize;

    	GetSize( itemSize, aWidgetType, aTemplate, aLandscapeOrientation, EFalse, GetParentRect( aLandscapeOrientation ) );

    	TRAPD( err, SetupMoveIndicatorTemplateChildrenL(

    	        *lookup_indicator_string, itemSize ) );

    	if ( KErrNone == err )

    	    {

            itemRect = iMoveIndicatorRectsMap.Find( lookup_indicator_string );

            if (!itemRect)

                {

                User::Panic( KMtlPanic, -1);

                }

    	    }

        }

    delete lookup_indicator_string;

    delete lookup_string;

    return *itemRect;

	}

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

//

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

//

void CMmTemplateLibrary::GetChildrenL(TMmWidgetType aWidgetType, RArray<

		TTemplateChild>& aArray, const TDesC8& aTemplate,

		TBool aLandscapeOrientation, TBool aHighlighted, TBool aIsEditMode)

	{

	ASSERT( KNullDesC8() != aTemplate && aTemplate.Compare( KEmpty8 ) );

	HBufC8* lookup_string = LookupText( aTemplate, aWidgetType,

        aLandscapeOrientation, aHighlighted );

	CleanupStack::PushL( lookup_string );

    RArray<TTemplateChild>* children = iTemplateChildrenMap.Find( lookup_string );

    if ( !children )

        {

        LoadTemplateL( aWidgetType, aTemplate, aLandscapeOrientation );

        children = iTemplateChildrenMap.Find( lookup_string );

        if (!children)

        	{

            User::Panic( KMtlPanic, -1);

        	}

        }

    CleanupStack::PopAndDestroy( lookup_string );

    for (TInt i = 0; i < children->Count(); i++)

    	aArray.AppendL((*children)[i]);

    if ( aIsEditMode )

    	{

    	TSize size = GetSize( aWidgetType, aTemplate, aLandscapeOrientation, aHighlighted, GetParentRect(aLandscapeOrientation) );

        AppendEditModeTemplateL( aArray, size );

    	}

	}

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

//

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

//

void CMmTemplateLibrary::GetMoveIndicatorChildrenL(TMmWidgetType aWidgetType,

		RArray<TTemplateChild>& aArray, const TDesC8& aTemplate,

		TBool aLandscapeOrientation, TBool aHighlighted)

	{

	ASSERT( KNullDesC8() != aTemplate && aTemplate.Compare( KEmpty8 ) );

	HBufC8* lookup_string = LookupText(aTemplate, aWidgetType,

        aLandscapeOrientation, aHighlighted );

	CleanupStack::PushL( lookup_string );

	HBufC8* lookup_indicator_string = LookupIndicatorText( *lookup_string );

	CleanupStack::PushL( lookup_indicator_string );

    RArray<TTemplateChild>* children = iTemplateChildrenMap.Find( lookup_indicator_string );

    if ( !children )

    	{

    	TSize itemSize;

    	GetSize( itemSize, aWidgetType, aTemplate, aLandscapeOrientation, EFalse, GetParentRect( aLandscapeOrientation ) );

        SetupMoveIndicatorTemplateChildrenL( *lookup_indicator_string, itemSize );

        children = iTemplateChildrenMap.Find( lookup_indicator_string );

        if (!children)

        	User::Panic( KMtlPanic, -1);

    	}

    CleanupStack::PopAndDestroy( lookup_indicator_string );

	CleanupStack::PopAndDestroy( lookup_string );

    for (TInt i = 0; i < children->Count(); i++)

    	{

    	aArray.AppendL((*children)[i]);

    	}

	}

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

//

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

//

HBufC8* CMmTemplateLibrary::LookupText( const TDesC8& aTemplate,

    TMmWidgetType aWidgetType, TBool aLandscapeOrientation, TBool aHighlighted )

    {

    HBufC8* lookup_string = HBufC8::New( MmTemplateContants::KTemplateChildTextLength );

    if (lookup_string)

    	{

		TPtr8 lookup_string_ptr( lookup_string->Des() );

		lookup_string_ptr.Append( aTemplate );

		lookup_string_ptr.Append( KColon8 );

		switch ( aWidgetType )

			{

			case EListbox:

				lookup_string_ptr.Append( KListbox8 );

				break;

			case EGrid:

				lookup_string_ptr.Append( KGrid8 );

				break;

			}

		lookup_string_ptr.Append( KColon8 );

		lookup_string_ptr.AppendNum( aLandscapeOrientation );

		lookup_string_ptr.Append( KColon8 );

		lookup_string_ptr.AppendNum( aHighlighted );

		lookup_string_ptr.Append( KColon8 );

    	}

    return lookup_string;

    }

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

//

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

//

HBufC8* CMmTemplateLibrary::LookupLayoutText( TMmWidgetType aWidgetType,

        const TDesC8& aTemplate, TBool aLandscapeOrientation )

	{

    HBufC8* lookup_string = HBufC8::New( MmTemplateContants::KTemplateChildTextLength );

    if (lookup_string)

    	{

		TPtr8 lookup_string_ptr( lookup_string->Des() );

		switch ( aWidgetType )

			{

			case EListbox:

				lookup_string_ptr.Append( KListbox8 );

				break;

			case EGrid:

				lookup_string_ptr.Append( KGrid8 );

				break;

			}

		lookup_string_ptr.Append( KColon8 );

        lookup_string_ptr.Append( KColon8 );

		lookup_string_ptr.Append( aTemplate );

		lookup_string_ptr.Append( KColon8 );

		lookup_string_ptr.AppendNum( aLandscapeOrientation );

    	}

    return lookup_string;

	}

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

//

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

//

HBufC8* CMmTemplateLibrary::LookupIndicatorText( const TDesC8& aLookupText )

	{

	HBufC8* lookup_string = HBufC8::New( MmTemplateContants::KTemplateChildTextLength );

	if (lookup_string)

		{

		TPtr8 lookup_string_ptr( lookup_string->Des() );

		lookup_string_ptr.Append( KMI8 );

		lookup_string_ptr.Append( KColon8 );

		lookup_string_ptr.Append( aLookupText );

		}

	return lookup_string;

	}

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

//

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

//

void CMmTemplateLibrary::LoadTemplateL( TMmWidgetType aWidgetType,

		const TDesC8& aTemplate, TBool aLandscapeOrientation )

	{

	iWidgetType = aWidgetType;

	DEBUG(("_Mm_:CMmTemplateLibrary::LoadTemplateL IN"));

	TMmTemplateType mmTemplateType;

	HBufC8* content = GetTemplateContentL( aTemplate, aWidgetType, mmTemplateType );

	CleanupStack::PushL( content );

    RXmlEngDOMImplementation domImpl;

    CleanupClosePushL( domImpl );

    RXmlEngDOMParser domParser;

    CleanupClosePushL( domParser );

    DEBUG(("_Mm_:CMmTemplateLibrary::LoadTemplateL Opening domImpl"));

    domImpl.OpenL();

    User::LeaveIfError( domParser.Open( domImpl ) );

    DEBUG(("_Mm_:CMmTemplateLibrary::LoadTemplateL parsing content..."));

    RXmlEngDocument xmlDoc = domParser.ParseL( *content );

    CleanupClosePushL( xmlDoc );

    // first orientation

    RXmlEngNodeList<TXmlEngElement> orientElements;

    CleanupClosePushL( orientElements );

    xmlDoc.DocumentElement().GetChildElements( orientElements );

    TXmlEngElement orientationElement;

    while ( orientElements.HasNext() )

        {

        orientationElement = orientElements.Next();

        DEBUG(("_Mm_:CMmTemplateLibrary::LoadTemplateL Reading orientation"));

        TPtrC8 name = orientationElement.Name();

        DEBUG8(("\t_Mm_:orientation: %S", &name));

        if ( !name.Compare( KOrientation8 ) )

            {

            TBool landscapeOrientation(EFalse);

            if (orientationElement.AttributeValueL(KId8) == KLandscape8)

                landscapeOrientation = ETrue;

            if ( landscapeOrientation != aLandscapeOrientation )

            	{

            	continue;

            	}

            RXmlEngNodeList<TXmlEngElement> elements;

            orientationElement.GetChildElements( elements );

            CleanupClosePushL( elements );

            TXmlEngElement element;

            while ( elements.HasNext() )

                {

                element = elements.Next();

            	DEBUG(("_Mm_:iMmTemplateType != EMmTemplateMoveIndicator"));

            	if (element.AttributeValueL(KId8) == KHighlight8)

                    {

                    DEBUG(("_Mm_:AttributeValueL - id == highlight"));

                    ProcessElementL( mmTemplateType, element, aTemplate, landscapeOrientation, ETrue );

                    DEBUG(("ProcesElementL END"));

                    }

                else if (element.AttributeValueL(KId8) == KNoHighlight8)

                    {

                    DEBUG(("_Mm_:AttributeValueL - id == nohighlight"));

                    ProcessElementL( mmTemplateType, element, aTemplate, landscapeOrientation, EFalse );

                    DEBUG(("ProcesElementL END"));

                    if ( aWidgetType == EGrid )

                        {

                        DEBUG(("_Mm_:aWidgetType == EGrid"));

                        ProcessElementL( mmTemplateType, element, aTemplate, landscapeOrientation, ETrue );

                        DEBUG(("ProcesElementL END"));

                        }

                    }

                }

            CleanupStack::PopAndDestroy( &elements );

            }

        }

    CleanupStack::PopAndDestroy( &orientElements );

    CleanupStack::PopAndDestroy( &xmlDoc );

    CleanupStack::PopAndDestroy( &domParser );

    CleanupStack::PopAndDestroy( &domImpl );

    CleanupStack::PopAndDestroy(content);

    DEBUG(("_Mm_:CMmTemplateLibrary::LoadTemplateL OUT"));

    }

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

//

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

//

void CMmTemplateLibrary::ProcessElementL(TMmTemplateType aMmTemplateType,

										 TXmlEngElement aElement,

                                         const TDesC8& aTemplate,

                                         TBool aLandscapeOrientation,

                                         TBool aHighlighted )

    {

    switch ( aMmTemplateType )

	    {

	    case ETemplateTypeLCT:

	    	ProcessLCTTemplateElementL(aElement, aTemplate, aLandscapeOrientation, aHighlighted );

	    	break;

	    case ETemplateTypeCustom:

	    	ProcessCustomTemplateElementL(aElement, aTemplate, aLandscapeOrientation, aHighlighted );

	    	break;