/*

* 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:    bindings required to populate the visual item

*

*/

#include "glxbinding.h"                 // The binding is created by the binding set factory.

#include "glxmuliconprovider.h"         // Icon details 

#include <StringLoader.h>               // Class provides methods to load and format resource strings

#include <mul/mulvisualitem.h>          // Client need to use this class to add data in data model

#include <mul/imulwidget.h>

#include <glxthumbnailattributeinfo.h>  // Thumbnail attribute content ID

#include <mpxcollectionpath.h>          // Encapsulates a 'bookmark' to a specific collection entry

#include <glxlog.h>                     // Logging

#include <glxtracer.h>

#include "glxcommandbindingutility.h"   // collect binding handling here

#include "glxmulthumbnailvarianttype.h"

#include "mglxbindingobserver.h"        // Notifies that binding has changed

#include "glxustringconverter.h"        // converts the symbian types to UString type

#include "glxattributerequirement.h"    // class will set the required attribute to the medialist

#include "glxuiutility.h"

#include "glxdetailsboundcommand.h"     // Handles user commands

using namespace Alf;

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

// Sets the attribute to the visual item

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

//

static void SetAttributeT( Alf::MulVisualItem& aItem,  const Alf::mulvisualitem::TVisualAttribute& aTag/*const UString& aTag*/, 

        std::auto_ptr<MulVariantType> aValue )

    {

    TRACER("SetAttributeT");

    aItem.SetAttribute( aTag, aValue.get() );

    aValue.release();

    }

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

// Destructor

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

//

CGlxBinding::~CGlxBinding()

	{

	}

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

// Checks whether the attributes are relevant, returns EFalse always

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

//

