66 HBufC* MemSpyUiUtils::FormatItem( const TDesC& aCaption )

    67 	{

    68 	HBufC* retBuf = HBufC::NewL( 32 );

    69 	TPtr pRetBuf( retBuf->Des() );

    70 	pRetBuf.Zero();

    71 	pRetBuf.Append( _L("\t") );

    72 	pRetBuf.Append( aCaption );

    73 	return retBuf;

    74 	}

    75 

    76 TDesC& MemSpyUiUtils::ThreadInfoItemNameByType( TMemSpyThreadInfoItemType aType )

    77 	{	

    78 	TPtrC pType( KTypeUnknown );

    79 	

    80 	switch( aType )

    81 		{

    82 		case EMemSpyThreadInfoItemTypeFirst:			

    83 			pType.Set(KGeneral);

    84 			break;			

    85 		case EMemSpyThreadInfoItemTypeHeap:			

    86 			pType.Set(KHeap);

    87 			break;				

    88 		case EMemSpyThreadInfoItemTypeStack:			

    89 			pType.Set(KStack);

    90 			break;			

    91 		case EMemSpyThreadInfoItemTypeChunk:			

    92 			pType.Set(KChunks);

    93 			break;

    94 		case EMemSpyThreadInfoItemTypeCodeSeg:

    95 			pType.Set(KCodeSegs);

    96 			break;

    97 		case EMemSpyThreadInfoItemTypeOpenFiles:

    98 			pType.Set(KOpenFiles);

    99 			break;	

   100 		case EMemSpyThreadInfoItemTypeActiveObject:

   101 			pType.Set(KActiveObjects);

   102 			break;

   103 		case EMemSpyThreadInfoItemTypeOwnedThreadHandles:

   104 			pType.Set(KThreadHandlers);

   105 			break;

   106 		case EMemSpyThreadInfoItemTypeOwnedProcessHandles:

   107 			pType.Set(KProcessHandlers);

   108 			break;

   109 		case EMemSpyThreadInfoItemTypeServer:

   110 			pType.Set(KServers);

   111 			break;

   112 		case EMemSpyThreadInfoItemTypeSession:

   113 			pType.Set(KConnections);

   114 			break;

   115 		case EMemSpyThreadInfoItemTypeSemaphore:

   116 			pType.Set(KSemaphores);

   117 			break;

   118 		case EMemSpyThreadInfoItemTypeOtherThreads:

   119 			pType.Set(KThreadReferences);

   120 			break;

   121 		case EMemSpyThreadInfoItemTypeOtherProcesses:

   122 			pType.Set(KProcessReferences);

   123 			break;

   124 		case EMemSpyThreadInfoItemTypeMutex:

   125 			pType.Set(KMutexes);

   126 			break;

   127 		case EMemSpyThreadInfoItemTypeTimer:

   128 			pType.Set(KTimers);					

   129 			break;

   130 		case EMemSpyThreadInfoItemTypeLogicalChannel:

   131 			pType.Set(KDD);

   132 			break;

   133 		case EMemSpyThreadInfoItemTypeChangeNotifier:

   134 			pType.Set(KChangeNotif);

   135 			break;

   136 		case EMemSpyThreadInfoItemTypeUndertaker:

   137 			pType.Set(KUndertakers);

   138 			break;				

   139 		case EMemSpyThreadInfoItemTypeLDD:

   140 			pType.Set(KLogicalDrivers);

   141 			break;

   142 		case EMemSpyThreadInfoItemTypePDD:

   143 			pType.Set(KPhysicalDrivers);

   144 			break;

   145 			

   146 	    default:	       

   147 	    	break;  

   148 		}

   149 	return pType;

   150 	}

   151 

   152 

   153 void MemSpyUiUtils::AppendPriority( TDes& aDes, TProcessPriority aPriority )

   154 	{

   155 	switch( aPriority )

   156 		{

   157 	    case EPriorityLow:

   158 	        aDes += _L("[L]");

   159 	        break;

   160 	    case EPriorityBackground:

   161 	        aDes += _L("[B]");

   162 	        break;

   163 	    case EPriorityForeground:

   164 	        aDes += _L("[F]");

   165 	        break;

   166 	    case EPriorityHigh:

   167 	        aDes += _L("[H]");

   168 	        break;

   169 	    case EPriorityWindowServer:

   170 	        aDes += _L("[WS]");

   171 	        break;

   172 	    case EPriorityFileServer:

   173 	        aDes += _L("[FS]");

   174 	        break;

   175 	    case EPriorityRealTimeServer:

   176 	        aDes += _L("[RTS]");

   177 	        break;

   178 	    case EPrioritySupervisor:

   179 	        aDes += _L("[SUP]");

   180 	        break;

   181 	    default:

   182 	        aDes += _L("[?]");

   183 	        break;

   184 		}

   185 	}

   186 

   187 void MemSpyUiUtils::AppendExitInfo( TDes& aDes, TExitType aType, TInt aExitReason, const TDesC& aExitCategory  )

   188 	{

   189     aDes.Append( '[' );

   190     const TInt length = aDes.Length();

   191     AppendExitType( aDes, aType );

   192     aDes.SetLength( length + 1 ); // Remove all but the first letter

   193     aDes.Append( ']' );

   194     

   195     if  ( aType == EExitKill || aType == EExitPending )

   196         {

   197         // Kill implies "clean" exit. Pending implies not yet dead.

   198         }

   199     else

   200         {

   201         TMemSpyTruncateOverflow overflow;

   202 

   203         // Terminate or Panic implies abnormal exit condition, so

   204         // show full exit info.

   205         _LIT( KAbnormalFormatSpec, " %S-%d" );

   206         aDes.AppendFormat( KAbnormalFormatSpec, &overflow, &aExitCategory, aExitReason );

   207         }

   208 	}

   209 

   210 

   211 void MemSpyUiUtils::AppendExitType( TDes& aDes, TExitType aType )

   212     {

   213     _LIT( KExitTypeKilled, "Killed" );

   214     _LIT( KExitTypeTerminated, "Terminated" );

   215     _LIT( KExitTypePanicked, "Panicked" );

   216     _LIT( KExitTypePending, "Pending" );

   217     

   218     // Panic and Terminate are exceptional exit conditions.

   219     // Kill, is ironically, not an exceptional condition.

   220     switch( aType )

   221         {

   222     case EExitKill:

   223         aDes += KExitTypeKilled;

   224         break;

   225     case EExitTerminate:

   226         aDes += KExitTypeTerminated;

   227         break;

   228     case EExitPanic:

   229         aDes += KExitTypePanicked;

   230         break;

   231     default:

   232     case EExitPending:

   233         aDes += KExitTypePending;

   234         break;

   235         }

   236     }

   237 

   238 

   239 TPtrC MemSpyUiUtils::TypeAsString( TMemSpyDriverContainerType aType )

   240     {     

   241     TPtrC pType( KTypeUnknown );

   242     //

   243     switch( aType )

   244         {

   245     case EMemSpyDriverContainerTypeThread:

   246         pType.Set( KTypeThread );

   247         break;

   248     case EMemSpyDriverContainerTypeProcess:

   249         pType.Set( KTypeProcess );

   250         break;

   251     case EMemSpyDriverContainerTypeChunk:

   252         pType.Set( KTypeChunk );

   253         break;

   254     case EMemSpyDriverContainerTypeLibrary:

   255         pType.Set( KTypeLibrary );

   256         break;

   257     case EMemSpyDriverContainerTypeSemaphore:

   258         pType.Set( KTypeSemaphore );

   259         break;

   260     case EMemSpyDriverContainerTypeMutex:

   261         pType.Set( KTypeMutex );

   262         break;

   263     case EMemSpyDriverContainerTypeTimer:

   264         pType.Set( KTypeTimer );

   265         break;

   266     case EMemSpyDriverContainerTypeServer:

   267         pType.Set( KTypeServer );

   268         break;

   269     case EMemSpyDriverContainerTypeSession:

   270         pType.Set( KTypeSession );

   271         break;

   272     case EMemSpyDriverContainerTypeLogicalDevice:

   273         pType.Set( KTypeLogicalDevice );

   274         break;

   275     case EMemSpyDriverContainerTypePhysicalDevice:

   276         pType.Set( KTypePhysicalDevice );

   277         break;

   278     case EMemSpyDriverContainerTypeLogicalChannel:

   279         pType.Set( KTypeLogicalChannel );

   280         break;

   281     case EMemSpyDriverContainerTypeChangeNotifier:

   282         pType.Set( KTypeChangeNotifier );

   283         break;

   284     case EMemSpyDriverContainerTypeUndertaker:

   285         pType.Set( KTypeUndertaker );

   286         break;

   287     case EMemSpyDriverContainerTypeMsgQueue:

   288         pType.Set( KTypeMsgQueue );

   289         break;

   290     case EMemSpyDriverContainerTypePropertyRef:

   291         pType.Set( KTypePropertyRef );

   292         break;

   293     case EMemSpyDriverContainerTypeCondVar:

   294         pType.Set( KTypeCondVar );

   295         break;

   296         

   297     default:

   298         break;

   299         }

   300     //

   301     return pType;

   302     }

   303 

   304 TMemSpySizeText MemSpyUiUtils::FormatSizeText( const TInt64& aValue, TInt aDecimalPlaces, TBool aExtraRounding )

   305     {

   306     _LIT(KFormatKilo, "%dK");

   307     _LIT(KFormatMega, "%SM");

   308     _LIT(KFormatGiga, "%SG");

   309 

   310 	TMemSpySizeText buf;

   311 	if  ( aValue < 1024000 )					// If < 1000K

   312 		{

   313 		TInt sizeInK = 0;

   314 

   315         if  ( aValue != 0 )

   316 			{

   317 			sizeInK = I64INT( (aValue + 512) >> 10 );

   318 			if  (sizeInK < 1)

   319                 {

   320 				sizeInK = 1;

   321                 }

   322 			if  (sizeInK > 999)

   323                 {

   324 				sizeInK = 999;

   325                 }

   326 			}

   327 

   328         buf.Format( KFormatKilo, sizeInK );

   329 		}

   330 	else

   331 		{

   332 		TReal sizeInM = I64INT( aValue );

   333 		sizeInM /= 1048576;

   334 		if  ( sizeInM < 1 )

   335             {

   336 			sizeInM = 1;

   337             }

   338 

   339         TPtrC pFormat( KFormatMega );

   340 		if  ( sizeInM >= 1000 )

   341 			{

   342 			sizeInM /= 1024;				// Size in G

   343 			if  (sizeInM < 1)

   344                 {

   345 				sizeInM = 1;

   346                 }

   347 			

   348             pFormat.Set( KFormatGiga );

   349 			}

   350 

   351         if  ( sizeInM > 999.9)

   352             {

   353             sizeInM = 999.9;

   354             }

   355 

   356         if  ( aExtraRounding )

   357             {

   358 			sizeInM += 0.499999;

   359             }

   360 

   361 		TBuf<16> size;

   362 		size.Num( sizeInM, TRealFormat( 14, aDecimalPlaces ) );	// Allow for "17179869184.0"G which is 2^64

   363         buf.Format( pFormat, &size );

   364 		}

   365 

   366     return buf;

   367     }