Changeset 48124 in vbox for trunk

Timestamp:

Aug 28, 2013 12:46:51 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

88504

Message:

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

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• globals/UIDefs.h (modified) (1 diff)
• globals/VBoxGlobal.cpp (modified) (8 diffs)
• globals/VBoxGlobal.h (modified) (3 diffs)
• medium/UIMediumManager.cpp (modified) (2 diffs)
• runtime/UIMachine.cpp (modified) (1 diff)
• settings/machine/UIMachineSettingsStorage.cpp (modified) (1 diff)
• widgets/VBoxMediaComboBox.cpp (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDefs.h

@@ -71 +71 @@
         , SetRegionEventType
         , ModifierKeyChangeEventType
-        , MediaEnumEventType
+        , MediumEnumeratedEventType
+        , MediumsEnumeratedEventType
 #ifdef Q_WS_WIN
         , ShellExecuteEventType

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

@@ -162 +162 @@
 #endif
 
-// VBoxMediaEnumEvent
-/////////////////////////////////////////////////////////////////////////////
-
-class VBoxMediaEnumEvent : public QEvent
+/* Medium enumerated event: */
+class UIMediumEnumeratedEvent : public QEvent
 {
 public:
 
-    /** Constructs a regular enum event */
-    VBoxMediaEnumEvent (const UIMedium &aMedium,
-                        const VBoxMediaList::iterator &aIterator)
-        : QEvent ((QEvent::Type) MediaEnumEventType)
-        , mMedium (aMedium), mIterator (aIterator), mLast (false)
-        {}
-    /** Constructs the last enum event */
-    VBoxMediaEnumEvent (const VBoxMediaList::iterator &aIterator)
-        : QEvent ((QEvent::Type) MediaEnumEventType)
-        , mIterator (aIterator), mLast (true)
-        {}
-
-    /** Last enumerated medium (not valid when #last is true) */
-    const UIMedium mMedium;
-    /* Iterator which points to the corresponding item in the GUI thread: */
-    const VBoxMediaList::iterator mIterator;
-    /** Whether this is the last event for the given enumeration or not */
-    const bool mLast;
+    /* Constructor: */
+    UIMediumEnumeratedEvent(const UIMedium &medium, const VBoxMediaList::iterator &iterator)
+        : QEvent((QEvent::Type)MediumEnumeratedEventType)
+        , m_medium(medium), m_iterator(iterator)
+    {}
+
+    /* Variables: */
+    const UIMedium m_medium;
+    const VBoxMediaList::iterator m_iterator;
+};
+
+/* Mediums enumerated event: */
+class UIMediumsEnumeratedEvent : public QEvent
+{
+public:
+
+    /* Constructor: */
+    UIMediumsEnumeratedEvent(const VBoxMediaList::iterator &iterator)
+        : QEvent((QEvent::Type)MediumsEnumeratedEventType)
+        , m_iterator(iterator)
+    {}
+
+    /* Variable: */
+    const VBoxMediaList::iterator m_iterator;
 };
 
@@ -957 +961 @@
 }
 
-QString VBoxGlobal::details (const CMedium &aMedium, bool aPredictDiff, bool fUseHtml /* = true */)
-{
-    CMedium cmedium (aMedium);
-    UIMedium medium;
-
-    if (!findMedium (cmedium, medium))
-    {
-        /* Medium may be new and not already in the media list, request refresh */
-        startEnumeratingMedia();
-        if (!findMedium (cmedium, medium))
-            /* Medium might be deleted already, return null string */
+QString VBoxGlobal::details(const CMedium &medium, bool fPredictDiff, bool fUseHtml /*= true*/)
+{
+    /* Search for corresponding UI medium: */
+    UIMedium uimedium;
+    if (!findMedium(medium, uimedium))
+    {
+        /* UI medium may be new and not in medium list, request enumeration: */
+        startMediumEnumeration();
+
+        /* Search for corresponding UI medium again: */
+        if (!findMedium(medium, uimedium))
+        {
+            /* Medium might be deleted already, return null string: */
             return QString();
-    }
-
-    return fUseHtml ? medium.detailsHTML (true /* aNoDiffs */, aPredictDiff) :
-                      medium.details(true /* aNoDiffs */, aPredictDiff);
+        }
+    }
+
+    /* Return UI medium details: */
+    return fUseHtml ? uimedium.detailsHTML(true /* aNoDiffs */, fPredictDiff) :
+                      uimedium.details(true /* aNoDiffs */, fPredictDiff);
 }
 
@@ -1718 +1726 @@
 }
 
