VirtualBox

Changeset 104965 in vbox


Ignore:
Timestamp:
Jun 19, 2024 2:03:06 PM (3 months ago)
Author:
vboxsync
Message:

FE/Qt. bugref:10659. Cleaning obsolete classes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/src/activity/overview/UIVMActivityOverviewWidget.cpp

    r104964 r104965  
    2727
    2828/* Qt includes: */
    29 #include <QAbstractTableModel>
    3029#include <QApplication>
    3130#include <QCheckBox>
    … …  
    3635#include <QPainter>
    3736#include <QPushButton>
    38 #include <QTableView>
    3937#include <QTimer>
    4038#include <QVBoxLayout>
    41 #include <QSortFilterProxyModel>
    4239
    4340/* GUI includes: */
    4441#include "QIDialogButtonBox.h"
    45 #include "QITableView.h"
    4642#include "QIToolBar.h"
    4743#include "UIActionPoolManager.h"
    … …  
    166162
    167163/*********************************************************************************************************************************
    168 *   Class UIVMActivityOverviewTableView definition.                                                                              *
    169 *********************************************************************************************************************************/
    170 /** A QTableView extension so manage the column width a bit better than what Qt offers out of box. */
    171 class UIVMActivityOverviewTableView : public QTableView
    172 {
    173     Q_OBJECT;
    174 
    175 signals:
    176 
    177     void sigSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected);
    178 
    179 public:
    180 
    181     UIVMActivityOverviewTableView(QWidget *pParent = 0);
    182     void setMinimumColumnWidths(const QMap<int, int>& widths);
    183     void updateColumVisibility();
    184     int selectedItemIndex() const;
    185     bool hasSelection() const;
    186 
    187 protected:
    188 
    189     virtual void resizeEvent(QResizeEvent *pEvent) RT_OVERRIDE;
    190     virtual void selectionChanged(const QItemSelection &selected, const QItemSelection &deselected) RT_OVERRIDE;
    191     virtual void mousePressEvent(QMouseEvent *pEvent) RT_OVERRIDE;
    192 
    193 private slots:
    194 
    195 
    196 
    197 private:
    198 
    199     /** Resizes all the columns in response to resizeEvent. Columns cannot be narrower than m_minimumColumnWidths values. */
    200     void resizeHeaders();
    201     /** Value is in pixels. Columns cannot be narrower than this width. */
    202     QMap<int, int> m_minimumColumnWidths;
    203 };
    204 
    205 
    206 /*********************************************************************************************************************************
    207164 *   Class UIActivityOverviewItem definition.                                                                           *
    208165 *********************************************************************************************************************************/
    … …  
    318275    KCloudMachineState m_enmMachineState;
    319276    QVector<KMetricType> m_availableMetricTypes;
    320 };
    321 
    322 
    323 /*********************************************************************************************************************************
    324 *   Class UIVMActivityOverviewProxyModel definition.                                                                             *
    325 *********************************************************************************************************************************/
    326 class UIActivityOverviewProxyModel : public QSortFilterProxyModel
    327 {
    328 
    329     Q_OBJECT;
    330 
    331 public:
    332 
    333     UIActivityOverviewProxyModel(QObject *parent = 0);
    334     void dataUpdate();
    335     void setNotRunningVMVisibility(bool fShow);
    336     void setCloudVMVisibility(bool fShow);
    337 
    338 protected:
    339 
    340     virtual bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const RT_OVERRIDE;
    341     bool filterAcceptsRow(int iSourceRow, const QModelIndex &sourceParent) const RT_OVERRIDE;
    342 
    343 private:
    344 
    345     bool m_fShowNotRunningVMs;
    346     bool m_fShowCloudVMs;
    347 };
    348 
    349 
    350 /*********************************************************************************************************************************
    351 *   UIActivityOverviewModel definition.                                                                                    *
    352 *********************************************************************************************************************************/
    353 class UIActivityOverviewModel : public QAbstractTableModel
    354 {
    355     Q_OBJECT;
    356 
    357 signals:
    358 
    359     void sigDataUpdate();
    360     void sigHostStatsUpdate(const UIVMActivityOverviewHostStats &stats);
    361 
    362 public:
    363 
    364     UIActivityOverviewModel(QObject *parent = 0);
    365     int      rowCount(const QModelIndex &parent = QModelIndex()) const RT_OVERRIDE;
    366     int      columnCount(const QModelIndex &parent = QModelIndex()) const RT_OVERRIDE;
    367     QVariant data(const QModelIndex &index, int role) const RT_OVERRIDE;
    368     void clearData();
    369     QVariant headerData(int section, Qt::Orientation orientation, int role) const RT_OVERRIDE;
    370     void setColumnCaptions(const QMap<int, QString>& captions);
    371     void setColumnVisible(const QMap<int, bool>& columnVisible);
    372     bool columnVisible(int iColumnId) const;
    373     void setShouldUpdate(bool fShouldUpdate);
    374     const QMap<int, int> dataLengths() const;
    375     QUuid itemUid(int iIndex);
    376     int itemIndex(const QUuid &uid);
    377     bool isVMRunning(int rowIndex) const;
    378     bool isCloudVM(int rowIndex) const;
    379     void setCloudMachineItems(const QList<UIVirtualMachineItemCloud*> &cloudItems);
    380 
    381 private slots:
    382 
    383     void sltMachineStateChanged(const QUuid &uId, const KMachineState state);
    384     void sltMachineRegistered(const QUuid &uId, bool fRegistered);
    385     void sltLocalVMUpdateTimeout();
    386 
    387 private:
    388 
    389     void initialize();
    390     void initializeItems();
    391     void setupPerformanceCollector();
    392     void queryPerformanceCollector();
    393     void addItem(const QUuid& uMachineId, const QString& strMachineName, KMachineState enmState);
    394     void removeItem(const QUuid& uMachineId);
    395     void getHostRAMStats();
    396 
    397     QVector<UIActivityOverviewItem*> m_itemList;
    398     QMap<int, QString> m_columnTitles;
    399     QTimer *m_pLocalVMUpdateTimer;
    400 
    401     /** @name The following are used during UIPerformanceCollector::QueryMetricsData(..)
    402      * @{ */
    403        QVector<QString> m_nameList;
    404        QVector<CUnknown> m_objectList;
    405     /** @} */
    406     CPerformanceCollector m_performanceCollector;
    407     QMap<int, bool> m_columnVisible;
    408     UIVMActivityOverviewHostStats m_hostStats;
    409     /** Maximum length of string length of data displayed in column. Updated in UIActivityOverviewModel::data(..). */
    410     mutable QMap<int, int> m_columnDataMaxLength;
    411277};
    412278
    … …  
    731597
    732598
    733 
    734 /*********************************************************************************************************************************
    735 *   Class UIVMActivityOverviewTableView implementation.                                                                          *
    736 *********************************************************************************************************************************/
    737 
    738 UIVMActivityOverviewTableView::UIVMActivityOverviewTableView(QWidget *pParent /* = 0 */)
    739     :QTableView(pParent)
    740 {
    741 }
    742 
    743 void UIVMActivityOverviewTableView::setMinimumColumnWidths(const QMap<int, int>& widths)
    744 {
    745     m_minimumColumnWidths = widths;
    746     resizeHeaders();
    747 }
    748 
    749 void UIVMActivityOverviewTableView::updateColumVisibility()
    750 {
    751     UIActivityOverviewProxyModel *pProxyModel = qobject_cast<UIActivityOverviewProxyModel *>(model());
    752     if (!pProxyModel)
    753         return;
    754     UIActivityOverviewModel *pModel = qobject_cast<UIActivityOverviewModel *>(pProxyModel->sourceModel());
    755     QHeaderView *pHeader = horizontalHeader();
    756 
    757     if (!pModel || !pHeader)
    758         return;
    759     for (int i = (int)VMActivityOverviewColumn_Name; i < (int)VMActivityOverviewColumn_Max; ++i)
    760     {
    761         if (!pModel->columnVisible(i))
    762             pHeader->hideSection(i);
    763         else
    764             pHeader->showSection(i);
    765     }
    766     resizeHeaders();
    767 }
    768 
    769 int UIVMActivityOverviewTableView::selectedItemIndex() const
    770 {
    771     UIActivityOverviewProxyModel *pModel = qobject_cast<UIActivityOverviewProxyModel*>(model());
    772     if (!pModel)
    773         return -1;
    774 
    775     QItemSelectionModel *pSelectionModel =  selectionModel();
    776     if (!pSelectionModel)
    777         return -1;
    778     QModelIndexList selectedItemIndices = pSelectionModel->selectedRows();
    779     if (selectedItemIndices.isEmpty())
    780         return -1;
    781 
    782     /* just use the the 1st index: */
    783     QModelIndex modelIndex = pModel->mapToSource(selectedItemIndices[0]);
    784 
    785     if (!modelIndex.isValid())
    786         return -1;
    787     return modelIndex.row();
    788 }
    789 
    790 bool UIVMActivityOverviewTableView::hasSelection() const
    791 {
    792     if (!selectionModel())
    793         return false;
    794     return selectionModel()->hasSelection();
    795 }
    796 
    797 void UIVMActivityOverviewTableView::resizeEvent(QResizeEvent *pEvent)
    798 {
    799     resizeHeaders();
    800     QTableView::resizeEvent(pEvent);
    801 }
    802 
    803 void UIVMActivityOverviewTableView::selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
    804 {
    805     emit sigSelectionChanged(selected, deselected);
    806     QTableView::selectionChanged(selected, deselected);
    807 }
    808 
    809 void UIVMActivityOverviewTableView::mousePressEvent(QMouseEvent *pEvent)
    810 {
    811     if (!indexAt(pEvent->position().toPoint()).isValid())
    812         clearSelection();
    813     QTableView::mousePressEvent(pEvent);
    814 }
    815 
    816 void UIVMActivityOverviewTableView::resizeHeaders()
    817 {
    818     QHeaderView* pHeader = horizontalHeader();
    819     if (!pHeader)
    820         return;
    821     int iSectionCount = pHeader->count();
    822     int iHiddenSectionCount = pHeader->hiddenSectionCount();
    823     int iWidth = width() / (iSectionCount - iHiddenSectionCount);
    824     for (int i = 0; i < iSectionCount; ++i)
    825     {
    826         if (pHeader->isSectionHidden(i))
    827             continue;
    828         int iMinWidth = m_minimumColumnWidths.value((VMActivityOverviewColumn)i, 0);
    829         pHeader->resizeSection(i, iWidth < iMinWidth ? iMinWidth : iWidth);
    830     }
    831 }
    832 
    833 
    834599/*********************************************************************************************************************************
    835600*   Class UIActivityOverviewItem implementation.                                                                                 *
    … …  
    1226991{
    1227992    return gpConverter->toString(m_enmMachineState);
    1228 }
    1229 
    1230 
    1231 /*********************************************************************************************************************************
    1232 *   Class UIVMActivityOverviewProxyModel implementation.                                                                         *
    1233 *********************************************************************************************************************************/
    1234 UIActivityOverviewProxyModel::UIActivityOverviewProxyModel(QObject *parent /* = 0 */)
    1235     :QSortFilterProxyModel(parent)
    1236 {
    1237 }
    1238 
    1239 void UIActivityOverviewProxyModel::dataUpdate()
    1240 {
    1241     if (sourceModel())
    1242         emit dataChanged(index(0,0), index(sourceModel()->rowCount(), sourceModel()->columnCount()));
    1243     invalidate();
    1244 }
    1245 
    1246 void UIActivityOverviewProxyModel::setNotRunningVMVisibility(bool fShow)
    1247 {
    1248     if (m_fShowNotRunningVMs == fShow)
    1249         return;
    1250     m_fShowNotRunningVMs = fShow;
    1251     invalidateFilter();
    1252 }
    1253 
    1254 void UIActivityOverviewProxyModel::setCloudVMVisibility(bool fShow)
    1255 {
    1256     if (m_fShowCloudVMs == fShow)
    1257         return;
    1258     m_fShowCloudVMs = fShow;
    1259     invalidateFilter();
    1260 }
    1261 
    1262 bool UIActivityOverviewProxyModel::lessThan(const QModelIndex &sourceLeftIndex, const QModelIndex &sourceRightIndex) const
    1263 {
    1264     UIActivityOverviewModel *pModel = qobject_cast<UIActivityOverviewModel*>(sourceModel());
    1265     if (pModel)
    1266     {
    1267         /* Keep running vm always on top of the list: */
    1268         bool fLeftRunning = pModel->isVMRunning(sourceLeftIndex.row());
    1269         bool fRightRunning = pModel->isVMRunning(sourceRightIndex.row());
    1270         if (fLeftRunning && !fRightRunning)
    1271         {
    1272             if (sortOrder() == Qt::AscendingOrder)
    1273                 return true;
    1274             else
    1275                 return false;
    1276         }
    1277         if (!fLeftRunning && fRightRunning)
    1278         {
    1279             if (sortOrder() == Qt::AscendingOrder)
    1280                 return false;
    1281             else
    1282                 return true;
    1283         }
    1284     }
    1285     return QSortFilterProxyModel::lessThan(sourceLeftIndex, sourceRightIndex);
    1286 }
    1287 
    1288 bool UIActivityOverviewProxyModel::filterAcceptsRow(int iSourceRow, const QModelIndex &sourceParent) const
    1289 {
    1290     Q_UNUSED(sourceParent);
    1291     if (m_fShowNotRunningVMs && m_fShowCloudVMs)
    1292         return true;
    1293     UIActivityOverviewModel *pModel = qobject_cast<UIActivityOverviewModel*>(sourceModel());
    1294     if (!pModel)
    1295         return true;
    1296 
    1297     if (!m_fShowNotRunningVMs && !pModel->isVMRunning(iSourceRow))
    1298         return false;
    1299     if (!m_fShowCloudVMs && pModel->isCloudVM(iSourceRow))
    1300         return false;
    1301     return true;
    1302 }
    1303 
    1304 
    1305 /*********************************************************************************************************************************
    1306 *   Class UIActivityOverviewModel implementation.                                                                                *
    1307 *********************************************************************************************************************************/
    1308 UIActivityOverviewModel::UIActivityOverviewModel(QObject *parent /*= 0*/)
    1309     :QAbstractTableModel(parent)
    1310     , m_pLocalVMUpdateTimer(new QTimer(this))
    1311 {
    1312     initialize();
    1313 }
    1314 
    1315 void UIActivityOverviewModel::initialize()
    1316 {
    1317     for (int i = 0; i < (int)VMActivityOverviewColumn_Max; ++i)
    1318         m_columnDataMaxLength[i] = 0;
    1319 
    1320     initializeItems();
    1321     connect(gVBoxEvents, &UIVirtualBoxEventHandler::sigMachineStateChange,
    1322             this, &UIActivityOverviewModel::sltMachineStateChanged);
    1323     connect(gVBoxEvents, &UIVirtualBoxEventHandler::sigMachineRegistered,
    1324             this, &UIActivityOverviewModel::sltMachineRegistered);
    1325     if (m_pLocalVMUpdateTimer)
    1326     {
    1327         connect(m_pLocalVMUpdateTimer, &QTimer::timeout, this, &UIActivityOverviewModel::sltLocalVMUpdateTimeout);
    1328         m_pLocalVMUpdateTimer->start(1000);
    1329     }
    1330 }
    1331 
    1332 int UIActivityOverviewModel::rowCount(const QModelIndex &parent /* = QModelIndex() */) const
    1333 {
    1334     Q_UNUSED(parent);
    1335     return m_itemList.size();
    1336 }
    1337 
    1338 int UIActivityOverviewModel::columnCount(const QModelIndex &parent /* = QModelIndex() */) const
    1339 {
    1340     Q_UNUSED(parent);
    1341     return VMActivityOverviewColumn_Max;
    1342 }
    1343 
    1344 void UIActivityOverviewModel::setShouldUpdate(bool fShouldUpdate)
    1345 {
    1346     if (m_pLocalVMUpdateTimer)
    1347     {
    1348         if (fShouldUpdate)
    1349             m_pLocalVMUpdateTimer->start();
    1350         else
    1351             m_pLocalVMUpdateTimer->stop();
    1352     }
    1353 }
    1354 
    1355 const QMap<int, int> UIActivityOverviewModel::dataLengths() const
    1356 {
    1357     return m_columnDataMaxLength;
    1358 }
    1359 
    1360 QUuid UIActivityOverviewModel::itemUid(int iIndex)
    1361 {
    1362     if (iIndex >= m_itemList.size() || !m_itemList[iIndex])
    1363         return QUuid();
    1364     return m_itemList[iIndex]->machineId();
    1365 }
    1366 
    1367 int UIActivityOverviewModel::itemIndex(const QUuid &uid)
    1368 {
    1369     for (int i = 0; i < m_itemList.size(); ++i)
    1370     {
    1371         if (!m_itemList[i])
    1372             continue;
    1373         if (m_itemList[i]->machineId() == uid)
    1374             return i;
    1375     }
    1376     return -1;
    1377 }
    1378 
    1379 bool UIActivityOverviewModel::isVMRunning(int rowIndex) const
    1380 {
    1381     if (rowIndex >= m_itemList.size() || rowIndex < 0 || !m_itemList[rowIndex])
    1382         return false;
    1383     return m_itemList[rowIndex]->isRunning();
    1384 }
    1385 
    1386 bool UIActivityOverviewModel::isCloudVM(int rowIndex) const
    1387 {
    1388     if (rowIndex >= m_itemList.size() || rowIndex < 0 || !m_itemList[rowIndex])
    1389         return false;
    1390     return m_itemList[rowIndex]->isCloudVM();
    1391 }
    1392 
    1393 void UIActivityOverviewModel::setCloudMachineItems(const QList<UIVirtualMachineItemCloud*> &cloudItems)
    1394 {
    1395     QVector<QUuid> newIds;
    1396     foreach (const UIVirtualMachineItemCloud* pItem, cloudItems)
    1397     {
    1398         if (!pItem)
    1399             continue;
    1400         QUuid id = pItem->machineId();
    1401         if (id.isNull())
    1402             continue;
    1403         newIds << id;
    1404     }
    1405     QVector<UIActivityOverviewItem*> originalItemList = m_itemList;
    1406 
    1407     /* Remove m_itemList items that are not in @cloudItems: */
    1408     QMutableVectorIterator<UIActivityOverviewItem*> iterator(m_itemList);
    1409     while (iterator.hasNext())
    1410     {
    1411         UIActivityOverviewItem *pItem = iterator.next();
    1412         if (!pItem->isCloudVM())
    1413             continue;
    1414         if (pItem && !newIds.contains(pItem->machineId()))
    1415             iterator.remove();
    1416     }
    1417 
    1418     /* Add items that are not in m_itemList: */
    1419     foreach (const UIVirtualMachineItemCloud* pItem, cloudItems)
    1420     {
    1421         if (!pItem)
    1422             continue;
    1423         CCloudMachine comMachine = pItem->machine();
    1424         if (!comMachine.isOk())
    1425             continue;
    1426         QUuid id = comMachine.GetId();
    1427         /* Linearly search for the vm with th same id. I cannot make QVector::contain work since we store pointers: */
    1428         bool fFound = false;
    1429         for (int i = 0; i < m_itemList.size() && !fFound; ++i)
    1430         {
    1431             if (m_itemList[i] && m_itemList[i]->machineId() == id)
    1432                 fFound = true;
    1433         }
    1434         if (!fFound)
    1435             m_itemList.append(new UIActivityOverviewItemCloud(this, id, comMachine.GetName(), comMachine));
    1436     }
    1437 
    1438     /* Update cloud machine states: */
    1439     for (int i = 0; i < m_itemList.size(); ++i)
    1440     {
    1441         if (!m_itemList[i] || !m_itemList[i]->isCloudVM())
    1442             continue;
    1443         UIActivityOverviewItemCloud *pItem = qobject_cast<UIActivityOverviewItemCloud*>(m_itemList[i]);
    1444         if (!pItem)
    1445             continue;
    1446         pItem->updateMachineState();
    1447     }
    1448 }
    1449 
    1450 QVariant UIActivityOverviewModel::data(const QModelIndex &index, int role) const
    1451 {
    1452     if (!isVMRunning(index.row()))
    1453     {
    1454         if (role == Qt::FontRole)
    1455         {
    1456             QFont font = qApp->font();
    1457             font.setItalic(true);
    1458             return font;
    1459         }
    1460         if (role == Qt::ForegroundRole)
    1461         {
    1462             /* For some reason QColor::lighter(..) is not working here: */
    1463             QColor color = qApp->palette().color(QPalette::Active, QPalette::WindowText);
    1464             int h, s, l;
    1465             color.getHsl(&h, &s, &l);
    1466             l = 100;
    1467             return QColor::fromHsl(h, s, l);
    1468         }
    1469     }
    1470     if (!index.isValid() || role != Qt::DisplayRole || index.row() >= rowCount())
    1471         return QVariant();
    1472 
    1473     UIActivityOverviewItem *pItem = m_itemList[index.row()];
    1474     AssertPtrReturn(pItem, QVariant());
    1475 
    1476     if (index.column() == VMActivityOverviewColumn_Name)
    1477         return pItem->columnData(index.column());
    1478 
    1479     if (!pItem->isRunning())
    1480         return pItem->machineStateString();
    1481 
    1482     return pItem->columnData(index.column());
    1483 }
    1484 
    1485 void UIActivityOverviewModel::clearData()
    1486 {
    1487     /* We have a request to detach COM stuff,
    1488      * first of all we are removing all the items,
    1489      * this will detach COM wrappers implicitly: */
    1490     qDeleteAll(m_itemList);
    1491     m_itemList.clear();
    1492     /* Detaching perf. collector finally,
    1493      * please do not use it after all: */
    1494     m_performanceCollector.detach();
    1495 }
    1496 
    1497 QVariant UIActivityOverviewModel::headerData(int section, Qt::Orientation orientation, int role) const
    1498 {
    1499     if (role == Qt::DisplayRole && orientation == Qt::Horizontal)
    1500         return m_columnTitles.value((VMActivityOverviewColumn)section, QString());;
    1501     return QVariant();
    1502 }
    1503 
    1504 void UIActivityOverviewModel::setColumnCaptions(const QMap<int, QString>& captions)
    1505 {
    1506     m_columnTitles = captions;
    1507 }
    1508 
    1509 void UIActivityOverviewModel::initializeItems()
    1510 {
    1511     foreach (const CMachine &comMachine, gpGlobalSession->virtualBox().GetMachines())
    1512     {
    1513         if (!comMachine.isNull())
    1514             addItem(comMachine.GetId(), comMachine.GetName(), comMachine.GetState());
    1515     }
    1516     setupPerformanceCollector();
    1517 }
    1518 
    1519 void UIActivityOverviewModel::sltMachineStateChanged(const QUuid &uId, const KMachineState state)
    1520 {
    1521     int iIndex = itemIndex(uId);
    1522     if (iIndex != -1 && iIndex < m_itemList.size())
    1523     {
    1524         UIActivityOverviewItemLocal *pItem = qobject_cast<UIActivityOverviewItemLocal*>(m_itemList[iIndex]);
    1525         if (pItem)
    1526         {
    1527             pItem->setMachineState(state);
    1528             if (state == KMachineState_Running)
    1529                 pItem->resetDebugger();
    1530         }
    1531     }
    1532 }
    1533 
    1534 void UIActivityOverviewModel::sltMachineRegistered(const QUuid &uId, bool fRegistered)
    1535 {
    1536     if (fRegistered)
    1537     {
    1538         CMachine comMachine = gpGlobalSession->virtualBox().FindMachine(uId.toString());
    1539         if (!comMachine.isNull())
    1540             addItem(uId, comMachine.GetName(), comMachine.GetState());
    1541     }
    1542     else
    1543         removeItem(uId);
    1544     emit sigDataUpdate();
    1545 }
    1546 
    1547 void UIActivityOverviewModel::getHostRAMStats()
    1548 {
    1549     CHost comHost = gpGlobalSession->host();
    1550     m_hostStats.m_iRAMTotal = _1M * (quint64)comHost.GetMemorySize();
    1551     m_hostStats.m_iRAMFree = _1M * (quint64)comHost.GetMemoryAvailable();
    1552 }
    1553 
    1554 void UIActivityOverviewModel::sltLocalVMUpdateTimeout()
    1555 {
    1556     /* Host's RAM usage is obtained from IHost not from IPerformanceCollector: */
    1557     getHostRAMStats();
    1558 
    1559     /* Use IPerformanceCollector to update VM RAM usage and Host CPU and file IO stats: */
    1560     queryPerformanceCollector();
    1561 
    1562     for (int i = 0; i < m_itemList.size(); ++i)
    1563     {
    1564         UIActivityOverviewItemLocal *pItem = qobject_cast<UIActivityOverviewItemLocal*>(m_itemList[i]);
    1565         if (!pItem || !pItem->isRunning())
    1566             continue;
    1567         pItem->updateColumnData();
    1568     }
    1569 
    1570     for (int i = 0; i < (int)VMActivityOverviewColumn_Max; ++i)
    1571     {
    1572         for (int j = 0; j < m_itemList.size(); ++j)
    1573             if (m_columnDataMaxLength.value(i, 0) < m_itemList[j]->columnLength(i))
    1574                 m_columnDataMaxLength[i] = m_itemList[j]->columnLength(i);
    1575     }
    1576 
    1577     emit sigDataUpdate();
    1578     emit sigHostStatsUpdate(m_hostStats);
    1579 }
    1580 
    1581 void UIActivityOverviewModel::setupPerformanceCollector()
    1582 {
    1583     m_nameList.clear();
    1584     m_objectList.clear();
    1585     /* Initialize and configure CPerformanceCollector: */
    1586     const ULONG iPeriod = 1;
    1587     const int iMetricSetupCount = 1;
    1588     if (m_performanceCollector.isNull())
    1589         m_performanceCollector = gpGlobalSession->virtualBox().GetPerformanceCollector();
    1590     for (int i = 0; i < m_itemList.size(); ++i)
    1591         m_nameList << "Guest/RAM/Usage*";
    1592     /* This is for the host: */
    1593     m_nameList << "CPU*";
    1594     m_nameList << "FS*";
    1595     m_objectList = QVector<CUnknown>(m_nameList.size(), CUnknown());
    1596     m_performanceCollector.SetupMetrics(m_nameList, m_objectList, iPeriod, iMetricSetupCount);
    1597 }
    1598 
    1599 void UIActivityOverviewModel::queryPerformanceCollector()
    1600 {
    1601     QVector<QString>  aReturnNames;
    1602     QVector<CUnknown>  aReturnObjects;
    1603     QVector<QString>  aReturnUnits;
    1604     QVector<ULONG>  aReturnScales;
    1605     QVector<ULONG>  aReturnSequenceNumbers;
    1606     QVector<ULONG>  aReturnDataIndices;
    1607     QVector<ULONG>  aReturnDataLengths;
    1608 
    1609     QVector<LONG> returnData = m_performanceCollector.QueryMetricsData(m_nameList,
    1610                                                                        m_objectList,
    1611                                                                        aReturnNames,
    1612                                                                        aReturnObjects,
    1613                                                                        aReturnUnits,
    1614                                                                        aReturnScales,
    1615                                                                        aReturnSequenceNumbers,
    1616                                                                        aReturnDataIndices,
    1617                                                                        aReturnDataLengths);
    1618     /* Parse the result we get from CPerformanceCollector to get respective values: */
    1619     for (int i = 0; i < aReturnNames.size(); ++i)
    1620     {
    1621         if (aReturnDataLengths[i] == 0)
    1622             continue;
    1623         /* Read the last of the return data disregarding the rest since we are caching the data in GUI side: */
    1624         float fData = returnData[aReturnDataIndices[i] + aReturnDataLengths[i] - 1] / (float)aReturnScales[i];
    1625         if (aReturnNames[i].contains("RAM", Qt::CaseInsensitive) && !aReturnNames[i].contains(":"))
    1626         {
    1627             if (aReturnNames[i].contains("Total", Qt::CaseInsensitive) || aReturnNames[i].contains("Free", Qt::CaseInsensitive))
    1628             {
    1629                 {
    1630                     CMachine comMachine = (CMachine)aReturnObjects[i];
    1631                     if (comMachine.isNull())
    1632                         continue;
    1633                     int iIndex = itemIndex(comMachine.GetId());
    1634                     if (iIndex == -1 || iIndex >= m_itemList.size() || !m_itemList[iIndex])
    1635                         continue;
    1636 
    1637                     if (aReturnNames[i].contains("Total", Qt::CaseInsensitive))
    1638                         m_itemList[iIndex]->m_uTotalRAM = fData;
    1639                     else
    1640                         m_itemList[iIndex]->m_uFreeRAM = fData;
    1641                 }
    1642             }
    1643         }
    1644         else if (aReturnNames[i].contains("CPU/Load/User", Qt::CaseInsensitive) && !aReturnNames[i].contains(":"))
    1645         {
    1646             CHost comHost = (CHost)aReturnObjects[i];
    1647             if (!comHost.isNull())
    1648                 m_hostStats.m_iCPUUserLoad = fData;
    1649         }
    1650         else if (aReturnNames[i].contains("CPU/Load/Kernel", Qt::CaseInsensitive) && !aReturnNames[i].contains(":"))
    1651         {
    1652             CHost comHost = (CHost)aReturnObjects[i];
    1653             if (!comHost.isNull())
    1654                 m_hostStats.m_iCPUKernelLoad = fData;
    1655         }
    1656         else if (aReturnNames[i].contains("CPU/MHz", Qt::CaseInsensitive) && !aReturnNames[i].contains(":"))
    1657         {
    1658             CHost comHost = (CHost)aReturnObjects[i];
    1659             if (!comHost.isNull())
    1660                 m_hostStats.m_iCPUFreq = fData;
    1661         }
    1662        else if (aReturnNames[i].contains("FS", Qt::CaseInsensitive) &&
    1663                 aReturnNames[i].contains("Total", Qt::CaseInsensitive) &&
    1664                 !aReturnNames[i].contains(":"))
    1665        {
    1666             CHost comHost = (CHost)aReturnObjects[i];
    1667             if (!comHost.isNull())
    1668                 m_hostStats.m_iFSTotal = _1M * fData;
    1669        }
    1670        else if (aReturnNames[i].contains("FS", Qt::CaseInsensitive) &&
    1671                 aReturnNames[i].contains("Free", Qt::CaseInsensitive) &&
    1672                 !aReturnNames[i].contains(":"))
    1673        {
    1674             CHost comHost = (CHost)aReturnObjects[i];
    1675             if (!comHost.isNull())
    1676                 m_hostStats.m_iFSFree = _1M * fData;
    1677        }
    1678     }
    1679     for (int i = 0; i < m_itemList.size(); ++i)
    1680     {
    1681         if (!m_itemList[i] || m_itemList[i]->isCloudVM())
    1682             continue;
    1683         m_itemList[i]->m_uUsedRAM = m_itemList[i]->m_uTotalRAM - m_itemList[i]->m_uFreeRAM;
    1684         if (m_itemList[i]->m_uTotalRAM != 0)
    1685             m_itemList[i]->m_fRAMUsagePercentage = 100.f * (m_itemList[i]->m_uUsedRAM / (float)m_itemList[i]->m_uTotalRAM);
    1686     }
    1687 }
    1688 
    1689 void UIActivityOverviewModel::addItem(const QUuid& uMachineId, const QString& strMachineName, KMachineState enmState)
    1690 {
    1691     UIActivityOverviewItemLocal *pItem = new UIActivityOverviewItemLocal(this, uMachineId, strMachineName);
    1692     pItem->setMachineState(enmState);
    1693     m_itemList.append(pItem);
    1694 }
    1695 
    1696 void UIActivityOverviewModel::removeItem(const QUuid& uMachineId)
    1697 {
    1698     int iIndex = itemIndex(uMachineId);
    1699     if (iIndex == -1)
    1700         return;
    1701     delete m_itemList[iIndex];
    1702     m_itemList.remove(iIndex);
    1703 }
    1704 
    1705 void UIActivityOverviewModel::setColumnVisible(const QMap<int, bool>& columnVisible)
    1706 {
    1707     m_columnVisible = columnVisible;
    1708 }
    1709 
    1710 bool UIActivityOverviewModel::columnVisible(int iColumnId) const
    1711 {
    1712     return m_columnVisible.value(iColumnId, true);
    1713993}
    1714994
Note: See TracChangeset for help on using the changeset viewer.

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