Changeset 548 in vbox

Timestamp:

Feb 2, 2007 1:57:12 PM (18 years ago)

Author:

vboxsync

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

18165

Message:

FE/Qt: Latest fixes to VDM and media enumeration process (better cooperation between media cobmoboxes, modal and modeless VDMs during the enumeration).

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• include/VBoxGlobal.h (modified) (4 diffs)
• include/VBoxMediaComboBox.h (modified) (3 diffs)
• include/VBoxSelectorWnd.h (modified) (1 diff)
• src/VBoxGlobal.cpp (modified) (21 diffs)
• src/VBoxMediaComboBox.cpp (modified) (6 diffs)
• src/VBoxSelectorWnd.cpp (modified) (3 diffs)
• ui/VBoxDiskImageManagerDlg.ui (modified) (4 diffs)
• ui/VBoxDiskImageManagerDlg.ui.h (modified) (37 diffs)
• ui/VBoxNewVMWzd.ui.h (modified) (6 diffs)
• ui/VBoxVMSettingsDlg.ui.h (modified) (8 diffs)

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

@@ -245 +245 @@
         return toString (aHD.GetType());
     }
-    
+
     QString toString (CEnums::DiskControllerType t, LONG d) const;
 
@@ -321 +321 @@
 
     void startEnumeratingMedia();
-    bool isInEnumeratingProcess() { return media_enum_thread ? true : false; }
-
-    /** Returns a list of all currently enumerated media (it is empty if the
-     *  enumeration has been finished or never been started). */
-    VBoxMediaList currentMediaList() const { return media_list; }
+
+    /**
+     *  Returns a list of all currently registered media. This list is used
+     *  to globally track the accessiblity state of all media on a dedicated
+     *  thread. This the list is initially empty (before the first enumeration
+     *  process is started using #startEnumeratingMedia()).
+     */
+    const VBoxMediaList &currentMediaList() const { return media_list; }
+
+    /** Returns true if the media enumeration is in progress. */
+    bool isMediaEnumerationStarted() const { return media_enum_thread != NULL; }
+
+    void addMedia (const VBoxMedia &);
+    void updateMedia (const VBoxMedia &);
+    void removeMedia (VBoxDefs::DiskType, const QUuid &);
 
     /* various helpers */
@@ -360 +370 @@
 
     /**
-     *  Emitted during the enumeration process started
-     *  by #startEnumeratingMedia(). */
-    void mediaEnumerated (const VBoxMedia &media);
+     *  Emitted at the beginning of the enumeration process started
+     *  by #startEnumeratingMedia().
+     */
+    void mediaEnumStarted();
+
+    /**
+     *  Emitted when a new media item from the list has updated
+     *  its accessibility state.
+     */
+    void mediaEnumerated (const VBoxMedia &aMedia, int aIndex);
 
     /**
@@ -368 +385 @@
      *  by #startEnumeratingMedia().
      *  @note #currentMediaList() will return an empty list
-     *  when this signal is emitted, use the argument instead. */
-    void mediaEnumerated (const VBoxMediaList &list);
+     *  when this signal is emitted, use the argument instead.
+     */
+    void mediaEnumFinished (const VBoxMediaList &aList);
+
+    /** Emitted when a new media is added using #addMedia(). */
+    void mediaAdded (const VBoxMedia &);
+
+    /** Emitted when the media is updated using #updateMedia(). */
+    void mediaUpdated (const VBoxMedia &);
+
+    /** Emitted when the media is removed using #removeMedia(). */
+    void mediaRemoved (VBoxDefs::DiskType, const QUuid &);
 
     /* signals emitted when the VirtualBox callback is called by the server

trunk/src/VBox/Frontends/VirtualBox/include/VBoxMediaComboBox.h

@@ -27 +27 @@
 
 #include <qcombobox.h>
-#include <quuid.h>
 
 class QListBoxItem;
@@ -37 +36 @@
 public:
 
-    VBoxMediaComboBox (QWidget *aParent = 0,
-                       const char *aName = 0, int aType = 0);
+    VBoxMediaComboBox (QWidget *aParent = 0, const char *aName = 0,
+                       int aType = 0, bool aUseEmptyItem = false);
     ~VBoxMediaComboBox() {}
 
     void  refresh();
-    void  appendItem (const QString &, const QUuid &, const QString &);
-    void  replaceItem (int, const QString &, const QString &);
-    void  removeLastItem();
-    void  setReadyForRefresh();
-    void  setRequiredItem (const QUuid &);
     void  setUseEmptyItem (bool);
     void  setBelongsTo (const QUuid &);
     QUuid getId();
     QUuid getBelongsTo();
-    void setCurrentItem (int);
+    void  setCurrentItem (const QUuid &);
 
 protected slots:
 
-    void mediaEnumerated (const VBoxMedia &);
-    void listEnumerated (const VBoxMediaList &);
+    void mediaEnumStarted();
+    void mediaEnumerated (const VBoxMedia &, int);
+    void mediaEnumFinished (const VBoxMediaList &);
+    void mediaAdded (const VBoxMedia &);
+    void mediaUpdated (const VBoxMedia &);
+    void mediaRemoved (VBoxDefs::DiskType, const QUuid &);
     void processOnItem (QListBoxItem *);
-    void updateToolTip (int);
+    void processActivated (int);
 
 protected:
 
-    void loadCleanContent();
-    int updateMedia (const QString &, const QUuid &, const QString &,
-                     VBoxMedia::Status);
+    void updateToolTip (int);
+    void setCurrentItem (int);
+    void processMedia (const VBoxMedia &);
+    void processHdMedia (const VBoxMedia &);
+    void processCdMedia (const VBoxMedia &);
+    void processFdMedia (const VBoxMedia &);
+    void appendItem (const QString &, const QUuid &,
+                     const QString &, QPixmap *);
+    void replaceItem (int, const QString &,
+                      const QString &, QPixmap *);
+    void updateShortcut (const QString &, const QUuid &, const QString &,
+                          VBoxMedia::Status);
 
     int         mType;
@@ -72 +79 @@
     QUuid       mRequiredId;
     bool        mUseEmptyItem;
-    bool        mToBeRefreshed;
+    QPixmap     mPmInacc;
+    QPixmap     mPmError;
 };
 

trunk/src/VBox/Frontends/VirtualBox/include/VBoxSelectorWnd.h

@@ -91 +91 @@
     void vmListBoxCurrentChanged (bool aRefreshDetails = true,
                                   bool aRefreshSnapshots = true);
-    void mediaEnumerated (const VBoxMediaList &list);
+    void mediaEnumFinished (const VBoxMediaList &);
 
     /* VirtualBox callback events we're interested in */

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

@@ -52 +52 @@
 
     /** Constructs a regular enum event */
-    VBoxEnumerateMediaEvent (const VBoxMedia &m)
+    VBoxEnumerateMediaEvent (const VBoxMedia &aMedia, int aIndex)
         : QEvent ((QEvent::Type) VBoxDefs::EnumerateMediaEventType)
-        , media (m), last (false)
+        , mMedia (aMedia), mLast (false), mIndex (aIndex)
         {}
     /** Constructs the last enum event */
     VBoxEnumerateMediaEvent()
         : QEvent ((QEvent::Type) VBoxDefs::EnumerateMediaEventType)
-        , last (true)
+        , mLast (true), mIndex (-1)
         {}
 
     /** the last enumerated media (not valid when #last is true) */
-    const VBoxMedia media;
+    const VBoxMedia mMedia;
     /** whether this is the last event for the given enumeration or not */
-    const bool last;
+    const bool mLast;
+    /** last enumerated media index (-1 when #last is true) */
+    const int mIndex;
 };
 
@@ -580 +582 @@
 
     CEnums::HardDiskType type = root.GetType();
-    
+
     if (type == CEnums::NormalHardDisk &&
         (aHD != root || (aPredict && root.GetChildren().GetCount() != 0)))
@@ -586 +588 @@
     else
         details = hardDiskTypeString (root);
-    
+
     details += ", " + formatSize (root.GetSize() * _1M);
-    
+
     return details;
 }
@@ -611 +613 @@
             details += " " + p;
     }
-    ushort r = aDevice.GetRevision();                    
+    ushort r = aDevice.GetRevision();
     if (r != 0)
         details += QString().sprintf (" [%04hX]", r);
 
-    return details;        
+    return details;
 }
 
@@ -642 +644 @@
                         .arg (vboxGlobal().toString (hostDev.GetState()));
     }
-                        
-    return tip;        
+
+    return tip;
 }
 
@@ -1054 +1056 @@
  *  If the enumeration is already in progress, no new thread is started.
  *