TBool CGlxBinding::HasRelevantAttributes( 

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

	{

	TRACER("CGlxBinding::HasRelevantAttributes");

	return EFalse;

	}

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

// Notification whether any updation is required for the focus changed

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

//

CGlxBinding::TResponse CGlxBinding::HandleFocusChanged( TBool /*aIsGained*/ )

	{

	TRACER("CGlxBinding::HandleFocusChanged");

	return ENoUpdateNeeded;

	}

void  CGlxBinding::HandleItemChangedL(const CMPXCollectionPath& /*aPath*/ )

    {

    }

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

// Set the binding observer 

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

//

void CGlxBinding::SetObserver( MGlxBindingObserver& aObserver )

	{

	TRACER("CGlxBinding::SetObserver");

	iObserver = &aObserver;

	}

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

// Initiates the update process when the binding changed

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

//

void CGlxBinding::Update()

	{

	TRACER("CGlxBinding::Update");

	__ASSERT_DEBUG( iObserver, User::Invariant() );

	iObserver->HandleBindingChanged( *this ); 

	}

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

// AddRequestL

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

//

 void CGlxBinding::AddRequestL( CGlxAttributeRequirements&

    /*aAttributeRequirement*/, TSize /*aSize*/ )

    {

    }

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

// Template Binding

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

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

// Destructor

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

//

CGlxTemplateBinding::~CGlxTemplateBinding()  

    {

    }

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

// Two phase constructor

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

//

CGlxTemplateBinding* CGlxTemplateBinding::NewL(

    Alf::mulwidget::TLogicalTemplate aTemplate, 

	Alf::mulwidget::TLogicalTemplate aTemplateWhenFocused)

    {

    TRACER("CGlxTemplateBinding::NewL");

    CGlxTemplateBinding* self = CGlxTemplateBinding::NewLC( aTemplate, aTemplateWhenFocused );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two phase constructor

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

//

CGlxTemplateBinding* CGlxTemplateBinding::NewLC(

    Alf::mulwidget::TLogicalTemplate aTemplate, 

	Alf::mulwidget::TLogicalTemplate aTemplateWhenFocused)

    {

    TRACER("CGlxTemplateBinding::NewLC");

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

    CleanupStack::PushL( self );

    self->iTemplate = aTemplate;

    self->iFocusedTemplate = aTemplateWhenFocused;

    return self;

    }

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

// PopulateT

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

//

void CGlxTemplateBinding::PopulateT( Alf::MulVisualItem& aItem, 

    {

    TRACER("CGlxTemplateBinding::PopulateT");

    // need to get the MUL field for the editable template from Akash

    aItem.SetAttribute(  Alf::mulvisualitem::KAttributeTemplate , 

        ( aIsFocused && iFocusedTemplate ) ? iFocusedTemplate : iTemplate );

    }

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

// HandleFocusChanged

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

//            

CGlxBinding::TResponse CGlxTemplateBinding::HandleFocusChanged( TBool /*aIsGained*/ )

    {

    TRACER("CGlxTemplateBinding::HandleFocusChanged");

    //Need further implementation

    return iFocusedTemplate ? EUpdateRequested: ENoUpdateNeeded;

    }

void CGlxTemplateBinding::HandleItemChangedL(const CMPXCollectionPath& /*aPath*/ )

    {

    }

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

// Single Tag Binding

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

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

// Constructor

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

//

CGlxSingleTagBinding::CGlxSingleTagBinding()

	{

	}

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

// Destructor

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

//

CGlxSingleTagBinding::~CGlxSingleTagBinding()

    {

    TRACER("CGlxSingleTagBinding::~CGlxSingleTagBinding");

    }

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

// Two phase construction

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

//

void CGlxSingleTagBinding::BaseConstructL( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/ )

    {

    TRACER("CGlxSingleTagBinding::BaseConstructL");

    iMulTag = aMulTag ;

    }

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

// Returns the MUL field

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

//

Alf::mulvisualitem::TVisualAttribute CGlxSingleTagBinding::MulTag() const

    {

    TRACER("CGlxSingleTagBinding::MulTag");

    return iMulTag;

    }

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

// String Binding

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

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

// Two phase construction

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

//

CGlxStringBinding* CGlxStringBinding::NewL( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/,

        TInt aStringId )

	{

	TRACER("CGlxStringBinding::NewL");

	CGlxStringBinding* self = CGlxStringBinding::NewLC( aMulTag, aStringId );

	CleanupStack::Pop(self);

	return self;

	}

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

// Two phase construction

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

//

CGlxStringBinding* CGlxStringBinding::NewLC( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/,

        TInt aStringId  )

    {

    TRACER("CGlxStringBinding::NewLC");

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

    CleanupStack::PushL( self );

    self->ConstructL( aMulTag, aStringId );

    return self;

    }

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

// Two phase construction

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

//

CGlxStringBinding* CGlxStringBinding::NewL( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/,

        const char* const aString )

    {

    TRACER("CGlxStringBinding::NewL");

    CGlxStringBinding* self = CGlxStringBinding::NewLC( aMulTag, aString );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two phase construction

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

//

CGlxStringBinding* CGlxStringBinding::NewLC( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/,

        const char* const aString )

    {

    TRACER("CGlxStringBinding::NewLC");

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

    CleanupStack::PushL( self );

    self->ConstructL( aMulTag, aString );

    return self;

    }

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

// Constructor

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

//   

CGlxStringBinding::CGlxStringBinding()

    {

    }

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

// Destructor

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

//

CGlxStringBinding::~CGlxStringBinding()

    {

    TRACER("CGlxStringBinding::~CGlxStringBinding");

    delete iStringBuffer;

    }

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

//  Two phase construction

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

//    

void CGlxStringBinding::ConstructL( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/,

        TInt aStringId )

	{

	TRACER("CGlxStringBinding::ConstructL");

	BaseConstructL( aMulTag );

    iStringBuffer = StringLoader::LoadL( aStringId );

	}

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

// Two phase construction

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

//

void CGlxStringBinding::ConstructL( const Alf::mulvisualitem::TVisualAttribute& aMulTag/*const char* const aMulTag*/,

        const char* const /*aString*/ )

	{

	TRACER("CGlxStringBinding::ConstructL");

	BaseConstructL( aMulTag );

	}

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

// populate visual item

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

//

void CGlxStringBinding::PopulateT( MulVisualItem& aItem, const TGlxMedia& /*aMedia*/,

    {

    TRACER("CGlxStringBinding::PopulateT");

    aItem.SetAttribute( MulTag(), *iStringBuffer );

    }

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

// MPX attribute Binding

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

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

// Two phase construction

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

//

CGlxMpxAttributeBinding* CGlxMpxAttributeBinding::NewL( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const 

    aMulTag*/, const TMPXAttribute& aAttribute, TInt aFormatStringId )

    {

    TRACER("CGlxMpxAttributeBinding::NewL");

    CGlxMpxAttributeBinding* self = CGlxMpxAttributeBinding::NewLC

        ( aMulTag, aAttribute, aFormatStringId );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two phase construction

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

//

CGlxMpxAttributeBinding* CGlxMpxAttributeBinding::NewLC( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/,

        const TMPXAttribute& aAttribute, TInt aFormatStringId )

    {

    TRACER("CGlxMpxAttributeBinding::NewLC");

    CGlxMpxAttributeBinding* self = new ( ELeave ) CGlxMpxAttributeBinding( 

        aAttribute, aFormatStringId);

    CleanupStack::PushL( self );

    self->ConstructL( aMulTag );

    return self;

    }

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

// Two phase construction

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

//    

void CGlxMpxAttributeBinding::ConstructL(const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/ )

    {

    TRACER("CGlxMpxAttributeBinding::ConstructL");

    BaseConstructL( aMulTag );

    }

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

// Constructor

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

//

CGlxMpxAttributeBinding::CGlxMpxAttributeBinding( const TMPXAttribute&

     aAttribute, TInt aFormatStringId ) : iAttribute( aAttribute ),

     iFormatStringId( aFormatStringId )

    {

    }

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

// populate visual item

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

//

void CGlxMpxAttributeBinding::PopulateT( MulVisualItem& aItem/**/, const 

    {

    TRACER("CGlxMpxAttributeBinding::PopulateT");

    //T is used for throws as per C++ standard.Hence used instead of "L"

    //Ignoring this for code scanner warnings - Leaving functions called in non-leaving functions.

    CGlxUStringConverter* stringConverter = CGlxUStringConverter::NewL();

    CleanupStack::PushL(stringConverter );

    HBufC* string = NULL;

    stringConverter->AsStringL( aMedia, iAttribute, iFormatStringId, string );  

    if ( string )

        {

        aItem.SetAttribute( MulTag(), *string );

        delete string;

        string = NULL;

        }

    CleanupStack::PopAndDestroy(stringConverter );

    }

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

// checks whether the attributes are relevant, returns EFalse always

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

//

TBool CGlxMpxAttributeBinding::HasRelevantAttributes( 

        const RArray< TMPXAttribute >& aAttributes ) const

    {

    TRACER("CGlxMpxAttributeBinding::HasRelevantAttributes");

    // only the member attribute is relevant; check if it is in the list

    TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );

    return ( KErrNotFound != aAttributes.Find( iAttribute, match ) );

    }

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

// checks whether the focus has changed, returns the response status 

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

//	

CGlxBinding::TResponse CGlxMpxAttributeBinding::HandleFocusChanged( 

        TBool aIsGained )

    {

    TRACER("CGlxMpxAttributeBinding::HandleFocusChanged");

    //Need further implementation

    return aIsGained ? EUpdateRequested : ENoUpdateNeeded ;

    }

void CGlxMpxAttributeBinding::HandleItemChangedL(const CMPXCollectionPath& /*aPath*/ )

    {

    }

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

// sends the attribute that is to be set to the medialist

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

//

 void CGlxMpxAttributeBinding::AddRequestL( CGlxAttributeRequirements&  

    aAttributeRequirement,TSize /*aSize*/ )

    {

    TRACER("CGlxMpxAttributeBinding::AddRequestL");

    aAttributeRequirement.AddAttributeL(iAttribute);

    }

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

// Thumbnail Binding

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

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

// Two phase construction

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

//

CGlxThumbnailBinding* CGlxThumbnailBinding::NewL( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/, 

	const TSize& aSize )

    {

    TRACER("CGlxThumbnailBinding::NewL");

    CGlxThumbnailBinding* self = CGlxThumbnailBinding::NewLC( aMulTag, aSize );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two phase construction

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

//

CGlxThumbnailBinding* CGlxThumbnailBinding::NewLC( const Alf::mulvisualitem::TVisualAttribute& aMulTag /*const char* const aMulTag*/, 

	const TSize& aSize )

    {

    TRACER("CGlxThumbnailBinding::NewLC");

    CGlxThumbnailBinding* self = new ( ELeave ) CGlxThumbnailBinding( aSize );

    CleanupStack::PushL( self );

    self->BaseConstructL( aMulTag );

    return self;

    }

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

// Constructor

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

//

CGlxThumbnailBinding::CGlxThumbnailBinding( const TSize& aSize ) : 

    iThumbnailSize( aSize )

    {

    }

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

// Destructor

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

//

CGlxThumbnailBinding::~CGlxThumbnailBinding()

    {

    }

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

// populate visual item

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

//

void CGlxThumbnailBinding::PopulateT( MulVisualItem& aItem, const TGlxMedia& 

    {

    TRACER("CGlxThumbnailBinding::PopulateT");

    //T is used for throws as per C++ standard.Hence used instead of "L"

    //Ignoring this for code scanner warnings - Leaving functions called in non-leaving functions.

    SetAttributeT( aItem, MulTag(), 

        std::auto_ptr< GlxThumbnailVariantType >( 

            GlxThumbnailVariantType::NewL( aMedia, iThumbnailSize, 

        //@todo

    }

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

// checks whether the attributes are relevant, returns EFalse always

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