--- /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;
+ }