- *  @see #currentMediaList()
+ *  @sa #currentMediaList()
+ *  @sa #isMediaEnumerationStarted()
  */
 void VBoxGlobal::startEnumeratingMedia()
 {
     Assert (valid);
-    if (!valid)
-        return;
-
-    // check if already started but not yet finished
+
+    /* check if already started but not yet finished */
     if (media_enum_thread)
         return;
 
+    /* composes a list of all currently known media */
+    media_list.clear();
+    {
+        CHardDiskEnumerator enHD = vbox.GetHardDisks().Enumerate();
+        while (enHD.HasMore() && !vboxGlobal_cleanup)
+        {
+            CHardDisk hd = enHD.GetNext();
+            media_list += VBoxMedia (CUnknown (hd), VBoxDefs::HD, VBoxMedia::Unknown);
+        }
+        CDVDImageEnumerator enCD = vbox.GetDVDImages().Enumerate();
+        while (enCD.HasMore() && !vboxGlobal_cleanup)
+        {
+            CDVDImage cd = enCD.GetNext();
+            media_list += VBoxMedia (CUnknown (cd), VBoxDefs::CD, VBoxMedia::Unknown);
+        }
+        CFloppyImageEnumerator enFD = vbox.GetFloppyImages().Enumerate();
+        while (enFD.HasMore() && !vboxGlobal_cleanup)
+        {
+            CFloppyImage fd = enFD.GetNext();
+            media_list += VBoxMedia (CUnknown (fd), VBoxDefs::FD, VBoxMedia::Unknown);
+        }
+        if (!vboxGlobal_cleanup)
+            emit mediaEnumStarted();
+    }
+
+    /* enumeration thread class */
     class Thread : public QThread
     {
     public:
 
+        Thread (VBoxMediaList &aList) : mList (aList) {}
+
         virtual void run()
         {
             LogFlow (("MediaEnumThread started.\n"));
-
             COMBase::initializeCOM();
 
@@ -1079 +1107 @@
             QObject *target = &vboxGlobal();
 
-            CHardDiskEnumerator enHd = vbox.GetHardDisks().Enumerate();
-            while (enHd.HasMore() && !vboxGlobal_cleanup)
+            /* enumerating list */
+            int index = 0;
+            VBoxMediaList::Iterator it;
+            for (it = mList.begin();
+                 it != mList.end() && !vboxGlobal_cleanup;
+                 ++ it, ++ index)
             {
-                CHardDisk hd = enHd.GetNext();
-                VBoxMedia::Status status =
-                    hd.GetAllAccessible() == TRUE ? VBoxMedia::Ok :
-                    hd.isOk() ? VBoxMedia::Inaccessible :
-                    VBoxMedia::Error;
-
-                if (status == VBoxMedia::Inaccessible)
+                VBoxMedia &media = *it;
+                switch (media.type)
                 {
-                    // correct media status if the machine using the hard disk
-                    // is currently running (so the disk is actually accessed by it
-                    // in a normal way)
-                    QUuid machineId = hd.GetMachineId();
-                    if (!machineId.isNull())
+                    case VBoxDefs::HD:
                     {
-                        CMachine machine = vbox.GetMachine (machineId);
-                        if (!machine.isNull() && (machine.GetState() >= CEnums::Running))
-                            status = VBoxMedia::Ok;
+                        CHardDisk hd = media.disk;
+                        media.status =
+                            hd.GetAllAccessible() == TRUE ? VBoxMedia::Ok :
+                            hd.isOk() ? VBoxMedia::Inaccessible :
+                            VBoxMedia::Error;
+                        if (media.status == VBoxMedia::Inaccessible)
+                        {
+                            QUuid machineId = hd.GetMachineId();
+                            if (!machineId.isNull())
+                            {
+                                CMachine machine = vbox.GetMachine (machineId);
+                                if (!machine.isNull() && (machine.GetState() >= CEnums::Running))
+                                    media.status = VBoxMedia::Ok;
+                            }
+                        }
+                        VBoxMedia newMedia (CUnknown(hd), VBoxDefs::HD, media.status);
+                        QApplication::postEvent (target,
+                            new VBoxEnumerateMediaEvent (newMedia, index));
+                        break;
+                    }
+                    case VBoxDefs::CD:
+                    {
+                        CDVDImage cd = media.disk;
+                        media.status =
+                            cd.GetAccessible() == TRUE ? VBoxMedia::Ok :
+                            cd.isOk() ? VBoxMedia::Inaccessible :
+                            VBoxMedia::Error;
+                        VBoxMedia newMedia (CUnknown(cd), VBoxDefs::CD, media.status);
+                        QApplication::postEvent (target,
+                            new VBoxEnumerateMediaEvent (newMedia, index));
+                        break;
+                    }
+                    case VBoxDefs::FD:
+                    {
+                        CFloppyImage fd = media.disk;
+                        media.status =
+                            fd.GetAccessible() == TRUE ? VBoxMedia::Ok :
+                            fd.isOk() ? VBoxMedia::Inaccessible :
+                            VBoxMedia::Error;
+                        VBoxMedia newMedia (CUnknown(fd), VBoxDefs::FD, media.status);
+                        QApplication::postEvent (target,
+                            new VBoxEnumerateMediaEvent (newMedia, index));
+                        break;
+                    }
+                    default:
+                    {
+                        AssertMsgFailed (("Invalid aMedia type\n"));
+                        break;
                     }
                 }
-
-                VBoxMedia media =
-                    VBoxMedia (CUnknown (hd), VBoxDefs::HD, status);
-
-                QApplication::postEvent (target,
-                    new VBoxEnumerateMediaEvent (media));
             }
 
-            CDVDImageEnumerator enDVD = vbox.GetDVDImages().Enumerate();
-            while (enDVD.HasMore() && !vboxGlobal_cleanup)
-            {
-                CDVDImage dvd = enDVD.GetNext();
-                VBoxMedia::Status status =
-                    dvd.GetAccessible() == TRUE ? VBoxMedia::Ok :
-                    dvd.isOk() ? VBoxMedia::Inaccessible :
-                    VBoxMedia::Error;
-
-                VBoxMedia media =
-                    VBoxMedia (CUnknown (dvd), VBoxDefs::CD, status);
-
-                QApplication::postEvent (target,
-                    new VBoxEnumerateMediaEvent (media));
-            }
-
-            CFloppyImageEnumerator enFloppy = vbox.GetFloppyImages().Enumerate();
-            while (enFloppy.HasMore() && !vboxGlobal_cleanup)
-            {
-                CFloppyImage floppy = enFloppy.GetNext();
-                VBoxMedia::Status status =
-                    floppy.GetAccessible() == TRUE ? VBoxMedia::Ok :
-                    floppy.isOk() ? VBoxMedia::Inaccessible :
-                    VBoxMedia::Error;
-
-                VBoxMedia media =
-                    VBoxMedia (CUnknown (floppy), VBoxDefs::FD, status);
-
-                QApplication::postEvent (target,
-                    new VBoxEnumerateMediaEvent (media));
-            }
-
-            // post the last message to indicate the end of enumeration
+            /* post the last message to indicate the end of enumeration */
             if (!vboxGlobal_cleanup)
                 QApplication::postEvent (target, new VBoxEnumerateMediaEvent());
 
             COMBase::cleanupCOM();
-
             LogFlow (("MediaEnumThread finished.\n"));
         }
+
+    private:
+
+        VBoxMediaList &mList;
     };
 
-    media_enum_thread = new Thread();
+    media_enum_thread = new Thread (media_list);
     media_enum_thread->start();
+}
+
+/**
+ *  Adds a new media to the current media list.
+ *  @note Currently, this method does nothing but emits the mediaAdded() signal.
+ *        Later, it will be used to synchronize the current media list with
+ *        the actial media list on the server after a single media opetartion
+ *        performed from within one of our UIs.
+ *  @sa #currentMediaList()
+ */
+void VBoxGlobal::addMedia (const VBoxMedia &aMedia)
+{
+    emit mediaAdded (aMedia);
+}
+
+/**
+ *  Updates the media in the current media list.
+ *  @note Currently, this method does nothing but emits the mediaUpdated() signal.
+ *        Later, it will be used to synchronize the current media list with
+ *        the actial media list on the server after a single media opetartion
+ *        performed from within one of our UIs.
+ *  @sa #currentMediaList()
+ */
+void VBoxGlobal::updateMedia (const VBoxMedia &aMedia)
+{
+    emit mediaUpdated (aMedia);
+}
+
+/**
+ *  Removes the media from the current media list.
+ *  @note Currently, this method does nothing but emits the mediaRemoved() signal.
+ *        Later, it will be used to synchronize the current media list with
+ *        the actial media list on the server after a single media opetartion
+ *        performed from within one of our UIs.
+ *  @sa #currentMediaList()
+ */
+void VBoxGlobal::removeMedia (VBoxDefs::DiskType aType, const QUuid &aId)
+{
+    emit mediaRemoved (aType, aId);
 }
 
@@ -1357 +1429 @@
     AssertReturnVoid (aWidget);
     AssertReturnVoid (aWidget->isTopLevel());
-    
+
     QRect deskGeo, parentGeo;
     QWidget *w = aRelative;
@@ -1368 +1440 @@
          * widgets with parents, what a shame. Use mapToGlobal() to workaround. */
         QPoint d = w->mapToGlobal (QPoint (0, 0));
-        d.rx() -= w->geometry().x() - w->x(); 
-        d.ry() -= w->geometry().y() - w->y(); 
+        d.rx() -= w->geometry().x() - w->x();
+        d.ry() -= w->geometry().y() - w->y();
         parentGeo.moveTopLeft (d);
     }
@@ -1397 +1469 @@
         framew = current->frameGeometry().width() - current->width();
         frameh = current->frameGeometry().height() - current->height();
-    
+
         extraw = QMAX (extraw, framew);
         extrah = QMAX (extrah, frameh);
@@ -1413 +1485 @@
     }
 #endif
-    
+
     /* On non-X11 platforms, the following would be enough instead of the
-     * above workaround: */    
+     * above workaround: */
     // QRect geo = frameGeometry();
     QRect geo = QRect (0, 0, aWidget->width() + extraw,
@@ -1422 +1494 @@
     geo.moveCenter (QPoint (parentGeo.x() + (parentGeo.width() - 1) / 2,
                             parentGeo.y() + (parentGeo.height() - 1) / 2));
-    
+
     /* ensure the widget is within the available desktop area */
     QRect newGeo = normalizeGeometry (geo, deskGeo, aCanResize);
-    
+
     aWidget->move (newGeo.topLeft());
-    
+
     if (aCanResize &&
         (geo.width() != newGeo.width() || geo.height() != newGeo.height()))
@@ -1508 +1580 @@
         hund = hund * denom / 100;
         intg = intg * denom + hund;
-        return intg; 
+        return intg;
     }
     else
@@ -1527 +1599 @@
  *      digit number that is not greater than the result. This guarantees that
  *      converting the resulting string back to the integer value in bytes
- *      will not produce a value greater that the initial \a size parameter. 
+ *      will not produce a value greater that the initial \a size parameter.
  *  </li>
  *  <li>When \a mode is 1, the result is rounded to the smallest two decimal
  *      digit number that is not less than the result. This guarantees that
  *      converting the resulting string back to the integer value in bytes
- *      will not produce a value less that the initial \a size parameter. 
+ *      will not produce a value less that the initial \a size parameter.
  *  </li>
  *  </ul>
@@ -1543 +1615 @@
 QString VBoxGlobal::formatSize (Q_UINT64 aSize, int aMode /* = 0 */)
 {
-    static const char *Suffixes [] = { "B", "KB", "MB", "GB", "TB", "PB", NULL }; 
+    static const char *Suffixes [] = { "B", "KB", "MB", "GB", "TB", "PB", NULL };
 
     Q_UINT64 denom = 0;
@@ -1604 +1676 @@
             {
                 intg /= 1024;
-                ++ suffix; 
+                ++ suffix;
             }
         }
@@ -1614 +1686 @@
         number = QString::number (intg);
     }
-    
+
     return QString ("%1 %2").arg (number).arg (Suffixes [suffix]);
 }
@@ -1635 +1707 @@
 QString VBoxGlobal::highlight (const QString &aStr, bool aToolTip /* = false */)
 {
-    QString strFont; 
+    QString strFont;
     QString uuidFont;
     QString endFont;
@@ -1644 +1716 @@
         endFont = "</font>";
     }
-    
+
     QString text = aStr;
 
@@ -1682 +1754 @@
             VBoxEnumerateMediaEvent *ev = (VBoxEnumerateMediaEvent *) e;
 
-            if (!ev->last)
+            if (!ev->mLast)
             {
-                // gather all media to the list
-                media_list += ev->media;
-
-                if (ev->media.status == VBoxMedia::Error)
-                    vboxProblem().cannotGetMediaAccessibility (ev->media.disk);
-
-                emit mediaEnumerated (ev->media);
+                if (ev->mMedia.status == VBoxMedia::Error)
+                    vboxProblem().cannotGetMediaAccessibility (ev->mMedia.disk);
+                media_list [ev->mIndex] = ev->mMedia;
+                emit mediaEnumerated (media_list [ev->mIndex], ev->mIndex);
             }
             else
             {
-                // the thread has posted the last message, wait for termination
+                /* the thread has posted the last message, wait for termination */
                 media_enum_thread->wait();
                 delete media_enum_thread;
                 media_enum_thread = 0;
 
-                // this is the last event, clear the list (create a copy first)
-                VBoxMediaList list = media_list;
-                media_list.clear();
-
-                emit mediaEnumerated (list);
+                emit mediaEnumFinished (media_list);
             }
 
@@ -1709 +1774 @@
         }
 
-        // VirtualBox callback events
+        /* VirtualBox callback events */
 
         case VBoxDefs::MachineStateChangeEventType:

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

@@ -23 +23 @@
 #include "VBoxMediaComboBox.h"
 #include "VBoxDiskImageManagerDlg.h"
-#include "VBoxGlobal.h"
 
 #include <qfileinfo.h>
@@ -32 +31 @@
 #include <qlistbox.h>
 
-VBoxMediaComboBox::VBoxMediaComboBox (QWidget *aParent, const char *aName, int aType)
+VBoxMediaComboBox::VBoxMediaComboBox (QWidget *aParent, const char *aName,
+                                      int aType, bool aUseEmptyItem)
     : QComboBox (aParent , aName),
-    mType (aType), mRequiredId (QUuid()), mUseEmptyItem (false), mToBeRefreshed (false)
+    mType (aType), mRequiredId (QUuid()), mUseEmptyItem (aUseEmptyItem)
 {
     setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Fixed);
-    /* Media shortcuts creating */
-    connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMedia &)),
-             this, SLOT (mediaEnumerated (const VBoxMedia &)));
-    connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMediaList &)),
-             this, SLOT (listEnumerated (const VBoxMediaList &)));
+    /* setup enumeration handlers */
+    connect (&vboxGlobal(), SIGNAL (mediaEnumStarted()),
+             this, SLOT (mediaEnumStarted()));
+    connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMedia &, int)),
+             this, SLOT (mediaEnumerated (const VBoxMedia &, int)));
+    connect (&vboxGlobal(), SIGNAL (mediaEnumFinished (const VBoxMediaList &)),
+             this, SLOT (mediaEnumFinished (const VBoxMediaList &)));
+
+    /* setup update handlers */
+    connect (&vboxGlobal(), SIGNAL (mediaAdded (const VBoxMedia &)),
+             this, SLOT (mediaAdded (const VBoxMedia &)));
+    connect (&vboxGlobal(), SIGNAL (mediaUpdated (const VBoxMedia &)),
+             this, SLOT (mediaUpdated (const VBoxMedia &)));
+    connect (&vboxGlobal(), SIGNAL (mediaRemoved (VBoxDefs::DiskType, const QUuid &)),
+             this, SLOT (mediaRemoved (VBoxDefs::DiskType, const QUuid &)));
+
     connect (this, SIGNAL (activated (int)),
-             this, SLOT (updateToolTip (int)));
+             this, SLOT (processActivated (int)));
     connect (listBox(), SIGNAL (onItem (QListBoxItem*)),
              this, SLOT (processOnItem (QListBoxItem*)));
