/*

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

*

*/

#include "T_DataWindowTreeNode.h"

//Parameters

_LIT(KObjectName,							"objectName");

_LIT(KExpected,								"expected");

_LIT(KInputWindowPosition,					"inputWindowPosition");

_LIT(KInputWindowPriority,					"inputWindowPriority");

_LIT(KInputCursorNumber,					"inputCursorNumber");

_LIT(KInputEventControl,					"inputEventControl");

_LIT(KInputEventModifier,					"inputEventModifier");

_LIT(KInputNonFading,						"inputNonFading");

_LIT(KInputFaded,							"inputFaded");

_LIT(KInputFadeControl,						"inputFadeControl");

_LIT(KInputBlackMap,						"inputBlackMap");

_LIT(KInputWhiteMap,						"inputWhiteMap");

_LIT(KFldPointerCursor,                     "pointerCursor");

//Commands

_LIT(KCmdClose,                         	"Close");

_LIT(KCmdDestroy,                       	"Destroy");

_LIT(KCmdParent,                        	"Parent");

_LIT(KCmdPrevSibling,                   	"PrevSibling");

_LIT(KCmdNextSibling,                   	"NextSibling");

_LIT(KCmdChild,                         	"Child");

_LIT(KCmdOrdinalPriority,               	"OrdinalPriority");

_LIT(KCmdOrdinalPosition,               	"OrdinalPosition");

_LIT(KCmdFullOrdinalPosition,           	"FullOrdinalPosition");

_LIT(KCmdSetOrdinalPosition,            	"SetOrdinalPosition");

_LIT(KCmdWindowGroupId,                 	"WindowGroupId");

_LIT(KCmdSetPointerCursor,              	"SetPointerCursor");

_LIT(KCmdSetCustomPointerCursor,        	"SetCustomPointerCursor");

_LIT(KCmdEnableOnEvents,                	"EnableOnEvents");

_LIT(KCmdDisableOnEvents,               	"DisableOnEvents");

_LIT(KCmdEnableGroupChangeEvents,       	"EnableGroupChangeEvents");

_LIT(KCmdDisableGroupChangeEvents,      	"DisableGroupChangeEvents");

_LIT(KCmdEnableFocusChangeEvents,       	"EnableFocusChangeEvents");

_LIT(KCmdDisableFocusChangeEvents,      	"DisableFocusChangeEvents");

_LIT(KCmdEnableGroupListChangeEvents,   	"EnableGroupListChangeEvents");

_LIT(KCmdDisableGroupListChangeEvents,  	"DisableGroupListChangeEvents");

_LIT(KCmdEnableVisibilityChangeEvents,  	"EnableVisibilityChangeEvents");

_LIT(KCmdDisableVisibilityChangeEvents, 	"DisableVisibilityChangeEvents");

_LIT(KCmdEnableErrorMessages,           	"EnableErrorMessages");

_LIT(KCmdDisableErrorMessages,          	"DisableErrorMessages");

_LIT(KCmdEnableModifierChangedEvents,   	"EnableModifierChangedEvents");

_LIT(KCmdDisableModifierChangedEvents,  	"DisableModifierChangedEvents");

_LIT(KCmdSetNonFading,                  	"SetNonFading");

_LIT(KCmdSetFaded,                      	"SetFaded");

_LIT(KCmdClearPointerCursor,            	"ClearPointerCursor");

/*@}*/

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CT_DataWindowTreeNode::CT_DataWindowTreeNode()

:    CDataWrapperBase()

	{

	}

MWsClientClass* CT_DataWindowTreeNode::GetClientClass() const

	{

	return GetWindowTreeNode();

	}

/**

* Process a command read from the ini file

*

* @param aCommand			the command to process

* @param aSection			the entry in the ini file requiring the command to be processed

* @param aAsyncErrorIndex	index of command. used for async calls

*

* @return ETrue if the command is processed

*/

