Mercurial Mercurial > oss > FCL > sf > app > rndtools / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
perfapps/memspyui/ui/avkon/src/MemSpyViewKernelHeap.cpp
changeset 53 819e59dfc032
parent 51 b048e15729d6
equal deleted inserted replaced
52:36d60d12b4af 53:819e59dfc032 
    96     }
 
    96     }
 
    97 
    97 
    98 
    98 
    99 void CMemSpyViewKernelHeap::SetListBoxModelL()
 
    99 void CMemSpyViewKernelHeap::SetListBoxModelL()
 
   100     {	
   100     {	
   101 	CMemSpyApiHeap* iHeap;
 
   101 	CMemSpyApiHeap* heap = iMemSpySession.GetHeap();
 
   102 	iHeap = iMemSpySession.GetHeap( );
 
   102 	User::LeaveIfNull( heap );
 
       
   103 	CleanupStack::PushL( heap );
 
   103 		
   104 		
   104 	CDesCArrayFlat* model = new (ELeave) CDesC16ArrayFlat( 22 );
 
   105 	CDesCArrayFlat* model = FormatModelLC( heap );	
   105 		
       
   106 	model = FormatModel( iHeap );	
       
   107 				
   106 				
   108 	CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );
 
   107 	CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );
 
   109 	listbox->Model()->SetItemTextArray( model );
 
   108 	listbox->Model()->SetItemTextArray( model );
 
   110 	listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );			
   109 	listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );
 
       
   110 	
       
   111 	CleanupStack::Pop( model );
 
       
   112 	CleanupStack::PopAndDestroy( heap );
 
   111 	}
 
   113 	}
 
   112 
   114 
   113 
   115 
   114 TBool CMemSpyViewKernelHeap::HandleCommandL( TInt aCommand )
 
   116 TBool CMemSpyViewKernelHeap::HandleCommandL( TInt aCommand )
 
   115     {
 
   117     {
 
   135     iMemSpySession.DumpKernelHeap();
 
   137     iMemSpySession.DumpKernelHeap();
 
   136     }
 
   138     }
 
   137 
   139 
   138 
   140 
   139 //CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModel( RArray<CMemSpyApiHeap*> &aHeap )
 
   141 //CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModel( RArray<CMemSpyApiHeap*> &aHeap )
 
   140 CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModel( CMemSpyApiHeap* aHeap )
 
   142 CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModelLC( CMemSpyApiHeap* aHeap )
 
   141 	{
 
   143 	{
 
   142 	CDesCArrayFlat* model = new (ELeave) CDesC16ArrayFlat( 2 );
 
   144 	CDesCArrayFlat* model = new (ELeave) CDesC16ArrayFlat( 2 );
 
       
   145 	CleanupStack::PushL( model );
 
   143 	
   146 	
   144 	if (aHeap) 
   147 	if (aHeap) 
   145 	    {
 
   148 	    {
 
   146         _LIT( KItem0, "Heap type" );		   	  
   149         _LIT( KItem0, "Heap type" );		   	  
   147         _LIT( KItem1, "Heap size" );	  
   150         _LIT( KItem1, "Heap size" );	  
   164         _LIT( KItem9d, "Overhead" );
 
   167         _LIT( KItem9d, "Overhead" );
 
   165         _LIT( KItem10, "Min. length" );
 
   168         _LIT( KItem10, "Min. length" );
 
   166         _LIT( KItem11, "Max. length" );
 
   169         _LIT( KItem11, "Max. length" );
 
   167         _LIT( KItem12, "Debug Allocator Library" );
 
   170         _LIT( KItem12, "Debug Allocator Library" );
 
   168          
   171          
   169         HBufC* hItem = FormatItem( KItem0, aHeap->Type() );
 
   172         HBufC* hItem = FormatItemLC( KItem0, aHeap->Type() );
 
   170         TPtr pItem(hItem->Des());
 
   173         TPtr pItem(hItem->Des());
 
   171         model->AppendL( pItem );
 
   174         model->AppendL( pItem );
 
       
   175         CleanupStack::PopAndDestroy( hItem );
 
   172         pItem.Zero();	
   176         pItem.Zero();	
   173         
   177         
   174         hItem = FormatItem( KItem1, aHeap->Size() );
 
   178         hItem = FormatItemLC( KItem1, aHeap->Size() );
 
   175         pItem = hItem->Des();
 
   179         pItem = hItem->Des();
 
   176         model->AppendL( pItem );
 
   180         model->AppendL( pItem );
 
       
   181         CleanupStack::PopAndDestroy( hItem );
 
   177         pItem.Zero();	
   182         pItem.Zero();	
   178         
   183         
   179         TUint address( aHeap->BaseAddress() );	
   184         TUint address( aHeap->BaseAddress() );	
   180         hItem = FormatItem( KItem8b, address );
 
   185         hItem = FormatItemLC( KItem8b, address );
 
   181         pItem = hItem->Des();
 
   186         pItem = hItem->Des();
 
   182         model->AppendL( pItem );
 
   187         model->AppendL( pItem );
 
       
   188         CleanupStack::PopAndDestroy( hItem );
 
   183         pItem.Zero();
 
   189         pItem.Zero();
 
   184         
   190         
   185         if(aHeap->Shared()) //Yes / No value formatting		
   191         if(aHeap->Shared()) //Yes / No value formatting		
   186             hItem = FormatItem( KItem1b, KMemSpyCaptionYes );		
   192             hItem = FormatItemLC( KItem1b, KMemSpyCaptionYes );		
   187         else		
   193         else		
   188             hItem = FormatItem( KItem1b, KMemSpyCaptionNo );	
   194             hItem = FormatItemLC( KItem1b, KMemSpyCaptionNo );	
   189         pItem = hItem->Des();
 
   195         pItem = hItem->Des();
 
   190         model->AppendL( pItem );
 
   196         model->AppendL( pItem );
 
   191         pItem.Zero();
 
   197         CleanupStack::PopAndDestroy( hItem );
 
   192         
   198         pItem.Zero();
 
   193         hItem = FormatItem( KItem2, aHeap->ChunkSize() );
 
   199         
   194         pItem = hItem->Des();
 
   200         hItem = FormatItemLC( KItem2, aHeap->ChunkSize() );
 
   195         model->AppendL( pItem );
 
   201         pItem = hItem->Des();
 
   196         pItem.Zero();
 
   202         model->AppendL( pItem );
 
   197         
   203         CleanupStack::PopAndDestroy( hItem );
 
   198         hItem = FormatItem( KItem3, aHeap->AllocationsCount() );
 
   204         pItem.Zero();
 
   199         pItem = hItem->Des();
 
   205         
   200         model->AppendL( pItem );
 
   206         hItem = FormatItemLC( KItem3, aHeap->AllocationsCount() );
 
   201         pItem.Zero();
 
   207         pItem = hItem->Des();
 
   202         
   208         model->AppendL( pItem );
 
   203         hItem = FormatItem( KItem4, aHeap->FreeCount() );
 
   209         CleanupStack::PopAndDestroy( hItem );
 
   204         pItem = hItem->Des();
 
   210         pItem.Zero();
 
   205         model->AppendL( pItem );
 
   211         
   206         pItem.Zero();
 
   212         hItem = FormatItemLC( KItem4, aHeap->FreeCount() );
 
   207         
   213         pItem = hItem->Des();
 
   208         hItem = FormatItem( KItem5, aHeap->BiggestAllocation() );
 
   214         model->AppendL( pItem );
 
   209         pItem = hItem->Des();
 
   215         CleanupStack::PopAndDestroy( hItem );
 
   210         model->AppendL( pItem );
 
   216         pItem.Zero();
 
   211         pItem.Zero();
 
   217         
   212         
   218         hItem = FormatItemLC( KItem5, aHeap->BiggestAllocation() );
 
   213         hItem = FormatItem( KItem6, aHeap->BiggestFree() );
 
   219         pItem = hItem->Des();
 
   214         pItem = hItem->Des();
 
   220         model->AppendL( pItem );
 
   215         model->AppendL( pItem );
 
   221         CleanupStack::PopAndDestroy( hItem );
 
   216         pItem.Zero();
 
   222         pItem.Zero();
 
   217         
   223         
   218         hItem = FormatItem( KItem6a, aHeap->TotalAllocations() );
 
   224         hItem = FormatItemLC( KItem6, aHeap->BiggestFree() );
 
   219         pItem = hItem->Des();
 
   225         pItem = hItem->Des();
 
   220         model->AppendL( pItem );
 
   226         model->AppendL( pItem );
 
   221         pItem.Zero();
 
   227         CleanupStack::PopAndDestroy( hItem );
 
   222         
   228         pItem.Zero();
 
   223         hItem = FormatItem( KItem6b, aHeap->TotalFree() );
 
   229         
   224         pItem = hItem->Des();
 
   230         hItem = FormatItemLC( KItem6a, aHeap->TotalAllocations() );
 
   225         model->AppendL( pItem );
 
   231         pItem = hItem->Des();
 
   226         pItem.Zero();
 
   232         model->AppendL( pItem );
 
   227         
   233         CleanupStack::PopAndDestroy( hItem );
 
   228         hItem = FormatItem( KItem7, aHeap->SlackFreeSpace() );
 
   234         pItem.Zero();
 
   229         pItem = hItem->Des();
 
   235         
   230         model->AppendL( pItem );
 
   236         hItem = FormatItemLC( KItem6b, aHeap->TotalFree() );
 
       
   237         pItem = hItem->Des();
 
       
   238         model->AppendL( pItem );
 
       
   239         CleanupStack::PopAndDestroy( hItem );
 
       
   240         pItem.Zero();
 
       
   241         
       
   242         hItem = FormatItemLC( KItem7, aHeap->SlackFreeSpace() );
 
       
   243         pItem = hItem->Des();
 
       
   244         model->AppendL( pItem );
 
       
   245         CleanupStack::PopAndDestroy( hItem );
 
   231         pItem.Zero();
 
   246         pItem.Zero();
 
   232         
   247         
   233         TReal iOneHundred( aHeap->Size() );
 
   248         TReal iOneHundred( aHeap->Size() );
 
   234         TReal iValue( aHeap->Fragmentation() );	
   249         TReal iValue( aHeap->Fragmentation() );	
   235         hItem = FormatPercentageItem( KItem8a, iOneHundred, iValue );
 
   250         hItem = FormatPercentageItemLC( KItem8a, iOneHundred, iValue );
 
   236         pItem = hItem->Des();
 
   251         pItem = hItem->Des();
 
   237         model->AppendL( pItem );
 
   252         model->AppendL( pItem );
 
   238         pItem.Zero();
 
   253         CleanupStack::PopAndDestroy( hItem );
 
   239         
   254         pItem.Zero();
 
   240         hItem = FormatItem( KItem13, aHeap->HeaderSizeA() );
 
   255         
   241         pItem = hItem->Des();
 
   256         hItem = FormatItemLC( KItem13, aHeap->HeaderSizeA() );
 
   242         model->AppendL( pItem );
 
   257         pItem = hItem->Des();
 
   243         pItem.Zero();
 
   258         model->AppendL( pItem );
 
   244         
   259         CleanupStack::PopAndDestroy( hItem );
 
   245         hItem = FormatItem( KItem14, aHeap->HeaderSizeF() );
 
   260         pItem.Zero();
 
   246         pItem = hItem->Des();
 
   261         
   247         model->AppendL( pItem );
 
   262         hItem = FormatItemLC( KItem14, aHeap->HeaderSizeF() );
 
   248         pItem.Zero();
 
   263         pItem = hItem->Des();
 
   249         
   264         model->AppendL( pItem );
 
   250         hItem = FormatItem( KItem9a, aHeap->AllocationOverhead() );
 
   265         CleanupStack::PopAndDestroy( hItem );
 
   251         pItem = hItem->Des();
 
   266         pItem.Zero();
 
   252         model->AppendL( pItem );
 
   267         
   253         pItem.Zero();
 
   268         hItem = FormatItemLC( KItem9a, aHeap->AllocationOverhead() );
 
   254         
   269         pItem = hItem->Des();
 
   255         hItem = FormatItem( KItem9b, aHeap->FreeOverhead() );
 
   270         model->AppendL( pItem );
 
   256         pItem = hItem->Des();
 
   271         CleanupStack::PopAndDestroy( hItem );
 
   257         model->AppendL( pItem );
 
   272         pItem.Zero();
 
   258         pItem.Zero();
 
   273         
   259         
   274         hItem = FormatItemLC( KItem9b, aHeap->FreeOverhead() );
 
   260         hItem = FormatItem( KItem9c, aHeap->TotalOverhead() );
 
   275         pItem = hItem->Des();
 
   261         pItem = hItem->Des();
 
   276         model->AppendL( pItem );
 
   262         model->AppendL( pItem );
 
   277         CleanupStack::PopAndDestroy( hItem );
 
       
   278         pItem.Zero();
 
       
   279         
       
   280         hItem = FormatItemLC( KItem9c, aHeap->TotalOverhead() );
 
       
   281         pItem = hItem->Des();
 
       
   282         model->AppendL( pItem );
 
       
   283         CleanupStack::PopAndDestroy( hItem );
 
   263         pItem.Zero();
 
   284         pItem.Zero();
 
   264         
   285         
   265         TReal iOverhead( aHeap->Overhead() );	
   286         TReal iOverhead( aHeap->Overhead() );	
   266         hItem = FormatPercentageItem( KItem9d, iOneHundred, iOverhead );	
   287         hItem = FormatPercentageItemLC( KItem9d, iOneHundred, iOverhead );	
   267         pItem = hItem->Des();
 
   288         pItem = hItem->Des();
 
   268         model->AppendL( pItem );
 
   289         model->AppendL( pItem );
 
   269         pItem.Zero();
 
   290         CleanupStack::PopAndDestroy( hItem );
 
   270         
   291         pItem.Zero();
 
   271         hItem = FormatItem( KItem10, aHeap->MinLength() );
 
   292         
   272         pItem = hItem->Des();
 
   293         hItem = FormatItemLC( KItem10, aHeap->MinLength() );
 
   273         model->AppendL( pItem );
 
   294         pItem = hItem->Des();
 
       
   295         model->AppendL( pItem );
 
       
   296         CleanupStack::PopAndDestroy( hItem );
 
   274         pItem.Zero();
 
   297         pItem.Zero();
 
   275             
   298             
   276         hItem = FormatItem( KItem11, aHeap->MaxLength() );
 
   299         hItem = FormatItemLC( KItem11, aHeap->MaxLength() );
 
   277         pItem = hItem->Des();
 
   300         pItem = hItem->Des();
 
   278         model->AppendL( pItem );
 
   301         model->AppendL( pItem );
 
       
   302         CleanupStack::PopAndDestroy( hItem );
 
   279         pItem.Zero();
 
   303         pItem.Zero();
 
   280         
   304         
   281         if( aHeap->DebugAllocatorLibrary() )		
   305         if( aHeap->DebugAllocatorLibrary() )		
   282             hItem = FormatItem( KItem12, KMemSpyCaptionYes );		
   306             hItem = FormatItemLC( KItem12, KMemSpyCaptionYes );		
   283         else
 
   307         else
 
   284             hItem = FormatItem( KItem12, KMemSpyCaptionNo );	
   308             hItem = FormatItemLC( KItem12, KMemSpyCaptionNo );	
   285         pItem = hItem->Des();
 
   309         pItem = hItem->Des();
 
   286         model->AppendL( pItem );
 
   310         model->AppendL( pItem );
 
       
   311         CleanupStack::PopAndDestroy( hItem );
 
   287         pItem.Zero();
 
   312         pItem.Zero();
 
   288 	    }
 
   313 	    }
 
   289 	else
 
   314 	else
 
   290 	    {
 
   315 	    {
 
   291         HBufC* hItem = FormatItem( _L("Not Found"), _L("") );
 
   316         HBufC* hItem = FormatItemLC( _L("Not Found"), _L("") );
 
   292         TPtr pItem(hItem->Des());
 
   317         TPtr pItem(hItem->Des());
 
   293         model->AppendL( pItem );
 
   318         model->AppendL( pItem );
 
       
   319         CleanupStack::PopAndDestroy( hItem );
 
   294         pItem.Zero();	    
   320         pItem.Zero();	    
   295 	    }
 
   321 	    }
 
   296 	
   322 	
   297 	return model;
 
   323 	return model;
 
   298 	}
 
   324 	}
 
   299 
   325 
   300 HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, const TDesC& aValue )
 
   326 HBufC* CMemSpyViewKernelHeap::FormatItemLC( const TDesC& aCaption, const TDesC& aValue )
 
   301 	{
 
   327 	{
 
   302 	HBufC* retBuf = HBufC::NewL( KMaxName );
 
   328 	HBufC* retBuf = HBufC::NewLC( KMaxName );
 
   303 	TPtr pRetBuf( retBuf->Des() );
 
   329 	TPtr pRetBuf( retBuf->Des() );
 
   304 	pRetBuf.Zero();
 
   330 	pRetBuf.Zero();
 
   305 	pRetBuf.Append( _L("\t") );
 
   331 	pRetBuf.Append( _L("\t") );
 
   306 	pRetBuf.Append( aCaption );
 
   332 	pRetBuf.Append( aCaption );
 
   307 	pRetBuf.Append( _L("\t\t") );
 
   333 	pRetBuf.Append( _L("\t\t") );
 
   308 	pRetBuf.Append( aValue );
 
   334 	pRetBuf.Append( aValue );
 
   309 	return retBuf;
 
   335 	return retBuf;
 
   310 	}
 
   336 	}
 
   311 
   337 
   312 HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TInt aValue )
 
   338 HBufC* CMemSpyViewKernelHeap::FormatItemLC( const TDesC& aCaption, TInt aValue )
 
   313 	{
 
   339 	{
 
   314 	HBufC* retBuf = HBufC::NewL( KMaxName );
 
   340 	HBufC* retBuf = HBufC::NewLC( KMaxName );
 
   315 	TPtr pRetBuf( retBuf->Des() );
 
   341 	TPtr pRetBuf( retBuf->Des() );
 
   316 	pRetBuf.Zero();
 
   342 	pRetBuf.Zero();
 
   317     
   343     
   318 	TBuf<KMemSpyBufferSize> val;
 
   344 	TBuf<KMemSpyBufferSize> val;
 
   319     val.Format( KMemSpyDecFormat, aValue );
 
   345     val.Format( KMemSpyDecFormat, aValue );
 
   324     pRetBuf.Append( val );    
   350     pRetBuf.Append( val );    
   325 	
   351 	
   326 	return retBuf;
 
   352 	return retBuf;
 
   327 	}
 
   353 	}
 
   328 
   354 
   329 HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint aValue )
 
   355 HBufC* CMemSpyViewKernelHeap::FormatItemLC( const TDesC& aCaption, TUint aValue )
 
   330 	{
 
   356 	{
 
   331 	HBufC* retBuf = HBufC::NewL( KMaxName );
 
   357 	HBufC* retBuf = HBufC::NewLC( KMaxName );
 
   332 	TPtr pRetBuf( retBuf->Des() );
 
   358 	TPtr pRetBuf( retBuf->Des() );
 
   333 	pRetBuf.Zero();
 
   359 	pRetBuf.Zero();
 
   334     
   360     
   335 	TBuf<KMemSpyBufferSize> val;
 
   361 	TBuf<KMemSpyBufferSize> val;
 
   336     //val.Format( KMemSpyDecFormat, aValue );
 
   362     //val.Format( KMemSpyDecFormat, aValue );
 
   342     pRetBuf.Append( val );    
   368     pRetBuf.Append( val );    
   343 	
   369 	
   344 	return retBuf;	
   370 	return retBuf;	
   345 	}
 
   371 	}
 
   346 
   372 
   347 HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, const TInt64& aValue )
 
   373 HBufC* CMemSpyViewKernelHeap::FormatItemLC( const TDesC& aCaption, const TInt64& aValue )
 
   348 	{
 
   374 	{
 
   349 	HBufC* retBuf = HBufC::NewL( KMaxName );
 
   375 	HBufC* retBuf = HBufC::NewLC( KMaxName );
 
   350 	TPtr pRetBuf( retBuf->Des() );
 
   376 	TPtr pRetBuf( retBuf->Des() );
 
   351 	pRetBuf.Zero();
 
   377 	pRetBuf.Zero();
 
   352 	    
   378 	    
   353 	TBuf<KMemSpyBufferSize> val;
 
   379 	TBuf<KMemSpyBufferSize> val;
 
   354 	val.Format( KMemSpyLongFormat, aValue );
 
   380 	val.Format( KMemSpyLongFormat, aValue );
 
   359 	pRetBuf.Append( val );    
   385 	pRetBuf.Append( val );    
   360 		
   386 		
   361 	return retBuf;	
   387 	return retBuf;	
   362 	}
 
   388 	}
 
   363 
   389 
   364 HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TAny* aValue )
 
   390 HBufC* CMemSpyViewKernelHeap::FormatItemLC( const TDesC& aCaption, TAny* aValue )
 
   365 	{
 
   391 	{
 
   366 	HBufC* retBuf = HBufC::NewL( KMaxName );
 
   392 	HBufC* retBuf = HBufC::NewLC( KMaxName );
 
   367 	TPtr pRetBuf( retBuf->Des() );
 
   393 	TPtr pRetBuf( retBuf->Des() );
 
   368 	pRetBuf.Zero();
 
   394 	pRetBuf.Zero();
 
   369 		    
   395 		    
   370 	TBuf<KMemSpyBufferSize> val;
 
   396 	TBuf<KMemSpyBufferSize> val;
 
   371 	val.Format( KMemSpyHexFormat, aValue );
 
   397 	val.Format( KMemSpyHexFormat, aValue );
 
   376 	pRetBuf.Append( val );    
   402 	pRetBuf.Append( val );    
   377 			
   403 			
   378 	return retBuf;	
   404 	return retBuf;	
   379 	}
 
   405 	}
 
   380 
   406 
   381 HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint* aValue )
 
   407 HBufC* CMemSpyViewKernelHeap::FormatItemLC( const TDesC& aCaption, TUint* aValue )
 
   382 	{
 
   408 	{
 
   383 	HBufC* retBuf = HBufC::NewL( KMaxName );
 
   409 	HBufC* retBuf = HBufC::NewLC( KMaxName );
 
   384 	TPtr pRetBuf( retBuf->Des() );
 
   410 	TPtr pRetBuf( retBuf->Des() );
 
   385 	pRetBuf.Zero();
 
   411 	pRetBuf.Zero();
 
   386 		    
   412 		    
   387 	TBuf<KMemSpyBufferSize> val;
 
   413 	TBuf<KMemSpyBufferSize> val;
 
   388 	val.Format( KMemSpyHexFormat, aValue );
 
   414 	val.Format( KMemSpyHexFormat, aValue );
 
   393 	pRetBuf.Append( val );    
   419 	pRetBuf.Append( val );    
   394 			
   420 			
   395 	return retBuf;	
   421 	return retBuf;	
   396 	}
 
   422 	}
 
   397 
   423 
   398 HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint8* aValue )
 
   424 HBufC* CMemSpyViewKernelHeap::FormatItemLC( const TDesC& aCaption, TUint8* aValue )
 
   399 	{
 
   425 	{
 
   400 	HBufC* retBuf = HBufC::NewL( KMaxName );
 
   426 	HBufC* retBuf = HBufC::NewLC( KMaxName );
 
   401 	TPtr pRetBuf( retBuf->Des() );
 
   427 	TPtr pRetBuf( retBuf->Des() );
 
   402 	pRetBuf.Zero();
 
   428 	pRetBuf.Zero();
 
   403 		    
   429 		    
   404 	TBuf<KMemSpyBufferSize> val;
 
   430 	TBuf<KMemSpyBufferSize> val;
 
   405 	val.Format( KMemSpyHexFormat, aValue );
 
   431 	val.Format( KMemSpyHexFormat, aValue );
 
   410 	pRetBuf.Append( val );    
   436 	pRetBuf.Append( val );    
   411 			
   437 			
   412 	return retBuf;	
   438 	return retBuf;	
   413 	}
 
   439 	}
 
   414 
   440 
   415 HBufC* CMemSpyViewKernelHeap::FormatPercentageItem( const TDesC& aCaption, TReal aOneHundredPercentValue, TReal aValue )
 
   441 HBufC* CMemSpyViewKernelHeap::FormatPercentageItemLC( const TDesC& aCaption, TReal aOneHundredPercentValue, TReal aValue )
 
   416 	{
 
   442 	{
 
   417 	HBufC* retBuf = HBufC::NewL( KMaxName );	//buffer for formatted item
 
   443 	HBufC* retBuf = HBufC::NewLC( KMaxName );	//buffer for formatted item
 
   418 	TPtr pRetBuf( retBuf->Des() );
 
   444 	TPtr pRetBuf( retBuf->Des() );
 
   419 	pRetBuf.Zero();
 
   445 	pRetBuf.Zero();
 
   420 	
   446 	
   421     const TReal value = (TInt) (( aValue / aOneHundredPercentValue) * 100.0); // percentage value calculation    
   447     const TReal value = (TInt) (( aValue / aOneHundredPercentValue) * 100.0); // percentage value calculation    
   422     _LIT(KPercentFormat, "%3.2f %%");
 
   448     _LIT(KPercentFormat, "%3.2f %%");
FCL/sf/app/rndtools