/*

* 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:    Implementation of Command Binding Class's

*

*/

#include    <e32base.h>                                 // Base class for all classes to be instantiated on the heap

#include    <ExifModify.h>                              //For CExifModify

#include    "glxdetailsboundcommand.hrh"

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

#include    <glxmetadatadialog.rsg>

#include    <glxuiutilities.rsg>

#include    <glxuiutilities.rsg>

#include    <glxcommandhandleraddtocontainer.h>	        // For CGlxCommandHandlerAddToContainer

#include    <glxcommandhandlers.hrh> 			        // for command handler id

#include    <glxdrmutility.h>	                        //For launching DRM details pane

#include    <glxmedialist.h>                            // Interface for reading lists of media items

#include    <glxcommandfactory.h>			            //for command factory

#include    <mpxcommandgeneraldefs.h>                   // Content ID identifying general category of content provided

#include    <glxtextentrypopup.h>                       //for testing

#include    <glxgeneraluiutilities.h>                   // General utilties class definition

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

#include    <glxlog.h>                                  // Logging

#include    <glxtracer.h>

#include    <glxviewbase.rsg>

#include    "glxuiutility.h"

#include <glxscreenfurniture.h>

/** Error Id EMPY-7MKDHP **/ 

#include 	"mglxmetadatadialogobserver.h" 				//for call back to dailog

//CONSTANTS

const TInt KMaxMediaPopupTitleLength = 0x100;

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

// CGlxTitleBoundCommand::NewL

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

//

EXPORT_C CGlxTitleBoundCommand* CGlxTitleBoundCommand::NewL()

	{

	TRACER("CGlxTitleBoundCommand::NewL");

	CGlxTitleBoundCommand* self = CGlxTitleBoundCommand::NewLC();

	CleanupStack::Pop( self );

	return self;

	}

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

// CGlxTitleBoundCommand::NewLC

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

//

CGlxTitleBoundCommand* CGlxTitleBoundCommand::NewLC()

	{

	TRACER("CGlxTitleBoundCommand::NewLC");

	CGlxTitleBoundCommand* self = new ( ELeave ) CGlxTitleBoundCommand;

	CleanupStack::PushL( self );

	return self;

	}

CGlxTitleBoundCommand::~CGlxTitleBoundCommand()

    {

    }

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

// CGlxTitleBoundCommand::OfferCommandL

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

//

TBool CGlxTitleBoundCommand::OfferCommandL( TInt aCommandId , MGlxMediaList& aMedialist )

	{

	TRACER("CGlxTitleBoundCommand::OfferCommandL");

	TBool consumed = EFalse;

	iMedialist = &aMedialist;

	const CGlxMedia* media = iMedialist->Item(0).Properties();

	if( media )

	    {

	    if ( aCommandId == KGlxEditBoundMenuCommandId  && media->IsSupported( KMPXMediaGeneralTitle))

	        {

	        ///@todo - remove popup when editable template is avaliable

	        //Popup for testing

	        HBufC* textBuf = HBufC::NewLC( KMaxMediaPopupTitleLength );

	        (textBuf->Des()).Copy((media->ValueText(KMPXMediaGeneralTitle)));

	        TPtr textPtr = textBuf->Des();

	        /// bug fix - EMPY-7MCKD6 

	        TBuf<KMaxMediaPopupTitleLength> titleText(*textBuf);

	        /// bug fix - EMPY-7MCKD6

	        ///@todo - remove literal for popup title when resource string is avaliable

			HBufC *buf = StringLoader::LoadLC(R_GLX_METADATA_VIEW_TITLE_NSERIES);

	        CGlxTextEntryPopup* popup = CGlxTextEntryPopup::NewL( *buf, textPtr );

			CleanupStack::PopAndDestroy(buf);

            if ( popup->ExecuteLD() == EEikBidOk )

                {

                // Text entry was successful

                /// bug fix - EMPY-7MCKD6

                //Compare if there is any change in the entry

                if(0 != (titleText.Compare(*textBuf)))

                /// bug fix - EMPY-7MCKD6

                 ModifyTitleL( *textBuf );

                }

	        CleanupStack::PopAndDestroy( textBuf ); 

	        consumed = ETrue;

	        }

	    }

	return consumed;

	}

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

// CGlxTitleBoundCommand::InitMenuL

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

//