-}
-
-void VBoxMediaComboBox::loadCleanContent()
-{
-    CVirtualBox vbox = vboxGlobal().virtualBox();
-
-    switch (mType)
-    {
-        /* load hd list */
+
+    /* cache pixmaps as class members */
+    QImage img;
+    img = QMessageBox::standardIcon (QMessageBox::Warning).convertToImage();
+    if (!img.isNull())
+    {
+        img = img.smoothScale (14, 14);
+        mPmInacc.convertFromImage (img);
+    }
+    img = QMessageBox::standardIcon (QMessageBox::Critical).convertToImage();
+    if (!img.isNull())
+    {
+        img = img.smoothScale (14, 14);
+        mPmError.convertFromImage (img);
+    }
+
+    /* media shortcuts creating */
+    refresh();
+}
+
+void VBoxMediaComboBox::refresh()
+{
+    /* clearing lists */
+    clear(), mUuidList.clear(), mTipList.clear();
+    /* prepend empty item if used */
+    if (mUseEmptyItem)
+        appendItem (tr ("<no hard disk>"), QUuid(), tr ("No hard disk"), 0);
+    updateToolTip (currentItem());
+    /* load current media list */
+    VBoxMediaList list = vboxGlobal().currentMediaList();
+    VBoxMediaList::const_iterator it;
+    for (it = list.begin(); it != list.end(); ++ it)
+        mediaEnumerated (*it, 0);
+}
+
+
+void VBoxMediaComboBox::mediaEnumStarted()
+{
+    refresh();
+}
+
+void VBoxMediaComboBox::mediaEnumerated (const VBoxMedia &aMedia, int /*aIndex*/)
+{
+    processMedia (aMedia);
+}
+
+void VBoxMediaComboBox::mediaEnumFinished (const VBoxMediaList &/*aList*/)
+{
+    emit activated (currentItem());
+}
+
+
+void VBoxMediaComboBox::mediaAdded (const VBoxMedia &aMedia)
+{
+    processMedia (aMedia);
+}
+
+void VBoxMediaComboBox::mediaUpdated (const VBoxMedia &aMedia)
+{
+    processMedia (aMedia);
+}
+
+void VBoxMediaComboBox::mediaRemoved (VBoxDefs::DiskType aType,
+                                     const QUuid &aId)
+{
+    if (!(aType & mType))
+        return;
+
+    /* search & remove media */
+    int index = mUuidList.findIndex (aId);
+    if (index != -1)
+    {
+        removeItem (index);
+        mUuidList.remove (mUuidList.at (index));
+        mTipList.remove (mTipList.at (index));
+        updateToolTip (currentItem());
+    }
+}
+
+
+void VBoxMediaComboBox::processMedia (const VBoxMedia &aMedia)
+{
+    if (!(aMedia.type & mType))
+        return;
+
+    switch (aMedia.type)
+    {
         case VBoxDefs::HD:
-        {
-            CHardDiskEnumerator en = vbox.GetHardDisks().Enumerate();
-            while (en.HasMore())
-            {
-                QUuid mediaId;
-                QString toolTip;
-                CHardDisk hd = en.GetNext();
-                QString src = hd.GetLocation();
-                QUuid machineId = hd.GetMachineId();
-                /* append list only with free hd */
-                if (machineId.isNull() || machineId == mMachineId)
-                {
-                    mediaId = hd.GetId();
-                    toolTip = VBoxDiskImageManagerDlg::composeHdToolTip (hd, VBoxMedia::Unknown);
-                }
-                if (!mediaId.isNull()) updateMedia (src, mediaId, toolTip, VBoxMedia::Unknown);
-            }
+            processHdMedia (aMedia);
             break;
-        }
-        /* load cd list */
         case VBoxDefs::CD:
-        {
-            CDVDImageEnumerator en = vbox.GetDVDImages().Enumerate();
-            while (en.HasMore())
-            {
-                QUuid mediaId;
-                QString toolTip;
-                CDVDImage cd = en.GetNext();
-                QString src = cd.GetFilePath();
-                mediaId = cd.GetId();
-                toolTip = VBoxDiskImageManagerDlg::composeCdToolTip (cd, VBoxMedia::Unknown);
-                updateMedia (src, mediaId, toolTip, VBoxMedia::Unknown);
-            }
+            processCdMedia (aMedia);
             break;
-        }
-        /* load fd list */
         case VBoxDefs::FD:
-        {
-            CFloppyImageEnumerator en = vbox.GetFloppyImages().Enumerate();
-            while (en.HasMore())
-            {
-                QUuid mediaId;
-                QString toolTip;
-                CFloppyImage fd = en.GetNext();
-                QString src = fd.GetFilePath();
-                mediaId = fd.GetId();
-                toolTip = VBoxDiskImageManagerDlg::composeFdToolTip (fd, VBoxMedia::Unknown);
-                updateMedia (src, mediaId, toolTip, VBoxMedia::Unknown);
-            }
+            processFdMedia (aMedia);
             break;
-        }
         default:
             AssertFailed();
@@ -112 +158 @@
 }
 
-void VBoxMediaComboBox::mediaEnumerated (const VBoxMedia &aMedia)
-{
-    if (!mToBeRefreshed) return;
-    if (!(aMedia.type & mType))
-        return;
-
-    QString src;
-    QUuid   mediaId;
+void VBoxMediaComboBox::processHdMedia (const VBoxMedia &aMedia)
+{
+    QUuid mediaId;
     QString toolTip;
-
-    switch (aMedia.type)
-    {
-        case VBoxDefs::HD:
-        {
-            CHardDisk hd = aMedia.disk;
-            src = hd.GetLocation();
-            QUuid machineId = hd.GetMachineId();
-            /* append list only with free hd */
-            if (machineId.isNull() || machineId == mMachineId)
-            {
-                mediaId = hd.GetId();
-                toolTip = VBoxDiskImageManagerDlg::composeHdToolTip (hd, aMedia.status);
-            }
-            break;
-        }
-        case VBoxDefs::CD:
-        {
-            CDVDImage dvd = aMedia.disk;
-            src = dvd.GetFilePath();
-            mediaId = dvd.GetId();
-            toolTip = VBoxDiskImageManagerDlg::composeCdToolTip (dvd, aMedia.status);
-            break;
-        }
-        case VBoxDefs::FD:
-        {
-            CFloppyImage floppy = aMedia.disk;
-            src = floppy.GetFilePath();
-            mediaId = floppy.GetId();
-            toolTip = VBoxDiskImageManagerDlg::composeFdToolTip (floppy, aMedia.status);
-            break;
-        }
-        default:
-            AssertFailed();
-    }
-    int updatedMedia = -1;
+    CHardDisk hd = aMedia.disk;
+    QString src = hd.GetLocation();
+    QUuid machineId = hd.GetMachineId();
+    /* append list only with free hd */
+    if (machineId.isNull() || machineId == mMachineId)
+    {
+        mediaId = hd.GetId();
+        toolTip = VBoxDiskImageManagerDlg::composeHdToolTip (hd, aMedia.status);
+    }
     if (!mediaId.isNull())
-        updatedMedia = updateMedia (src, mediaId, toolTip, aMedia.status);
-    if (updatedMedia == -1) return;
-
-    /* update warning/error icons */
-    /// @todo (r=dmik) cache pixmaps as class members
-    QPixmap pixmap;
-    QImage img;
-    if (aMedia.status == VBoxMedia::Inaccessible)
-        img = QMessageBox::standardIcon (QMessageBox::Warning).convertToImage();
-    else if (aMedia.status == VBoxMedia::Error)
-        img = QMessageBox::standardIcon (QMessageBox::Critical).convertToImage();
-    if (!img.isNull())
-    {
-        img = img.smoothScale (14, 14);
-        pixmap.convertFromImage (img);
-    }
-    if (!pixmap.isNull())
-        changeItem (pixmap, text (updatedMedia), updatedMedia); 
-}
-
-int VBoxMediaComboBox::updateMedia (const QString &aSrc,
-                                    const QUuid   &aId,
-                                    const QString &aTip,
-                                    VBoxMedia::Status /* aStatus */)
-{
-    /* search & update media */
+        updateShortcut (src, mediaId, toolTip, aMedia.status);
+}
+
+void VBoxMediaComboBox::processCdMedia (const VBoxMedia &aMedia)
+{
+    CDVDImage dvd = aMedia.disk;
+    QString src = dvd.GetFilePath();
+    QUuid mediaId = dvd.GetId();
+    QString toolTip = VBoxDiskImageManagerDlg::composeCdToolTip (dvd, aMedia.status);
+    updateShortcut (src, mediaId, toolTip, aMedia.status);
+}
+
+void VBoxMediaComboBox::processFdMedia (const VBoxMedia &aMedia)
+{
+    CFloppyImage floppy = aMedia.disk;
+    QString src = floppy.GetFilePath();
+    QUuid mediaId = floppy.GetId();
+    QString toolTip = VBoxDiskImageManagerDlg::composeFdToolTip (floppy, aMedia.status);
+    updateShortcut (src, mediaId, toolTip, aMedia.status);
+}
+
+void VBoxMediaComboBox::updateShortcut (const QString &aSrc,
+                                        const QUuid &aId,
+                                        const QString &aTip,
+                                        VBoxMedia::Status aStatus)
+{
+    /* compose item's name */
     QFileInfo fi (aSrc);
-    int index = mUuidList.findIndex (aId);
     QString name = QString ("%1 (%2)").arg (fi.fileName())
                    .arg (QDir::convertSeparators (fi.dirPath()));
-    index == -1 ? appendItem (name, aId, aTip) : replaceItem (index, name, aTip);
+    /* update warning/error icons */
+    QPixmap *pixmap = 0;
+    if (aStatus == VBoxMedia::Inaccessible)
+        pixmap = &mPmInacc;
+    else if (aStatus == VBoxMedia::Error)
+        pixmap = &mPmError;
+
+    /* search media */
+    int index = mUuidList.findIndex (aId);
+    /* create or update media */
+    if (index == -1)
+        appendItem (name, aId, aTip, pixmap);
+    else
+        replaceItem (index, name, aTip, pixmap);
+
     if (aId == mRequiredId)
     {
         int activatedItem = index == -1 ? count() - 1 : index;
         setCurrentItem (activatedItem);
-        emit activated (activatedItem);
-    }
-    else
-        updateToolTip (currentItem());
-    return index == -1 ? count() - 1 : index;
-}
-
-void VBoxMediaComboBox::listEnumerated (const VBoxMediaList & /*aList*/)
-{
-    emit activated (currentItem());
-    mToBeRefreshed = false;
+    }
+}
+
+void VBoxMediaComboBox::processActivated (int aItem)
+{
+    mRequiredId = QUuid (mUuidList [aItem]);
+    updateToolTip (aItem);
 }
 
@@ -210 +234 @@
     /* combobox tooltip attaching */
     QToolTip::remove (this);
-    QToolTip::add (this, mTipList [aItem]);
+    if (!mTipList.isEmpty())
+        QToolTip::add (this, mTipList [aItem]);
 }
 
@@ -221 +246 @@
 }
 
