Fix def files so that the implementation agnostic interface definition has no non-standards defined entry points, and change the eglrefimpl specific implementation to place its private entry points high up in the ordinal order space in the implementation region, not the standards based entrypoints region.
// Copyright (c) 1995-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:
// Decodes data into text - platform independent
//
//
#include "../SERVER/w32cmd.h"
#include "DEBUGLOG.H"
_LIT(LogCloseBracket,")");
_LIT(LogComma,", ");
_LIT(LogString,"%S");
_LIT(LogClose,"Close()");
_LIT(LogSpaces," ");
void TDebugLogOverflow::Overflow(TDes &aDes)
{
if (!iError) //Should never be re-entrant but just in case
{
_LIT(OverflowThreeDots,"...");
const TInt LenThreeDots=3;
iError=ETrue;
TInt length=aDes.MaxLength();
if (length>LenThreeDots)
{
length-=LenThreeDots;
if (aDes.Length()>length)
aDes.SetLength(length);
}
aDes.AppendFormat(OverflowThreeDots,this);
}
}
class TRawEventX : public TRawEvent
// For bypassing protected members of TRawEvent
{
public:
inline TUint Ticks();
inline TInt posx();
inline TInt posy();
inline TInt scanCode();
};
inline TUint TRawEventX::Ticks()
{return(iTicks);}
inline TInt TRawEventX::posx()
{return(iU.pos.x);}
inline TInt TRawEventX::posy()
{return(iU.pos.y);}
inline TInt TRawEventX::scanCode()
{return(iU.key.scanCode __REMOVE_WINS_CHARCODE);}
GLDEF_C TInt hHandleToValue(TUint32 handle)
{
return(handle&0xFFFF);
}
TDesC &TWsDecoder::CommandBuf(TInt aApp)
{
iText.Format(_L("[start of command buffer from app %d]"), aApp);
return iText;
}
TDesC &TWsDecoder::Command(TInt aClass, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
TPtrC details(commandDetails(aClass, aOpcode, aCmdData, aHandle));
iText=KNullDesC;
if (details!=KNullDesC)
iText=details;
return iText;
}
TDesC &TWsDecoder::NewClient(TUint aConnectionHandle)
{
iText.Format(_L("Client Connected %d"), aConnectionHandle);
iRequestFuncClass=ENewClientClass;
return iText;
}
TDesC &TWsDecoder::CommandReply(TInt aData)
{
iText.Format(_L("returns %d (0x%x)"), aData, aData);
return iText;
}
TDesC &TWsDecoder::CommandReplyBuf(const TDesC8 &aDes)
{
TPtrC details(replyBufDetails(iRequestFuncClass, iPrevOpcode, &aDes, NULL));
iText=KNullDesC;
if (details!=KNullDesC)
{
iText=LogSpaces;
TDebugLogTextHandler::Append(iText, details);
}
return iText;
}
TDesC &TWsDecoder::CommandReplyBuf(const TDesC16 &aDes)
{
iOverflowHandler.Reset();
TPtrC details(replyBufDetails(iRequestFuncClass, iPrevOpcode, NULL, &aDes));
iText=KNullDesC;
if (details!=KNullDesC)
{
iText=LogSpaces;
TDebugLogTextHandler::Append(iText, details);
}
return iText;
}
TDesC &TWsDecoder::SignalEvent(TInt aApp)
{
iText.Format(_L("Event signalled for App %d"),aApp);
return iText;
}
TDesC &TWsDecoder::Panic(TInt aApp, TInt aReason)
{
if (aApp==CDebugLogBase::EDummyConnectionId)
iText.Format(_L("WSERV Internal Panic (%d)"), aReason);
else
iText.Format(_L("App %d, Paniced (%d)"),aApp, aReason);
return iText;
}
void TWsDecoder::UnKnown()
{
}
void TWsDecoder::UnKnownOpcode(TBuf<LogTBufSize> &aText, TInt aOpcode)
{
aText.AppendFormat(_L("unknown function (opcode %u)"), aOpcode);
UnKnown();
}
void TWsDecoder::UnKnownReplyBuf(TBuf<LogTBufSize> &aText, TInt aOpcode)
{
aText.AppendFormat(_L("unknown reply buffer (opcode %u)"), aOpcode);
UnKnown();
}
TDesC &TWsDecoder::MiscMessage(const TDesC &aFormat,TInt aParam)
{
iText.Format(aFormat,aParam);
return iText;
}
void TWsDecoder::AppendPoint(TBuf<LogTBufSize> &aText, const TDesC8 *aReplyDes8)
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*((TPoint *)aReplyDes8->Ptr())));
aText.AppendFormat(LogString, &buf);
}
void TWsDecoder::AppendRect(TBuf<LogTBufSize> &aText, const TDesC8 *aReplyDes8)
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*((TRect *)aReplyDes8->Ptr())));
aText.AppendFormat(LogString, &buf);
}
void TWsDecoder::AppendDesc(TBuf<LogTBufSize> &aText, const TDesC8 *aReplyDes8)
{
TBuf<LogTBufSize> buf;
buf.Copy(*aReplyDes8);
aText.AppendFormat(LogString, &buf);
}
void TWsDecoder::AppendDesc(TBuf<LogTBufSize> &aText, const TDesC16 *aReplyDes16)
{
aText.AppendFormat(LogString, aReplyDes16);
}
void TWsDecoder::DecodeWindowGroup(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
aText.Format(_L("RWindowGroup[%d]::"),aHandle);
TWsWinCmdUnion pData;
pData.any=aCmdData;
switch (aOpcode)
{
case EWsWinOpReceiveFocus:
aText.AppendFormat(_L("ReceiveFocus(%d)"), pData.Bool);
break;
case EWsWinOpAutoForeground:
aText.AppendFormat(_L("AutoForeground(%d)"), pData.Bool);
break;
case EWsWinOpCancelCaptureKey:
aText.AppendFormat(_L("CancelCaptureKey(%d)"), *pData.UInt);
break;
case EWsWinOpCaptureKey:
aText.AppendFormat(_L("CaptureKey(%u, 0x%04x, 0x%04x)"),
pData.CaptureKey->key,
pData.CaptureKey->modifiers,
pData.CaptureKey->modifierMask);
break;
case EWsWinOpCancelCaptureKeyUpsAndDowns:
aText.AppendFormat(_L("CancelCaptureKeyUpsAndDowns(%d)"), *pData.UInt);
break;
case EWsWinOpCaptureKeyUpsAndDowns:
aText.AppendFormat(_L("CaptureKeyUpsAndDowns(%u, 0x%04x, 0x%04x)"),
pData.CaptureKey->key,
pData.CaptureKey->modifiers,
pData.CaptureKey->modifierMask);
break;
case EWsWinOpSetTextCursor:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.SetTextCursor->pos));
aText.AppendFormat(_L("SetTextCursor(%d, %S, {%u,%d,%d,%d,0x%08x})"),
hHandleToValue(pData.SetTextCursor->window), &buf,
pData.SetTextCursor->cursor.iType, pData.SetTextCursor->cursor.iHeight,
pData.SetTextCursor->cursor.iAscent, pData.SetTextCursor->cursor.iWidth,
pData.SetTextCursor->cursor.iFlags);
}
break;
case EWsWinOpSetTextCursorClipped:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.SetTextCursor->pos));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.SetTextCursor->rect));
aText.AppendFormat(_L("SetTextCursor(%d, %S, {%u,%d,%d,%d,0x%08x}, %S)"),
hHandleToValue(pData.SetTextCursor->window), &buf1,
pData.SetTextCursor->cursor.iType, pData.SetTextCursor->cursor.iHeight,
pData.SetTextCursor->cursor.iAscent, pData.SetTextCursor->cursor.iWidth,
pData.SetTextCursor->cursor.iFlags, &buf2);
}
break;
case EWsWinOpCancelTextCursor:
aText.AppendFormat(_L("CancelTextCursor()"));
break;
case EWsWinOpSetOrdinalPriorityAdjust:
aText.AppendFormat(_L("SetOrdinalPriorityAdjust(%d)"), *pData.Int);
break;
case EWsWinOpAddPriorityKey:
aText.AppendFormat(_L("AddPriorityKey(0x%x,0x%x,%d)"), pData.PriorityKey->modifiers, pData.PriorityKey->modifierMask, pData.PriorityKey->keycode);
break;
case EWsWinOpRemovePriorityKey:
aText.AppendFormat(_L("RemovePriorityKey(0x%x,0x%x,%d)"), pData.PriorityKey->modifiers, pData.PriorityKey->modifierMask, pData.PriorityKey->keycode);
break;
case EWsWinOpSetOrdinalPositionErr:
aText.AppendFormat(_L("SetOrdinalPositionErr(%d, %d)"), pData.OrdinalPos->pos, pData.OrdinalPos->ordinalPriority);
break;
case EWsWinOpDisableKeyClick:
aText.AppendFormat(_L("DisableKeyClick(%u)"), *pData.UInt);
break;
case EWsWinOpCaptureLongKey:
aText.AppendFormat(_L("CaptureLongKey(TTimeIntervalMicroSeconds32(%d), %u, %u, %u, %u, %d, %u)"),
pData.CaptureLongKey->delay.Int(), pData.CaptureLongKey->inputKey, pData.CaptureLongKey->outputKey,
pData.CaptureLongKey->modifierMask, pData.CaptureLongKey->modifiers, pData.CaptureLongKey->priority, pData.CaptureLongKey->flags);
break;
case EWsWinOpCancelCaptureLongKey:
aText.AppendFormat(_L("CancelCaptureLongKey(%d)"), pData.CaptureKey->key);
break;
case EWsWinOpAllowChildWindowGroup:
aText.AppendFormat(_L("AllowProcessToCreateChildWindowGroup(%d)"), *pData.Int);
break;
case EWsWinOpClearChildGroup:
aText.AppendFormat(_L("ClearChildGroup()"));
break;
case EWsWinOpSetChildGroup:
aText.AppendFormat(_L("SetChildGroup(%d)"), *pData.Int);
break;
case EWsWinOpEnableVisibilityChangeEvents:
aText.Append(_L("EnableVisibilityChangeEvents()"));
break;
case EWsWinOpDisableVisibilityChangeEvents:
aText.Append(_L("DisableVisibilityChangeEvents()"));
break;
case EWsWinOpWindowGroupId:
aText.Append(_L("WindowGroupId()"));
break;
case EWsWinOpEnableFocusChangeEvents:
aText.Append(_L("EnableFocusChangeEvents()"));
break;
case EWsWinOpDisableFocusChangeEvents:
aText.Append(_L("DisableFocusChangeEvents()"));
break;
default:
decodeWindow(aText,aOpcode,aCmdData);
break;
}
}
void TWsDecoder::DecodeClient(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
TWsClCmdUnion pData;
aText.Format(_L("RWsSession[%d]::"),aHandle);
pData.any=aCmdData;
switch (aOpcode)
{
case EWsClOpDisconnect:
aText.AppendFormat(LogClose);
break;
case EWsClOpSetHotKey:
aText.AppendFormat(_L("SetHotKey(%u, %u, 0x%04x, 0x%04x)"),
pData.SetHotKey->type,
pData.SetHotKey->keycode,
pData.SetHotKey->modifiers,
pData.SetHotKey->modifierMask);
break;
case EWsClOpClearHotKeys:
aText.AppendFormat(_L("ClearHotKeys(%d)"),*pData.UInt);
break;
case EWsClOpRestoreDefaultHotKey:
aText.AppendFormat(_L("ResetDefaultHotKey(%d)"),*pData.UInt);
break;
case EWsClOpComputeMode:
aText.AppendFormat(_L("ComputeMode(%u)"),*pData.UInt);
break;
case EWsClOpEventReady:
aText.AppendFormat(_L("EventReady(TInt *stat)"));
break;
case EWsClOpRedrawReady:
aText.AppendFormat(_L("RedrawReady(TInt *stat)"));
break;
case EWsClOpPriorityKeyReady:
aText.AppendFormat(_L("PriorityKeyReady(TInt *stat)"));
break;
case EWsClOpEventReadyCancel:
aText.AppendFormat(_L("EventReadyCancel()"));
break;
case EWsClOpRedrawReadyCancel:
aText.AppendFormat(_L("RedrawReadyCancel()"));
break;
case EWsClOpPriorityKeyReadyCancel:
aText.AppendFormat(_L("PriorityKeyReadyCancel()"));
break;
case EWsClOpGetEvent:
aText.AppendFormat(_L("GetEvent(TWsEvent *aEvent)"));
break;
case EWsClOpGetRedraw:
aText.AppendFormat(_L("GetRedraw(TWsRedrawEvent *aEvent)"));
break;
case EWsClOpGetPriorityKey:
aText.AppendFormat(_L("GetPriorityKey(TWsPriorityKeyEvent *aEvent)"));
break;
case EWsClOpCreateWindow:
case EWsClOpCreateGc:
case EWsClOpCreateWindowGroup:
case EWsClOpCreateAnimDll:
case EWsClOpCreateScreenDevice:
case EWsClOpCreateSprite:
case EWsClOpCreatePointerCursor:
case EWsClOpCreateBitmap:
case EWsClOpCreateDirectScreenAccess:
case EWsClOpCreateClick:
switch(aOpcode)
{
case EWsClOpCreateWindow:
aText.AppendFormat(_L("CreateWindow(%d,%x)"),hHandleToValue(pData.CreateWindow->parent),pData.CreateWindow->clientHandle);
break;
case EWsClOpCreateGc:
aText.AppendFormat(_L("CreateGc()"));
break;
case EWsClOpCreateWindowGroup:
aText.AppendFormat(_L("CreateWindowGroup(%x)"),pData.CreateWindow->clientHandle);
break;
case EWsClOpCreateAnimDll:
TDebugLogTextHandler::Append(aText, _L("LoadAnimDll(\""));
if (pData.LoadAnimDll && (pData.LoadAnimDll->length >= 0) && (pData.LoadAnimDll->length < LogTBufSize - 22))
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.LoadAnimDll+1), pData.LoadAnimDll->length));
else
TDebugLogTextHandler::Append(aText, _L("<INVALID DESCRIPTOR>"));
TDebugLogTextHandler::Append(aText, _L("\")"));
break;
case EWsClOpCreateScreenDevice:
aText.AppendFormat(_L("CreateScreenDevice()"));
break;
case EWsClOpCreateSprite:
aText.AppendFormat(_L("CreateSprite(...)"));
break;
case EWsClOpCreatePointerCursor:
aText.AppendFormat(_L("CreatePointerCursor(...)"));
break;
case EWsClOpCreateBitmap:
aText.AppendFormat(_L("CreateBitmap(...)"));
break;
case EWsClOpCreateDirectScreenAccess:
aText.AppendFormat(_L("CreateDirectScreenAccess()"));
break;
case EWsClOpCreateClick:
aText.AppendFormat(_L("CreateSoundPlugin()"));
break;
}
break;
case EWsClOpHeapCount:
aText.AppendFormat(_L("HeapCount()"));
break;
case EWsClOpDebugInfo:
aText.AppendFormat(_L("DebugInfo(%d,%d)"), pData.DebugInfo->iFunction, pData.DebugInfo->iParam);
break;
case EWsClOpDebugInfoReplyBuf:
aText.AppendFormat(_L("DebugInfo(%d,%d,...)"), pData.DebugInfo->iFunction, pData.DebugInfo->iParam);
break;
case EWsClOpTestInvariant:
aText.AppendFormat(_L("unimplemented opcode 'EWsClOpTestInvariant' (%u)"), aOpcode);
break;
case EWsClOpSetShadowVector:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
aText.AppendFormat(_L("SetShadowVector(%S)"), &buf);
break;
}
case EWsClOpShadowVector:
aText.Append(_L("ShadowVector()"));
break;
case EWsClOpResourceCount:
aText.Append(_L("ResourceCount()"));
break;
case EWsClOpSetKeyboardRepeatRate:
aText.Append(_L("SetKeyboardRepeatRate(...,...)"));
break;
case EWsClOpGetKeyboardRepeatRate:
aText.Append(_L("GetKeyboardRepeatRate(...,...)"));
break;
case EWsClOpSetDoubleClick:
aText.AppendFormat(_L("SetDoubleClickSettings(...,%d)"), pData.SetDoubleClick->distance);
break;
case EWsClOpGetDoubleClickSettings:
aText.Append(_L("GetDoubleClickSettings(...,...)"));
break;
case EWsClOpHeapSetFail:
aText.AppendFormat(_L("HeapSetFail(%d, %d)"), pData.HeapSetFail->type, pData.HeapSetFail->value);
break;
case EWsClOpNumWindowGroups:
aText.AppendFormat(_L("NumWindowGroups(%d)"),*pData.UInt);
break;
case EWsClOpNumWindowGroupsAllPriorities:
aText.Append(_L("NumWindowGroups()"));
break;
case EWsClOpWindowGroupList:
aText.AppendFormat(_L("WindowGroupList(...,%d,%d)"),pData.WindowGroupList->priority, pData.WindowGroupList->count);
break;
case EWsClOpWindowGroupListAllPriorities:
aText.AppendFormat(_L("WindowGroupList(...,%d)"),pData.WindowGroupList->count);
break;
case EWsClOpGetFocusWindowGroup:
aText.AppendFormat(_L("GetFocusWindowGroup(%d, ...)"), *pData.UInt);
break;
case EWsClOpGetDefaultOwningWindow:
aText.Append(_L("GetDefaultOwningWindow()"));
break;
case EWsClOpSetWindowGroupOrdinalPosition:
aText.AppendFormat(_L("SetWindowGroupOrdinalPosition(%d, %d)"),
pData.SetWindowGroupOrdinalPosition->identifier,
pData.SetWindowGroupOrdinalPosition->position);
break;
case EWsClOpGetWindowGroupHandle:
aText.AppendFormat(_L("GetWindowGroupHandle(%d)"),*pData.Int);
break;
case EWsClOpGetWindowGroupOrdinalPriority:
aText.AppendFormat(_L("GetWindowGroupOrdinalPriority(%d)"),*pData.Int);
break;
case EWsClOpGetWindowGroupClientThreadId:
aText.AppendFormat(_L("GetWindowGroupClientThreadId(%d)"),*pData.Int);
break;
case EWsClOpGetWindowGroupNameFromIdentifier:
aText.AppendFormat(_L("GetWindowGroupNameFromIdentifier(%d)"),pData.GetWindowGroupNameFromIdentifier->identifier);
break;
case EWsClOpFindWindowGroupIdentifier:
aText.AppendFormat(_L("FindWindowGroupIdentifier(%d,...,%d)"),pData.FindWindowGroupIdentifier->identifier,
pData.FindWindowGroupIdentifier->offset);
break;
case EWsClOpFindWindowGroupIdentifierThread:
aText.AppendFormat(_L("FindWindowGroupIdentifier(%d,0x%x)"),pData.FindWindowGroupIdentifierThread->identifier,
pData.FindWindowGroupIdentifierThread->threadId.Id());
break;
case EWsClOpSendMessageToWindowGroup:
aText.AppendFormat(_L("SendMessageToWindowGroup(0x%x,0x%x,...)"),pData.SendMessageToWindowGroup->identifierOrPriority,
pData.SendMessageToWindowGroup->uid, pData.SendMessageToWindowGroup->dataLength);
break;
case EWsClOpSendMessageToAllWindowGroups:
aText.AppendFormat(_L("SendMessageToAllWindowGroups(0x%x,...)"),pData.SendMessageToWindowGroup->uid, pData.SendMessageToWindowGroup->dataLength);
break;
case EWsClOpSendMessageToAllWindowGroupsPriority:
aText.AppendFormat(_L("SendMessageToAllWindowGroups(%d,0x%x,...)"),pData.SendMessageToWindowGroup->identifierOrPriority,
pData.SendMessageToWindowGroup->uid, pData.SendMessageToWindowGroup->dataLength);
break;
case EWsClOpFetchMessage:
aText.AppendFormat(_L("FetchMessage(...)"));
break;
case EWsClOpSetSystemPointerCursor:
aText.AppendFormat(_L("SetSystemPointerCursor(...,%d)"), pData.SetSystemPointerCursor->number);
break;
case EWsClOpClearSystemPointerCursor:
aText.AppendFormat(_L("ClearSystemPointerCursor(%d)"), *pData.UInt);
break;
case EWsClOpClaimSystemPointerCursorList:
aText.Append(_L("ClaimSystemPointerCursorList()"));
break;
case EWsClOpFreeSystemPointerCursorList:
aText.Append(_L("FreeSystemPointerCursorList()"));
break;
case EWsClOpLogMessage:
aText.Append(_L("LogMessage(...)"));
break;
case EWsClOpPasswordEntered:
aText.Append(_L("PasswordEntered()"));
break;
case EWsClOpPurgePointerEvents:
aText.Append(_L("PurgePointerEvents()"));
break;
case EWsClOpRawEvent:
aText.AppendFormat(_L("SimulateRawEvent(%d,%d,{{%d,%d},%d})"),((TRawEventX *)pData.RawEvent)->Type(),
((TRawEventX *)pData.RawEvent)->Ticks(),((TRawEventX *)pData.RawEvent)->posx(),
((TRawEventX *)pData.RawEvent)->posy(),((TRawEventX *)pData.RawEvent)->scanCode());
break;
case EWsClOpSendEventToWindowGroup:
aText.AppendFormat(_L("SendEventToWindowGroup(%d,"),pData.SendEventToWindowGroup->parameter);
aText.Append(eventDetails(&pData.SendEventToWindowGroup->event));
aText.Append(LogCloseBracket);
break;
case EWsClOpSetModifierState:
aText.AppendFormat(_L("SetModifierState(%d,%d)"), pData.SetModifierState->modifier, pData.SetModifierState->state);
break;
case EWsClOpGetModifierState:
aText.Append(_L("GetModifierState()"));
break;
case EWsClOpSendOffEventsToShell:
{
_LIT(LogClientSendOffEventsToShell,"RequestOffEvents(%u,%d)");
aText.AppendFormat(LogClientSendOffEventsToShell
,pData.OffEventsToShell->on,hHandleToValue(pData.OffEventsToShell->window));
}
break;
case EWsClOpGetDefModeMaxNumColors:
{
_LIT(LogClientGetDefModeMaxNumColors,"GetDefModeMaxNumColors()");
aText.Append(LogClientGetDefModeMaxNumColors);
}
break;
case EWsClOpGetColorModeList:
{
_LIT(LogClientGetColorModeList,"GetColorModeList()");
aText.Append(LogClientGetColorModeList);
}
break;
case EWsClOpKeyEvent:
{
_LIT(LogClientKeyEvent,"SimulateKeyEvent(%d)");
aText.AppendFormat(LogClientKeyEvent,pData.KeyEvent->iCode);
}
break;
case EWsClOpSendEventToAllWindowGroup:
{
_LIT(LogClientSendEventToAllWindowGroups,"SendEventToAllWindowGroups(");
aText.Append(LogClientSendEventToAllWindowGroups);
aText.Append(eventDetails(&pData.SendEventToWindowGroup->event));
aText.Append(LogCloseBracket);
}
break;
case EWsClOpSendEventToAllWindowGroupPriority:
{
_LIT(LogClientSendEventToAllWindowGroupPriority,"SendEventToAllWindowGroups(%d,");
aText.AppendFormat(LogClientSendEventToAllWindowGroupPriority,pData.SendEventToWindowGroup->parameter);
aText.Append(eventDetails(&pData.SendEventToWindowGroup->event));
aText.Append(LogCloseBracket);
}
break;
case EWsClOpSetPointerCursorArea:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.SetPointerCursorArea->area));
_LIT(LogClientSetPointerCursorArea,"SetPointerCursorArea(%d,%S)");
aText.AppendFormat(LogClientSetPointerCursorArea,pData.SetPointerCursorArea->mode,&buf);
}
break;
case EWsClOpPointerCursorArea:
{
_LIT(LogClientPointerCursorArea,"PointerCursorArea(%d)");
aText.AppendFormat(LogClientPointerCursorArea,*pData.Int);
}
break;
case EWsClOpSetPointerCursorMode:
{
_LIT(LogClientSetPointerCursorMode,"SetPointerCursorMode(%d)");
aText.AppendFormat(LogClientSetPointerCursorMode,*pData.Mode);
}
break;
case EWsClOpPointerCursorMode:
{
_LIT(LogClientPointerCursorMode,"PointerCursorMode()");
aText.Append(LogClientPointerCursorMode);
}
break;
case EWsClOpSetDefaultSystemPointerCursor:
{
_LIT(LogClientSetDefaultSystemPointerCursor,"SetDefaultSystemPointerCursor(%d)");
aText.AppendFormat(LogClientSetDefaultSystemPointerCursor,*pData.Int);
}
break;
case EWsClOpClearDefaultSystemPointerCursor:
{
_LIT(LogClientClearDefaultSystemPointerCursor,"ClearDefaultSystemPointerCursor()");
aText.Append(LogClientClearDefaultSystemPointerCursor);
}
break;
case EWsClOpSetPointerCursorPosition:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogClientSetPointerCursorPosition,"SetPointerCursorPosition(%S)");
aText.AppendFormat(LogClientSetPointerCursorPosition,&buf);
}
break;
case EWsClOpPointerCursorPosition:
{
_LIT(LogClientPointerCursorPosition,"PointerCursorPosition()");
aText.Append(LogClientPointerCursorPosition);
}
break;
case EWsClOpSetDefaultFadingParams:
{
_LIT(LogClientSetDefaultFadingParams,"SetDefaultFadingParameters(%d,%d)");
aText.AppendFormat(LogClientSetDefaultFadingParams
,WservEncoding::ExtractFirst8BitValue(*pData.UInt),WservEncoding::ExtractSecond8BitValue(*pData.UInt));
}
break;
case EWsClOpPrepareForSwitchOff:
{
_LIT(LogClientPrepareForSwitchOff,"PrepareForSwitchOff()");
aText.Append(LogClientPrepareForSwitchOff);
}
break;
case EWsClOpSetFaded:
{
_LIT(LogWinSetFade,"SetSystemFade(%d");
aText.AppendFormat(LogWinSetFade,pData.SetSystemFaded->Faded());
if (!pData.SetSystemFaded->UseDefaultMap())
{
_LIT(LogWinSetFade2,",%d,%d");
TUint8 blackMap;
TUint8 whiteMap;
pData.SetSystemFaded->GetFadingParams(blackMap,whiteMap);
aText.AppendFormat(LogWinSetFade2,blackMap,whiteMap);
}
aText.Append(LogCloseBracket);
}
break;
case EWsClOpLogCommand:
{
_LIT(LogClientLogCommand,"LogCommand(%d)");
aText.AppendFormat(LogClientLogCommand,*pData.UInt);
}
break;
case EWsClOpSendEventToOneWindowGroupPerClient:
{
_LIT(LogClientSendEventToOneWindowGroupPerClient,"SendEventToOneWindowGroupsPerClient(");
aText.Append(LogClientSendEventToOneWindowGroupPerClient);
aText.Append(eventDetails(&pData.SendEventToWindowGroup->event));
aText.Append(LogCloseBracket);
}
break;
case EWsClOpStartSetCustomTextCursor:
{
_LIT(LogClientStartSetCustomTextCursor,"StartSetCustomTextCursorL(id=0x%08x, flags=0x%08x, align=%d)");
aText.AppendFormat(LogClientStartSetCustomTextCursor, pData.CustomTextCursorData->identifier, pData.CustomTextCursorData->flags, pData.CustomTextCursorData->alignment);
}
break;
case EWsClOpCompleteSetCustomTextCursor:
{
_LIT(LogClientCompleteSetCustomTextCursor,"CompleteSetCustomTextCursorL(err=%d)");
aText.AppendFormat(LogClientCompleteSetCustomTextCursor, *pData.Int);
}
break;
#if defined(__WINS__)
case EWsClOpRemoveKeyCode:
{
_LIT(LogClientRemoveKeyCode,"RemoveKeyCode(%d)");
aText.AppendFormat(LogClientRemoveKeyCode,*pData.UInt);
}
break;
case EWsClOpSimulateXyInput:
{
_LIT(LogClientSimulateXyInput,"SimulateXyInputType(%d)");
aText.AppendFormat(LogClientSimulateXyInput,*pData.UInt);
}
break;
#endif
case EWsClOpSetBackgroundColor:
{
TShortBuf buf(TDebugLogTextHandler::FormatRgb(*pData.rgb));
_LIT(LogClientSetBackgroundColor,"SetBackgroundColor(%S)");
aText.AppendFormat(LogClientSetBackgroundColor,&buf);
}
break;
case EWsClOpGetBackgroundColor:
{
_LIT(LogClientGetBackgroundColor,"GetBackgroundColor()");
aText.AppendFormat(LogClientGetBackgroundColor);
}
break;
case EWsClOpSystemInfo:
{
_LIT(LogClientSystemInfo,"SystemInfo(%d, SSystemInfo &aSystemInfo)");
aText.AppendFormat(LogClientSystemInfo, *pData.UInt);
}
break;
case EWsClOpSetFocusScreen:
{
_LIT(LogClientSetFocusScreen,"SetFocusScreen(%d)");
aText.AppendFormat(LogClientSetFocusScreen, *pData.UInt);
}
break;
case EWsClOpGetFocusScreen:
{
_LIT(LogClientGetFocusScreen,"GetFocusScreen()");
aText.AppendFormat(LogClientGetFocusScreen);
}
break;
case EWsClOpWindowGroupListAndChain:
{
_LIT(LogClientWindowGroupListAndChain,"WindowGroupList(%d, RArray<TWindowGroupChainInfo>* aWindowList)");
aText.AppendFormat(LogClientWindowGroupListAndChain, *pData.UInt);
}
break;
case EWsClOpWindowGroupListAndChainAllPriorities:
{
_LIT(LogClientWindowGroupListAndChainAllPriorities,"WindowGroupListAndChainAllPriorities(RArray<TWindowGroupChainInfo>* aWindowList)");
aText.AppendFormat(LogClientWindowGroupListAndChainAllPriorities);
}
break;
case EWsClOpSetClientCursorMode:
{
_LIT(LogClientSetClientCursorMode,"SetClientCursorMode(%d)");
aText.AppendFormat(LogClientSetClientCursorMode, *pData.UInt);
}
break;
case EWsClOpClearAllRedrawStores:
{
_LIT(LogClientClearAllRedrawStores,"ClearAllRedrawStores()");
aText.AppendFormat(LogClientClearAllRedrawStores);
}
break;
case EWsClOpGraphicMessageReady:
{
_LIT(LogClientGraphicMessageReady,"GraphicMessageReady(%d)");
aText.AppendFormat(LogClientGraphicMessageReady, *pData.UInt);
}
break;
case EWsClOpGetGraphicMessage:
{
_LIT(LogClientGraphicMessage,"GetGraphicMessage(%d)");
aText.AppendFormat(LogClientGraphicMessage, *pData.UInt);
}
break;
case EWsClOpGraphicMessageCancel:
{
_LIT(LogClientGraphicMessageCancel,"GraphicMessageCancel()");
aText.AppendFormat(LogClientGraphicMessageCancel);
}
break;
case EWsClOpNumWindowGroupsOnScreen:
{
_LIT(LogClientNumWindowGroupsOnScreen,"NumWindowGroups(%d, %d)");
aText.AppendFormat(LogClientNumWindowGroupsOnScreen, pData.NumWinGroups->screenNumber, pData.NumWinGroups->priority);
}
break;
case EWsClOpGetNumberOfScreens:
{
_LIT(LogClientGetNumberOfScreens,"NumberOfScreens()");
aText.AppendFormat(LogClientGetNumberOfScreens);
}
break;
case EWsClOpNoFlickerFree:
{
_LIT(LogNoFlickerFree,"EWsClOpNoFlickerFree enum");
aText.AppendFormat(LogNoFlickerFree);
}
break;
case EWsClOpCreateGraphic:
{
_LIT(LogCreateGraphic,"EWsClOpCreateGraphic enum");
aText.AppendFormat(LogCreateGraphic);
}
break;
case EWsClOpSetCloseProximityThresholds:
{
_LIT(LogSetCloseProximityThresholds,"SetCloseProximityThresholds(%d, %d)");
aText.AppendFormat(LogSetCloseProximityThresholds, pData.ZThresholdPair->enterThreshold, pData.ZThresholdPair->exitThreshold);
}
break;
case EWsClOpSetHighPressureThresholds:
{
_LIT(LogSetHighPressureThresholds,"SetHighPressureThresholds(%d, %d)");
aText.AppendFormat(LogSetHighPressureThresholds, pData.ZThresholdPair->enterThreshold, pData.ZThresholdPair->exitThreshold);
}
break;
case EWsClOpGetEnterCloseProximityThreshold:
{
_LIT(LogGetEnterCloseProximityThreshold,"EWsClOpGetEnterCloseProximityThreshold()");
aText.AppendFormat(LogGetEnterCloseProximityThreshold);
}
break;
case EWsClOpGetExitCloseProximityThreshold:
{
_LIT(LogGetExitCloseProximityThreshold,"EWsClOpGetExitCloseProximityThreshold()");
aText.AppendFormat(LogGetExitCloseProximityThreshold);
}
break;
case EWsClOpGetEnterHighPressureThreshold:
{
_LIT(LogGetEnterHighPressureThreshold,"EWsClOpGetEnterHighPressureThreshold()");
aText.AppendFormat(LogGetEnterHighPressureThreshold);
}
break;
case EWsClOpGetExitHighPressureThreshold:
{
_LIT(LogGetExitHighPressureThreshold,"EWsClOpGetExitHighPressureThreshold()");
aText.AppendFormat(LogGetExitHighPressureThreshold);
}
break;
case EWsClOpLastEnumValue:
{
_LIT(LogLastEnumValue,"EWsClOpLastEnumValue enum");
aText.AppendFormat(LogLastEnumValue);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeWindow(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
_LIT(LogWindow,"RWindow[%d]::");
aText.Format(LogWindow,aHandle);
decodeWindow(aText,aOpcode,aCmdData);
}
void TWsDecoder::decodeWindow(TBuf<LogTBufSize> &aText,TInt aOpcode,const TAny *aData)
{
TWsWinCmdUnion pData;
pData.any=aData;
switch (aOpcode)
{
case EWsWinOpFree:
aText.AppendFormat(LogClose);
break;
case EWsWinOpSetExtent:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.SetEx->pos));
TShortBuf buf2(TDebugLogTextHandler::FormatSize(pData.SetEx->size));
aText.AppendFormat(_L("SetExtent(%S, %S)"), &buf1, &buf2);
}
break;
case EWsWinOpSetExtentErr:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.SetEx->pos));
TShortBuf buf2(TDebugLogTextHandler::FormatSize(pData.SetEx->size));
aText.AppendFormat(_L("SetExtentError(%S, %S)"), &buf1, &buf2);
}
break;
case EWsWinOpOrdinalPosition:
aText.AppendFormat(_L("OrdinalPosition()"));
break;
case EWsWinOpFullOrdinalPosition:
aText.AppendFormat(_L("FullOrdinalPosition()"));
break;
case EWsWinOpSetOrdinalPosition:
aText.AppendFormat(_L("SetOrdinalPosition(%d)"),*pData.Int);
break;
case EWsWinOpSetOrdinalPositionPri:
aText.AppendFormat(_L("SetOrdinalPosition(%d,%d)"), pData.OrdinalPos->pos, pData.OrdinalPos->ordinalPriority);
break;
case EWsWinOpSetPos:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.pos));
aText.AppendFormat(_L("SetPosition(%S)"),&buf);
}
break;
case EWsWinOpSetSizeErr:
{
TShortBuf buf(TDebugLogTextHandler::FormatSize(*pData.size));
aText.AppendFormat(_L("SetSizeErr(%S)"), &buf);
}
break;
case EWsWinOpSetSize:
{
TShortBuf buf(TDebugLogTextHandler::FormatSize(*pData.size));
aText.AppendFormat(_L("SetSize(%S)"), &buf);
}
break;
case EWsWinOpPosition:
aText.AppendFormat(_L("Position()"));
break;
case EWsWinOpAbsPosition:
aText.AppendFormat(_L("AbsPosition()"));
break;
case EWsWinOpSize:
aText.AppendFormat(_L("Size()"));
break;
case EWsWinOpActivate:
aText.AppendFormat(_L("Activate()"));
break;
case EWsWinOpInvalidate:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*pData.rect));
aText.AppendFormat(_L("Invalidate(%S)"), &buf);
}
break;
case EWsWinOpInvalidateFull:
aText.AppendFormat(_L("Invalidate()"));
break;
case EWsWinOpBeginRedraw:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*pData.rect));
aText.AppendFormat(_L("BeginRedraw(%S)"), &buf);
}
break;
case EWsWinOpBeginRedrawFull:
aText.AppendFormat(_L("BeginRedraw()"));
break;
case EWsWinOpEndRedraw:
aText.AppendFormat(_L("EndRedraw()"));
break;
case EWsWinOpTestInvariant:
aText.AppendFormat(_L("__TestInvariant()"));
break;
case EWsWinOpParent:
aText.AppendFormat(_L("Parent()"));
break;
case EWsWinOpNextSibling:
aText.AppendFormat(_L("NextSibling()"));
break;
case EWsWinOpPrevSibling:
aText.AppendFormat(_L("PrevSibling()"));
break;
case EWsWinOpChild:
aText.AppendFormat(_L("Child()"));
break;
case EWsWinOpInquireOffset:
aText.AppendFormat(_L("InquireOffset(%d)"),hHandleToValue(*pData.UInt));
break;
case EWsWinOpPointerFilter:
aText.AppendFormat(_L("PointerFilter(0x%08x)"), *pData.UInt);
break;
case EWsWinOpSetPointerCapture:
aText.AppendFormat(_L("SetPointerCapture(%u)"), *pData.UInt);
break;
case EWsWinOpSetPointerGrab:
aText.AppendFormat(_L("SetPointerGrab(%u)"), *pData.UInt);
break;
case EWsWinOpSetNoBackgroundColor:
aText.Append(_L("SetBackgroundColor()"));
break;
case EWsWinOpSetBackgroundColor:
{
TLongBuf buf(TDebugLogTextHandler::FormatRgb(*pData.rgb));
aText.AppendFormat(_L("SetBackgroundColor(%S)"), &buf);
}
break;
case EWsWinOpSetColor:
{
TLongBuf buf(TDebugLogTextHandler::FormatRgb(*pData.rgb));
aText.AppendFormat(_L("SetColor(%S)"), &buf);
}
break;
case EWsWinOpSetShadowHeight:
aText.AppendFormat(_L("SetShadowHeight(%d)"), *pData.Int);
break;
case EWsWinOpShadowDisabled:
{
TShortBuf buf(TDebugLogTextHandler::FormatBool(*pData.Bool));
aText.AppendFormat(_L("SetShadowDisabled(%S)"), &buf);
}
break;
case EWsWinOpSetVisible:
{
TShortBuf buf(TDebugLogTextHandler::FormatBool(*pData.Bool));
aText.AppendFormat(_L("SetVisible(%S)"), &buf);
}
break;
case EWsWinOpUpdateScreen:
aText.Append(_L("UpdateScreen()"));
break;
case EWsWinOpUpdateScreenRegion:
aText.Append(_L("UpdateScreenRegion(TRegion(...))"));
break;
case EWsWinOpMaintainBackup:
aText.Append(_L("MaintainBackup()"));
break;
case EWsWinOpGetInvalidRegion:
aText.Append(_L("GetInvalidRegion(...)"));
break;
case EWsWinOpGetInvalidRegionCount:
aText.Append(_L("GetInvalidRegionCount()"));
break;
case EWsWinOpScroll:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.ScrollRect->offset));
aText.AppendFormat(_L("Scroll(%S)"), &buf);
}
break;
case EWsWinOpScrollClip:
{
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.ScrollRect->clip));
TShortBuf buf2(TDebugLogTextHandler::FormatPoint(pData.ScrollRect->offset));
aText.AppendFormat(_L("Scroll(%S, %S)"), &buf1, &buf2);
}
break;
case EWsWinOpScrollRect:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.ScrollRect->offset));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.ScrollRect->rect));
aText.AppendFormat(_L("Scroll(%S, %S)"), &buf1, &buf2);
}
break;
case EWsWinOpScrollClipRect:
{
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.ScrollRect->clip));
TShortBuf buf2(TDebugLogTextHandler::FormatPoint(pData.ScrollRect->offset));
TLongBuf buf3(TDebugLogTextHandler::FormatRect(pData.ScrollRect->rect));
aText.AppendFormat(_L("Scroll(%S, %S, %S)"), &buf1, &buf2, &buf3);
}
break;
case EWsWinOpBitmapHandle:
aText.Append(_L("BitmapHandle()"));
break;
case EWsWinOpUpdateBackupBitmap:
aText.Append(_L("UpdateBackupBitmap()"));
break;
case EWsWinOpRequiredDisplayMode:
aText.AppendFormat(_L("SetRequiredDisplayMode(%d)"), *pData.UInt);
break;
case EWsWinOpSetCornerType:
aText.AppendFormat(_L("SetCornerType(%d)"), *pData.UInt);
break;
case EWsWinOpSetShape:
aText.AppendFormat(_L("SetWindowShape(%d rects)"), pData.SetShape->count);
break;
case EWsWinOpSetName:
aText.Append(_L("SetName(\"...\")"));
break;
case EWsWinOpName:
aText.Append(_L("Name()"));
break;
case EWsWinOpSetOwningWindowGroup:
aText.AppendFormat(_L("SetOwningWindowGroup(%d)"),*pData.Int);
break;
case EWsWinOpDefaultOwningWindow:
aText.Append(_L("DefaultOwningWindow()"));
break;
case EWsWinOpEnableOnEvents:
aText.AppendFormat(_L("EnableOnEvents(%d)"),*pData.Int);
break;
case EWsWinOpDisableOnEvents:
aText.Append(_L("DisableOnEvents()"));
break;
case EWsWinOpEnableErrorMessages:
aText.AppendFormat(_L("EnableErrorMessages(%d)"),*pData.Int);
break;
case EWsWinOpDisableErrorMessages:
aText.Append(_L("DisableErrorMessages()"));
break;
case EWsWinOpEnableModifierChangedEvents:
aText.Append(_L("EnableModifierChangedEvents()"));
break;
case EWsWinOpDisableModifierChangedEvents:
aText.Append(_L("DisableModifierChangedEvents()"));
break;
case EWsWinOpEnableGroupChangeEvents:
aText.Append(_L("EnableGroupChangeEvents()"));
break;
case EWsWinOpDisableGroupChangeEvents:
aText.Append(_L("DisableGroupChangeEvents()"));
break;
case EWsWinOpRequestPointerRepeatEvent:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.RequestPointerRepeatEvent->rect));
aText.AppendFormat(_L("RequestPointerRepeatEvent(TTimeIntervalMicroSeconds32(%d), %S)"),
pData.RequestPointerRepeatEvent->time.Int(), &buf);
}
break;
case EWsWinOpCancelPointerRepeatEventRequest:
aText.Append(_L("CancelPointerRepeatEventRequest()"));
break;
case EWsWinOpSetPointerCursor:
aText.AppendFormat(_L("SetPointerCursor(%d)"),*pData.UInt);
break;
case EWsWinOpSetCustomPointerCursor:
aText.AppendFormat(_L("SetCustomPointerCursor(%d)"),*pData.UInt);
break;
case EWsWinOpPasswordWindow:
aText.AppendFormat(_L("PasswordWindow(%d)"),*pData.PasswordMode);
break;
case EWsWinOpAddKeyRect:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.AddKeyRect->rect));
aText.AppendFormat(_L("AddKeyRect(%S,%d,%d)"),&buf,pData.AddKeyRect->scanCode,pData.AddKeyRect->activatedByPointerSwitchOn);
}
break;
case EWsWinOpRemoveAllKeyRects:
aText.Append(_L("RemoveAllKeyRects()"));
break;
case EWsWinOpAllocPointerMoveBuffer:
aText.AppendFormat(_L("AllocPointerMoveBuffer(%d,%d)"),pData.AllocPointerMoveBuffer->maxNumPoints,pData.AllocPointerMoveBuffer->flags);
break;
case EWsWinOpFreePointerMoveBuffer:
aText.Append(_L("FreePointerMoveBuffer()"));
break;
case EWsWinOpEnablePointerMoveBuffer:
aText.Append(_L("EnablePointerMoveBuffer()"));
break;
case EWsWinOpDisablePointerMoveBuffer:
aText.Append(_L("DisablePointerMoveBuffer()"));
break;
case EWsWinOpRetrievePointerMoveBuffer:
aText.Append(_L("RetrievePointerMoveBuffer(...)"));
break;
case EWsWinOpDiscardPointerMoveBuffer:
aText.Append(_L("DiscardPointerMoveBuffer()"));
break;
case EWsWinOpEnableBackup:
aText.Append(_L("EnableBackup()"));
break;
case EWsWinOpClaimPointerGrab:
aText.Append(_L("ClaimPointerGrab()"));
break;
case EWsWinOpIdentifier:
aText.Append(_L("Identifier()"));
break;
case EWsWinOpSetFade:
{
_LIT(LogWinSetFade,"SetFade(%d,%d");
aText.AppendFormat(LogWinSetFade,pData.SetFaded->Faded(),pData.SetFaded->IncludeChildren());
if (!pData.SetFaded->UseDefaultMap())
{
_LIT(LogWinSetFade2,",%d,%d");
TUint8 blackMap;
TUint8 whiteMap;
pData.SetFaded->GetFadingParams(blackMap,whiteMap);
aText.AppendFormat(LogWinSetFade2,blackMap,whiteMap);
}
aText.Append(LogCloseBracket);
}
break;
case EWsWinOpSetNonFading:
{
_LIT(LogWinSetNonFading,"SetNonFading(%d)");
aText.AppendFormat(LogWinSetNonFading,*(pData.Bool));
}
break;
case EWsWinOpFadeBehind:
{
_LIT(LogWinFadeBehind,"FadeBehind(%d)");
aText.AppendFormat(LogWinFadeBehind,*(pData.Bool));
}
break;
case EWsWinOpEnableScreenChangeEvents:
{
_LIT(LogWinEnableScreenChangeEvents,"EnableScreenChangeEvents()");
aText.Append(LogWinEnableScreenChangeEvents);
}
break;
case EWsWinOpDisableScreenChangeEvents:
{
_LIT(LogWinDisableScreenChangeEvents,"DisableScreenChangeEvents()");
aText.Append(LogWinDisableScreenChangeEvents);
}
break;
case EWsWinOpSendPointerEvent:
{
_LIT(LogWinSendPointerEvent,"SimulatePointerEvent(");
aText.Append(LogWinSendPointerEvent);
aText.Append(eventDetails(pData.RawEvent));
aText.Append(LogCloseBracket);
}
break;
case EWsWinOpSendAdvancedPointerEvent:
{
_LIT(LogWinSendPointerEvent,"SimulateAdvancedPointerEvent(");
aText.Append(LogWinSendPointerEvent);
aText.Append(eventDetails(pData.RawEvent));
aText.Append(LogCloseBracket);
}
break;
case EWsWinOpGetDisplayMode:
{
_LIT(LogWinGetDisplayMode,"GetDisplayMode()");
aText.Append(LogWinGetDisplayMode);
}
break;
case EWsWinOpGetIsFaded:
{
_LIT(LogWinIsFaded,"IsFaded()");
aText.Append(LogWinIsFaded);
}
break;
case EWsWinOpGetIsNonFading:
{
_LIT(LogWinIsNonFading,"IsNonFading()");
aText.Append(LogWinIsNonFading);
}
break;
case EWsWinOpOrdinalPriority:
{
_LIT(LogWinOrdinalPriority,"OrdinalPriority()");
aText.Append(LogWinOrdinalPriority);
}
break;
case EWsWinOpClearPointerCursor:
{
_LIT(LogWinClearPointerCursor,"ClearPointerCursor()");
aText.Append(LogWinClearPointerCursor);
}
break;
case EWsWinOpEnableGroupListChangeEvents:
{
_LIT(LogWinEnableGroupListChangeEvents,"EnableGroupListChangeEvents()");
aText.Append(LogWinEnableGroupListChangeEvents);
}
break;
case EWsWinOpDisableGroupListChangeEvents:
{
_LIT(LogWinDisableGroupListChangeEvents,"DisableGroupListChangeEvents()");
aText.Append(LogWinDisableGroupListChangeEvents);
}
break;
case EWsWinOpHandleTransparencyUpdate:
{
_LIT(LogWinHandleTransparencyUpdate,"HandleTransparencyUpdate()");
aText.Append(LogWinHandleTransparencyUpdate);
}
break;
case EWsWinOpSetTransparencyFactor:
{
_LIT(LogWinSetTransparencyFactor,"SetTransparencyFactor()");
aText.Append(LogWinSetTransparencyFactor);
}
break;
case EWsWinOpSetTransparencyBitmap:
{
_LIT(LogWinSetTransparencyBitmap,"SetTransparencyBitmap()");
aText.Append(LogWinSetTransparencyBitmap);
}
break;
case EWsWinOpSetTransparencyBitmapCWs:
{
_LIT(LogWinSetTransparencyWsBitmap,"SetTransparencyWsBitmap()");
aText.Append(LogWinSetTransparencyWsBitmap);
}
break;
case EWsWinOpSetTransparencyAlphaChannel:
{
_LIT(LogWinSetTransparencyAlphaChannel,"SetTransparencyAlphaChannel()");
aText.Append(LogWinSetTransparencyAlphaChannel);
}
break;
case EWsWinOpMoveToGroup:
{
_LIT(LogWinMoveToGroup,"MoveToGroup(%d)");
aText.AppendFormat(LogWinMoveToGroup, pData.Int);
}
break;
case EWsWinOpStoreDrawCommands:
{
_LIT(LogWinStoreDrawCommands,"EnableRedrawStore(%u)");
aText.AppendFormat(LogWinStoreDrawCommands, pData.Bool);
}
break;
case EWsWinOpSetPointerCapturePriority:
{
_LIT(LogWinSetPointerCapturePriority,"SetPointerCapturePriority(%d)");
aText.AppendFormat(LogWinSetPointerCapturePriority, pData.Int);
}
break;
case EWsWinOpGetPointerCapturePriority:
{
_LIT(LogWinGetPointerCapturePriority,"GetPointerCapturePriority()");
aText.Append(LogWinGetPointerCapturePriority);
}
break;
case EWsWinOpSetTransparentRegion:
{
_LIT(LogWinSetTransparentRegion,"SetTransparentRegion(%d rects)");
aText.AppendFormat(LogWinSetTransparentRegion, pData.SetShape->count);
}
break;
case EWsWinOpSetTransparencyPolicy:
{
_LIT(LogWinSetTransparentPolicy,"SetTransparencyPolicy(TransparencyPolicy= %d)");
aText.AppendFormat(LogWinSetTransparentPolicy, pData.Int);
}
break;
case EWsWinOpIsRedrawStoreEnabled:
{
_LIT(LogWinIsRedrawStoreEnabled,"IsRedrawStoreEnabled()");
aText.Append(LogWinIsRedrawStoreEnabled);
}
break;
case EWsWinOpEnableOSB:
{
_LIT(LogOSBEnabled,"EWsWinOpEnableOSB enum");
aText.Append(LogOSBEnabled);
}
break;
case EWsWinOpDisableOSB:
{
_LIT(LogOSBDisabled,"EWsWinOpDisableOSB enum");
aText.Append(LogOSBDisabled);
}
break;
case EWsWinOpClientHandle:
{
_LIT(LogClientHandle,"ClientHandle()");
aText.AppendFormat(LogClientHandle);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
//#pragma check_stack(on)
void TWsDecoder::DecodeGc(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
_LIT(LogGc,"RGc[%d]::");
aText.Format(LogGc,aHandle);
if (aOpcode<EWsGcOpGdiBlt2)
{
if (aOpcode<EWsGcOpDrawPolyLineContinued)
DecodeGc1(aText,aOpcode,aCmdData);
else
DecodeGc2(aText,aOpcode,aCmdData);
}
else
DecodeGc3(aText,aOpcode,aCmdData);
}
void TWsDecoder::DecodeGc1(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData)
{
TWsGcCmdUnion pData;
pData.any=aCmdData;
switch (aOpcode)
{
case EWsGcOpFree:
aText.AppendFormat(LogClose);
break;
case EWsGcOpActivate:
{
_LIT(LogGcActivate,"Activate(%d)");
aText.AppendFormat(LogGcActivate,hHandleToValue(*pData.UInt));
}
break;
case EWsGcOpDeactivate:
{
_LIT(LogGcDeactivate,"Deactivate()");
aText.AppendFormat(LogGcDeactivate);
}
break;
case EWsGcOpDrawLine:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.DrawLine->pnt1));
TShortBuf buf2(TDebugLogTextHandler::FormatPoint(pData.DrawLine->pnt2));
_LIT(LogGcDrawLine,"DrawLine(%S, %S)");
aText.AppendFormat(LogGcDrawLine, &buf1, &buf2);
}
break;
case EWsGcOpSetBrushStyle:
{
_LIT(LogGcSetBrushStyle,"SetBrushStyle(%u)");
aText.AppendFormat(LogGcSetBrushStyle,*pData.UInt);
}
break;
case EWsGcOpPlot:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcPlot,"Plot(%S)");
aText.AppendFormat(LogGcPlot, &buf);
}
break;
case EWsGcOpSetPenColor:
{
TLongBuf buf(TDebugLogTextHandler::FormatRgb(*pData.rgb));
_LIT(LogGcSetPenColor,"SetPenColor(%S)");
aText.AppendFormat(LogGcSetPenColor,&buf);
}
break;
case EWsGcOpSetBrushColor:
{
TLongBuf buf(TDebugLogTextHandler::FormatRgb(*pData.rgb));
_LIT(LogGcSetBrushColor,"SetBrushColor(%S)");
aText.AppendFormat(LogGcSetBrushColor,&buf);
}
break;
case EWsGcOpSetPenSize:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcSetPenSize,"SetPenSize(%S)");
aText.AppendFormat(LogGcSetPenSize,&buf);
}
break;
case EWsGcOpSetPenStyle:
{
_LIT(LogGcSetPenStyle,"SetPenStyle(%d)");
aText.AppendFormat(LogGcSetPenStyle,*pData.UInt);
}
break;
case EWsGcOpSetClippingRegion:
{
_LIT(LogGcSetClippingRegion,"SetClippingRegion(...)");
aText.Append(LogGcSetClippingRegion);
}
break;
case EWsGcOpCancelClippingRegion:
{
_LIT(LogGcCancelClippingRegion,"CancelClippingRegion()");
aText.Append(LogGcCancelClippingRegion);
}
break;
case EWsGcOpSetClippingRect:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*pData.Rect));
_LIT(LogGcSetClippingRect,"SetClippingRect(%S)");
aText.AppendFormat(LogGcSetClippingRect,&buf);
}
break;
case EWsGcOpCancelClippingRect:
{
_LIT(LogGcCancelClippingRect,"CancelClippingRect()");
aText.Append(LogGcCancelClippingRect);
}
break;
case EWsGcOpDrawTo:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcDrawTo,"DrawTo(%S)");
aText.AppendFormat(LogGcDrawTo,&buf);
}
break;
case EWsGcOpDrawBy:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcDrawBy,"DrawBy(%S)");
aText.AppendFormat(LogGcDrawBy,&buf);
}
break;
case EWsGcOpDrawPolyLine:
{
_LIT(LogGcDrawPolyLine,"DrawPolyLine(%d...)");
aText.AppendFormat(LogGcDrawPolyLine,pData.PolyLine->numPoints);
}
break;
case EWsGcOpDrawPolyLineContinued:
{
_LIT(LogGcDrawPolyLineContinued,"DrawPolyLineContinued(%d...)");
aText.AppendFormat(LogGcDrawPolyLineContinued,pData.PolyLine->numPoints);
}
break;
case EWsGcOpUseBrushPattern:
{
_LIT(LogGcUseBrushPattern,"UseBrushPattern({0x%x})");
aText.AppendFormat(LogGcUseBrushPattern,hHandleToValue(*pData.handle));
}
break;
case EWsGcOpDrawArc:
{
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.ArcOrPie->rect));
TShortBuf buf2(TDebugLogTextHandler::FormatPoint(pData.ArcOrPie->start));
TShortBuf buf3(TDebugLogTextHandler::FormatPoint(pData.ArcOrPie->end));
_LIT(LogGcDrawArc,"DrawArc(%S,%S,%S)");
aText.AppendFormat(LogGcDrawArc,&buf1,&buf2,&buf3);
}
break;
case EWsGcOpSetWordJustification:
{
_LIT(LogGcSetWordJustification,"SetWordJustification(%d,%d)");
aText.AppendFormat(LogGcSetWordJustification,pData.SetJustification->excessWidth,pData.SetJustification->numGaps);
}
break;
case EWsGcOpSetCharJustification:
{
_LIT(LogGcSetCharJustification,"SetCharJustification(%d,%d)");
aText.AppendFormat(LogGcSetCharJustification,pData.SetJustification->excessWidth,pData.SetJustification->numGaps);
}
break;
case EWsGcOpSetBrushOrigin:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
aText.AppendFormat(_L("SetBrushOrigin(%S)"), &buf);
}
break;
case EWsGcOpDiscardBrushPattern:
{
_LIT(LogGcDiscardBrushPattern,"DiscardBrushPattern()");
aText.Append(LogGcDiscardBrushPattern);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeGc2(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData)
{
TWsGcCmdUnion pData;
pData.any=aCmdData;
switch (aOpcode)
{
case EWsGcOpDrawText:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.DrawText->pos));
_LIT(LogGcDrawText1,"DrawText(\"");
TDebugLogTextHandler::Append(aText, LogGcDrawText1);
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.DrawText+1), pData.DrawText->length));
_LIT(LogGcDrawText2,"\", %S)");
aText.AppendFormat(LogGcDrawText2,&iOverflowHandler,&buf);
}
break;
case EWsGcOpDrawTextVertical:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.DrawTextVertical->pos));
_LIT(LogGcDrawTextVertical1,"DrawTextVertical(\"");
TDebugLogTextHandler::Append(aText, LogGcDrawTextVertical1);
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.DrawTextVertical+1), pData.DrawTextVertical->length));
_LIT(LogGcDrawTextVertical2,"\", %S, %d)");
aText.AppendFormat(LogGcDrawTextVertical2,&iOverflowHandler,&buf,pData.DrawTextVertical->up);
}
break;
case EWsGcOpDrawTextVerticalPtr:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.DrawTextVertical->pos));
_LIT(LogGcDrawTextVertical1,"DrawTextVertical(...");
TDebugLogTextHandler::Append(aText, LogGcDrawTextVertical1);
_LIT(LogGcDrawTextVertical2,", %S, %d)");
aText.AppendFormat(LogGcDrawTextVertical2,&iOverflowHandler,&buf,pData.DrawTextVertical->up);
}
break;
case EWsGcOpDrawTextPtr:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.DrawText->pos));
_LIT(LogGcDrawText1,"DrawText(...");
TDebugLogTextHandler::Append(aText, LogGcDrawText1);
_LIT(LogGcDrawText2,",%S)");
aText.AppendFormat(LogGcDrawText2,&iOverflowHandler,&buf);
}
break;
case EWsGcOpDrawBoxTextOptimised1:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.BoxTextO1->box));
_LIT(LogGcDrawText1,"DrawText(\"");
aText.Append(LogGcDrawText1);
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.BoxTextO1+1), pData.BoxTextO1->length));
_LIT(LogGcDrawText2,"\", %S, %d, %d, 0)");
aText.AppendFormat(LogGcDrawText2,&iOverflowHandler, &buf,
pData.BoxTextO1->baselineOffset,CGraphicsContext::ELeft);
}
break;
case EWsGcOpDrawBoxTextOptimised2:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.BoxTextO2->box));
_LIT(LogGcDrawText1,"DrawText(\"");
aText.Append(LogGcDrawText1);
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.BoxTextO2+1), pData.BoxTextO2->length));
_LIT(LogGcDrawText2,"\", %S, %d, %d, %d)");
aText.AppendFormat(LogGcDrawText2,&iOverflowHandler, &buf, pData.BoxTextO2->baselineOffset,
pData.BoxTextO2->horiz, pData.BoxTextO2->leftMrg);
}
break;
case EWsGcOpDrawBoxTextVertical:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.DrawBoxTextVertical->box));
_LIT(LogGcDrawTextVertical1,"DrawTextVertical(\"");
aText.Append(LogGcDrawTextVertical1);
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.DrawBoxTextVertical+1), pData.DrawBoxTextVertical->length));
_LIT(LogGcDrawTextVertical2,"\", %S, %d, %d, %d, %d)");
aText.AppendFormat(LogGcDrawTextVertical2,&iOverflowHandler, &buf,
pData.DrawBoxTextVertical->baselineOffset, pData.DrawBoxTextVertical->up,
pData.DrawBoxTextVertical->vert, pData.DrawBoxTextVertical->margin);
}
break;
case EWsGcOpDrawBoxTextPtr:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.BoxText->box));
_LIT(LogGcDrawText1,"DrawText(...");
TDebugLogTextHandler::Append(aText, LogGcDrawText1);
_LIT(LogGcDrawText2,", %S, %d, %d, %d)");
aText.AppendFormat(LogGcDrawText2,&iOverflowHandler, &buf, pData.BoxText->baselineOffset,
pData.BoxText->horiz, pData.BoxText->leftMrg);
}
break;
case EWsGcOpDrawBoxTextVerticalPtr:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.DrawBoxTextVertical->box));
_LIT(LogGcDrawTextVertical1,"DrawTextVertical(...");
aText.Append(LogGcDrawTextVertical1);
_LIT(LogGcDrawTextVertical2,", %S, %d, %d, %d, %d)");
aText.AppendFormat(LogGcDrawTextVertical2,&iOverflowHandler,&buf,
pData.DrawBoxTextVertical->baselineOffset, pData.DrawBoxTextVertical->up,
pData.DrawBoxTextVertical->vert, pData.DrawBoxTextVertical->margin);
}
break;
case EWsGcOpCopyRect:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.CopyRect->pos));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.CopyRect->rect));
_LIT(LogGcCopyRect,"CopyRect(%S, %S)");
aText.AppendFormat(LogGcCopyRect,&buf1,&buf2);
}
break;
case EWsGcOpDrawEllipse:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*pData.Rect));
_LIT(LogGcDrawEllipse,"DrawEllipse(%S)");
aText.AppendFormat(LogGcDrawEllipse,&buf);
}
break;
case EWsGcOpMoveTo:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcMoveTo,"MoveTo(%S)");
aText.AppendFormat(LogGcMoveTo,&buf);
}
break;
case EWsGcOpMoveBy:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcMoveBy,"MoveBy(%S)");
aText.AppendFormat(LogGcMoveBy,&buf);
}
break;
case EWsGcOpDrawPolygon:
{
_LIT(LogGcDrawPolygon,"DrawPolygon(...)");
aText.Append(LogGcDrawPolygon);
}
break;
case EWsGcOpDrawRoundRect:
{
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.RoundRect->rect));
TShortBuf buf2(TDebugLogTextHandler::FormatSize(pData.RoundRect->ellipse));
_LIT(LogGcDrawRoundRect,"DrawRoundRect(%S,%S)");
aText.AppendFormat(LogGcDrawRoundRect,&buf1,&buf2);
}
break;
case EWsGcOpDrawPie:
{
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.ArcOrPie->rect));
TShortBuf buf2(TDebugLogTextHandler::FormatPoint(pData.ArcOrPie->start));
TShortBuf buf3(TDebugLogTextHandler::FormatPoint(pData.ArcOrPie->end));
_LIT(LogGcDrawPie,"DrawPie(%S,%S,%S)");
aText.AppendFormat(LogGcDrawPie,&buf1,&buf2,&buf3);
}
break;
case EWsGcOpSetOrigin:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcSetOrigin,"SetOrigin(%S)");
aText.AppendFormat(LogGcSetOrigin,&buf);
}
break;
case EWsGcOpStartSegmentedDrawPolygon:
{
_LIT(LogGcStartSegmentedDrawPolygon,"StartSegmentedDrawPolygon(%d)");
aText.AppendFormat(LogGcStartSegmentedDrawPolygon,*pData.StartSegmentedDrawPolygon);
}
break;
case EWsGcOpSegmentedDrawPolygonData:
{
_LIT(LogGcSegmentedDrawPolygonData,"SegmentedDrawPolygonData(%d,%d,...)");
aText.AppendFormat(LogGcSegmentedDrawPolygonData,pData.SegmentedDrawPolygonData->index,
pData.SegmentedDrawPolygonData->numPoints);
}
break;
case EWsGcOpDrawSegmentedPolygon:
{
_LIT(LogGcDrawSegmentedPolygon,"DrawSegmentedPolygon()");
aText.AppendFormat(LogGcDrawSegmentedPolygon);
}
break;
case EWsGcOpDrawRect:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*pData.Rect));
_LIT(LogGcDrawRect,"DrawRect(%S)");
aText.AppendFormat(LogGcDrawRect,&buf);
}
break;
case EWsGcOpDrawBitmap:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.Bitmap->pos));
_LIT(KLitGcDrawBitmap, "DrawBitmap({%d}, %S)");
aText.AppendFormat(KLitGcDrawBitmap, hHandleToValue(pData.Bitmap->handle), &buf);
}
break;
case EWsGcOpDrawBitmap2:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.Bitmap2->rect));
_LIT(KLitGcDrawBitmap2, "DrawBitmap2({%d}, %S)");
aText.AppendFormat(KLitGcDrawBitmap2, hHandleToValue(pData.Bitmap2->handle), &buf);
}
break;
case EWsGcOpDrawBitmap3:
{
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.Bitmap3->rect));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.Bitmap3->srcRect));
_LIT(KLitGcDrawBitmap3, "DrawBitmap3({%d}, %S, %S)");
aText.AppendFormat(KLitGcDrawBitmap3, hHandleToValue(pData.Bitmap3->handle), &buf1, &buf2);
}
break;
case EWsGcOpDrawBitmapMasked:
case EWsGcOpWsDrawBitmapMasked:
{
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.iBitmapMasked->iRect));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.iBitmapMasked->iSrcRect));
_LIT(KLitGcDrawBitmapMasked, "DrawBitmapMasked(%S, {%d}, %S, {%d}, %d)");
aText.AppendFormat(KLitGcDrawBitmapMasked, &buf1, hHandleToValue(pData.iBitmapMasked->iHandle),
&buf2, hHandleToValue(pData.iBitmapMasked->iMaskHandle), pData.iBitmapMasked->iInvertMask);
}
break;
case EWsGcOpDrawBoxText:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.BoxText->box));
_LIT(LogGcDrawText1,"DrawText(\"");
aText.Append(LogGcDrawText1);
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.BoxText+1), pData.BoxText->length));
_LIT(LogGcDrawText2,"\", %S, %d, %d, %d)");
aText.AppendFormat(LogGcDrawText2,&iOverflowHandler, &buf, pData.BoxText->baselineOffset,
pData.BoxText->horiz, pData.BoxText->leftMrg);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeGc3(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData)
{
TWsGcCmdUnion pData;
pData.any=aCmdData;
switch (aOpcode)
{
case EWsGcOpSetDrawMode:
{
_LIT(LogGcSetDrawMode,"SetDrawMode(%u)");
aText.AppendFormat(LogGcSetDrawMode,*pData.UInt);
}
break;
case EWsGcOpClearRect:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*pData.Rect));
_LIT(LogGcClear,"Clear(%S)");
aText.AppendFormat(LogGcClear, &buf);
}
break;
case EWsGcOpClear:
{
_LIT(LogGcClear,"Clear()");
aText.AppendFormat(LogGcClear);
}
break;
case EWsGcOpGdiBlt2:
case EWsGcOpGdiWsBlt2:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.GdiBlt2->pos));
_LIT(LogGcGdiBlt,"GdiBlt(%S, {%d})");
aText.AppendFormat(LogGcGdiBlt,&buf,hHandleToValue(pData.GdiBlt2->handle));
}
break;
case EWsGcOpGdiBlt3:
case EWsGcOpGdiWsBlt3:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.GdiBlt3->pos));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.GdiBlt3->rect));
_LIT(LogGcGdiBlt,"GdiBlt(%S, {%d}, %S)");
aText.AppendFormat(LogGcGdiBlt,&buf1,hHandleToValue(pData.GdiBlt3->handle),&buf2);
}
break;
case EWsGcOpGdiBltMasked:
case EWsGcOpGdiWsBltMasked:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.GdiBltMasked->destination));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.GdiBltMasked->source));
_LIT(LogGcBitBltMasked,"BitBltMasked(%S, {%d}, %S)");
aText.AppendFormat(LogGcBitBltMasked, &buf1, hHandleToValue(pData.GdiBltMasked->handle),
&buf2, hHandleToValue(pData.GdiBltMasked->maskHandle),
pData.GdiBltMasked->invertMask);
}
break;
case EWsGcOpSize:
{
_LIT(LogGcSize,"Size()");
aText.AppendFormat(LogGcSize);
}
break;
case EWsGcOpUseFont:
{
_LIT(LogGcUseFont,"UseFont({0x%x})");
aText.AppendFormat(LogGcUseFont,hHandleToValue(*pData.handle));
}
break;
case EWsGcOpDiscardFont:
{
_LIT(LogGcDiscardFont,"DiscardFont()");
aText.AppendFormat(LogGcDiscardFont);
}
break;
case EWsGcOpTestInvariant:
{
_LIT(LogGcTestInvariant,"unimplemented opcode 'EWsGcOpTestInvariant' (%u)");
aText.AppendFormat(LogGcTestInvariant, aOpcode);
}
break;
case EWsGcOpReset:
{
_LIT(LogGcReset,"Reset()");
aText.Append(LogGcReset);
}
break;
case EWsGcOpSetDitherOrigin:
{
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
_LIT(LogGcSetDitherOrigin,"SetDitherOrigin(%S)");
aText.AppendFormat(LogGcSetDitherOrigin,&buf);
}
break;
case EWsGcOpMapColors:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.MapColors->rect));
_LIT(LogGcMapColors,"MapColors(%S,?,%d)");
aText.AppendFormat(LogGcMapColors,&buf,pData.MapColors->numPairs);
}
break;
case EWsGcOpSetUnderlineStyle:
{
_LIT(LogGcSetUnderlineStyle,"SetUnderlineStyle(%x)");
aText.AppendFormat(LogGcSetUnderlineStyle,*pData.SetUnderlineStyle);
}
break;
case EWsGcOpSetStrikethroughStyle:
{
_LIT(LogGcSetStrikethroughStyle,"SetStrikethroughStyle(%x)");
aText.AppendFormat(LogGcSetStrikethroughStyle,*pData.SetStrikethroughStyle);
}
break;
case EWsGcOpDrawWsGraphic:
case EWsGcOpDrawWsGraphicPtr:
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.WsGraphic->iRect));
_LIT(KLitGcDrawWsGraphic,"DrawWsGraphic(%x, %d, %S, %d)");
aText.AppendFormat(KLitGcDrawWsGraphic, pData.WsGraphic->iFlags, pData.WsGraphic->iId, &buf, pData.WsGraphic->iDataLen);
}
break;
case EWsGcOpSetFaded:
{
_LIT(KLitGcSetFaded, "SetFaded(%d)");
aText.AppendFormat(KLitGcSetFaded, pData.Bool);
}
break;
case EWsGcOpSetFadeParams:
{
_LIT(KLitGcSetFadeParams, "SetFadeParams(BlackMap %d, WhiteMap %d)");
const unsigned char *bytePtr = (const unsigned char*)(pData.UInt);
aText.AppendFormat(KLitGcSetFadeParams, bytePtr[0], bytePtr[1]);
}
break;
case EWsGcOpGdiAlphaBlendBitmaps:
case EWsGcOpGdiWsAlphaBlendBitmaps:
{
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(pData.AlphaBlendBitmaps->point));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.AlphaBlendBitmaps->source));
TShortBuf buf3(TDebugLogTextHandler::FormatPoint(pData.AlphaBlendBitmaps->alphaPoint));
_LIT(KLitGcAlphaBlendBitmaps,"AlphaBlendBitmaps(%S, {%d}, %S, {%d}, %S)");
aText.AppendFormat(KLitGcAlphaBlendBitmaps, &buf1, hHandleToValue(pData.AlphaBlendBitmaps->bitmapHandle),
&buf2, hHandleToValue(pData.AlphaBlendBitmaps->alphaHandle),
&buf3);
}
break;
case EWsGcOpSetOpaque:
{
_LIT(KLitGcOpSetOpaque, "SetOpaque(%d)");
aText.AppendFormat(KLitGcOpSetOpaque, pData.Bool);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeScreenDevice(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
TWsSdCmdUnion pData;
_LIT(LogScreenDevice,"CWsScreenDevice[%d]::");
aText.Format(LogScreenDevice,aHandle);
pData.any=aCmdData;
switch (aOpcode)
{
case EWsSdOpFree:
{
_LIT(LogScreenDeviceDelete,"~CWsScreenDevice()");
aText.Append(LogScreenDeviceDelete);
}
break;
case EWsSdOpPixel:
{
_LIT(LogScreenDevicePixel,"Pixel(%S)");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(*pData.Point));
aText.AppendFormat(LogScreenDevicePixel,&buf);
}
break;
case EWsSdOpGetScanLine:
{ //This fills up the log two much for test code
aText=KNullDesC;
/*_LIT(LogScreenDeviceGetScanLine,"GetScanLine(TRgb *aScanLine, %d, %S)");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(pData.GetScanLine->pos));
aText.AppendFormat(LogScreenDeviceGetScanLine,pData.GetScanLine->len,&buf);*/
}
break;
case EWsSdOpHorizontalTwipsToPixels:
{
_LIT(LogScreenDeviceHorizontalTwipsToPixels,"HorizontalTwipsToPixels()");
aText.Append(LogScreenDeviceHorizontalTwipsToPixels);
}
break;
case EWsSdOpVerticalTwipsToPixels:
{
_LIT(LogScreenDeviceVerticalTwipsToPixels,"VerticalTwipsToPixels()");
aText.Append(LogScreenDeviceVerticalTwipsToPixels);
}
break;
case EWsSdOpHorizontalPixelsToTwips:
{
_LIT(LogScreenDeviceHorizontalPixelsToTwips,"HorizontalPixelsToTwips()");
aText.Append(LogScreenDeviceHorizontalPixelsToTwips);
}
break;
case EWsSdOpVerticalPixelsToTwips:
{
_LIT(LogScreenDeviceVerticalPixelsToTwips,"VerticalPixelsToTwips()");
aText.Append(LogScreenDeviceVerticalPixelsToTwips);
}
break;
case EWsSdOpPixelSize:
{
_LIT(LogScreenDeviceSizeInPixels,"SizeInPixels()");
aText.Append(LogScreenDeviceSizeInPixels);
}
break;
case EWsSdOpTwipsSize:
{
_LIT(LogScreenDeviceSizeInTwips,"SizeInTwips()");
aText.Append(LogScreenDeviceSizeInTwips);
}
break;
case EWsSdOpDisplayMode:
{
_LIT(LogScreenDeviceDisplayMode,"DisplayMode()");
aText.Append(LogScreenDeviceDisplayMode);
}
break;
case EWsSdOpRectCompare:
{
_LIT(LogScreenDeviceRectCompare,"RectCompare(%S, %S)");
TLongBuf buf1(TDebugLogTextHandler::FormatRect(pData.RectCompare->rect1));
TLongBuf buf2(TDebugLogTextHandler::FormatRect(pData.RectCompare->rect2));
aText.AppendFormat(LogScreenDeviceRectCompare,&buf1,&buf2);
}
break;
case EWsSdOpPointerRect:
{
_LIT(LogScreenDevicePointerRect,"PointerRect()");
aText.Append(LogScreenDevicePointerRect);
}
break;
case EWsSdOpCopyScreenToBitmap:
{
_LIT(LogScreenDeviceCopyScreenToBitmap,"CopyScreenToBitmap(%d)");
aText.AppendFormat(LogScreenDeviceCopyScreenToBitmap,pData.CopyScreenToBitmap->handle);
}
break;
case EWsSdOpCopyScreenToBitmap2:
{
_LIT(LogScreenDeviceCopyScreenToBitmap2,"CopyScreenToBitmap(%d,%S)");
TLongBuf buf(TDebugLogTextHandler::FormatRect(pData.CopyScreenToBitmap2->rect));
aText.AppendFormat(LogScreenDeviceCopyScreenToBitmap2,pData.CopyScreenToBitmap2->handle,&buf);
}
break;
case EWsSdOpSetScreenSizeAndRotation:
{
_LIT(LogScreenDeviceSetScreenSizeAndRotation,"SetScreenSizeAndRotation({%S, %S, %d})");
TShortBuf buf1(TDebugLogTextHandler::FormatSize(pData.PixelsTwipsAndRotation->iPixelSize));
TShortBuf buf2(TDebugLogTextHandler::FormatSize(pData.PixelsTwipsAndRotation->iTwipsSize));
aText.AppendFormat(LogScreenDeviceSetScreenSizeAndRotation,&buf1,&buf2,pData.PixelsTwipsAndRotation->iRotation);
}
break;
case EWsSdOpSetScreenSizeAndRotation2:
{
_LIT(LogScreenDeviceSetScreenSizeAndRotation,"SetScreenSizeAndRotation({%S, %d})");
TShortBuf buf(TDebugLogTextHandler::FormatSize(pData.PixelsAndRotation->iPixelSize));
aText.AppendFormat(LogScreenDeviceSetScreenSizeAndRotation,&buf,pData.PixelsAndRotation->iRotation);
}
break;
case EWsSdOpGetDefaultScreenSizeAndRotation:
case EWsSdOpGetDefaultScreenSizeAndRotation2:
{
_LIT(LogScreenDeviceGetDefaultScreenSizeAndRotation,"GetDefaultScreenSizeAndRotation(...)");
aText.Append(LogScreenDeviceGetDefaultScreenSizeAndRotation);
}
break;
case EWsSdOpGetNumScreenModes:
{
_LIT(LogScreenDeviceNumScreenModes,"NumScreenModes");
aText.Append(LogScreenDeviceNumScreenModes);
}
break;
case EWsSdOpSetScreenMode:
{
_LIT(LogScreenDeviceSetScreenMode,"ScreenMode(%d)");
aText.AppendFormat(LogScreenDeviceSetScreenMode,pData.Int);
}
break;
case EWsSdOpGetScreenModeSizeAndRotation:
case EWsSdOpGetScreenModeSizeAndRotation2:
{
_LIT(LogScreenDeviceGetScreenModeSizeAndRotation,"GetScreenModeSizeAndRotation(%d)");
aText.AppendFormat(LogScreenDeviceGetScreenModeSizeAndRotation,pData.Int);
}
break;
case EWsSdOpSetScreenModeEnforcement:
{
_LIT(LogScreenDeviceSetScreenModeEnforcement,"SetScreenModeEnforcement(%d)");
aText.AppendFormat(LogScreenDeviceSetScreenModeEnforcement,pData.Int);
}
break;
case EWsSdOpScreenModeEnforcement:
{
_LIT(LogScreenDeviceScreenModeEnforcement,"ScreenModeEnforcement");
aText.Append(LogScreenDeviceScreenModeEnforcement);
}
break;
case EWsSdOpSetModeRotation:
{
_LIT(LogScreenDeviceSetModeRotation,"SetModeRotation(%d,%d)");
aText.AppendFormat(LogScreenDeviceSetModeRotation,pData.SetScreenRotation->mode,pData.SetScreenRotation->rotation);
}
break;
case EWsSdOpGetRotationList:
{
_LIT(LogScreenDeviceGetRotationList,"GetRotationList(%d)");
aText.AppendFormat(LogScreenDeviceGetRotationList,pData.Int);
}
break;
case EWsSdOpPaletteAttributes:
{
_LIT(LogScreenDevicePaletteAttributes,"PaletteAttributes(...)");
aText.Append(LogScreenDevicePaletteAttributes);
}
break;
case EWsSdOpSetPalette:
{
_LIT(LogScreenDeviceSetPalette,"SetPalette(...)");
aText.Append(LogScreenDeviceSetPalette);
}
break;
case EWsSdOpGetPalette:
{
_LIT(LogScreenDeviceGetPalette,"GetPalette()");
aText.Append(LogScreenDeviceGetPalette);
}
break;
case EWsSdOpGetScreenMode:
{
_LIT(LogScreenDeviceGetScreenMode,"CurrentScreenMode()");
aText.Append(LogScreenDeviceGetScreenMode);
}
break;
case EWsSdOpGetDefaultScreenModeOrigin:
{
_LIT(LogScreenDeviceGetDefaultScreenModeOrigin,"GetDefaultScreenModeOrigin()");
aText.Append(LogScreenDeviceGetDefaultScreenModeOrigin);
}
break;
case EWsSdOpGetScreenModeOrigin:
{
_LIT(LogScreenDeviceGetScreenModeOrigin,"GetScreenModeOrigin(%d)");
aText.AppendFormat(LogScreenDeviceGetScreenModeOrigin, pData.Int);
}
break;
case EWsSdOpGetScreenModeScale:
{
_LIT(LogScreenDeviceGetScreenModeScale,"GetScreenModeScale(%d)");
aText.AppendFormat(LogScreenDeviceGetScreenModeScale, pData.Int);
}
break;
case EWsSdOpGetCurrentScreenModeScale:
{
_LIT(LogScreenDeviceGetCurrentScreenModeScale,"GetCurrentScreenModeScale()");
aText.Append(LogScreenDeviceGetCurrentScreenModeScale);
}
break;
case EWsSdOpSetAppScreenMode:
{
_LIT(LogScreenDeviceSetAppScreenMode,"SetAppScreenMode(%d)");
aText.AppendFormat(LogScreenDeviceSetAppScreenMode, pData.Int);
}
break;
case EWsSdOpGetScreenModeScaledOrigin:
{
_LIT(LogScreenDeviceGetScreenModeScaledOrigin,"GetScreenModeScaledOrigin(%d)");
aText.AppendFormat(LogScreenDeviceGetScreenModeScaledOrigin, pData.Int);
}
break;
case EWsSdOpGetCurrentScreenModeScaledOrigin:
{
_LIT(LogScreenDeviceGetCurrentScreenModeScaledOrigin,"GetCurrentScreenModeScaledOrigin()");
aText.Append(LogScreenDeviceGetCurrentScreenModeScaledOrigin);
}
break;
case EWsSdOpSetCurrentScreenModeAttributes:
{
_LIT(LogScreenDeviceSetCurrentScreenModeAttributes,"SetCurrentScreenModeAttributes(%S)");
TShortBuf buf(TDebugLogTextHandler::FormatSize(pData.ScreenSizeMode->iScreenSize));
aText.AppendFormat(LogScreenDeviceSetCurrentScreenModeAttributes,&buf);
}
break;
case EWsSdOpGetCurrentScreenModeAttributes:
{
_LIT(LogScreenDeviceGetCurrentScreenModeOrigin,"GetCurrentScreenModeAttributes()");
aText.Append(LogScreenDeviceGetCurrentScreenModeOrigin);
}
break;
case EWsSdOpGetScreenNumber:
{
_LIT(LogScreenDeviceGetScreenNumber,"GetScreenNumber()");
aText.Append(LogScreenDeviceGetScreenNumber);
}
break;
case EWsSdOpGetScreenSizeModeList:
{
_LIT(LogScreenDeviceGetScreenSizeModeList,"GetScreenSizeModeList(RArray<TInt>* aModeList)");
aText.Append(LogScreenDeviceGetScreenSizeModeList);
}
break;
case EWsSdOpGetScreenModeDisplayMode:
{
_LIT(LogScreenDeviceGetScreenModeDisplayMode,"GetScreenModeDisplayMode(%d)");
aText.AppendFormat(LogScreenDeviceGetScreenModeDisplayMode, pData.Int);
}
break;
case EWsClOpSetBackLight:
{
_LIT(LogScreenDeviceSetBackLight,"SetBackLight(%u)");
aText.AppendFormat(LogScreenDeviceSetBackLight, pData.UInt);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeAnimDll(TBuf<LogTBufSize>& aText,TInt aOpcode,const TAny* /*aCmdData*/,TInt aHandle)
{
aText.Format(_L("CAnimDll[%d]::"),aHandle);
switch (aOpcode)
{
case EWsAnimDllOpCreateInstance:
TDebugLogTextHandler::Append(aText, _L("CreateInstance(...)"));
break;
case EWsAnimDllOpDestroyInstance:
TDebugLogTextHandler::Append(aText, LogClose);
break;
case EWsAnimDllOpCommandReply:
TDebugLogTextHandler::Append(aText, _L("CommandReply(...)"));
break;
case EWsAnimDllOpCommand:
TDebugLogTextHandler::Append(aText, _L("Command(...)"));
break;
case EWsAnimDllOpFree:
aText.Append(_L("~CAnimDll()"));
break;
case EWsAnimDllOpCreateInstanceSprite:
aText.Append(_L("EWsAnimDllOpCreateInstanceSprite enum"));
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeSpriteBase(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
TWsSpriteCmdUnion pData;
aText.Format(_L("RWsSpriteBase[%d]::"),aHandle);
pData.any=aCmdData;
switch (aOpcode)
{
case EWsSpriteOpFree:
aText.Append(LogClose);
break;
case EWsSpriteOpSetPosition:
aText.Append(_L("SetPosition(...)"));
break;
case EWsSpriteOpUpdateMember:
aText.AppendFormat(_L("UpdateMember(%d)"),pData.UpdateMember->index);
break;
case EWsSpriteOpUpdateMember2:
aText.AppendFormat(_L("UpdateMember(%d,{%d,%d,%d,%d,{%d,%d},%d})"),pData.UpdateMember->index,
pData.UpdateMember->data.iBitmap,pData.UpdateMember->data.iMaskBitmap,
pData.UpdateMember->data.iInvertMask,pData.UpdateMember->data.iDrawMode,
pData.UpdateMember->data.iOffset.iX,pData.UpdateMember->data.iOffset.iY,
pData.UpdateMember->data.iInterval.Int());
break;
case EWsSpriteOpAppendMember:
aText.Append(_L("AppendMember(...)"));
break;
case EWsSpriteOpActivate:
aText.Append(_L("Activate()"));
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeBitmap(TBuf<LogTBufSize>& aText,TInt aOpcode,const TAny* /*aCmdData*/,TInt aHandle)
{
aText.Format(_L("CWsBitmap[%d]::"),aHandle);
switch (aOpcode)
{
case EWsBitmapOpFree:
aText.Append(LogClose);
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeDirect(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
TWsDirectCmdUnion pData;
_LIT(KClassName,"RDirectScreenAccess[%d]::");
aText.Format(KClassName,aHandle);
pData.any=aCmdData;
switch (aOpcode)
{
case EWsDirectOpFree:
aText.Append(LogClose);
break;
case EWsDirectOpRequest:
{
_LIT(LogDirectRequest,"Request(TInt *stat,%d)");
aText.AppendFormat(LogDirectRequest,hHandleToValue(*pData.Int));
}
break;
case EWsDirectOpInitFailed:
{
_LIT(LogDirectInitFailed,"InitFailed()");
aText.Append(LogDirectInitFailed);
}
break;
case EWsDirectOpGetRegion:
{
_LIT(LogDirectGetRegion,"GetRegion(%d)");
aText.AppendFormat(LogDirectGetRegion,pData.Int);
}
break;
case EWsDirectOpCancel:
{
_LIT(LogDirectCancel,"Cancel()");
aText.Append(LogDirectCancel);
}
break;
case EWsDirectOpGetSendQueue:
{
_LIT(LogGetSendQueue,"EWsDirectOpGetSendQueue enum");
aText.Append(LogGetSendQueue);
}
break;
case EWsDirectOpGetRecQueue:
{
_LIT(LogGetRecQueue,"EWsDirectOpGetRecQueue enum");
aText.Append(LogGetRecQueue);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
void TWsDecoder::DecodeClick(TBuf<LogTBufSize> &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
TWsClickCmdUnion pData;
_LIT(KClassName,"RSoundPlugIn[%d]::");
aText.Format(KClassName,aHandle);
pData.any=aCmdData;
switch (aOpcode)
{
case EWsClickOpFree:
aText.Append(LogClose);
break;
case EWsClickOpIsLoaded:
{
_LIT(LogClickIsLoaded,"IsLoaded()");
aText.Append(LogClickIsLoaded);
}
break;
case EWsClickOpUnLoad:
{
_LIT(LogClickUnLoad,"UnLoad()");
aText.Append(LogClickUnLoad);
}
break;
case EWsClickOpLoad:
{
_LIT(LogClickLoad1,"Load(\"");
_LIT(LogClickLoad2,"\")");
TDebugLogTextHandler::Append(aText, LogClickLoad1);
TDebugLogTextHandler::Append(aText, TPtrC((TText *)(pData.Int+1), *pData.Int));
TDebugLogTextHandler::Append(aText, LogClickLoad2);
}
break;
case EWsClickOpCommandReply:
{
_LIT(LogClickCommandReply,"CommandReply(...)");
aText.Append(LogClickCommandReply);
}
break;
case EWsClickOpSetKeyClick:
{
_LIT(LogSetKeyClick,"SetKeyClick(%u)");
aText.AppendFormat(LogSetKeyClick, pData.Bool);
}
break;
case EWsClickOpSetPenClick:
{
_LIT(LogSetPenClick,"SetPenClick(%u)");
aText.AppendFormat(LogSetPenClick, pData.Bool);
}
break;
case EWsClickOpKeyClickEnabled:
{
_LIT(LogKeyClickEnabled,"KeyClickEnabled()");
aText.Append(LogKeyClickEnabled);
}
break;
case EWsClickOpPenClickEnabled:
{
_LIT(LogPenClickEnabled,"PenClickEnabled()");
aText.Append(LogPenClickEnabled);
}
break;
default:
UnKnownOpcode(aText, aOpcode);
break;
}
}
TDesC &TWsDecoder::replyBufDetails(TInt aClass, TInt aOpcode, const TDesC8 *aReplyDes8, const TDesC *aReplyDesText)
{
iCommandDetailsText.Format(_L("Reply Buffer: "));
switch (aClass)
{
case WS_HANDLE_GROUP_WINDOW:
ReplyBufWindowGroup(iCommandDetailsText, aOpcode, aReplyDes8, aReplyDesText);
break;
case WS_HANDLE_CLIENT:
ReplyBufClient(iCommandDetailsText, aOpcode, aReplyDes8, aReplyDesText);
break;
case WS_HANDLE_WINDOW:
ReplyBufWindow(iCommandDetailsText, aOpcode, aReplyDes8, aReplyDesText);
break;
case WS_HANDLE_SCREEN_DEVICE:
ReplyBufScreenDevice(iCommandDetailsText, aOpcode, aReplyDes8, aReplyDesText);
break;
default:
iCommandDetailsText.Format(_L("Reply buffer not handled (%u)"), aClass);
UnKnown();
break;
}
return iCommandDetailsText;
}
TDesC &TWsDecoder::commandDetails(TInt aClass, TInt aOpcode, const TAny *aCmdData, TInt aHandle)
{
switch (aClass)
{
case WS_HANDLE_ROOT_WINDOW:
iCommandDetailsText.Format(_L("invalid class"));
break;
case WS_HANDLE_GROUP_WINDOW:
DecodeWindowGroup(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_CLIENT:
DecodeClient(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_WINDOW:
DecodeWindow(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_GC:
DecodeGc(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_SCREEN_DEVICE:
DecodeScreenDevice(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_ANIM_DLL:
DecodeAnimDll(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_SPRITE:
case WS_HANDLE_POINTER_CURSOR:
case WS_HANDLE_TEXT_CURSOR:
DecodeSpriteBase(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_BITMAP:
DecodeBitmap(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_DIRECT:
DecodeDirect(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
case WS_HANDLE_CLICK:
DecodeClick(iCommandDetailsText, aOpcode, aCmdData, aHandle);
break;
default:
iCommandDetailsText.Format(_L("unknown class (%u)"), aClass);
UnKnown();
break;
}
iRequestFuncClass=aClass;
iPrevOpcode=aOpcode;
return iCommandDetailsText;
}
TDesC &TWsDecoder::eventDetails(const TWsEvent *aWsEvent)
{
switch (aWsEvent->Type())
{
case EEventKey:
iEventDetailsText.Format(_L("EEventKey (code %u, scanCode %u, mdfs 0x%04x, repeats %u)"),
aWsEvent->Key()->iCode,
aWsEvent->Key()->iScanCode,
aWsEvent->Key()->iModifiers,
aWsEvent->Key()->iRepeats);
break;
case EEventKeyUp:
iEventDetailsText.Format(_L("EEventKeyUp (scanCode %u, mdfs 0x%04x)"),
aWsEvent->Key()->iScanCode,
aWsEvent->Key()->iModifiers);
break;
case EEventKeyDown:
iEventDetailsText.Format(_L("EEventKeyDown (scanCode %u, mdfs 0x%04x)"),
aWsEvent->Key()->iScanCode,
aWsEvent->Key()->iModifiers);
break;
case EEventPointer:
{
TShortBuf buf1(TDebugLogTextHandler::PointerEventType(aWsEvent->Pointer()->iType));
TShortBuf buf2(TDebugLogTextHandler::FormatPoint(aWsEvent->Pointer()->iPosition));
TShortBuf buf3(TDebugLogTextHandler::FormatPoint(aWsEvent->Pointer()->iParentPosition));
iEventDetailsText.Format(_L("EEventPointer (type %S, modifiers 0x%x, pos %S, global-pos %S)"),
&buf1,aWsEvent->Pointer()->iModifiers,&buf2,&buf3);
}
break;
case EEventDragDrop:
{
TShortBuf buf1(TDebugLogTextHandler::PointerEventType(aWsEvent->Pointer()->iType));
TShortBuf buf2(TDebugLogTextHandler::FormatPoint(aWsEvent->Pointer()->iPosition));
TShortBuf buf3(TDebugLogTextHandler::FormatPoint(aWsEvent->Pointer()->iParentPosition));
iEventDetailsText.Format(_L("EEventDragDrop (type %S, modifiers 0x%x, pos %S, global-pos %S)"),
&buf1,aWsEvent->Pointer()->iModifiers,&buf2,&buf3);
}
break;
case EEventPointerEnter:
iEventDetailsText.Format(_L("EEventPointerEnter"));
break;
case EEventPointerExit:
iEventDetailsText.Format(_L("EEventPointerExit"));
break;
case EEventFocusLost:
iEventDetailsText.Format(_L("EEventFocusLost"));
break;
case EEventFocusGained:
iEventDetailsText.Format(_L("EEventFocusGained"));
break;
case EEventModifiersChanged:
iEventDetailsText.Format(_L("EEventModifiersChanged"));
break;
case EEventSwitchOn:
iEventDetailsText.Format(_L("EEventSwitchOn"));
break;
case EEventPassword:
iEventDetailsText.Format(_L("EEventPassword"));
break;
case EEventWindowGroupsChanged:
iEventDetailsText.Format(_L("EEventWindowGroupsChanged"));
break;
case EEventErrorMessage:
iEventDetailsText.Format(_L("EEventErrorMessage (%d,%d)"),aWsEvent->ErrorMessage()->iErrorCategory,aWsEvent->ErrorMessage()->iError);
break;
case EEventMessageReady:
iEventDetailsText.Format(_L("EEventMessageReady"));
break;
case EEventScreenDeviceChanged:
iEventDetailsText.Format(_L("EEventScreenDeviceChanged"));
break;
case EEventSwitchOff:
{
_LIT(LogEventSwitchOff,"EEventSwitchOff");
iEventDetailsText.Format(LogEventSwitchOff);
}
break;
case EEventKeySwitchOff:
{
_LIT(LogEventKeySwitchOff,"EEventKeySwitchOff");
iEventDetailsText.Format(LogEventKeySwitchOff);
}
break;
case EEventFocusGroupChanged:
{
_LIT(LogEventFocusGroupChanged,"EEventFocusGroupChanged");
iEventDetailsText.Format(LogEventFocusGroupChanged);
}
break;
case EEventCaseOpened:
{
_LIT(LogEventCaseOpened,"EEventCaseOpened");
iEventDetailsText.Format(LogEventCaseOpened);
}
break;
case EEventCaseClosed:
{
_LIT(LogEventCaseClosed,"EEventCaseClosed");
iEventDetailsText.Format(LogEventCaseClosed);
}
break;
default:
if (aWsEvent->Type()>=EEventUser)
iEventDetailsText.Format(_L("EEventUser[%d]"), aWsEvent->Type()-EEventUser);
else
{
UnKnown();
iEventDetailsText.Format(_L("Unknown event type=%d "), aWsEvent->Type());
}
break;
}
return iEventDetailsText;
}
TDesC &TWsDecoder::eventDetails(const TRawEvent *aEvent)
{
iEventDetailsText.Zero();
switch (aEvent->Type())
{
case TRawEvent::ENone:
{
_LIT(LogEventDetailsNone,"ENone");
iEventDetailsText.Append(LogEventDetailsNone);
}
break;
case TRawEvent::EPointerMove:
{
_LIT(LogEventDetailsPointerMove,"EPointerMove(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsPointerMove);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::EPointerSwitchOn:
{
_LIT(LogEventDetailsPointerSwitchOn,"EPointerSwitchOn(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsPointerSwitchOn);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::EKeyDown:
{
_LIT(LogEventDetailsKeyDown,"EKeyDown(%d)");
iEventDetailsText.Format(LogEventDetailsKeyDown,aEvent->ScanCode());
}
break;
case TRawEvent::EKeyUp:
{
_LIT(LogEventDetailsKeyUp,"EKeyUp(%d)");
iEventDetailsText.Format(LogEventDetailsKeyUp,aEvent->ScanCode());
}
break;
case TRawEvent::ERedraw:
{
_LIT(LogEventDetailsRedraw,"ERedraw");
iEventDetailsText.Append(LogEventDetailsRedraw);
}
break;
case TRawEvent::ESwitchOn:
{
_LIT(LogEventDetailsSwitchOn,"ESwitchOn");
iEventDetailsText.Append(LogEventDetailsSwitchOn);
}
break;
case TRawEvent::EActive:
{
_LIT(LogEventDetailsActive,"EActive");
iEventDetailsText.Append(LogEventDetailsActive);
}
break;
case TRawEvent::EInactive:
{
_LIT(LogEventDetailsInactive,"EInactive");
iEventDetailsText.Append(LogEventDetailsInactive);
}
break;
case TRawEvent::EUpdateModifiers:
{
_LIT(LogEventDetailsModifiers,"EUpdateModifiers(%d)");
iEventDetailsText.Format(LogEventDetailsModifiers,aEvent->Modifiers());
}
break;
case TRawEvent::EButton1Down:
{
_LIT(LogEventDetailsButton1Down,"EButton1Down(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsButton1Down);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::EButton1Up:
{
_LIT(LogEventDetailsButton1Up,"EButton1Up(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsButton1Up);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::EButton2Down:
{
_LIT(LogEventDetailsButton2Down,"EButton2Down(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsButton2Down);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::EButton2Up:
{
_LIT(LogEventDetailsButton2Up,"EButton2Up(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsButton2Up);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::EButton3Down:
{
_LIT(LogEventDetailsButton3Down,"EButton3Down(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsButton3Down);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::EButton3Up:
{
_LIT(LogEventDetailsButton3Up,"EButton3Up(");
TShortBuf buf(TDebugLogTextHandler::FormatPoint(aEvent->Pos()));
iEventDetailsText.Append(LogEventDetailsButton3Up);
iEventDetailsText.Append(buf);
iEventDetailsText.Append(LogCloseBracket);
}
break;
case TRawEvent::ESwitchOff:
{
_LIT(LogEventDetailsSwitchOff,"ESwitchOff");
iEventDetailsText.Append(LogEventDetailsSwitchOff);
}
break;
case TRawEvent::EKeyRepeat:
{
_LIT(LogEventDetailsKeyRepeat,"ERepeatKey(scancode=%d,repeat=%d");
iEventDetailsText.Format(LogEventDetailsKeyRepeat,aEvent->ScanCode(),aEvent->Repeats());
}
break;
case TRawEvent::EPointer3DOutOfRange:
{
_LIT(LogEventDetailsOutOfRange,"EPointer3DOutOfRange");
iEventDetailsText.Format(LogEventDetailsOutOfRange);
}
break;
default:
{
_LIT(LogEventDetailsUnknown,"Unknown event type: %d");
iEventDetailsText.Format(LogEventDetailsUnknown,aEvent->Type());
UnKnown();
}
break;
}
return iEventDetailsText;
}
void TWsDecoder::ReplyBufWindowGroup(TBuf<LogTBufSize> &aText, TInt aOpcode, const TDesC8 *aReplyDes8, const TDesC *aReplyDesText)
{
ReplyBufWindow(aText, aOpcode, aReplyDes8, aReplyDesText);
}
void TWsDecoder::ReplyBufWindow(TBuf<LogTBufSize> &aText, TInt aOpcode, const TDesC8 *aReplyDes8, const TDesC *aReplyDesText)
{
switch (aOpcode)
{
case EWsWinOpPosition:
AppendPoint(aText,aReplyDes8);
break;
case EWsWinOpAbsPosition:
AppendPoint(aText,aReplyDes8);
break;
case EWsWinOpSize:
AppendPoint(aText,aReplyDes8);
break;
case EWsWinOpInquireOffset:
AppendPoint(aText,aReplyDes8);
break;
case EWsWinOpName:
AppendDesc(aText, aReplyDesText);
break;
case EWsWinOpRetrievePointerMoveBuffer:
aText.Append(_L("..."));
break;
case EWsWinOpGetInvalidRegion:
{
TRect *rect=(TRect *)aReplyDes8->Ptr();
TInt count=aReplyDes8->Size()/sizeof(TRect);
TBuf<2> comma;
_LIT(LogTwoStrings,"%S%S");
for(TInt index=0;index<count && !iOverflowHandler.IsError();index++)
{
TLongBuf buf(TDebugLogTextHandler::FormatRect(*rect++));
aText.AppendFormat(LogTwoStrings,&iOverflowHandler,&comma,&buf);
if (index==0)
comma=LogComma;
}
break;
}
default:
UnKnownReplyBuf(aText, aOpcode);
break;
}
}
void TWsDecoder::ReplyBufClient(TBuf<LogTBufSize> &aText, TInt aOpcode, const TDesC8 *aReplyDes8, const TDesC *aReplyDesText)
{
switch (aOpcode)
{
case EWsClOpGetEvent:
{
const TWsEvent *wsEvent=(TWsEvent *)aReplyDes8->Ptr();
TPtrC details(eventDetails(wsEvent));
aText=KNullDesC;
if (details!=KNullDesC)
{
TDebugLogTextHandler::Append(aText, details);
TBuf<128> buf;
_LIT(LogReplyClientDestTime,"(dest %d, time ");
_LIT(LogReplyClientTime,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S%.%*C2%:3)");
buf.Format(LogReplyClientDestTime, wsEvent->Handle());
TDebugLogTextHandler::Append(aText, buf);
TRAPD(err,wsEvent->Time().FormatL(buf,LogReplyClientTime));
if (err==KErrNone)
TDebugLogTextHandler::Append(aText, buf);
else
{
_LIT(LogReplyClientTimeErr,"######)");
TDebugLogTextHandler::Append(aText,LogReplyClientTimeErr);
}
}
}
break;
case EWsClOpGetRedraw:
{
const TWsRedrawEvent *redrawEvent=(TWsRedrawEvent *)aReplyDes8->Ptr();
TLongBuf buf(TDebugLogTextHandler::FormatRect(redrawEvent->Rect()));
aText.Format(_L("Redraw (handle %d): "), redrawEvent->Handle());
aText.AppendFormat(_L("rect %S"), &buf);
}
break;
case EWsClOpGetPriorityKey:
{
const TWsPriorityKeyEvent *abortEvent=(TWsPriorityKeyEvent *)aReplyDes8->Ptr();
aText.Format(_L("Abort key handle %d"), abortEvent->Handle());
}
break;
case EWsClOpShadowVector:
AppendPoint(aText,aReplyDes8);
break;
case EWsClOpGetWindowGroupClientThreadId:
{
const TThreadId *threadId=(TThreadId *)aReplyDes8->Ptr();
aText.Format(_L("TThreadId=%d"), *(TInt *)threadId);
}
break;
case EWsClOpGetWindowGroupNameFromIdentifier:
AppendDesc(aText, aReplyDesText);
break;
case EWsClOpWindowGroupList:
case EWsClOpWindowGroupListAndChain:
case EWsClOpWindowGroupListAllPriorities:
{
TInt *handlPtr=(TInt *)aReplyDes8->Ptr();
TInt count=aReplyDes8->Size()/sizeof(TInt);
TBuf<2> comma;
_LIT(LogStringInt,"%S%d");
for(TInt index=0;index<count && !iOverflowHandler.IsError();index++)
{
aText.AppendFormat(LogStringInt,&iOverflowHandler,&comma,*handlPtr++);
if (index==0)
comma=LogComma;
}
}
break;
case EWsClOpGetKeyboardRepeatRate:
{
SKeyRepeatSettings *settings=(SKeyRepeatSettings *)aReplyDes8->Ptr();
aText.AppendFormat(_L("initial=%d,normal=%d"),settings->iInitialTime.Int(),settings->iTime.Int());
}
break;
case EWsClOpGetDoubleClickSettings:
{
SDoubleClickSettings *settings=(SDoubleClickSettings *)aReplyDes8->Ptr();
aText.AppendFormat(_L("interval=%d,distance=%d"),settings->iInterval.Int(),settings->iDistance);
}
break;
case EWsClOpFetchMessage:
{
_LIT(LogClientRetFetchMessage,"FetchMessage");
aText.Append(LogClientRetFetchMessage);
}
break;
case EWsClOpCreateGraphic:
aText.AppendFormat(_L("Creating graphic: %s"), aReplyDes8);
break;
case EWsClOpGetGraphicMessage:
aText.AppendFormat(_L("Graphic message: %s"), aReplyDes8);
break;
case EWsClOpPointerCursorPosition:
{
TWsClCmdSetPointerCursorArea *settings=(TWsClCmdSetPointerCursorArea*)aReplyDes8->Ptr();
TLongBuf buf1(TDebugLogTextHandler::FormatRect(settings->area));
aText.AppendFormat(_L("Cursor position area=%S"), &buf1);
}
break;
case EWsClOpPointerCursorArea:
{
TWsClCmdSetPointerCursorArea *settings=(TWsClCmdSetPointerCursorArea*)aReplyDes8->Ptr();
TLongBuf buf1(TDebugLogTextHandler::FormatRect(settings->area));
aText.AppendFormat(_L("Cursor area=%S"), &buf1);
}
break;
case EWsClOpGetDefModeMaxNumColors:
{
SDefModeMaxNumColors *settings=(SDefModeMaxNumColors*)aReplyDes8->Ptr();
aText.AppendFormat(_L("Num of colors=%d, num of grays=%d, display mode=%d"),settings->iColors, settings->iGrays, settings->iDisplayMode);
}
break;
default:
UnKnownReplyBuf(aText, aOpcode);
break;
}
}
void TWsDecoder::ReplyBufScreenDevice(TBuf<LogTBufSize> &aText, TInt aOpcode, const TDesC8 *aReplyDes8, const TDesC *)
{
switch (aOpcode)
{
case EWsSdOpGetScanLine:
{ //This fills up the log two much for test code
aText=KNullDesC;
//Alternate code that would log this information.
/*_LIT(LogScreenDeviceReplyBufGetScanLine,"aScanLine set to ...");
aText=LogScreenDeviceReplyBufGetScanLine;*/
/*TDebugLogTextHandler::Append(aText, TDebugLogTextHandler::FormatArray(TDebugLogTextHandler::ERgb,
((TDesC8 *)aReplyData)->Ptr(),((TDesC8 *)aReplyData)->Length()*sizeof(TRgb)));*/
}
break;
case EWsSdOpHorizontalTwipsToPixels:
case EWsSdOpVerticalTwipsToPixels:
case EWsSdOpHorizontalPixelsToTwips:
case EWsSdOpVerticalPixelsToTwips:
case EWsSdOpPixelSize:
case EWsSdOpTwipsSize:
AppendPoint(aText,aReplyDes8);
break;
case EWsSdOpPointerRect:
AppendRect(aText,aReplyDes8);
break;
case EWsSdOpGetDefaultScreenSizeAndRotation:
case EWsSdOpGetScreenModeSizeAndRotation:
{
_LIT(LogScreenDeviceReplyBufPTR,"%S %S %d");
const TPixelsTwipsAndRotation *sar=(TPixelsTwipsAndRotation *)aReplyDes8->Ptr();
TShortBuf buf1(TDebugLogTextHandler::FormatSize(sar->iPixelSize));
TShortBuf buf2(TDebugLogTextHandler::FormatSize(sar->iTwipsSize));
aText.AppendFormat(LogScreenDeviceReplyBufPTR,&buf1,&buf2,sar->iRotation);
}
break;
case EWsSdOpGetDefaultScreenSizeAndRotation2:
case EWsSdOpGetScreenModeSizeAndRotation2:
{
_LIT(LogScreenDeviceReplyBufPR,"%S %d");
const TPixelsAndRotation *sar=(TPixelsAndRotation *)aReplyDes8->Ptr();
TShortBuf buf(TDebugLogTextHandler::FormatSize(sar->iPixelSize));
aText.AppendFormat(LogScreenDeviceReplyBufPR,&buf,sar->iRotation);
}
break;
case EWsSdOpGetPalette:
{
_LIT(LogScreenDeviceReplyBufGetPalette,"Palette returned ...");
aText.Append(LogScreenDeviceReplyBufGetPalette);
}
break;
case EWsSdOpGetDefaultScreenModeOrigin:
{
const TPoint *point = reinterpret_cast<const TPoint*>(aReplyDes8->Ptr());
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(*point));
_LIT(LogScreenDeviceReplyBufGetDefaultScreenModeOrigin,"Default screen mode origin=%S");
aText.AppendFormat(LogScreenDeviceReplyBufGetDefaultScreenModeOrigin, &buf1);
}
break;
case EWsSdOpGetScreenModeOrigin:
{
const TPoint *point = reinterpret_cast<const TPoint*>(aReplyDes8->Ptr());
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(*point));
_LIT(LogScreenDeviceReplyBufGetScreenModeOrigin,"Screen mode origin=%S");
aText.AppendFormat(LogScreenDeviceReplyBufGetScreenModeOrigin, &buf1);
}
break;
case EWsSdOpGetScreenModeScale:
case EWsSdOpGetCurrentScreenModeScale:
{
const TSize *size = reinterpret_cast<const TSize*>(aReplyDes8->Ptr());
TShortBuf buf1(TDebugLogTextHandler::FormatSize(*size));
_LIT(LogScreenDeviceReplyBufGetScreenScale,"Screen scale=%S");
aText.AppendFormat(LogScreenDeviceReplyBufGetScreenScale, &buf1);
}
break;
case EWsSdOpGetScreenModeScaledOrigin:
{
const TPoint *point = reinterpret_cast<const TPoint*>(aReplyDes8->Ptr());
TShortBuf buf1(TDebugLogTextHandler::FormatPoint(*point));
_LIT(LogScreenDeviceReplyBufGetScreenModeScaledOrigin,"Screen mode scaled origin=%S");
aText.AppendFormat(LogScreenDeviceReplyBufGetScreenModeScaledOrigin, &buf1);
}
break;
case EWsSdOpGetCurrentScreenModeAttributes:
{
TSizeMode *settings=(TSizeMode*)aReplyDes8->Ptr();
TShortBuf origin(TDebugLogTextHandler ::FormatPoint(settings->iOrigin));
TShortBuf size(TDebugLogTextHandler ::FormatSize(settings->iScreenSize));
TShortBuf area(TDebugLogTextHandler ::FormatRect(settings->iPointerCursorArea));
aText.AppendFormat(_L("Screen attribute: origin=%S, size=%s, rotation=%d, area=$s, display mode = %d"),
&origin, &size, settings->iAlternativeRotations, &area, settings->iDefaultDisplayMode);
}
break;
case EWsSdOpGetScreenSizeModeList:
AppendDesc(aText, aReplyDes8);
break;
default:
UnKnownReplyBuf(aText, aOpcode);
break;
}
}