--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphics/wserv/src/T_DataWsSession.cpp Thu Jan 21 12:53:44 2010 +0000
@@ -0,0 +1,2440 @@
+/*
+* 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_DataWsSession.h"
+#include "T_GraphicsUtil.h"
+#include "T_DataWindowGroup.h"
+
+// EPOC Includes
+#include <apgtask.h>
+#include <w32std.h>
+#include <gdi.h>
+
+/*@{*/
+_LIT(KDataClassname, "RWsSession");
+
+/// Fields
+_LIT(KFldCheckWithStore, "checkwithstore");
+_LIT(KFldExpected, "expected");
+_LIT(KFldKeyCode, "keycode");
+_LIT(KFldModifier, "modifier");
+_LIT(KFldModifierMask, "modifiermask");
+_LIT(KFldModifiers, "modifiers");
+_LIT(KFldNullPointer, "nullpointer");
+_LIT(KFldOffset, "offset");
+_LIT(KFldRepeats, "repeats");
+_LIT(KFldStdScanCode, "stdscancode");
+_LIT(KFldType, "type");
+_LIT(KFldStore, "store");
+_LIT(KFldPos, "pos");
+_LIT(KFldDeviceNumber, "devicenumber");
+_LIT(KFldTip, "tip");
+_LIT(KFldIdentifier, "identifier");
+_LIT(KFldSpriteMember, "spritemember");
+_LIT(KFldSpriteFlags, "spriteflags");
+_LIT(KFldAlignment, "alignment");
+_LIT(KFldWindowGroup, "windowgroup");
+
+/// Parameters
+
+_LIT(KLogMessage, "logMessage");
+_LIT(KLogCommand, "logCommand");
+_LIT(KTPoint, "point");
+_LIT(KInputWGId, "inputWGId");
+_LIT(KBGColour, "bgcolour");
+_LIT(KInputCursorNumber, "inputcursornumber");
+_LIT(KComputeMode, "computemode");
+_LIT(KInputScrnNo, "inputscreenno");
+_LIT(KDefDisplayMode, "defDisplayMode");
+_LIT(KDefModeMaxNumColor, "defModeMaxNumColor");
+_LIT(KDefModeMaxNumGray, "defModeMaxNumGray");
+_LIT(KWindowGroupIdentifier, "wgIdentifier");
+_LIT(KInputDefaultCursorNumber, "defaultsyscurnum");
+_LIT(KUseRfs, "userfs");
+_LIT(KExpectedHeapCount, "heapCount");
+_LIT(KExpectPtrCursorMode, "expectptrcurmode");
+_LIT(KExpectBgColour, "expectbgcolour");
+_LIT(KExpectedDiff, "expected_diff");
+_LIT(KSetBuffer, "setbuffer");
+_LIT(KSetMaxBuffer, "setmaxbuffer");
+_LIT(KSetFocusScreen, "setfocusscreen");
+_LIT(KSetEventOffOn, "seteventoffon");
+_LIT(KWTreeNodeObj, "treenodeobj");
+_LIT(KExpectShadowVector, "expectshdwvet");
+_LIT(KAutoFlushState, "newFlushstate");
+_LIT(KExpectFlushState, "expectedFlushstate");
+_LIT(KVersionBuild, "build");
+_LIT(KVersionMajor, "major");
+_LIT(KVersionMinor, "minor");
+_LIT(KWGUseArray, "usearray");
+_LIT(KWGListPriority, "priority");
+_LIT(KWGGivenPriority, "givenwgpriority");
+_LIT(KWGSpecifieScrnNo, "specifiescrnno");
+_LIT(KWGScreenNumber, "screennum");
+_LIT(KWGOrdinalId, "identifier");
+_LIT(KWGOrdinalPosition, "position");
+_LIT(KWGOrdinalPriority, "wgid");
+_LIT(KWGinquiredId, "inquiredwgid");
+_LIT(KFindWGPreId, "prewgid");
+_LIT(KMatchWGString, "matchwgname");
+_LIT(KThreadId, "threadid");
+_LIT(KRequestEvent, "requestevent");
+_LIT(KRequestRedraw, "requestRedraw");
+_LIT(KPKPriorityKey, "prioritykey");
+_LIT(KSetHotKey, "hotkey");
+_LIT(KClsHotKey, "clshotkey");
+_LIT(KRestoreDefHotKey, "restoredefhk");
+_LIT(KSetKeyCode, "keycode");
+_LIT(KDblClickInterval, "maxinterval");
+_LIT(KDblClickDistance, "maxdistance");
+_LIT(KExpectedDblMaxInitialTime, "expecteddblmaxinittime");
+_LIT(KExpectedDblDistance, "expecteddblmaxdistance");
+_LIT(KSetKBRepRateInterval, "kbreprateinterval");
+_LIT(KSetKBRepRateTime, "kbrepratetime");
+_LIT(KWGGetExpectedKBInitialTime, "expectedkbinittime");
+_LIT(KWGGetExpectedKBRepeatTime, "expectedkbRepeattime");
+_LIT(KSetSysFading, "sysfadonoff");
+_LIT(KSetblackMapFading, "blackmapfading");
+_LIT(KSetwhiteMapFading, "whitemapfading");
+_LIT(KSetDefblackMapFading, "defblackmapfading");
+_LIT(KSetDefwhiteMapFading, "defwhitemapfading");
+_LIT(KSetShadowVec, "shadowvector");
+_LIT(KSetScrnSizeMode, "screensizemode");
+_LIT(KSetPtrCurPosValue, "ptrcurpos");
+_LIT(KPtrCurPosArea, "ptrcurarea");
+_LIT(KSetPtrCurMode, "pointercurmode");
+_LIT(KSetCltCurMode, "cltcurmode");
+_LIT(KInputPermanentModifier, "inputpermanmodif");
+_LIT(KInputPermanentModifierState, "inputpermanmodifstate");
+
+//Commands
+_LIT(KCmdnew, "new");
+_LIT(KCmdConnect, "Connect");
+_LIT(KCmdClose, "Close");
+_LIT(KCmdVersion, "Version");
+_LIT(KCmdSetHotKey, "SetHotKey");
+_LIT(KCmdClearHotKeys, "ClearHotKeys");
+_LIT(KCmdRestoreDefaultHotKey, "RestoreDefaultHotKey");
+_LIT(KCmdEventReady, "EventReady");
+_LIT(KCmdEventReadyCancel, "EventReadyCancel");
+_LIT(KCmdGetEvent, "GetEvent");
+_LIT(KCmdPurgePointerEvents, "PurgePointerEvents");
+_LIT(KCmdRedrawReady, "RedrawReady");
+_LIT(KCmdRedrawReadyCancel, "RedrawReadyCancel");
+_LIT(KCmdGetRedraw, "GetRedraw");
+_LIT(KCmdPriorityKeyReady, "PriorityKeyReady");
+_LIT(KCmdPriorityKeyReadyCancel, "PriorityKeyReadyCancel");
+_LIT(KCmdGetPriorityKey, "GetPriorityKey");
+_LIT(KCmdFlush, "Flush");
+_LIT(KCmdSetAutoFlush, "SetAutoFlush");
+_LIT(KCmdSetKeyboardRepeatRate, "SetKeyboardRepeatRate");
+_LIT(KCmdGetKeyboardRepeatRate, "GetKeyboardRepeatRate");
+_LIT(KCmdGetDoubleClickSettings, "GetDoubleClickSettings");
+_LIT(KCmdSetDoubleClick, "SetDoubleClick");
+_LIT(KCmdNumWindowGroups, "NumWindowGroups");
+_LIT(KCmdWindowGroupList, "WindowGroupList");
+_LIT(KCmdGetFocusWindowGroup, "GetFocusWindowGroup");
+_LIT(KCmdGetDefaultOwningWindow, "GetDefaultOwningWindow");
+_LIT(KCmdSetWindowGroupOrdinalPosition, "SetWindowGroupOrdinalPosition");
+_LIT(KCmdGetWindowGroupClientThreadId, "GetWindowGroupClientThreadId");
+_LIT(KCmdGetWindowGroupHandle, "GetWindowGroupHandle");
+_LIT(KCmdGetWindowGroupOrdinalPriority, "GetWindowGroupOrdinalPriority");
+_LIT(KCmdGetWindowGroupNameFromIdentifier, "GetWindowGroupNameFromIdentifier");
+_LIT(KCmdFindWindowGroupIdentifier, "FindWindowGroupIdentifier");
+_LIT(KCmdFetchMessage, "FetchMessage");
+_LIT(KCmdSetShadowVector, "SetShadowVector");
+_LIT(KCmdShadowVector, "ShadowVector");
+_LIT(KCmdSetBackgroundColor, "SetBackgroundColor");
+_LIT(KCmdGetBackgroundColor, "GetBackgroundColor");
+_LIT(KCmdSetSystemPointerCursor, "SetSystemPointerCursor");
+_LIT(KCmdClearSystemPointerCursor, "ClearSystemPointerCursor");
+_LIT(KCmdClaimSystemPointerCursorList, "ClaimSystemPointerCursorList");
+_LIT(KCmdFreeSystemPointerCursorList, "FreeSystemPointerCursorList");
+_LIT(KCmdSetCustomTextCursor, "SetCustomTextCursor");
+_LIT(KCmdResourceCount, "ResourceCount");
+_LIT(KCmdPasswordEntered, "PasswordEntered");
+_LIT(KCmdComputeMode, "ComputeMode");
+_LIT(KCmdHeapCount, "HeapCount");
+_LIT(KCmdSetModifierState, "SetModifierState");
+_LIT(KCmdGetModifierState, "GetModifierState");
+_LIT(KCmdRequestOffEvents, "RequestOffEvents");
+_LIT(KCmdGetDefModeMaxNumColors, "GetDefModeMaxNumColors");
+_LIT(KCmdGetColorModeList, "GetColorModeList");
+_LIT(KCmdSetPointerCursorArea, "SetPointerCursorArea");
+_LIT(KCmdPointerCursorArea, "PointerCursorArea");
+_LIT(KCmdSetPointerCursorMode, "SetPointerCursorMode");
+_LIT(KCmdSetClientCursorMode, "SetClientCursorMode");
+_LIT(KCmdPointerCursorMode, "PointerCursorMode");
+_LIT(KCmdSetDefaultSystemPointerCursor, "SetDefaultSystemPointerCursor");
+_LIT(KCmdClearDefaultSystemPointerCursor, "ClearDefaultSystemPointerCursor");
+_LIT(KCmdSetPointerCursorPosition, "SetPointerCursorPosition");
+_LIT(KCmdPointerCursorPosition, "PointerCursorPosition");
+_LIT(KCmdSetDefaultFadingParameters, "SetDefaultFadingParameters");
+_LIT(KCmdPrepareForSwitchOff, "PrepareForSwitchOff");
+_LIT(KCmdSetBufferSizeL, "SetBufferSizeL");
+_LIT(KCmdSetMaxBufferSizeL, "SetMaxBufferSizeL");
+_LIT(KCmdSetSystemFaded, "SetSystemFaded");
+_LIT(KCmdSetFocusScreen, "SetFocusScreen");
+_LIT(KCmdGetFocusScreen, "GetFocusScreen");
+_LIT(KCmdClearAllRedrawStores, "ClearAllRedrawStores");
+_LIT(KCmdLogCommand, "LogCommand");
+_LIT(KCmdLogMessage, "LogMessage");
+_LIT(KCmdNumberOfScreens, "NumberOfScreens");
+_LIT(KCmdSimulateRawEvent, "SimulateRawEvent");
+_LIT(KCmdSimulateKeyEvent, "SimulateKeyEvent");
+
+/// Logging
+_LIT(KLogError, "Error=%d");
+_LIT(KLogMissingParameter, "Missing parameter '%S'");
+_LIT(KLogNotExpectedValue, "Not expected value");
+
+//constants
+const TInt KGroupNameMaxSize =100;
+
+/*@}*/
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CT_DataWsSession* CT_DataWsSession::NewL()
+ {
+ CT_DataWsSession* ret=new (ELeave) CT_DataWsSession();
+ CleanupStack::PushL(ret);
+ ret->ConstructL();
+ CleanupStack::Pop(ret);
+ return ret;
+ }
+
+CT_DataWsSession::CT_DataWsSession()
+: CDataWrapperBase()
+, iWsSession(NULL)
+, iResourceCount(0)
+, iNumWinGroup(0)
+, iColorModeCount(0)
+, iWindowGroupIdentifier(0)
+, iActiveEventReady(NULL)
+, iActivePriorityKeyReady(NULL)
+, iActiveRedrawReady(NULL)
+ {
+ }
+
+void CT_DataWsSession::ConstructL()
+ {
+ iActiveEventReady=CActiveCallback::NewL(*this);
+ iActivePriorityKeyReady=CActiveCallback::NewL(*this);
+ iActiveRedrawReady=CActiveCallback::NewL(*this);
+ }
+
+CT_DataWsSession::~CT_DataWsSession()
+ {
+ DestroyData();
+ delete iActiveRedrawReady;
+ iActiveRedrawReady=NULL;
+ delete iActivePriorityKeyReady;
+ iActivePriorityKeyReady=NULL;
+ delete iActiveEventReady;
+ iActiveEventReady=NULL;
+ }
+
+void CT_DataWsSession::SetObjectL(TAny* aAny)
+ {
+ DestroyData();
+ iWsSession = static_cast<RWsSession*> (aAny);
+ }
+
+void CT_DataWsSession::DisownObjectL()
+ {
+ iWsSession = NULL;
+ }
+
+void CT_DataWsSession::DestroyData()
+ {
+ delete iWsSession;
+ iWsSession=NULL;
+ }
+
+MWsClientClass* CT_DataWsSession::GetClientClass() const
+ {
+ return iWsSession;
+ }
+
+
+/**
+* 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_DataWsSession::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
+ {
+ TBool ret = ETrue;
+
+ if ( aCommand==KCmdnew || aCommand==KDataClassname )
+ {
+ DoCmdnew();
+ }
+ else if ( aCommand==KCmdConnect )
+ {
+ DoCmdConnectL(aSection);
+ }
+ else if ( aCommand==KCmdClose )
+ {
+ DoCmdClose();
+ }
+ else if ( aCommand==KCmdVersion )
+ {
+ DoCmdVersion(aSection);
+ }
+ else if ( aCommand==KCmdSetHotKey )
+ {
+ DoCmdSetHotKey(aSection);
+ }
+ else if ( aCommand==KCmdClearHotKeys )
+ {
+ DoCmdClearHotKeys(aSection);
+ }
+ else if ( aCommand==KCmdRestoreDefaultHotKey )
+ {
+ DoCmdRestoreDefaultHotKey(aSection);
+ }
+ else if ( aCommand==KCmdEventReady )
+ {
+ DoCmdEventReady(aSection, aAsyncErrorIndex);
+ }
+ else if ( aCommand==KCmdEventReadyCancel )
+ {
+ DoCmdEventReadyCancel();
+ }
+ else if ( aCommand==KCmdGetEvent )
+ {
+ DoCmdGetEventL(aSection);
+ }
+ else if ( aCommand==KCmdPurgePointerEvents )
+ {
+ DoCmdPurgePointerEvents();
+ }
+ else if ( aCommand==KCmdRedrawReady )
+ {
+ DoCmdRedrawReady(aSection, aAsyncErrorIndex);
+ }
+ else if ( aCommand==KCmdRedrawReadyCancel )
+ {
+ DoCmdRedrawReadyCancel();
+ }
+ else if ( aCommand==KCmdGetRedraw )
+ {
+ DoCmdGetRedrawL(aSection);
+ }
+ else if ( aCommand==KCmdPriorityKeyReady )
+ {
+ DoCmdPriorityKeyReady(aSection, aAsyncErrorIndex);
+ }
+ else if ( aCommand==KCmdPriorityKeyReadyCancel )
+ {
+ DoCmdPriorityKeyReadyCancel();
+ }
+ else if ( aCommand==KCmdGetPriorityKey )
+ {
+ DoCmdGetPriorityKeyL(aSection);
+ }
+ else if ( aCommand==KCmdFlush )
+ {
+ DoCmdFlush();
+ }
+ else if ( aCommand==KCmdSetAutoFlush )
+ {
+ DoCmdSetAutoFlush(aSection);
+ }
+ else if ( aCommand==KCmdSetKeyboardRepeatRate )
+ {
+ DoCmdSetKeyboardRepeatRate(aSection);
+ }
+ else if ( aCommand==KCmdGetKeyboardRepeatRate )
+ {
+ DoCmdGetKeyboardRepeatRate(aSection);
+ }
+ else if ( aCommand==KCmdGetDoubleClickSettings )
+ {
+ DoCmdGetDoubleClickSettings(aSection);
+ }
+ else if ( aCommand==KCmdSetDoubleClick )
+ {
+ DoCmdSetDoubleClick(aSection);
+ }
+ else if ( aCommand==KCmdNumWindowGroups )
+ {
+ DoCmdNumWindowGroups(aSection);
+ }
+ else if ( aCommand==KCmdWindowGroupList )
+ {
+ DoCmdWindowGroupListL(aSection);
+ }
+ else if ( aCommand==KCmdGetFocusWindowGroup )
+ {
+ DoCmdGetFocusWindowGroup(aSection);
+ }
+ else if ( aCommand==KCmdGetDefaultOwningWindow )
+ {
+ DoCmdGetDefaultOwningWindow(aSection);
+ }
+ else if ( aCommand==KCmdSetWindowGroupOrdinalPosition )
+ {
+ DoCmdSetWindowGroupOrdinalPosition(aSection);
+ }
+ else if ( aCommand==KCmdGetWindowGroupClientThreadId )
+ {
+ DoCmdGetWindowGroupClientThreadId(aSection);
+ }
+ else if ( aCommand==KCmdGetWindowGroupHandle )
+ {
+ DoCmdGetWindowGroupHandle(aSection);
+ }
+ else if ( aCommand==KCmdGetWindowGroupOrdinalPriority )
+ {
+ DoCmdGetWindowGroupOrdinalPriority(aSection);
+ }
+ else if ( aCommand==KCmdGetWindowGroupNameFromIdentifier )
+ {
+ DoCmdGetWindowGroupNameFromIdentifier(aSection);
+ }
+ else if ( aCommand==KCmdFindWindowGroupIdentifier )
+ {
+ DoCmdFindWindowGroupIdentifier(aSection);
+ }
+ else if ( aCommand==KCmdFetchMessage )
+ {
+ DoCmdFetchMessage(aSection);
+ }
+ else if ( aCommand==KCmdSetShadowVector )
+ {
+ DoCmdSetShadowVector(aSection);
+ }
+ else if ( aCommand==KCmdShadowVector )
+ {
+ DoCmdShadowVector(aSection);
+ }
+ else if ( aCommand==KCmdSetBackgroundColor )
+ {
+ DoCmdSetBackgroundColor(aSection);
+ }
+ else if ( aCommand==KCmdGetBackgroundColor )
+ {
+ DoCmdGetBackgroundColor(aSection);
+ }
+ else if ( aCommand==KCmdSetSystemPointerCursor )
+ {
+ DoCmdSetSystemPointerCursor(aSection);
+ }
+ else if ( aCommand==KCmdClearSystemPointerCursor )
+ {
+ DoCmdClearSystemPointerCursor(aSection);
+ }
+ else if ( aCommand==KCmdClaimSystemPointerCursorList )
+ {
+ DoCmdClaimSystemPointerCursorList();
+ }
+ else if ( aCommand==KCmdFreeSystemPointerCursorList )
+ {
+ DoCmdFreeSystemPointerCursorList();
+ }
+ else if ( aCommand==KCmdSetCustomTextCursor )
+ {
+ DoCmdSetCustomTextCursorL(aSection);
+ }
+ else if ( aCommand==KCmdResourceCount )
+ {
+ DoCmdResourceCount(aSection);
+ }
+ else if ( aCommand==KCmdPasswordEntered )
+ {
+ DoCmdPasswordEntered();
+ }
+ else if ( aCommand==KCmdComputeMode )
+ {
+ DoCmdComputeMode(aSection);
+ }
+ else if ( aCommand==KCmdHeapCount )
+ {
+ DoCmdHeapCount(aSection);
+ }
+ else if ( aCommand==KCmdSetModifierState )
+ {
+ DoCmdSetModifierState(aSection);
+ }
+ else if ( aCommand==KCmdGetModifierState )
+ {
+ DoCmdGetModifierState(aSection);
+ }
+ else if ( aCommand==KCmdRequestOffEvents )
+ {
+ DoCmdRequestOffEventsL(aSection);
+ }
+ else if ( aCommand==KCmdGetDefModeMaxNumColors )
+ {
+ DoCmdGetDefModeMaxNumColors(aSection);
+ }
+ else if ( aCommand==KCmdGetColorModeList )
+ {
+ DoCmdGetColorModeListL(aSection);
+ }
+ else if ( aCommand==KCmdSetPointerCursorArea )
+ {
+ DoCmdSetPointerCursorArea(aSection);
+ }
+ else if ( aCommand==KCmdPointerCursorArea )
+ {
+ DoCmdPointerCursorArea(aSection);
+ }
+ else if ( aCommand==KCmdSetPointerCursorMode )
+ {
+ DoCmdSetPointerCursorMode(aSection);
+ }
+ else if ( aCommand==KCmdSetClientCursorMode )
+ {
+ DoCmdSetClientCursorMode(aSection);
+ }
+ else if ( aCommand==KCmdPointerCursorMode )
+ {
+ DoCmdPointerCursorMode(aSection);
+ }
+ else if ( aCommand==KCmdSetDefaultSystemPointerCursor )
+ {
+ DoCmdSetDefaultSystemPointerCursor(aSection);
+ }
+ else if ( aCommand==KCmdClearDefaultSystemPointerCursor )
+ {
+ DoCmdClearDefaultSystemPointerCursor();
+ }
+ else if ( aCommand==KCmdSetPointerCursorPosition )
+ {
+ DoCmdSetPointerCursorPosition(aSection);
+ }
+ else if ( aCommand==KCmdPointerCursorPosition )
+ {
+ DoCmdPointerCursorPosition(aSection);
+ }
+ else if ( aCommand==KCmdSetDefaultFadingParameters )
+ {
+ DoCmdSetDefaultFadingParameters(aSection);
+ }
+ else if ( aCommand==KCmdPrepareForSwitchOff )
+ {
+ DoCmdPrepareForSwitchOff();
+ }
+ else if ( aCommand==KCmdSetBufferSizeL )
+ {
+ DoCmdSetBufferSizeL(aSection);
+ }
+ else if ( aCommand==KCmdSetMaxBufferSizeL )
+ {
+ DoCmdSetMaxBufferSizeL(aSection);
+ }
+ else if ( aCommand==KCmdSetSystemFaded )
+ {
+ DoCmdSetSystemFaded(aSection);
+ }
+ else if ( aCommand==KCmdSetFocusScreen )
+ {
+ DoCmdSetFocusScreen(aSection);
+ }
+ else if ( aCommand==KCmdGetFocusScreen )
+ {
+ DoCmdGetFocusScreen(aSection);
+ }
+ else if ( aCommand==KCmdClearAllRedrawStores )
+ {
+ DoCmdClearAllRedrawStores();
+ }
+ else if ( aCommand==KCmdLogCommand )
+ {
+ DoCmdLogCommand(aSection);
+ }
+ else if ( aCommand==KCmdLogMessage )
+ {
+ DoCmdLogMessage(aSection);
+ }
+ else if ( aCommand==KCmdNumberOfScreens )
+ {
+ DoCmdNumberOfScreens(aSection);
+ }
+ else if ( aCommand==KCmdSimulateRawEvent )
+ {
+ DoCmdSimulateRawEvent(aSection);
+ }
+ else if ( aCommand==KCmdSimulateKeyEvent )
+ {
+ DoCmdSimulateKeyEvent(aSection);
+ }
+ else
+ {
+ ret=CT_DataWsClientClass::DoCommandL(*this, aCommand, aSection, aAsyncErrorIndex);
+ }
+
+ return ret;
+ }
+
+
+void CT_DataWsSession::DoCmdnew()
+ {
+ INFO_PRINTF1(_L("Session is going to create"));
+ TRAPD(err, iWsSession = new (ELeave) RWsSession());
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+
+void CT_DataWsSession::DoCmdConnectL(const TDesC& aSection)
+ {
+ TBool useRfs=EFalse;
+ GetBoolFromConfig(aSection, KUseRfs(), useRfs);
+
+ TInt err=KErrNone;
+ if ( useRfs )
+ {
+ INFO_PRINTF1(_L("RWsSession::Connect(RFs&) call"));
+ err=iWsSession->Connect(FileServer());
+ }
+ else
+ {
+ INFO_PRINTF1(_L("RWsSession::Connect() call"));
+ err=iWsSession->Connect();
+ }
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+
+void CT_DataWsSession::DoCmdClose()
+ {
+ INFO_PRINTF1(_L("RWsSession::Close() call"));
+ iWsSession->Close();
+ }
+
+void CT_DataWsSession::DoCmdVersion(const TDesC& aSection)
+ {
+ INFO_PRINTF1(_L("WsSession::Version() call"));
+
+ TVersion version = iWsSession->Version();
+
+ INFO_PRINTF2(_L("Version build : %d"), (TInt)version.iBuild);
+ INFO_PRINTF2(_L("Version major : %d"), (TInt)version.iMajor);
+ INFO_PRINTF2(_L("Version minor : %d"), (TInt)version.iMinor);
+ TInt intTemp;
+ if ( GetIntFromConfig(aSection, KVersionBuild(), intTemp) )
+ {
+ if ( intTemp != version.iBuild )
+ {
+ ERR_PRINTF1(_L("Build does not match expected build"));
+ SetBlockResult(EFail);
+ }
+ }
+
+ if ( GetIntFromConfig(aSection, KVersionMajor(), intTemp) )
+ {
+ if ( intTemp != version.iMajor )
+ {
+ ERR_PRINTF1(_L("Major does not match expected major"));
+ SetBlockResult(EFail);
+ }
+ }
+
+ if ( GetIntFromConfig(aSection, KVersionMinor(), intTemp) )
+ {
+ if ( intTemp != version.iMinor )
+ {
+ ERR_PRINTF1(_L("Minor does not match expected minor"));
+ SetBlockResult(EFail);
+ }
+ }
+
+ if (version.Name() == _L("") && version.iBuild == 0 && version.iMajor == 0 && version.iMinor == 0)
+ {
+ ERR_PRINTF1(_L("Some version fields are not set!"));
+ SetBlockResult(EFail);
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetHotKey(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+
+ THotKey hotKey;
+
+ TInt err=KErrNone;
+
+ if ( !CT_GraphicsUtil::ReadHotKey(*this, aSection, KSetHotKey(), hotKey) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KSetHotKey());
+ SetBlockResult(EFail);
+ }
+
+ TKeyCode keyCode;
+ if ( !CT_GraphicsUtil::ReadKeyCode(*this, aSection, KSetKeyCode(), keyCode) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KSetKeyCode());
+ SetBlockResult(EFail);
+ }
+
+ TUint modifierMask=EModifierAlt | EModifierCtrl | EModifierShift | EModifierFunc | EModifierCapsLock;
+ CT_GraphicsUtil::ReadEventModifier(*this, aSection, KFldModifierMask, modifierMask);
+ TUint modifier=EModifierAlt | EModifierCtrl | EModifierShift | EModifierFunc | EModifierCapsLock;
+ CT_GraphicsUtil::ReadEventModifier(*this, aSection, KFldModifier, modifier);
+ if ( dataOk )
+ {
+ err = iWsSession->SetHotKey(hotKey, keyCode, modifierMask, modifier);
+ }
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+
+void CT_DataWsSession::DoCmdClearHotKeys(const TDesC& aSection)
+ {
+ THotKey hotKey;
+
+ TInt err=KErrNone;
+
+ if ( !CT_GraphicsUtil::ReadHotKey(*this, aSection, KClsHotKey(), hotKey) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KClsHotKey());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ err = iWsSession->ClearHotKeys(hotKey);
+ }
+
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+
+void CT_DataWsSession::DoCmdRestoreDefaultHotKey(const TDesC& aSection)
+ {
+ THotKey hotKey;
+
+ TInt err=KErrNone;
+
+ if ( !CT_GraphicsUtil::ReadHotKey(*this, aSection, KRestoreDefHotKey(), hotKey) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KRestoreDefHotKey());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ err = iWsSession->RestoreDefaultHotKey(hotKey);
+ }
+
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+
+void CT_DataWsSession::DoCmdEventReady(const TDesC& aSection, TInt aAsyncErrorIndex)
+ {
+ CActive::TPriority priority=CActive::EPriorityHigh;
+ CT_GraphicsUtil::ReadPriority(*this, aSection, KRequestEvent(), priority);
+
+ iActiveEventReady->SetPriority(priority);
+ INFO_PRINTF1(_L("RWsSession::EventReady() call"));
+ iWsSession->EventReady(&iActiveEventReady->iStatus);
+ iActiveEventReady->Activate(aAsyncErrorIndex);
+ IncOutstanding();
+ }
+
+void CT_DataWsSession::DoCmdEventReadyCancel()
+ {
+ iWsSession->EventReadyCancel();
+ }
+
+void CT_DataWsSession::DoCmdGetEventL(const TDesC& aSection)
+ {
+ TWsEvent event;
+
+ iWsSession->GetEvent(event);
+ INFO_PRINTF1(_L("RWsSession::GetEvent() call"));
+
+ TWsEvent* store=NULL;
+ if ( CT_GraphicsUtil::GetWsEventL(*this, aSection, KFldStore(), store) )
+ {
+ *store=event;
+ }
+ }
+
+void CT_DataWsSession::DoCmdPurgePointerEvents()
+ {
+ // Execute command and log parameters
+ INFO_PRINTF3(_L("execute %S::%S()"), &KDataClassname, &KCmdPurgePointerEvents);
+ iWsSession->PurgePointerEvents();
+ }
+
+void CT_DataWsSession::DoCmdRedrawReady(const TDesC& aSection, TInt aAsyncErrorIndex)
+ {
+ CActive::TPriority priority=CActive::EPriorityHigh;
+ CT_GraphicsUtil::ReadPriority(*this, aSection, KRequestRedraw(), priority);
+
+ iActiveRedrawReady->SetPriority(priority);
+ INFO_PRINTF1(_L("RWsSession::RedrawReady() call"));
+ iWsSession->RedrawReady(&iActiveRedrawReady->iStatus);
+ iActiveRedrawReady->Activate(aAsyncErrorIndex);
+ IncOutstanding();
+ }
+
+void CT_DataWsSession::DoCmdRedrawReadyCancel()
+ {
+ INFO_PRINTF1(_L("RWsSession::RedrawReadyCancel() call"));
+ iWsSession->RedrawReadyCancel();
+ }
+
+void CT_DataWsSession::DoCmdGetRedrawL(const TDesC& aSection)
+ {
+ TWsRedrawEvent redrawEvent;
+
+ iWsSession->GetRedraw(redrawEvent);
+ INFO_PRINTF1(_L("RWsSession::GetRedraw() call"));
+
+ TWsRedrawEvent* store=NULL;
+ if ( CT_GraphicsUtil::GetWsRedrawEventL(*this, aSection, KFldStore(), store) )
+ {
+ *store=redrawEvent;
+ }
+ }
+
+void CT_DataWsSession::DoCmdPriorityKeyReady(const TDesC& aSection, TInt aAsyncErrorIndex)
+ {
+ CActive::TPriority priority=CActive::EPriorityHigh;
+ CT_GraphicsUtil::ReadPriority(*this, aSection, KPKPriorityKey(), priority);
+
+ iActivePriorityKeyReady->SetPriority(priority);
+ INFO_PRINTF1(_L("RWsSession::PriorityKeyReady() call"));
+ iWsSession->PriorityKeyReady(&iActivePriorityKeyReady->iStatus);
+ iActivePriorityKeyReady->Activate(aAsyncErrorIndex);
+ IncOutstanding();
+ }
+
+
+void CT_DataWsSession::DoCmdPriorityKeyReadyCancel()
+ {
+ INFO_PRINTF1(_L("RWsSession::PriorityKeyReadyCancel() call"));
+ iWsSession->PriorityKeyReadyCancel();
+ }
+
+void CT_DataWsSession::DoCmdGetPriorityKeyL(const TDesC& aSection)
+ {
+ TWsPriorityKeyEvent event;
+
+ iWsSession->GetPriorityKey(event);
+ INFO_PRINTF1(_L("RWsSession::GetPriorityKey() call"));
+
+ TWsPriorityKeyEvent * store=NULL;
+ if ( CT_GraphicsUtil::GetWsPriorityKeyEventL(*this, aSection, KFldStore(), store) )
+ {
+ *store=event;
+ }
+ }
+
+void CT_DataWsSession::DoCmdFlush()
+ {
+ INFO_PRINTF1(_L("RWsSession::Flush() call"));
+ iWsSession->Flush();
+ }
+
+void CT_DataWsSession::DoCmdSetAutoFlush(const TDesC& aSection)
+ {
+ TBool actualFlushstate;
+ TBool setFlushState=EFalse;
+ TBool expectedFlush=EFalse;
+
+ if ( !GetBoolFromConfig(aSection, KAutoFlushState(), setFlushState) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KAutoFlushState());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ actualFlushstate = iWsSession->SetAutoFlush(setFlushState);
+ INFO_PRINTF2(_L("Flush State: %d"),actualFlushstate);
+
+ if ( !GetBoolFromConfig(aSection, KExpectFlushState(), expectedFlush) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectFlushState());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actualFlushstate!=expectedFlush)
+ {
+ ERR_PRINTF1(_L("SetAutoFlush is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetKeyboardRepeatRate(const TDesC& aSection)
+ {
+ TInt setInputInterval=iKeyboardRepeateRateInitialTime.Int();
+ GetIntFromConfig(aSection, KSetKBRepRateInterval(), setInputInterval);
+
+ TInt setInputTime=iKeyboardRepeateRateTime.Int();
+ GetIntFromConfig(aSection, KSetKBRepRateTime(), setInputTime);
+
+ TTimeIntervalMicroSeconds32 changeInitialTime(setInputInterval);
+ TTimeIntervalMicroSeconds32 changeTime(setInputTime);
+ iWsSession->SetKeyboardRepeatRate(changeInitialTime, changeTime);
+ }
+
+void CT_DataWsSession::DoCmdGetKeyboardRepeatRate(const TDesC& aSection)
+ {
+ TTimeIntervalMicroSeconds32 actualInitialTime;
+ TTimeIntervalMicroSeconds32 actualTime;
+ iWsSession->GetKeyboardRepeatRate(actualInitialTime, actualTime);
+ INFO_PRINTF2(_L("actual Interval Time: %d"), actualInitialTime.Int());
+ INFO_PRINTF2(_L("actual Time: %d"), actualTime.Int());
+
+ TInt expectInitialTime;
+ if( GetIntFromConfig(aSection, KWGGetExpectedKBInitialTime(), expectInitialTime))
+ {
+ if ( actualInitialTime.Int()!=expectInitialTime )
+ {
+ ERR_PRINTF1(_L("GetKeyboardRepeatRate is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+
+ TInt expectTime;
+ if ( GetIntFromConfig(aSection, KWGGetExpectedKBRepeatTime(), expectTime) )
+ {
+ if ( actualTime.Int()!=expectTime)
+ {
+ ERR_PRINTF1(_L("GetKeyboardRepeatRate is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+
+ TBool checkWithStore=FALSE;
+ GetBoolFromConfig(aSection, KFldCheckWithStore(), checkWithStore);
+ if ( checkWithStore )
+ {
+ if ( iKeyboardRepeateRateInitialTime!=actualInitialTime )
+ {
+ ERR_PRINTF1(_L("GetKeyboardRepeatRate is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ if ( iKeyboardRepeateRateTime!=actualTime )
+ {
+ ERR_PRINTF1(_L("GetKeyboardRepeatRate is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+
+ TBool store=FALSE;
+ GetBoolFromConfig(aSection, KFldStore(), store);
+ if ( store )
+ {
+ iKeyboardRepeateRateInitialTime=actualInitialTime;
+ iKeyboardRepeateRateTime=actualTime;
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetDoubleClick(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+ TInt setMaxInputInterval;
+ if ( !GetIntFromConfig(aSection, KDblClickInterval(), setMaxInputInterval) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KDblClickInterval());
+ SetBlockResult(EFail);
+ }
+
+ TInt setMaxDistance;
+ if ( !GetIntFromConfig(aSection, KDblClickDistance(), setMaxDistance) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KDblClickDistance());
+ SetBlockResult(EFail);
+ }
+
+ if ( dataOk )
+ {
+ TTimeIntervalMicroSeconds32 changeMaxIntervalTime(setMaxInputInterval);
+ iWsSession->SetDoubleClick(changeMaxIntervalTime, setMaxDistance);
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetDoubleClickSettings(const TDesC& aSection)
+ {
+ TTimeIntervalMicroSeconds32 actualMaxIntervalValue;
+ TInt actualMaxDistanceValue;
+ iWsSession->GetDoubleClickSettings(actualMaxIntervalValue, actualMaxDistanceValue);
+ INFO_PRINTF2(_L("Maximum interval: %d"), actualMaxIntervalValue.Int());
+ INFO_PRINTF2(_L("Maximum distance : %d"), actualMaxDistanceValue);
+
+ TInt expectMaxIntervalValue;
+ if ( !GetIntFromConfig(aSection, KExpectedDblMaxInitialTime(), expectMaxIntervalValue))
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectedDblMaxInitialTime());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actualMaxIntervalValue.Int()!=expectMaxIntervalValue )
+ {
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+
+ TInt expectMaxDistanceValue;
+ if ( !GetIntFromConfig(aSection, KExpectedDblDistance(), expectMaxDistanceValue))
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectedDblDistance());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actualMaxDistanceValue!=expectMaxDistanceValue)
+ {
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdNumWindowGroups(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+ TInt previousCount=iNumWinGroup;
+
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+ TInt priority;
+ if ( GetIntFromConfig(aSection, KWGGivenPriority(), priority) )
+ {
+ TInt screenNumber=0;
+ if ( !GetIntFromConfig(aSection, KWGSpecifieScrnNo(), screenNumber) )
+ {
+ iNumWinGroup=iWsSession->NumWindowGroups(priority);
+ INFO_PRINTF2(_L("NumWindowGroups(TInt aPriority):%d"), iNumWinGroup);
+ }
+ else
+ {
+ iNumWinGroup=iWsSession->NumWindowGroups(screenNumber, priority);
+ INFO_PRINTF2(_L("NumWindowGroups(TInt aScreenNumber, TInt aPriority):%d"), iNumWinGroup);
+ }
+ }
+ else
+#endif
+ {
+ iNumWinGroup=iWsSession->NumWindowGroups();
+ INFO_PRINTF2(_L("NumWindowGroups():%d"), iNumWinGroup);
+ }
+
+ if ( dataOk )
+ {
+ TInt difference=0;
+ if ( GetIntFromConfig(aSection, KExpectedDiff(), difference) )
+ {
+ if ( (iNumWinGroup-previousCount)!=difference )
+ {
+ ERR_PRINTF2(_L("Previous count:%d"), previousCount);
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdWindowGroupListL(const TDesC& aSection)
+ {
+ INFO_PRINTF2(_L("iNumWinGroup:%d"), iNumWinGroup);
+ RArray<RWsSession::TWindowGroupChainInfo> numWGListRArray(1);
+ CArrayFixFlat<TInt>* numWGListCArray=new (ELeave) CArrayFixFlat<TInt>(iNumWinGroup);
+ CleanupStack::PushL(numWGListCArray);
+ CleanupClosePushL(numWGListRArray);
+
+ //True:CArrayFixFlat Flase:RArray
+ TInt priority;
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+ TBool hasPriority=CT_GraphicsUtil::ReadPriorities(*this, aSection, KWGListPriority(), priority);
+#else
+ TBool hasPriority=GetIntFromConfig(aSection, KWGListPriority(), priority);
+#endif
+
+ TBool useClassArray;
+ if ( !GetBoolFromConfig(aSection, KWGUseArray(), useClassArray) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KWGUseArray());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ TInt err=KErrNone;
+ INFO_PRINTF2(_L("Use Class array:%d"), useClassArray);
+
+ if ( useClassArray )
+ {
+ if( hasPriority )
+ {
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+ TInt theScrnNum;
+ if( GetIntFromConfig(aSection, KWGScreenNumber(), theScrnNum))
+ {
+ INFO_PRINTF1(_L("WindowGroupList(CArrayFixFlat< TInt >*, TInt, TInt)"));
+ err=iWsSession->WindowGroupList(numWGListCArray, theScrnNum, priority);
+ }
+ else
+#endif
+ {
+ INFO_PRINTF1(_L("WindowGroupList(TInt, CArrayFixFlat<TInt>*)"));
+ err=iWsSession->WindowGroupList(priority, numWGListCArray);
+ }
+ }
+ else
+ {
+ INFO_PRINTF1(_L("WindowGroupList(CArrayFixFlat<TInt>*)"));
+ err=iWsSession->WindowGroupList(numWGListCArray);
+ }
+ }
+ else
+ {
+ if ( hasPriority )
+ {
+ INFO_PRINTF1(_L("WindowGroupList(TInt, RArray<RWsSession::TWindowGroupChainInfo>*)"));
+ err=iWsSession->WindowGroupList(priority, &numWGListRArray);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("WindowGroupList(RArray<RWsSession::TWindowGroupChainInfo>)"));
+ err=iWsSession->WindowGroupList(&numWGListRArray);
+ }
+ }
+
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ else
+ {
+ if ( useClassArray )
+ {
+ TInt actual=0;
+ INFO_PRINTF2(_L("numWGListCArray:%d"), numWGListCArray->Count());
+ for ( TInt index=0; index<numWGListCArray->Count(); ++index )
+ {
+ // Gets a list of identifiers of all window groups in all window server sessions
+ actual=(*numWGListCArray)[index];
+ INFO_PRINTF3(_L("CArrayFixFlat[%d]= :%d"), index, actual);
+ }
+ }
+ else
+ {
+ RWsSession::TWindowGroupChainInfo actual;
+ INFO_PRINTF2(_L("numWGListRArray:%d"), numWGListRArray.Count());
+ for ( TInt index=0; index<numWGListRArray.Count(); ++index )
+ {
+ // Gets a list of identifiers of all window groups in all window server sessions
+ actual=numWGListRArray[index];
+ INFO_PRINTF4(_L("RArray{%d] iId:%d iParentId:%d"), index, actual.iId, actual.iParentId);
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(2, numWGListCArray);
+ }
+
+void CT_DataWsSession::DoCmdGetFocusWindowGroup(const TDesC& aSection)
+ {
+ TInt actual=0;
+
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+ TInt theScrnNum=0;
+ if ( GetIntFromConfig(aSection, KWGScreenNumber(), theScrnNum) )
+ {
+ INFO_PRINTF1(_L("RWsSession::GetFocusWindowGroup(TInt aScreenNumber) call"));
+ actual=iWsSession->GetFocusWindowGroup(theScrnNum);
+ }
+ else
+#endif
+ {
+ INFO_PRINTF1(_L("RWsSession::GetFocusWindowGroup() call"));
+ actual=iWsSession->GetFocusWindowGroup();
+ }
+ INFO_PRINTF2(_L("Window Group Identifier:%d"), actual);
+
+ TInt expected=0;
+ if ( GetIntFromConfig(aSection, KFldExpected(), expected) )
+ {
+ if ( actual!=expected )
+ {
+ ERR_PRINTF1(_L("Window group identifier is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetDefaultOwningWindow(const TDesC& aSection)
+ {
+ TInt actual=0;
+ TBool dataOk=ETrue;
+
+ TInt theScrnNum=0;
+ if( GetIntFromConfig(aSection, KWGScreenNumber(), theScrnNum))
+ {
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+ INFO_PRINTF1(_L("RWsSession::GetDefaultOwningWindow(TInt aScreenNumber) call"));
+ actual=iWsSession->GetDefaultOwningWindow(theScrnNum);
+#else
+ dataOk=EFalse;
+ ERR_PRINTF1(_L("SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS Not Supported"));
+ SetBlockResult(EFail);
+#endif
+ }
+ else
+ {
+ INFO_PRINTF1(_L("RWsSession::GetDefaultOwningWindow() call"));
+ actual=iWsSession->GetDefaultOwningWindow();
+ }
+
+ if ( dataOk )
+ {
+ INFO_PRINTF2(_L("default owning window:%d"), actual);
+
+ TInt expected=0;
+ if ( !GetIntFromConfig(aSection, KFldExpected(), expected) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KFldExpected());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actual!=expected)
+ {
+ ERR_PRINTF1(_L("Default Owning Window is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetWindowGroupOrdinalPosition(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+
+ TInt inputWGId;
+ if ( !GetIntFromConfig(aSection, KWGOrdinalId(), inputWGId) )
+ {
+ TPtrC objectName;
+ if ( GetStringFromConfig(aSection, KFldWindowGroup(), objectName) )
+ {
+ INFO_PRINTF1(_L("Get CT_DataWindowGroup's wrapper. "));
+ CDataWrapperBase* wrapper = NULL;
+ wrapper = static_cast<CDataWrapperBase*>(GetDataWrapperL(objectName));
+ if(wrapper)
+ {
+ inputWGId=wrapper->GetIdentifier();
+ INFO_PRINTF2(_L("Window group's identifier is: %d"), inputWGId);
+ }
+ else
+ {
+ dataOk=EFalse;
+ ERR_PRINTF1(_L("Window group's wrapper pointer is NULL"));
+ SetBlockResult(EFail);
+ }
+ }
+ else
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KWGOrdinalId());
+ SetBlockResult(EFail);
+ }
+ }
+
+ TInt inputWGOrdinalPos;
+ if ( !GetIntFromConfig(aSection, KWGOrdinalPosition(), inputWGOrdinalPos) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KWGOrdinalPosition());
+ SetBlockResult(EFail);
+ }
+
+ if ( dataOk )
+ {
+ TInt err=iWsSession->SetWindowGroupOrdinalPosition(inputWGId, inputWGOrdinalPos);
+
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetWindowGroupClientThreadId(const TDesC& aSection)
+ {
+ TInt inputWindowGroupIdentifier=0;
+ if ( !GetIntFromConfig(aSection, KWindowGroupIdentifier(), inputWindowGroupIdentifier) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KWindowGroupIdentifier());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ TThreadId threadId;
+ TInt err=iWsSession->GetWindowGroupClientThreadId(inputWindowGroupIdentifier, threadId);
+ TUint64 actual=threadId.Id();
+ INFO_PRINTF1(_L("RWsSession::GetWindowGroupClientThreadId"));
+ INFO_PRINTF2(_L("actual ThreadId:%d"), actual);
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetWindowGroupHandle(const TDesC& aSection)
+ {
+ TInt inputWGId=0;
+ if ( !GetIntFromConfig(aSection, KInputWGId(), inputWGId) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KInputWGId());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ TInt actual=iWsSession->GetWindowGroupHandle(inputWGId);
+ INFO_PRINTF2(_L("Window group handle :%d"), actual);
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetWindowGroupOrdinalPriority(const TDesC& aSection)
+ {
+ TInt inputWGId=0;
+ if ( !GetIntFromConfig(aSection, KWGOrdinalPriority(), inputWGId))
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KWGOrdinalPriority());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ TInt actual=iWsSession->GetWindowGroupOrdinalPriority(inputWGId);
+ INFO_PRINTF2(_L("Window Group Ordinal Priority:%d"), actual);
+
+ TInt expected;
+ if ( GetIntFromConfig(aSection, KFldExpected(), expected) )
+ {
+ if ( actual!=expected )
+ {
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetWindowGroupNameFromIdentifier(const TDesC& aSection)
+ {
+ TInt inquiredWGId=0;
+ TInt rtnStatus;
+
+ if ( !GetIntFromConfig(aSection, KWGinquiredId(), inquiredWGId) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KWGinquiredId());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ TBuf<KGroupNameMaxSize> storeAWindowName;
+ INFO_PRINTF2(_L("Window Group inquired Id:%d"),inquiredWGId);
+ rtnStatus= iWsSession->GetWindowGroupNameFromIdentifier(inquiredWGId, storeAWindowName);
+ INFO_PRINTF2(_L("return status:%d"),rtnStatus);
+
+ if (rtnStatus==KErrNone)
+ {
+ INFO_PRINTF2(_L("the length of buffer:%d"),storeAWindowName.Length());
+ INFO_PRINTF1(_L("the name of window group:"));
+ INFO_PRINTF1(storeAWindowName);
+ }
+ else
+ {
+ ERR_PRINTF1(_L("GetWindowGroupNameFromIdentifier function is fail!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdFindWindowGroupIdentifier(const TDesC& aSection)
+ {
+ TInt previousId=iWindowGroupIdentifier;
+ GetIntFromConfig(aSection, KFindWGPreId(), previousId);
+ INFO_PRINTF2(_L("previous window group id:%d"), previousId);
+
+ TInt nextId;
+ TPtrC matchString;
+ if ( GetStringFromConfig(aSection, KMatchWGString(), matchString) )
+ {
+ TInt offset=0;
+ GetIntFromConfig(aSection, KFldOffset(), offset);
+ nextId=iWsSession->FindWindowGroupIdentifier(previousId, matchString, offset);
+ }
+ else
+ {
+ RThread proc;
+ TThreadId threadId=proc.Id();
+
+ TInt id;
+ if ( GetIntFromConfig(aSection, KThreadId(), id) )
+ {
+ threadId=id;
+ }
+ nextId=iWsSession->FindWindowGroupIdentifier(previousId, threadId);
+ }
+
+ if ( nextId<0 )
+ {
+ ERR_PRINTF1(_L("failed to find Window group name function !"));
+ SetError(nextId);
+ }
+ else
+ {
+ iWindowGroupIdentifier=nextId;
+ }
+ }
+
+void CT_DataWsSession::DoCmdFetchMessage(const TDesC& aSection)
+ {
+ TUid uid;
+ TPtr8 params(NULL,0);
+ TWsEvent event;
+ TInt err=iWsSession->FetchMessage(uid, params, event);
+ TInt expected;
+ if ( GetIntFromConfig(aSection, KFldExpected(), expected) )
+ {
+ if ( err!=expected )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetShadowVector(const TDesC& aSection)
+ {
+ // Get test data for command input parameter(s)
+ TPoint setPtShdwVet;
+ if ( !GetPointFromConfig(aSection, KSetShadowVec(), setPtShdwVet) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetShadowVec());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ // Execute command and log parameters
+ INFO_PRINTF1(_L("execute SetShadowVector(const TPoint &aVector)"));
+ iWsSession->SetShadowVector(setPtShdwVet);
+ }
+ }
+
+void CT_DataWsSession::DoCmdShadowVector(const TDesC& aSection)
+ {
+ // Get test data for command input parameter(s)
+ TPoint actual=iWsSession->ShadowVector();
+ INFO_PRINTF3(_L("execute ShadowVector() x=%d y=%d"), actual.iX, actual.iY);
+
+ TPoint expected;
+ if ( !GetPointFromConfig(aSection, KExpectShadowVector(), expected) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectShadowVector());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actual!=expected )
+ {
+ ERR_PRINTF1(_L("The current value of the shadow vector is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetBackgroundColor(const TDesC& aSection)
+ {
+ TRgb datColour;
+ if ( !GetRgbFromConfig(aSection, KBGColour, datColour) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KBGColour());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ // Execute command and log parameters
+ INFO_PRINTF1(_L("execute SetColor(TRgb)"));
+ iWsSession->SetBackgroundColor(datColour);
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetBackgroundColor(const TDesC& aSection)
+ {
+ // Get test data for command input parameter(s)
+ TRgb actualBgColour=iWsSession->GetBackgroundColor();
+
+ TRgb expectBgColour;
+ if ( !GetRgbFromConfig(aSection, KExpectBgColour(), expectBgColour) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectBgColour());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actualBgColour!=expectBgColour )
+ {
+ ERR_PRINTF1(_L("The current value of the shadow vector is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetSystemPointerCursor(const TDesC& aSection)
+ {
+ RWsPointerCursor sysPointerCursor=RWsPointerCursor(*iWsSession);
+
+ INFO_PRINTF1(_L("RWsSession::SetSystemPointerCursor() call"));
+ TInt inputCursorNumber=0;
+ if ( !GetIntFromConfig(aSection, KInputCursorNumber(), inputCursorNumber) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectBgColour());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("CursorNumber:%d"),inputCursorNumber);
+ TInt err=iWsSession->SetSystemPointerCursor(sysPointerCursor,inputCursorNumber);
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdClearSystemPointerCursor(const TDesC& aSection)
+ {
+ TInt inputCursorNumber=0;
+
+ if ( !GetIntFromConfig(aSection, KInputCursorNumber(), inputCursorNumber) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KInputCursorNumber());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("CursorNumber:%d"),inputCursorNumber);
+ INFO_PRINTF1(_L("RWsSession::ClearSystemPointerCursor"));
+ iWsSession->ClearSystemPointerCursor(inputCursorNumber);
+ }
+ }
+
+void CT_DataWsSession::DoCmdClaimSystemPointerCursorList()
+ {
+ INFO_PRINTF1(_L("RWsSession::ClaimSystemPointerCursorList() call"));
+ TInt err=iWsSession->ClaimSystemPointerCursorList();
+
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+
+void CT_DataWsSession::DoCmdFreeSystemPointerCursorList()
+ {
+ INFO_PRINTF1(_L("RWsSession::FreeSystemPointerCursorList() call"));
+ iWsSession->FreeSystemPointerCursorList();
+ }
+
+void CT_DataWsSession::DoCmdSetCustomTextCursorL(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+
+ TInt identifier;
+ if ( !GetIntFromConfig(aSection, KFldIdentifier(), identifier) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KFldIdentifier);
+ SetBlockResult(EFail);
+ }
+
+ CArrayFixFlat<TSpriteMember>* spriteMember = new (ELeave) CArrayFixFlat<TSpriteMember>(1);
+ if ( !CT_GraphicsUtil::GetSpriteMemberListL(*this, aSection, KFldSpriteMember, *spriteMember) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KFldSpriteMember);
+ SetBlockResult(EFail);
+ }
+ TArray<TSpriteMember> spriteArray = spriteMember->Array();
+
+ TSpriteFlags spriteFlags;
+ if ( !CT_GraphicsUtil::ReadSpriteFlags(*this, aSection, KFldSpriteFlags, spriteFlags) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KFldSpriteFlags);
+ SetBlockResult(EFail);
+ }
+
+ RWsSession::TCustomTextCursorAlignment alignment;
+ if ( !CT_GraphicsUtil::ReadCustomTextCursorAlignment(*this, aSection, KFldAlignment, alignment) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KFldAlignment);
+ SetBlockResult(EFail);
+ }
+
+ if ( dataOk )
+ {
+ INFO_PRINTF1(_L("SetCustomTextCursor(TInt, TArray< TSpriteMember >, TUint, TCustomTextCursorAlignment)"));
+ TInt err=iWsSession->SetCustomTextCursor(identifier, spriteArray, (TUint)spriteFlags, alignment);
+
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdResourceCount(const TDesC& aSection)
+ {
+ TInt resourceCount=iWsSession->ResourceCount();
+ INFO_PRINTF2(_L("RWsSession::ResourceCount() %d"), resourceCount);
+
+ // get expected difference from parameters
+ TInt expectedDifference;
+ if ( GetIntFromConfig(aSection, KExpectedDiff(), expectedDifference) )
+ {
+ TInt actualDifference=resourceCount-iResourceCount;
+ if ( actualDifference != expectedDifference )
+ {
+ ERR_PRINTF3(_L("Resource count difference is not as expected! expected: %d, actual: %d"), expectedDifference, actualDifference);
+ SetBlockResult(EFail);
+ }
+ }
+ iResourceCount = resourceCount;
+ }
+
+void CT_DataWsSession::DoCmdPasswordEntered()
+ {
+ INFO_PRINTF1(_L("RWsSession::PasswordEntered() call"));
+ iWsSession->PasswordEntered();
+ }
+
+void CT_DataWsSession::DoCmdComputeMode(const TDesC& aSection)
+ {
+ RWsSession::TComputeMode mode;
+
+ INFO_PRINTF1(_L("RWsSession::ComputeMode() call"));
+ if ( !CT_GraphicsUtil::ReadComputeMode(*this, aSection, KComputeMode(), mode) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KComputeMode());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->ComputeMode(mode);
+ }
+ }
+
+
+void CT_DataWsSession::DoCmdHeapCount(const TDesC& aSection)
+ {
+ TInt expectedCount;
+ TInt heapCount;
+
+ if ( !GetIntFromConfig(aSection, KExpectedHeapCount(), expectedCount) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectedHeapCount());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("expected count: %d"), expectedCount);
+ INFO_PRINTF1(_L("RWsSession::HeapCount() call"));
+ heapCount=iWsSession->HeapCount();
+ INFO_PRINTF2(_L("RWsSession::HeapCount(): %d"), heapCount);
+ if ( expectedCount > heapCount )
+ {
+ ERR_PRINTF3(_L("Heap count is lower than expected! expected: %d, actual: %d"), expectedCount, heapCount);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetModifierState(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+
+ TEventModifier eventModifier;
+ if ( !CT_GraphicsUtil::ReadEventModifier(*this, aSection, KInputPermanentModifier(), eventModifier) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KInputPermanentModifier());
+ SetBlockResult(EFail);
+ }
+
+ TModifierState modifierState;
+ if( !CT_GraphicsUtil::ReadModifierState(*this, aSection, KInputPermanentModifierState(), modifierState) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KInputPermanentModifierState());
+ SetBlockResult(EFail);
+ }
+
+ if ( dataOk )
+ {
+ INFO_PRINTF1(_L("RWsSession::SetModifierState"));
+ TInt err = iWsSession->SetModifierState(eventModifier, modifierState);
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetModifierState(const TDesC& aSection)
+ {
+ TInt actual=iWsSession->GetModifierState();
+ INFO_PRINTF2(_L("GetModifierState:%d"), actual);
+
+ TUint expected=0;
+ if ( CT_GraphicsUtil::ReadEventModifier(*this, aSection, KFldExpected(), expected) )
+ {
+ if ( actual!=(TInt)expected )
+ {
+ ERR_PRINTF1(_L("ModifierState is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdRequestOffEventsL(const TDesC& aSection)
+ {
+ TBool eventOffOn;
+ if ( !GetBoolFromConfig(aSection, KSetEventOffOn(), eventOffOn) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetEventOffOn());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ RWindowTreeNode* treeNodeObj=NULL;
+ TPtrC treeNodeObjectName;
+ if ( GetStringFromConfig(aSection, KWTreeNodeObj(), treeNodeObjectName) )
+ {
+ treeNodeObj = static_cast<RWindowTreeNode*>(GetDataObjectL(treeNodeObjectName));
+ }
+
+ INFO_PRINTF1(_L("RWsSession::RequestOffEvents(TBool, RWindowTreeNode*) call"));
+ TInt err=iWsSession->RequestOffEvents(eventOffOn, treeNodeObj);
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetDefModeMaxNumColors(const TDesC& aSection)
+ {
+ TInt colors;
+ TInt grays;
+
+ INFO_PRINTF1(_L("RWsSession::GetDefModeMaxNumColors(TInt &aColor, TInt &aGray) call"));
+
+ TDisplayMode displayMode;
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+ TInt theScrnNum=0;
+ if ( GetIntFromConfig(aSection, KWGScreenNumber(), theScrnNum) )
+ {
+ displayMode=iWsSession->GetDefModeMaxNumColors(theScrnNum, colors, grays);
+ }
+ else
+#endif
+ {
+ displayMode=iWsSession->GetDefModeMaxNumColors(colors, grays);
+ }
+ INFO_PRINTF4(_L("RWsSession::GetDefModeMaxNumColors() DisplayMode:%d Colors:%d Grays:%d"), displayMode, colors, grays);
+
+ TDisplayMode expectedDisplayMode;
+ if ( CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KDefDisplayMode(), expectedDisplayMode) )
+ {
+ if ( expectedDisplayMode!=displayMode )
+ {
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+ TInt expected=0;
+ if ( GetIntFromConfig(aSection, KDefModeMaxNumColor(), expected) )
+ {
+ if ( expected!=colors )
+ {
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+ if ( GetIntFromConfig(aSection, KDefModeMaxNumGray(), expected) )
+ {
+ if ( expected!=grays )
+ {
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetColorModeListL(const TDesC& aSection)
+ {
+ TBool nullPointer=EFalse;
+ GetBoolFromConfig(aSection, KFldNullPointer(), nullPointer);
+
+ CArrayFixFlat<TInt>* modeList=NULL;
+ if ( !nullPointer )
+ {
+ modeList=new (ELeave) CArrayFixFlat<TInt>(iColorModeCount);
+ }
+ CleanupStack::PushL(modeList);
+
+ TBool dataOk=ETrue;
+ TInt err=KErrNone;
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+ TInt inputScreenNo=0;
+ if ( GetIntFromConfig(aSection, KInputScrnNo(), inputScreenNo))
+ {
+ INFO_PRINTF1(_L("RWsSession::GetColorModeList(TInt aScreenNumber, CArrayFixFlat< TInt > *aModeList) call"));
+ err=iWsSession->GetColorModeList(inputScreenNo, modeList);
+ }
+ else
+#endif
+ {
+ INFO_PRINTF1(_L("RWsSession::GetColorModeList(CArrayFixFlat< TInt > *aModeList) call"));
+ err=iWsSession->GetColorModeList(modeList);
+ }
+
+ if ( err<KErrNone )
+ {
+ ERR_PRINTF2(KLogError, err);
+ SetError(err);
+ }
+ else
+ {
+ if ( dataOk )
+ {
+ if ( nullPointer )
+ {
+ iColorModeCount=err;
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Color Mode List array count:%d"), modeList->Count());
+ for ( TInt index=0; index<modeList->Count(); ++index )
+ {
+ INFO_PRINTF2(_L("Content of Color Mode List:%d"), (*modeList)[index]);
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(modeList);
+ }
+
+void CT_DataWsSession::DoCmdSetPointerCursorArea(const TDesC& aSection)
+ {
+ // Get test data for command input parameter(s)
+ TRect setRectArea;
+ if ( !GetRectFromConfig(aSection, KPtrCurPosArea, setRectArea) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KPtrCurPosArea());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ // Execute command and log parameters
+ INFO_PRINTF1(_L("execute SetPointerCursorPosition(TPoint)"));
+
+ TInt setScrnSizeMode;
+ if ( !GetIntFromConfig(aSection, KSetScrnSizeMode, setScrnSizeMode) )
+ {
+ iWsSession->SetPointerCursorArea(setRectArea);
+ }
+ else
+ {
+ iWsSession->SetPointerCursorArea(setScrnSizeMode,setRectArea);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdPointerCursorArea(const TDesC& aSection)
+ {
+ // Get test data for command input parameter(s)
+ TRect actual;
+ TInt theScreenSizeMode=0;
+ if ( !GetIntFromConfig(aSection, KSetScrnSizeMode, theScreenSizeMode) )
+ {
+ actual=iWsSession->PointerCursorArea();
+ LogRect(_L("PointerCursorArea()"), actual);
+ }
+ else
+ {
+ actual=iWsSession->PointerCursorArea(theScreenSizeMode);
+ LogRect(_L("PointerCursorArea(TInt)"), actual);
+ }
+
+ TRect expected;
+ if ( !GetRectFromConfig(aSection, KPtrCurPosArea, expected) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KPtrCurPosArea);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actual!=expected )
+ {
+ ERR_PRINTF1(KLogNotExpectedValue);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+
+void CT_DataWsSession::DoCmdSetPointerCursorMode(const TDesC& aSection)
+ {
+ TPointerCursorMode mode;
+ if ( !CT_GraphicsUtil::ReadPointerCursorMode(*this, aSection, KSetPtrCurMode(), mode) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetPtrCurMode());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->SetPointerCursorMode(mode);
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetClientCursorMode(const TDesC& aSection)
+ {
+ TPointerCursorMode mode;
+ if ( !CT_GraphicsUtil::ReadPointerCursorMode(*this, aSection, KSetCltCurMode(), mode) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetCltCurMode());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->SetClientCursorMode(mode);
+ }
+ }
+
+void CT_DataWsSession::DoCmdPointerCursorMode(const TDesC& aSection)
+ {
+ INFO_PRINTF1(_L("RWsSession::PointerCursorMode() call"));
+ TPointerCursorMode actual=iWsSession->PointerCursorMode();
+ INFO_PRINTF2(_L("actual Pointer Cursor Mode:%d"), actual);
+
+ TPointerCursorMode expected;
+ if ( !CT_GraphicsUtil::ReadPointerCursorMode(*this, aSection, KFldExpected(), expected) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KExpectPtrCursorMode());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actual!=expected )
+ {
+ ERR_PRINTF1(_L("Pointer cursor mode is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetDefaultSystemPointerCursor(const TDesC& aSection)
+ {
+ TInt inputDefCursorNumber=0;
+ INFO_PRINTF1(_L("RWsSession::SetDefaultSystemPointerCursor() call"));
+
+ if ( !GetIntFromConfig(aSection, KInputDefaultCursorNumber(), inputDefCursorNumber))
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KInputDefaultCursorNumber());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->SetDefaultSystemPointerCursor(inputDefCursorNumber);
+ }
+ }
+
+void CT_DataWsSession::DoCmdClearDefaultSystemPointerCursor()
+ {
+ INFO_PRINTF1(_L("RWsSession::ClearDefaultSystemPointerCursor() call"));
+ iWsSession->ClearDefaultSystemPointerCursor();
+ }
+
+void CT_DataWsSession::DoCmdSetPointerCursorPosition(const TDesC& aSection)
+ {
+ // Get test data for command input parameter(s)
+ TPoint ptrCurPost;
+ if ( !GetPointFromConfig(aSection, KSetPtrCurPosValue, ptrCurPost) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetPtrCurPosValue);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ // Execute command and log parameters
+ INFO_PRINTF1(_L("execute SetPointerCursorPosition(TPoint)"));
+ iWsSession->SetPointerCursorPosition(ptrCurPost);
+ }
+ }
+
+void CT_DataWsSession::DoCmdPointerCursorPosition(const TDesC& aSection)
+ {
+ // Get test data for command input parameter(s)
+ TPoint actualPtrCurPost=iWsSession->PointerCursorPosition();
+
+ TPoint expectPtrCurPost;
+ if ( !GetPointFromConfig(aSection, KTPoint, expectPtrCurPost) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KTPoint);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ // Execute command and log parameters
+ INFO_PRINTF1(_L("execute SetPointerCursorPosition(TPoint)"));
+ if ((expectPtrCurPost.iX!=expectPtrCurPost.iX)||(expectPtrCurPost.iY!=expectPtrCurPost.iY))
+ {
+ ERR_PRINTF1(_L("The cursor position is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetDefaultFadingParameters(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+ TInt setBlackMap;
+ TInt setWhiteMap;
+
+ if ( !GetIntFromConfig(aSection, KSetDefblackMapFading(), setBlackMap) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KSetDefblackMapFading);
+ SetBlockResult(EFail);
+ }
+
+ if ( !GetIntFromConfig(aSection, KSetDefwhiteMapFading(), setWhiteMap) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KSetDefwhiteMapFading);
+ SetBlockResult(EFail);
+ }
+
+ if ( dataOk )
+ {
+ iWsSession->SetDefaultFadingParameters(setBlackMap, setWhiteMap);
+ }
+ }
+
+void CT_DataWsSession::DoCmdPrepareForSwitchOff()
+ {
+ INFO_PRINTF1(_L("RWsSession::PrepareForSwitchOff() call"));
+ iWsSession->PrepareForSwitchOff();
+ }
+
+
+void CT_DataWsSession::DoCmdSetBufferSizeL(const TDesC& aSection)
+ {
+ TInt theBuffersize;
+
+ if ( !GetIntFromConfig(aSection, KSetBuffer(), theBuffersize) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetBuffer);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->SetBufferSizeL(theBuffersize);
+ INFO_PRINTF1(_L("RWsSession::SetBufferSizeL"));
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetMaxBufferSizeL(const TDesC& aSection)
+ {
+ TInt theMaxBuffersize;
+
+ if ( !GetIntFromConfig(aSection, KSetMaxBuffer(), theMaxBuffersize) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetBuffer);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->SetMaxBufferSizeL(theMaxBuffersize);
+ INFO_PRINTF1(_L("RWsSession::SetMaxBufferSizeL"));
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetSystemFaded(const TDesC& aSection)
+ {
+ TBool systemFadOffOn;
+ TInt blackMap;
+ TInt whiteMap;
+
+ if ( !GetBoolFromConfig(aSection, KSetSysFading(), systemFadOffOn) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetSysFading());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("the status of fad window :%d"),systemFadOffOn);
+ if( GetIntFromConfig(aSection, KSetblackMapFading(), blackMap))
+ {
+ if ( !GetIntFromConfig(aSection, KSetwhiteMapFading(), whiteMap) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetwhiteMapFading);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->SetSystemFaded(systemFadOffOn,blackMap,whiteMap);
+ INFO_PRINTF1(_L("RWsSession::SetSystemFaded"));
+ }
+ }
+ else
+ {
+ iWsSession->SetSystemFaded(systemFadOffOn);
+ INFO_PRINTF1(_L("RWsSession::SetSystemFaded"));
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdSetFocusScreen(const TDesC& aSection)
+ {
+ TInt theScreenNo;
+ if ( !GetIntFromConfig(aSection, KSetFocusScreen(), theScreenNo) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KSetFocusScreen());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ iWsSession->SetFocusScreen(theScreenNo);
+ INFO_PRINTF1(_L("RWsSession::SetFocusScreen"));
+ }
+ }
+
+void CT_DataWsSession::DoCmdGetFocusScreen(const TDesC& aSection)
+ {
+ TInt actual=iWsSession->GetFocusScreen();
+ INFO_PRINTF2(_L("RWsSession::GetFocusScreen()=%d"), actual);
+
+ TInt expected;
+ if ( !GetIntFromConfig(aSection, KFldExpected(), expected) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KFldExpected());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actual!=expected )
+ {
+ ERR_PRINTF1(_L("GetFocusScreen is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+
+void CT_DataWsSession::DoCmdClearAllRedrawStores()
+ {
+ INFO_PRINTF1(_L("RWsSession::ClearAllRedrawStores() call"));
+ iWsSession->ClearAllRedrawStores();
+ }
+
+
+void CT_DataWsSession::DoCmdLogCommand(const TDesC& aSection)
+ {
+ RWsSession::TLoggingCommand inputCommand;
+ if ( !CT_GraphicsUtil::ReadLoggingCommand(*this, aSection, KLogCommand(), inputCommand) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KLogCommand());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("RWsSession::LogCommand() call"));
+ iWsSession->LogCommand(inputCommand);
+ }
+ }
+
+
+void CT_DataWsSession::DoCmdLogMessage(const TDesC& aSection)
+ {
+ TPtrC theMessage;
+
+ if ( !GetStringFromConfig(aSection, KLogMessage(), theMessage) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KLogMessage());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("RWsSession::LogMessage() call"));
+ iWsSession->LogMessage(theMessage);
+ }
+ }
+
+#if defined(SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS)
+void CT_DataWsSession::DoCmdNumberOfScreens(const TDesC& aSection)
+ {
+ TInt actual=iWsSession->NumberOfScreens();
+ INFO_PRINTF2(_L("NumberOfScreens:%d"), actual);
+
+ TInt expected=0;
+ if ( !GetIntFromConfig(aSection, KFldExpected(), expected) )
+ {
+ ERR_PRINTF2(KLogMissingParameter, &KFldExpected());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ if ( actual!=expected )
+ {
+ ERR_PRINTF1(_L("NumberOfScreens is not as expected!"));
+ SetBlockResult(EFail);
+ }
+ }
+ }
+#else
+void CT_DataWsSession::DoCmdNumberOfScreens(const TDesC& /*aSection*/)
+ {
+ ERR_PRINTF1(_L("SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS Not Supported"));
+ SetBlockResult(EFail);
+ }
+#endif
+
+void CT_DataWsSession::DoCmdSimulateRawEvent(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+ TRawEvent event;
+
+ TRawEvent::TType type=TRawEvent::ENone;
+ if ( !CT_GraphicsUtil::ReadType(*this, aSection, KFldType(), type) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(_L("Missing parameter %S"), &KFldType());
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ event.Set(type);
+ }
+
+ TStdScanCode stdScanCode;
+ if ( CT_GraphicsUtil::ReadStdScanCode(*this, aSection, KFldStdScanCode(), stdScanCode) )
+ {
+ event.Set(type, stdScanCode);
+ }
+
+ TInt deviceNumber;
+ if ( GetIntFromConfig(aSection, KFldDeviceNumber, deviceNumber) )
+ {
+ event.SetDeviceNumber(deviceNumber);
+ }
+
+ TPoint pointerPos(0,0);
+ if ( GetPointFromConfig(aSection, KFldPos, pointerPos) )
+ {
+ event.Set(type, pointerPos.iX, pointerPos.iY);
+ }
+
+ TBool tip;
+ if ( GetBoolFromConfig(aSection, KFldTip, tip) )
+ {
+ event.SetTip(tip);
+ }
+
+ if ( dataOk )
+ {
+ INFO_PRINTF1(_L("RWsSession::SimulateRawEvent(TRawEvent) call"));
+ iWsSession->SimulateRawEvent(event);
+ }
+ }
+
+void CT_DataWsSession::DoCmdSimulateKeyEvent(const TDesC& aSection)
+ {
+ TBool dataOk=ETrue;
+
+ TKeyCode keyCode;
+ if ( !CT_GraphicsUtil::ReadKeyCode(*this, aSection, KFldKeyCode(), keyCode) )
+ {
+ dataOk=EFalse;
+ ERR_PRINTF2(KLogMissingParameter, &KFldKeyCode());
+ SetBlockResult(EFail);
+ }
+
+ TUint modifiers=0;
+ CT_GraphicsUtil::ReadEventModifier(*this, aSection, KFldModifiers(), modifiers);
+
+ TInt repeats=0;
+ GetIntFromConfig(aSection, KFldRepeats(), repeats);
+
+ if ( dataOk )
+ {
+ TKeyEvent event;
+
+ event.iCode=keyCode;
+ event.iScanCode=keyCode;
+ event.iModifiers=modifiers;
+ event.iRepeats=repeats;
+ INFO_PRINTF1(_L("RWsSession::SimulateKeyEvent(TKeyEvent) call"));
+ iWsSession->SimulateKeyEvent(event);
+ }
+ }
+
+/**
+ Virtual RunL - Called on completion of an asynchronous command
+ @see MTPActiveCallback
+ @param aActive Active Object that RunL has been called on
+ @pre N/A
+ @post N/A
+ @leave system wide error code
+*/
+void CT_DataWsSession::RunL(CActive* aActive, const TInt aIndex)
+ {
+ if ( aActive==iActiveEventReady )
+ {
+ RunEventReady(aIndex);
+ }
+ else if ( aActive==iActivePriorityKeyReady )
+ {
+ RunPriorityKeyReady(aIndex);
+ }
+ else if ( aActive==iActiveRedrawReady )
+ {
+ RunRedrawReady(aIndex);
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Stray signal"));
+ SetBlockResult(EFail);
+ }
+ DecOutstanding();
+ }
+
+/**
+ Virtual DoCancel - Request to cancel the asynchronous command
+ @see - MTPActiveCallback
+ @param aActive Active Object that DoCancel has been called on
+ @pre - N/A
+ @post - N/A
+ @leave system wide error code
+*/
+void CT_DataWsSession::DoCancel(CActive* aActive, const TInt aIndex)
+ {
+ if ( aActive==iActiveEventReady )
+ {
+ DoCancelEventReady(aIndex);
+ }
+ else if ( aActive==iActivePriorityKeyReady )
+ {
+ DoCancelPriorityKeyReady(aIndex);
+ }
+ else if ( aActive==iActiveRedrawReady )
+ {
+ DoCancelRedrawReady(aIndex);
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Stray signal"));
+ SetBlockResult(EFail);
+ }
+ DecOutstanding();
+ }
+
+void CT_DataWsSession::RunEventReady(const TInt aIndex)
+ {
+ TInt err=iActiveEventReady->iStatus.Int();
+ INFO_PRINTF2(_L("RunEventReady %d"), err);
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(_L("RunL Error %d"), err);
+ SetAsyncError(aIndex, err);
+ }
+ }
+
+void CT_DataWsSession::DoCancelEventReady(const TInt /*aIndex*/)
+ {
+ }
+
+void CT_DataWsSession::RunPriorityKeyReady(const TInt aIndex)
+ {
+ TInt err=iActivePriorityKeyReady->iStatus.Int();
+ INFO_PRINTF2(_L("RunPriorityKeyReady %d"), err);
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(_L("RunL Error %d"), err);
+ SetAsyncError(aIndex, err);
+ }
+ }
+
+void CT_DataWsSession::DoCancelPriorityKeyReady(const TInt /*aIndex*/)
+ {
+ }
+
+void CT_DataWsSession::RunRedrawReady(const TInt aIndex)
+ {
+ TInt err=iActiveRedrawReady->iStatus.Int();
+ INFO_PRINTF2(_L("RunRedrawReady %d"), err);
+ if ( err!=KErrNone )
+ {
+ ERR_PRINTF2(_L("RunL Error %d"), err);
+ SetAsyncError(aIndex, err);
+ }
+ }
+
+void CT_DataWsSession::DoCancelRedrawReady(const TInt /*aIndex*/)
+ {
+ }