VirtualBox

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

Last change on this file since 12464 was 12464, checked in by vboxsync, 16 years ago

spaces
  • 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 12464 2008-09-15 15:19:46Z 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 */
60const 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
80VBoxDbgStatsItem::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
91VBoxDbgStatsItem::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
101VBoxDbgStatsItem::~VBoxDbgStatsItem()
102{
103 RTStrFree(m_pszName);
104 m_pszName = NULL;
105}
106
107void 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
126void 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
145void 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
167VBoxDbgStatsLeafItem::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
176VBoxDbgStatsLeafItem::~VBoxDbgStatsLeafItem()
177{
178}
179
180
181/**
182 * Formats a number into a 64-byte buffer.
183 */
184static 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 */
209static 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 */
237static 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 */
262static 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 */
289static 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
324void 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
532QString 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
628void 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
673void 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
726VBoxDbgStatsView::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
816VBoxDbgStatsView::~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 */
839static 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 */
860static void showParentBranches(VBoxDbgStatsLeafItem *pItem)
861{
862 for (VBoxDbgStatsItem *pParent = pItem->getParent(); pParent; pParent = pParent->getParent())
863 pParent->setVisible(true);
864}
865
866void 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
884void VBoxDbgStatsView::reset(const QString &rPatStr)
885{
886 stamReset(rPatStr);
887}
888
889static 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
904void VBoxDbgStatsView::expandAll()
905{
906 setOpenTree(m_pRoot, true);
907}
908
909void 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
1003VBoxDbgStatsItem *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
1064void 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
1100void 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
1134void 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
1201void 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
1250VBoxDbgStats::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
1382VBoxDbgStats::~VBoxDbgStats()
1383{
1384 //????
1385}
1386
1387void VBoxDbgStats::apply(const QString &Str)
1388{
1389 m_PatStr = Str;
1390 refresh();
1391}
1392
1393void VBoxDbgStats::applyAll()
1394{
1395 apply("");
1396}
1397
1398void VBoxDbgStats::refresh()
1399{
1400 m_pView->update(m_PatStr);
1401}
1402
1403void 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.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette