VBoxDbgStats.cpp@ 12329

Last change on this file since 12329 was 12183, checked in by vboxsync, 16 years ago
Debugger GUI: Having a go at the statistics view and hitting a extremely inefficient tree view. So, later.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 39.1 KB

Line
1	/* $Id: VBoxDbgStats.cpp 12183 2008-09-07 02:35:53Z vboxsync $ */
2	/** @file
3	* VBox Debugger GUI - Statistics.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_DBGG
27	#include "VBoxDbgStats.h"
28	#ifdef VBOXDBG_USE_QT4
29	# include <QLocale>
30	# include <QPushButton>
31	# include <QSpinBox>
32	# include <QLabel>
33	# include <QClipboard>
34	# include <QApplication>
35	# include <QHBoxLayout>
36	# include <QVBoxLayout>
37	#else
38	# include <qlocale.h>
39	# include <qpushbutton.h>
40	# include <qspinbox.h>
41	# include <qlabel.h>
42	# include <qclipboard.h>
43	# include <qapplication.h>
44	#endif
45
46	#include <VBox/err.h>
47	#include <VBox/log.h>
48	#include <iprt/string.h>
49	#include <iprt/assert.h>
50
51
52	#include <stdio.h> //remove me
53
54
55	/**
56	* Gets the last component of a statistics name string.
57	*
58	* @returns the last component in the name string.
59	*/
60	const char getNodeName(const char pszName)
61	{
62	const char *pszRet = strrchr(pszName, '/');
63	return pszRet && pszName[1] ? pszRet + 1 : pszName;
64	}
65
66
67
68
69
70
71	/*
72	*
73	* V B o x D b g S t a t s I t e m
74	* V B o x D b g S t a t s I t e m
75	* V B o x D b g S t a t s I t e m
76	*
77	*/
78
79
80	VBoxDbgStatsItem::VBoxDbgStatsItem(const char pszName, VBoxDbgStatsItem pParent, bool fBranch /= true/)
81	#ifdef VBOXDBG_USE_QT4
82	: QTreeWidgetItem(pParent, QStringList(QString(getNodeName(pszName)))),
83	#else
84	: QListViewItem(pParent, QString(getNodeName(pszName))),
85	#endif
86	m_pszName(RTStrDup(pszName)), m_fBranch(fBranch), m_pParent(pParent)
87
88	{
89	}
90
91	VBoxDbgStatsItem::VBoxDbgStatsItem(const char pszName, QListView pParent, bool fBranch/* = true*/)
92	#ifdef VBOXDBG_USE_QT4
93	: QTreeWidgetItem(pParent, QStringList(QString(getNodeName(pszName)))),
94	#else
95	: QListViewItem(pParent, QString(getNodeName(pszName))),
96	#endif
97	m_pszName(RTStrDup(pszName)), m_fBranch(fBranch), m_pParent(NULL)
98	{
99	}
100
101	VBoxDbgStatsItem::~VBoxDbgStatsItem()
102	{
103	RTStrFree(m_pszName);
104	m_pszName = NULL;
105	}
106
107	void VBoxDbgStatsItem::logTree(bool fReleaseLog) const
108	{
109	/* Iterate and print our children. */
110	#ifdef VBOXDBG_USE_QT4
111	int cChildren = childCount();
112	for (int i = 0; i < cChildren; i++)
113	{
114	VBoxDbgStatsItem pMyItem = (VBoxDbgStatsItem )child(i);
115	pMyItem->logTree(fReleaseLog);
116	}
117	#else
118	for (QListViewItem *pItem = firstChild(); pItem; pItem = pItem->nextSibling())
119	{
120	VBoxDbgStatsItem pMyItem = (VBoxDbgStatsItem )pItem;
121	pMyItem->logTree(fReleaseLog);
122	}
123	#endif
124	}
125
126	void VBoxDbgStatsItem::stringifyTree(QString &String) const
127	{
128	/* Iterate and stringify our children. */
129	#ifdef VBOXDBG_USE_QT4
130	int cChildren = childCount();
131	for (int i = 0; i < cChildren; i++)
132	{
133	VBoxDbgStatsItem pMyItem = (VBoxDbgStatsItem )child(i);
134	pMyItem->stringifyTree(String);
135	}
136	#else
137	for (QListViewItem *pItem = firstChild(); pItem; pItem = pItem->nextSibling())
138	{
139	VBoxDbgStatsItem pMyItem = (VBoxDbgStatsItem )pItem;
140	pMyItem->stringifyTree(String);
141	}
142	#endif
143	}
144
145	void VBoxDbgStatsItem::copyTreeToClipboard(void) const
146	{
147	QString String;
148	stringifyTree(String);
149
150	QClipboard *pClipboard = QApplication::clipboard();
151	if (pClipboard)
152	pClipboard->setText(String, QClipboard::Clipboard);
153	}
154
155
156
157
158	/*
159	*
160	* V B o x D b g S t a t s L e a f I t e m
161	* V B o x D b g S t a t s L e a f I t e m
162	* V B o x D b g S t a t s L e a f I t e m
163	*
164	*/
165
166
167	VBoxDbgStatsLeafItem::VBoxDbgStatsLeafItem(const char pszName, VBoxDbgStatsItem pParent)
168	: VBoxDbgStatsItem(pszName, pParent, false),
169	m_pNext(NULL), m_pPrev(NULL), m_enmType(STAMTYPE_INVALID),
170	m_enmUnit(STAMUNIT_INVALID), m_DescStr()
171	{
172	memset(&m_Data, 0, sizeof(m_Data));
173	}
174
175
176	VBoxDbgStatsLeafItem::~VBoxDbgStatsLeafItem()
177	{
178	}
179
180
181	/**
182	* Formats a number into a 64-byte buffer.
183	*/
184	static char formatNumber(char psz, uint64_t u64)
185	{
186	static const char s_szDigits[] = "0123456789";
187	psz += 63;
188	*psz-- = '\0';
189	unsigned cDigits = 0;
190	for (;;)
191	{
192	const unsigned iDigit = u64 % 10;
193	u64 /= 10;
194	*psz = s_szDigits[iDigit];
195	if (!u64)
196	break;
197	psz--;
198	if (!(++cDigits % 3))
199	*psz-- = ',';
200	}
201	return psz;
202	}
203
204
205	/**
206	* Formats a number into a 64-byte buffer.
207	* (18.446.744.073.709.551.615)
208	*/
209	static char formatNumberSigned(char psz, int64_t i64)
210	{
211	static const char s_szDigits[] = "0123456789";
212	psz += 63;
213	*psz-- = '\0';
214	const bool fNegative = i64 < 0;
215	uint64_t u64 = fNegative ? -i64 : i64;
216	unsigned cDigits = 0;
217	for (;;)
218	{
219	const unsigned iDigit = u64 % 10;
220	u64 /= 10;
221	*psz = s_szDigits[iDigit];
222	if (!u64)
223	break;
224	psz--;
225	if (!(++cDigits % 3))
226	*psz-- = ',';
227	}
228	if (fNegative)
229	*--psz = '-';
230	return psz;
231	}
232
233
234	/**
235	* Formats a unsigned hexadecimal number into a into a 64-byte buffer.
236	*/
237	static char formatHexNumber(char psz, uint64_t u64, unsigned cZeros)
238	{
239	static const char s_szDigits[] = "0123456789abcdef";
240	psz += 63;
241	*psz-- = '\0';
242	unsigned cDigits = 0;
243	for (;;)
244	{
245	const unsigned iDigit = u64 % 16;
246	u64 /= 16;
247	*psz = s_szDigits[iDigit];
248	++cDigits;
249	if (!u64 && cDigits >= cZeros)
250	break;
251	psz--;
252	if (!(cDigits % 8))
253	*psz-- = '\'';
254	}
255	return psz;
256	}
257
258
259	/**
260	* Formats a sort key number.
261	*/
262	static void formatSortKey(char *psz, uint64_t u64)
263	{
264	static const char s_szDigits[] = "0123456789abcdef";
265	/* signed */
266	*psz++ = '+';
267
268	/* 16 hex digits */
269	psz[16] = '\0';
270	unsigned i = 16;
271	while (i-- > 0)
272	{
273	if (u64)
274	{
275	const unsigned iDigit = u64 % 16;
276	u64 /= 16;
277	psz[i] = s_szDigits[iDigit];
278	}
279	else
280	psz[i] = '0';
281	}
282	}
283
284
285	#if 0/* unused */
286	/**
287	* Formats a sort key number.
288	*/
289	static void formatSortKeySigned(char *psz, int64_t i64)
290	{
291	static const char s_szDigits[] = "0123456789abcdef";
292
293	/* signed */
294	uint64_t u64;
295	if (i64 >= 0)
296	{
297	*psz++ = '+';
298	u64 = i64;
299	}
300	else
301	{
302	*psz++ = '-';
303	u64 = -i64;
304	}
305
306	/* 16 hex digits */
307	psz[16] = '\0';
308	unsigned i = 16;
309	while (i-- > 0)
310	{
311	if (u64)
312	{
313	const unsigned iDigit = u64 % 16;
314	u64 /= 16;
315	psz[i] = s_szDigits[iDigit];
316	}
317	else
318	psz[i] = '0';
319	}
320	}
321	#endif
322
323
324	void VBoxDbgStatsLeafItem::update(STAMTYPE enmType, void pvSample, STAMUNIT enmUnit, STAMVISIBILITY enmVisibility, const char pszDesc)
325	{
326	/*
327	* Detect changes.
328	* This path will be taken on the first update and if a item
329	* is reregistred with a different unit/type (unlikely).
330	*/
331	if ( enmType != m_enmType
332	\|\| enmUnit != m_enmUnit)
333	{
334	m_enmType = enmType;
335	m_enmUnit = enmUnit;
336
337	/*
338	* Unit.
339	*/
340	setText(1, STAMR3GetUnit(enmUnit));
341
342	/**
343	* Update the description.
344	* Insert two spaces as gap after the last left-aligned field.
345	* @todo dmik: How to make this better?
346	*/
347	m_DescStr = QString(" ") + QString(pszDesc);
348
349	/*
350	* Clear the content.
351	*/
352	setText(2, "");
353	setText(3, "");
354	setText(4, "");
355	setText(5, "");
356	setText(6, "");
357	setText(8, m_DescStr);
358	}
359
360	/*
361	* Update the data.
362	*/
363	char sz[64];
364	switch (enmType)
365	{
366	case STAMTYPE_COUNTER:
367	{
368	const uint64_t cPrev = m_Data.Counter.c;
369	m_Data.Counter = *(PSTAMCOUNTER)pvSample;
370	setText(2, formatNumber(sz, m_Data.Counter.c));
371	setText(7, formatNumberSigned(sz, m_Data.Counter.c - cPrev));
372	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
373	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.Counter.c));
374	break;
375	}
376
377	case STAMTYPE_PROFILE:
378	case STAMTYPE_PROFILE_ADV:
379	{
380	const uint64_t cPeriodsPrev = m_Data.Profile.cPeriods;
381	m_Data.Profile = *(PSTAMPROFILE)pvSample;
382	if (m_Data.Profile.cPeriods)
383	{
384	setText(2, formatNumber(sz, m_Data.Profile.cPeriods));
385	setText(3, formatNumber(sz, m_Data.Profile.cTicksMin));
386	setText(4, formatNumber(sz, m_Data.Profile.cTicks / m_Data.Profile.cPeriods));
387	setText(5, formatNumber(sz, m_Data.Profile.cTicksMax));
388	setText(6, formatNumber(sz, m_Data.Profile.cTicks));
389	setText(7, formatNumberSigned(sz, m_Data.Profile.cPeriods - cPeriodsPrev));
390	setVisible(enmVisibility != STAMVISIBILITY_NOT_GUI);
391	}
392	else
393	{
394	setText(2, "0");
395	setText(3, "0");
396	setText(4, "0");
397	setText(5, "0");
398	setText(6, "0");
399	setText(7, "0");
400	setVisible(enmVisibility != STAMVISIBILITY_NOT_GUI && enmVisibility == STAMVISIBILITY_ALWAYS);
401	}
402	break;
403	}
404
405	case STAMTYPE_RATIO_U32:
406	case STAMTYPE_RATIO_U32_RESET:
407	{
408	const STAMRATIOU32 RatioU32 = m_Data.RatioU32;
409	m_Data.RatioU32 = *(PSTAMRATIOU32)pvSample;
410
411	char sz2[64];
412	char sz3[128];
413	strcat(strcat(strcpy(sz3, formatNumber(sz, m_Data.RatioU32.u32A)), " : "), formatNumber(sz2, m_Data.RatioU32.u32B));
414	setText(2, sz3);
415	///@todo ratio: setText(7, formatNumberSigned(sz, m_Data.u64 - u64Prev));
416	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
417	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.RatioU32.u32A \|\| m_Data.RatioU32.u32B));
418	break;
419	}
420
421	case STAMTYPE_CALLBACK:
422	{
423	const char pszString = (const char )pvSample;
424	setText(2, pszString);
425	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
426	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| *pszString));
427	break;
428	}
429
430	case STAMTYPE_U8:
431	case STAMTYPE_U8_RESET:
432	{
433	const uint8_t u8Prev = m_Data.u8;
434	m_Data.u8 = (uint8_t )pvSample;
435	setText(2, formatNumber(sz, m_Data.u8));
436	setText(7, formatNumberSigned(sz, (int32_t)m_Data.u8 - u8Prev));
437	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
438	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u8));
439	break;
440	}
441
442	case STAMTYPE_X8:
443	case STAMTYPE_X8_RESET:
444	{
445	const uint8_t u8Prev = m_Data.u8;
446	m_Data.u8 = (uint8_t )pvSample;
447	setText(2, formatHexNumber(sz, m_Data.u8, 2));
448	setText(7, formatHexNumber(sz, m_Data.u8 - u8Prev, 1));
449	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
450	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u8));
451	break;
452	}
453
454	case STAMTYPE_U16:
455	case STAMTYPE_U16_RESET:
456	{
457	const uint16_t u16Prev = m_Data.u16;
458	m_Data.u16 = (uint16_t )pvSample;
459	setText(2, formatNumber(sz, m_Data.u16));
460	setText(7, formatNumberSigned(sz, (int32_t)m_Data.u16 - u16Prev));
461	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
462	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u16));
463	break;
464	}
465
466	case STAMTYPE_X16:
467	case STAMTYPE_X16_RESET:
468	{
469	const uint16_t u16Prev = m_Data.u16;
470	m_Data.u16 = (uint16_t )pvSample;
471	setText(2, formatHexNumber(sz, m_Data.u16, 4));
472	setText(7, formatHexNumber(sz, m_Data.u16 - u16Prev, 1));
473	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
474	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u16));
475	break;
476	}
477
478	case STAMTYPE_U32:
479	case STAMTYPE_U32_RESET:
480	{
481	const uint32_t u32Prev = m_Data.u32;
482	m_Data.u32 = (uint32_t )pvSample;
483	setText(2, formatNumber(sz, m_Data.u32));
484	setText(7, formatNumberSigned(sz, (int64_t)m_Data.u32 - u32Prev));
485	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
486	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u32));
487	break;
488	}
489
490	case STAMTYPE_X32:
491	case STAMTYPE_X32_RESET:
492	{
493	const uint32_t u32Prev = m_Data.u32;
494	m_Data.u32 = (uint32_t )pvSample;
495	setText(2, formatHexNumber(sz, m_Data.u32, 8));
496	setText(7, formatHexNumber(sz, m_Data.u32 - u32Prev, 1));
497	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
498	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u32));
499	break;
500	}
501
502	case STAMTYPE_U64:
503	case STAMTYPE_U64_RESET:
504	{
505	const uint64_t u64Prev = m_Data.u64;
506	m_Data.u64 = (uint64_t )pvSample;
507	setText(2, formatNumber(sz, m_Data.u64));
508	setText(7, formatNumberSigned(sz, m_Data.u64 - u64Prev));
509	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
510	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u64));
511	break;
512	}
513
514	case STAMTYPE_X64:
515	case STAMTYPE_X64_RESET:
516	{
517	const uint64_t u64Prev = m_Data.u64;
518	m_Data.u64 = (uint64_t )pvSample;
519	setText(2, formatHexNumber(sz, m_Data.u64, 16));
520	setText(7, formatHexNumber(sz, m_Data.u64 - u64Prev, 1));
521	setVisible( enmVisibility != STAMVISIBILITY_NOT_GUI
522	&& (enmVisibility == STAMVISIBILITY_ALWAYS \|\| m_Data.u64));
523	break;
524	}
525
526	default:
527	break;
528	}
529	}
530
531
532	QString VBoxDbgStatsLeafItem::key(int iColumn, bool /fAscending/) const
533	{
534	/* name and description */
535	if (iColumn <= 1 \|\| iColumn >= 8)
536	return text(iColumn);
537
538	/* the number columns */
539	char sz[128];
540	switch (m_enmType)
541	{
542	case STAMTYPE_COUNTER:
543	switch (iColumn)
544	{
545	case 2: formatSortKey(sz, m_Data.Counter.c); break;
546	case 7: return text(iColumn);
547	default: sz[0] = '\0'; break;
548	}
549	break;
550
551	case STAMTYPE_PROFILE:
552	case STAMTYPE_PROFILE_ADV:
553	if (m_Data.Profile.cPeriods)
554	{
555	switch (iColumn)
556	{
557	case 2: formatSortKey(sz, m_Data.Profile.cPeriods); break;
558	case 3: formatSortKey(sz, m_Data.Profile.cTicksMin); break;
559	case 4: formatSortKey(sz, m_Data.Profile.cTicks / m_Data.Profile.cPeriods); break;
560	case 5: formatSortKey(sz, m_Data.Profile.cTicksMax); break;
561	case 6: formatSortKey(sz, m_Data.Profile.cTicks); break;
562	case 7: return text(iColumn);
563	default: sz[0] = '\0'; break;
564	}
565	}
566	else
567	sz[0] = '\0';
568	break;
569
570	case STAMTYPE_RATIO_U32:
571	case STAMTYPE_RATIO_U32_RESET:
572	if (m_Data.RatioU32.u32B)
573	formatSortKey(sz, (m_Data.RatioU32.u32A * (uint64_t)1000) / m_Data.RatioU32.u32B);
574	else if (m_Data.RatioU32.u32A)
575	formatSortKey(sz, m_Data.RatioU32.u32A * (uint64_t)1000);
576	else
577	formatSortKey(sz, 1000);
578	break;
579
580	case STAMTYPE_U8:
581	case STAMTYPE_U8_RESET:
582	switch (iColumn)
583	{
584	case 2: formatSortKey(sz, m_Data.u8); break;
585	case 7: return text(iColumn);
586	default: sz[0] = '\0'; break;
587	}
588	break;
589
590	case STAMTYPE_U16:
591	case STAMTYPE_U16_RESET:
592	switch (iColumn)
593	{
594	case 2: formatSortKey(sz, m_Data.u16); break;
595	case 7: return text(iColumn);
596	default: sz[0] = '\0'; break;
597	}
598	break;
599
600	case STAMTYPE_U32:
601	case STAMTYPE_U32_RESET:
602	switch (iColumn)
603	{
604	case 2: formatSortKey(sz, m_Data.u32); break;
605	case 7: return text(iColumn);
606	default: sz[0] = '\0'; break;
607	}
608	break;
609
610	case STAMTYPE_U64:
611	case STAMTYPE_U64_RESET:
612	switch (iColumn)
613	{
614	case 2: formatSortKey(sz, m_Data.u64); break;
615	case 7: return text(iColumn);
616	default: sz[0] = '\0'; break;
617	}
618	break;
619
620	case STAMTYPE_CALLBACK:
621	default:
622	return text(iColumn);
623	}
624
625	return QString(sz);
626	}
627
628	void VBoxDbgStatsLeafItem::logTree(bool fReleaseLog) const
629	{
630	/*
631	* Generic printing.
632	*/
633	#ifdef VBOXDBG_USE_QT4
634	if (!isHidden())
635	{
636	QByteArray aColumns[9];
637	const char *apszColumns[9];
638	for (int i = 0; RT_ELEMENTS(aColumns); i++)
639	{
640	aColumns[i] = text(i).toUtf8();
641	apszColumns[i] = aColumns[i].constData();
642	}
643
644	if (fReleaseLog)
645	RTLogRelPrintf("%-50s %-10s %18s %18s %18s %18s %16s %s\n",
646	getName(), apszColumns[1], apszColumns[2], apszColumns[3],
647	apszColumns[4], apszColumns[5], apszColumns[7], apszColumns[8]);
648	else
649	RTLogPrintf("%-50s %-10s %18s %18s %18s %18s %16s %s\n",
650	getName(), apszColumns[1], apszColumns[2], apszColumns[3],
651	apszColumns[4], apszColumns[5], apszColumns[7], apszColumns[8]);
652	}
653	#else
654	if (isVisible())
655	{
656	if (fReleaseLog)
657	RTLogRelPrintf("%-50s %-10s %18s %18s %18s %18s %16s %s\n",
658	getName(), (const char )text(1), (const char )text(2), (const char *)text(3),
659	(const char )text(4), (const char )text(5), (const char )text(7), (const char )text(8));
660	else
661	RTLogPrintf("%-50s %-10s %18s %18s %18s %18s %16s %s\n",
662	getName(), (const char )text(1), (const char )text(2), (const char *)text(3),
663	(const char )text(4), (const char )text(5), (const char )text(7), (const char )text(8));
664	}
665	#endif
666
667	/*
668	* Let the super class to do the rest.
669	*/
670	VBoxDbgStatsItem::logTree(fReleaseLog);
671	}
672
673	void VBoxDbgStatsLeafItem::stringifyTree(QString &String) const
674	{
675	/*
676	* Generic printing.
677	*/
678	#ifdef VBOXDBG_USE_QT4
679	if (!isHidden())
680	{
681	QByteArray aColumns[9];
682	const char *apszColumns[9];
683	for (int i = 0; RT_ELEMENTS(aColumns); i++)
684	{
685	aColumns[i] = text(i).toUtf8();
686	apszColumns[i] = aColumns[i].constData();
687	}
688
689	QString ItemString;
690	ItemString.sprintf("%-50s %-10s %18s %18s %18s %18s %16s %s\n",
691	getName(), apszColumns[1], apszColumns[2], apszColumns[3],
692	apszColumns[4], apszColumns[5], apszColumns[7], apszColumns[8]);
693	String += ItemString;
694	}
695	#else
696	if (isVisible())
697	{
698	QString ItemString;
699	ItemString.sprintf("%-50s %-10s %18s %18s %18s %18s %16s %s\n",
700	getName(), (const char )text(1), (const char )text(2), (const char *)text(3),
701	(const char )text(4), (const char )text(5), (const char )text(7), (const char )text(8));
702	String += ItemString;
703	}
704	#endif
705
706	/*
707	* Let the super class to do the rest.
708	*/
709	VBoxDbgStatsItem::stringifyTree(String);
710	}
711
712
713
714
715
716	/*
717	*
718	* V B o x D b g S t a t s V i e w
719	* V B o x D b g S t a t s V i e w
720	* V B o x D b g S t a t s V i e w
721	*
722	*
723	*/
724
725
726	VBoxDbgStatsView::VBoxDbgStatsView(PVM pVM, VBoxDbgStats pParent/ = NULL*/)
727	: QListView(pParent),
728	VBoxDbgBase(pVM),
729	m_pParent(pParent), m_pHead(NULL), m_pTail(NULL), m_pCur(NULL), m_pRoot(NULL),
730	m_pLeafMenu(NULL), m_pBranchMenu(NULL), m_pViewMenu(NULL), m_pContextMenuItem(NULL)
731
732	{
733	/*
734	* Create the columns.
735	*/
736	#ifdef VBOXDBG_USE_QT4
737	setColumnCount(9);
738	QStringList Headers;
739	setHeaderLabels(Headers << "Name" << "Unit" << "Value/Times" << "Min" << "Average" << "Max" << "Total" << "dInt" << "Description");
740	setItemsExpandable(true);
741	setSortingEnabled(true);
742
743	#else
744	addColumn("Name"); // 0
745	addColumn("Unit"); // 1
746	setColumnAlignment(1, Qt::AlignCenter);
747	addColumn("Value/Times"); // 2
748	setColumnAlignment(2, Qt::AlignRight);
749	addColumn("Min"); // 3
750	setColumnAlignment(3, Qt::AlignRight);
751	addColumn("Average"); // 4
752	setColumnAlignment(4, Qt::AlignRight);
753	addColumn("Max"); // 5
754	setColumnAlignment(5, Qt::AlignRight);
755	addColumn("Total"); // 6
756	setColumnAlignment(6, Qt::AlignRight);
757	addColumn("dInt"); // 7
758	setColumnAlignment(7, Qt::AlignRight);
759	int i = addColumn("Description"); // 8
760	NOREF(i);
761	Assert(i == 8);
762	setShowSortIndicator(true);
763	#endif
764
765	/*
766	* Create the root node.
767	*/
768	setRootIsDecorated(true);
769	m_pRoot = new VBoxDbgStatsItem("/", this);
770	#ifdef VBOXDBG_USE_QT4
771	m_pRoot->setExpanded(true);
772	#else
773	m_pRoot->setOpen(true);
774	#endif
775
776	/*
777	* We've got three menus to populate and link up.
778	*/
779	#ifdef VBOXDBG_USE_QT4
780	/** @todo */
781
782	#else /* QT3 */
783	m_pLeafMenu = new QPopupMenu(this);
784	m_pLeafMenu->insertItem("Rese&t", eReset);
785	m_pLeafMenu->insertItem("&Refresh", eRefresh);
786	m_pLeafMenu->insertItem("&Copy", eCopy);
787	m_pLeafMenu->insertItem("To &Log", eLog);
788	m_pLeafMenu->insertItem("T&o Release Log", eLogRel);
789	connect(m_pLeafMenu, SIGNAL(activated(int)), this, SLOT(leafMenuActivated(int)));
790
791	m_pBranchMenu = new QPopupMenu(this);
792	m_pBranchMenu->insertItem("&Expand Tree", eExpand);
793	m_pBranchMenu->insertItem("&Collaps Tree", eCollaps);
794	m_pBranchMenu->insertItem("&Refresh", eRefresh);
795	m_pBranchMenu->insertItem("Rese&t", eReset);
796	m_pBranchMenu->insertItem("&Copy", eCopy);
797	m_pBranchMenu->insertItem("To &Log", eLog);
798	m_pBranchMenu->insertItem("T&o Release Log", eLogRel);
799	connect(m_pBranchMenu, SIGNAL(activated(int)), this, SLOT(branchMenuActivated(int)));
800
801	m_pViewMenu = new QPopupMenu(this);
802	m_pViewMenu->insertItem("&Expand All", eExpand);
803	m_pViewMenu->insertItem("&Collaps All", eCollaps);
804	m_pViewMenu->insertItem("&Refresh", eRefresh);
805	m_pViewMenu->insertItem("Rese&t", eReset);
806	m_pViewMenu->insertItem("&Copy", eCopy);
807	m_pViewMenu->insertItem("To &Log", eLog);
808	m_pViewMenu->insertItem("T&o Release Log", eLogRel);
809	connect(m_pViewMenu, SIGNAL(activated(int)), this, SLOT(viewMenuActivated(int)));
810
811	connect(this, SIGNAL(contextMenuRequested(QListViewItem *, const QPoint &, int)), this,
812	SLOT(contextMenuReq(QListViewItem *, const QPoint &, int)));
813	#endif /* QT3 */
814	}
815
816	VBoxDbgStatsView::~VBoxDbgStatsView()
817	{
818	/* Who frees the items? What happens to the reference in QListView? Does the parent free things in some way? */
819	#if 0
820	VBoxDbgStatsLeafItem *pCur = m_pHead;
821	while (pCur)
822	{
823	VBoxDbgStatsLeafItem *pFree = pCur;
824	pCur = pCur->m_pNext;
825	delete pFree;
826	}
827
828	delete m_pRoot;
829	#endif
830	m_pHead = NULL;
831	m_pTail = NULL;
832	m_pCur = NULL;
833	m_pRoot = NULL;
834	}
835
836	/**
837	* Hides all parent branches which doesn't have any visible leafs.
838	*/
839	static void hideParentBranches(VBoxDbgStatsLeafItem *pItem)
840	{
841	#ifdef VBOXDBG_USE_QT4
842	/// @todo
843	NOREF(pItem);
844	#else
845	for (VBoxDbgStatsItem *pParent = pItem->getParent(); pParent; pParent = pParent->getParent())
846	{
847	QListViewItem *pChild = pParent->firstChild();
848	while (pChild && !pChild->isVisible())
849	pChild = pChild->nextSibling();
850	if (pChild)
851	return;
852	pParent->setVisible(false);
853	}
854	#endif
855	}
856
857	/**
858	* Shows all parent branches
859	*/
860	static void showParentBranches(VBoxDbgStatsLeafItem *pItem)
861	{
862	for (VBoxDbgStatsItem *pParent = pItem->getParent(); pParent; pParent = pParent->getParent())
863	pParent->setVisible(true);
864	}
865
866	void VBoxDbgStatsView::update(const QString &rPatStr)
867	{
868	m_pCur = m_pHead;
869	m_PatStr = rPatStr;
870	int rc = stamEnum(m_PatStr, updateCallback, this);
871	if (VBOX_SUCCESS(rc))
872	{
873	/* hide what's left */
874	for (VBoxDbgStatsLeafItem *pCur = m_pCur; pCur; pCur = pCur->m_pNext)
875	if (pCur->isVisible())
876	{
877	pCur->setVisible(false);
878	hideParentBranches(pCur);
879	}
880	}
881	m_pCur = NULL;
882	}
883
884	void VBoxDbgStatsView::reset(const QString &rPatStr)
885	{
886	stamReset(rPatStr);
887	}
888
889	static void setOpenTree(QListViewItem *pItem, bool f)
890	{
891	#ifdef VBOXDBG_USE_QT4
892	pItem->setExpanded(f);
893	int cChildren = pItem->childCount();
894	for (int i = 0; i < cChildren; i++)
895	pItem->child(i)->setExpanded(f);
896	#else
897	pItem->setOpen(f);
898	for (pItem = pItem->firstChild(); pItem; pItem = pItem->nextSibling())
899	setOpenTree(pItem, f);
900	#endif
901	}
902
903	#ifndef VBOXDBG_USE_QT4
904	void VBoxDbgStatsView::expandAll()
905	{
906	setOpenTree(m_pRoot, true);
907	}
908
909	void VBoxDbgStatsView::collapsAll()
910	{
911	setOpenTree(m_pRoot, false);
912	}
913	#endif /* QT3 */
914
915
916	/static/ DECLCALLBACK(int) VBoxDbgStatsView::updateCallback(const char pszName, STAMTYPE enmType, void pvSample, STAMUNIT enmUnit,
917	STAMVISIBILITY enmVisibility, const char pszDesc, void pvUser)
918	{
919	Log3(("updateCallback: %s\n", pszName));
920	VBoxDbgStatsView pThis = (VBoxDbgStatsView )pvUser;
921
922	/*
923	* Skip the ones which shouldn't be visible in the GUI.
924	*/
925	if (enmVisibility == STAMVISIBILITY_NOT_GUI)
926	return 0;
927
928	/*
929	* Advance to the matching item.
930	*/
931	VBoxDbgStatsLeafItem *pCur = pThis->m_pCur;
932	while (pCur)
933	{
934	/*
935	* ASSUMES ascending order of STAM items.
936	*/
937	int iDiff = strcmp(pszName, pCur->getName());
938	if (!iDiff)
939	break;
940	if (iDiff > 0)
941	{
942	/*
943	* Removed / filtered out.
944	*/
945	Log2(("updateCallback: %s - filtered out\n", pCur->getName()));
946	if (pCur->isVisible())
947	{
948	pCur->setVisible(false);
949	hideParentBranches(pCur);
950	}
951
952	pCur = pCur->m_pNext;
953	}
954	else if (iDiff < 0)
955	{
956	/*
957	* New item, insert before pCur.
958	*/
959	Log2(("updateCallback: %s - new\n", pszName));
960	VBoxDbgStatsLeafItem *pNew = new VBoxDbgStatsLeafItem(pszName, pThis->createPath(pszName));
961	pNew->m_pNext = pCur;
962	pNew->m_pPrev = pCur->m_pPrev;
963	if (pNew->m_pPrev)
964	pNew->m_pPrev->m_pNext = pNew;
965	else
966	pThis->m_pHead = pNew;
967	pCur->m_pPrev = pNew;
968	pCur = pNew;
969	Assert(!strcmp(pszName, pCur->getName()));
970	break;
971	}
972	}
973
974	/*
975	* End of items, insert it at the tail.
976	*/
977	if (!pCur)
978	{
979	Log2(("updateCallback: %s - new end\n", pszName));
980	pCur = new VBoxDbgStatsLeafItem(pszName, pThis->createPath(pszName));
981	pCur->m_pNext = NULL;
982	pCur->m_pPrev = pThis->m_pTail;
983	if (pCur->m_pPrev)
984	pCur->m_pPrev->m_pNext = pCur;
985	else
986	pThis->m_pHead = pCur;
987	pThis->m_pTail = pCur;
988	}
989	Assert(pThis->m_pHead);
990	Assert(pThis->m_pTail);
991
992	/*
993	* Update it and move on.
994	*/
995	if (!pCur->isVisible())
996	showParentBranches(pCur);
997	pCur->update(enmType, pvSample, enmUnit, enmVisibility, pszDesc);
998	pThis->m_pCur = pCur->m_pNext;
999
1000	return 0;
1001	}
1002
1003	VBoxDbgStatsItem VBoxDbgStatsView::createPath(const char pszName)
1004	{
1005	const char * const pszFullName = pszName;
1006
1007	/*
1008	* Start at root.
1009	*/
1010	while (*pszName == '/')
1011	pszName++;
1012	VBoxDbgStatsItem *pParent = m_pRoot;
1013
1014	/*
1015	* Walk down the path creating what's missing.
1016	*/
1017	for (;;)
1018	{
1019	/*
1020	* Extract the path component.
1021	*/
1022	const char *pszEnd = strchr(pszName, '/');
1023	if (!pszEnd)
1024	return pParent;
1025	QString NameStr = QString::fromUtf8(pszName, pszEnd - pszName);
1026	/* advance */
1027	pszName = pszEnd + 1;
1028
1029	/*
1030	* Try find the name among the children of that parent guy.
1031	*/
1032	#ifdef VBOXDBG_USE_QT4
1033	QListViewItem *pChild = NULL;
1034	int cChildren = pParent->childCount();
1035	for (int i = 0; i < cChildren; i++)
1036	{
1037	pChild = pParent->child(i);
1038	if (pChild->text(0) == NameStr)
1039	break;
1040	}
1041	#else
1042	QListViewItem *pChild = pParent->firstChild();
1043	while (pChild && pChild->text(0) != NameStr)
1044	pChild = pChild->nextSibling();
1045	#endif
1046
1047	if (pChild)
1048	pParent = (VBoxDbgStatsItem *)pChild;
1049	else
1050	{
1051	Log3(("createPath: %.*s\n", pszEnd - pszFullName, pszFullName));
1052	NameStr = QString::fromUtf8(pszFullName, pszEnd - pszFullName);
1053	#ifdef VBOXDBG_USE_QT4
1054	QByteArray NameArray = NameStr.toUtf8();
1055	pParent = new VBoxDbgStatsItem(NameArray.constData(), pParent);
1056	#else
1057	pParent = new VBoxDbgStatsItem(NameStr, pParent);
1058	#endif
1059	}
1060	pParent->setVisible(true);
1061	}
1062	}
1063
1064	void VBoxDbgStatsView::contextMenuReq(QListViewItem pItem, const QPoint &rPoint, int /iColumn*/)
1065	{
1066	if (pItem)
1067	{
1068	m_pContextMenuItem = (VBoxDbgStatsItem *)pItem;
1069	if (m_pContextMenuItem->isLeaf())
1070	{
1071	#ifdef VBOXDBG_USE_QT4
1072	#else
1073	m_pLeafMenu->setItemEnabled(eReset, isVMOk());
1074	m_pLeafMenu->setItemEnabled(eRefresh, isVMOk());
1075	#endif
1076	m_pLeafMenu->popup(rPoint);
1077	}
1078	else
1079	{
1080	#ifdef VBOXDBG_USE_QT4
1081	#else
1082	m_pBranchMenu->setItemEnabled(eReset, isVMOk());
1083	m_pBranchMenu->setItemEnabled(eRefresh, isVMOk());
1084	#endif
1085	m_pBranchMenu->popup(rPoint);
1086	}
1087	}
1088	else
1089	{
1090	m_pContextMenuItem = NULL;
1091	#ifdef VBOXDBG_USE_QT4
1092	#else
1093	m_pViewMenu->setItemEnabled(eReset, isVMOk());
1094	m_pViewMenu->setItemEnabled(eRefresh, isVMOk());
1095	#endif
1096	m_pViewMenu->popup(rPoint);
1097	}
1098	}
1099
1100	void VBoxDbgStatsView::leafMenuActivated(int iId)
1101	{
1102	VBoxDbgStatsLeafItem pItem = (VBoxDbgStatsLeafItem )m_pContextMenuItem;
1103	AssertReturn(pItem, (void)0);
1104
1105	switch ((MenuId)iId)
1106	{
1107	case eReset:
1108	stamReset(m_pContextMenuItem->getName());
1109	/* fall thru */
1110
1111	case eRefresh:
1112	m_pCur = pItem;
1113	stamEnum(m_pContextMenuItem->getName(), updateCallback, this);
1114	break;
1115
1116	case eCopy:
1117	m_pContextMenuItem->copyTreeToClipboard();
1118	break;
1119
1120	case eLog:
1121	m_pContextMenuItem->logTree(false /* !release log */);
1122	break;
1123
1124	case eLogRel:
1125	m_pContextMenuItem->logTree(true /* release log */);
1126	break;
1127
1128	default: /* keep gcc quite */
1129	break;
1130	}
1131	m_pContextMenuItem = NULL;
1132	}
1133
1134	void VBoxDbgStatsView::branchMenuActivated(int iId)
1135	{
1136	AssertReturn(m_pContextMenuItem, (void)0);
1137
1138	/** @todo make enum for iId */
1139	switch ((MenuId)iId)
1140	{
1141	case eExpand:
1142	setOpenTree(m_pContextMenuItem, true);
1143	break;
1144
1145	case eCollaps:
1146	setOpenTree(m_pContextMenuItem, false);
1147	break;
1148
1149	case eReset:
1150	{
1151	QString Str = QString::fromUtf8(m_pContextMenuItem->getName());
1152	Str.append((Str != "/") ? "/" : "");
1153	stamReset(Str);
1154	}
1155	/* fall thru */
1156
1157	case eRefresh:
1158	{
1159	const char *psz = m_pContextMenuItem->getName();
1160	QString Str = QString::fromUtf8(psz);
1161	if (strcmp(psz, "/"))
1162	{
1163	int cch = strlen(psz);
1164	m_pCur = m_pHead;
1165	while ( m_pCur
1166	&& ( strncmp(psz, m_pCur->getName(), cch)
1167	\|\| m_pCur->getName()[cch] != '/'))
1168	{
1169	m_pCur = m_pCur->m_pNext;
1170	}
1171	if (!m_pCur)
1172	return;
1173	Str.append("/*");
1174	}
1175	else
1176	{
1177	m_pCur = m_pHead;
1178	Str.append("*");
1179	}
1180	stamEnum(Str, updateCallback, this);
1181	m_pCur = NULL;
1182	break;
1183	}
1184
1185	case eCopy:
1186	m_pContextMenuItem->copyTreeToClipboard();
1187	break;
1188
1189	case eLog:
1190	m_pContextMenuItem->logTree(false /* !release log */);
1191	break;
1192
1193	case eLogRel:
1194	m_pContextMenuItem->logTree(true /* release log */);
1195	break;
1196
1197	}
1198	m_pContextMenuItem = NULL;
1199	}
1200
1201	void VBoxDbgStatsView::viewMenuActivated(int iId)
1202	{
1203	switch ((MenuId)iId)
1204	{
1205	case eExpand:
1206	setOpenTree(m_pRoot, true);
1207	break;
1208
1209	case eCollaps:
1210	setOpenTree(m_pRoot, false);
1211	break;
1212
1213	case eReset:
1214	reset(m_PatStr);
1215	/* fall thru */
1216
1217	case eRefresh:
1218	update(QString(m_PatStr));
1219	break;
1220
1221	case eCopy:
1222	m_pRoot->copyTreeToClipboard();
1223	break;
1224
1225	case eLog:
1226	m_pRoot->logTree(false /* !release log */);
1227	break;
1228
1229	case eLogRel:
1230	m_pRoot->logTree(true /* release log */);
1231	break;
1232	}
1233	}
1234
1235
1236
1237
1238
1239
1240	/*
1241	*
1242	* V B o x D b g S t a t s
1243	* V B o x D b g S t a t s
1244	* V B o x D b g S t a t s
1245	*
1246	*
1247	*/
1248
1249
1250	VBoxDbgStats::VBoxDbgStats(PVM pVM, const char pszPat/ = NULL/, unsigned uRefreshRate/ = 0/, QWidget pParent/* = NULL*/)
1251	#ifdef VBOXDBG_USE_QT4
1252	: QWidget(pParent),
1253	#else
1254	: QVBox(pParent),
1255	#endif
1256	VBoxDbgBase(pVM), m_PatStr(pszPat), m_uRefreshRate(0)
1257	{
1258	#ifdef VBOXDBG_USE_QT4
1259	setWindowTitle("VBoxDbg - Statistics");
1260	#else
1261	setCaption("VBoxDbg - Statistics");
1262	#endif
1263
1264	/*
1265	* On top, a horizontal box with the pattern field, buttons and refresh interval.
1266	*/
1267	#ifdef VBOXDBG_USE_QT4
1268	QHBoxLayout *pHLayout = new QHBoxLayout;
1269
1270	QLabel *pLabel = new QLabel(" Pattern ");
1271	pHLayout->addWidget(pLabel);
1272	pLabel->setMaximumSize(pLabel->sizeHint());
1273	pLabel->setAlignment(Qt::AlignHCenter \| Qt::AlignVCenter);
1274
1275	m_pPatCB = new QComboBox();
1276	pHLayout->addWidget(m_pPatCB);
1277	if (pszPat && *pszPat)
1278	m_pPatCB->addItem(pszPat);
1279	m_pPatCB->setDuplicatesEnabled(false);
1280	m_pPatCB->setEditable(true);
1281	connect(m_pPatCB, SIGNAL(activated(const QString &)), this, SLOT(apply(const QString &)));
1282
1283	QPushButton *pPB = new QPushButton("&All");
1284	pHLayout->addWidget(pPB);
1285	pPB->setMaximumSize(pPB->sizeHint());
1286	connect(pPB, SIGNAL(clicked()), this, SLOT(applyAll()));
1287
1288	pLabel = new QLabel(" Interval ");
1289	pHLayout->addWidget(pLabel);
1290	pLabel->setMaximumSize(pLabel->sizeHint());
1291	pLabel->setAlignment(Qt::AlignRight \| Qt::AlignVCenter);
1292
1293	QSpinBox *pSB = new QSpinBox();
1294	pHLayout->addWidget(pSB);
1295	pSB->setMinimum(0);
1296	pSB->setMaximum(60);
1297	pSB->setSingleStep(1.0);
1298	/* The reset of the spinbox setup is identical - bet they forgot to change something ;-) */
1299	#else
1300
1301	QHBox *pHBox = new QHBox(this);
1302
1303	QLabel *pLabel = new QLabel(NULL, " Pattern ", pHBox);
1304	pLabel->setMaximumSize(pLabel->sizeHint());
1305	pLabel->setAlignment(AlignHCenter \| AlignVCenter);
1306
1307	m_pPatCB = new QComboBox(true, pHBox, "Pattern");
1308	if (pszPat && *pszPat)
1309	m_pPatCB->insertItem(pszPat);
1310	m_pPatCB->setDuplicatesEnabled(false);
1311	connect(m_pPatCB, SIGNAL(activated(const QString &)), this, SLOT(apply(const QString &)));
1312
1313	QPushButton *pPB = new QPushButton("&All", pHBox);
1314	connect(pPB, SIGNAL(clicked()), this, SLOT(applyAll()));
1315	pPB->setMaximumSize(pPB->sizeHint());
1316
1317	pLabel = new QLabel(NULL, " Interval ", pHBox);
1318	pLabel->setMaximumSize(pLabel->sizeHint());
1319	pLabel->setAlignment(AlignRight \| AlignVCenter);
1320
1321	QSpinBox *pSB = new QSpinBox(0, 60, 1, pHBox, "Interval");
1322	#endif
1323	pSB->setValue(m_uRefreshRate);
1324	pSB->setSuffix(" s");
1325	pSB->setWrapping(false);
1326	pSB->setButtonSymbols(QSpinBox::PlusMinus);
1327	pSB->setMaximumSize(pSB->sizeHint());
1328	connect(pSB, SIGNAL(valueChanged(int)), this, SLOT(setRefresh(int)));
1329
1330
1331	/*
1332	* Create the tree view and setup the layout.
1333	*/
1334	#ifdef VBOXDBG_USE_QT4
1335	m_pView = new VBoxDbgStatsView(pVM, this);
1336
1337	QWidget *pHBox = new QWidget;
1338	pHBox->setLayout(pHLayout);
1339
1340	QVBoxLayout *pVLayout = new QVBoxLayout;
1341	pVLayout->addWidget(pHBox);
1342	pVLayout->addWidget(m_pView);
1343	this->setLayout(pVLayout);
1344	#else
1345	m_pView = new VBoxDbgStatsView(pVM, this);
1346	#endif
1347
1348	/*
1349	* Perform the first refresh to get a good window size.
1350	* We do this with sorting disabled because it's horribly slow otherwise.
1351	*/
1352	int iColumn = m_pView->sortColumn();
1353	#ifdef VBOXDBG_USE_QT4
1354	m_pView->setUpdatesEnabled(false);
1355	m_pView->setSortingEnabled(false);
1356	refresh();
1357	m_pView->sortItems(iColumn, Qt::AscendingOrder);
1358	// QTreeView::expandAll
1359	m_pView->expandAll();
1360	for (int i = 0; i <= 8; i++)
1361	{
1362	printf("%#x: %d", i, m_pView->columnWidth(i));
1363	m_pView->resizeColumnToContents(i);
1364	printf(" -> %d\n", m_pView->columnWidth(i));
1365	}
1366	m_pView->setUpdatesEnabled(true);
1367	#else
1368	m_pView->setSortColumn(-1);
1369	refresh();
1370	m_pView->setSortColumn(iColumn);
1371	m_pView->sort();
1372	#endif
1373
1374	/*
1375	* Create a refresh timer and start it.
1376	*/
1377	m_pTimer = new QTimer(this);
1378	connect(m_pTimer, SIGNAL(timeout()), this, SLOT(refresh()));
1379	setRefresh(uRefreshRate);
1380	}
1381
1382	VBoxDbgStats::~VBoxDbgStats()
1383	{
1384	//????
1385	}
1386
1387	void VBoxDbgStats::apply(const QString &Str)
1388	{
1389	m_PatStr = Str;
1390	refresh();
1391	}
1392
1393	void VBoxDbgStats::applyAll()
1394	{
1395	apply("");
1396	}
1397
1398	void VBoxDbgStats::refresh()
1399	{
1400	m_pView->update(m_PatStr);
1401	}
1402
1403	void VBoxDbgStats::setRefresh(int iRefresh)
1404	{
1405	if ((unsigned)iRefresh != m_uRefreshRate)
1406	{
1407	#ifdef VBOXDBG_USE_QT4
1408	if (!m_uRefreshRate \|\| iRefresh)
1409	m_pTimer->start(iRefresh * 1000);
1410	#else
1411	if (!m_uRefreshRate)
1412	m_pTimer->start(iRefresh * 1000);
1413	else if (iRefresh)
1414	m_pTimer->changeInterval(iRefresh * 1000);
1415	#endif
1416	else
1417	m_pTimer->stop();
1418	m_uRefreshRate = iRefresh;
1419	}
1420	}
1421

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Debugger/VBoxDbgStats.cpp@ 12329

Download in other formats: