|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 #include "MemSpyViewHeapTrackingResults.h" |
|
19 |
|
20 // System includes |
|
21 #include <hal.h> |
|
22 #ifdef __EPOC32__ |
|
23 #include <e32rom.h> |
|
24 #endif |
|
25 |
|
26 // Engine includes |
|
27 #include <memspy/engine/memspyengine.h> |
|
28 #include <memspy/engine/memspyenginehelpersysmemtrackercycle.h> |
|
29 #include <memspy/engine/memspyenginehelpersysmemtrackercyclechange.h> |
|
30 #include <memspy/engine/memspyenginehelpersysmemtrackerenums.h> |
|
31 #include <memspy/engine/memspyenginehelpersysmemtracker.h> |
|
32 #include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h> |
|
33 #include <memspyui.rsg> |
|
34 #include <memspysession.h> |
|
35 |
|
36 // User includes |
|
37 #include "MemSpyUiUtils.h" |
|
38 #include "MemSpyContainer.h" |
|
39 #include "MemSpyViewHeapTracking.h" |
|
40 #include "MemSpyContainerObserver.h" |
|
41 |
|
42 |
|
43 _LIT( KCycle, "Cycle" ); |
|
44 _LIT( KTime, "Time" ); |
|
45 _LIT( KMemoryFree, "Memory Free" ); |
|
46 _LIT( KMemoryChange, "Memory Change (vs. Last Cycle)" ); |
|
47 _LIT( KNumOfChanges, "Number of Changes" ); |
|
48 |
|
49 CMemSpyViewHeapTrackingResults::CMemSpyViewHeapTrackingResults( RMemSpySession& aSession, MMemSpyViewObserver& aObserver ) |
|
50 : CMemSpyViewBase( aSession, aObserver ) |
|
51 { |
|
52 //iEngine.HelperSysMemTracker().SetObserver( this ); |
|
53 } |
|
54 |
|
55 |
|
56 CMemSpyViewHeapTrackingResults::~CMemSpyViewHeapTrackingResults() |
|
57 { |
|
58 //iEngine.HelperSysMemTracker().RemoveObserver( this ); |
|
59 } |
|
60 |
|
61 |
|
62 void CMemSpyViewHeapTrackingResults::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune ) |
|
63 { |
|
64 _LIT( KTitle, "Results Summary" ); |
|
65 SetTitleL( KTitle ); |
|
66 // |
|
67 CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune ); |
|
68 |
|
69 // Make sure the correct item is selected |
|
70 const TInt cycleNumber = ((TInt) aSelectionRune); |
|
71 TInt maxCycle = iMemSpySession.GetSwmtCyclesCount(); |
|
72 if ( cycleNumber > 0 && cycleNumber <= maxCycle ) |
|
73 { |
|
74 iListBox->SetCurrentItemIndex( cycleNumber - 1 ); |
|
75 HandleListBoxItemSelectedL( cycleNumber ); |
|
76 } |
|
77 } |
|
78 |
|
79 |
|
80 void CMemSpyViewHeapTrackingResults::RefreshL() |
|
81 { |
|
82 SetListBoxModelL(); |
|
83 CMemSpyViewBase::RefreshL(); |
|
84 } |
|
85 |
|
86 |
|
87 TMemSpyViewType CMemSpyViewHeapTrackingResults::ViewType() const |
|
88 { |
|
89 return EMemSpyViewTypeHeapTrackingResults; |
|
90 } |
|
91 |
|
92 |
|
93 CMemSpyViewBase* CMemSpyViewHeapTrackingResults::PrepareParentViewL() |
|
94 { |
|
95 CMemSpyViewHeapTracking* parent = new(ELeave) CMemSpyViewHeapTracking( iMemSpySession, iObserver ); |
|
96 CleanupStack::PushL( parent ); |
|
97 parent->ConstructL( Rect(), *Parent(), (TAny*) ViewType() ); |
|
98 CleanupStack::Pop( parent ); |
|
99 // |
|
100 // iEngine.HelperSysMemTracker().RemoveObserver( this ); |
|
101 // |
|
102 return parent; |
|
103 } |
|
104 |
|
105 |
|
106 CMemSpyViewBase* CMemSpyViewHeapTrackingResults::PrepareChildViewL() |
|
107 { |
|
108 const TInt index = iListBox->CurrentItemIndex(); |
|
109 // |
|
110 CMemSpyViewBase* child = NULL; |
|
111 |
|
112 if ( index >= 0 ) |
|
113 { |
|
114 //const CMemSpyEngineHelperSysMemTrackerCycle* cycle = iEngine.HelperSysMemTracker().CompletedCycles()[ index ]; |
|
115 const CMemSpyApiMemoryTrackingCycle* cycle = iCycles[ index ]; |
|
116 // |
|
117 child = new(ELeave) CMemSpyViewHeapTrackingResultsCycleInfo( iMemSpySession, iObserver, *cycle ); |
|
118 CleanupStack::PushL( child ); |
|
119 child->ConstructL( Rect(), *Parent() ); |
|
120 CleanupStack::Pop( child ); |
|
121 // |
|
122 //iEngine.HelperSysMemTracker().RemoveObserver( this ); |
|
123 } |
|
124 |
|
125 // |
|
126 return child; |
|
127 } |
|
128 |
|
129 |
|
130 void CMemSpyViewHeapTrackingResults::SetListBoxModelL() |
|
131 { |
|
132 CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox ); |
|
133 |
|
134 iMemSpySession.GetMemoryTrackingCyclesL( iCycles ); |
|
135 |
|
136 CDesCArrayFlat* model = new (ELeave) CDesC16ArrayFlat( iCycles.Count()); |
|
137 |
|
138 for ( TInt i = 0; i < iCycles.Count(); i++ ) |
|
139 { |
|
140 HBufC* tempName = HBufC::NewL( iCycles[i]->Caption().Length() + 16 ); |
|
141 CleanupStack::PushL( tempName ); |
|
142 TPtr tempNamePtr( tempName->Des() ); |
|
143 |
|
144 TBuf<KMaxName> temp; |
|
145 temp.Copy(iCycles[i]->Caption()); |
|
146 tempNamePtr.Append( temp ); |
|
147 model->AppendL( tempNamePtr ); |
|
148 |
|
149 CleanupStack::PopAndDestroy( tempName ); |
|
150 } |
|
151 |
|
152 listbox->Model()->SetItemTextArray( model ); |
|
153 listbox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray ); |
|
154 } |
|
155 |
|
156 |
|
157 void CMemSpyViewHeapTrackingResults::HandleCyclesResetL() |
|
158 { |
|
159 CMemSpyViewBase::RefreshL(); |
|
160 } |
|
161 |
|
162 |
|
163 void CMemSpyViewHeapTrackingResults::HandleCycleStartedL( const CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ ) |
|
164 { |
|
165 } |
|
166 |
|
167 |
|
168 void CMemSpyViewHeapTrackingResults::HandleCycleFinishedL( const CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ ) |
|
169 { |
|
170 TInt count = iMemSpySession.GetSwmtCyclesCount(); |
|
171 SetListBoxCurrentItemIndexL( count - 1 ); |
|
172 CMemSpyViewBase::RefreshL(); |
|
173 } |
|
174 |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 |
|
191 |
|
192 |
|
193 |
|
194 |
|
195 |
|
196 |
|
197 |
|
198 |
|
199 |
|
200 |
|
201 |
|
202 |
|
203 |
|
204 |
|
205 |
|
206 CMemSpyViewHeapTrackingResultsCycleInfo::CMemSpyViewHeapTrackingResultsCycleInfo( RMemSpySession& aSession, MMemSpyViewObserver& aObserver, const CMemSpyApiMemoryTrackingCycle& aCycle ) |
|
207 : CMemSpyViewBase( aSession, aObserver ), iCycle( aCycle ) |
|
208 { |
|
209 //iEngine.HelperSysMemTracker().SetObserver( this ); |
|
210 } |
|
211 |
|
212 |
|
213 CMemSpyViewHeapTrackingResultsCycleInfo::~CMemSpyViewHeapTrackingResultsCycleInfo() |
|
214 { |
|
215 //iEngine.HelperSysMemTracker().RemoveObserver( this ); |
|
216 } |
|
217 |
|
218 |
|
219 void CMemSpyViewHeapTrackingResultsCycleInfo::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune ) |
|
220 { |
|
221 _LIT( KTitleFormat, "Cycle Summary [%04d]" ); |
|
222 TBuf<30> buf; |
|
223 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
224 SetTitleL( buf ); |
|
225 // |
|
226 CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune ); |
|
227 |
|
228 // Make sure the correct item is selected |
|
229 const TInt index = ((TInt) aSelectionRune); |
|
230 iListBox->SetCurrentItemIndex( index ); |
|
231 HandleListBoxItemSelectedL( index ); |
|
232 } |
|
233 |
|
234 |
|
235 void CMemSpyViewHeapTrackingResultsCycleInfo::RefreshL() |
|
236 { |
|
237 SetListBoxModelL(); |
|
238 CMemSpyViewBase::RefreshL(); |
|
239 } |
|
240 |
|
241 |
|
242 TMemSpyViewType CMemSpyViewHeapTrackingResultsCycleInfo::ViewType() const |
|
243 { |
|
244 return EMemSpyViewTypeHeapTrackingResultsCycleInfo; |
|
245 } |
|
246 |
|
247 |
|
248 CMemSpyViewBase* CMemSpyViewHeapTrackingResultsCycleInfo::PrepareParentViewL() |
|
249 { |
|
250 CMemSpyViewHeapTrackingResults* parent = new(ELeave) CMemSpyViewHeapTrackingResults( iMemSpySession, iObserver ); |
|
251 CleanupStack::PushL( parent ); |
|
252 parent->ConstructL( Rect(), *Parent(), (TAny*) iCycle.CycleNumber() ); |
|
253 CleanupStack::Pop( parent ); |
|
254 // |
|
255 //iEngine.HelperSysMemTracker().RemoveObserver( this ); |
|
256 // |
|
257 return parent; |
|
258 } |
|
259 |
|
260 |
|
261 void CMemSpyViewHeapTrackingResultsCycleInfo::SetListBoxModelL() |
|
262 { |
|
263 CDesCArrayFlat* model = new (ELeave) CDesC16ArrayFlat( 6 ); |
|
264 |
|
265 HBufC* buf = HBufC::NewL( 64 ); |
|
266 TPtr pBuf( buf->Des() ); |
|
267 |
|
268 TBuf<4> cycleBuf; |
|
269 _LIT( KCycleFormat, "%d"); |
|
270 cycleBuf.Format( KCycleFormat, iCycle.CycleNumber() ); |
|
271 |
|
272 pBuf.Zero(); |
|
273 pBuf.Append( _L("\t") ); |
|
274 pBuf.Append( KCycle ); |
|
275 pBuf.Append( _L("\t\t") ); |
|
276 pBuf.Append( cycleBuf ); |
|
277 model->AppendL( pBuf ); |
|
278 |
|
279 //time: |
|
280 TBuf<128> timeBuf; |
|
281 const TDateTime dt = iCycle.Time().DateTime(); |
|
282 // |
|
283 _LIT( KTimeFormatSpec, "%04d%02d%02d %02d:%02d:%02d" ); |
|
284 timeBuf.Format( KTimeFormatSpec, dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second() ); |
|
285 pBuf.Zero(); |
|
286 pBuf.Append( _L("\t")); |
|
287 pBuf.Append( KTime ); |
|
288 pBuf.Append( _L("\t\t") ); |
|
289 pBuf.Append( timeBuf ); |
|
290 model->AppendL( pBuf ); |
|
291 |
|
292 TBuf<16> memoryFreeBuf; |
|
293 memoryFreeBuf.Format( KCycleFormat, iCycle.FreeMemory() ); |
|
294 pBuf.Zero(); |
|
295 pBuf.Append( _L("\t") ); |
|
296 pBuf.Append( KMemoryFree ); |
|
297 pBuf.Append( _L("\t\t") ); |
|
298 pBuf.Append( memoryFreeBuf ); |
|
299 model->AppendL( pBuf ); |
|
300 |
|
301 memoryFreeBuf.Format( KCycleFormat, iCycle.MemoryDelta() ); |
|
302 pBuf.Zero(); |
|
303 pBuf.Append( _L("\t") ); |
|
304 pBuf.Append( KMemoryChange ); |
|
305 pBuf.Append( _L("\t\t") ); |
|
306 pBuf.Append( memoryFreeBuf ); |
|
307 model->AppendL( pBuf ); |
|
308 |
|
309 cycleBuf.Format( KCycleFormat, iCycle.ChangeCount() ); |
|
310 pBuf.Zero(); |
|
311 pBuf.Append( _L("\t") ); |
|
312 pBuf.Append( KNumOfChanges ); |
|
313 pBuf.Append( _L("\t\t") ); |
|
314 pBuf.Append( cycleBuf ); |
|
315 model->AppendL( pBuf ); |
|
316 |
|
317 CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox ); |
|
318 listbox->Model()->SetItemTextArray( model ); |
|
319 listbox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray ); |
|
320 } |
|
321 |
|
322 |
|
323 void CMemSpyViewHeapTrackingResultsCycleInfo::HandleCyclesResetL() |
|
324 { |
|
325 Container().NavigateToParentViewL(); |
|
326 } |
|
327 |
|
328 |
|
329 void CMemSpyViewHeapTrackingResultsCycleInfo::HandleCycleStartedL( const CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ ) |
|
330 { |
|
331 } |
|
332 |
|
333 |
|
334 void CMemSpyViewHeapTrackingResultsCycleInfo::HandleCycleFinishedL( const CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ ) |
|
335 { |
|
336 } |
|
337 |
|
338 |
|
339 |
|
340 |
|
341 |
|
342 |
|
343 |
|
344 |
|
345 |
|
346 |
|
347 |
|
348 |
|
349 |
|
350 |
|
351 |
|
352 |
|
353 |
|
354 |
|
355 |
|
356 |
|
357 |
|
358 |
|
359 |
|
360 |
|
361 |
|
362 |
|
363 |
|
364 |
|
365 |
|
366 |
|
367 |
|
368 |
|
369 |
|
370 |
|
371 |
|
372 |
|
373 |
|
374 |
|
375 |
|
376 |
|
377 /* |
|
378 |
|
379 |
|
380 |
|
381 CMemSpyViewHeapTrackingResultsChangeDescriptor::CMemSpyViewHeapTrackingResultsChangeDescriptor( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver, const CMemSpyEngineHelperSysMemTrackerCycle& aCycle, const CMemSpyEngineHelperSysMemTrackerCycleChange& aChangeDescriptor, TInt aIndex ) |
|
382 : CMemSpyViewBase( aEngine, aObserver ), iCycle( aCycle ), iChangeDescriptor( aChangeDescriptor ), iIndex( aIndex ) |
|
383 { |
|
384 iEngine.HelperSysMemTracker().SetObserver( this ); |
|
385 } |
|
386 |
|
387 |
|
388 CMemSpyViewHeapTrackingResultsChangeDescriptor::~CMemSpyViewHeapTrackingResultsChangeDescriptor() |
|
389 { |
|
390 iEngine.HelperSysMemTracker().RemoveObserver( this ); |
|
391 } |
|
392 |
|
393 |
|
394 void CMemSpyViewHeapTrackingResultsChangeDescriptor::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune ) |
|
395 { |
|
396 TBuf<30> buf; |
|
397 if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeHeapUser ) |
|
398 { |
|
399 _LIT( KTitleFormat, "User Heap Change [%04d]" ); |
|
400 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
401 } |
|
402 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeHeapKernel ) |
|
403 { |
|
404 _LIT( KTitleFormat, "Kernel Heap Change [%04d]" ); |
|
405 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
406 } |
|
407 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeChunk ) |
|
408 { |
|
409 _LIT( KTitleFormat, "Chunk Change [%04d]" ); |
|
410 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
411 } |
|
412 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeRamDrive ) |
|
413 { |
|
414 _LIT( KTitleFormat, "RAM Drive Change [%04d]" ); |
|
415 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
416 } |
|
417 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeStack ) |
|
418 { |
|
419 _LIT( KTitleFormat, "Stack Change [%04d]" ); |
|
420 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
421 } |
|
422 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeGlobalData ) |
|
423 { |
|
424 _LIT( KTitleFormat, "Global Data Change [%04d]" ); |
|
425 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
426 } |
|
427 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeCode ) |
|
428 { |
|
429 _LIT( KTitleFormat, "RAM-Loaded Code Change [%04d]" ); |
|
430 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
431 } |
|
432 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeHandle ) |
|
433 { |
|
434 _LIT( KTitleFormat, "Handle Change [%04d]" ); |
|
435 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
436 } |
|
437 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeOpenFile ) |
|
438 { |
|
439 _LIT( KTitleFormat, "Open File Change [%04d]" ); |
|
440 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
441 } |
|
442 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeDiskSpace ) |
|
443 { |
|
444 _LIT( KTitleFormat, "Disk Space Change [%04d]" ); |
|
445 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
446 } |
|
447 else if ( iChangeDescriptor.Type() == EMemSpyEngineSysMemTrackerTypeBitmap ) |
|
448 { |
|
449 _LIT( KTitleFormat, "Bitmap Change [%04d]" ); |
|
450 buf.Format( KTitleFormat, iCycle.CycleNumber() ); |
|
451 } |
|
452 // |
|
453 SetTitleL( buf ); |
|
454 // |
|
455 CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune ); |
|
456 } |
|
457 |
|
458 |
|
459 void CMemSpyViewHeapTrackingResultsChangeDescriptor::RefreshL() |
|
460 { |
|
461 SetListBoxModelL(); |
|
462 CMemSpyViewBase::RefreshL(); |
|
463 } |
|
464 |
|
465 |
|
466 TMemSpyViewType CMemSpyViewHeapTrackingResultsChangeDescriptor::ViewType() const |
|
467 { |
|
468 return EMemSpyViewTypeHeapTrackingResultsCycleChangeDescriptor; |
|
469 } |
|
470 |
|
471 |
|
472 CMemSpyViewBase* CMemSpyViewHeapTrackingResultsChangeDescriptor::PrepareParentViewL() |
|
473 { |
|
474 CMemSpyViewHeapTrackingResultsCycleInfo* parent = new(ELeave) CMemSpyViewHeapTrackingResultsCycleInfo( iEngine, iObserver, iCycle ); |
|
475 CleanupStack::PushL( parent ); |
|
476 parent->ConstructL( Rect(), *Parent(), (TAny*) iIndex ); |
|
477 CleanupStack::Pop( parent ); |
|
478 // |
|
479 iEngine.HelperSysMemTracker().RemoveObserver( this ); |
|
480 // |
|
481 return parent; |
|
482 } |
|
483 |
|
484 |
|
485 void CMemSpyViewHeapTrackingResultsChangeDescriptor::SetListBoxModelL() |
|
486 { |
|
487 MDesCArray& model = const_cast< MDesCArray& >( static_cast< const MDesCArray&>( iChangeDescriptor ) ); |
|
488 // |
|
489 CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox ); |
|
490 listbox->Model()->SetItemTextArray( &model ); |
|
491 listbox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray ); |
|
492 } |
|
493 |
|
494 |
|
495 void CMemSpyViewHeapTrackingResultsChangeDescriptor::HandleCyclesResetL() |
|
496 { |
|
497 CMemSpyViewHeapTrackingResults* mainResultsMenu = new(ELeave) CMemSpyViewHeapTrackingResults( iEngine, iObserver ); |
|
498 CleanupStack::PushL( mainResultsMenu ); |
|
499 mainResultsMenu->ConstructL( Rect(), *Parent() ); |
|
500 CleanupStack::Pop( mainResultsMenu ); |
|
501 // |
|
502 Container().SetNewActiveViewL( mainResultsMenu ); |
|
503 } |
|
504 |
|
505 |
|
506 void CMemSpyViewHeapTrackingResultsChangeDescriptor::HandleCycleStartedL( const CMemSpyEngineHelperSysMemTrackerCycle& aCycle ) |
|
507 { |
|
508 } |
|
509 |
|
510 |
|
511 void CMemSpyViewHeapTrackingResultsChangeDescriptor::HandleCycleFinishedL( const CMemSpyEngineHelperSysMemTrackerCycle& aCycle ) |
|
512 { |
|
513 } |
|
514 */ |
|
515 |