diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/debuglog/DECODER.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/debuglog/DECODER.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,2982 @@ +// 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 &aText, TInt aOpcode) + { + aText.AppendFormat(_L("unknown function (opcode %u)"), aOpcode); + UnKnown(); + } + +void TWsDecoder::UnKnownReplyBuf(TBuf &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 &aText, const TDesC8 *aReplyDes8) + { + TShortBuf buf(TDebugLogTextHandler::FormatPoint(*((TPoint *)aReplyDes8->Ptr()))); + aText.AppendFormat(LogString, &buf); + } + +void TWsDecoder::AppendRect(TBuf &aText, const TDesC8 *aReplyDes8) + { + TLongBuf buf(TDebugLogTextHandler::FormatRect(*((TRect *)aReplyDes8->Ptr()))); + aText.AppendFormat(LogString, &buf); + } + +void TWsDecoder::AppendDesc(TBuf &aText, const TDesC8 *aReplyDes8) + { + TBuf buf; + buf.Copy(*aReplyDes8); + aText.AppendFormat(LogString, &buf); + } + +void TWsDecoder::AppendDesc(TBuf &aText, const TDesC16 *aReplyDes16) + { + aText.AppendFormat(LogString, aReplyDes16); + } + +void TWsDecoder::DecodeWindowGroup(TBuf &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 &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("")); + 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* aWindowList)"); + aText.AppendFormat(LogClientWindowGroupListAndChain, *pData.UInt); + } + break; + case EWsClOpWindowGroupListAndChainAllPriorities: + { + _LIT(LogClientWindowGroupListAndChainAllPriorities,"WindowGroupListAndChainAllPriorities(RArray* 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 &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle) + { + _LIT(LogWindow,"RWindow[%d]::"); + aText.Format(LogWindow,aHandle); + decodeWindow(aText,aOpcode,aCmdData); + } + +void TWsDecoder::decodeWindow(TBuf &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 &aText, TInt aOpcode, const TAny *aCmdData, TInt aHandle) + { + _LIT(LogGc,"RGc[%d]::"); + aText.Format(LogGc,aHandle); + if (aOpcode &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 &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 &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 &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* 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& 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 &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& 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 &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 &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 &aText, TInt aOpcode, const TDesC8 *aReplyDes8, const TDesC *aReplyDesText) + { + ReplyBufWindow(aText, aOpcode, aReplyDes8, aReplyDesText); + } + +void TWsDecoder::ReplyBufWindow(TBuf &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 &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;indexPtr(); + 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 &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(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(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(aReplyDes8->Ptr()); + TShortBuf buf1(TDebugLogTextHandler::FormatSize(*size)); + _LIT(LogScreenDeviceReplyBufGetScreenScale,"Screen scale=%S"); + aText.AppendFormat(LogScreenDeviceReplyBufGetScreenScale, &buf1); + } + break; + case EWsSdOpGetScreenModeScaledOrigin: + { + const TPoint *point = reinterpret_cast(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; + } + }