-void VBoxMediaComboBox::setReadyForRefresh()
-{
-    mToBeRefreshed = true;
-    /* clearing media combobox */
-    clear(), mUuidList.clear(), mTipList.clear();
-    /* prepend empty item if used */
-    if (mUseEmptyItem)
-        appendItem (tr ("<no hard disk>"), QUuid(), tr ("No hard disk"));
-    /* load all non-enumerated shortcuts */
-    if (!vboxGlobal().isInEnumeratingProcess()) loadCleanContent();
-    /* update already enumerated shortcuts */
-    VBoxMediaList list = vboxGlobal().currentMediaList();
-    for (VBoxMediaList::const_iterator it = list.begin(); it != list.end(); ++ it)
-        mediaEnumerated (*it);
-}
-
-void VBoxMediaComboBox::refresh()
-{
-    if (mToBeRefreshed) return;
-    setReadyForRefresh();
-    vboxGlobal().startEnumeratingMedia();
-}
-
 QUuid VBoxMediaComboBox::getId()
 {
@@ -251 +253 @@
 void VBoxMediaComboBox::appendItem (const QString &aName,
                                     const QUuid   &aId,
-                                    const QString &aTip)
-{
-    insertItem (aName);
+                                    const QString &aTip,
+                                    QPixmap       *aPixmap)
+{
+    aPixmap ? insertItem (*aPixmap, aName) : insertItem (aName);
     mUuidList << aId;
     mTipList  << aTip;
 }
 
-void VBoxMediaComboBox::replaceItem (int aNumber,
+void VBoxMediaComboBox::replaceItem (int            aNumber,
                                      const QString &aName,
-                                     const QString &aTip)
-{
-    changeItem (aName, aNumber);
+                                     const QString &aTip,
+                                     QPixmap       *aPixmap)
+{
+    aPixmap ? changeItem (*aPixmap, aName, aNumber) : changeItem (aName, aNumber);
     mTipList [aNumber] = aTip;
 }
 
-void VBoxMediaComboBox::removeLastItem()
-{
-    if (count())
-        removeItem (count() - 1);
-    mUuidList.pop_back();
-    mTipList.pop_back();
-}
-
-void VBoxMediaComboBox::setRequiredItem (const QUuid &aId)
+void VBoxMediaComboBox::setUseEmptyItem (bool aUseEmptyItem)
+{
+    mUseEmptyItem = aUseEmptyItem;
+}
+
+void VBoxMediaComboBox::setBelongsTo (const QUuid &aMachineId)
+{
+    mMachineId = aMachineId;
+}
+
+QUuid VBoxMediaComboBox::getBelongsTo()
+{
+    return mMachineId;
+}
+
+void VBoxMediaComboBox::setCurrentItem (int aIndex)
+{
+    QComboBox::setCurrentItem (aIndex);
+    emit activated (aIndex);
+}
+
+void VBoxMediaComboBox::setCurrentItem (const QUuid &aId)
 {
     mRequiredId = aId;
-}
-
-void VBoxMediaComboBox::setUseEmptyItem (bool aUseEmptyItem)
-{
-    mUseEmptyItem = aUseEmptyItem;
-}
-
-void VBoxMediaComboBox::setBelongsTo (const QUuid &aMachineId)
-{
-    mMachineId = aMachineId;
-}
-
-QUuid VBoxMediaComboBox::getBelongsTo()
-{
-    return mMachineId;
-}
-
-void VBoxMediaComboBox::setCurrentItem (int aIndex)
-{
-    QComboBox::setCurrentItem (aIndex);
-    updateToolTip (aIndex);
-}
+    int index = mUuidList.findIndex (mRequiredId);
+    if (index != -1)
+        setCurrentItem (index);
+}

trunk/src/VBox/Frontends/VirtualBox/src/VBoxSelectorWnd.cpp

@@ -415 +415 @@
 
     /* listen to "media enumeration finished" signals */
-    connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMediaList &)),
-             this, SLOT (mediaEnumerated (const VBoxMediaList &)));
+    connect (&vboxGlobal(), SIGNAL (mediaEnumFinished (const VBoxMediaList &)),
+             this, SLOT (mediaEnumFinished (const VBoxMediaList &)));
 
     /* connect VirtualBox callback events */
@@ -956 +956 @@
 }
 
-void VBoxSelectorWnd::mediaEnumerated (const VBoxMediaList &list)
+void VBoxSelectorWnd::mediaEnumFinished (const VBoxMediaList &list)
 {
     /* refresh the current details to pick up hard disk sizes */
@@ -992 +992 @@
      * emumeration started from main() at startup), and then disconnect
      * to avoid annoying the user */
-    disconnect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMediaList &)),
-                this, SLOT (mediaEnumerated (const VBoxMediaList &)));
+    disconnect (&vboxGlobal(), SIGNAL (mediaEnumFinished (const VBoxMediaList &)),
+                this, SLOT (mediaEnumFinished (const VBoxMediaList &)));
 }
 

trunk/src/VBox/Frontends/VirtualBox/ui/VBoxDiskImageManagerDlg.ui

@@ -562 +562 @@
     <variable>QPushButton *defaultButton;</variable>
     <variable access="private">static VBoxDiskImageManagerDlg *mModelessDialog;</variable>
-    <variable access="private">bool mToBeRefreshed;</variable>
     <variable access="private">QProgressBar *mProgressBar;</variable>
     <variable access="private">QLabel *mProgressText;</variable>
+    <variable access="private">QUuid hdSelectedId;</variable>
+    <variable access="private">QUuid cdSelectedId;</variable>
+    <variable access="private">QUuid fdSelectedId;</variable>
 </variables>
 <slots>
-    <slot access="protected">mediaEnumerated( const VBoxMedia &amp; media )</slot>
-    <slot access="protected">mediaEnumerated( const VBoxMediaList &amp; )</slot>
+    <slot access="protected">mediaEnumStarted()</slot>
+    <slot access="protected">mediaEnumerated( const VBoxMedia &amp;, int )</slot>
+    <slot access="protected">mediaEnumFinished( const VBoxMediaList &amp; )</slot>
+    <slot access="protected">mediaAdded( const VBoxMedia &amp; )</slot>
+    <slot access="protected">mediaUpdated( const VBoxMedia &amp; )</slot>
+    <slot access="protected">mediaRemoved( VBoxDefs::DiskType, const QUuid &amp; )</slot>
     <slot access="protected">machineStateChanged( const VBoxMachineStateChangeEvent &amp; )</slot>
     <slot>refreshAll()</slot>
@@ -586 +592 @@
 <functions>
     <function access="private">init()</function>
-    <function access="private">loadListViews()</function>
     <function access="private" returnType="int">result()</function>
     <function access="private">setResult( int )</function>
     <function returnType="int">exec()</function>
     <function access="private">done( int )</function>
-    <function access="private">updateMedia( const VBoxMedia &amp; media )</function>
-    <function access="private" returnType="DiskImageItem*">searchItem( QListView*, QUuid )</function>
+    <function access="private" returnType="DiskImageItem*">searchItem( QListView*, const QUuid &amp; )</function>
     <function specifier="non virtual" access="private" returnType="QString">static getDVDImageUsage( const QUuid &amp; id )</function>
     <function specifier="non virtual" access="private" returnType="QString">static getFloppyImageUsage( const QUuid &amp; id )</function>
@@ -601 +605 @@
     <function>setup( int aType, bool aDoSelect, const QUuid *aTargetVMId = NULL, const VBoxMediaList *mediaList = NULL, CMachine machine = 0 )</function>
     <function access="private" returnType="QListView*">getCurrentListView()</function>
+    <function access="private" returnType="QListView*">getListView( VBoxDefs::DiskType )</function>
     <function returnType="bool">eventFilter( QObject *, QEvent * )</function>
     <function access="private">addDroppedImages( QStringList* )</function>
-    <function access="private" returnType="DiskImageItem*">addImageToList( QString aSource, VBoxDefs::DiskType aDiskType )</function>
-    <function access="private" returnType="DiskImageItem*">createImageNode( QListView *aList, DiskImageItem *aRoot, QString aName, QString aLabel1 = QString::null, QString aLabel2 = QString::null, QString aLabel3 = QString::null, QString aLabel4 = QString::null, QString aLabel5 = QString::null, QString aLabel6 = QString::null, QString aLabel7 = QString::null )</function>
-    <function access="private" returnType="DiskImageItem*">createHdItem( QListView*, DiskImageItem*, CHardDisk &amp;, VBoxMedia::Status )</function>
-    <function access="private" returnType="DiskImageItem*">createCdItem( QListView*, DiskImageItem*, CDVDImage &amp;, VBoxMedia::Status )</function>
-    <function access="private" returnType="DiskImageItem*">createFdItem( QListView*, DiskImageItem*, CFloppyImage &amp;, VBoxMedia::Status )</function>
-    <function access="private">createHdChildren( DiskImageItem*, CHardDisk &amp;, VBoxMedia::Status )</function>
+    <function access="private">addImageToList( QString aSource, VBoxDefs::DiskType aDiskType )</function>
+    <function access="private" returnType="DiskImageItem*">createImageNode( QListView *aList, DiskImageItem *aRoot )</function>
+    <function access="private">updateHdItem( DiskImageItem*, const VBoxMedia &amp; )</function>
+    <function access="private">updateCdItem( DiskImageItem*, const VBoxMedia &amp; )</function>
+    <function access="private">updateFdItem( DiskImageItem*, const VBoxMedia &amp; )</function>
+    <function access="private" returnType="DiskImageItem*">createHdItem( QListView*, DiskImageItem*, const VBoxMedia &amp; )</function>
+    <function access="private" returnType="DiskImageItem*">createCdItem( QListView*, DiskImageItem*, const VBoxMedia &amp; )</function>
+    <function access="private" returnType="DiskImageItem*">createFdItem( QListView*, DiskImageItem*, const VBoxMedia &amp; )</function>
+    <function access="private">createHdChildren( DiskImageItem*, const VBoxMedia &amp; )</function>
     <function access="protected">showEvent( QShowEvent * )</function>
     <function access="protected">resizeEvent( QResizeEvent* )</function>
@@ -620 +628 @@
     <function specifier="non virtual" returnType="QString">static composeCdToolTip( CDVDImage &amp;, VBoxMedia::Status = VBoxMedia::Ok )</function>
     <function specifier="non virtual" returnType="QString">static composeFdToolTip( CFloppyImage &amp;, VBoxMedia::Status = VBoxMedia::Ok )</function>
-    <function access="protected">prepareToRefresh()</function>
+    <function access="protected">prepareToRefresh( int aTotal = 0 )</function>
 </functions>
 <layoutdefaults spacing="10" margin="10"/>

trunk/src/VBox/Frontends/VirtualBox/ui/VBoxDiskImageManagerDlg.ui.h

@@ -35 +35 @@
 public:
 
-    DiskImageItem (DiskImageItem *parent, QString aLabel1,
-                   QString aLabel2 = QString::null,
-                   QString aLabel3 = QString::null,
-                   QString aLabel4 = QString::null,
-                   QString aLabel5 = QString::null,
-                   QString aLabel6 = QString::null,
-                   QString aLabel7 = QString::null,
-                   QString aLabel8 = QString::null) :
-        QListViewItem (parent, aLabel1, aLabel2, aLabel3, aLabel4, aLabel5,
-                       aLabel6, aLabel7, aLabel8),
-        mName (aLabel1), mStatus (VBoxMedia::Unknown) {}
-
-    DiskImageItem (QListView *parent, QString aLabel1,
-                   QString aLabel2 = QString::null,
-                   QString aLabel3 = QString::null,
-                   QString aLabel4 = QString::null,
-                   QString aLabel5 = QString::null,
-                   QString aLabel6 = QString::null,
-                   QString aLabel7 = QString::null,
-                   QString aLabel8 = QString::null) :
-        QListViewItem (parent, aLabel1, aLabel2, aLabel3, aLabel4, aLabel5,
-                       aLabel6, aLabel7, aLabel8),
-        mName (aLabel1), mStatus (VBoxMedia::Unknown) {}
+    DiskImageItem (DiskImageItem *parent) :
+        QListViewItem (parent), mStatus (VBoxMedia::Unknown) {}
+
+    DiskImageItem (QListView *parent) :
+        QListViewItem (parent), mStatus (VBoxMedia::Unknown) {}
 
     QString getName() { return mName; }
