diff -r 000000000000 -r 7f656887cf89 libraries/qr3/src/threadListboxdata.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libraries/qr3/src/threadListboxdata.cpp	Wed Jun 23 15:52:26 2010 +0100
@@ -0,0 +1,204 @@
+// threadListboxdata.cpp
+// 
+// Copyright (c) 2010 Accenture. All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the "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:
+// Accenture - Initial contribution
+//
+#include "KernLbxModel.h"
+#include "Utils.h"
+#include <fshell/clogger.h>
+#include <fshell/memoryaccess.h>
+#include <fshell/qr3dll.h>
+#include "QResources3.hrh"
+#include <fshell/heaputils.h>
+
+CThreadsListBoxData::CThreadsListBoxData(CKernListBoxModel* aModel)
+	: CKernListBoxData(aModel)
+	{
+	}
+
+void CThreadsListBoxData::DoFormatL(TObjectKernelInfo* aInfo, RBuf& name, RBuf& more, TInt& itemId)
+	{
+	TThreadKernelInfo& info = *(TThreadKernelInfo*)aInfo;
+	name.Copy(info.iFullName);
+	PrettyName(iType, name);
+
+	TUint tid = info.iThreadId;
+	TExitType exitType = EExitPending;
+	RThread thread;
+	if (Model().MemAccess().RThreadForceOpen(thread, tid) == KErrNone)
+		{
+		exitType = thread.ExitType();
+		}
+	if (exitType == EExitPending)
+		{
+		more.Format(_L("Tid %i"), tid);
+		}
+	else
+		{
+		TExitCategoryName cat = thread.ExitCategory();
+		more.Format(_L("Tid %i %S %i"), tid, &cat, thread.ExitReason());
+		}
+	thread.Close();
+	itemId = tid;
+	}
+
+void CThreadsListBoxData::DumpToCloggerL(RClogger& clogger, TInt i, TInt /*count*/)
+	{
+	_LIT8(KThreadDesc,"Thread;FullName;Tid;Priority;(PriorityHumanReadable);ParentPid;StackSize;(StackSizeHumanReadable);HeapSize;(HeapSizeHumanReadable);MinHeapSize;(MinHumanReadable);UnusedPages;LostBytes;(LostBytesHumanReadable);ExitStatus;ExitCategory;ExitReason;KernObjAddr");
+	_LIT8(KThreadFmt,"Thread;%S;%i;%i;(%S);%i;%i;(%S);%i;(%S);%i;(%S);%i;%i;(%S);%S;%S;%i;%x");
+	//                                                    ^ HeapSizeHumanReadable
+	if (i == 0) clogger.Log(KThreadDesc);
+	TThreadKernelInfo& info = *(TThreadKernelInfo*)iInfo;
+
+	TBuf<16> priority16 = ToString((TThreadPriority)info.iThreadPriority);
+	TPtr8 priority = priority16.Collapse();
+	
+	LtkUtils::RProxyAllocatorHelper allocHelper;
+	User::LeaveIfError(allocHelper.Open(Model().MemAccess(), info.iThreadId));
+	TBuf8<16> heapSize, minHeap, lostBytes, stackSize;
+	HR(heapSize, allocHelper.CommittedSize());
+	HR(stackSize, info.iUserStackSize);
+	HR(minHeap, allocHelper.MinCommittedSize());
+	TInt lostBytesCount = allocHelper.CommittedFreeSpace();
+	HR(lostBytes, lostBytesCount);
+	TInt parentPid = 0; //TODO
+	TPtrC exitStatus;
+	TInt exitReason = 0;
+	TExitCategoryName exitCategory;
+	RThread handle;
+	if (Model().MemAccess().RThreadForceOpen(handle, info.iThreadId) == KErrNone)
+		{
+		exitStatus.Set(ToString(handle.ExitType()));
+		exitCategory = handle.ExitCategory();
+		exitReason = handle.ExitReason();
+		handle.Close();
+		}
+	TBuf8<16> exitStatus8;
+	exitStatus8.Copy(exitStatus);
+	TPtrC8 exitCategory8 = exitCategory.Collapse();
+	clogger.Log(KThreadFmt, &info.iFullName, info.iThreadId, info.iThreadPriority, &priority, parentPid, info.iUserStackSize, &stackSize, allocHelper.CommittedSize(), &heapSize, allocHelper.MinCommittedSize(), &minHeap, allocHelper.CountUnusedPages(), lostBytesCount, &lostBytes, &exitStatus8, &exitCategory8, exitReason, info.iAddressOfKernelObject);
+	allocHelper.Close();
+	}
+
+void CThreadsListBoxData::DoInfoForDialogL(RBuf& aTitle, RBuf& inf, TDes* aTemp)
+	{
+	TThreadKernelInfo& info = *(TThreadKernelInfo*)iInfo;
+	RThread thread;
+	RProcess process;
+	TInt err = Model().MemAccess().RThreadForceOpen(thread, info.iThreadId);
+	if (!err)
+		{
+		err = thread.Process(process);
+		}
+	TUint processId = err;
+	if (!err)
+		{
+		processId = (TUint)process.Id();
+		}
+	CleanupClosePushL(thread);
+	CleanupClosePushL(process);
+
+	_LIT(KInfo, "Thread info");
+	aTitle.Copy(KInfo);
+	inf.Copy(iInfo->iFullName);
+	inf.Append(Klflf);
+	
+	_LIT(KThread, "Tid: %d Pid: %d Kern Priority: %d\nPriority: %d (%S)\nProc Priority: %d (%S)");
+	_LIT(KCritical, "\n%S");
+	_LIT(KCreator, "\nCreator thread id: %d (%S)");
+	_LIT(KKern, "\nKernel object address: 0x%08x");
+	_LIT(KStack, "\n\nUser stack size: %S");
+	_LIT(KHeap, "\nAllocator: 0x%08x\nHeap size: %S (%d)\nMin/Max: %S/%S\nUnused: %S Usable: %S");
+	_LIT(KDied, "\n\nDied with: %S %S %i");
+
+	TThreadPriority threadPriority = (TThreadPriority)err;
+	TProcessPriority processPriority = (TProcessPriority)err;
+	TPtrC priority = _L("?");
+	TPtrC priorityP = _L("?");
+	if (!err)
+		{
+		threadPriority = thread.Priority();
+		priority.Set(ToString(threadPriority));
+		processPriority = process.Priority();
+		priorityP.Set(ToString(processPriority));
+		}
+	LtkUtils::RProxyAllocatorHelper allocHelper;
+	User::LeaveIfError(allocHelper.Open(Model().MemAccess(), info.iThreadId));
+	TBuf<16> heapSize, minHeap, maxHeap, unusedMem, reclaimableMem, stackSize;
+	HR(heapSize, allocHelper.CommittedSize());
+	HR(stackSize, info.iUserStackSize);
+	HR(minHeap, allocHelper.MinCommittedSize());
+	HR(maxHeap, allocHelper.MaxCommittedSize());
+	HR(unusedMem, allocHelper.CommittedFreeSpace());
+	HR(reclaimableMem, allocHelper.CountUnusedPages() * 4096);
+	inf.AppendFormat(KThread, info.iThreadId, processId, info.iThreadPriority, threadPriority, &priority, processPriority, &priorityP);
+
+	TUint creatorTid = Model().MemAccess().GetThreadCreatorId(info.iThreadId);
+	if (creatorTid != 0)
+		{
+		RThread creator;
+		TInt err = Model().MemAccess().RThreadForceOpen(creator, creatorTid);
+		*aTemp = _L("?");
+		if (err == KErrNone)
+			{
+			*aTemp = creator.FullName();
+			PrettyName(iType, *aTemp);
+			creator.Close();
+			}
+		inf.AppendFormat(KCreator, creatorTid, aTemp);
+		}
+
+	User::TCritical crit = User::ENotCritical;
+	if (!err)
+		{
+		crit = User::Critical(thread);
+		}
+	if (crit != User::ENotCritical)
+		{
+		TPtrC critical = ToString(crit);
+		inf.AppendFormat(KCritical, &critical);
+		}
+	inf.AppendFormat(KKern, info.iAddressOfKernelObject);
+
+	inf.AppendFormat(KStack, &stackSize);
+	inf.AppendFormat(KHeap, allocHelper.AllocatorAddress(), &heapSize, allocHelper.CommittedSize(), &minHeap, &maxHeap, &unusedMem, &reclaimableMem);
+	allocHelper.Close();
+	if (err == KErrNone && thread.ExitType() != EExitPending)
+		{
+		TPtrC exitStatus;
+		TInt exitReason = 0;
+		TExitCategoryName exitCategory;
+		exitStatus.Set(ToString(thread.ExitType()));
+		if (thread.ExitType() == EExitPanic)
+			{
+			exitCategory = thread.ExitCategory();
+			}
+		exitReason = thread.ExitReason();
+		inf.AppendFormat(KDied, &exitStatus, &exitCategory, exitReason);
+		}
+	CleanupStack::PopAndDestroy(2, &thread);
+	}
+
+TBool CThreadsListBoxData::SupportsCommand(TInt aCommand)
+	{
+	switch (aCommand)
+		{
+		case ECmdHandleInfo:
+		case ECmdKill:
+		case ECmdDumpHeap:
+		case ECmdSetCritical:
+		case ECmdSetPriority:
+		case ECmdPoll:
+			return ETrue;
+		default:
+			return EFalse;
+		}
+	}
+
+