TBool CT_DataWindowTreeNode::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

	{

	TBool    ret = ETrue;

	if ( aCommand==KCmdClose )

		{

		DoCmdClose();

		}

	else if ( aCommand==KCmdDestroy )

		{

		DoCmdDestroyL();

		}

	else if ( aCommand==KCmdParent )

		{

		DoCmdParent(aSection);

		}

	else if ( aCommand==KCmdPrevSibling )

		{

		DoCmdPrevSibling(aSection);

		}

	else if ( aCommand==KCmdNextSibling )

		{

		DoCmdNextSibling(aSection);

		}

	else if ( aCommand==KCmdChild )

		{

		DoCmdChild(aSection);

		}

	else if ( aCommand==KCmdOrdinalPriority )

		{

		DoCmdOrdinalPriority(aSection);

		}

	else if ( aCommand==KCmdOrdinalPosition )

		{

		DoCmdOrdinalPosition(aSection);

		}

	else if ( aCommand==KCmdFullOrdinalPosition )

		{

		DoCmdFullOrdinalPosition(aSection);

		}

	else if ( aCommand==KCmdSetOrdinalPosition )

		{

		DoCmdSetOrdinalPosition(aSection);

		}

	else if ( aCommand==KCmdWindowGroupId )

		{

		DoCmdWindowGroupId();

		}

	else if ( aCommand==KCmdSetPointerCursor )

		{

		DoCmdSetPointerCursor(aSection);

		}

	else if (	aCommand==KCmdSetCustomPointerCursor )

		{

		DoCmdSetCustomPointerCursorL(aSection);

		}

	else if ( aCommand==KCmdEnableOnEvents )

		{

		DoCmdEnableOnEvents(aSection);

		}

	else if ( aCommand==KCmdDisableOnEvents )

		{

		DoCmdDisableOnEvents();

		}

	else if ( aCommand==KCmdEnableGroupChangeEvents )

		{

		DoCmdEnableGroupChangeEvents();

		}

	else if ( aCommand==KCmdDisableGroupChangeEvents )

		{

		DoCmdDisableGroupChangeEvents();

		}

	else if ( aCommand==KCmdEnableFocusChangeEvents )

		{

		DoCmdEnableFocusChangeEvents();

		}

	else if ( aCommand==KCmdDisableFocusChangeEvents )

		{

		DoCmdDisableFocusChangeEvents();

		}

	else if ( aCommand==KCmdEnableGroupListChangeEvents )

		{

		DoCmdEnableGroupListChangeEvents();

		}

	else if ( aCommand==KCmdDisableGroupListChangeEvents )

		{

		DoCmdDisableGroupListChangeEvents();

		}

	else if ( aCommand==KCmdEnableVisibilityChangeEvents )

		{

		DoCmdEnableVisibilityChangeEvents();

		}

	else if ( aCommand==KCmdDisableVisibilityChangeEvents )

		{

		DoCmdDisableVisibilityChangeEvents();

		}

	else if	( aCommand==KCmdEnableErrorMessages	)

		{

		DoCmdEnableErrorMessages(aSection);

		}

	else if ( aCommand==KCmdDisableErrorMessages )

		{

		DoCmdDisableErrorMessages();

		}

	else if ( aCommand==KCmdEnableModifierChangedEvents )

		{

		DoCmdEnableModifierChangedEvents(aSection);

		}

	else if ( aCommand==KCmdDisableModifierChangedEvents )

		{

		DoCmdDisableModifierChangedEvents();

		}

	else if ( aCommand==KCmdSetNonFading )

		{

		DoCmdSetNonFading(aSection);

		}

	else if ( aCommand==KCmdSetFaded )

		{

		DoCmdSetFaded(aSection);

		}

	else if ( aCommand==KCmdClearPointerCursor )

		{

		DoCmdClearPointerCursor();

		}

	else

		{

		ret=CT_DataWsClientClass::DoCommandL(*this, aCommand, aSection, aAsyncErrorIndex);

		}

	return ret;

	}

void CT_DataWindowTreeNode::DoCmdClose()

	{

	GetWindowTreeNode()->Close();

	INFO_PRINTF1(_L("RWindowTreeNode::Close"));

	}

void CT_DataWindowTreeNode::DoCmdDestroyL()

	{

	RWindowTreeNode*	node=GetWindowTreeNode();

	//	We disown the object as Destroy() also deletes it

	DisownObjectL();

	INFO_PRINTF1(_L("RWindowTreeNode::Destroy"));

	node->Destroy();

	}