@@ -179 +161 @@
         /// @todo refreshAll() may be slow, so it may be better to analyze
         //  event details and update only what is changed */
-        //connect (&vboxGlobal(), SIGNAL (machineDataChanged (const VBoxMachineDataChangeEvent &)),
-        //         mModelessDialog, SLOT (refreshAll()));
+        connect (&vboxGlobal(), SIGNAL (machineDataChanged (const VBoxMachineDataChangeEvent &)),
+                 mModelessDialog, SLOT (refreshAll()));
         connect (&vboxGlobal(), SIGNAL (machineRegistered (const VBoxMachineRegisteredEvent &)),
                  mModelessDialog, SLOT (refreshAll()));
         connect (&vboxGlobal(), SIGNAL (snapshotChanged (const VBoxSnapshotEvent &)),
                  mModelessDialog, SLOT (refreshAll()));
-
-        /* listen also to the machine state change because hard disks of running
-         * VMs are inaccessible by the current design */
-        connect (&vboxGlobal(), SIGNAL (machineStateChanged (const VBoxMachineStateChangeEvent &)),
-                 mModelessDialog, SLOT (machineStateChanged (const VBoxMachineStateChangeEvent &)));
     }
 
@@ -203 +180 @@
     polished = false;
 
-    mToBeRefreshed = false;
     mInLoop = false;
 
@@ -415 +391 @@
     mProgressBar->setMaximumWidth (100);
     buttonLayout->insertWidget (3, mProgressBar);
-
-    if (!vboxGlobal().isInEnumeratingProcess()) loadListViews();
-}
-
-
-void VBoxDiskImageManagerDlg::loadListViews()
-{
-    /* load hd list */
-    CHardDiskEnumerator hdEnum = vbox.GetHardDisks().Enumerate();
-    while (hdEnum.HasMore())
-    {
-        CHardDisk hd = hdEnum.GetNext();
-        DiskImageItem *item = createHdItem (hdsView, 0, hd, VBoxMedia::Unknown);
-        createHdChildren (item, hd, VBoxMedia::Unknown);
-    }
-
-    /* load cd list */
-    CDVDImageEnumerator cdEnum = vbox.GetDVDImages().Enumerate();
-    while (cdEnum.HasMore())
-    {
-        CDVDImage cd = cdEnum.GetNext();
-        DiskImageItem *item = createCdItem (cdsView, 0, cd, VBoxMedia::Unknown);
-        NOREF(item);
-    }
-
-    /* load fd list */
-    CFloppyImageEnumerator fdEnum = vbox.GetFloppyImages().Enumerate();
-    while (fdEnum.HasMore())
-    {
-        CFloppyImage fd = fdEnum.GetNext();
-        DiskImageItem *item = createFdItem (fdsView, 0, fd, VBoxMedia::Unknown);
-        NOREF(item);
-    }
 }
 
@@ -621 +564 @@
 }
 
+QListView* VBoxDiskImageManagerDlg::getListView (VBoxDefs::DiskType aType)
+{
+    switch (aType)
+    {
+        case VBoxDefs::HD:
+            return hdsView;
+        case VBoxDefs::CD:
+            return cdsView;
+        case VBoxDefs::FD:
+            return fdsView;
+        default:
+            return 0;
+    }
+}
+
 
 bool VBoxDiskImageManagerDlg::eventFilter (QObject *aObject, QEvent *aEvent)
@@ -697 +655 @@
     QListView *currentList = getCurrentListView();
 
-    DiskImageItem *item = 0;
     for (QStringList::Iterator it = (*aDroppedList).begin();
          it != (*aDroppedList).end(); ++it)
@@ -716 +673 @@
         }
         // If media type has been determined - attach this device
-        if (type) item = addImageToList (*it, type);
+        if (type) addImageToList (*it, type);
     }
     delete aDroppedList;
