Add MMP files to build libOpenVG_sw.lib which uses LINKAS to redirect to libOpenVG.dll (and
the same for libEGL_sw.lib and libOpenVGU_sw.lib).
Only the libEGL_sw.lib redirection isn't activated - this can't happen until there is a merged
libEGL.dll which supports the OpenWF synchronisation and also implements the graphical support functions.
The overall aim is to eliminate the *_sw.dll implementations, at least as a compile-time way of choosing
a software-only implementation.The correct way to choose is to put the right set of libraries into a ROM
with suitable renaming, and in the emulator to use the "switching DLL" technique to pick the right set.
As the Symbian Foundation doesn't have any alternative implementations, we don't need the switching DLLs
and we can build directly to the correct name.
/*
* 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_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*/)
{
}