VirtualBox

Changeset 102264 in vbox for trunk


Ignore:
Timestamp:
Nov 22, 2023 3:54:04 PM (15 months ago)
Author:
vboxsync
Message:

FE/Qt: bugref:10501. Getting cpu utilization data series and drawing them. not complete.

Location:
trunk/src/VBox/Frontends/VirtualBox/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r102147 r102264  
    3838#include "QIToolBar.h"
    3939#include "UIVirtualMachineItem.h"
     40#include "UIVirtualMachineItemCloud.h"
     41#include "UIVirtualMachineItemLocal.h"
    4042
    4143#ifdef VBOX_WS_MAC
    … …  
    99101void UIVMActivityToolWidget::setSelectedVMListItems(const QList<UIVirtualMachineItem*> &items)
    100102{
    101     QVector<QUuid> selectedMachines;
    102 
    103     foreach (const UIVirtualMachineItem *item, items)
    104     {
    105         if (!item)
    106             continue;
    107         selectedMachines << item->id();
    108     }
    109     setMachines(selectedMachines);
    110 }
    111 
    112 void UIVMActivityToolWidget::setMachines(const QVector<QUuid> &machineIds)
    113 {
     103    setMachines(items);
     104}
     105
     106void UIVMActivityToolWidget::setMachines(const QList<UIVirtualMachineItem*> &machines)
     107{
     108    QVector<QUuid> machineIds;
     109    foreach (const UIVirtualMachineItem* pMachine, machines)
     110    {
     111        if (!pMachine)
     112            continue;
     113        machineIds << pMachine->id();
     114    }
    114115    /* List of machines that are newly added to selected machine list: */
    115     QVector<QUuid> newSelections;
     116    QList<UIVirtualMachineItem*> newSelections;
    116117    QVector<QUuid> unselectedMachines(m_machineIds);
    117118
    118     foreach (const QUuid &id, machineIds)
    119     {
     119    foreach (UIVirtualMachineItem* pMachine, machines)
     120    {
     121        if (!pMachine)
     122            continue;
     123        QUuid id = pMachine->id();
    120124        unselectedMachines.removeAll(id);
    121125        if (!m_machineIds.contains(id))
    122             newSelections << id;
     126            newSelections << pMachine;
    123127    }
    124128    m_machineIds = machineIds;
    … …  
    188192}
    189193
    190 void UIVMActivityToolWidget::addTabs(const QVector<QUuid> &machineIdsToAdd)
    191 {
    192     foreach (const QUuid &id, machineIdsToAdd)
    193     {
    194         CMachine comMachine = uiCommon().virtualBox().FindMachine(id.toString());
    195         if (comMachine.isNull())
    196             continue;
    197         addTab(new UIVMActivityMonitorLocal(m_enmEmbedding, this, comMachine), comMachine.GetName());
     194void UIVMActivityToolWidget::addTabs(const QList<UIVirtualMachineItem*> &machines)
     195{
     196    foreach (UIVirtualMachineItem* pMachine, machines)
     197    {
     198        if (!pMachine)
     199            continue;
     200        if (pMachine->toLocal())
     201        {
     202            CMachine comMachine = pMachine->toLocal()->machine();
     203            addTab(new UIVMActivityMonitorLocal(m_enmEmbedding, this, comMachine), comMachine.GetName());
     204            continue;
     205        }
     206        if (pMachine->toCloud())
     207        {
     208            CCloudMachine comMachine = pMachine->toCloud()->machine();
     209            if (!comMachine.isOk())
     210                continue;
     211            addTab(new UIVMActivityMonitorCloud(m_enmEmbedding, this, comMachine), comMachine.GetName());
     212            continue;
     213        }
    198214    }
    199215}

  • trunk/src/VBox/Frontends/VirtualBox/src/activity/overview/UIVMActivityToolWidget.h

    r98103 r102264  
    8585private:
    8686
    87     void setMachines(const QVector<QUuid> &machineIDs);
     87    void setMachines(const QList<UIVirtualMachineItem*> &machines);
    8888    /** @name Prepare/cleanup cascade.
    8989      * @{ */
    … …  
    9898    void removeTabs(const QVector<QUuid> &machineIdsToRemove);
    9999    /** Add new tabs for each QUuid in @machineIdsToAdd. Does not check for duplicates. */
    100     void addTabs(const QVector<QUuid> &machineIdsToAdd);
     100    void addTabs(const QList<UIVirtualMachineItem*> &machines);
    101101    void setExportActionEnabled(bool fEnabled);
    102102

  • trunk/src/VBox/Frontends/VirtualBox/src/activity/vmactivity/UIVMActivityMonitor.cpp

    r102151 r102264  
    4141#include "QIFileDialog.h"
    4242#include "UICommon.h"
     43#include "UIConverter.h"
    4344#include "UIIconPool.h"
     45#include "UIProgressTask.h"
    4446#include "UITranslator.h"
    4547#include "UIVMActivityMonitor.h"
    … …  
    5153#include "CPerformanceCollector.h"
    5254#include "CPerformanceMetric.h"
     55#include "CStringArray.h"
    5356#include <iprt/string.h>
    5457
    … …  
    6366const int g_iMetricSetupCount = 1;
    6467const int g_iDecimalCount = 2;
     68
     69
     70/*********************************************************************************************************************************
     71*   UIProgressTaskReadCloudMachineMetricList definition.                                                                         *
     72*********************************************************************************************************************************/
     73
     74class UIProgressTaskReadCloudMachineMetricList : public UIProgressTask
     75{
     76    Q_OBJECT;
     77
     78signals:
     79
     80    void sigMetricListReceived(QVector<QString> metricNamesList);
     81
     82public:
     83
     84    UIProgressTaskReadCloudMachineMetricList(QObject *pParent, CCloudMachine comCloudMachine);
     85
     86protected:
     87
     88    virtual CProgress createProgress() RT_OVERRIDE;
     89    virtual void handleProgressFinished(CProgress &comProgress) RT_OVERRIDE;
     90
     91private:
     92
     93    CCloudMachine m_comCloudMachine;
     94    CStringArray m_metricNamesArray;
     95};
     96
     97
     98/*********************************************************************************************************************************
     99*   UIProgressTaskReadCloudMachineMetricList definition.                                                                         *
     100*********************************************************************************************************************************/
     101
     102class UIProgressTaskReadCloudMachineMetricData : public UIProgressTask
     103{
     104    Q_OBJECT;
     105
     106signals:
     107
     108    void sigMetricDataReceived(KMetricType enmMetricType, QVector<QString> data, QVector<QString> timeStamps);
     109
     110public:
     111
     112    UIProgressTaskReadCloudMachineMetricData(QObject *pParent, CCloudMachine comCloudMachine,
     113                                             KMetricType enmMetricType, ULONG uDataPointsCount);
     114
     115protected:
     116
     117    virtual CProgress createProgress() RT_OVERRIDE;
     118    virtual void handleProgressFinished(CProgress &comProgress) RT_OVERRIDE;
     119
     120private:
     121
     122    CCloudMachine m_comCloudMachine;
     123    CStringArray m_metricData;
     124    CStringArray m_timeStamps;
     125    KMetricType m_enmMetricType;
     126    ULONG m_uDataPointsCount;
     127};
    65128
    66129
    … …  
    177240    int m_iRightMarginCharWidth;
    178241};
     242
     243
     244/*********************************************************************************************************************************
     245*   UIProgressTaskReadCloudMachineMetricList implementation.                                                                     *
     246*********************************************************************************************************************************/
     247
     248UIProgressTaskReadCloudMachineMetricList::UIProgressTaskReadCloudMachineMetricList(QObject *pParent, CCloudMachine comCloudMachine)
     249    :UIProgressTask(pParent)
     250    , m_comCloudMachine(comCloudMachine)
     251{
     252}
     253
     254CProgress UIProgressTaskReadCloudMachineMetricList::createProgress()
     255{
     256    if (!m_comCloudMachine.isOk())
     257        return CProgress();
     258    return m_comCloudMachine.ListMetricNames(m_metricNamesArray);
     259}
     260
     261void UIProgressTaskReadCloudMachineMetricList::handleProgressFinished(CProgress &comProgress)
     262{
     263    if (!comProgress.isOk())
     264        return;
     265    emit sigMetricListReceived(m_metricNamesArray.GetValues());
     266}
     267
     268
     269/*********************************************************************************************************************************
     270*   UIProgressTaskReadCloudMachineMetricData implementation.                                                                     *
     271*********************************************************************************************************************************/
     272
     273UIProgressTaskReadCloudMachineMetricData::UIProgressTaskReadCloudMachineMetricData(QObject *pParent,
     274                                                                                   CCloudMachine comCloudMachine,
     275                                                                                   KMetricType enmMetricType,
     276                                                                                   ULONG uDataPointsCount)
     277    :UIProgressTask(pParent)
     278    , m_comCloudMachine(comCloudMachine)
     279    , m_enmMetricType(enmMetricType)
     280    , m_uDataPointsCount(uDataPointsCount)
     281{
     282}
     283
     284CProgress UIProgressTaskReadCloudMachineMetricData::createProgress()
     285{
     286    if (!m_comCloudMachine.isOk())
     287        return CProgress();
     288
     289    CStringArray aUnit;
     290    return m_comCloudMachine.EnumerateMetricData(m_enmMetricType, m_uDataPointsCount, m_metricData, m_timeStamps, aUnit);
     291}
     292
     293
     294void UIProgressTaskReadCloudMachineMetricData::handleProgressFinished(CProgress &comProgress)
     295{
     296    if (!comProgress.isOk())
     297        return;
     298    if (m_metricData.isOk() && m_timeStamps.isOk())
     299        emit sigMetricDataReceived(m_enmMetricType, m_metricData.GetValues(), m_timeStamps.GetValues());
     300}
    179301
    180302/*********************************************************************************************************************************
    … …  
    16241746}
    16251747
    1626 
     1748UIVMActivityMonitorCloud::UIVMActivityMonitorCloud(EmbedTo enmEmbedding, QWidget *pParent, const CCloudMachine &machine)
     1749    :UIVMActivityMonitor(enmEmbedding, pParent)
     1750{
     1751    m_metricTypeNames[KMetricType_CpuUtilization] = m_strCPUMetricName;
     1752    m_metricTypeNames[KMetricType_MemoryUtilization] = m_strRAMMetricName;
     1753    m_metricTypeNames[KMetricType_DiskBytesRead] = m_strDiskMetricName;
     1754    m_metricTypeNames[KMetricType_DiskBytesWritten] = m_strDiskMetricName;
     1755    m_metricTypeNames[KMetricType_NetworksBytesIn] = m_strNetworkMetricName;
     1756    m_metricTypeNames[KMetricType_NetworksBytesOut] = m_strNetworkMetricName;
     1757
     1758    prepareMetrics();
     1759    prepareWidgets();
     1760    retranslateUi();
     1761    prepareActions();
     1762    //connect(&uiCommon(), &UICommon::sigAskToDetachCOM, this, &UIVMActivityMonitorLocal::sltClearCOMData);
     1763    setMachine(machine);
     1764}
     1765
     1766
     1767void UIVMActivityMonitorCloud::setMachine(const CCloudMachine &comMachine)
     1768{
     1769    m_comMachine = comMachine;
     1770    if (!m_comMachine.isOk())
     1771        return;
     1772
     1773    m_ReadListProgressTask = new UIProgressTaskReadCloudMachineMetricList(this, comMachine);
     1774    if (m_ReadListProgressTask)
     1775    {
     1776        connect(m_ReadListProgressTask, &UIProgressTaskReadCloudMachineMetricList::sigMetricListReceived,
     1777                this, &UIVMActivityMonitorCloud::sltMetricNameListingComplete);
     1778        m_ReadListProgressTask->start();
     1779    }
     1780}
     1781
     1782void UIVMActivityMonitorCloud::sltMetricNameListingComplete(QVector<QString> metricNameList)
     1783{
     1784    m_availableMetricTypes.clear();
     1785    foreach (const QString &strName, metricNameList)
     1786        m_availableMetricTypes << gpConverter->fromInternalString<KMetricType>(strName);
     1787
     1788    if (!m_availableMetricTypes.isEmpty())
     1789        start();
     1790
     1791    sender()->deleteLater();
     1792}
     1793
     1794void UIVMActivityMonitorCloud::sltMetricDataReceived(KMetricType enmMetricType, QVector<QString> data, QVector<QString> timeStamps)
     1795{
     1796    if (data.size() != timeStamps.size())
     1797        return;
     1798    for (int i = 0; i < data.size(); ++i)
     1799    {
     1800        if (enmMetricType == KMetricType_CpuUtilization)
     1801        {
     1802            float fValue = data[i].toFloat();
     1803            updateCPUGraphsAndMetric((ULONG)fValue, 0);
     1804        }
     1805    }
     1806
     1807    sender()->deleteLater();
     1808}
     1809
     1810QUuid UIVMActivityMonitorCloud::machineId() const
     1811{
     1812    if (m_comMachine.isOk())
     1813        return m_comMachine.GetId();
     1814    return QUuid();
     1815}
     1816
     1817QString UIVMActivityMonitorCloud::machineName() const
     1818{
     1819    if (m_comMachine.isOk())
     1820        return m_comMachine.GetName();
     1821    return QString();
     1822}
     1823
     1824void UIVMActivityMonitorCloud::retranslateUi()
     1825{
     1826    UIVMActivityMonitor::retranslateUi();
     1827}
     1828
     1829void UIVMActivityMonitorCloud::obtainDataAndUpdate()
     1830{
     1831    foreach (const KMetricType &enmMetricType, m_availableMetricTypes)
     1832    {
     1833        UIMetric metric;
     1834        int iDataSeriesIndex = 0;
     1835        if (!findMetric(enmMetricType, metric, iDataSeriesIndex))
     1836            continue;
     1837        /* Be a paranoid: */
     1838        if (iDataSeriesIndex >= DATA_SERIES_SIZE)
     1839            continue;
     1840        int iDataSize = 1;
     1841        if (metric.dataSize(iDataSeriesIndex) == 0)
     1842            iDataSize = 60;
     1843        UIProgressTaskReadCloudMachineMetricData *pTask = new UIProgressTaskReadCloudMachineMetricData(this, m_comMachine,
     1844                                                                                                       enmMetricType, iDataSize);
     1845        connect(pTask, &UIProgressTaskReadCloudMachineMetricData::sigMetricDataReceived,
     1846                this, &UIVMActivityMonitorCloud::sltMetricDataReceived);
     1847        pTask->start();
     1848    }
     1849}
     1850
     1851QString UIVMActivityMonitorCloud::defaultMachineFolder() const
     1852{
     1853    /** @todo */
     1854    return QString();
     1855}
     1856void UIVMActivityMonitorCloud::reset(){}
     1857void UIVMActivityMonitorCloud::start()
     1858{
     1859    obtainDataAndUpdate();
     1860    /* Every minute: */
     1861    if (m_pTimer)
     1862        m_pTimer->start(1000 * 60);
     1863
     1864}
     1865
     1866void UIVMActivityMonitorCloud::updateCPUGraphsAndMetric(ULONG iLoadPercentage, ULONG /*iOtherPercentage*/)
     1867{
     1868    UIMetric &CPUMetric = m_metrics[m_strCPUMetricName];
     1869    CPUMetric.addData(0, iLoadPercentage);
     1870    CPUMetric.setMaximum(100);
     1871    if (m_infoLabels.contains(m_strCPUMetricName)  && m_infoLabels[m_strCPUMetricName])
     1872    {
     1873        QString strInfo;
     1874
     1875        strInfo = QString("<b>%1</b></b><br/><font color=\"%2\">%3: %4%5</font>")
     1876            .arg(m_strCPUInfoLabelTitle)
     1877            .arg(dataColorString(m_strCPUMetricName, 0))
     1878            .arg(m_strCPUInfoLabelGuest).arg(QString::number(iLoadPercentage)).arg(CPUMetric.unit());
     1879
     1880        m_infoLabels[m_strCPUMetricName]->setText(strInfo);
     1881    }
     1882
     1883    if (m_charts.contains(m_strCPUMetricName))
     1884        m_charts[m_strCPUMetricName]->update();
     1885}
     1886void UIVMActivityMonitorCloud::updateRAMGraphsAndMetric(quint64 /*iTotalRAM*/, quint64 /*iFreeRAM*/){}
     1887void UIVMActivityMonitorCloud::updateNetworkGraphsAndMetric(quint64 /*iReceiveTotal*/, quint64 /*iTransmitTotal*/){}
     1888void UIVMActivityMonitorCloud::updateDiskIOGraphsAndMetric(quint64 /*uDiskIOTotalWritten*/, quint64 /*uDiskIOTotalRead*/){}
     1889
     1890bool UIVMActivityMonitorCloud::findMetric(KMetricType enmMetricType, UIMetric &metric, int &iDataSeriesIndex) const
     1891{
     1892    if (m_metricTypeNames[enmMetricType].isEmpty())
     1893        return false;
     1894
     1895    const QString &strMetricName = m_metricTypeNames[enmMetricType];
     1896
     1897    if (!m_metrics.contains(strMetricName))
     1898        return false;
     1899
     1900    metric = m_metrics[strMetricName];
     1901    iDataSeriesIndex = 0;
     1902    if (enmMetricType == KMetricType_NetworksBytesOut ||
     1903        enmMetricType == KMetricType_DiskBytesRead)
     1904        iDataSeriesIndex = 1;
     1905    return true;
     1906}
     1907
     1908void UIVMActivityMonitorCloud::prepareMetrics()
     1909{
     1910    // UIMetric ramMetric(m_strRAMMetricName, metrics[i].GetUnit(), g_iMaximumQueueSize);
     1911    // ramMetric.setDataSeriesName(0, "Free");
     1912    // ramMetric.setDataSeriesName(1, "Used");
     1913    // ramMetric.setRequiresGuestAdditions(true);
     1914    // m_metrics.insert(m_strRAMMetricName, ramMetric);
     1915
     1916    /* CPU Metric: */
     1917    UIMetric cpuMetric(m_strCPUMetricName, "%", g_iMaximumQueueSize);
     1918    cpuMetric.setDataSeriesName(0, "CPU Utilization");
     1919    m_metrics.insert(m_strCPUMetricName, cpuMetric);
     1920
     1921    // /* Network metric: */
     1922    // UIMetric networkMetric(m_strNetworkMetricName, "B", g_iMaximumQueueSize);
     1923    // networkMetric.setDataSeriesName(0, "Receive Rate");
     1924    // networkMetric.setDataSeriesName(1, "Transmit Rate");
     1925    // networkMetric.setAutoUpdateMaximum(true);
     1926    // m_metrics.insert(m_strNetworkMetricName, networkMetric);
     1927
     1928    // /* Disk IO metric */
     1929    // UIMetric diskIOMetric(m_strDiskIOMetricName, "B", g_iMaximumQueueSize);
     1930    // diskIOMetric.setDataSeriesName(0, "Write Rate");
     1931    // diskIOMetric.setDataSeriesName(1, "Read Rate");
     1932    // diskIOMetric.setAutoUpdateMaximum(true);
     1933    // m_metrics.insert(m_strDiskIOMetricName, diskIOMetric);
     1934
     1935    // /* VM exits metric */
     1936    // UIMetric VMExitsMetric(m_strVMExitMetricName, "times", g_iMaximumQueueSize);
     1937    // VMExitsMetric.setAutoUpdateMaximum(true);
     1938    // m_metrics.insert(m_strVMExitMetricName, VMExitsMetric);
     1939}
     1940void UIVMActivityMonitorCloud::prepareWidgets()
     1941{
     1942    UIVMActivityMonitor::prepareWidgets();
     1943    m_charts[m_strCPUMetricName]->setShowPieChart(false);
     1944}
    16271945#include "UIVMActivityMonitor.moc"

  • trunk/src/VBox/Frontends/VirtualBox/src/activity/vmactivity/UIVMActivityMonitor.h

    r102151 r102264  
    3737#include <QQueue>
    3838#include <QTextStream>
     39#include <QHash>
    3940
    4041/* COM includes: */
    … …  
    4243#include "CGuest.h"
    4344#include "CMachine.h"
     45#include "CCloudMachine.h"
    4446#include "CMachineDebugger.h"
    4547#include "CPerformanceCollector.h"
    … …  
    5860class UISession;
    5961class UIRuntimeInfoWidget;
     62class UIProgressTaskReadCloudMachineMetricList;
    6063
    6164#define DATA_SERIES_SIZE 2
    … …  
    170173    /** @} */
    171174
    172     void prepareWidgets();
     175    virtual void prepareWidgets();
    173176    void prepareActions();
    174177
    … …  
    307310public:
    308311
    309 
     312    UIVMActivityMonitorCloud(EmbedTo enmEmbedding, QWidget *pParent, const CCloudMachine &machine);
     313    virtual QUuid machineId() const RT_OVERRIDE;
     314    virtual QString machineName() const RT_OVERRIDE;
     315
     316private slots:
     317
     318    void sltMetricNameListingComplete(QVector<QString> metricNameList);
     319    void sltMetricDataReceived(KMetricType enmMetricType, QVector<QString> data, QVector<QString> timeStamps);
     320
     321private:
     322    void setMachine(const CCloudMachine &comMachine);
     323    virtual void retranslateUi() RT_OVERRIDE;
     324    virtual void obtainDataAndUpdate() RT_OVERRIDE;
     325
     326    virtual QString defaultMachineFolder() const RT_OVERRIDE;
     327    virtual void reset() RT_OVERRIDE;
     328    virtual void start() RT_OVERRIDE;
     329    virtual void prepareWidgets();
     330    /** @name The following functions update corresponding metric charts and labels with new values
     331      * @{ */
     332        virtual void updateCPUGraphsAndMetric(ULONG iLoadPercentage, ULONG iOtherPercentage) RT_OVERRIDE;
     333        virtual void updateRAMGraphsAndMetric(quint64 iTotalRAM, quint64 iFreeRAM) RT_OVERRIDE;
     334        virtual void updateNetworkGraphsAndMetric(quint64 iReceiveTotal, quint64 iTransmitTotal) RT_OVERRIDE;
     335        virtual void updateDiskIOGraphsAndMetric(quint64 uDiskIOTotalWritten, quint64 uDiskIOTotalRead) RT_OVERRIDE;
     336    /** @} */
     337    bool findMetric(KMetricType enmMetricType, UIMetric &metric, int &iDataSeriesIndex) const;
     338    void prepareMetrics();
     339    CCloudMachine m_comMachine;
     340    UIProgressTaskReadCloudMachineMetricList *m_ReadListProgressTask;
     341
     342    QVector<KMetricType> m_availableMetricTypes;
     343    /** Mapping from API enums to internal metric names. Necessary also since we don't hace a 1-to-1 mapping. */
     344    QHash<KMetricType, QString> m_metricTypeNames;
    310345};
    311346#endif /* !FEQT_INCLUDED_SRC_activity_vmactivity_UIVMActivityMonitor_h */

  • trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackend.h

    r98999 r102264  
    173173template<> SHARED_LIBRARY_STUFF bool canConvert<KGuestSessionStatus>();
    174174template<> SHARED_LIBRARY_STUFF bool canConvert<KProcessStatus>();
    175 
     175template<> SHARED_LIBRARY_STUFF bool canConvert<KMetricType>();
    176176
    177177/* Declare global conversion specializations: */
    … …  
    350350template<> SHARED_LIBRARY_STUFF QString toString(const KProcessStatus &status);
    351351template<> SHARED_LIBRARY_STUFF KProcessStatus fromString<KProcessStatus>(const QString &strStatus);
     352template<> SHARED_LIBRARY_STUFF QString toString(const KMetricType &metricType);
     353template<> SHARED_LIBRARY_STUFF KMetricType fromString<KMetricType>(const QString &strMetricType);
    352354
    353355

  • trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendCOM.cpp

    r101200 r102264  
    6868template<> bool canConvert<KGuestSessionStatus>() { return true; }
    6969template<> bool canConvert<KProcessStatus>() { return true; }
     70template<> bool canConvert<KMetricType>() { return true; }
    7071
    7172/* QIcon <= KCloudMachineState: */
    … …  
    864865    return list.value(strStatus, KProcessStatus_Undefined);
    865866}
     867
     868/* QString <= KMetricType: */
     869template<> QString toInternalString(const KMetricType &metricType)
     870{
     871    QString strResult;
     872    switch (metricType)
     873    {
     874        case KMetricType_Invalid:           strResult = "Invalid"; break;
     875        case KMetricType_CpuUtilization:    strResult = "CpuUtilization"; break;
     876        case KMetricType_MemoryUtilization: strResult = "MemoryUtilization"; break;
     877        case KMetricType_DiskBytesRead:     strResult = "DiskBytesRead"; break;
     878        case KMetricType_DiskBytesWritten:  strResult = "DiskBytesWritten"; break;
     879        case KMetricType_NetworksBytesIn:   strResult = "NetworksBytesIn"; break;
     880        case KMetricType_NetworksBytesOut:  strResult = "NetworksBytesOut"; break;
     881        default: AssertMsgFailed(("No text for metric type=%d", metricType)); break;
     882    }
     883    return strResult;
     884}
     885
     886/* KMetricType <= QString: */
     887template<> KMetricType fromInternalString<KMetricType>(const QString &strMetricType)
     888{
     889    if (strMetricType.compare("Invalid", Qt::CaseInsensitive) == 0)
     890        return KMetricType_Invalid;
     891    if (strMetricType.compare("CpuUtilization", Qt::CaseInsensitive) == 0)
     892        return KMetricType_CpuUtilization;
     893    if (strMetricType.compare("MemoryUtilization", Qt::CaseInsensitive) == 0)
     894        return KMetricType_MemoryUtilization;
     895    if (strMetricType.compare("DiskBytesRead", Qt::CaseInsensitive) == 0)
     896        return KMetricType_DiskBytesRead;
     897    if (strMetricType.compare("DiskBytesWritten", Qt::CaseInsensitive) == 0)
     898        return KMetricType_DiskBytesWritten;
     899    if (strMetricType.compare("NetworksBytesIn", Qt::CaseInsensitive) == 0)
     900        return KMetricType_NetworksBytesIn;
     901    if (strMetricType.compare("NetworksBytesOut", Qt::CaseInsensitive) == 0)
     902        return KMetricType_NetworksBytesOut;
     903    AssertMsgFailedReturn(("No value for '%s'", strMetricType.toUtf8().constData()), KMetricType_Invalid);
     904}
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