-    setCurrentItem (currentList, item);
-}
-
-
-DiskImageItem* VBoxDiskImageManagerDlg::addImageToList (QString aSource, VBoxDefs::DiskType aDiskType)
+}
+
+
+void VBoxDiskImageManagerDlg::addImageToList (QString aSource,
+                                              VBoxDefs::DiskType aDiskType)
 {
     if (aSource.isEmpty())
-        return 0;
-
-    DiskImageItem *item = 0;
+        return;
+
     QUuid uuid;
+    VBoxMedia media;
     switch (aDiskType)
     {
@@ -737 +694 @@
             if (vbox.isOk())
             {
-                CHardDisk hardDisk = CUnknown (vdi);
-                vbox.RegisterHardDisk (hardDisk);
+                CHardDisk hd = CUnknown (vdi);
+                vbox.RegisterHardDisk (hd);
                 if (vbox.isOk())
                 {
-                    VBoxMedia::Status status = hardDisk.GetAccessible() ?
-                        VBoxMedia::Ok : VBoxMedia::Inaccessible;
-                    item = createHdItem (hdsView, 0, hardDisk, status);
-                    /* synchronize modeless dialog if present */
-                    if (mModelessDialog && mModelessDialog != this)
-                        mModelessDialog->createHdItem (mModelessDialog->hdsView,
-                                                       0, hardDisk, status);
+                    VBoxMedia::Status status =
+                        hd.GetAccessible() ? VBoxMedia::Ok :
+                        hd.isOk() ? VBoxMedia::Inaccessible :
+                        VBoxMedia::Error;
+                    media = VBoxMedia (CUnknown (hd), VBoxDefs::HD, status);
                 }
             }
@@ -754 +709 @@
         case VBoxDefs::CD:
         {
-            CDVDImage dvdImage = vbox.OpenDVDImage (aSource, uuid);
+            CDVDImage cd = vbox.OpenDVDImage (aSource, uuid);
             if (vbox.isOk())
             {
-                vbox.RegisterDVDImage (dvdImage);
+                vbox.RegisterDVDImage (cd);
                 if (vbox.isOk())
                 {
-                    VBoxMedia::Status status = dvdImage.GetAccessible() ?
-                        VBoxMedia::Ok : VBoxMedia::Inaccessible;
-                    item = createCdItem (cdsView, 0, dvdImage, status);
-                    /* synchronize modeless dialog if present */
-                    if (mModelessDialog && mModelessDialog != this)
-                        mModelessDialog->createCdItem (mModelessDialog->cdsView,
-                                                       0, dvdImage, status);
+                    VBoxMedia::Status status =
+                        cd.GetAccessible() ? VBoxMedia::Ok :
+                        cd.isOk() ? VBoxMedia::Inaccessible :
+                        VBoxMedia::Error;
+                    media = VBoxMedia (CUnknown (cd), VBoxDefs::CD, status);
                 }
             }
@@ -773 +726 @@
         case VBoxDefs::FD:
         {
-            CFloppyImage floppyImage = vbox.OpenFloppyImage (aSource, uuid);
+            CFloppyImage fd = vbox.OpenFloppyImage (aSource, uuid);
             if (vbox.isOk())
             {
-                vbox.RegisterFloppyImage (floppyImage);
+                vbox.RegisterFloppyImage (fd);
                 if (vbox.isOk())
                 {
-                    VBoxMedia::Status status = floppyImage.GetAccessible() ?
-                        VBoxMedia::Ok : VBoxMedia::Inaccessible;
-                    item = createFdItem (fdsView, 0, floppyImage, status);
-                    /* synchronize modeless dialog if present */
-                    if (mModelessDialog && mModelessDialog != this)
-                        mModelessDialog->createFdItem (mModelessDialog->fdsView,
-                                                       0, floppyImage, status);
+                    VBoxMedia::Status status =
+                        fd.GetAccessible() ? VBoxMedia::Ok :
+                        fd.isOk() ? VBoxMedia::Inaccessible :
+                        VBoxMedia::Error;
+                    media = VBoxMedia (CUnknown (fd), VBoxDefs::FD, status);
                 }
             }
@@ -791 +742 @@
         }
         default:
-        {
-            Assert(0);
-        }
-    }
-    return item;
+            AssertMsgFailed (("Invalid aDiskType type\n"));
+    }
+    if (media.type != VBoxDefs::InvalidType)
+        vboxGlobal().addMedia (media);
 }
 
 
 DiskImageItem* VBoxDiskImageManagerDlg::createImageNode (QListView *aList,
-                                                         DiskImageItem *aRoot,
-                                                         QString aName,
-                                                         QString aLabel2,
-                                                         QString aLabel3,
-                                                         QString aLabel4,
-                                                         QString aLabel5,
-                                                         QString aLabel6,
-                                                         QString aLabel7,
-                                                         QString aLabel8)
+                                                         DiskImageItem *aRoot)
 {
     DiskImageItem *item = 0;
 
     if (aList)
-        item = new DiskImageItem (aList, aName,
-            aLabel2, aLabel3, aLabel4, aLabel5, aLabel6, aLabel7, aLabel8);
+        item = new DiskImageItem (aList);
     else if (aRoot)
-        item = new DiskImageItem (aRoot, aName,
-            aLabel2, aLabel3, aLabel4, aLabel5, aLabel6, aLabel7, aLabel8);
+        item = new DiskImageItem (aRoot);
     else
-        Assert(0);
+        Assert (0);
 
     return item;
@@ -1101 +1041 @@
 
 
-DiskImageItem* VBoxDiskImageManagerDlg::createHdItem (QListView *aList,
-                                                      DiskImageItem *aRoot,
-                                                      CHardDisk &aHd,
-                                                      VBoxMedia::Status aStatus)
-{
-    DiskImageItem *item = 0;
-
-    QUuid uuid = aHd.GetId();
-    QString src = aHd.GetLocation();
-    QUuid machineId = aHd.GetMachineId();
-
+void VBoxDiskImageManagerDlg::updateHdItem (DiskImageItem   *aItem,
+                                            const VBoxMedia &aMedia)
+{
+    CHardDisk hd = aMedia.disk;
+    VBoxMedia::Status status = aMedia.status;
+
+    QUuid uuid = hd.GetId();
+    QString src = hd.GetLocation();
+    QUuid machineId = hd.GetMachineId();
     QString usage;
     if (!machineId.isNull())
         usage = vbox.GetMachine (machineId).GetName();
-    QString storageType = vboxGlobal().toString (aHd.GetStorageType());
-    QString hardDiskType = vboxGlobal().hardDiskTypeString (aHd);
-    QString virtualSize = aStatus == VBoxMedia::Ok ?
-        vboxGlobal().formatSize ((ULONG64)aHd.GetSize() * _1M) : QString ("--");
-    QString actualSize = aStatus == VBoxMedia::Ok ?
-        vboxGlobal().formatSize (aHd.GetActualSize()) : QString ("--");
+    QString storageType = vboxGlobal().toString (hd.GetStorageType());
+    QString hardDiskType = vboxGlobal().hardDiskTypeString (hd);
+    QString virtualSize = status == VBoxMedia::Ok ?
+        vboxGlobal().formatSize ((ULONG64)hd.GetSize() * _1M) : QString ("--");
+    QString actualSize = status == VBoxMedia::Ok ?
+        vboxGlobal().formatSize (hd.GetActualSize()) : QString ("--");
     QString snapshotName;
-    if (!machineId.isNull() && !aHd.GetSnapshotId().isNull())
+    if (!machineId.isNull() && !hd.GetSnapshotId().isNull())
     {
         CSnapshot snapshot = vbox.GetMachine (machineId).
-                                  GetSnapshot (aHd.GetSnapshotId());
+                                  GetSnapshot (hd.GetSnapshotId());
         if (!snapshot.isNull())
             snapshotName = QString ("%1").arg (snapshot.GetName());
@@ -1131 +1069 @@
     QFileInfo fi (src);
 
-    item = createImageNode (aList, aRoot,
-                            fi.fileName(),
-                            virtualSize,
-                            actualSize);
-    item->setPath (aHd.GetStorageType() == CEnums::ISCSIHardDisk ? src :
+    aItem->setText (0, fi.fileName());
+    aItem->setText (1, virtualSize);
+    aItem->setText (2, actualSize);
+    aItem->setPath (hd.GetStorageType() == CEnums::ISCSIHardDisk ? src :
                    QDir::convertSeparators (fi.absFilePath()));
-    item->setUsage (usage);
-    item->setSnapshotName (snapshotName);
-    item->setDiskType (hardDiskType);
-    item->setStorageType (storageType);
-    item->setVirtualSize (virtualSize);
-    item->setActualSize (actualSize);
-    item->setUuid (uuid);
-    item->setMachineId (machineId);
-    item->setToolTip (composeHdToolTip (aHd, aStatus));
-    item->setStatus (aStatus);
-
+    aItem->setUsage (usage);
+    aItem->setSnapshotName (snapshotName);
+    aItem->setDiskType (hardDiskType);
+    aItem->setStorageType (storageType);
+    aItem->setVirtualSize (virtualSize);
+    aItem->setActualSize (actualSize);
+    aItem->setUuid (uuid);
+    aItem->setMachineId (machineId);
+    aItem->setToolTip (composeHdToolTip (hd, status));
+    aItem->setStatus (status);
+
+    if (aMedia.status == VBoxMedia::Inaccessible)
+        aItem->setPixmap (0, pxInaccessible);
+    else if (aMedia.status == VBoxMedia::Error)
+        aItem->setPixmap (0, pxErroneous);
+}
+
+void VBoxDiskImageManagerDlg::updateCdItem (DiskImageItem   *aItem,
+                                            const VBoxMedia &aMedia)
+{
+    CDVDImage cd = aMedia.disk;
+    VBoxMedia::Status status = aMedia.status;
+
+    QUuid uuid = cd.GetId();
+    QString src = cd.GetFilePath();
+    QString usage = getDVDImageUsage (uuid);
+    QString size = status == VBoxMedia::Ok ?
+        vboxGlobal().formatSize (cd.GetSize()) : QString ("--");
+    QFileInfo fi (src);
+
+    aItem->setText (0, fi.fileName());
+    aItem->setText (1, size);
+    aItem->setPath (QDir::convertSeparators (fi.absFilePath ()));
+    aItem->setUsage (usage);
+    aItem->setActualSize (size);
+    aItem->setUuid (uuid);
+    aItem->setToolTip (composeCdToolTip (cd, status));
+    aItem->setStatus (status);
+
+    if (aMedia.status == VBoxMedia::Inaccessible)
+        aItem->setPixmap (0, pxInaccessible);
+    else if (aMedia.status == VBoxMedia::Error)
+        aItem->setPixmap (0, pxErroneous);
+}
+
+void VBoxDiskImageManagerDlg::updateFdItem (DiskImageItem   *aItem,
+                                            const VBoxMedia &aMedia)
+{
+    CFloppyImage fd = aMedia.disk;
+    VBoxMedia::Status status = aMedia.status;
+
+    QUuid uuid = fd.GetId();
+    QString src = fd.GetFilePath();
+    QString usage = getFloppyImageUsage (uuid);
+    QString size = status == VBoxMedia::Ok ?
+        vboxGlobal().formatSize (fd.GetSize()) : QString ("--");
+    QFileInfo fi (src);
+
+    aItem->setText (0, fi.fileName());
+    aItem->setText (1, size);
+    aItem->setPath (QDir::convertSeparators (fi.absFilePath ()));
+    aItem->setUsage (usage);
+    aItem->setActualSize (size);
+    aItem->setUuid (uuid);
+    aItem->setToolTip (composeFdToolTip (fd, status));
+    aItem->setStatus (status);
+
+    if (aMedia.status == VBoxMedia::Inaccessible)
+        aItem->setPixmap (0, pxInaccessible);
+    else if (aMedia.status == VBoxMedia::Error)
+        aItem->setPixmap (0, pxErroneous);
+}
+
+
+DiskImageItem* VBoxDiskImageManagerDlg::createHdItem (QListView       *aList,
+                                                      DiskImageItem   *aRoot,
+                                                      const VBoxMedia &aMedia)
+{
+    DiskImageItem *item = createImageNode (aList, aRoot);
+    updateHdItem (item, aMedia);
+    createHdChildren (item, aMedia);
     return item;
 }
 
-
-DiskImageItem* VBoxDiskImageManagerDlg::createCdItem (QListView *aList,
-                                                      DiskImageItem *aRoot,
-                                                      CDVDImage &aCd,
-                                                      VBoxMedia::Status aStatus)
-{
-    DiskImageItem *item = 0;
-
-    QUuid uuid = aCd.GetId();
-    QString src = aCd.GetFilePath();
-    QString usage = getDVDImageUsage (uuid);
-
-    QString size = aStatus == VBoxMedia::Ok ?
-        vboxGlobal().formatSize (aCd.GetSize()) : QString ("--");
-    QFileInfo fi (src);
-
-    item = createImageNode (aList, aRoot,
-                            fi.fileName(),
-                            size);
-    item->setPath (QDir::convertSeparators (fi.absFilePath ()));
-    item->setUsage (usage);
-    item->setActualSize (size);
-    item->setUuid (uuid);
-    item->setToolTip (composeCdToolTip (aCd, aStatus));
-    item->setStatus (aStatus);
-
+DiskImageItem* VBoxDiskImageManagerDlg::createCdItem (QListView       *aList,
+                                                      DiskImageItem   *aRoot,
+                                                      const VBoxMedia &aMedia)
+{
+    DiskImageItem *item = createImageNode (aList, aRoot);
+    updateCdItem (item, aMedia);
     return item;
 }
 
-
-DiskImageItem* VBoxDiskImageManagerDlg::createFdItem (QListView *aList,
-                                                      DiskImageItem *aRoot,
-                                                      CFloppyImage &aFd,
-                                                      VBoxMedia::Status aStatus)
-{
-    DiskImageItem *item = 0;
-
-    QUuid uuid = aFd.GetId();
-    QString src = aFd.GetFilePath();
-    QString usage = getFloppyImageUsage (uuid);
-
-    QString size = aStatus == VBoxMedia::Ok ?
-        vboxGlobal().formatSize (aFd.GetSize()) : QString ("--");
-    QFileInfo fi (src);
-
-    item = createImageNode (aList, aRoot,
-                            fi.fileName(),
-                            size);
-    item->setPath (QDir::convertSeparators (fi.absFilePath ()));
-    item->setUsage (usage);
-    item->setActualSize (size);
-    item->setUuid (uuid);
-    item->setToolTip (composeFdToolTip (aFd, aStatus));
-    item->setStatus (aStatus);
-
+DiskImageItem* VBoxDiskImageManagerDlg::createFdItem (QListView       *aList,
+                                                      DiskImageItem   *aRoot,
+                                                      const VBoxMedia &aMedia)
+{
+    DiskImageItem *item = createImageNode (aList, aRoot);
+    updateFdItem (item, aMedia);
     return item;
 }
 
-
-void VBoxDiskImageManagerDlg::createHdChildren (DiskImageItem *aRoot,
-                                                CHardDisk &aHd,
-                                                VBoxMedia::Status aStatus)
-{
-    CHardDiskEnumerator enumerator = aHd.GetChildren().Enumerate();
+void VBoxDiskImageManagerDlg::createHdChildren (DiskImageItem   *aRoot,
+                                                const VBoxMedia &aMedia)
+{
+    CHardDisk hd = aMedia.disk;
+    CHardDiskEnumerator enumerator = hd.GetChildren().Enumerate();
     while (enumerator.HasMore())
     {
         CHardDisk subHd = enumerator.GetNext();
-        DiskImageItem *subItem = createHdItem (0, aRoot, subHd, aStatus);
-        createHdChildren (subItem, subHd, aStatus);
-    }
-}
-
-
-DiskImageItem* VBoxDiskImageManagerDlg::searchItem (QListView *aList, QUuid aId)
+        VBoxMedia::Status status =
+            subHd.GetAccessible() == TRUE ? VBoxMedia::Ok :
+            subHd.isOk() ? VBoxMedia::Inaccessible :
+            VBoxMedia::Error;
+        const VBoxMedia media (CUnknown (subHd), VBoxDefs::HD, status);
+        createHdItem (0, aRoot, media);
+    }
+}
+
+
+DiskImageItem* VBoxDiskImageManagerDlg::searchItem (QListView *aList,
+                                                    const QUuid &aId)
 {
     DiskImageItem *item = 0, *iterator = 0;
@@ -1239 +1210 @@
 
 
-void VBoxDiskImageManagerDlg::updateMedia (const VBoxMedia &aMedia)
-{
-    /* ignore non-updated aMedia */
-    if (!(type & aMedia.type))
-        return;
-
-    /* search for updated listview item */
-    DiskImageItem *item = 0;
-    switch (aMedia.type)
-    {
-        case VBoxDefs::HD:
-        {
-            CHardDisk hd = aMedia.disk;
-            item = searchItem (hdsView, hd.GetId());
-            delete item;
-            item = createHdItem (hdsView, 0, hd, aMedia.status);
-            createHdChildren (item, hd, aMedia.status);
-            break;
-        }
-        case VBoxDefs::CD:
-        {
-            CDVDImage cd = aMedia.disk;
-            item = searchItem (cdsView, cd.GetId());
-            delete item;
-            item = createCdItem (cdsView, 0, cd, aMedia.status);
-            break;
-        }
-        case VBoxDefs::FD:
-        {
-            CFloppyImage fd = aMedia.disk;
-            item = searchItem (fdsView, fd.GetId());
-            delete item;
-            item = createFdItem (fdsView, 0, fd, aMedia.status);
-            break;
-        }
-        default:
-        {
-            AssertMsgFailed (("Invalid aMedia type\n"));
-            break;
-        }
-    }
-
-    if (aMedia.status == VBoxMedia::Inaccessible)
-        item->setPixmap (0, pxInaccessible);
-    else if (aMedia.status == VBoxMedia::Error)
-        item->setPixmap (0, pxErroneous);
-
-    mProgressBar->setProgress (mProgressBar->progress() + 1);
-}
-
-
 void VBoxDiskImageManagerDlg::setup (int aType, bool aDoSelect,
                                      const QUuid *aTargetVMId,
@@ -1311 +1231 @@
         buttonCancel->setShown (false);
 
+    /* listen to "media enumeration started" signals */
+    connect (&vboxGlobal(), SIGNAL (mediaEnumStarted()),
+             this, SLOT (mediaEnumStarted()));
     /* listen to "media enumeration" signals */
-    connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMedia &)),
-             this, SLOT (mediaEnumerated (const VBoxMedia &)));
+    connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMedia &, int)),
+             this, SLOT (mediaEnumerated (const VBoxMedia &, int)));
     /* listen to "media enumeration finished" signals */
-    connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMediaList &)),
-             this, SLOT (mediaEnumerated (const VBoxMediaList &)));
+    connect (&vboxGlobal(), SIGNAL (mediaEnumFinished (const VBoxMediaList &)),
+             this, SLOT (mediaEnumFinished (const VBoxMediaList &)));
+
+    /* listen to "media add" signals */
+    connect (&vboxGlobal(), SIGNAL (mediaAdded (const VBoxMedia &)),
+             this, SLOT (mediaAdded (const VBoxMedia &)));
+    /* listen to "media update" signals */
+    connect (&vboxGlobal(), SIGNAL (mediaUpdated (const VBoxMedia &)),
+             this, SLOT (mediaUpdated (const VBoxMedia &)));
+    /* listen to "media remove" signals */
+    connect (&vboxGlobal(), SIGNAL (mediaRemoved (VBoxDefs::DiskType, const QUuid &)),
+             this, SLOT (mediaRemoved (VBoxDefs::DiskType, const QUuid &)));
 
     /* insert already enumerated media */
