diff -r e8c1ea2c6496 -r 8758140453c0 graphics/wserv/src/T_DataWindowTreeNode.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphics/wserv/src/T_DataWindowTreeNode.cpp	Thu Jan 21 12:53:44 2010 +0000
@@ -0,0 +1,682 @@
+/*
+* 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 the License "Symbian Foundation License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.symbianfoundation.org/legal/sfl-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()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::EnableFocusChangeEvents"));
+	TInt	err = GetWindowTreeNode()->EnableFocusChangeEvents();
+	if ( err!=KErrNone )
+		{
+		ERR_PRINTF2(_L("**** EnableFocusChangeEvents failed with error %d"),	err);
+		SetError(err);
+		}
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdDisableFocusChangeEvents()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::DisableFocusChangeEvents"));
+	GetWindowTreeNode()->DisableFocusChangeEvents();
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdEnableGroupListChangeEvents()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::EnableGroupListChangeEvents"));
+	TInt	err = GetWindowTreeNode()->EnableGroupListChangeEvents();
+	if ( err!=KErrNone )
+		{
+		ERR_PRINTF2(_L("**** EnableGroupListChangeEvents failed with error %d"),	err);
+		SetError(err);
+		}
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdDisableGroupListChangeEvents()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::DisableGroupListChangeEvents"));
+	GetWindowTreeNode()->DisableGroupListChangeEvents();
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdEnableVisibilityChangeEvents()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::EnableVisibilityChangeEvents"));
+	TInt	err = GetWindowTreeNode()->EnableVisibilityChangeEvents();
+	if ( err!=KErrNone )
+		{
+		ERR_PRINTF2(_L("**** EnableVisibilityChangeEvents failed with error %d"),	err);
+		SetError(err);
+		}
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdDisableVisibilityChangeEvents()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::DisableVisibilityChangeEvents"));
+	GetWindowTreeNode()->DisableVisibilityChangeEvents();
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdEnableErrorMessages(const TDesC& aSection)
+	{
+	TEventControl	eventControl=EEventControlOnlyWithKeyboardFocus;
+	CT_GraphicsUtil::ReadEventControl(*this, aSection, KInputEventControl(), eventControl);
+
+	INFO_PRINTF1(_L("RWindowTreeNode::EnableErrorMessages"));
+	TInt	err=GetWindowTreeNode()->EnableErrorMessages(eventControl);
+	if ( err!=KErrNone )
+		{
+		ERR_PRINTF2(_L("**** EnableErrorMessages failed with error	%d"),	err);
+		SetError(err);
+		}
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdDisableErrorMessages()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::DisableErrorMessages"));
+	GetWindowTreeNode()->DisableErrorMessages();
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdEnableModifierChangedEvents(const TDesC& aSection)
+	{
+	TEventModifier	eventModifier = EModifierAutorepeatable;
+	CT_GraphicsUtil::ReadEventModifier(*this, aSection, KInputEventModifier(), eventModifier);
+
+	TEventControl	eventControl = EEventControlOnlyWithKeyboardFocus;
+	CT_GraphicsUtil::ReadEventControl(*this, aSection, KInputEventControl(), eventControl);
+
+	INFO_PRINTF1(_L("RWindowTreeNode::EnableModifierChangedEvents"));
+	TInt	err=GetWindowTreeNode()->EnableModifierChangedEvents(eventModifier, eventControl);
+	if ( err!=KErrNone )
+		{
+		ERR_PRINTF2(_L("**** EnableModifierChangedEvents failed with error	%d"),	err);
+		SetError(err);
+		}
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdDisableModifierChangedEvents()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::DisableModifierChangedEvents"));
+	GetWindowTreeNode()->DisableModifierChangedEvents();
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdSetNonFading(const TDesC& aSection)
+	{
+	TBool	inputNonFading=ETrue;
+	if(	GetBoolFromConfig(aSection, KInputNonFading(), inputNonFading))
+		{
+		INFO_PRINTF1(_L("RWindowTreeNode::SetNonFading"));
+		GetWindowTreeNode()->SetNonFading(inputNonFading);
+		}
+	else
+		{
+		ERR_PRINTF2(_L("Missing parameter %S"), &KInputNonFading());
+		SetBlockResult(EFail);
+		}
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdSetFaded(const TDesC& aSection)
+	{
+	TBool	inputFaded=ETrue;
+	if( !GetBoolFromConfig(aSection, KInputFaded(), inputFaded))
+		{
+		ERR_PRINTF2(_L("Missing parameter %S"), &KInputFaded());
+		SetBlockResult(EFail);
+		}
+	else
+		{
+		RWindowTreeNode::TFadeControl	fadeControl=RWindowTreeNode::EFadeIncludeChildren;
+		CT_GraphicsUtil::ReadFadeControl(*this, aSection, KInputFadeControl(), fadeControl);
+
+		TInt	inputBlackMap=0;
+		TInt	inputWhiteMap=255;
+		if( GetIntFromConfig(aSection, KInputBlackMap(), inputBlackMap) &&
+			GetIntFromConfig(aSection, KInputWhiteMap(), inputWhiteMap) )
+			{
+			INFO_PRINTF1(_L("RWindowTreeNode::SetFaded (Map Fading)"));
+			GetWindowTreeNode()->SetFaded(inputFaded, fadeControl, (TUint8) inputBlackMap, (TUint8) inputWhiteMap);
+			}
+		else
+			{
+			INFO_PRINTF1(_L("RWindowTreeNode::SetFaded"));
+			GetWindowTreeNode()->SetFaded(inputFaded, fadeControl);
+			}
+		}
+	}
+
+
+void CT_DataWindowTreeNode::DoCmdClearPointerCursor()
+	{
+	INFO_PRINTF1(_L("RWindowTreeNode::ClearPointerCursor"));
+	GetWindowTreeNode()->ClearPointerCursor();
+	}