void CGlxTitleBoundCommand::InitMenuL( CEikMenuPane& aMenu ) const

	{

	TRACER("CGlxTitleBoundCommand::InitMenuL");

	aMenu.SetItemTextL( KGlxEditBoundMenuCommandId, R_GLX_METADATA_VIEW_OPTIONS_EDIT );

	aMenu.SetItemDimmed( KGlxEditBoundMenuCommandId, EFalse );

	}

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

// CGlxTitleBoundCommand::HideLocationMenuItem

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

//

void CGlxTitleBoundCommand::HideLocationMenuItem( CEikMenuPane& aMenu ) const

    {

    TRACER("CGlxTitleBoundCommand::HideLocationMenuItem");

    aMenu.SetItemDimmed( EGlxCmdAiwBase, ETrue );

    }

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

// CGlxDescriptionBoundCommand::ModifyTitleL

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

//  

void CGlxTitleBoundCommand::ModifyTitleL(const TDesC& aData )

    {    

    TRACER("CGlxTitleBoundCommand::ModifyTitleL");

    if( iMedialist->Count() > 0 )

        {

        iMedialist->SetFocusL(NGlxListDefs::EAbsolute,0);//set focus to first item

        CMPXCollectionPath* path = iMedialist->PathLC();

        CMPXCommand* command = TGlxCommandFactory::RenameCommandLC(aData,*path);

        command->SetTObjectValueL<TAny*>(KMPXCommandGeneralSessionId, static_cast<TAny*>(this));

        iMedialist->CommandL(*command);

        CleanupStack::PopAndDestroy(command);

        CleanupStack::PopAndDestroy(path);

        }

    }

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

// CGlxTitleBoundCommand::Close

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

//

void CGlxTitleBoundCommand::Close()

    {

    delete this;

    }

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

// CGlxTitleBoundCommand::ChangeMskL

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

//

void CGlxTitleBoundCommand::ChangeMskL()

    {

    TRACER("CGlxTitleBoundCommand::ChangeMskL");

    CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

    uiUtility->ScreenFurniture()->ModifySoftkeyIdL(CEikButtonGroupContainer::EMiddleSoftkeyPosition,

            EAknSoftkeySelect,R_GLX_METADATA_MSK_EDIT);

    if ( uiUtility )

        {

        uiUtility->Close();

        }

    }

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

// CGlxTitleBoundCommand::SetDetailsDailogObserver

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

//

void CGlxTitleBoundCommand::SetDetailsDailogObserver( MGlxMetadataDialogObserver& /*aObserver*/ )

	{

	}

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

// CGlxTagsBoundCommand::NewL

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

//