-    VBoxMediaList list;
+    VBoxMediaList list = mediaList ?
+        *mediaList : vboxGlobal().currentMediaList();
+    prepareToRefresh (list.size());
+    VBoxMediaList::const_iterator it;
+    int index = 0;
+    for (it = list.begin(); it != list.end(); ++ it)
+    {
+        mediaAdded (*it);
+        if ((*it).status != VBoxMedia::Unknown)
+            mProgressBar->setProgress (index ++);
+    }
+    /* select first child */
+    setCurrentItem (hdsView, hdsView->firstChild());
+    setCurrentItem (cdsView, cdsView->firstChild());
+    setCurrentItem (fdsView, fdsView->firstChild());
+
     if (mediaList)
-        list = *mediaList;
+    {
+        mediaEnumFinished (list);
+    }
     else
-        list = vboxGlobal().currentMediaList();
-
-    VBoxMediaList::const_iterator it;
-    prepareToRefresh();
-    for (it = list.begin(); it != list.end(); ++ it)
-        updateMedia (*it);
-
-    if (mediaList)
-    {
-        mediaEnumerated (*mediaList);
-    }
-    else
-    {
-        /* only start enumerating media if we haven't been supplied with a list
+    {
+        /* only start enumerating media if we haven't been supplied a list
          * (it's ok if the enumeration has been already started, nothing will
          * happen) */
@@ -1344 +1282 @@
 
 
-void VBoxDiskImageManagerDlg::mediaEnumerated (const VBoxMedia &aMedia)
-{
-    if (!mToBeRefreshed) return;
-    updateMedia (aMedia);
+void VBoxDiskImageManagerDlg::mediaEnumStarted()
+{
+    VBoxMediaList list = vboxGlobal().currentMediaList();
+    prepareToRefresh (list.size());
+    /* clearing lists */
+    hdsView->clear(), cdsView->clear(), fdsView->clear();
+    /* load current media list */
+    VBoxMediaList::const_iterator it;
+    for (it = list.begin(); it != list.end(); ++ it)
+        mediaAdded (*it);
+    /* select first child */
+    if (!hdsView->isSelected (hdsView->currentItem()))
+        setCurrentItem (hdsView, hdsView->firstChild());
+    if (!cdsView->isSelected (cdsView->currentItem()))
+        setCurrentItem (cdsView, cdsView->firstChild());
+    if (!fdsView->isSelected (fdsView->currentItem()))
+        setCurrentItem (fdsView, fdsView->firstChild());
+
     processCurrentChanged();
 }
 
-
-void VBoxDiskImageManagerDlg::mediaEnumerated (const VBoxMediaList & /*aList*/)
-{
-    if (!mToBeRefreshed) return;
-
+void VBoxDiskImageManagerDlg::mediaEnumerated (const VBoxMedia &aMedia,
+                                               int aIndex)
+{
+    mediaUpdated (aMedia);
+    if (aMedia.status != VBoxMedia::Unknown)
+        mProgressBar->setProgress (aIndex);
+}
+
+void VBoxDiskImageManagerDlg::mediaEnumFinished (const VBoxMediaList &/* aList */)
+{
     mProgressBar->setHidden (true);
     mProgressText->setHidden (true);
@@ -1362 +1319 @@
     unsetCursor();
 
-    mToBeRefreshed = false;
+    processCurrentChanged();
+}
+
+
+void VBoxDiskImageManagerDlg::mediaAdded (const VBoxMedia &aMedia)
+{
+    /* ignore non-interesting aMedia */
+    if (!(type & aMedia.type))
+        return;
+
+    DiskImageItem *item = 0;
+    switch (aMedia.type)
+    {
+        case VBoxDefs::HD:
+            item = createHdItem (hdsView, 0, aMedia);
+            if (item->getUuid() == hdSelectedId)
+                setCurrentItem (hdsView, item);
+            break;
+        case VBoxDefs::CD:
+            item = createCdItem (cdsView, 0, aMedia);
+            if (item->getUuid() == cdSelectedId)
+                setCurrentItem (cdsView, item);
+            break;
+        case VBoxDefs::FD:
+            item = createFdItem (fdsView, 0, aMedia);
+            if (item->getUuid() == fdSelectedId)
+                setCurrentItem (fdsView, item);
+            break;
+        default:
+            AssertMsgFailed (("Invalid aMedia type\n"));
+    }
+    if (!item)
+        return;
+    if (!vboxGlobal().isMediaEnumerationStarted())
+        setCurrentItem (getListView (aMedia.type), item);
+}
+
+void VBoxDiskImageManagerDlg::mediaUpdated (const VBoxMedia &aMedia)
+{
+    /* ignore non-interesting aMedia */
+    if (!(type & aMedia.type))
+        return;
+
+    DiskImageItem *item = 0;
+    switch (aMedia.type)
+    {
+        case VBoxDefs::HD:
+        {
+            CHardDisk hd = aMedia.disk;
+            item = searchItem (hdsView, hd.GetId());
+            if (item)
+                updateHdItem (item, aMedia);
+            break;
+        }
+        case VBoxDefs::CD:
+        {
+            CDVDImage cd = aMedia.disk;
+            item = searchItem (cdsView, cd.GetId());
+            if (item)
+                updateCdItem (item, aMedia);
+            break;
+        }
+        case VBoxDefs::FD:
+        {
+            CFloppyImage fd = aMedia.disk;
+            item = searchItem (fdsView, fd.GetId());
+            if (item)
+                updateFdItem (item, aMedia);
+            break;
+        }
+        default:
+            AssertMsgFailed (("Invalid aMedia type\n"));
+    }
+    if (!item)
+        return;
+    if (!vboxGlobal().isMediaEnumerationStarted())
+        setCurrentItem (getListView (aMedia.type), item);
+}
+
+void VBoxDiskImageManagerDlg::mediaRemoved (VBoxDefs::DiskType aType,
+                                            const QUuid &aId)
+{
+    QListView *listView = getListView (aType);
+    DiskImageItem *item = searchItem (listView, aId);
+    delete item;
+    setCurrentItem (listView, listView->currentItem());
 }
 
@@ -1389 +1431 @@
 
 
-void VBoxDiskImageManagerDlg::prepareToRefresh()
-{
-    if (mToBeRefreshed) return;
-    mToBeRefreshed = true;
-
+void VBoxDiskImageManagerDlg::prepareToRefresh (int aTotal)
+{
     /* info panel clearing */
     hdsPane1->clear();
@@ -1404 +1443 @@
     if (mProgressBar)
     {
-        int totalSteps = 0;
-        if (type & VBoxDefs::HD)
-            totalSteps += vbox.GetHardDisks().GetCount();
-        if (type & VBoxDefs::CD)
-            totalSteps += vbox.GetDVDImages().GetCount();
-        if (type & VBoxDefs::FD)
-            totalSteps += vbox.GetFloppyImages().GetCount();
-        mProgressBar->setProgress (0, totalSteps);
+        mProgressBar->setProgress (0, aTotal);
         mProgressBar->setHidden (false);
         mProgressText->setHidden (false);
@@ -1423 +1455 @@
 void VBoxDiskImageManagerDlg::refreshAll()
 {
-    if (mToBeRefreshed) return;
-    prepareToRefresh();
-    /* lists clearing */
-    hdsView->clear(), cdsView->clear(), fdsView->clear();
-    /* load all lists */
-    loadListViews();
     /* start enumerating media */
     vboxGlobal().startEnumeratingMedia();
@@ -1494 +1520 @@
 
 
-void VBoxDiskImageManagerDlg::setCurrentItem (QListView *aListView, QListViewItem *aItem)
-{
-    aListView->setFocus();
-    if (aItem)
-    {
-        aListView->setCurrentItem (aItem);
-        aListView->setSelected (aListView->currentItem(), true);
-        /* it is strange repeat but it works */
-        aListView->adjustColumn (1);
-        aListView->adjustColumn (2);
-        aListView->adjustColumn (1);
-    }
-    processCurrentChanged (aListView->currentItem());
+void VBoxDiskImageManagerDlg::setCurrentItem (QListView *aListView,
+                                              QListViewItem *aItem)
+{
+    if (!aItem)
+        return;
+
+    aListView->setCurrentItem (aItem);
+    aListView->setSelected (aListView->currentItem(), true);
+    /* it is strange repeat but it works */
+    aListView->adjustColumn (1);
+    aListView->adjustColumn (2);
+    aListView->adjustColumn (1);
 }
 
@@ -1514 +1539 @@
     QListView *currentList = getCurrentListView();
     currentList->setFocus();
-
-    QListViewItem *itemToSelect =
-        !currentList->isSelected (currentList->currentItem()) ?
-        currentList->firstChild() : currentList->currentItem();
-    setCurrentItem (currentList, itemToSelect);
 
     /* tab stop setup */
@@ -1538 +1558 @@
     setTabOrder (buttonHelp, buttonOk);
     setTabOrder (buttonOk, twImages);
+
+    processCurrentChanged (currentList->currentItem());
 }
 
@@ -1545 +1567 @@
         static_cast<DiskImageItem*> (aItem) : 0;
 
-    bool modifyEnabled  = item &&  item->getUsage().isNull() &&
+    bool notInEnum      = !vboxGlobal().isMediaEnumerationStarted();
+    bool modifyEnabled  = notInEnum &&
+                          item &&  item->getUsage().isNull() &&
                           !item->firstChild() && !item->getPath().isNull();
     bool releaseEnabled = item && !item->getUsage().isNull() &&
@@ -1551 +1575 @@
                           !item->parent() && !item->firstChild() &&
                           item->getSnapshotName().isNull();
-    bool newEnabled = getCurrentListView() == hdsView ? true : false;
+    bool newEnabled     = notInEnum &&
+                          getCurrentListView() == hdsView ? true : false;
+    bool addEnabled     = notInEnum;
 
     // imEditAction->setEnabled (modifyEnabled);
@@ -1557 +1583 @@
     imReleaseAction->setEnabled (releaseEnabled);
     imNewAction->setEnabled (newEnabled);
+    imAddAction->setEnabled (addEnabled);
 
     // itemMenu->setItemVisible (itemMenu->idAt(0), modifyEnabled);
@@ -1574 +1601 @@
     if (item)
     {
-        if (getCurrentListView() == hdsView)
+        if (item->listView() == hdsView)
         {
             hdsPane1->setText (item->getInformation (item->getPath(), true, "end"));
@@ -1581 +1608 @@
             hdsPane4->setText (item->getInformation (item->getUsage()));
             hdsPane5->setText (item->getInformation (item->getSnapshotName()));
-        }
-        else if (getCurrentListView() == cdsView)
+            hdSelectedId = item->getUuid();
+        }
+        else if (item->listView() == cdsView)
         {
             cdsPane1->setText (item->getInformation (item->getPath(), true, "end"));
             cdsPane2->setText (item->getInformation (item->getUsage()));
-        }
-        else if (getCurrentListView() == fdsView)
+            cdSelectedId = item->getUuid();
+        }
+        else if (item->listView() == fdsView)
         {
             fdsPane1->setText (item->getInformation (item->getPath(), true, "end"));
             fdsPane2->setText (item->getInformation (item->getUsage()));
+            fdSelectedId = item->getUuid();
         }
     }
@@ -1603 +1633 @@
         currentList->setSelected (currentList->currentItem(), true);
     }
-    processCurrentChanged();
 }
 
@@ -1616 +1645 @@
     {
         CHardDisk hd = dlg.hardDisk();
-        VBoxMedia::Status status = hd.GetAccessible() ?
-            VBoxMedia::Ok : VBoxMedia::Inaccessible;
-        DiskImageItem *createdItem = createHdItem (hdsView, 0, hd, status);
-        setCurrentItem (hdsView, createdItem);
-        /* synchronize modeless dialog if present */
-        if (mModelessDialog && mModelessDialog != this)
-            mModelessDialog->createHdItem (mModelessDialog->hdsView,
-                                           0, hd, status);
+        VBoxMedia::Status status =
+            hd.GetAccessible() ? VBoxMedia::Ok :
+            hd.isOk() ? VBoxMedia::Inaccessible :
+            VBoxMedia::Error;
+        VBoxMedia media (CUnknown (hd), VBoxDefs::HD, status);
+        vboxGlobal().addMedia (media);
     }
 }
@@ -1669 +1696 @@
                                                 title);
 
-    DiskImageItem *createdItem = addImageToList (src, type);
-    setCurrentItem (currentList, createdItem);
-
+    addImageToList (src, type);
     if (!vbox.isOk())
-    {
         vboxProblem().cannotRegisterMedia (this, vbox, type, src);
-    }
 }
 
