Changeset 48061 in vbox

Timestamp:

Aug 26, 2013 1:26:46 PM (11 years ago)

Author:

vboxsync

Message:

FE/Qt: 6909: Medium-enumeration cleanup (part 3).

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• globals/VBoxGlobal.cpp (modified) (1 diff)
• medium/UIMedium.cpp (modified) (18 diffs)
• medium/UIMedium.h (modified) (8 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.cpp

@@ -1740 +1740 @@
         return;
 
-    /* composes a list of all currently known media & their children */
+    /* Compose a list of all currently known mediums & their children: */
     m_mediums.clear();
-    addNullMediumToList (m_mediums, m_mediums.end());
-    addHardDisksToList (mVBox.GetHardDisks(), m_mediums, m_mediums.end());
-    addMediumsToList (mHost.GetDVDDrives(), m_mediums, m_mediums.end(), UIMediumType_DVD);
-    addMediumsToList (mVBox.GetDVDImages(), m_mediums, m_mediums.end(), UIMediumType_DVD);
-    addMediumsToList (mHost.GetFloppyDrives(), m_mediums, m_mediums.end(), UIMediumType_Floppy);
-    addMediumsToList (mVBox.GetFloppyImages(), m_mediums, m_mediums.end(), UIMediumType_Floppy);
-
-    /* enumeration thread class */
+    addNullMediumToList(m_mediums, m_mediums.end());
+    addHardDisksToList(mVBox.GetHardDisks(), m_mediums, m_mediums.end());
+    addMediumsToList(mHost.GetDVDDrives(), m_mediums, m_mediums.end(), UIMediumType_DVD);
+    addMediumsToList(mVBox.GetDVDImages(), m_mediums, m_mediums.end(), UIMediumType_DVD);
+    addMediumsToList(mHost.GetFloppyDrives(), m_mediums, m_mediums.end(), UIMediumType_Floppy);
+    addMediumsToList(mVBox.GetFloppyImages(), m_mediums, m_mediums.end(), UIMediumType_Floppy);
+
+    /* Enumeration thread class: */
     class MediaEnumThread : public QThread
     {
     public:
 
-        MediaEnumThread (VBoxMediaList &aList)
-            : mVector (aList.size())
-            , mSavedIt (aList.begin())
+        MediaEnumThread(VBoxMediaList &mediums)
+            : m_mediums(mediums.size())
+            , m_iterator(mediums.begin())
         {
             int i = 0;
-            for (VBoxMediaList::const_iterator it = aList.begin();
-                 it != aList.end(); ++ it)
-                mVector [i ++] = *it;
-        }
-
-        virtual void run()
-        {
-            LogFlow (("MediaEnumThread started.\n"));
+            for (VBoxMediaList::const_iterator it = mediums.begin(); it != mediums.end(); ++it)
+                m_mediums[i++] = *it;
+        }
+
+        void run()
+        {
+            LogFlow(("MediaEnumThread started.\n"));
             COMBase::InitializeCOM(false);
 
-            CVirtualBox mVBox = vboxGlobal().virtualBox();
-            QObject *self = &vboxGlobal();
-
-            /* Enumerate the list */
-            for (int i = 0; i < mVector.size() && !m_sfCleanupInProgress; ++ i)
+            QObject *pSelf = &vboxGlobal();
+
+            /* Enumerate medium list: */
+            for (int i = 0; i < m_mediums.size() && !m_sfCleanupInProgress; ++i)
             {
-                mVector [i].blockAndQueryState();
-                QApplication::
-                    postEvent (self,
-                               new VBoxMediaEnumEvent (mVector [i], mSavedIt));
-                ++mSavedIt;
+                m_mediums[i].blockAndQueryState();
+                QApplication::postEvent(pSelf, new VBoxMediaEnumEvent(m_mediums[i], m_iterator));
+                ++m_iterator;
             }
 
-            /* Post the end-of-enumeration event */
+            /* Post the end-of-enumeration event: */
             if (!m_sfCleanupInProgress)
-                QApplication::postEvent (self, new VBoxMediaEnumEvent (mSavedIt));
+                QApplication::postEvent(pSelf, new VBoxMediaEnumEvent(m_iterator));
 
             COMBase::CleanupCOM();
-            LogFlow (("MediaEnumThread finished.\n"));
+            LogFlow(("MediaEnumThread finished.\n"));
         }
 
     private:
 
-        QVector <UIMedium> mVector;
-        VBoxMediaList::iterator mSavedIt;
+        QVector<UIMedium> m_mediums;
+        VBoxMediaList::iterator m_iterator;
     };
 

trunk/src/VBox/Frontends/VirtualBox/src/medium/UIMedium.cpp

@@ -25 +25 @@
 #include <QDir>
 
-/* GUI includes */
+/* GUI includes: */
 #include "UIMedium.h"
 #include "VBoxGlobal.h"
@@ -37 +37 @@
 #endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
 
-QString UIMedium::mTable = QString ("<table>%1</table>");
-QString UIMedium::mRow = QString ("<tr><td>%1</td></tr>");
-
-UIMedium& UIMedium::operator= (const UIMedium &aOther)
-{
-    m_fHide = aOther.m_fHide;
-    m_fAttachedToHiddenMachinesOnly = aOther.m_fAttachedToHiddenMachinesOnly;
-
-    mMedium = aOther.medium();
-    mType = aOther.type();
-    mState = aOther.state();
-    mLastAccessError = aOther.lastAccessError();
-    mResult = aOther.result();
-
-    mId = aOther.id();
-    mName = aOther.name();
-    mLocation = aOther.location();
-
-    mSize = aOther.size();
-    mLogicalSize = aOther.logicalSize();
-
-    mHardDiskFormat = aOther.hardDiskFormat();
-    mHardDiskType = aOther.hardDiskType();
-
-    mStorageDetails = aOther.storageDetails();
-
-    mUsage = aOther.usage();
-    mToolTip = aOther.tip();
-
-    mIsReadOnly = aOther.isReadOnly();
-    mIsUsedInSnapshots = aOther.isUsedInSnapshots();
-    mIsHostDrive = aOther.isHostDrive();
-
-    mCurStateMachineIds = aOther.curStateMachineIds();
-
-    mParent = aOther.parent();
-
-    mNoDiffs = aOther.cache();
+QString UIMedium::m_sstrTable = QString("<table>%1</table>");
+QString UIMedium::m_sstrRow = QString("<tr><td>%1</td></tr>");
+
+UIMedium& UIMedium::operator=(const UIMedium &other)
+{
+    m_fHidden = other.m_fHidden;
+    m_fAttachedToHiddenMachinesOnly = other.m_fAttachedToHiddenMachinesOnly;
+
+    m_medium = other.medium();
+    m_type = other.type();
+    m_state = other.state();
+    m_strLastAccessError = other.lastAccessError();
+    m_result = other.result();
+
+    m_strId = other.id();
+    m_strName = other.name();
+    m_strLocation = other.location();
+
+    m_strSize = other.size();
+    m_strLogicalSize = other.logicalSize();
+
+    m_strHardDiskFormat = other.hardDiskFormat();
+    m_strHardDiskType = other.hardDiskType();
+
+    m_strStorageDetails = other.storageDetails();
+
+    m_strUsage = other.usage();
+    m_strToolTip = other.tip();
+
+    m_fReadOnly = other.isReadOnly();
+    m_fUsedInSnapshots = other.isUsedInSnapshots();
+    m_fHostDrive = other.isHostDrive();
+
+    m_curStateMachineIds = other.curStateMachineIds();
+
+    m_pParent = other.parent();
+
+    m_noDiffs = other.cache();
 
     return *this;
@@ -95 +95 @@
 void UIMedium::blockAndQueryState()
 {
-    if (mMedium.isNull()) return;
-
-    mState = mMedium.RefreshState();
-
-    /* Save the result to distinguish between inaccessible and e.g. uninitialized objects */
-    mResult = COMResult (mMedium);
-
-    if (!mResult.isOk())
-    {
-        mState = KMediumState_Inaccessible;
-        mLastAccessError = QString::null;
+    if (m_medium.isNull())
+        return;
+
+    m_state = m_medium.RefreshState();
+
+    /* Save the result to distinguish between
+     * inaccessible and e.g. uninitialized objects: */
+    m_result = COMResult(m_medium);
+    if (!m_result.isOk())
+    {
+        m_state = KMediumState_Inaccessible;
+        m_strLastAccessError = QString();
     }
     else
-        mLastAccessError = mMedium.GetLastAccessError();
+        m_strLastAccessError = m_medium.GetLastAccessError();
 
     refresh();
@@ -125 +126 @@
 {
     /* We assume these flags are 'false' by default: */
-    m_fHide = false;
+    m_fHidden = false;
     m_fAttachedToHiddenMachinesOnly = false;
 
     /* Detect basic parameters */
-    mId = mMedium.isNull() ? QUuid().toString().remove ('{').remove ('}') : mMedium.GetId();
-
-    mIsHostDrive = mMedium.isNull() ? false : mMedium.GetHostDrive();
-
-    if (mMedium.isNull())
-        mName = VBoxGlobal::tr ("Empty", "medium");
-    else if (!mIsHostDrive)
-        mName = mMedium.GetName();
-    else if (mMedium.GetDescription().isEmpty())
-        mName = VBoxGlobal::tr ("Host Drive '%1'", "medium").arg (QDir::toNativeSeparators (mMedium.GetLocation()));
+    m_strId = m_medium.isNull() ? QUuid().toString().remove ('{').remove ('}') : m_medium.GetId();
+
+    m_fHostDrive = m_medium.isNull() ? false : m_medium.GetHostDrive();
+
+    if (m_medium.isNull())
+        m_strName = VBoxGlobal::tr("Empty", "medium");
+    else if (!m_fHostDrive)
+        m_strName = m_medium.GetName();
+    else if (m_medium.GetDescription().isEmpty())
+        m_strName = VBoxGlobal::tr("Host Drive '%1'", "medium").arg(QDir::toNativeSeparators(m_medium.GetLocation()));
     else
-        mName = VBoxGlobal::tr ("Host Drive %1 (%2)", "medium").arg (mMedium.GetDescription(), mMedium.GetName());
-
-    mLocation = mMedium.isNull() || mIsHostDrive ? QString ("--") :
-                QDir::toNativeSeparators (mMedium.GetLocation());
+        m_strName = VBoxGlobal::tr("Host Drive %1 (%2)", "medium").arg(m_medium.GetDescription(), m_medium.GetName());
+
+    m_strLocation = m_medium.isNull() || m_fHostDrive ? QString("--") :
+                    QDir::toNativeSeparators(m_medium.GetLocation());
 
     QString tmp;
-    if (!mMedium.isNull())
-        tmp = mMedium.GetProperty("Special/GUI/Hints");
+    if (!m_medium.isNull())
+        tmp = m_medium.GetProperty("Special/GUI/Hints");
     if (!tmp.isEmpty())
     {
         QStringList tmpList(tmp.split(','));
         if (tmpList.contains("Hide", Qt::CaseInsensitive))
-            m_fHide = true;
-    }
-
-    if (mType == UIMediumType_HardDisk)
-    {
-        mHardDiskFormat = mMedium.GetFormat();
-        mHardDiskType = vboxGlobal().mediumTypeString (mMedium);
-
-        QVector<KMediumVariant> mediumVariants_QVector = mMedium.GetVariant();
-        qlonglong mediumVariants_qlonglong = 0;
-        for (int i = 0; i < mediumVariants_QVector.size(); i++)
-            mediumVariants_qlonglong |= mediumVariants_QVector[i];
-
-        mStorageDetails = gpConverter->toString((KMediumVariant)mediumVariants_qlonglong);
-        mIsReadOnly = mMedium.GetReadOnly();
-
-        /* Adjust the parent if its possible */
-        CMedium parentMedium = mMedium.GetParent();
-        Assert (!parentMedium.isNull() || mParent == NULL);
-
-        if (!parentMedium.isNull() && (mParent == NULL || mParent->mMedium != parentMedium))
-        {
-            /* Search for the parent (might be there) */
+            m_fHidden = true;
+    }
+
+    if (m_type == UIMediumType_HardDisk)
+    {
+        m_strHardDiskFormat = m_medium.GetFormat();
+        m_strHardDiskType = vboxGlobal().mediumTypeString(m_medium);
+
+        QVector<KMediumVariant> mediumVariants = m_medium.GetVariant();
+        qlonglong mediumVariant = 0;
+        for (int i = 0; i < mediumVariants.size(); ++i)
+            mediumVariant |= mediumVariants[i];
+
+        m_strStorageDetails = gpConverter->toString((KMediumVariant)mediumVariant);
+        m_fReadOnly = m_medium.GetReadOnly();
+
+        /* Adjust the parent if its possible: */
+        CMedium parentMedium = m_medium.GetParent();
+        Assert(!parentMedium.isNull() || m_pParent == NULL);
+
+        if (!parentMedium.isNull() && (m_pParent == NULL || m_pParent->m_medium != parentMedium))
+        {
+            /* Search for the parent (might be there): */
             const VBoxMediaList &list = vboxGlobal().currentMediaList();
-            for (VBoxMediaList::const_iterator it = list.begin(); it != list.end(); ++ it)
+            for (VBoxMediaList::const_iterator it = list.begin(); it != list.end(); ++it)
             {
-                if ((*it).mType != UIMediumType_HardDisk)
+                if ((*it).m_type != UIMediumType_HardDisk)
                     break;
 
-                if ((*it).mMedium == parentMedium)
+                if ((*it).m_medium == parentMedium)
                 {
-                    mParent = unconst (&*it);
+                    m_pParent = unconst(&*it);
                     break;
                 }
@@ -191 +192 @@
     else
     {
-        mHardDiskFormat = QString::null;
-        mHardDiskType = QString::null;
-        mIsReadOnly = false;
+        m_strHardDiskFormat = QString();
+        m_strHardDiskType = QString();
+        m_fReadOnly = false;
     }
 
     /* Detect sizes */
-    if (mState != KMediumState_Inaccessible && mState != KMediumState_NotCreated && !mIsHostDrive)
-    {
-        mSize = vboxGlobal().formatSize (mMedium.GetSize());
-        if (mType == UIMediumType_HardDisk)
-            mLogicalSize = vboxGlobal().formatSize(mMedium.GetLogicalSize());
+    if (m_state != KMediumState_Inaccessible && m_state != KMediumState_NotCreated && !m_fHostDrive)
+    {
+        m_strSize = vboxGlobal().formatSize(m_medium.GetSize());
+        if (m_type == UIMediumType_HardDisk)
+            m_strLogicalSize = vboxGlobal().formatSize(m_medium.GetLogicalSize());
         else
-            mLogicalSize = mSize;
+            m_strLogicalSize = m_strSize;
     }
     else
     {
-        mSize = mLogicalSize = QString ("--");
+        m_strSize = m_strLogicalSize = QString("--");
     }
 
     /* Detect usage */
-    mUsage = QString::null;
-    if (!mMedium.isNull())
-    {
-        mCurStateMachineIds.clear();
-        QVector <QString> machineIds = mMedium.GetMachineIds();
+    m_strUsage = QString();
+    if (!m_medium.isNull())
+    {
+        m_curStateMachineIds.clear();
+        QVector <QString> machineIds = m_medium.GetMachineIds();
         if (machineIds.size() > 0)
         {
@@ -221 +222 @@
             m_fAttachedToHiddenMachinesOnly = true;
 
-            QString sUsage;
+            QString strUsage;
 
             CVirtualBox vbox = vboxGlobal().virtualBox();
 
-            for (QVector <QString>::ConstIterator it = machineIds.begin(); it != machineIds.end(); ++ it)
+            for (QVector <QString>::ConstIterator it = machineIds.begin(); it != machineIds.end(); ++it)
             {
                 CMachine machine = vbox.FindMachine(*it);
@@ -245 +246 @@
                     m_fAttachedToHiddenMachinesOnly = false;
 
-                QString sName = machine.GetName();
-                QString sSnapshots;
-
-                QVector <QString> snapIds = mMedium.GetSnapshotIds (*it);
-                for (QVector <QString>::ConstIterator jt = snapIds.begin(); jt != snapIds.end(); ++ jt)
+                QString strName = machine.GetName();
+                QString strSnapshots;
+
+                QVector <QString> snapIds = m_medium.GetSnapshotIds(*it);
+                for (QVector <QString>::ConstIterator jt = snapIds.begin(); jt != snapIds.end(); ++jt)
                 {
                     if (*jt == *it)
@@ -256 +257 @@
                          * state, we don't distinguish this for now by always
                          * giving the VM name in front of snapshot names. */
-                        mCurStateMachineIds.push_back (*jt);
+                        m_curStateMachineIds.push_back(*jt);
                         continue;
                     }
 
                     CSnapshot snapshot = machine.FindSnapshot(*jt);
-                    if (!snapshot.isNull())           // can be NULL while takeSnaphot is in progress
+                    if (!snapshot.isNull()) // can be NULL while takeSnaphot is in progress
                     {
-                        if (!sSnapshots.isNull())
-                            sSnapshots += ", ";
-                        sSnapshots += snapshot.GetName();
+                        if (!strSnapshots.isNull())
+                            strSnapshots += ", ";
+                        strSnapshots += snapshot.GetName();
                     }
                 }
 
-                if (!sUsage.isNull())
-                    sUsage += ", ";
-
-                sUsage += sName;
-
-                if (!sSnapshots.isNull())
+                if (!strUsage.isNull())
+                    strUsage += ", ";
+
+                strUsage += strName;
+
+                if (!strSnapshots.isNull())
                 {
-                    sUsage += QString (" (%2)").arg (sSnapshots);
-                    mIsUsedInSnapshots = true;
+                    strUsage += QString(" (%2)").arg(strSnapshots);
+                    m_fUsedInSnapshots = true;
                 }
                 else
-                    mIsUsedInSnapshots = false;
+                    m_fUsedInSnapshots = false;
             }
 
-            if (!sUsage.isEmpty())
-                mUsage = sUsage;
+            if (!strUsage.isEmpty())
+                m_strUsage = strUsage;
         }
     }
 
     /* Compose the tooltip */
-    if (!mMedium.isNull())
-    {
-        mToolTip = mRow.arg (QString ("<p style=white-space:pre><b>%1</b></p>").arg (mIsHostDrive ? mName : mLocation));
-
-        if (mType == UIMediumType_HardDisk)
-        {
-            mToolTip += mRow.arg (VBoxGlobal::tr ("<p style=white-space:pre>Type (Format):  %1 (%2)</p>", "medium")
-                                                  .arg (mHardDiskType).arg (mHardDiskFormat));
-        }
-
-        mToolTip += mRow.arg (VBoxGlobal::tr ("<p>Attached to:  %1</p>", "image")
-                                              .arg (mUsage.isNull() ? VBoxGlobal::tr ("<i>Not Attached</i>", "image") : mUsage));
-
-        switch (mState)
+    if (!m_medium.isNull())
+    {
+        m_strToolTip = m_sstrRow.arg(QString("<p style=white-space:pre><b>%1</b></p>").arg(m_fHostDrive ? m_strName : m_strLocation));
+
+        if (m_type == UIMediumType_HardDisk)
+        {
+            m_strToolTip += m_sstrRow.arg(VBoxGlobal::tr("<p style=white-space:pre>Type (Format):  %1 (%2)</p>", "medium")
+                                                         .arg(m_strHardDiskType).arg(m_strHardDiskFormat));
+        }
+
+        m_strToolTip += m_sstrRow.arg(VBoxGlobal::tr("<p>Attached to:  %1</p>", "image")
+                                                     .arg(m_strUsage.isNull() ? VBoxGlobal::tr("<i>Not Attached</i>", "image") : m_strUsage));
+
+        switch (m_state)
         {
             case KMediumState_NotCreated:
             {
-                mToolTip += mRow.arg (VBoxGlobal::tr ("<i>Checking accessibility...</i>", "medium"));
+                m_strToolTip += m_sstrRow.arg(VBoxGlobal::tr("<i>Checking accessibility...</i>", "medium"));
                 break;
             }
             case KMediumState_Inaccessible:
             {
-                if (mResult.isOk())
+                if (m_result.isOk())
                 {
                     /* Not Accessible */
-                    mToolTip += mRow.arg ("<hr>") + mRow.arg (VBoxGlobal::highlight (mLastAccessError, true /* aToolTip */));
+                    m_strToolTip += m_sstrRow.arg("<hr>") + m_sstrRow.arg(VBoxGlobal::highlight(m_strLastAccessError, true /* aToolTip */));
                 }
                 else
                 {
-                    /* Accessibility check (eg GetState()) itself failed */
-                    mToolTip += mRow.arg ("<hr>") + mRow.arg (VBoxGlobal::tr ("Failed to check media accessibility.", "medium")) +
-                                mRow.arg (UIMessageCenter::formatErrorInfo (mResult) + ".");
+                    /* Accessibility check (eg GetState()) itself failed: */
+                    m_strToolTip += m_sstrRow.arg("<hr>") + m_sstrRow.arg(VBoxGlobal::tr("Failed to check media accessibility.", "medium")) +
+                                    m_sstrRow.arg(UIMessageCenter::formatErrorInfo(m_result) + ".");
                 }
                 break;
@@ -329 +330 @@
     }
 
-    /* Reset mNoDiffs */
-    mNoDiffs.isSet = false;
+    /* Reset m_noDiffs */
+    m_noDiffs.isSet = false;
 }
 
@@ -339 +340 @@
 UIMedium &UIMedium::root() const
 {
-    UIMedium *pRoot = unconst (this);
-    while (pRoot->mParent != NULL)
-        pRoot = pRoot->mParent;
+    UIMedium *pRoot = unconst(this);
+    while (pRoot->m_pParent != NULL)
+        pRoot = pRoot->m_pParent;
 
     return *pRoot;
@@ -354 +355 @@
  * medium is actually a differencing hard disk.
  *
- * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
- * @param aCheckRO  @c true to perform the #readOnly() check and add a notice
+ * @param fNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+ * @param fCheckRO  @c true to perform the #readOnly() check and add a notice
  *                  accordingly.
  */
-QString UIMedium::toolTip (bool aNoDiffs /* = false */, bool aCheckRO /* = false */, bool aNullAllowed /* = false */) const
-{
-    QString sTip;
-
-    if (mMedium.isNull())
-    {
-        sTip = aNullAllowed ? mRow.arg (VBoxGlobal::tr ("<b>No medium selected</b>", "medium")) +
-                              mRow.arg (VBoxGlobal::tr ("You can also change this while the machine is running.")) :
-                              mRow.arg (VBoxGlobal::tr ("<b>No media available</b>", "medium")) +
-                              mRow.arg (VBoxGlobal::tr ("You can create media images using the virtual media manager."));
+QString UIMedium::toolTip (bool fNoDiffs /* = false */, bool fCheckRO /* = false */, bool fNullAllowed /* = false */) const
+{
+    QString strTip;
+
+    if (m_medium.isNull())
+    {
+        strTip = fNullAllowed ? m_sstrRow.arg(VBoxGlobal::tr("<b>No medium selected</b>", "medium")) +
+                                m_sstrRow.arg(VBoxGlobal::tr("You can also change this while the machine is running.")) :
+                                m_sstrRow.arg(VBoxGlobal::tr("<b>No media available</b>", "medium")) +
+                                m_sstrRow.arg(VBoxGlobal::tr("You can create media images using the virtual media manager."));
     }
     else
     {
-        unconst (this)->checkNoDiffs (aNoDiffs);
-
-        sTip = aNoDiffs ? mNoDiffs.toolTip : mToolTip;
-
-        if (aCheckRO && mIsReadOnly)
-            sTip += mRow.arg ("<hr>") +
-                    mRow.arg (VBoxGlobal::tr ("Attaching this hard disk will be performed indirectly using "
-                                              "a newly created differencing hard disk.", "medium"));
-    }
-
-    return mTable.arg (sTip);
+        unconst(this)->checkNoDiffs(fNoDiffs);
+
+        strTip = fNoDiffs ? m_noDiffs.toolTip : m_strToolTip;
+
+        if (fCheckRO && m_fReadOnly)
+            strTip += m_sstrRow.arg("<hr>") +
+                      m_sstrRow.arg(VBoxGlobal::tr("Attaching this hard disk will be performed indirectly using "
+                                                   "a newly created differencing hard disk.", "medium"));
+    }
+
+    return m_sstrTable.arg(strTip);
 }
 
@@ -394 +395 @@
  * media icon.
  *
- * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
- * @param aCheckRO  @c true to perform the #readOnly() check and change the icon
+ * @param fNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+ * @param fCheckRO  @c true to perform the #readOnly() check and change the icon
  *                  accordingly.
  */
-QPixmap UIMedium::icon (bool aNoDiffs /* = false */, bool aCheckRO /* = false */) const
+QPixmap UIMedium::icon(bool fNoDiffs /* = false */, bool fCheckRO /* = false */) const
 {
     QPixmap pixmap;
 
-    if (state (aNoDiffs) == KMediumState_Inaccessible)
-        pixmap = result (aNoDiffs).isOk() ? vboxGlobal().warningIcon() : vboxGlobal().errorIcon();
-
-    if (aCheckRO && mIsReadOnly)
-        pixmap = VBoxGlobal::joinPixmaps (pixmap, QPixmap (":/hd_new_16px.png"));
+    if (state(fNoDiffs) == KMediumState_Inaccessible)
+        pixmap = result(fNoDiffs).isOk() ? vboxGlobal().warningIcon() : vboxGlobal().errorIcon();
+
+    if (fCheckRO && m_fReadOnly)
+        pixmap = VBoxGlobal::joinPixmaps(pixmap, QPixmap(":/hd_new_16px.png"));
 
     return pixmap;
@@ -415 +416 @@
  *
  * For hard disks, the details include the location, type and the logical size
- * of the hard disk. Note that if @a aNoDiffs is @c true, these properties are
+ * of the hard disk. Note that if @a fNoDiffs is @c true, these properties are
  * queried on the root hard disk of the given hard disk because the primary
  * purpose of the returned string is to be human readable (so that seeing a
@@ -421 +422 @@
  *
  * For other media types, the location and the actual size are returned.
- * Arguments @a aPredictDiff and @a aNoRoot are ignored in this case.
- *
- * @param aNoDiffs      @c true to enable user-friendly "don't show diffs" mode.
- * @param aPredictDiff  @c true to mark the hard disk as differencing if
+ * Arguments @a fPredictDiff and @a aNoRoot are ignored in this case.
+ *
+ * @param fNoDiffs      @c true to enable user-friendly "don't show diffs" mode.
+ * @param fPredictDiff  @c true to mark the hard disk as differencing if
  *                      attaching it would create a differencing hard disk (not
  *                      used when @a aNoRoot is true).
- * @param aUseHTML      @c true to allow for emphasizing using bold and italics.
- *
- * @note Use #detailsHTML() instead of passing @c true for @a aUseHTML.
+ * @param fUseHTML      @c true to allow for emphasizing using bold and italics.
+ *
+ * @note Use #detailsHTML() instead of passing @c true for @a fUseHTML.
  *
  * @note The media object may become uninitialized by a third party while this
@@ -435 +436 @@
  *       an empty string.
  */
-QString UIMedium::details (bool aNoDiffs /* = false */,
-                             bool aPredictDiff /* = false */,
-                             bool aUseHTML /* = false */) const
-{
-    // @todo the below check is rough; if mMedium becomes uninitialized, any
+QString UIMedium::details(bool fNoDiffs /* = false */,
+                          bool fPredictDiff /* = false */,
+                          bool fUseHTML /* = false */) const
+{
+    // @todo the below check is rough; if m_medium becomes uninitialized, any
     // of getters called afterwards will also fail. The same relates to the
     // root hard disk object (that will be the hard disk itself in case of
@@ -454 +455 @@
     // @bugref{2149}.
 
-    if (mMedium.isNull() || mIsHostDrive)
-        return mName;
-
-    if (!mMedium.isOk())
-        return QString::null;
-
-    QString sDetails, sStr;
-
-    UIMedium *pRoot = unconst (this);
-    KMediumState eState = mState;
-
-    if (mType == UIMediumType_HardDisk)
-    {
-        if (aNoDiffs)
+    if (m_medium.isNull() || m_fHostDrive)
+        return m_strName;
+
+    if (!m_medium.isOk())
+        return QString();
+
+    QString strDetails, strText;
+
+    UIMedium *pRoot = unconst(this);
+    KMediumState eState = m_state;
+
+    if (m_type == UIMediumType_HardDisk)
+    {
+        if (fNoDiffs)
         {
             pRoot = &this->root();
 
-            bool isDiff = (!aPredictDiff && mParent != NULL) || (aPredictDiff && mIsReadOnly);
-
-            sDetails = isDiff && aUseHTML ?
-                QString ("<i>%1</i>, ").arg (pRoot->mHardDiskType) :
-                QString ("%1, ").arg (pRoot->mHardDiskType);
-
-            eState = this->state (true /* aNoDiffs */);
-
-            if (pRoot->mState == KMediumState_NotCreated)
+            bool isDiff = (!fPredictDiff && m_pParent != NULL) || (fPredictDiff && m_fReadOnly);
+
+            strDetails = isDiff && fUseHTML ?
+                QString("<i>%1</i>, ").arg(pRoot->m_strHardDiskType) :
+                QString("%1, ").arg(pRoot->m_strHardDiskType);
+
+            eState = this->state(true /* fNoDiffs */);
+
+            if (pRoot->m_state == KMediumState_NotCreated)
                 eState = KMediumState_NotCreated;
         }
         else
         {
-            sDetails = QString ("%1, ").arg (pRoot->mHardDiskType);
+            strDetails = QString("%1, ").arg(pRoot->m_strHardDiskType);
         }
     }
@@ -493 +494 @@
     {
         case KMediumState_NotCreated:
-            sStr = VBoxGlobal::tr ("Checking...", "medium");
-            sDetails += aUseHTML ? QString ("<i>%1</i>").arg (sStr) : sStr;
+            strText = VBoxGlobal::tr("Checking...", "medium");
+            strDetails += fUseHTML ? QString("<i>%1</i>").arg(strText) : strText;
             break;
         case KMediumState_Inaccessible:
-            sStr = VBoxGlobal::tr ("Inaccessible", "medium");
-            sDetails += aUseHTML ? QString ("<b>%1</b>").arg (sStr) : sStr;
+            strText = VBoxGlobal::tr("Inaccessible", "medium");
+            strDetails += fUseHTML ? QString("<b>%1</b>").arg(strText) : strText;
             break;
         default:
-            sDetails += mType == UIMediumType_HardDisk ? pRoot->mLogicalSize : pRoot->mSize;
+            strDetails += m_type == UIMediumType_HardDisk ? pRoot->m_strLogicalSize : pRoot->m_strSize;
             break;
     }
 
-    sDetails = aUseHTML ?
-        QString ("%1 (<nobr>%2</nobr>)").arg (VBoxGlobal::locationForHTML (pRoot->mName), sDetails) :
-        QString ("%1 (%2)").arg (VBoxGlobal::locationForHTML (pRoot->mName), sDetails);
-
-    return sDetails;
-}
-
-/**
- * Checks if mNoDiffs is filled in and does it if not.
- *
- * @param aNoDiffs  @if false, this method immediately returns.
- */
-void UIMedium::checkNoDiffs (bool aNoDiffs)
-{
-    if (!aNoDiffs || mNoDiffs.isSet)
+    strDetails = fUseHTML ?
+        QString("%1 (<nobr>%2</nobr>)").arg(VBoxGlobal::locationForHTML(pRoot->m_strName), strDetails) :
+        QString("%1 (%2)").arg(VBoxGlobal::locationForHTML(pRoot->m_strName), strDetails);
+
+    return strDetails;
+}
+
+/**
+ * Checks if m_noDiffs is filled in and does it if not.
+ *
+ * @param fNoDiffs  @if false, this method immediately returns.
+ */
+void UIMedium::checkNoDiffs(bool fNoDiffs)
+{
+    if (!fNoDiffs || m_noDiffs.isSet)
         return;
 
-    mNoDiffs.toolTip = QString::null;
-
-    mNoDiffs.state = mState;
-    for (UIMedium *cur = mParent; cur != NULL; cur = cur->mParent)
-    {
-        if (cur->mState == KMediumState_Inaccessible)
-        {
-            mNoDiffs.state = cur->mState;
-
-            if (mNoDiffs.toolTip.isNull())
-                mNoDiffs.toolTip = mRow.arg (VBoxGlobal::tr ("Some of the media in this hard disk chain "
-                                                             "are inaccessible. Please use the Virtual Media "
-                                                             "Manager in <b>Show Differencing Hard Disks</b> "
-                                                             "mode to inspect these media.", "medium"));
-
-            if (!cur->mResult.isOk())
+    m_noDiffs.toolTip = QString();
+
+    m_noDiffs.state = m_state;
+    for (UIMedium *cur = m_pParent; cur != NULL; cur = cur->m_pParent)
+    {
+        if (cur->m_state == KMediumState_Inaccessible)
+        {
+            m_noDiffs.state = cur->m_state;
+
+            if (m_noDiffs.toolTip.isNull())
+                m_noDiffs.toolTip = m_sstrRow.arg(VBoxGlobal::tr("Some of the media in this hard disk chain "
+                                                                 "are inaccessible. Please use the Virtual Media "
+                                                                 "Manager in <b>Show Differencing Hard Disks</b> "
+                                                                 "mode to inspect these media.", "medium"));
+
+            if (!cur->m_result.isOk())
             {
-                mNoDiffs.result = cur->mResult;
+                m_noDiffs.result = cur->m_result;
                 break;
             }
@@ -545 +546 @@
     }
 
-    if (mParent != NULL && !mIsReadOnly)
-    {
-        mNoDiffs.toolTip = root().tip() +
-                           mRow.arg ("<hr>") +
-                           mRow.arg (VBoxGlobal::tr ("This base hard disk is indirectly attached using "
-                                                     "the following differencing hard disk:", "medium")) +
-                           mToolTip + mNoDiffs.toolTip;
-    }
-
-    if (mNoDiffs.toolTip.isNull())
-        mNoDiffs.toolTip = mToolTip;
-
-    mNoDiffs.isSet = true;
-}
-
+    if (m_pParent != NULL && !m_fReadOnly)
+    {
+        m_noDiffs.toolTip = root().tip() +
+                            m_sstrRow.arg("<hr>") +
+                            m_sstrRow.arg(VBoxGlobal::tr("This base hard disk is indirectly attached using "
+                                                         "the following differencing hard disk:", "medium")) +
+                            m_strToolTip + m_noDiffs.toolTip;
+    }
+
+    if (m_noDiffs.toolTip.isNull())
+        m_noDiffs.toolTip = m_strToolTip;
+
+    m_noDiffs.isSet = true;
+}
+

trunk/src/VBox/Frontends/VirtualBox/src/medium/UIMedium.h

@@ -39 +39 @@
 struct NoDiffsCache
 {
-    NoDiffsCache() : isSet (false), state (KMediumState_NotCreated) {}
-    NoDiffsCache& operator= (const NoDiffsCache &aOther)
+    NoDiffsCache() : isSet(false), state(KMediumState_NotCreated) {}
+    NoDiffsCache& operator=(const NoDiffsCache &other)
     {
-        isSet = aOther.isSet;
-        state = aOther.state;
-        result = aOther.result;
-        toolTip = aOther.toolTip;
+        isSet = other.isSet;
+        state = other.state;
+        result = other.result;
+        toolTip = other.toolTip;
         return *this;
     }
@@ -87 +87 @@
      */
     UIMedium()
-        : mType (UIMediumType_Invalid)
-        , mState (KMediumState_NotCreated)
-        , mIsReadOnly (false)
-        , mIsUsedInSnapshots (false)
-        , mParent (0) { refresh(); }
+        : m_type(UIMediumType_Invalid)
+        , m_state(KMediumState_NotCreated)
+        , m_fReadOnly(false)
+        , m_fUsedInSnapshots(false)
+        , m_pParent(0) { refresh(); }
 
     /**
@@ -101 +101 @@
      *
      * One of the hardDisk, dvdImage, or floppyImage members is assigned from
-     * aMedium according to aType. @a aParent must be always NULL for non-hard
+     * medium according to type. @a pParent must be always NULL for non-hard
      * disk media.
      */
-    UIMedium (const CMedium &aMedium, UIMediumType aType, UIMedium *aParent = 0)
-        : mMedium (aMedium)
-        , mType (aType)
-        , mState (KMediumState_NotCreated)
-        , mIsReadOnly (false)
-        , mIsUsedInSnapshots (false)
-        , mParent (aParent) { refresh(); }
+    UIMedium(const CMedium &medium, UIMediumType type, UIMedium *pParent = 0)
+        : m_medium(medium)
+        , m_type(type)
+        , m_state(KMediumState_NotCreated)
+        , m_fReadOnly(false)
+        , m_fUsedInSnapshots(false)
+        , m_pParent(pParent) { refresh(); }
 
     /**
      * Similar to the other non-null constructor but sets the media state to
-     * @a aState. Suitable when the media state is known such as right after
+     * @a state. Suitable when the media state is known such as right after
      * creation.
      */
-    UIMedium (const CMedium &aMedium, UIMediumType aType, KMediumState aState)
-        : mMedium (aMedium)
-        , mType (aType)
-        , mState (aState)
-        , mIsReadOnly (false)
-        , mIsUsedInSnapshots (false)
-        , mParent (0) { refresh(); }
-
-    UIMedium& operator= (const UIMedium &aOther);
+    UIMedium(const CMedium &medium, UIMediumType type, KMediumState state)
+        : m_medium(medium)
+        , m_type(type)
+        , m_state(state)
+        , m_fReadOnly(false)
+        , m_fUsedInSnapshots(false)
+        , m_pParent(0) { refresh(); }
+
+    UIMedium& operator=(const UIMedium &other);
 
     void blockAndQueryState();
     void refresh();
 
-    bool isHidden() const { return m_fHide | m_fAttachedToHiddenMachinesOnly; }
-
-    const CMedium &medium() const { return mMedium; }
-
-    UIMediumType type() const { return mType; }
+    bool isHidden() const { return m_fHidden | m_fAttachedToHiddenMachinesOnly; }
+
+    const CMedium &medium() const { return m_medium; }
+
+    UIMediumType type() const { return m_type; }
 
     /**
@@ -140 +140 @@
      * terms of inaccessibility) detected on the given hard disk chain.
      *
-     * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
-     */
-    KMediumState state (bool aNoDiffs = false) const
+     * @param fNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+     */
+    KMediumState state(bool fNoDiffs = false) const
     {
-        unconst (this)->checkNoDiffs (aNoDiffs);
-        return aNoDiffs ? mNoDiffs.state : mState;
+        unconst (this)->checkNoDiffs(fNoDiffs);
+        return fNoDiffs ? m_noDiffs.state : m_state;
     }
 
-    QString lastAccessError() const { return mLastAccessError; }
+    QString lastAccessError() const { return m_strLastAccessError; }
 
     /**
@@ -156 +156 @@
      * detected on the given hard disk chain.
      *
-     * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
-     */
-    const COMResult &result (bool aNoDiffs = false) const
+     * @param fNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+     */
+    const COMResult &result(bool fNoDiffs = false) const
     {
-        unconst (this)->checkNoDiffs (aNoDiffs);
-        return aNoDiffs ? mNoDiffs.result : mResult;
+        unconst(this)->checkNoDiffs(fNoDiffs);
+        return fNoDiffs ? m_noDiffs.result : m_result;
     }
 
-    QString id() const { return mId; }
-    QString name (bool aNoDiffs = false) const { return aNoDiffs ? root().mName : mName; }
-    QString location (bool aNoDiffs = false) const { return aNoDiffs ? root().mLocation : mLocation; }
-
-    QString size (bool aNoDiffs = false) const { return aNoDiffs ? root().mSize : mSize; }
-    QString logicalSize (bool aNoDiffs = false) const { return aNoDiffs ? root().mLogicalSize : mLogicalSize; }
-
-    QString hardDiskFormat (bool aNoDiffs = false) const { return aNoDiffs ? root().mHardDiskFormat : mHardDiskFormat; }
-    QString hardDiskType (bool aNoDiffs = false) const { return aNoDiffs ? root().mHardDiskType : mHardDiskType; }
-
-    QString storageDetails() const { return mStorageDetails; }
-
-    QString usage (bool aNoDiffs = false) const { return aNoDiffs ? root().mUsage : mUsage; }
-    QString tip() const { return mToolTip; }
-
-    const NoDiffsCache& cache() const { return mNoDiffs; }
+    QString id() const { return m_strId; }
+    QString name(bool fNoDiffs = false) const { return fNoDiffs ? root().m_strName : m_strName; }
+    QString location(bool fNoDiffs = false) const { return fNoDiffs ? root().m_strLocation : m_strLocation; }
+
+    QString size(bool fNoDiffs = false) const { return fNoDiffs ? root().m_strSize : m_strSize; }
+    QString logicalSize(bool fNoDiffs = false) const { return fNoDiffs ? root().m_strLogicalSize : m_strLogicalSize; }
+
+    QString hardDiskFormat(bool fNoDiffs = false) const { return fNoDiffs ? root().m_strHardDiskFormat : m_strHardDiskFormat; }
+    QString hardDiskType(bool fNoDiffs = false) const { return fNoDiffs ? root().m_strHardDiskType : m_strHardDiskType; }
+
+    QString storageDetails() const { return m_strStorageDetails; }
+
+    QString usage(bool fNoDiffs = false) const { return fNoDiffs ? root().m_strUsage : m_strUsage; }
+    QString tip() const { return m_strToolTip; }
+
+    const NoDiffsCache& cache() const { return m_noDiffs; }
 
     /**
@@ -186 +186 @@
      * be attached indirectly.
      */
-    bool isReadOnly() const { return mIsReadOnly; }
+    bool isReadOnly() const { return m_fReadOnly; }
 
     /**
@@ -193 +193 @@
      * comma-separated VM names (with snapshot names, if any, in parenthesis).
      */
-    bool isUsed() const { return !mUsage.isNull(); }
+    bool isUsed() const { return !m_strUsage.isNull(); }
 
     /**
      * Returns @c true if this medium is attached to any VM in any snapshot.
      */
-    bool isUsedInSnapshots() const { return mIsUsedInSnapshots; }
+    bool isUsedInSnapshots() const { return m_fUsedInSnapshots; }
 
     /**
      * Returns @c true if this medium corresponds to real host drive.
      */
-    bool isHostDrive() const { return mIsHostDrive; }
+    bool isHostDrive() const { return m_fHostDrive; }
 
     /**
      * Returns @c true if this medium is attached to the given machine in the current state.
      */
-    bool isAttachedInCurStateTo (const QString &aMachineId) const { return mCurStateMachineIds.indexOf (aMachineId) >= 0; }
+    bool isAttachedInCurStateTo(const QString &strMachineId) const { return m_curStateMachineIds.indexOf(strMachineId) >= 0; }
 
     /**
@@ -214 +214 @@
      * to in their current state (i.e. excluding snapshots).
      */
-    const QList <QString> &curStateMachineIds() const { return mCurStateMachineIds; }
+    const QList <QString> &curStateMachineIds() const { return m_curStateMachineIds; }
 
     /**
      * Returns a parent medium. For non-hard disk media, this is always NULL.
      */
-    UIMedium* parent() const { return mParent; }
+    UIMedium* parent() const { return m_pParent; }
 
     UIMedium& root() const;
 
-    QString toolTip (bool aNoDiffs = false, bool aCheckRO = false, bool aNullAllowed = false) const;
-    QPixmap icon (bool aNoDiffs = false, bool aCheckRO = false) const;
-
-    /** Shortcut to <tt>#toolTip (aNoDiffs, true)</tt>. */
-    QString toolTipCheckRO (bool aNoDiffs = false, bool aNullAllowed = false) const { return toolTip (aNoDiffs, true, aNullAllowed); }
-
-    /** Shortcut to <tt>#icon (aNoDiffs, true)</tt>. */
-    QPixmap iconCheckRO (bool aNoDiffs = false) const { return icon (aNoDiffs, true); }
-
-    QString details (bool aNoDiffs = false, bool aPredictDiff = false, bool aUseHTML = false) const;
-
-    /** Shortcut to <tt>#details (aNoDiffs, aPredictDiff, true)</tt>. */
-    QString detailsHTML (bool aNoDiffs = false, bool aPredictDiff = false) const { return details (aNoDiffs, aPredictDiff, true); }
+    QString toolTip(bool fNoDiffs = false, bool fCheckRO = false, bool fNullAllowed = false) const;
+    QPixmap icon(bool fNoDiffs = false, bool fCheckRO = false) const;
+
+    /** Shortcut to <tt>#toolTip(fNoDiffs, true)</tt>. */
+    QString toolTipCheckRO(bool fNoDiffs = false, bool fNullAllowed = false) const { return toolTip(fNoDiffs, true, fNullAllowed); }
+
+    /** Shortcut to <tt>#icon(fNoDiffs, true)</tt>. */
+    QPixmap iconCheckRO(bool fNoDiffs = false) const { return icon(fNoDiffs, true); }
+
+    QString details(bool fNoDiffs = false, bool fPredictDiff = false, bool aUseHTML = false) const;
+
+    /** Shortcut to <tt>#details(fNoDiffs, fPredictDiff, true)</tt>. */
+    QString detailsHTML(bool fNoDiffs = false, bool fPredictDiff = false) const { return details(fNoDiffs, fPredictDiff, true); }
 
     /** Returns @c true if this media descriptor is a null object. */
-    bool isNull() const { return mMedium.isNull(); }
+    bool isNull() const { return m_medium.isNull(); }
 
 private:
 
-    void checkNoDiffs (bool aNoDiffs);
-
-    CMedium mMedium;
-
-    UIMediumType mType;
-
-    KMediumState mState;
-    QString mLastAccessError;
-    COMResult mResult;
-
-    QString mId;
-    QString mName;
-    QString mLocation;
-
-    QString mSize;
-    QString mLogicalSize;
-
-    QString mHardDiskFormat;
-    QString mHardDiskType;
-
-    QString mStorageDetails;
-
-    QString mUsage;
-    QString mToolTip;
-
-    bool mIsReadOnly        : 1;
-    bool mIsUsedInSnapshots : 1;
-    bool mIsHostDrive       : 1;
-    bool m_fHide            : 1;
+    void checkNoDiffs(bool fNoDiffs);
+
+    CMedium m_medium;
+
+    UIMediumType m_type;
+
+    KMediumState m_state;
+    QString m_strLastAccessError;
+    COMResult m_result;
+
+    QString m_strId;
+    QString m_strName;
+    QString m_strLocation;
+
+    QString m_strSize;
+    QString m_strLogicalSize;
+
+    QString m_strHardDiskFormat;
+    QString m_strHardDiskType;
+
+    QString m_strStorageDetails;
+
+    QString m_strUsage;
+    QString m_strToolTip;
+
+    bool m_fReadOnly                     : 1;
+    bool m_fUsedInSnapshots              : 1;
+    bool m_fHostDrive                    : 1;
+    bool m_fHidden                       : 1;
     bool m_fAttachedToHiddenMachinesOnly : 1;
 
-    QList <QString> mCurStateMachineIds;
-
-    UIMedium *mParent;
-
-    NoDiffsCache mNoDiffs;
-
-    static QString mTable;
-    static QString mRow;
+    QList<QString> m_curStateMachineIds;
+
+    UIMedium *m_pParent;
+
+    NoDiffsCache m_noDiffs;
+
+    static QString m_sstrTable;
+    static QString m_sstrRow;
 };
 
-typedef QLinkedList <UIMedium> VBoxMediaList;
+typedef QLinkedList<UIMedium> VBoxMediaList;
 
 #endif /* __UIMedium_h__ */
-