/*

* 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"));

    }

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

//

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