void CT_DataWindowTreeNode::DoCmdParent(const TDesC& aSection)

	{

	TUint32	actual = GetWindowTreeNode()->Parent();

	INFO_PRINTF2(_L("RWindowTreeNode::Parent = %d"), actual);

	TInt	expected = 0;

	if(	GetIntFromConfig(aSection, KExpected(), expected))

		{

		if ( actual!=(TUint32)expected )

			{

			ERR_PRINTF1(_L("Parent is	not	as expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KExpected());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdPrevSibling(const TDesC& aSection)

	{

	TUint32	actual = GetWindowTreeNode()->PrevSibling();

	INFO_PRINTF2(_L("RWindowTreeNode::PrevSibling	= %d"),	actual);

	TInt	expected = 0;

	if(	GetIntFromConfig(aSection, KExpected(), expected))

		{

		if ( actual!=(TUint32)expected )

			{

			ERR_PRINTF1(_L("PrevSibling is not as	expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KExpected());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdNextSibling(const TDesC& aSection)

	{

	TUint32	actual = GetWindowTreeNode()->NextSibling();

	INFO_PRINTF2(_L("RWindowTreeNode::NextSibling	= %d"),	actual);

	TInt	expected = 0;

	if(	GetIntFromConfig(aSection, KExpected(), expected))

		{

		if ( actual!=(TUint32)expected )

			{

			ERR_PRINTF1(_L("NextSibling is not as	expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KExpected());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdChild(const TDesC& aSection)

	{

	TUint32	actual = GetWindowTreeNode()->Child();

	INFO_PRINTF2(_L("RWindowTreeNode::Child =	%d"), actual);

	TInt	expected = 0;

	if(	GetIntFromConfig(aSection, KExpected(), expected))

		{

		if ( actual!=(TUint32)expected )

			{

			ERR_PRINTF1(_L("Child	is not as expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KExpected());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdOrdinalPriority(const TDesC& aSection)

	{

	TInt		actual = GetWindowTreeNode()->OrdinalPriority();

	INFO_PRINTF2(_L("RWindowTreeNode::OrdinalPriority	= %d"),	actual);

	TInt	expected = 0;

	if(	GetIntFromConfig(aSection, KExpected(), expected))

		{

		if(	actual != expected )

			{

			ERR_PRINTF1(_L("OrdinalPriority is not as	expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KExpected());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdOrdinalPosition(const TDesC& aSection)

	{

	TInt		actual = GetWindowTreeNode()->OrdinalPosition();

	INFO_PRINTF2(_L("RWindowTreeNode::OrdinalPosition	= %d"),	actual);

	TInt	expected = 0;

	if(	GetIntFromConfig(aSection, KExpected(), expected))

		{

		if(	actual != expected )

			{

			ERR_PRINTF1(_L("OrdinalPosition is not as	expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KExpected());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdFullOrdinalPosition(const TDesC& aSection)

	{

	TInt		actual = GetWindowTreeNode()->FullOrdinalPosition();

	INFO_PRINTF2(_L("RWindowTreeNode::FullOrdinalPosition	= %d"),	actual);

	TInt	expected = 0;

	if(	GetIntFromConfig(aSection, KExpected(), expected))

		{

		if(	actual != expected )

			{

			ERR_PRINTF1(_L("FullOrdinalPosition is not as	expected!"));

			SetBlockResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KExpected());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdSetOrdinalPosition(const TDesC& aSection)

	{

	TInt	inputWindowPosition=0;

	if(	GetIntFromConfig(aSection, KInputWindowPosition(), inputWindowPosition))

		{

		TInt	inputWindowPriority=0;

		if(	GetIntFromConfig(aSection, KInputWindowPriority(), inputWindowPriority))

			{

			GetWindowTreeNode()->SetOrdinalPosition(inputWindowPosition, inputWindowPriority);

			INFO_PRINTF1(_L("RWindowTreeNode::SetOrdinalPosition (Priority)"));

			}

		else

			{

			GetWindowTreeNode()->SetOrdinalPosition(inputWindowPosition);

			INFO_PRINTF1(_L("RWindowTreeNode::SetOrdinalPosition"));

			}

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KInputWindowPosition());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdWindowGroupId()

	{

	TInt	actual = GetWindowTreeNode()->WindowGroupId();

	INFO_PRINTF2(_L("RWindowTreeNode::WindowGroupId =	%d"), actual);

	SetIdentifier(actual);

	}

void CT_DataWindowTreeNode::DoCmdSetPointerCursor(const TDesC& aSection)

	{

	TPointerCursorMode	inputCursorNumber=EPointerCursorNormal;

 	if ( CT_GraphicsUtil::ReadPointerCursorMode(*this, aSection, KInputCursorNumber(), inputCursorNumber) )

		{

		TInt	err=GetWindowTreeNode()->SetPointerCursor(inputCursorNumber);

		if ( err!=KErrNone )

			{

			ERR_PRINTF2(_L("**** SetPointerCursor failed with error	%d"),	err);

			SetError(err);

			}

		INFO_PRINTF1(_L("RWindowTreeNode::SetPointerCursor"));

		}

	else

		{

		ERR_PRINTF2(_L("Missing parameter	%S"), &KInputCursorNumber());

		SetBlockResult(EFail);

		}

	}

void CT_DataWindowTreeNode::DoCmdSetCustomPointerCursorL(const TDesC& aSection)

	{

	TPtrC	objectName;

	if( GetStringFromConfig(aSection, KObjectName(), objectName) )

		{

		RWsSession*			wsSession = static_cast<RWsSession*>(GetDataObjectL(objectName));

		RWsPointerCursor 	pointerCursor(*wsSession);

		User::LeaveIfError(pointerCursor.Construct(0));

		CleanupClosePushL(pointerCursor);

		INFO_PRINTF1(_L("RWindowTreeNode::SetCustomPointerCursor"));

		GetWindowTreeNode()->SetCustomPointerCursor(pointerCursor);

		CleanupStack::PopAndDestroy(&pointerCursor);

		}

	else

		{

		TPtrC pointerCursorName;

		if( GetStringFromConfig(aSection, KFldPointerCursor(), pointerCursorName) )

			{

			RWsPointerCursor*			pointerCursor = static_cast<RWsPointerCursor*>(GetDataObjectL(pointerCursorName));

			INFO_PRINTF1(_L("RWindowTreeNode::SetCustomPointerCursor"));

			GetWindowTreeNode()->SetCustomPointerCursor(*pointerCursor);

			}

		else

			{

			ERR_PRINTF3(_L("Missing parameter %S or %S"), &KFldPointerCursor(),&KObjectName());

			SetBlockResult(EFail);

			}

		}

	}

void CT_DataWindowTreeNode::DoCmdEnableOnEvents(const TDesC& aSection)

	{

	TEventControl	eventControl=EEventControlOnlyWithKeyboardFocus;

	CT_GraphicsUtil::ReadEventControl(*this, aSection, KInputEventControl(), eventControl);

	INFO_PRINTF1(_L("RWindowTreeNode::EnableOnEvents"));

	TInt	err=GetWindowTreeNode()->EnableOnEvents(eventControl);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("**** EnableOnEvents failed with error %d"), err);

		SetError(err);

		}

	}

void CT_DataWindowTreeNode::DoCmdDisableOnEvents()

	{

	INFO_PRINTF1(_L("RWindowTreeNode::DisableOnEvents"));

	GetWindowTreeNode()->DisableOnEvents();

	}

void CT_DataWindowTreeNode::DoCmdEnableGroupChangeEvents()

	{

	INFO_PRINTF1(_L("RWindowTreeNode::EnableGroupChangeEvents"));

	TInt	err = GetWindowTreeNode()->EnableGroupChangeEvents();

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("**** EnableGroupChangeEvents failed with error %d"),	err);

		SetError(err);

		}

	}

void CT_DataWindowTreeNode::DoCmdDisableGroupChangeEvents()

	{

	INFO_PRINTF1(_L("RWindowTreeNode::DisableGroupChangeEvents"));

	GetWindowTreeNode()->DisableGroupChangeEvents();

	}

void CT_DataWindowTreeNode::DoCmdEnableFocusChangeEvents()