diff -r 48060abbbeaf -r b3cee849fa46 memspyui/ui/avkon/src/MemSpyUiUtils.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspyui/ui/avkon/src/MemSpyUiUtils.cpp	Tue Aug 31 15:15:20 2010 +0300
@@ -0,0 +1,367 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include "MemSpyUiUtils.h"
+
+// System includes
+#include <coemain.h>
+#include <memspyui.rsg>
+
+
+
+
+void MemSpyUiUtils::Format( TDes& aBuf, TInt aResourceId, ...)
+    {
+	VA_LIST list;
+    VA_START(list,aResourceId);
+	TBuf<128> format;
+	CCoeEnv::Static()->ReadResource( format, aResourceId );
+	aBuf.FormatList( format, list );
+    }
+
+
+void MemSpyUiUtils::GetErrorText( TDes& aBuf, TInt aError )
+    {
+    if  ( aError == KErrNotSupported )
+        {
+        _LIT( KMemSpyErrorText, "Not Supported" );
+        aBuf = KMemSpyErrorText;
+        }
+    else if ( aError == KErrNotReady )
+        {
+        _LIT( KMemSpyErrorText, "Not Ready" );
+        aBuf = KMemSpyErrorText;
+        }
+    else if ( aError == KErrNotFound )
+        {
+        _LIT( KMemSpyErrorText, "Missing" );
+        aBuf = KMemSpyErrorText;
+        }
+    else if ( aError == KErrGeneral )
+        {
+        _LIT( KMemSpyErrorText, "General Error" );
+        aBuf = KMemSpyErrorText;
+        }
+    else
+        {
+        _LIT( KMemSpyItemValueError, "Error: %d" );
+        aBuf.Format( KMemSpyItemValueError, aError );
+        }
+    }
+
+HBufC* MemSpyUiUtils::FormatItem( const TDesC& aCaption )
+	{
+	HBufC* retBuf = HBufC::NewL( 32 );
+	TPtr pRetBuf( retBuf->Des() );
+	pRetBuf.Zero();
+	pRetBuf.Append( _L("\t") );
+	pRetBuf.Append( aCaption );
+	return retBuf;
+	}
+
+TDesC& MemSpyUiUtils::ThreadInfoItemNameByType( TMemSpyThreadInfoItemType aType )
+	{	
+	TPtrC pType( KTypeUnknown );
+	
+	switch( aType )
+		{
+		case EMemSpyThreadInfoItemTypeFirst:			
+			pType.Set(KGeneral);
+			break;			
+		case EMemSpyThreadInfoItemTypeHeap:			
+			pType.Set(KHeap);
+			break;				
+		case EMemSpyThreadInfoItemTypeStack:			
+			pType.Set(KStack);
+			break;			
+		case EMemSpyThreadInfoItemTypeChunk:			
+			pType.Set(KChunks);
+			break;
+		case EMemSpyThreadInfoItemTypeCodeSeg:
+			pType.Set(KCodeSegs);
+			break;
+		case EMemSpyThreadInfoItemTypeOpenFiles:
+			pType.Set(KOpenFiles);
+			break;	
+		case EMemSpyThreadInfoItemTypeActiveObject:
+			pType.Set(KActiveObjects);
+			break;
+		case EMemSpyThreadInfoItemTypeOwnedThreadHandles:
+			pType.Set(KThreadHandlers);
+			break;
+		case EMemSpyThreadInfoItemTypeOwnedProcessHandles:
+			pType.Set(KProcessHandlers);
+			break;
+		case EMemSpyThreadInfoItemTypeServer:
+			pType.Set(KServers);
+			break;
+		case EMemSpyThreadInfoItemTypeSession:
+			pType.Set(KConnections);
+			break;
+		case EMemSpyThreadInfoItemTypeSemaphore:
+			pType.Set(KSemaphores);
+			break;
+		case EMemSpyThreadInfoItemTypeOtherThreads:
+			pType.Set(KThreadReferences);
+			break;
+		case EMemSpyThreadInfoItemTypeOtherProcesses:
+			pType.Set(KProcessReferences);
+			break;
+		case EMemSpyThreadInfoItemTypeMutex:
+			pType.Set(KMutexes);
+			break;
+		case EMemSpyThreadInfoItemTypeTimer:
+			pType.Set(KTimers);					
+			break;
+		case EMemSpyThreadInfoItemTypeLogicalChannel:
+			pType.Set(KDD);
+			break;
+		case EMemSpyThreadInfoItemTypeChangeNotifier:
+			pType.Set(KChangeNotif);
+			break;
+		case EMemSpyThreadInfoItemTypeUndertaker:
+			pType.Set(KUndertakers);
+			break;				
+		case EMemSpyThreadInfoItemTypeLDD:
+			pType.Set(KLogicalDrivers);
+			break;
+		case EMemSpyThreadInfoItemTypePDD:
+			pType.Set(KPhysicalDrivers);
+			break;
+			
+	    default:	       
+	    	break;  
+		}
+	return pType;
+	}
+
+
+void MemSpyUiUtils::AppendPriority( TDes& aDes, TProcessPriority aPriority )
+	{
+	switch( aPriority )
+		{
+	    case EPriorityLow:
+	        aDes += _L("[L]");
+	        break;
+	    case EPriorityBackground:
+	        aDes += _L("[B]");
+	        break;
+	    case EPriorityForeground:
+	        aDes += _L("[F]");
+	        break;
+	    case EPriorityHigh:
+	        aDes += _L("[H]");
+	        break;
+	    case EPriorityWindowServer:
+	        aDes += _L("[WS]");
+	        break;
+	    case EPriorityFileServer:
+	        aDes += _L("[FS]");
+	        break;
+	    case EPriorityRealTimeServer:
+	        aDes += _L("[RTS]");
+	        break;
+	    case EPrioritySupervisor:
+	        aDes += _L("[SUP]");
+	        break;
+	    default:
+	        aDes += _L("[?]");
+	        break;
+		}
+	}
+
+void MemSpyUiUtils::AppendExitInfo( TDes& aDes, TExitType aType, TInt aExitReason, const TDesC& aExitCategory  )
+	{
+    aDes.Append( '[' );
+    const TInt length = aDes.Length();
+    AppendExitType( aDes, aType );
+    aDes.SetLength( length + 1 ); // Remove all but the first letter
+    aDes.Append( ']' );
+    
+    if  ( aType == EExitKill || aType == EExitPending )
+        {
+        // Kill implies "clean" exit. Pending implies not yet dead.
+        }
+    else
+        {
+        TMemSpyTruncateOverflow overflow;
+
+        // Terminate or Panic implies abnormal exit condition, so
+        // show full exit info.
+        _LIT( KAbnormalFormatSpec, " %S-%d" );
+        aDes.AppendFormat( KAbnormalFormatSpec, &overflow, &aExitCategory, aExitReason );
+        }
+	}
+
+
+void MemSpyUiUtils::AppendExitType( TDes& aDes, TExitType aType )
+    {
+    _LIT( KExitTypeKilled, "Killed" );
+    _LIT( KExitTypeTerminated, "Terminated" );
+    _LIT( KExitTypePanicked, "Panicked" );
+    _LIT( KExitTypePending, "Pending" );
+    
+    // Panic and Terminate are exceptional exit conditions.
+    // Kill, is ironically, not an exceptional condition.
+    switch( aType )
+        {
+    case EExitKill:
+        aDes += KExitTypeKilled;
+        break;
+    case EExitTerminate:
+        aDes += KExitTypeTerminated;
+        break;
+    case EExitPanic:
+        aDes += KExitTypePanicked;
+        break;
+    default:
+    case EExitPending:
+        aDes += KExitTypePending;
+        break;
+        }
+    }
+
+
+TPtrC MemSpyUiUtils::TypeAsString( TMemSpyDriverContainerType aType )
+    {     
+    TPtrC pType( KTypeUnknown );
+    //
+    switch( aType )
+        {
+    case EMemSpyDriverContainerTypeThread:
+        pType.Set( KTypeThread );
+        break;
+    case EMemSpyDriverContainerTypeProcess:
+        pType.Set( KTypeProcess );
+        break;
+    case EMemSpyDriverContainerTypeChunk:
+        pType.Set( KTypeChunk );
+        break;
+    case EMemSpyDriverContainerTypeLibrary:
+        pType.Set( KTypeLibrary );
+        break;
+    case EMemSpyDriverContainerTypeSemaphore:
+        pType.Set( KTypeSemaphore );
+        break;
+    case EMemSpyDriverContainerTypeMutex:
+        pType.Set( KTypeMutex );
+        break;
+    case EMemSpyDriverContainerTypeTimer:
+        pType.Set( KTypeTimer );
+        break;
+    case EMemSpyDriverContainerTypeServer:
+        pType.Set( KTypeServer );
+        break;
+    case EMemSpyDriverContainerTypeSession:
+        pType.Set( KTypeSession );
+        break;
+    case EMemSpyDriverContainerTypeLogicalDevice:
+        pType.Set( KTypeLogicalDevice );
+        break;
+    case EMemSpyDriverContainerTypePhysicalDevice:
+        pType.Set( KTypePhysicalDevice );
+        break;
+    case EMemSpyDriverContainerTypeLogicalChannel:
+        pType.Set( KTypeLogicalChannel );
+        break;
+    case EMemSpyDriverContainerTypeChangeNotifier:
+        pType.Set( KTypeChangeNotifier );
+        break;
+    case EMemSpyDriverContainerTypeUndertaker:
+        pType.Set( KTypeUndertaker );
+        break;
+    case EMemSpyDriverContainerTypeMsgQueue:
+        pType.Set( KTypeMsgQueue );
+        break;
+    case EMemSpyDriverContainerTypePropertyRef:
+        pType.Set( KTypePropertyRef );
+        break;
+    case EMemSpyDriverContainerTypeCondVar:
+        pType.Set( KTypeCondVar );
+        break;
+        
+    default:
+        break;
+        }
+    //
+    return pType;
+    }
+
+TMemSpySizeText MemSpyUiUtils::FormatSizeText( const TInt64& aValue, TInt aDecimalPlaces, TBool aExtraRounding )
+    {
+    _LIT(KFormatKilo, "%dK");
+    _LIT(KFormatMega, "%SM");
+    _LIT(KFormatGiga, "%SG");
+
+	TMemSpySizeText buf;
+	if  ( aValue < 1024000 )					// If < 1000K
+		{
+		TInt sizeInK = 0;
+
+        if  ( aValue != 0 )
+			{
+			sizeInK = I64INT( (aValue + 512) >> 10 );
+			if  (sizeInK < 1)
+                {
+				sizeInK = 1;
+                }
+			if  (sizeInK > 999)
+                {
+				sizeInK = 999;
+                }
+			}
+
+        buf.Format( KFormatKilo, sizeInK );
+		}
+	else
+		{
+		TReal sizeInM = I64INT( aValue );
+		sizeInM /= 1048576;
+		if  ( sizeInM < 1 )
+            {
+			sizeInM = 1;
+            }
+
+        TPtrC pFormat( KFormatMega );
+		if  ( sizeInM >= 1000 )
+			{
+			sizeInM /= 1024;				// Size in G
+			if  (sizeInM < 1)
+                {
+				sizeInM = 1;
+                }
+			
+            pFormat.Set( KFormatGiga );
+			}
+
+        if  ( sizeInM > 999.9)
+            {
+            sizeInM = 999.9;
+            }
+
+        if  ( aExtraRounding )
+            {
+			sizeInM += 0.499999;
+            }
+
+		TBuf<16> size;
+		size.Num( sizeInM, TRealFormat( 14, aDecimalPlaces ) );	// Allow for "17179869184.0"G which is 2^64
+        buf.Format( pFormat, &size );
+		}
+
+    return buf;
+    }