-void VBoxGlobal::startEnumeratingMedia(bool fForceStart /*= true*/)
+void VBoxGlobal::startMediumEnumeration(bool fForceStart /*= true*/)
 {
     /* Make sure VBoxGlobal is already valid: */
@@ -1774 +1782 @@
             {
                 m_mediums[i].blockAndQueryState();
-                QApplication::postEvent(pSelf, new VBoxMediaEnumEvent(m_mediums[i], m_iterator));
+                QApplication::postEvent(pSelf, new UIMediumEnumeratedEvent(m_mediums[i], m_iterator));
                 ++m_iterator;
             }
@@ -1780 +1788 @@
             /* Post the end-of-enumeration event: */
             if (!m_sfCleanupInProgress)
-                QApplication::postEvent(pSelf, new VBoxMediaEnumEvent(m_iterator));
+                QApplication::postEvent(pSelf, new UIMediumsEnumeratedEvent(m_iterator));
 
             COMBase::CleanupCOM();
@@ -4016 +4024 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-bool VBoxGlobal::event (QEvent *e)
-{
-    switch (e->type())
-    {
-        case MediaEnumEventType:
-        {
-            VBoxMediaEnumEvent *ev = (VBoxMediaEnumEvent*) e;
-
-            if (!ev->mLast)
-            {
-                if (ev->mMedium.state() == KMediumState_Inaccessible &&
-                    !ev->mMedium.result().isOk())
-                    msgCenter().cannotGetMediaAccessibility (ev->mMedium);
-                Assert (ev->mIterator != m_mediums.end());
-                *(ev->mIterator) = ev->mMedium;
-                emit sigMediumEnumerated(*ev->mIterator);
-            }
-            else
-            {
-                /* the thread has posted the last message, wait for termination */
-                m_pMediumEnumerationThread->wait();
-                delete m_pMediumEnumerationThread;
-                m_pMediumEnumerationThread = 0;
-                emit sigMediumEnumerationFinished(m_mediums);
-            }
-
+bool VBoxGlobal::event(QEvent *pEvent)
+{
+    /* Handle events: */
+    switch (pEvent->type())
+    {
+        case MediumEnumeratedEventType:
+        {
+            /* Cast to corresponding event: */
+            UIMediumEnumeratedEvent *pMediumEnumeratedEvent = static_cast<UIMediumEnumeratedEvent*>(pEvent);
+
+            /* Show accessibility error message if necessary: */
+            if (pMediumEnumeratedEvent->m_medium.state() == KMediumState_Inaccessible &&
+                !pMediumEnumeratedEvent->m_medium.result().isOk())
+                msgCenter().cannotGetMediaAccessibility(pMediumEnumeratedEvent->m_medium);
+
+            /* Make sure incoming iterator is valid: */
+            AssertReturn(pMediumEnumeratedEvent->m_iterator != m_mediums.end(), false);
+
+            /* Assign enumeration result to corresponding medium: */
+            *(pMediumEnumeratedEvent->m_iterator) = pMediumEnumeratedEvent->m_medium;
+
+            /* Notify listeners about newly enumerated medium: */
+            emit sigMediumEnumerated(*pMediumEnumeratedEvent->m_iterator);
+
+            /* Accept event: */
             return true;
         }
-
+        case MediumsEnumeratedEventType:
+        {
+            /* Cleanup enumeration thread: */
+            m_pMediumEnumerationThread->wait();
+            delete m_pMediumEnumerationThread;
+            m_pMediumEnumerationThread = 0;
+
+            /* Notify listeners about enumeration finished: */
+            emit sigMediumEnumerationFinished(m_mediums);
+
+            /* Accept event: */
+            return true;
+        }
         default:
             break;
     }
-
-    return QObject::event (e);
+    /* Call to base-class: */
+    return QObject::event(pEvent);
 }
 
@@ -4566 +4585 @@
      * used by some VBox smart widgets, like VBoxMediaComboBox: */
     if (agressiveCaching())
-        startEnumeratingMedia();
+        startMediumEnumeration();
 
     /* Prepare global settings change handler: */
@@ -4649 +4668 @@
     mVBox.detach();
 
-    /* There may be VBoxMediaEnumEvent instances still in the message
+    /* There may be UIMedium(s)EnumeratedEvent instances still in the message
      * queue which reference COM objects. Remove them to release those objects
      * before uninitializing the COM subsystem. */

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

@@ -225 +225 @@
     /* details generators */
 
-    QString details (const CMedium &aHD, bool aPredictDiff, bool fUseHtml = true);
+    QString details(const CMedium &medium, bool fPredictDiff, bool fUseHtml = true);
 
     QString details (const CUSBDevice &aDevice) const;
@@ -243 +243 @@
 
     /* API: Medium-enumeration stuff: */
-    void startEnumeratingMedia(bool fForceStart = true);
+    void startMediumEnumeration(bool fForceStart = true);
     bool agressiveCaching() const { return mAgressiveCaching; }
     bool isMediaEnumerationStarted() const { return !!m_pMediumEnumerationThread; }
@@ -404 +404 @@
 protected:
 
-    bool event (QEvent *e);
+    bool event(QEvent *pEvent);
     bool eventFilter (QObject *, QEvent *);
 

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

@@ -269 +269 @@
     // to machine who's event called for *full-refresh* and start medium-enumeration.
     // But medium-enumeration itself should update *only* invalidated mediums.
-    vboxGlobal().startEnumeratingMedia();
+    vboxGlobal().startMediumEnumeration();
 }
 
@@ -1140 +1140 @@
     {
         /* Just start medium-enumeration: */
-        vboxGlobal().startEnumeratingMedia();
+        vboxGlobal().startMediumEnumeration();
     }
     /* If refresh was not requested or enumeration already started: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachine.cpp

@@ -383 +383 @@
 
     /* Cache medium data only if really necessary: */
-    vboxGlobal().startEnumeratingMedia(false /* force start */);
+    vboxGlobal().startMediumEnumeration(false /* force start */);
 
     /* Load machine settings: */

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.cpp

@@ -1735 +1735 @@
      * lasted point, where we can start. The rest of the media checking is done
      * in a background thread. */
-    vboxGlobal().startEnumeratingMedia();
+    vboxGlobal().startMediumEnumeration();
 
     /* Initialize pixmap pool */

trunk/src/VBox/Frontends/VirtualBox/src/widgets/VBoxMediaComboBox.cpp

@@ -90 +90 @@
 {
     if (!vboxGlobal().isMediaEnumerationStarted())
-        vboxGlobal().startEnumeratingMedia();
+        vboxGlobal().startMediumEnumeration();
     else
         refresh();