@@ -1686 +1709 @@
         static_cast<DiskImageItem*> (currentList->currentItem()) : 0;
     AssertMsg (item, ("Current item must not be null"));
-    QString removedItemName = item->getName();
 
     QString src = item->getPath().stripWhiteSpace();
@@ -1730 +1752 @@
     }
 
-    if (!vbox.isOk())
-    {
+    if (vbox.isOk())
+        vboxGlobal().removeMedia (type, uuid);
+    else
         vboxProblem().cannotUnregisterMedia (this, vbox, type, src);
-    }
-    else
-    {
-        delete item;
-        setCurrentItem (currentList, currentList->currentItem());
-        /* synchronize modeless dialog if present */
-        if (mModelessDialog && mModelessDialog != this)
-        {
-            DiskImageItem *itemToRemove = 0;
-            QListView *modelessView = 0;
-            if (currentList == hdsView)
-                modelessView = mModelessDialog->hdsView;
-            else if (currentList == cdsView)
-                modelessView = mModelessDialog->cdsView;
-            else if (currentList == fdsView)
-                modelessView = mModelessDialog->fdsView;
-            itemToRemove = static_cast<DiskImageItem*>
-                (modelessView->findItem (removedItemName, 0));
-            delete itemToRemove;
-            if (modelessView->currentItem())
-                modelessView->setSelected (modelessView->currentItem(), true);
-            mModelessDialog->processCurrentChanged();
-        }
-    }
 }
 
@@ -1767 +1766 @@
         static_cast<DiskImageItem*> (currentList->currentItem()) : 0;
     AssertMsg (item, ("Current item must not be null"));
-    QString releasedItemName = item->getName();
-    QString usageAfterRelease;
 
     QUuid itemId = QUuid (item->getUuid());
     AssertMsg (!itemId.isNull(), ("Current item must have uuid"));
 
+    VBoxMedia media;
     QUuid machineId;
     /* if it is a hard disk sub-item: */
@@ -1782 +1780 @@
         {
             releaseDisk (machineId, itemId, VBoxDefs::HD);
-
-            /* re-request current usage */
-            machineId = vbox.GetHardDisk (itemId).GetMachineId();
-            usageAfterRelease = machineId.isNull() ? QString::null :
-                                vbox.GetMachine (machineId).GetName();
-            item->setUsage (usageAfterRelease);
+            CHardDisk hd = vboxGlobal().virtualBox().GetHardDisk (itemId);
+            media = VBoxMedia (CUnknown (hd), VBoxDefs::HD, item->getStatus());
         }
     }
@@ -1804 +1798 @@
                 releaseDisk (QUuid (*it), itemId, VBoxDefs::CD);
 
-            /* re-request current usage */
-            usageAfterRelease = getDVDImageUsage (itemId);
-            item->setUsage (usageAfterRelease);
+            CDVDImage cd = vboxGlobal().virtualBox().GetDVDImage (itemId);
+            media = VBoxMedia (CUnknown (cd), VBoxDefs::CD, item->getStatus());
         }
     }
@@ -1823 +1816 @@
                 releaseDisk (QUuid (*it), itemId, VBoxDefs::FD);
 
-            /* re-request current usage */
-            usageAfterRelease = getFloppyImageUsage (itemId);
-            item->setUsage (usageAfterRelease);
-        }
-    }
-    processCurrentChanged (item);
-
-    /* processing modeless dialog */
-    if (mModelessDialog && mModelessDialog != this)
-    {
-        DiskImageItem *itemToRelease = 0;
-        QListView *modelessView = 0;
-        if (currentList == hdsView)
-            modelessView = mModelessDialog->hdsView;
-        else if (currentList == cdsView)
-            modelessView = mModelessDialog->cdsView;
-        else if (currentList == fdsView)
-            modelessView = mModelessDialog->fdsView;
-        itemToRelease = static_cast<DiskImageItem*>
-            (modelessView->findItem (releasedItemName, 0));
-        itemToRelease->setUsage (usageAfterRelease);
-        mModelessDialog->processCurrentChanged();
-    }
+            CFloppyImage fd = vboxGlobal().virtualBox().GetFloppyImage (itemId);
+            media = VBoxMedia (CUnknown (fd), VBoxDefs::FD, item->getStatus());
+        }
+    }
+    if (media.type != VBoxDefs::InvalidType)
+        vboxGlobal().updateMedia (media);
 }
 

trunk/src/VBox/Frontends/VirtualBox/ui/VBoxNewVMWzd.ui.h

@@ -99 +99 @@
 
     /* HDD Images page */
-    mediaCombo = new VBoxMediaComboBox (grbHDA, "mediaCombo", VBoxDefs::HD);
-    mediaCombo->setUseEmptyItem (true);
-    mediaCombo->refresh();
+    mediaCombo = new VBoxMediaComboBox (grbHDA, "mediaCombo", VBoxDefs::HD, true);
     grbHDALayout->addMultiCellWidget (mediaCombo, 0, 0, 0, 2);
     setTabOrder (mediaCombo, pbNewHD);
@@ -107 +105 @@
     connect (mediaCombo, SIGNAL (activated (int)),
              this, SLOT (currentMediaChanged (int)));
+    vboxGlobal().startEnumeratingMedia();
 
     /// @todo (dmik) remove?
@@ -339 +338 @@
     if (!chd.isNull())
     {
+        QUuid hdId = chd.GetId();
         CVirtualBox vbox = vboxGlobal().virtualBox();
         vbox.UnregisterHardDisk (chd.GetId());
@@ -355 +355 @@
         }
         chd.detach();
-        mediaCombo->removeLastItem();
+        vboxGlobal().removeMedia (VBoxDefs::HD, hdId);
     }
 }
@@ -368 +368 @@
     VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg", WType_Dialog | WShowModal);
     dlg.setup (VBoxDefs::HD, true);
-    if (dlg.exec() == VBoxDiskImageManagerDlg::Accepted)
-    {
-        /* fetch uuid and name/path */
-        if (dlg.getSelectedUuid() != uuidHD)
-        {
-            ensureNewHardDiskDeleted();
-            uuidHD = dlg.getSelectedUuid();
-        }
-        /* refresh media combobox */
-        mediaCombo->setRequiredItem (uuidHD);
-        mediaCombo->refresh();
-        mediaCombo->setFocus();
-        /* revailidate */
-        wvalHDD->revalidate();
-    }
+    QUuid newId = dlg.exec() == VBoxDiskImageManagerDlg::Accepted ?
+        dlg.getSelectedUuid() : mediaCombo->getId();
+
+    if (uuidHD != newId)
+    {
+        ensureNewHardDiskDeleted();
+        uuidHD = newId;
+        mediaCombo->setCurrentItem (uuidHD);
+    }
+    mediaCombo->setFocus();
+    /* revailidate */
+    wvalHDD->revalidate();
 }
 
@@ -401 +398 @@
         uuidHD = chd.GetId();
         /* update media combobox */
-        QFileInfo fi (chd.GetLocation());
-        mediaCombo->appendItem (QString ("%1 (%2)")
-            .arg (fi.fileName())
-            .arg (QDir::convertSeparators (fi.dirPath())),
-            uuidHD, VBoxDiskImageManagerDlg::composeHdToolTip (chd));
-        mediaCombo->setCurrentItem (mediaCombo->count() - 1);
+        VBoxMedia::Status status =
+            chd.GetAccessible() == TRUE ? VBoxMedia::Ok :
+            chd.isOk() ? VBoxMedia::Inaccessible :
+            VBoxMedia::Error;
+        VBoxMedia media (CUnknown (chd), VBoxDefs::HD, status);
+        vboxGlobal().addMedia (media);
+        mediaCombo->setCurrentItem (uuidHD);
         mediaCombo->setFocus();
         /* revailidate */

trunk/src/VBox/Frontends/VirtualBox/ui/VBoxVMSettingsDlg.ui.h

@@ -658 +658 @@
 {
     /* setup necessary combobox item */
-    cbHDA->setRequiredItem (uuidHDA);
-    cbHDB->setRequiredItem (uuidHDB);
-    cbHDD->setRequiredItem (uuidHDD);
-    cbISODVD->setRequiredItem (uuidISODVD);
-    cbISOFloppy->setRequiredItem (uuidISOFloppy);
-    /* request for refresh every combo-box */
-    cbHDA->setReadyForRefresh();
-    cbHDB->setReadyForRefresh();
-    cbHDD->setReadyForRefresh();
-    cbISODVD->setReadyForRefresh();
-    cbISOFloppy->setReadyForRefresh();
-    /* starting media-enumerating process */
-    vboxGlobal().startEnumeratingMedia();
+    cbHDA->setCurrentItem (uuidHDA);
+    cbHDB->setCurrentItem (uuidHDB);
+    cbHDD->setCurrentItem (uuidHDD);
+    cbISODVD->setCurrentItem (uuidISODVD);
+    cbISOFloppy->setCurrentItem (uuidISOFloppy);
+    /* check if the enumeration process has been started yet */
+    if (!vboxGlobal().isMediaEnumerationStarted())
+        vboxGlobal().startEnumeratingMedia();
+    else
+    {
+        cbHDA->refresh();
+        cbHDB->refresh();
+        cbHDD->refresh();
+        cbISODVD->refresh();
+        cbISOFloppy->refresh();
+    }
 }
 
@@ -677 +680 @@
 {
     uuidHDA = grbHDA->isChecked() ? cbHDA->getId() : QUuid();
-    cbHDA->setRequiredItem (uuidHDA);
     txHDA->setText (getHdInfo (grbHDA, uuidHDA));
     /* revailidate */
@@ -687 +689 @@
 {
     uuidHDB = grbHDB->isChecked() ? cbHDB->getId() : QUuid();
-    cbHDB->setRequiredItem (uuidHDB);
     txHDB->setText (getHdInfo (grbHDB, uuidHDB));
     /* revailidate */
@@ -697 +698 @@
 {
     uuidHDD = grbHDD->isChecked() ? cbHDD->getId() : QUuid();
-    cbHDD->setRequiredItem (uuidHDD);
     txHDD->setText (getHdInfo (grbHDD, uuidHDD));
     /* revailidate */
@@ -707 +707 @@
 {
     uuidISODVD = bgDVD->isChecked() ? cbISODVD->getId() : QUuid();
-    cbISODVD->setRequiredItem (uuidISODVD);
     /* revailidate */
     wvalDVD->revalidate();
@@ -716 +715 @@
 {
     uuidISOFloppy = bgFloppy->isChecked() ? cbISOFloppy->getId() : QUuid();
-    cbISOFloppy->setRequiredItem (uuidISOFloppy);
     /* revailidate */
     wvalFloppy->revalidate();
@@ -1288 +1286 @@
 
     /* request for media shortcuts update */
-    cbHDA->setBelongsTo(machine.GetId());
-    cbHDB->setBelongsTo(machine.GetId());
-    cbHDD->setBelongsTo(machine.GetId());
+    cbHDA->setBelongsTo (machine.GetId());
+    cbHDB->setBelongsTo (machine.GetId());
+    cbHDD->setBelongsTo (machine.GetId());
     updateShortcuts();
 
@@ -1541 +1539 @@
     QUuid machineId = cmachine.GetId();
     dlg.setup (type, true, &machineId, (const VBoxMediaList*)0, cmachine);
-    if (dlg.exec() == VBoxDiskImageManagerDlg::Accepted)
-        *id = dlg.getSelectedUuid();
-    updateShortcuts();
+    *id = dlg.exec() == VBoxDiskImageManagerDlg::Accepted ?
+        dlg.getSelectedUuid() : cbb->getId();
+    cbb->setCurrentItem (*id);
     cbb->setFocus();
+
+    /* revalidate pages with custom validation */
+    wvalHDD->revalidate();
+    wvalDVD->revalidate();
+    wvalFloppy->revalidate();
 }