EXPORT_C CGlxTagsBoundCommand* CGlxTagsBoundCommand::NewL()

	{

	TRACER("CGlxTagsBoundCommand::NewL");

	CGlxTagsBoundCommand* self = CGlxTagsBoundCommand::NewLC();

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CGlxTagsBoundCommand::NewLC

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

//

CGlxTagsBoundCommand* CGlxTagsBoundCommand::NewLC()

	{

	TRACER("CGlxTagsBoundCommand::NewLC");

	CGlxTagsBoundCommand* self = new ( ELeave ) CGlxTagsBoundCommand;

	CleanupStack::PushL( self );

	return self;

	}

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

// CGlxTagsBoundCommand::ConstructL

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

//

void CGlxTagsBoundCommand::ConstructL()

	{

	TRACER("CGlxTagsBoundCommand::ConstructL");

	//create command handler

	}

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

// CGlxTagsBoundCommand::~CGlxTagsBoundCommand

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

//

CGlxTagsBoundCommand::~CGlxTagsBoundCommand()

    {

    if(iAddToTag)

        {

        delete iAddToTag;

        }

    }

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

// CGlxTagsBoundCommand::OfferCommandL

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

//

TBool CGlxTagsBoundCommand::OfferCommandL( TInt aCommandId , MGlxMediaList& aMedialist)

	{

	TRACER("CGlxTagsBoundCommand::OfferCommandL");

	SetMediaList(&aMedialist);

	TBool consumed = EFalse;

	if ( aCommandId == KGlxEditBoundMenuCommandId )

		{

		iAddToTag->ExecuteL(EGlxCmdAddTag);

		consumed = ETrue;

		}

	return consumed;

	}

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

// CGlxTagsBoundCommand::InitMenuL

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

//

void CGlxTagsBoundCommand::InitMenuL( CEikMenuPane& aMenu ) const

	{

	TRACER("CGlxTagsBoundCommand::InitMenuL");

	aMenu.SetItemTextL( KGlxEditBoundMenuCommandId, R_GLX_METADATA_VIEW_OPTIONS_EDIT ); 

	aMenu.SetItemDimmed( KGlxEditBoundMenuCommandId, EFalse );

	}

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

// CGlxTagsBoundCommand::HideLocationMenuItem

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

//

void CGlxTagsBoundCommand::HideLocationMenuItem( CEikMenuPane& aMenu ) const

    {

    TRACER("CGlxTagsBoundCommand::HideLocationMenuItem");

    aMenu.SetItemDimmed( EGlxCmdAiwBase, ETrue );

    }

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

// CGlxTagsBoundCommand::Close

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

//

void CGlxTagsBoundCommand::Close()

    {

    delete this;

    }

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

// CGlxTagsBoundCommand::ChangeMskL

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

//

void CGlxTagsBoundCommand::ChangeMskL()

    {

    TRACER("CGlxTagsBoundCommand::ChangeMskL");

    CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

    uiUtility->ScreenFurniture()->ModifySoftkeyIdL(CEikButtonGroupContainer::EMiddleSoftkeyPosition,

                EAknSoftkeySelect,R_GLX_METADATA_MSK_ADD);

    if ( uiUtility )

        {

        uiUtility->Close();

        }

    }

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

// CGlxTagsBoundCommand::SetDetailsDailogObserver

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

//

void CGlxTagsBoundCommand::SetDetailsDailogObserver( MGlxMetadataDialogObserver& /*aObserver*/ )

	{

	}

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

// CGlxTagsBoundCommand::SetMediaList

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

//

void CGlxTagsBoundCommand::SetMediaList(MGlxMediaList* aMedialist)

	{

	TRACER("CGlxTagsBoundCommand::SetMediaList");

	iMedialist = aMedialist;

	}

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

// CGlxTagsBoundCommand::MediaList

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

//

 MGlxMediaList& CGlxTagsBoundCommand::MediaList()

	 {

	 TRACER("CGlxTagsBoundCommand::MediaList");

	 return *iMedialist;

	 }

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

// CGlxDescriptionBoundCommand::NewL

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

//

EXPORT_C CGlxDescriptionBoundCommand* CGlxDescriptionBoundCommand::NewL()

	{

	TRACER("CGlxDescriptionBoundCommand::NewL");

	CGlxDescriptionBoundCommand* self = CGlxDescriptionBoundCommand::NewLC();

	CleanupStack::Pop( self );

	return self;

	}

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

// CGlxDescriptionBoundCommand::NewLC

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

//

CGlxDescriptionBoundCommand* CGlxDescriptionBoundCommand::NewLC()

	{

	TRACER("CGlxDescriptionBoundCommand::NewLC");

	CGlxDescriptionBoundCommand* self = new ( ELeave ) CGlxDescriptionBoundCommand;

	CleanupStack::PushL( self );

	return self;

	}

CGlxDescriptionBoundCommand::~CGlxDescriptionBoundCommand()

    {

    }

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

// CGlxDescriptionBoundCommand::OfferCommandL

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

//

TBool CGlxDescriptionBoundCommand::OfferCommandL( TInt aCommandId , MGlxMediaList& aMedialist )

	{

	TRACER("CGlxDescriptionBoundCommand::OfferCommandL");

	TBool consumed = EFalse;

	iMedialist = &aMedialist;

	const CGlxMedia* media = iMedialist->Item(0).Properties();

	if ( aCommandId == KGlxEditBoundMenuCommandId )

		{

		///@todo - remove popup when editable template is avaliable

		//Popup for testing

		HBufC* textBuf = HBufC::NewLC( KMaxMediaPopupTitleLength );

		(textBuf->Des()).Copy((media->ValueText(KMPXMediaGeneralComment)));

		TPtr textPtr = textBuf->Des();

		/// bug fix - EMPY-7MCKD6

		TBuf<KMaxMediaPopupTitleLength> descText(*textBuf);

		/// bug fix - EMPY-7MCKD6

		///@todo - remove literal for popup title when resource string is avaliable

		HBufC *buf = StringLoader::LoadLC(R_GLX_METADATA_VIEW_DESCRIPTION_NSERIES);

	    CGlxTextEntryPopup* popup = CGlxTextEntryPopup::NewL( *buf, textPtr );

		CleanupStack::PopAndDestroy(buf);

	    if ( popup->ExecuteLD() == EEikBidOk )

    		{

    		// Text entry was successful

    		/// bug fix - EMPY-7MCKD6

    		//Compare if there is any change in the entry

    		if(0 != (descText.Compare(*textBuf)))

    		/// bug fix - EMPY-7MCKD6

    		ModifyDescriptionL( *textBuf );

    	    }

		CleanupStack::PopAndDestroy( textBuf );

		consumed = ETrue;

		}

	return consumed;

	}

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

// CGlxDescriptionBoundCommand::InitMenuL

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

//

void CGlxDescriptionBoundCommand::InitMenuL( CEikMenuPane& aMenu ) const

	{

	TRACER("CGlxDescriptionBoundCommand::InitMenuL");

	aMenu.SetItemTextL( KGlxEditBoundMenuCommandId, R_GLX_METADATA_VIEW_OPTIONS_EDIT ); 

	aMenu.SetItemDimmed( KGlxEditBoundMenuCommandId, EFalse );

	}

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

// CGlxDescriptionBoundCommand::HideLocationMenuItem

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

//

void CGlxDescriptionBoundCommand::HideLocationMenuItem( CEikMenuPane& aMenu ) const

    {

    TRACER("CGlxDescriptionBoundCommand::HideLocationMenuItem");

    aMenu.SetItemDimmed( EGlxCmdAiwBase, ETrue );

    }

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

// CGlxDescriptionBoundCommand::Close

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

//

void CGlxDescriptionBoundCommand::Close()

    {

    delete this;

    }

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

// CGlxDescriptionBoundCommand::ChangeMskL

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

//

void CGlxDescriptionBoundCommand::ChangeMskL()

    {

    TRACER("CGlxDescriptionBoundCommand::ChangeMskL");

    CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

    uiUtility->ScreenFurniture()->ModifySoftkeyIdL(CEikButtonGroupContainer::EMiddleSoftkeyPosition,

            EAknSoftkeySelect,R_GLX_METADATA_MSK_EDIT);

    if ( uiUtility )

        {

        uiUtility->Close();

        }

    }

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

// CGlxDescriptionBoundCommand::SetDetailsDailogObserver

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

//

void CGlxDescriptionBoundCommand::SetDetailsDailogObserver( MGlxMetadataDialogObserver& /*aObserver*/ )

	{

	}

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

// CGlxDescriptionBoundCommand::ModifyDescriptionL

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

//	

void CGlxDescriptionBoundCommand::ModifyDescriptionL(const TDesC& aData )

	{	 

	TRACER("CGlxDescriptionBoundCommand::ModifyDescriptionL");

	if( iMedialist->Count() > 0 )

        { 

        iMedialist->SetFocusL(NGlxListDefs::EAbsolute,0);//set focus to first item

    	CMPXCollectionPath* path =  iMedialist->PathLC();

    	CMPXCommand* command = TGlxCommandFactory::SetDescriptionCommandLC(aData,*path);

    	command->SetTObjectValueL<TAny*>(KMPXCommandGeneralSessionId, static_cast<TAny*>(this));

    	iMedialist->CommandL(*command);

     	CleanupStack::PopAndDestroy(command);

        CleanupStack::PopAndDestroy(path);

        }

	}

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

// CGlxLocationBoundCommand::NewL

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

//

EXPORT_C CGlxLocationBoundCommand* CGlxLocationBoundCommand::NewL()

	{

	TRACER("CGlxLocationBoundCommand::NewL");

	CGlxLocationBoundCommand* self = CGlxLocationBoundCommand::NewLC();

	CleanupStack::Pop( self );

	return self;

	}

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

// CGlxLocationBoundCommand::NewLC

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

//

CGlxLocationBoundCommand* CGlxLocationBoundCommand::NewLC()

	{

	TRACER("CGlxLocationBoundCommand::NewLC");

	CGlxLocationBoundCommand* self = new ( ELeave ) CGlxLocationBoundCommand;

	CleanupStack::PushL( self );

	return self;

	}

CGlxLocationBoundCommand::~CGlxLocationBoundCommand()

    {

    iDialogObserver = NULL ;

    }

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

// CGlxLocationBoundCommand::OfferCommandL

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

//

TBool CGlxLocationBoundCommand::OfferCommandL( TInt aCommandId , MGlxMediaList& aMedialist )