Changeset 13580 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Oct 27, 2008 2:04:18 PM (16 years ago)

Author:

vboxsync

Message:

Ported s2 branch (r37120:38456).

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• VBoxUI.pro (modified) (1 diff)
• include/COMDefs.h (modified) (22 diffs)
• include/COMWrappers.xsl (modified) (11 diffs)
• include/VBoxConsoleView.h (modified) (2 diffs)
• include/VBoxConsoleWnd.h (modified) (1 diff)
• include/VBoxDefs.h (modified) (4 diffs)
• include/VBoxGlobal.h (modified) (11 diffs)
• include/VBoxMediaComboBox.h (modified) (3 diffs)
• include/VBoxProblemReporter.h (modified) (8 diffs)
• include/VBoxSelectorWnd.h (modified) (2 diffs)
• src/COMDefs.cpp (modified) (1 diff)
• src/VBoxConsoleView.cpp (modified) (4 diffs)
• src/VBoxConsoleWnd.cpp (modified) (15 diffs)
• src/VBoxGlobal.cpp (modified) (45 diffs)
• src/VBoxMediaComboBox.cpp (modified) (3 diffs)
• src/VBoxProblemReporter.cpp (modified) (15 diffs)
• src/VBoxSelectorWnd.cpp (modified) (11 diffs)
• src/VBoxVMListBox.cpp (modified) (3 diffs)
• src/main.cpp (modified) (2 diffs)
• ui/VBoxDiskImageManagerDlg.ui (deleted)
• ui/VBoxDiskImageManagerDlg.ui.h (deleted)
• ui/VBoxGlobalSettingsDlg.ui (modified) (10 diffs)
• ui/VBoxGlobalSettingsDlg.ui.h (modified) (8 diffs)
• ui/VBoxHardDiskSettings.ui (modified) (7 diffs)
• ui/VBoxHardDiskSettings.ui.h (modified) (29 diffs)
• ui/VBoxMediaManagerDlg.ui (added)
• ui/VBoxMediaManagerDlg.ui.h (added)
• ui/VBoxNewHDWzd.ui (modified) (16 diffs)
• ui/VBoxNewHDWzd.ui.h (modified) (22 diffs)
• ui/VBoxNewVMWzd.ui (modified) (8 diffs)
• ui/VBoxNewVMWzd.ui.h (modified) (22 diffs)
• ui/VBoxSnapshotsWgt.ui.h (modified) (2 diffs)
• ui/VBoxUSBFilterSettings.ui.h (modified) (2 diffs)
• ui/VBoxVMFirstRunWzd.ui (modified) (4 diffs)
• ui/VBoxVMFirstRunWzd.ui.h (modified) (7 diffs)
• ui/VBoxVMInformationDlg.ui.h (modified) (7 diffs)
• ui/VBoxVMSettingsDlg.ui (modified) (6 diffs)
• ui/VBoxVMSettingsDlg.ui.h (modified) (34 diffs)

trunk/src/VBox/Frontends/VirtualBox/VBoxUI.pro

@@ -25 +25 @@
 LANGUAGE        = C++
 
-FORMS   = ui/VBoxDiskImageManagerDlg.ui \
+FORMS   = ui/VBoxMediaManagerDlg.ui \
         ui/VBoxVMNetworkSettings.ui \
         ui/VBoxVMSerialPortSettings.ui \

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

@@ -179 +179 @@
 
 /**
- *  Base COM class the CInterface template and all wrapper classes are derived
- *  from. Provides common functionality for all COM wrappers.
+ * Base COM class the CInterface template and all wrapper classes are derived
+ * from. Provides common functionality for all COM wrappers.
  */
 class COMBase
@@ -190 +190 @@
 
     /**
-     *  Returns the result code of the last interface method called
-     *  by the wrapper instance or the result of CInterface::createInstance()
-     *  operation.
+     * Returns the result code of the last interface method called by the
+     * wrapper instance or the result of CInterface::createInstance()
+     * operation.
      */
     HRESULT lastRC() const { return mRC; }
-
-    /**
-     *  Returns error info set by the last unsuccessfully invoked interface
-     *  method. Returned error info is useful only if CInterface::lastRC()
-     *  represents a failure or a warning (i.e. CInterface::isReallyOk() is
-     *  false).
-     */
-    virtual COMErrorInfo errorInfo() const { return COMErrorInfo(); }
 
 #if !defined (VBOX_WITH_XPCOM)
@@ -231 +223 @@
     static void ToSafeArray (const QValueVector <QT> &aVec, com::SafeArray <CT> &aArr)
     {
+        Q_UNUSED (aVec);
+        Q_UNUSED (aArr);
         AssertMsgFailedReturnVoid (("No conversion!\n"));
     }
@@ -237 +231 @@
     static void FromSafeArray (const com::SafeArray <CT> &aArr, QValueVector <QT> &aVec)
     {
+        Q_UNUSED (aArr);
+        Q_UNUSED (aVec);
         AssertMsgFailedReturnVoid (("No conversion!\n"));
     }
@@ -243 +239 @@
     static void ToSafeArray (const QValueVector <QT *> &aVec, com::SafeArray <CT *> &aArr)
     {
+        Q_UNUSED (aVec);
+        Q_UNUSED (aArr);
         AssertMsgFailedReturnVoid (("No conversion!\n"));
     }
@@ -249 +247 @@
     static void FromSafeArray (const com::SafeArray <CT *> &aArr, QValueVector <QT *> &aVec)
     {
+        Q_UNUSED (aArr);
+        Q_UNUSED (aVec);
         AssertMsgFailedReturnVoid (("No conversion!\n"));
     }
@@ -280 +280 @@
     static void FromSafeArray (const com::SafeArray <BSTR> &aArr,
                                QValueVector <QString> &aVec);
+
+    /* Arrays of GUID */
+
+    static void ToSafeArray (const QValueVector <QUuid> &aVec,
+                             com::SafeGUIDArray &aArr);
+    static void FromSafeArray (const com::SafeGUIDArray &aArr,
+                               QValueVector <QUuid> &aVec);
 
     /* Arrays of interface pointers. Note: we need a separate pair of names
@@ -299 +306 @@
              it != aVec.end(); ++ it, ++ i)
         {
-            aArr [i] = (*it).iface();
+            aArr [i] = (*it).raw();
             if (aArr [i])
                 aArr [i]->AddRef();
@@ -457 +464 @@
 #endif /* !defined (VBOX_WITH_XPCOM) */
 
-    void fetchErrorInfo (IUnknown * /*callee*/, const GUID * /*calleeIID*/) const {}
+    static void addref (IUnknown *aIface) { if (aIface) aIface->AddRef(); }
+    static void release (IUnknown *aIface) { if (aIface) aIface->Release(); }
+
+protected:
 
     mutable HRESULT mRC;
@@ -467 +477 @@
 
 /**
- *  Alternative base class for the CInterface template that adds
- *  the errorInfo() method for providing extended error info about
- *  unsuccessful invocation of the last called interface method.
+ * Alternative base class for the CInterface template that adds the errorInfo()
+ * method for providing extended error info about unsuccessful invocation of the
+ * last called interface method.
  */
 class COMBaseWithEI : public COMBase
@@ -476 +486 @@
 
     /**
-     *  Returns error info set by the last unsuccessfully invoked interface
-     *  method. Returned error info is useful only if CInterface::lastRC()
-     *  represents a failure or a warning (i.e. CInterface::isReallyOk() is
-     *  false).
-     */
-    COMErrorInfo errorInfo() const { return mErrInfo; }
+     * Returns error info set by the last unsuccessfully invoked interface
+     * method. Returned error info is useful only if CInterface::lastRC()
+     * represents a failure or a warning (i.e. CInterface::isReallyOk() is
+     * false).
+     */
+    const COMErrorInfo &errorInfo() const { return mErrInfo; }
 
 protected:
 
-    /* no arbitrary instance creations */
+    /* no arbitrary instance creation */
     COMBaseWithEI() : COMBase () {};
 
-    void fetchErrorInfo (IUnknown *callee, const GUID *calleeIID) const
-    {
-        mErrInfo.fetchFromCurrentThread (callee, calleeIID);
+    void setErrorInfo (const COMErrorInfo &aErrInfo) { mErrInfo = aErrInfo; }
+
+    void fetchErrorInfo (IUnknown *aCallee, const GUID *aCalleeIID) const
+    {
+        mErrInfo.fetchFromCurrentThread (aCallee, aCalleeIID);
     }
 
@@ -499 +511 @@
 
 /**
- *  Simple class that encapsulates the result code and COMErrorInfo.
+ * Simple class that encapsulates the result code and COMErrorInfo.
  */
 class COMResult
@@ -507 +519 @@
     COMResult() : mRC (S_OK) {}
 
-    /** Queries the current result code and error info from the given component */
-    COMResult (const COMBase &aComponent)
-    {
-        mErrInfo = aComponent.errorInfo();
-        mRC = aComponent.lastRC();
-    }
-
-    /** Queries the current result code and error info from the given component */
+    /**
+     * Queries the current result code from the given component.
+     */
+    explicit COMResult (const COMBase &aComponent)
+        : mRC (aComponent.lastRC()) {}
+
+    /**
+     * Queries the current result code and error info from the given component.
+     */
+    COMResult (const COMBaseWithEI &aComponent)
+        : mRC (aComponent.lastRC())
+        , mErrInfo (aComponent.errorInfo()) {}
+
+    /**
+     * Queries the current result code from the given component.
+     */
     COMResult &operator= (const COMBase &aComponent)
     {
-        mErrInfo = aComponent.errorInfo();
         mRC = aComponent.lastRC();
         return *this;
     }
 
+    /**
+     * Queries the current result code and error info from the given component.
+     */
+    COMResult &operator= (const COMBaseWithEI &aComponent)
+    {
+        mRC = aComponent.lastRC();
+        mErrInfo = aComponent.errorInfo();
+        return *this;
+    }
+
     bool isNull() const { return mErrInfo.isNull(); }
 
@@ -546 +575 @@
 private:
 
+    HRESULT mRC;
     COMErrorInfo mErrInfo;
-    HRESULT mRC;
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
-class CUnknown;
-
 /**
- *  Wrapper template class for all interfaces.
- *
- *  All interface methods named as they are in the original, i.e. starting
- *  with the capital letter. All utility non-interface methods are named
- *  starting with the small letter. Utility methods should be not normally
- *  called by the end-user client application.
- *
- *  @param  I   interface class (i.e. IUnknown/nsISupports derivant)
- *  @param  B   base class, either COMBase (by default) or COMBaseWithEI
+ * Wrapper template class for all interfaces.
+ *
+ * All interface methods named as they are in the original, i.e. starting
+ * with the capital letter. All utility non-interface methods are named
+ * starting with the small letter. Utility methods should be not normally
+ * called by the end-user client application.
+ *
+ * @param  I    Interface class (i.e. IUnknown/nsISupports derivant).
+ * @param  B    Base class, either COMBase (by default) or COMBaseWithEI.
  */
 template <class I, class B = COMBase>
@@ -573 +600 @@
     typedef I Iface;
 
-    /* constructors & destructor */
+    // constructors & destructor
 
     CInterface() : mIface (NULL) {}
@@ -582 +609 @@
     }
 
-    CInterface (const CUnknown &that);
-
-    CInterface (I *i) : mIface (i) { addref (mIface); }
+    CInterface (I *aIface) : mIface (aIface) { addref (mIface); }
 
     virtual ~CInterface() { release (mIface); }
 
-    /* utility methods */
-
-    void createInstance (const CLSID &clsid)
+    // utility methods
+
+    void createInstance (const CLSID &aClsId)
     {
         AssertMsg (!mIface, ("Instance is already non-NULL\n"));
@@ -597 +622 @@
 #if !defined (VBOX_WITH_XPCOM)
 
-            B::mRC = CoCreateInstance (clsid, NULL, CLSCTX_ALL,
+            B::mRC = CoCreateInstance (aClsId, NULL, CLSCTX_ALL,
                                        _ATL_IIDOF (I), (void **) &mIface);
 
@@ -605 +630 @@
             B::mRC = NS_GetComponentManager (getter_AddRefs (manager));
             if (SUCCEEDED (B::mRC))
-                B::mRC = manager->CreateInstance (clsid, nsnull, NS_GET_IID (I),
+                B::mRC = manager->CreateInstance (aClsId, nsnull, NS_GET_IID (I),
                                                   (void **) &mIface);
 
@@ -617 +642 @@
     }
 
-    void attach (I *i)
-    {
-        /* be aware of self (from COM point of view) assignment */
-        I *old_iface = mIface;
-        mIface = i;
-        addref (mIface);
-        release (old_iface);
+    /**
+     * Attaches to the given foreign interface pointer by querying the own
+     * interface on it. The operation may fail.
+     */
+    template <class OI>
+    void attach (OI *aIface)
+    {
+        /* be aware of self assignment */
+        addref (aIface);
+        release (mIface);
+        if (aIface)
+        {
+            mIface = NULL;
+#if !defined (VBOX_WITH_XPCOM)
+            B::mRC = aIface->QueryInterface (_ATL_IIDOF (I), (void **) &mIface);
+#else /* !defined (VBOX_WITH_XPCOM) */
+            B::mRC = aIface->QueryInterface (NS_GET_IID (I), (void **) &mIface);
+#endif /* !defined (VBOX_WITH_XPCOM) */
+        }
+        else
+        {
+            mIface = NULL;
+            B::mRC = S_OK;
+        }
+    };
+
+    /** Specialization of attach() for our own interface I. Never fails. */
+    void attach (I *aIface)
+    {
+        /* be aware of self assignment */
+        addref (aIface);
+        release (mIface);
+        mIface = aIface;
         B::mRC = S_OK;
     };
 
-    void attachUnknown (IUnknown *i)
-    {
-        /* be aware of self (from COM point of view) assignment */
-        I *old_iface = mIface;
-        mIface = NULL;
-        B::mRC = S_OK;
-        if (i)
-#if !defined (VBOX_WITH_XPCOM)
-            B::mRC = i->QueryInterface (_ATL_IIDOF (I), (void **) &mIface);
-#else /* !defined (VBOX_WITH_XPCOM) */
-            B::mRC = i->QueryInterface (NS_GET_IID (I), (void **) &mIface);
-#endif /* !defined (VBOX_WITH_XPCOM) */
-        release (old_iface);
-    };
-
+    /** Detaches from the underlying interface pointer. */
     void detach() { release (mIface); mIface = NULL; }
 
+    /** Returns @c true if not attached to any interface pointer. */
     bool isNull() const { return mIface == NULL; }
 
@@ -663 +701 @@
     bool isReallyOk() const { return !isNull() && B::mRC == S_OK; }
 
-    /* utility operators */
+    // utility operators
 
     CInterface &operator= (const CInterface &that)
@@ -672 +710 @@
     }
 
-    I *iface() const { return mIface; }
+    CInterface &operator= (I *aIface)
+    {
+        attach (aIface);
+        return *this;
+    }
+
+    /**
+     * Returns the raw interface pointer. Not intended to be used for anything
+     * else but in generated wrappers and for debugging. You've been warned.
+     */
+    I *raw() const { return mIface; }
 
     bool operator== (const CInterface &that) const { return mIface == that.mIface; }
     bool operator!= (const CInterface &that) const { return mIface != that.mIface; }
 
-    CInterface &operator= (const CUnknown &that);
-
 protected:
-
-    static void addref (I *i) { if (i) i->AddRef(); }
-    static void release (I *i) { if (i) i->Release(); }
 
     mutable I *mIface;
@@ -693 +736 @@
 public:
 
-    CUnknown() : CInterface <IUnknown, COMBaseWithEI> () {}
-
-    template <class C>
-    explicit CUnknown (const C &that)
-    {
-        mIface = NULL;
-        if (that.mIface)
-#if !defined (VBOX_WITH_XPCOM)
-            mRC = that.mIface->QueryInterface (_ATL_IIDOF (IUnknown), (void**) &mIface);
-#else /* !defined (VBOX_WITH_XPCOM) */
-            mRC = that.mIface->QueryInterface (NS_GET_IID (IUnknown), (void**) &mIface);
-#endif /* !defined (VBOX_WITH_XPCOM) */
+    typedef CInterface <IUnknown, COMBaseWithEI> Base;
+
+    CUnknown() {}
+
+    /** Creates an instance given another CInterface-based instance. */
+    template <class OI, class OB>
+    explicit CUnknown (const CInterface <OI, OB> &that)
+    {
+        attach (that.mIface);
         if (SUCCEEDED (mRC))
         {
+            /* preserve old error info if any */
             mRC = that.lastRC();
-            mErrInfo = that.errorInfo();
-        }
-    }
-
-    /* specialization for CUnknown */
-    CUnknown (const CUnknown &that) : CInterface <IUnknown, COMBaseWithEI> ()
-    {
-        mIface = that.mIface;
-        addref (mIface);
-        COMBaseWithEI::operator= (that);
-    }
-
-    template <class C>
-    CUnknown &operator= (const C &that)
-    {
-        /* be aware of self (from COM point of view) assignment */
-        IUnknown *old_iface = mIface;
-        mIface = NULL;
-        mRC = S_OK;
-#if !defined (VBOX_WITH_XPCOM)
-        if (that.mIface)
-            mRC = that.mIface->QueryInterface (_ATL_IIDOF (IUnknown), (void**) &mIface);
-#else /* !defined (VBOX_WITH_XPCOM) */
-        if (that.mIface)
-            mRC = that.mIface->QueryInterface (NS_GET_IID (IUnknown), (void**) &mIface);
-#endif /* !defined (VBOX_WITH_XPCOM) */
+            setErrorInfo (that.errorInfo());
+        }
+    }
+
+    /** Constructor specialization for IUnknown. */
+    CUnknown (const CUnknown &that) : Base (that) {}
+
+    /** Creates an instance given a foreign interface pointer. */
+    template <class OI>
+    explicit CUnknown (OI *aIface)
+    {
+        attach (aIface);
+    }
+
+    /** Constructor specialization for IUnknown. */
+    explicit CUnknown (IUnknown *aIface) : Base (aIface) {}
+
+    /** Assigns from another CInterface-based instance. */
+    template <class OI, class OB>
+    CUnknown &operator= (const CInterface <OI, OB> &that)
+    {
+        attach (that.mIface);
         if (SUCCEEDED (mRC))
         {
+            /* preserve old error info if any */
             mRC = that.lastRC();
-            mErrInfo = that.errorInfo();
-        }
-        release (old_iface);
+            setErrorInfo (that.errorInfo());
+        }
         return *this;
     }
 
-    /* specialization for CUnknown */
+    /** Assignment specialization for CUnknown. */
     CUnknown &operator= (const CUnknown &that)
     {
-        attach (that.mIface);
-        COMBaseWithEI::operator= (that);
+        Base::operator= (that);
         return *this;
     }
 
-    /* @internal Used in wrappers. */
-    IUnknown *&ifaceRef() { return mIface; };
+    /** Assigns from a foreign interface pointer. */
+    template <class OI>
+    CUnknown &operator= (OI *aIface)
+    {
+        attach (aIface);
+        return *this;
+    }
+
+    /** Assignment specialization for IUnknown. */
+    CUnknown &operator= (IUnknown *aIface)
+    {
+        Base::operator= (aIface);
+        return *this;
+    }
+
+    /* @internal Used in generated wrappers. Never use directly. */
+    IUnknown *&rawRef() { return mIface; };
 };
-
-/* inlined CInterface methods that use CUnknown */
-
-template <class I, class B>
-inline CInterface <I, B>::CInterface (const CUnknown &that)
-    : mIface (NULL)
-{
-    attachUnknown (that.iface());
-    if (SUCCEEDED (B::mRC))
-        B::operator= ((B &) that);
-}
-
-template <class I, class B>
-inline CInterface <I, B> &CInterface <I, B>::operator =(const CUnknown &that)
-{
-    attachUnknown (that.iface());
-    if (SUCCEEDED (B::mRC))
-        B::operator= ((B &) that);
-    return *this;
-}
 
 /////////////////////////////////////////////////////////////////////////////

trunk/src/VBox/Frontends/VirtualBox/include/COMWrappers.xsl

@@ -11 +11 @@
 
 /*
-     Copyright (C) 2006-2007 Sun Microsystems, Inc.
+     Copyright (C) 2006-2008 Sun Microsystems, Inc.
 
      This file is part of VirtualBox Open Source Edition (OSE), as
@@ -352 +352 @@
 </xsl:template>
 
+<xsl:template name="declareAttributes">
+
+  <xsl:param name="iface"/>
+
+  <xsl:apply-templates select="$iface//attribute[not(@internal='yes')]" mode="declare"/>
+  <xsl:if test="$iface//attribute[not(@internal='yes')]">
+    <xsl:text>&#x0A;</xsl:text>
+  </xsl:if>
+  <!-- go to the base interface -->
+  <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
+    <xsl:choose>
+      <!-- interfaces within library/if -->
+      <xsl:when test="name(..)='if'">
+        <xsl:call-template name="declareAttributes">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../preceding-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../following-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:when>
+      <!-- interfaces within library -->
+      <xsl:otherwise>
+        <xsl:call-template name="declareAttributes">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:if>
+
+</xsl:template>
+
+<xsl:template name="declareMethods">
+
+  <xsl:param name="iface"/>
+
+  <xsl:apply-templates select="$iface//method[not(@internal='yes')]" mode="declare"/>
+  <xsl:if test="$iface//method[not(@internal='yes')]">
+    <xsl:text>&#x0A;</xsl:text>
+  </xsl:if>
+  <!-- go to the base interface -->
+  <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
+    <xsl:choose>
+      <!-- interfaces within library/if -->
+      <xsl:when test="name(..)='if'">
+        <xsl:call-template name="declareMethods">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../preceding-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../following-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:when>
+      <!-- interfaces within library -->
+      <xsl:otherwise>
+        <xsl:call-template name="declareMethods">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:if>
+
+</xsl:template>
+
 <xsl:template name="declareMembers">
 
@@ -359 +443 @@
   <xsl:text>    C</xsl:text>
   <xsl:value-of select="substring(@name,2)"/>
-  <xsl:text> () : Base () {}&#x0A;</xsl:text>
-  <!-- constructor taking CUnknown -->
+  <xsl:text> () {}&#x0A;&#x0A;</xsl:text>
+  <!-- constructor taking CWhatever -->
+  <xsl:text>    template &lt;class OI, class OB&gt; explicit C</xsl:text>
+  <xsl:value-of select="substring(@name,2)"/>
+<xsl:text> (const CInterface &lt;OI, OB&gt; &amp; that)
+    {
+        attach (that.raw());
+        if (SUCCEEDED (mRC))
+        {
+            mRC = that.lastRC();
+            setErrorInfo (that.errorInfo());
+        }
+    }
+</xsl:text>
+  <xsl:text>&#x0A;</xsl:text>
+  <!-- specialization for ourselves (copy constructor) -->
   <xsl:text>    C</xsl:text>
   <xsl:value-of select="substring(@name,2)"/>
-  <xsl:text> (const CUnknown &amp; that) : Base (that) {}&#x0A;</xsl:text>
-  <!-- constructor taking raw iface pointer -->
-  <xsl:text>    C</xsl:text>
+  <xsl:text> (const C</xsl:text>
+  <xsl:value-of select="substring(@name,2)"/>
+  <xsl:text> &amp; that) : Base (that) {}&#x0A;&#x0A;</xsl:text>
+  <!-- constructor taking a raw iface pointer -->
+  <xsl:text>    template &lt;class OI&gt; explicit C</xsl:text>
+  <xsl:value-of select="substring(@name,2)"/>
+  <xsl:text> (OI * aIface) { attach (aIface); }&#x0A;&#x0A;</xsl:text>
+  <!-- specialization for ourselves -->
+  <xsl:text>    explicit C</xsl:text>
   <xsl:value-of select="substring(@name,2)"/>
   <xsl:text> (</xsl:text>
   <xsl:value-of select="@name"/>
-  <xsl:text> *i) : Base (i) {}&#x0A;</xsl:text>
-  <!-- assignment taking CUnknown -->
+  <xsl:text> * aIface) : Base (aIface) {}&#x0A;&#x0A;</xsl:text>
+  <!-- assignment taking CWhatever -->
+  <xsl:text>    template &lt;class OI, class OB&gt; C</xsl:text>
+  <xsl:value-of select="substring(@name,2)"/>
+<xsl:text> &amp; operator = (const CInterface &lt;OI, OB&gt; &amp; that)
+    {
+        attach (that.raw());
+        if (SUCCEEDED (mRC))
+        {
+            mRC = that.lastRC();
+            setErrorInfo (that.errorInfo());
+        }
+        return *this;
+    }
+</xsl:text>
+  <xsl:text>&#x0A;</xsl:text>
+  <!-- specialization for ourselves -->
   <xsl:text>    C</xsl:text>
   <xsl:value-of select="substring(@name,2)"/>
-  <xsl:text> &amp; operator = (const CUnknown &amp; that)&#x0A;    {&#x0A;        return (C</xsl:text>
+  <xsl:text> &amp; operator = (const C</xsl:text>
   <xsl:value-of select="substring(@name,2)"/>
-  <xsl:text> &amp;) Base::operator = (that);&#x0A;    }&#x0A;&#x0A;</xsl:text>
+<xsl:text> &amp; that)
+    {
+        Base::operator= (that);
+        return *this;
+    }
+</xsl:text>
+  <xsl:text>&#x0A;</xsl:text>
+  <!-- assignment taking a raw iface pointer -->
+  <xsl:text>    template &lt;class OI&gt; C</xsl:text>
+  <xsl:value-of select="substring(@name,2)"/>
+<xsl:text> &amp; operator = (OI * aIface)
+    {
+        attach (aIface);
+        return *this;
+    }
+</xsl:text>
+  <xsl:text>&#x0A;</xsl:text>
+  <!-- specialization for ourselves -->
+  <xsl:text>    C</xsl:text>
+  <xsl:value-of select="substring(@name,2)"/>
+  <xsl:text> &amp; operator = (</xsl:text>
+  <xsl:value-of select="@name"/>
+<xsl:text> * aIface)
+    {
+        Base::operator= (aIface);
+        return *this;
+    }
+</xsl:text>
+  <xsl:text>&#x0A;</xsl:text>
 
   <xsl:text>    // attributes (properties)&#x0A;&#x0A;</xsl:text>
-  <xsl:apply-templates select=".//attribute[not(@internal='yes')]" mode="declare"/>
-  <xsl:if test=".//attribute[not(@internal='yes')]">
-    <xsl:text>&#x0A;</xsl:text>
-  </xsl:if>
+  <xsl:call-template name="declareAttributes">
+    <xsl:with-param name="iface" select="."/>
+  </xsl:call-template>
 
   <xsl:text>    // methods&#x0A;&#x0A;</xsl:text>
-  <xsl:apply-templates select=".//method[not(@internal='yes')]" mode="declare"/>
-  <xsl:if test=".//method[not(@internal='yes')]">
-    <xsl:text>&#x0A;</xsl:text>
-  </xsl:if>
+  <xsl:call-template name="declareMethods">
+    <xsl:with-param name="iface" select="."/>
+  </xsl:call-template>
 
   <xsl:text>    // friend wrappers&#x0A;&#x0A;</xsl:text>
@@ -561 +706 @@
 </xsl:template>
 
+<xsl:template name="defineAttributes">
+
+  <xsl:param name="iface"/>
+
+  <xsl:apply-templates select="$iface//attribute[not(@internal='yes')]" mode="define">
+    <xsl:with-param name="namespace" select="."/>
+  </xsl:apply-templates>
+
+  <!-- go to the base interface -->
+  <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
+    <xsl:choose>
+      <!-- interfaces within library/if -->
+      <xsl:when test="name(..)='if'">
+        <xsl:call-template name="defineAttributes">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../preceding-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../following-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:when>
+      <!-- interfaces within library -->
+      <xsl:otherwise>
+        <xsl:call-template name="defineAttributes">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:if>
+
+</xsl:template>
+
+<xsl:template name="defineMethods">
+
+  <xsl:param name="iface"/>
+
+  <xsl:apply-templates select="$iface//method[not(@internal='yes')]" mode="define">
+    <xsl:with-param name="namespace" select="."/>
+  </xsl:apply-templates>
+
+  <!-- go to the base interface -->
+  <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
+    <xsl:choose>
+      <!-- interfaces within library/if -->
+      <xsl:when test="name(..)='if'">
+        <xsl:call-template name="defineMethods">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../preceding-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            ../following-sibling::if[@target=../@target]/
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:when>
+      <!-- interfaces within library -->
+      <xsl:otherwise>
+        <xsl:call-template name="defineMethods">
+          <xsl:with-param name="iface" select="
+            preceding-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends] |
+            following-sibling::
+              *[(self::interface or self::collection) and @name=$iface/@extends]
+          "/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:if>
+
+</xsl:template>
+
 <xsl:template name="defineMembers">
-    <xsl:apply-templates select=".//attribute[not(@internal='yes')]" mode="define"/>
-    <xsl:apply-templates select=".//method[not(@internal='yes')]" mode="define"/>
+  <xsl:call-template name="defineAttributes">
+    <xsl:with-param name="iface" select="."/>
+  </xsl:call-template>
+  <xsl:call-template name="defineMethods">
+    <xsl:with-param name="iface" select="."/>
+  </xsl:call-template>
 </xsl:template>
 
 <!-- attribute definitions -->
 <xsl:template match="interface//attribute | collection//attribute" mode="define">
+
+  <xsl:param name="namespace" select="(ancestor::interface | ancestor::collection)[1]"/>
+
   <xsl:apply-templates select="parent::node()" mode="begin"/>
   <xsl:apply-templates select="@if" mode="begin"/>
@@ -573 +809 @@
     <xsl:with-param name="return" select="."/>
     <xsl:with-param name="define" select="'yes'"/>
+    <xsl:with-param name="namespace" select="$namespace"/>
   </xsl:call-template>
   <xsl:if test="not(@readonly='yes')">
@@ -578 +815 @@
       <xsl:with-param name="return" select="''"/>
       <xsl:with-param name="define" select="'yes'"/>
+      <xsl:with-param name="namespace" select="$namespace"/>
     </xsl:call-template>
   </xsl:if>
@@ -583 +821 @@
   <xsl:apply-templates select="parent::node()" mode="end"/>
   <xsl:text>&#x0A;</xsl:text>
+
 </xsl:template>
 
 <!-- method definitions -->
 <xsl:template match="interface//method | collection//method" mode="define">
+
+  <xsl:param name="namespace" select="(ancestor::interface | ancestor::collection)[1]"/>
+
   <xsl:apply-templates select="parent::node()" mode="begin"/>
   <xsl:apply-templates select="@if" mode="begin"/>
   <xsl:call-template name="composeMethod">
     <xsl:with-param name="define" select="'yes'"/>
+    <xsl:with-param name="namespace" select="$namespace"/>
   </xsl:call-template>
   <xsl:apply-templates select="@if" mode="end"/>
   <xsl:apply-templates select="parent::node()" mode="end"/>
   <xsl:text>&#x0A;</xsl:text>
+
 </xsl:template>
 
@@ -622 +866 @@
  *      declaration, or
  *      empty string to produce method declaration only (w/o body)
+ *  @param namespace
+ *      actual interface node for which this method is being defined
+ *      (necessary to properly set a class name for inherited methods).
+ *      If not specified, will default to the parent interface/collection
+ *      node of the method being defined.
 -->
 <xsl:template name="composeMethod">
   <xsl:param name="return" select="param[@dir='return']"/>
   <xsl:param name="define" select="''"/>
-  <xsl:variable name="namespace" select="(ancestor::interface | ancestor::collection)[1]"/>
+  <xsl:param name="namespace" select="(ancestor::interface | ancestor::collection)[1]"/>
   <xsl:choose>
     <!-- no return value -->
@@ -1024 +1273 @@
           <xsl:choose>
             <xsl:when test="@type='$unknown'">
-              <xsl:text>.iface()</xsl:text>
+              <xsl:text>.raw()</xsl:text>
             </xsl:when>
             <xsl:otherwise>
@@ -1038 +1287 @@
           <xsl:choose>
             <xsl:when test="@type='$unknown'">
-              <xsl:text>.ifaceRef()</xsl:text>
+              <xsl:text>.rawRef()</xsl:text>
             </xsl:when>
             <xsl:otherwise>
@@ -1545 +1794 @@
               <xsl:text>&gt; </xsl:text>
             </xsl:when>
+            <!-- GUID is special too -->
+            <xsl:when test="@type='uuid'">
+              <xsl:text>    com::SafeGUIDArray </xsl:text>
+            </xsl:when>
+            <!-- everything else is not -->
             <xsl:otherwise>
               <xsl:text>    com::SafeArray &lt;</xsl:text>

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

@@ -112 +112 @@
     void machineStateChanged (KMachineState state);
     void additionsStateChanged (const QString &, bool, bool, bool);
-    void mediaChanged (VBoxDefs::DiskType aType);
+    void mediaDriveChanged (VBoxDefs::MediaType aType);
     void networkStateChange();
     void usbStateChange();
@@ -241 +241 @@
     bool mAutoresizeGuest : 1;
 
-    /** 
+    /**
      * This flag indicates whether the last console resize should trigger
      * a size hint to the guest.  This is important particularly when

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

@@ -178 +178 @@
     void updateNetworkAdarptersState();
     void updateUsbState();
-    void updateMediaState (VBoxDefs::DiskType aType);
+    void updateMediaDriveState (VBoxDefs::MediaType aType);
     void updateSharedFoldersState();
 

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -106 +106 @@
 struct VBoxDefs
 {
-    /** Disk image type. */
-    enum DiskType { InvalidType, HD = 0x01, CD = 0x02, FD = 0x04 };
+    /** Media type. */
+    enum MediaType
+    {
+        MediaType_Invalid,
+        MediaType_HardDisk,
+        MediaType_DVD,
+        MediaType_Floppy,
+        MediaType_All
+    };
 
     /** VM display rendering mode. */
@@ -126 +133 @@
         MachineStateChangeEventType,
         AdditionsStateChangeEventType,
-        MediaChangeEventType,
+        MediaDriveChangeEventType,
         MachineDataChangeEventType,
         MachineRegisteredEventType,
@@ -138 +145 @@
         RuntimeErrorEventType,
         ModifierKeyChangeEventType,
-        EnumerateMediaEventType,
+        MediaEnumEventType,
 #if defined (Q_WS_WIN)
         ShellExecuteEventType,

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

@@ -50 +50 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-/** Simple media descriptor type. */
-struct VBoxMedia
+/**
+ * Media descriptor for the GUI.
+ *
+ * Maintains the results of the last state (accessibility) check and precomposes
+ * string parameters such as location, size which can be used in various GUI
+ * controls.
+ *
+ * Many getter methods take the boolean @a aNoDiffs argument. Unless explicitly
+ * stated otherwise, this argument, when set to @c true, will cause the
+ * corresponding property of this object's root medium to be returned instead of
+ * its own one. This is useful when hard disk media is represented in the
+ * user-friendly "don't show diffs" mode. For non-hard disk media, the value of
+ * this argument is irrelevant because the root object for such medium is
+ * the medium itself.
+ *
+ * Note that this class "abuses" the KMediaState_NotCreated state value to
+ * indicate that the accessibility check of the given medium (see
+ * #blockAndQueryState()) has not been done yet and therefore some parameters
+ * such as #size() are meaningless because they can be read only from the
+ * accessible medium. The real KMediaState_NotCreated state is not necessary
+ * because this class is only used with created (existing) media.
+ */
+class VBoxMedium
 {
-    enum Status { Unknown, Ok, Error, Inaccessible };
-
-    VBoxMedia() : type (VBoxDefs::InvalidType), status (Ok) {}
-
-    VBoxMedia (const CUnknown &d, VBoxDefs::DiskType t, Status s)
-        : disk (d), type (t), status (s) {}
-
-    CUnknown disk;
-    VBoxDefs::DiskType type;
-    Status status;
+public:
+
+    /**
+     * Creates a null medium descriptor which is not associated with any medium.
+     * The state field is set to KMediaState_NotCreated.
+     */
+    VBoxMedium()
+        : mType (VBoxDefs::MediaType_Invalid)
+        , mState (KMediaState_NotCreated)
+        , mIsReadOnly (false), mIsUsedInSnapshots (false)
+        , mParent (NULL) {}
+
+    /**
+     * Creates a media descriptor associated with the given medium.
+     *
+     * The state field remain KMediaState_NotCreated until #blockAndQueryState()
+     * is called. All precomposed strings are filled up by implicitly calling
+     * #refresh(), see the #refresh() details for more info.
+     *
+     * One of the hardDisk, dvdImage, or floppyImage members is assigned from
+     * aMedium according to aType. @a aParent must be always NULL for non-hard
+     * disk media.
+     */
+    VBoxMedium (const CMedium &aMedium, VBoxDefs::MediaType aType,
+                VBoxMedium *aParent = NULL)
+        : mMedium (aMedium), mType (aType)
+        , mState (KMediaState_NotCreated)
+        , mIsReadOnly (false), mIsUsedInSnapshots (false)
+        , mParent (aParent) { init(); }
+
+    /**
+     * Similar to the other non-null constructor but sets the media state to
+     * @a aState. Suitable when the media state is known such as right after
+     * creation.
+     */
+    VBoxMedium (const CMedium &aMedium, VBoxDefs::MediaType aType,
+                KMediaState aState)
+        : mMedium (aMedium), mType (aType)
+        , mState (aState)
+        , mIsReadOnly (false), mIsUsedInSnapshots (false)
+        , mParent (NULL) { init(); }
+
+    void blockAndQueryState();
+    void refresh();
+
+    const CMedium &medium() const { return mMedium; };
+
+    VBoxDefs::MediaType type() const { return mType; }
+
+    /**
+     * Media state. In "don't show diffs" mode, this is the worst state (in
+     * terms of inaccessibility) detected on the given hard disk chain.
+     *
+     * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+     */
+    KMediaState state (bool aNoDiffs = false) const
+    {
+        unconst (this)->checkNoDiffs (aNoDiffs);
+        return aNoDiffs ? mNoDiffs.state : mState;
+    }
+
+    QString lastAccessError() const { return mLastAccessError; }
+
+    /**
+     * Result of the last blockAndQueryState() call. Will indicate an error and
+     * contain a proper error info if the last state check fails. In "don't show
+     * diffs" mode, this is the worst result (in terms of inaccessibility)
+     * detected on the given hard disk chain.
+     *
+     * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+     */
+    const COMResult &result (bool aNoDiffs = false) const
+    {
+        unconst (this)->checkNoDiffs (aNoDiffs);
+        return aNoDiffs ? mNoDiffs.result : mResult;
+    }
+
+    const CHardDisk2 &hardDisk() const { return mHardDisk; }
+    const CDVDImage2 &dvdImage() const { return mDVDImage; }
+    const CFloppyImage2 &floppyImage() const { return mFloppyImage; }
+
+    QUuid id() const { return mId; }
+
+    QString location (bool aNoDiffs = false) const
+        { return aNoDiffs ? root().mLocation : mLocation; }
+    QString name (bool aNoDiffs = false) const
+        { return aNoDiffs ? root().mName : mName; }
+
+    QString size (bool aNoDiffs = false) const
+        { return aNoDiffs ? root().mSize : mSize; }
+
+    QString hardDiskFormat (bool aNoDiffs = false) const
+        { return aNoDiffs ? root().mHardDiskFormat : mHardDiskFormat; }
+    QString hardDiskType (bool aNoDiffs = false) const
+        { return aNoDiffs ? root().mHardDiskType : mHardDiskType; }
+    QString logicalSize (bool aNoDiffs = false) const
+        { return aNoDiffs ? root().mLogicalSize : mLogicalSize; }
+
+    QString usage (bool aNoDiffs = false) const
+    { return aNoDiffs ? root().mUsage : mUsage; }
+
+    /**
+     * Returns @c true if this medium is read-only (either because it is
+     * Immutable or because it has child hard disks). Read-only media can only
+     * be attached indirectly.
+     */
+    bool isReadOnly() const { return mIsReadOnly; }
+
+    /**
+     * Returns @c true if this medium is attached to any VM (in the current
+     * state or in a snapshot) in which case #usage() will contain a string with
+     * comma-sparated VM names (with snapshot names, if any, in parenthesis).
+     */
+    bool isUsed() const { return !mUsage.isNull(); }
+
+    /**
+     * Returns @c true if this medium is attached to any VM in any snapshot.
+     * which case #usage() will contain a string with comma-sparated VM names.
+     */
+    bool isUsedInSnapshots() const { return mIsUsedInSnapshots; }
+
+    /**
+     * Returns @c true if this medium is attached to the given machine in the
+     * current state.
+     */
+    bool isAttachedInCurStateTo (const QUuid &aMachineId) const
+        { return mCurStateMachineIds.findIndex (aMachineId) >= 0; }
+
+    /**
+     * Returns a vector of IDs of all machines this medium is attached
+     * to in their current state (i.e. excluding snapshots).
+     */
+    const QValueList <QUuid> &curStateMachineIds() const
+        { return mCurStateMachineIds; }
+
+    /**
+     * Returns a parent medium. For non-hard disk media, this is always NULL.
+     */
+    VBoxMedium *parent() const { return mParent; }
+
+    VBoxMedium &root() const;
+
+    QString toolTip(bool aNoDiffs = false, bool aCheckRO = false) const;
+    QPixmap icon (bool aNoDiffs = false, bool aCheckRO = false) const;
+
+    /** Shortcut to <tt>#toolTip (aNoDiffs, true)</tt>. */
+    QString toolTipCheckRO (bool aNoDiffs = false) const
+        { return toolTip (aNoDiffs, true); }
+
+    /** Shortcut to <tt>#icon (aNoDiffs, true)</tt>. */
+    QPixmap iconCheckRO (bool aNoDiffs = false) const
+        { return icon (aNoDiffs, true); }
+
+    QString details (bool aNoDiffs = false, bool aPredictDiff = false,
+                     bool aUseHTML = false) const;
+
+    /** Shortcut to <tt>#details (aNoDiffs, aPredictDiff, true)</tt>. */
+    QString detailsHTML (bool aNoDiffs = false, bool aPredictDiff = false) const
+        { return details (aNoDiffs, aPredictDiff, true); }
+
+    /** Returns @c true if this media descriptor is a null object. */
+    bool isNull() const { return mMedium.isNull(); }
+
+private:
+
+    void init();
+
+    void checkNoDiffs (bool aNoDiffs);
+
+    CMedium mMedium;
+
+    VBoxDefs::MediaType mType;
+
+    KMediaState mState;
+    QString mLastAccessError;
+    COMResult mResult;
+
+    CHardDisk2 mHardDisk;
+    CDVDImage2 mDVDImage;
+    CFloppyImage2 mFloppyImage;
+
+    QUuid mId;
+    QString mLocation;
+    QString mName;
+    QString mSize;
+
+    QString mHardDiskFormat;
+    QString mHardDiskType;
+    QString mLogicalSize;
+
+    QString mUsage;
+    QString mToolTip;
+
+    bool mIsReadOnly        : 1;
+    bool mIsUsedInSnapshots : 1;
+
+    QValueList <QUuid> mCurStateMachineIds;
+
+    VBoxMedium *mParent;
+
+    /**
+     * Used to override some attributes in the user-friendly "don't show diffs"
+     * mode.
+     */
+    struct NoDiffs
+    {
+        NoDiffs() : isSet (false), state (KMediaState_NotCreated) {}
+
+        bool isSet : 1;
+
+        KMediaState state;
+        COMResult result;
+        QString toolTip;
+    }
+    mNoDiffs;
 };
 
-typedef QValueList <VBoxMedia> VBoxMediaList;
+typedef QValueList <VBoxMedium> VBoxMediaList;
 
 // VirtualBox callback events
@@ -255 +481 @@
     }
 
-    QString toString (KHardDiskStorageType t) const
-    {
-        AssertMsg (!diskStorageTypes [t].isNull(), ("No text for %d", t));
-        return diskStorageTypes [t];
+    /**
+     * Similar to toString (KHardDiskType), but returns 'Differencing' for
+     * normal hard disks that have a parent.
+     */
+    QString hardDiskTypeString (const CHardDisk2 &aHD) const
+    {
+        if (!aHD.GetParent().isNull())
+        {
+            Assert (aHD.GetType() == KHardDiskType_Normal);
+            return diskTypes_Differencing;
+        }
+        return toString (aHD.GetType());
     }
 
@@ -331 +565 @@
     }
 
-    /**
-     *  Similar to toString (KHardDiskType), but returns 'Differencing'
-     *  for normal hard disks that have a parent hard disk.
-     */
-    QString hardDiskTypeString (const CHardDisk &aHD) const
-    {
-        if (!aHD.GetParent().isNull())
-        {
-            Assert (aHD.GetType() == KHardDiskType_Normal);
-            return tr ("Differencing", "hard disk");
-        }
-        return toString (aHD.GetType());
-    }
-
     QString toString (KDeviceType t) const
     {
@@ -436 +656 @@
     }
 
+    QPixmap warningIcon() const { return mWarningIcon; }
+    QPixmap errorIcon() const { return mErrorIcon; }
+
     /* details generators */
 
-    QString details (const CHardDisk &aHD, bool aPredict = false,
-                     bool aDoRefresh = true);
+    QString details (const CHardDisk2 &aHD, bool aPredictDiff);
 
     QString details (const CUSBDevice &aDevice) const;
     QString toolTip (const CUSBDevice &aDevice) const;
 
-    QString prepareFileNameForHTML (const QString &fn) const;
-
-    QString detailsReport (const CMachine &m, bool isNewVM, bool withLinks,
-                           bool aDoRefresh = true);
+    QString detailsReport (const CMachine &aMachine, bool aIsNewVM,
+                           bool aWithLinks);
 
     /* VirtualBox helpers */
@@ -467 +687 @@
 
     /**
-     *  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 a list of all currently registered media. This list is used to
+     * globally track the accessiblity state of all media on a dedicated thread.
+     *
+     * Note that the media list is initially empty (i.e. before the enumeration
+     * process is started for the first time using #startEnumeratingMedia()).
+     * See #startEnumeratingMedia() for more information about how meida are
+     * sorted in the returned list.
+     */
+    const VBoxMediaList &currentMediaList() const { return mMediaList; }
 
     /** 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 &);
-
-    bool findMedia (const CUnknown &, VBoxMedia &) const;
+    bool isMediaEnumerationStarted() const { return mMediaEnumThread != NULL; }
+
+    void addMedium (const VBoxMedium &);
+    void updateMedium (const VBoxMedium &);
+    void removeMedium (VBoxDefs::MediaType, const QUuid &);
+
+    bool findMedium (const CMedium &, VBoxMedium &) const;
+
+    /** Compact version of #findMediumTo(). Asserts if not found. */
+    VBoxMedium getMedium (const CMedium &aObj) const
+    {
+        VBoxMedium medium;
+        if (!findMedium (aObj, medium))
+            AssertFailed();
+        return medium;
+    }
 
     /* various helpers */
@@ -526 +758 @@
     static QString formatSize (Q_UINT64, int aMode = 0);
 
+    static QString locationForHTML (const QString &aFileName);
+
     static QString highlight (const QString &aStr, bool aToolTip = false);
 
@@ -547 +781 @@
     static QString removeAccelMark (const QString &aText);
 
+    static QPixmap joinPixmaps (const QPixmap &aPM1, const QPixmap &aPM2);
+
     static QWidget *findWidget (QWidget *aParent, const char *aName,
                                 const char *aClassName = NULL,
@@ -554 +790 @@
 
     /**
-     *  Emitted at the beginning of the enumeration process started
-     *  by #startEnumeratingMedia().
+     * 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);
-
-    /**
-     *  Emitted at the end of the enumeration process started
-     *  by #startEnumeratingMedia(). The @a aList argument is passed for
-     *  convenience, it is exactly the same as returned by #currentMediaList().
+     * Emitted when a new medium item from the list has updated its
+     * accessibility state.
+     */
+    void mediumEnumerated (const VBoxMedium &aMedum, int aIndex);
+
+    /**
+     * Emitted at the end of the enumeration process started by
+     * #startEnumeratingMedia(). The @a aList argument is passed for
+     * convenience, it is exactly the same as returned by #currentMediaList().
      */
     void mediaEnumFinished (const VBoxMediaList &aList);
 
     /** Emitted when a new media is added using #addMedia(). */
-    void mediaAdded (const VBoxMedia &);
+    void mediumAdded (const VBoxMedium &);
 
     /** Emitted when the media is updated using #updateMedia(). */
-    void mediaUpdated (const VBoxMedia &);
+    void mediumUpdated (const VBoxMedium &);
 
     /** Emitted when the media is removed using #removeMedia(). */
-    void mediaRemoved (VBoxDefs::DiskType, const QUuid &);
+    void mediumRemoved (VBoxDefs::MediaType, const QUuid &);
 
     /* signals emitted when the VirtualBox callback is called by the server
@@ -626 +862 @@
     QUuid vmUuid;
 
-    QThread *media_enum_thread;
-    VBoxMediaList media_list;
+    QThread *mMediaEnumThread;
+    VBoxMediaList mMediaList;
 
     VBoxDefs::RenderMode vm_render_mode;
@@ -657 +893 @@
     QStringVector sessionStates;
     QStringVector deviceTypes;
+
     QStringVector storageBuses;
     QStringVector storageBusDevices;
     QStringVector storageBusChannels;
+
     QStringVector diskTypes;
-    QStringVector diskStorageTypes;
+    QString diskTypes_Differencing;
+
     QStringVector vrdpAuthTypes;
     QStringVector portModeTypes;
@@ -674 +913 @@
 
     QString mUserDefinedPortName;
+
+    QPixmap mWarningIcon, mErrorIcon;
 
     mutable bool detailReportTemplatesReady;

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

@@ -27 +27 @@
 
 #include <qcombobox.h>
+#include <qvaluelist.h>
 
 class QListBoxItem;
@@ -36 +37 @@
 public:
 
-    VBoxMediaComboBox (QWidget *aParent = 0, const char *aName = 0,
-                       int aType = 0, bool aUseEmptyItem = false);
+    typedef QMap <QUuid, QUuid> BaseToDiffMap;
+
+    VBoxMediaComboBox (QWidget *aParent, const char *aName,
+                       VBoxDefs::MediaType aType, QUuid aMachineId = QUuid());
     ~VBoxMediaComboBox() {}
 
-    void  refresh();
-    void  setUseEmptyItem (bool);
-    void  setBelongsTo (const QUuid &);
-    QUuid getId (int aId = -1);
-    QUuid getBelongsTo();
-    void  setCurrentItem (const QUuid &);
-    void  setType (int);
+    void refresh();
+    void repopulate();
+
+    QUuid id (int = -1);
+    QString location (int = -1);
+
+    void setCurrentItem (const QUuid &);
+    void setType (VBoxDefs::MediaType);
+
+    void setShowDiffs (bool aShowDiffs);
+    bool showDiffs() const { return mShowDiffs; }
 
 protected slots:
 
     void mediaEnumStarted();
-    void mediaEnumerated (const VBoxMedia &, int);
-    void mediaAdded (const VBoxMedia &);
-    void mediaUpdated (const VBoxMedia &);
-    void mediaRemoved (VBoxDefs::DiskType, const QUuid &);
+    void mediumEnumerated (const VBoxMedium &, int);
+    void mediumAdded (const VBoxMedium &);
+    void mediumUpdated (const VBoxMedium &);
+    void mediumRemoved (VBoxDefs::MediaType, const QUuid &);
     void processOnItem (QListBoxItem *);
     void processActivated (int);
@@ -60 +67 @@
 protected:
 
+    void addNoMediaItem();
+
     void updateToolTip (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;
-    QStringList mUuidList;
-    QStringList mTipList;
-    QUuid       mMachineId;
-    QUuid       mRequiredId;
-    bool        mUseEmptyItem;
-    QPixmap     mPmInacc;
-    QPixmap     mPmError;
+    void appendItem (const VBoxMedium &);
+    void replaceItem (int, const VBoxMedium &);
+
+    bool findMediaIndex (const QUuid &aId, size_t &aIndex);
+
+    VBoxDefs::MediaType mType;
+
+    /** Obtruncated VBoxMedium structure. */
+    struct Medium
+    {
+        Medium() {}
+        Medium (const QUuid &aId, const QString &aLocation,
+                const QString aToolTip)
+            : id (aId), location (aLocation), toolTip (aToolTip) {}
+
+        QUuid id;
+        QString location;
+        QString toolTip;
+    };
+
+    typedef QValueVector <Medium> Media;
+    Media mMedia;
+
+    QUuid mLastId;
+
+    bool mShowDiffs : 1;
+
+    QUuid mMachineId;
 };
 

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -29 +29 @@
 #include <qobject.h>
 
+class VBoxMedium;
+
 class QProcess;
 
@@ -147 +149 @@
     void cannotSaveGlobalConfig (const CVirtualBox &vbox);
     void cannotSetSystemProperties (const CSystemProperties &props);
-    void cannotAccessUSB (const COMBase &obj);
+    void cannotAccessUSB (const COMBaseWithEI &obj);
 
     void cannotCreateMachine (const CVirtualBox &vbox,
@@ -175 +177 @@
 
     void cannotSetSnapshotFolder (const CMachine &aMachine, const QString &aPath);
-    void cannotDiscardSnapshot (const CConsole &console, const CSnapshot &snapshot);
-    void cannotDiscardSnapshot (const CProgress &progress, const CSnapshot &snapshot);
+    void cannotDiscardSnapshot (const CConsole &aConsole,
+                                const QString &aSnapshotName);
+    void cannotDiscardSnapshot (const CProgress &aProgress,
+                                const QString &aSnapshotName);
     void cannotDiscardCurrentState (const CConsole &console);
     void cannotDiscardCurrentState (const CProgress &progress);
@@ -192 +196 @@
     bool confirmDiscardSavedState (const CMachine &machine);
 
-    bool confirmReleaseImage (QWidget *parent, const QString &usage);
-
-    void sayCannotOverwriteHardDiskImage (QWidget *parent, const QString &src);
-    int confirmHardDiskImageDeletion (QWidget *parent, const QString &src);
-    void cannotDeleteHardDiskImage (QWidget *parent, const CVirtualDiskImage &vdi);
-
-    bool confirmHardDiskUnregister (QWidget *parent, const QString &src);
+    bool confirmReleaseMedium (QWidget *aParent, const VBoxMedium &aMedium,
+                               const QString &aUsage);
+
+    bool confirmRemoveMedium (QWidget *aParent, const VBoxMedium &aMedium);
+
+    void sayCannotOverwriteHardDiskStorage (QWidget *aParent,
+                                            const QString &aLocation);
+    int confirmDeleteHardDiskStorage (QWidget *aParent,
+                                      const QString &aLocation);
+    void cannotDeleteHardDiskStorage (QWidget *aParent, const CHardDisk2 &aHD,
+                                      const CProgress &aProgress);
 
     int confirmDetachSATASlots (QWidget *aParent);
     int confirmRunNewHDWzdOrVDM (QWidget *aParent);
 
-    void cannotCreateHardDiskImage (
-        QWidget *parent, const CVirtualBox &vbox, const QString &src,
-        const CVirtualDiskImage &vdi, const CProgress &progress);
-    void cannotAttachHardDisk (QWidget *parent, const CMachine &m, const QUuid &id,
-                               KStorageBus bus, LONG channel, LONG dev);
-    void cannotDetachHardDisk (QWidget *parent, const CMachine &m,
-                               KStorageBus bus, LONG channel, LONG dev);
-    void cannotRegisterMedia (QWidget *parent, const CVirtualBox &vbox,
-                              VBoxDefs::DiskType type, const QString &src);
-    void cannotUnregisterMedia (QWidget *parent, const CVirtualBox &vbox,
-                                VBoxDefs::DiskType type, const QString &src);
+    void cannotCreateHardDiskStorage (QWidget *aParent, const CVirtualBox &aVBox,
+                                      const QString &aLocaiton,
+                                      const CHardDisk2 &aHD,
+                                      const CProgress &aProgress);
+    void cannotAttachHardDisk (QWidget *aParent, const CMachine &aMachine,
+                               const QString &aLocation, KStorageBus aBus,
+                               LONG aChannel, LONG aDevice);
+    void cannotDetachHardDisk (QWidget *aParent, const CMachine &aMachine,
+                               const QString &aLocation, KStorageBus aBus,
+                               LONG aChannel, LONG aDevice);
+
+    void cannotMountMedium (QWidget *aParent, const CMachine &aMachine,
+                            const VBoxMedium &aMedium, const COMResult &aResult);
+    void cannotUnmountMedium (QWidget *aParent, const CMachine &aMachine,
+                            const VBoxMedium &aMedium, const COMResult &aResult);
+
+    void cannotOpenMedium (QWidget *aParent, const CVirtualBox &aVBox,
+                           VBoxDefs::MediaType aType, const QString &aLocation);
+    void cannotCloseMedium (QWidget *aParent, const VBoxMedium &aMedium,
+                            const COMResult &aResult);
 
     void cannotOpenSession (const CSession &session);
@@ -219 +236 @@
                             const CProgress &progress = CProgress());
 
-    void cannotGetMediaAccessibility (const CUnknown &unk);
-
-/// @todo (r=dmik) later
-//    void cannotMountMedia (const CUnknown &unk);
-//    void cannotUnmountMedia (const CUnknown &unk);
+    void cannotGetMediaAccessibility (const VBoxMedium &aMedium);
 
 #if defined Q_WS_WIN
@@ -297 +310 @@
                            const QString &errorMsg);
 
+    static QString toAccusative (VBoxDefs::MediaType aType);
+
     static QString formatRC (HRESULT aRC);
 
@@ -307 +322 @@
     }
 
-    static QString formatErrorInfo (const COMBase &aWrapper)
+    static QString formatErrorInfo (const COMBaseWithEI &aWrapper)
     {
         Assert (aWrapper.lastRC() != S_OK);

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

@@ -62 +62 @@
 public slots:
 
-    void fileDiskMgr();
+    void fileMediaMgr();
     void fileSettings();
     void fileExit();
@@ -117 +117 @@
 
     /* actions */
-    QAction *fileDiskMgrAction;
+    QAction *fileMediaMgrAction;
     QAction *fileSettingsAction;
     QAction *fileExitAction;

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

@@ -208 +208 @@
 }
 
+/* static */
+void COMBase::ToSafeArray (const QValueVector <QUuid> &aVec,
+                           com::SafeGUIDArray &aArr)
+{
+    AssertCompileSize (GUID, sizeof (QUuid));
+    aArr.reset (aVec.size());
+    size_t i = 0;
+    for (QValueVector <QUuid>::const_iterator it = aVec.begin();
+         it != aVec.end(); ++ it, ++ i)
+        aArr [i] = *(GUID *) &(*it);
+}
+
+/* static */
+void COMBase::FromSafeArray (const com::SafeGUIDArray &aArr,
+                             QValueVector <QUuid> &aVec)
+{
+    AssertCompileSize (GUID, sizeof (QUuid));
+    aVec = QValueVector <QUuid> (aArr.size());
+    size_t i = 0;
+    for (QValueVector <QUuid>::iterator it = aVec.begin();
+         it != aVec.end(); ++ it, ++ i)
+        *it = *(QUuid *) &aArr [i];
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 

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

@@ -269 +269 @@
 };
 
-/** DVD/FD change event */
-class MediaChangeEvent : public QEvent
+/** DVD/Floppy drive change event */
+class MediaDriveChangeEvent : public QEvent
 {
 public:
-    MediaChangeEvent (VBoxDefs::DiskType aType)
-        : QEvent ((QEvent::Type) VBoxDefs::MediaChangeEventType)
+    MediaDriveChangeEvent (VBoxDefs::MediaType aType)
+        : QEvent ((QEvent::Type) VBoxDefs::MediaDriveChangeEventType)
         , mType (aType) {}
-    VBoxDefs::DiskType diskType() const { return mType; }
+    VBoxDefs::MediaType type() const { return mType; }
 private:
-    VBoxDefs::DiskType mType;
+    VBoxDefs::MediaType mType;
 };
 
@@ -465 +465 @@
     {
         LogFlowFunc (("DVD Drive changed\n"));
-        QApplication::postEvent (mView, new MediaChangeEvent (VBoxDefs::CD));
+        QApplication::postEvent (mView,
+            new MediaDriveChangeEvent (VBoxDefs::MediaType_DVD));
         return S_OK;
     }
@@ -472 +473 @@
     {
         LogFlowFunc (("Floppy Drive changed\n"));
-        QApplication::postEvent (mView, new MediaChangeEvent (VBoxDefs::FD));
+        QApplication::postEvent (mView,
+            new MediaDriveChangeEvent (VBoxDefs::MediaType_Floppy));
         return S_OK;
     }
@@ -1217 +1219 @@
             }
 
-            case VBoxDefs::MediaChangeEventType:
-            {
-                MediaChangeEvent *mce = (MediaChangeEvent *) e;
+            case VBoxDefs::MediaDriveChangeEventType:
+            {
+                MediaDriveChangeEvent *mce = (MediaDriveChangeEvent *) e;
                 LogFlowFunc (("MediaChangeEvent\n"));
 
-                emit mediaChanged (mce->diskType());
+                emit mediaDriveChanged (mce->type());
                 return true;
             }

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -25 +25 @@
 #include "VBoxCloseVMDlg.h"
 #include "VBoxTakeSnapshotDlg.h"
-#include "VBoxDiskImageManagerDlg.h"
+#include "VBoxMediaManagerDlg.h"
 #include "VBoxVMFirstRunWzd.h"
 #include "VBoxSharedFoldersSettings.h"
@@ -817 +817 @@
     connect (console, SIGNAL (additionsStateChanged (const QString&, bool, bool, bool)),
              this, SLOT (updateAdditionsState (const QString &, bool, bool, bool)));
-    connect (console, SIGNAL (mediaChanged (VBoxDefs::DiskType)),
-             this, SLOT (updateMediaState (VBoxDefs::DiskType)));
+    connect (console, SIGNAL (mediaDriveChanged (VBoxDefs::MediaType)),
+             this, SLOT (updateMediaDriveState (VBoxDefs::MediaType)));
     connect (console, SIGNAL (usbStateChange()),
              this, SLOT (updateUsbState()));
@@ -1678 +1678 @@
                 name = tr ("<br><nobr><b>Image</b>: %1</nobr>",
                            "Floppy tooltip")
-                    .arg (QDir::convertSeparators (floppy.GetImage().GetFilePath()));
+                    .arg (QDir::convertSeparators (floppy.GetImage().GetLocation()));
                 break;
             }
@@ -1722 +1722 @@
                 name = tr ("<br><nobr><b>Image</b>: %1</nobr>",
                            "DVD-ROM tooltip")
-                    .arg (QDir::convertSeparators (dvd.GetImage().GetFilePath()));
+                    .arg (QDir::convertSeparators (dvd.GetImage().GetLocation()));
                 break;
             }
@@ -1743 +1743 @@
         QString data;
         bool hasDisks = false;
-        CHardDiskAttachmentEnumerator aen = cmachine.GetHardDiskAttachments().Enumerate();
-        while (aen.HasMore())
-        {
-            CHardDiskAttachment hda = aen.GetNext();
-            CHardDisk hd = hda.GetHardDisk();
+        CHardDisk2AttachmentVector vec = cmachine.GetHardDisk2Attachments();
+        for (CHardDisk2AttachmentVector::ConstIterator hda = vec.begin();
+             hda != vec.end(); ++ hda)
+        {
+            CHardDisk2 hd = hda->GetHardDisk();
             data += QString ("<br><nobr><b>%1 %2</b>: %3</nobr>")
-                .arg (vboxGlobal().toString (hda.GetBus(), hda.GetChannel()))
-                .arg (vboxGlobal().toString (hda.GetBus(), hda.GetChannel(),
-                                             hda.GetDevice()))
+                .arg (vboxGlobal().toString (hda->GetBus(), hda->GetChannel()))
+                .arg (vboxGlobal().toString (hda->GetBus(), hda->GetChannel(),
+                                             hda->GetDevice()))
                 .arg (QDir::convertSeparators (hd.GetLocation()));
             hasDisks = true;
@@ -2500 +2500 @@
     if (!console) return;
 
-    VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg", WType_Dialog | WShowModal);
-    QUuid id = csession.GetMachine().GetId();
-    dlg.setup (VBoxDefs::FD, true, &id);
-
-    if (dlg.exec() == VBoxDiskImageManagerDlg::Accepted)
+    VBoxMediaManagerDlg dlg (this, "VBoxMediaManagerDlg", WType_Dialog | WShowModal);
+
+    dlg.setup (VBoxDefs::MediaType_Floppy, true /* aDoSelect */,
+               true /* aRefresh */, csession.GetMachine());
+
+    if (dlg.exec() == VBoxMediaManagerDlg::Accepted)
     {
         CFloppyDrive drv = csession.GetMachine().GetFloppyDrive();
-        drv.MountImage (dlg.getSelectedUuid());
+        drv.MountImage (dlg.selectedId());
         AssertWrapperOk (drv);
         if (drv.isOk())
@@ -2544 +2545 @@
     if (!console) return;
 
-    VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg", WType_Dialog | WShowModal);
-    QUuid id = csession.GetMachine().GetId();
-    dlg.setup (VBoxDefs::CD, true, &id);
-
-    if (dlg.exec() == VBoxDiskImageManagerDlg::Accepted)
+    VBoxMediaManagerDlg dlg (this, "VBoxMediaManagerDlg", WType_Dialog | WShowModal);
+
+    dlg.setup (VBoxDefs::MediaType_DVD, true /* aDoSelect */,
+               true /* aRefresh */, csession.GetMachine());
+
+    if (dlg.exec() == VBoxMediaManagerDlg::Accepted)
     {
         CDVDDrive drv = csession.GetMachine().GetDVDDrive();
-        drv.MountImage (dlg.getSelectedUuid());
+        drv.MountImage (dlg.selectedId());
         AssertWrapperOk (drv);
         if (drv.isOk())
@@ -2628 +2630 @@
     else
     {
-        /* Check for the already registered required image: */
+        /* Check for the already registered required image */
         CVirtualBox vbox = vboxGlobal().virtualBox();
         QString name = QString ("VBoxGuestAdditions_%1.iso")
                                  .arg (vbox.GetVersion().remove ("_OSE"));
-        CDVDImageEnumerator en = vbox.GetDVDImages().Enumerate();
-        while (en.HasMore())
-        {
-            QString path = en.GetNext().GetFilePath();
-            /* compare the name part ignoring the file case*/
+
+        CDVDImage2Vector vec = vbox.GetDVDImages();
+        for (CDVDImage2Vector::ConstIterator it = vec.begin();
+             it != vec.end(); ++ it)
+        {
+            QString path = it->GetLocation();
+            /* compare the name part ignoring the file case */
             QString fn = QFileInfo (path).fileName();
             if (RTPathCompare (name.utf8(), fn.utf8()) == 0)
                 return installGuestAdditionsFrom (path);
         }
-        /* Download required image: */
+
+        /* Download the required image */
         int rc = vboxProblem().cannotFindGuestAdditions (
             QDir::convertSeparators (src1), QDir::convertSeparators (src2));
@@ -2662 +2667 @@
     QUuid uuid;
 
-    CDVDImage image = vbox.FindDVDImage (aSource);
+    CDVDImage2 image = vbox.FindDVDImage (aSource);
     if (image.isNull())
     {
         image = vbox.OpenDVDImage (aSource, uuid);
         if (vbox.isOk())
-            vbox.RegisterDVDImage (image);
-        if (vbox.isOk())
             uuid = image.GetId();
     }
@@ -2676 +2679 @@
     if (!vbox.isOk())
     {
-        vboxProblem().cannotRegisterMedia (this, vbox, VBoxDefs::CD, aSource);
+        vboxProblem().cannotOpenMedium (this, vbox,
+                                        VBoxDefs::MediaType_DVD, aSource);
         return;
     }
@@ -2683 +2687 @@
     CDVDDrive drv = csession.GetMachine().GetDVDDrive();
     drv.MountImage (uuid);
-    /// @todo (r=dmik) use VBoxProblemReporter::cannotMountMedia...
+    /// @todo NEWMEDIA use VBoxProblemReporter::cannotMountMedia
     AssertWrapperOk (drv);
 }
@@ -3304 +3308 @@
 }
 
-void VBoxConsoleWnd::updateMediaState (VBoxDefs::DiskType aType)
-{
-    Assert (aType == VBoxDefs::CD || aType == VBoxDefs::FD);
-    updateAppearanceOf (aType == VBoxDefs::CD ? DVDStuff :
-                        aType == VBoxDefs::FD ? FloppyStuff : AllStuff);
+void VBoxConsoleWnd::updateMediaDriveState (VBoxDefs::MediaType aType)
+{
+    Assert (aType == VBoxDefs::MediaType_DVD || aType == VBoxDefs::MediaType_Floppy);
+    updateAppearanceOf (aType == VBoxDefs::MediaType_DVD ? DVDStuff :
+                        aType == VBoxDefs::MediaType_Floppy ? FloppyStuff :
+                        AllStuff);
 }
 
@@ -3452 +3457 @@
 bool VBoxConsoleWnd::dbgCreated()
 {
+#if 0
+    /// @todo needs to be ported back from VirtualBox4
     if (dbg_gui)
         return true;
-    int rc = DBGGuiCreate (csession.iface(), &dbg_gui, NULL);
+    int rc = DBGGuiCreate (csession.raw(), &dbg_gui);
     if (VBOX_SUCCESS (rc))
     {
@@ -3460 +3467 @@
         return true;
     }
+#endif
     return false;
 }

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -97 +97 @@
 #endif
 
-// VBoxEnumerateMediaEvent
+// VBoxMedium
 /////////////////////////////////////////////////////////////////////////////
 
-class VBoxEnumerateMediaEvent : public QEvent
+void VBoxMedium::init()
+{
+    AssertReturnVoid (!mMedium.isNull());
+
+    switch (mType)
+    {
+        case VBoxDefs::MediaType_HardDisk:
+        {
+            mHardDisk = mMedium;
+            AssertReturnVoid (!mHardDisk.isNull());
+            break;
+        }
+        case VBoxDefs::MediaType_DVD:
+        {
+            mDVDImage = mMedium;
+            AssertReturnVoid (!mDVDImage.isNull());
+            Assert (mParent == NULL);
+            break;
+        }
+        case VBoxDefs::MediaType_Floppy:
+        {
+            mFloppyImage = mMedium;
+            AssertReturnVoid (!mFloppyImage.isNull());
+            Assert (mParent == NULL);
+            break;
+        }
+        default:
+            AssertFailed();
+    }
+
+    refresh();
+}
+
+/**
+ * Queries the medium state. Call this and then read the state field instad
+ * of calling GetState() on medium directly as it will properly handle the
+ * situation when GetState() itself fails by setting state to Inaccessible
+ * and memorizing the error info describing why GetState() failed.
+ *
+ * As the last step, this method calls #refresh() to refresh all precomposed
+ * strings.
+ *
+ * @note This method blocks for the duration of the state check. Since this
+ *       check may take quite a while (e.g. for a medium located on a
+ *       network share), the calling thread must not be the UI thread. You
+ *       have been warned.
+ */
+void VBoxMedium::blockAndQueryState()
+{
+    mState = mMedium.GetState();
+
+    /* save the result to distinguish between inaccessible and e.g.
+     * uninitialized objects */
+    mResult = COMResult (mMedium);
+
+    if (!mResult.isOk())
+    {
+        mState = KMediaState_Inaccessible;
+        mLastAccessError = QString::null;
+    }
+    else
+        mLastAccessError = mMedium.GetLastAccessError();
+
+    refresh();
+}
+
+/**
+ * Refreshes the precomposed strings containing such media parameters as
+ * location, size by querying the respective data from the associated
+ * media object.
+ *
+ * Note that some string such as #size() are meaningless if the media state is
+ * KMediaState_NotCreated (i.e. the medium has not yet been checked for
+ * accessibility).
+ */
+void VBoxMedium::refresh()
+{
+    mId = mMedium.GetId();
+    mLocation = mMedium.GetLocation();
+    mName = mMedium.GetName();
+
+    if (mType == VBoxDefs::MediaType_HardDisk)
+    {
+        /// @todo NEWMEDIA use CSystemProperties::GetHardDIskFormats to see if the
+        /// given hard disk format is a file
+        mLocation = QDir::convertSeparators (mLocation);
+        mHardDiskFormat = mHardDisk.GetFormat();
+        mHardDiskType = vboxGlobal().hardDiskTypeString (mHardDisk);
+
+        mIsReadOnly = mHardDisk.GetReadOnly();
+
+        /* adjust the parent if necessary (note that mParent must always point
+         * to an item from VBoxGlobal::currentMediaList()) */
+
+        CHardDisk2 parent = mHardDisk.GetParent();
+        Assert (!parent.isNull() || mParent == NULL);
+
+        if (!parent.isNull() &&
+            (mParent == NULL || mParent->mHardDisk != parent))
+        {
+            /* search for the parent (must be there) */
+            const VBoxMediaList &list = vboxGlobal().currentMediaList();
+            for (VBoxMediaList::const_iterator it = list.begin();
+                  it != list.end(); ++ it)
+            {
+                if ((*it).mType != VBoxDefs::MediaType_HardDisk)
+                    break;
+
+                if ((*it).mHardDisk == parent)
+                {
+                    /* we unconst here because by the const list we don't mean
+                     * const items */
+                    mParent = unconst (&*it);
+                    break;
+                }
+            }
+
+            Assert (mParent != NULL && mParent->mHardDisk == parent);
+        }
+    }
+    else
+    {
+        mLocation = QDir::convertSeparators (mLocation);
+        mHardDiskFormat = QString::null;
+        mHardDiskType = QString::null;
+
+        mIsReadOnly = false;
+    }
+
+    if (mState != KMediaState_Inaccessible &&
+        mState != KMediaState_NotCreated)
+    {
+        mSize = vboxGlobal().formatSize (mMedium.GetSize());
+        if (mType == VBoxDefs::MediaType_HardDisk)
+            mLogicalSize = vboxGlobal()
+                .formatSize (mHardDisk.GetLogicalSize() * _1M);
+        else
+            mLogicalSize = mSize;
+    }
+    else
+    {
+        mSize = mLogicalSize = QString ("--");
+    }
+
+    /* detect usage */
+
+    mUsage = QString::null; /* important: null means not used! */
+
+    mCurStateMachineIds.clear();
+
+    QValueVector <QUuid> machineIds = mMedium.GetMachineIds();
+    if (machineIds.size() > 0)
+    {
+        QString usage;
+
+        CVirtualBox vbox = vboxGlobal().virtualBox();
+
+        for (QValueVector <QUuid>::ConstIterator it = machineIds.begin();
+             it != machineIds.end(); ++ it)
+        {
+            CMachine machine = vbox.GetMachine (*it);
+
+            QString name = machine.GetName();
+            QString snapshots;
+
+            QValueVector <QUuid> snapIds = mMedium.GetSnapshotIds (*it);
+            for (QValueVector <QUuid>::ConstIterator jt = snapIds.begin();
+                 jt != snapIds.end(); ++ jt)
+            {
+                if (*jt == *it)
+                {
+                    /* the medium is attached to the machine in the current
+                     * state, we don't distinguish this for now by always
+                     * giving the VM name in front of snapshot names. */
+
+                    mCurStateMachineIds.push_back (*jt);
+                    continue;
+                }
+
+                CSnapshot snapshot = machine.GetSnapshot (*jt);
+                if (!snapshots.isNull())
+                    snapshots += ", ";
+                snapshots += snapshot.GetName();
+            }
+
+            if (!usage.isNull())
+                usage += ", ";
+
+            usage += name;
+
+            if (!snapshots.isNull())
+            {
+                usage += QString (" (%2)").arg (snapshots);
+                mIsUsedInSnapshots = true;
+            }
+            else
+                mIsUsedInSnapshots = false;
+        }
+
+        Assert (!usage.isEmpty());
+        mUsage = usage;
+    }
+
+    /* compose the tooltip (makes sense to keep the format in sync with
+     * VBoxMediaManagerDlg::languageChangeImp() and
+     * VBoxMediaManagerDlg::processCurrentChanged()) */
+
+    mToolTip = QString ("<nobr><b>%1</b></nobr>").arg (mLocation);
+
+    if (mType == VBoxDefs::MediaType_HardDisk)
+    {
+        mToolTip += VBoxGlobal::tr (
+            "<br><nobr>Type&nbsp;(Format):&nbsp;&nbsp;%2&nbsp;(%3)</nobr>",
+            "hard disk")
+            .arg (mHardDiskType)
+            .arg (mHardDiskFormat);
+    }
+
+    mToolTip += VBoxGlobal::tr (
+        "<br><nobr>Attached to:&nbsp;&nbsp;%1</nobr>", "medium")
+        .arg (mUsage.isNull() ?
+              VBoxGlobal::tr ("<i>Not&nbsp;Attached</i>", "medium") :
+              mUsage);
+
+    switch (mState)
+    {
+        case KMediaState_NotCreated:
+        {
+            mToolTip += VBoxGlobal::tr ("<br><i>Checking accessibility...</i>",
+                                        "medium");
+            break;
+        }
+        case KMediaState_Inaccessible:
+        {
+            if (mResult.isOk())
+            {
+                /* not accessibile */
+                mToolTip += QString ("<hr>%1").
+                    arg (VBoxGlobal::highlight (mLastAccessError,
+                                                true /* aToolTip */));
+            }
+            else
+            {
+                /* accessibility check (eg GetState()) itself failed */
+                mToolTip = VBoxGlobal::tr (
+                    "<hr>Failed to check media accessibility.<br>%1.",
+                    "medium").
+                    arg (VBoxProblemReporter::formatErrorInfo (mResult));
+            }
+            break;
+        }
+        default:
+            break;
+    }
+
+    /* reset mNoDiffs */
+    mNoDiffs.isSet = false;
+}
+
+/**
+ * Returns a root medium of this medium. For non-hard disk media, this is always
+ * this medium itself.
+ */
+VBoxMedium &VBoxMedium::root() const
+{
+    VBoxMedium *root = unconst (this);
+    while (root->mParent != NULL)
+        root = root->mParent;
+
+    return *root;
+}
+
+/**
+ * Returns a tooltip for this medium.
+ *
+ * In "don't show diffs" mode (where the attributes of the base hard disk are
+ * shown instead of the attributes of the differencing hard disk), extra
+ * information will be added to the tooltip to give the user a hint that the
+ * medium is actually a differencing hard disk.
+ *
+ * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+ * @param aCheckRO  @c true to perform the #readOnly() check and add a notice
+ *                  accordingly.
+ */
+QString VBoxMedium::toolTip (bool aNoDiffs /*= false*/,
+                             bool aCheckRO /*= false*/) const
+{
+    unconst (this)->checkNoDiffs (aNoDiffs);
+
+    QString tip = aNoDiffs ? mNoDiffs.toolTip : mToolTip;
+
+    if (aCheckRO && mIsReadOnly)
+        tip += VBoxGlobal::tr (
+            "<hr><img src=%1/>&nbsp;Attaching this hard disk will "
+            "be performed indirectly using a newly created "
+            "differencing hard disk.",
+            "medium").
+            arg ("new_16px.png");
+
+    return tip;
+}
+
+/**
+ * Returns an icon corresponding to the media state. Distinguishes between
+ * the Inaccessible state and the situation when querying the state itself
+ * failed.
+ *
+ * In "don't show diffs" mode (where the attributes of the base hard disk are
+ * shown instead of the attributes of the differencing hard disk), the most
+ * worst media state on the given hard disk chain will be used to select the
+ * media icon.
+ *
+ * @param aNoDiffs  @c true to enable user-friendly "don't show diffs" mode.
+ * @param aCheckRO  @c true to perform the #readOnly() check and change the icon
+ *                  accordingly.
+ */
+QPixmap VBoxMedium::icon (bool aNoDiffs /*= false*/,
+                          bool aCheckRO /*= false*/) const
+{
+    QPixmap icon;
+
+    if (state (aNoDiffs) == KMediaState_Inaccessible)
+        icon = result (aNoDiffs).isOk() ?
+            vboxGlobal().warningIcon() : vboxGlobal().errorIcon();
+
+    if (aCheckRO && mIsReadOnly)
+        icon = VBoxGlobal::
+            joinPixmaps (icon, QPixmap::fromMimeSource ("new_16px.png"));
+
+    return icon;
+}
+
+/**
+ * Returns the details of this medium as a single-line string
+ *
+ * For hard disks, the details include the location, type and the logical size
+ * of the hard disk. Note that if @a aNoDiffs is @c true, these properties are
+ * queried on the root hard disk of the given hard disk because the primary
+ * purpose of the returned string is to be human readabile (so that seeing a
+ * complex diff hard disk name is usually not desirable).
+ *
+ * For other media types, the location and the actual size are returned.
+ * Arguments @a aPredictDiff and @a aNoRoot are ignored in this case.
+ *
+ * @param aNoDiffs      @c true to enable user-friendly "don't show diffs" mode.
+ * @param aPredictDiff  @c true to mark the hard disk as differencing if
+ *                      attaching it would create a differencing hard disk (not
+ *                      used when @a aNoRoot is true).
+ * @param aUseHTML      @c true to allow for emphasizing using bold and italics.
+ *
+ * @note Use #detailsHTML() instead of passing @c true for @a aUseHTML.
+ *
+ * @note The media object may become uninitialized by a third party while this
+ *       method is reading its properties. In this case, the method will return
+ *       an empty string.
+ */
+QString VBoxMedium::details (bool aNoDiffs /*= false*/,
+                             bool aPredictDiff /*= false*/,
+                             bool aUseHTML /*= false */) const
+{
+    // @todo *** the below check is rough; if mMedium becomes uninitialized, any
+    // of getters called afterwards will also fail. The same relates to the
+    // root hard disk object (that will be the hard disk itself in case of
+    // non-differencing disks). However, this check was added to fix a
+    // particular use case: when the hard disk is a differencing hard disk and
+    // it happens to be discarded (and uninitialized) after this method is
+    // called but before we read all its properties (yes, it's possible!), the
+    // root object will be null and calling methods on it will assert in the
+    // debug builds. This check seems to be enough as a quick solution (fresh
+    // hard disk attachments will be re-read by a machine state change signal
+    // after the discard operation is finished, so the user will eventually see
+    // correct data), but in order to solve the problem properly we need to use
+    // exceptions everywhere (or check the result after every method call). See
+    // also Defect #2149.
+    if (!mMedium.isOk())
+        return QString::null;
+
+    QString details, str;
+
+    VBoxMedium *root = unconst (this);
+    KMediaState state = mState;
+
+    if (mType == VBoxDefs::MediaType_HardDisk)
+    {
+        if (aNoDiffs)
+        {
+            root = &this->root();
+
+            bool isDiff =
+                (!aPredictDiff && mParent != NULL) ||
+                (aPredictDiff && mIsReadOnly);
+
+            details = isDiff && aUseHTML ?
+                QString ("<i>%1</i>, ").arg (root->mHardDiskType) :
+                QString ("%1, ").arg (root->mHardDiskType);
+
+            /* overall (worst) state */
+            state = this->state (true /* aNoDiffs */);
+
+            /* we cannot get the logical size if the root is not checked yet */
+            if (root->mState == KMediaState_NotCreated)
+                state = KMediaState_NotCreated;
+        }
+        else
+        {
+            details = QString ("%1, ").arg (root->mHardDiskType);
+        }
+    }
+
+    /// @todo prepend the details with the warning/error
+    //  icon when not accessible
+
+    switch (state)
+    {
+        case KMediaState_NotCreated:
+            str = VBoxGlobal::tr ("Checking...", "medium");
+            details += aUseHTML ? QString ("<i>%1</i>").arg (str) : str;
+            break;
+        case KMediaState_Inaccessible:
+            str = VBoxGlobal::tr ("Inaccessible", "medium");
+            details += aUseHTML ? QString ("<b>%1</b>").arg (str) : str;
+            break;
+        default:
+            details += mType == VBoxDefs::MediaType_HardDisk ?
+                       root->mLogicalSize : root->mSize;
+            break;
+    }
+
+    details = aUseHTML ?
+        QString ("%1 (<nobr>%2</nobr>)").
+            arg (VBoxGlobal::locationForHTML (root->mName), details) :
+        QString ("%1 (%2)").
+            arg (VBoxGlobal::locationForHTML (root->mName), details);
+
+    return details;
+}
+
+/**
+ * Checks if mNoDiffs is filled in and does it if not.
+ *
+ * @param aNoDiffs  @if false, this method immediately returns.
+ */
+void VBoxMedium::checkNoDiffs (bool aNoDiffs)
+{
+    if (!aNoDiffs || mNoDiffs.isSet)
+        return;
+
+    /* fill mNoDiffs */
+
+    mNoDiffs.toolTip = QString::null;
+
+    /* detect the overall (worst) state of the given hard disk chain */
+    mNoDiffs.state = mState;
+    for (VBoxMedium *cur = mParent; cur != NULL;
+         cur = cur->mParent)
+    {
+        if (cur->mState == KMediaState_Inaccessible)
+        {
+            mNoDiffs.state = cur->mState;
+
+            if (mNoDiffs.toolTip.isNull())
+                mNoDiffs.toolTip = VBoxGlobal::tr (
+                    "<hr>Some of the media in this hard disk chain are "
+                    "inaccessible. Please use the Virtual Media Manager "
+                    "in <b>Show Differencing Hard Disks</b> mode to inspect "
+                    "these media.");
+
+            if (!cur->mResult.isOk())
+            {
+                mNoDiffs.result = cur->mResult;
+                break;
+            }
+
+            /* comtinue looking for another !cur->mResult.isOk() */
+        }
+    }
+
+    if (mParent != NULL && !mIsReadOnly)
+    {
+        mNoDiffs.toolTip = VBoxGlobal::tr (
+            "%1"
+            "<hr>This base hard disk is indirectly attached using the "
+            "following differencing hard disk:<br>"
+            "%2%3").
+            arg (root().toolTip(), mToolTip, mNoDiffs.toolTip);
+    }
+
+    if (mNoDiffs.toolTip.isNull())
+        mNoDiffs.toolTip = mToolTip;
+
+    mNoDiffs.isSet = true;
+}
+
+// VBoxMediaEnumEvent
+/////////////////////////////////////////////////////////////////////////////
+
+class VBoxMediaEnumEvent : public QEvent
 {
 public:
 
     /** Constructs a regular enum event */
-    VBoxEnumerateMediaEvent (const VBoxMedia &aMedia, int aIndex)
-        : QEvent ((QEvent::Type) VBoxDefs::EnumerateMediaEventType)
-        , mMedia (aMedia), mLast (false), mIndex (aIndex)
+    VBoxMediaEnumEvent (const VBoxMedium &aMedium, int aIndex)
+        : QEvent ((QEvent::Type) VBoxDefs::MediaEnumEventType)
+        , mMedium (aMedium), mLast (false), mIndex (aIndex)
         {}
     /** Constructs the last enum event */
-    VBoxEnumerateMediaEvent()
-        : QEvent ((QEvent::Type) VBoxDefs::EnumerateMediaEventType)
+    VBoxMediaEnumEvent()
+        : QEvent ((QEvent::Type) VBoxDefs::MediaEnumEventType)
         , mLast (true), mIndex (-1)
         {}
 
-    /** the last enumerated media (not valid when #last is true) */
-    const VBoxMedia mMedia;
+    /** the last enumerated medium (not valid when #last is true) */
+    const VBoxMedium mMedium;
     /** whether this is the last event for the given enumeration or not */
     const bool mLast;
@@ -130 +626 @@
     /** Constructs a regular enum event */
     VBoxShellExecuteEvent (QThread *aThread, const QString &aURL,
-                             bool aOk)
+                           bool aOk)
         : QEvent ((QEvent::Type) VBoxDefs::ShellExecuteEventType)
         , mThread (aThread), mURL (aURL), mOk (aOk)
@@ -753 +1249 @@
     , mRegDlg (NULL)
 #endif
-    , media_enum_thread (NULL)
+    , mMediaEnumThread (NULL)
     , verString ("1.0")
     , vm_state_color (KMachineState_COUNT)
@@ -763 +1259 @@
     , storageBusChannels (3)
     , diskTypes (KHardDiskType_COUNT)
-    , diskStorageTypes (KHardDiskStorageType_COUNT)
     , vrdpAuthTypes (KVRDPAuthType_COUNT)
     , portModeTypes (KPortMode_COUNT)
@@ -1296 +1791 @@
 
 /**
- *  Returns the details of the given hard disk as a single-line string
- *  to be used in the VM details view.
- *
- *  The details include the type and the virtual size of the hard disk.
- *  Note that for differencing hard disks based on immutable hard disks,
- *  the Immutable hard disk type is returned.
- *
- *  @param aHD      hard disk image (when predict = true, must be a top-level image)
- *  @param aPredict when true, the function predicts the type of the resulting
- *                  image after attaching the given image to the machine.
- *                  Otherwise, a real type of the given image is returned
- *                  (with the exception mentioned above).
- *
- *  @note The hard disk object may become uninitialized by a third party
- *  while this method is reading its properties. In this case, the method will
- *  return an empty string.
- */
-QString VBoxGlobal::details (const CHardDisk &aHD, bool aPredict /* = false */,
-                             bool aDoRefresh)
-{
-    Assert (!aPredict || aHD.GetParent().isNull());
-
-    VBoxMedia media;
-    if (!aDoRefresh)
-        media = VBoxMedia (CUnknown (aHD), VBoxDefs::HD, VBoxMedia::Ok);
-    else if (!findMedia (CUnknown (aHD), media))
+ * Searches for the given hard disk in the list of known media descriptors and
+ * calls VBoxMedium::details() on the found desriptor.
+ *
+ * If the requeststed hard disk is not found (for example, it's a new hard disk
+ * for a new VM created outside our UI), then media enumeration is requested and
+ * the search is repeated. We assume that the secont attempt always succeeds and
+ * assert otherwise.
+ *
+ * @note Technically, the second attempt may fail if, for example, the new hard
+ *       passed to this method disk gets removed before #startEnumeratingMedia()
+ *       succeeds. This (unexpected object uninitialization) is a generic
+ *       problem though and needs to be addressed using exceptions (see also the
+ *       @todo in VBoxMedium::details()).
+ */
+QString VBoxGlobal::details (const CHardDisk2 &aHD,
+                             bool aPredictDiff)
+{
+    CMedium cmedium (aHD);
+    VBoxMedium medium;
+
+    if (!findMedium (cmedium, medium))
     {
         /* media may be new and not alredy in the media list, request refresh */
         startEnumeratingMedia();
-        if (!findMedia (CUnknown (aHD), media))
-            AssertFailed();
-    }
-
-    CHardDisk root = aHD.GetRoot();
-
-    // @todo *** this check is rough; if aHD becomes uninitialized, any of aHD
-    // getters called afterwards will also fail. The same relates to the root
-    // object (that will be aHD itself in case of non-differencing
-    // disks). However, this check was added to fix a particular use case:
-    // when aHD is a differencing hard disk and it happens to be discarded
-    // (and uninitialized) after this method is called but before we read all
-    // its properties (yes, it's possible!), the root object will be null and
-    // calling methods on it will assert in the debug builds. This check seems
-    // to be enough as a quick solution (fresh hard disk attachments will be
-    // re-read by a state change signal after the discard operation is
-    // finished, so the user will eventually see correct data), but in order
-    // to solve the problem properly we need to use exceptions everywhere (or
-    // check the result after every method call). See also Comment #17 and
-    // below in Defect #2126.
-    if (!aHD.isOk())
-        return QString::null;
-
-    QString details;
-
-    KHardDiskType type = root.GetType();
-
-    if (type == KHardDiskType_Normal &&
-        (aHD != root || (aPredict && root.GetChildren().GetCount() != 0)))
-            details = tr ("Differencing", "hard disk");
-    else
-        details = hardDiskTypeString (root);
-
-    details += ", ";
-
-    /// @todo prepend the details with the warning/error
-    //  icon when not accessible
-
-    switch (media.status)
-    {
-        case VBoxMedia::Unknown:
-            details += tr ("<i>Checking...</i>", "hard disk");
-            break;
-        case VBoxMedia::Ok:
-            details += formatSize (root.GetSize() * _1M);
-            break;
-        case VBoxMedia::Error:
-        case VBoxMedia::Inaccessible:
-            details += tr ("<i>Inaccessible</i>", "hard disk");
-            break;
-    }
-
-    return details;
+        if (!findMedium (cmedium, medium))
+            AssertFailedReturn (QString::null);
+    }
+
+    return medium.detailsHTML (true /* aNoDiffs */, aPredictDiff);
 }
 
@@ -1428 +1870 @@
 
     /* add the state field if it's a host USB device */
-    CHostUSBDevice hostDev = CUnknown (aDevice);
+    CHostUSBDevice hostDev (aDevice);
     if (!hostDev.isNull())
     {
@@ -1439 +1881 @@
 
 /**
- *  Puts soft hyphens after every path component in the given file name.
- *  @param fn   file name (must be a full path name)
- */
-QString VBoxGlobal::prepareFileNameForHTML (const QString &fn) const
-{
-/// @todo (dmik) remove?
-//    QString result = QDir::convertSeparators (fn);
-//#ifdef Q_OS_LINUX
-//    result.replace ('/', "/<font color=red>&shy;</font>");
-//#else
-//    result.replace ('\\', "\\<font color=red>&shy;</font>");
-//#endif
-//    return result;
-    QFileInfo fi (fn);
-    return fi.fileName();
-}
-
-/**
- *  Returns a details report on a given VM enclosed in a HTML table.
- *
- *  @param m            machine to create a report for
- *  @param isNewVM      true when called by the New VM Wizard
- *  @param withLinks    true if section titles should be hypertext links
- */
-QString VBoxGlobal::detailsReport (const CMachine &m, bool isNewVM,
-                                   bool withLinks, bool aDoRefresh)
+ * Returns a details report on a given VM represented as a HTML table.
+ *
+ * @param aMachine      Machine to create a report for.
+ * @param aIsNewVM      @c true when called by the New VM Wizard.
+ * @param aWithLinks    @c true if section titles should be hypertext links.
+ */
+QString VBoxGlobal::detailsReport (const CMachine &aMachine, bool aIsNewVM,
+                                   bool aWithLinks)
 {
     static const char *sTableTpl =
@@ -1533 +1957 @@
     /* common generated content */
 
-    const QString &sectionTpl = withLinks
+    const QString &sectionTpl = aWithLinks
         ? sSectionHrefTpl
         : sSectionBoldTpl;
@@ -1541 +1965 @@
         int rows = 2; /* including section header and footer */
 
-        CHardDiskAttachmentEnumerator aen = m.GetHardDiskAttachments().Enumerate();
-        while (aen.HasMore())
-        {
-            CHardDiskAttachment hda = aen.GetNext();
-            CHardDisk hd = hda.GetHardDisk();
-            /// @todo for the explaination of the below isOk() checks, see
-            /// @todo *** in #details (const CHardDisk &, bool).
+        CHardDisk2AttachmentVector vec = aMachine.GetHardDisk2Attachments();
+        for (size_t i = 0; i < vec.size(); ++ i)
+        {
+            CHardDisk2Attachment hda = vec [i];
+            CHardDisk2 hd = hda.GetHardDisk();
+
+            /// @todo for the explaination of the below isOk() checks, see ***
+            /// in #details (const CHardDisk &, bool).
             if (hda.isOk())
             {
-                CHardDisk root = hd.GetRoot();
-                if (hd.isOk())
-                {
-                    QString src = root.GetLocation();
-                    KStorageBus bus = hda.GetBus();
-                    LONG channel = hda.GetChannel();
-                    LONG device = hda.GetDevice();
-                    hardDisks += QString (sSectionItemTpl)
-                        .arg (toFullString (bus, channel, device))
-                        .arg (QString ("%1 [<nobr>%2</nobr>]")
-                              .arg (prepareFileNameForHTML (src))
-                              .arg (details (hd, isNewVM /* predict */, aDoRefresh)));
-                    ++ rows;
-                }
+                KStorageBus bus = hda.GetBus();
+                LONG channel = hda.GetChannel();
+                LONG device = hda.GetDevice();
+                hardDisks += QString (sSectionItemTpl)
+                    .arg (toFullString (bus, channel, device))
+                    .arg (details (hd, aIsNewVM));
+                ++ rows;
             }
         }
@@ -1584 +2002 @@
     /* compose details report */
 
-    const QString &generalBasicTpl = withLinks
+    const QString &generalBasicTpl = aWithLinks
         ? sGeneralBasicHrefTpl
         : sGeneralBasicBoldTpl;
 
-    const QString &generalFullTpl = withLinks
+    const QString &generalFullTpl = aWithLinks
         ? sGeneralFullHrefTpl
         : sGeneralFullBoldTpl;
@@ -1594 +2012 @@
     QString detailsReport;
 
-    if (isNewVM)
+    if (aIsNewVM)
     {
         detailsReport
             = generalBasicTpl
-                .arg (m.GetName())
-                .arg (vmGuestOSTypeDescription (m.GetOSTypeId()))
-                .arg (m.GetMemorySize())
+                .arg (aMachine.GetName())
+                .arg (vmGuestOSTypeDescription (aMachine.GetOSTypeId()))
+                .arg (aMachine.GetMemorySize())
             + hardDisks;
     }
@@ -1609 +2027 @@
         for (ulong i = 1; i <= mVBox.GetSystemProperties().GetMaxBootPosition(); i++)
         {
-            KDeviceType device = m.GetBootOrder (i);
+            KDeviceType device = aMachine.GetBootOrder (i);
             if (device == KDeviceType_Null)
                 continue;
@@ -1619 +2037 @@
             bootOrder = toString (KDeviceType_Null);
 
-        CBIOSSettings biosSettings = m.GetBIOSSettings();
+        CBIOSSettings biosSettings = aMachine.GetBIOSSettings();
 
         /* ACPI */
@@ -1633 +2051 @@
         /* VT-x/AMD-V */
         CSystemProperties props = vboxGlobal().virtualBox().GetSystemProperties();
-        QString virt = m.GetHWVirtExEnabled() == KTSBool_True ?
+        QString virt = aMachine.GetHWVirtExEnabled() == KTSBool_True ?
                        tr ("Enabled", "details report (VT-x/AMD-V)") :
-                       m.GetHWVirtExEnabled() == KTSBool_False ?
+                       aMachine.GetHWVirtExEnabled() == KTSBool_False ?
                        tr ("Disabled", "details report (VT-x/AMD-V)") :
                        props.GetHWVirtExEnabled() ?
@@ -1642 +2060 @@
 
         /* PAE/NX */
-        QString pae = m.GetPAEEnabled()
+        QString pae = aMachine.GetPAEEnabled()
             ? tr ("Enabled", "details report (PAE/NX)")
             : tr ("Disabled", "details report (PAE/NX)");
@@ -1649 +2067 @@
         detailsReport
             = generalFullTpl
-                .arg (m.GetName())
-                .arg (vmGuestOSTypeDescription (m.GetOSTypeId()))
-                .arg (m.GetMemorySize())
-                .arg (m.GetVRAMSize())
+                .arg (aMachine.GetName())
+                .arg (vmGuestOSTypeDescription (aMachine.GetOSTypeId()))
+                .arg (aMachine.GetMemorySize())
+                .arg (aMachine.GetVRAMSize())
                 .arg (bootOrder)
                 .arg (acpi)
@@ -1663 +2081 @@
 
         /* DVD */
-        CDVDDrive dvd = m.GetDVDDrive();
+        CDVDDrive dvd = aMachine.GetDVDDrive();
         item = QString (sSectionItemTpl);
         switch (dvd.GetState())
@@ -1672 +2090 @@
             case KDriveState_ImageMounted:
             {
-                CDVDImage img = dvd.GetImage();
+                CDVDImage2 img = dvd.GetImage();
                 item = item.arg (tr ("Image", "details report (DVD)"),
-                                 prepareFileNameForHTML (img.GetFilePath()));
+                                 locationForHTML (img.GetName()));
                 break;
             }
@@ -1700 +2118 @@
 
         /* Floppy */
-        CFloppyDrive floppy = m.GetFloppyDrive();
+        CFloppyDrive floppy = aMachine.GetFloppyDrive();
         item = QString (sSectionItemTpl);
         switch (floppy.GetState())
@@ -1709 +2127 @@
             case KDriveState_ImageMounted:
             {
-                CFloppyImage img = floppy.GetImage();
+                CFloppyImage2 img = floppy.GetImage();
                 item = item.arg (tr ("Image", "details report (floppy)"),
-                                 prepareFileNameForHTML (img.GetFilePath()));
+                                 locationForHTML (img.GetName()));
                 break;
             }
@@ -1738 +2156 @@
         /* audio */
         {
-            CAudioAdapter audio = m.GetAudioAdapter();
+            CAudioAdapter audio = aMachine.GetAudioAdapter();
             int rows = audio.GetEnabled() ? 3 : 2;
             if (audio.GetEnabled())
@@ -1765 +2183 @@
             for (ulong slot = 0; slot < count; slot ++)
             {
-                CNetworkAdapter adapter = m.GetNetworkAdapter (slot);
+                CNetworkAdapter adapter = aMachine.GetNetworkAdapter (slot);
                 if (adapter.GetEnabled())
                 {
@@ -1811 +2229 @@
             for (ulong slot = 0; slot < count; slot ++)
             {
-                CSerialPort port = m.GetSerialPort (slot);
+                CSerialPort port = aMachine.GetSerialPort (slot);
                 if (port.GetEnabled())
                 {
@@ -1853 +2271 @@
             for (ulong slot = 0; slot < count; slot ++)
             {
-                CParallelPort port = m.GetParallelPort (slot);
+                CParallelPort port = aMachine.GetParallelPort (slot);
                 if (port.GetEnabled())
                 {
@@ -1885 +2303 @@
         /* USB */
         {
-            CUSBController ctl = m.GetUSBController();
+            CUSBController ctl = aMachine.GetUSBController();
             if (!ctl.isNull())
             {
@@ -1918 +2336 @@
         /* Shared folders */
         {
-            ulong count = m.GetSharedFolders().GetCount();
+            ulong count = aMachine.GetSharedFolders().GetCount();
             if (count > 0)
             {
@@ -1939 +2357 @@
         /* VRDP */
         {
-            CVRDPServer srv = m.GetVRDPServer();
+            CVRDPServer srv = aMachine.GetVRDPServer();
             if (!srv.isNull())
             {
@@ -2146 +2564 @@
 
 /**
- *  Appends the disk object and all its children to the media list.
+ * Appends the given list of hard disks and all their children to the media
+ * list. To be called only from VBoxGlobal::startEnumeratingMedia().
  */
 static
-void addMediaToList (VBoxMediaList &aList,
-                     const CUnknown &aDisk,
-                     VBoxDefs::DiskType aType)
-{
-    VBoxMedia media (aDisk, aType, VBoxMedia::Unknown);
-    aList += media;
-    /* append all vdi children */
-    if (aType == VBoxDefs::HD)
-    {
-        CHardDisk hd = aDisk;
-        CHardDiskEnumerator enumerator = hd.GetChildren().Enumerate();
-        while (enumerator.HasMore())
-        {
-            CHardDisk subHd = enumerator.GetNext();
-            addMediaToList (aList, CUnknown (subHd), VBoxDefs::HD);
-        }
-    }
-}
-
-/**
- *  Starts a thread that asynchronously enumerates all currently registered
- *  media, checks for its accessibility and posts VBoxEnumerateMediaEvent
- *  events to the VBoxGlobal object until all media is enumerated.
- *
- *  If the enumeration is already in progress, no new thread is started.
- *
- *  @sa #currentMediaList()
- *  @sa #isMediaEnumerationStarted()
+void AddHardDisksToList (VBoxMediaList &aList,
+                         VBoxMediaList::iterator aWhere,
+                         const CHardDisk2Vector &aVector,
+                         VBoxMedium *aParent = NULL)
+{
+    VBoxMediaList::iterator first = aWhere;
+
+    /* first pass: add siblings sorted */
+    for (CHardDisk2Vector::ConstIterator it = aVector.begin();
+         it != aVector.end(); ++ it)
+    {
+        VBoxMedium medium (CMedium (*it), VBoxDefs::MediaType_HardDisk,
+                           aParent);
+
+        /* search for a proper alphabetic position */
+        VBoxMediaList::iterator jt = first;
+        for (; jt != aWhere; ++ jt)
+            if ((*jt).name().localeAwareCompare (medium.name()) > 0)
+                break;
+
+        aList.insert (jt, medium);
+
+        /* adjust the first item if inserted before it */
+        if (jt == first)
+            -- first;
+    }
+
+    /* second pass: add children */
+    for (VBoxMediaList::iterator it = first; it != aWhere;)
+    {
+        CHardDisk2Vector children = (*it).hardDisk().GetChildren();
+        VBoxMedium *parent = &(*it);
+
+        ++ it; /* go to the next sibling before inserting children */
+        AddHardDisksToList (aList, it, children, parent);
+    }
+}
+
+/**
+ * Starts a thread that asynchronously enumerates all currently registered
+ * media.
+ *
+ * Before the enumeration is started, the current media list (a list returned by
+ * #currentMediaList()) is populated with all registered media and the
+ * #mediaEnumStarted() signal is emitted. The enumeration thread then walks this
+ * list, checks for media acessiblity and emits #mediumEnumerated() signals of
+ * each checked medium. When all media are checked, the enumeration thread is
+ * stopped and the #mediaEnumFinished() signal is emitted.
+ *
+ * If the enumeration is already in progress, no new thread is started.
+ *
+ * The media list returned by #currentMediaList() is always sorted
+ * alphabetically by the location attribute and comes in the following order:
+ * <ol>
+ *  <li>All hard disks. If a hard disk has children, these children
+ *      (alphabetically sorted) immediately follow their parent and terefore
+ *      appear before its next sibling hard disk.</li>
+ *  <li>All CD/DVD images.</li>
+ *  <li>All Floppy images.</li>
+ * </ol>
+ *
+ * Note that #mediumEnumerated() signals are emitted in the same order as
+ * described above.
+ *
+ * @sa #currentMediaList()
+ * @sa #isMediaEnumerationStarted()
  */
 void VBoxGlobal::startEnumeratingMedia()
 {
-    Assert (mValid);
+    AssertReturnVoid (mValid);
 
     /* check if already started but not yet finished */
-    if (media_enum_thread)
+    if (mMediaEnumThread != NULL)
         return;
 
@@ -2191 +2648 @@
 
     /* composes a list of all currently known media & their children */
-    media_list.clear();
-    {
-        CHardDiskEnumerator enHD = mVBox.GetHardDisks().Enumerate();
-        while (enHD.HasMore())
-            addMediaToList (media_list, CUnknown (enHD.GetNext()), VBoxDefs::HD);
-
-        CDVDImageEnumerator enCD = mVBox.GetDVDImages().Enumerate();
-        while (enCD.HasMore())
-            addMediaToList (media_list, CUnknown (enCD.GetNext()), VBoxDefs::CD);
-
-        CFloppyImageEnumerator enFD = mVBox.GetFloppyImages().Enumerate();
-        while (enFD.HasMore())
-            addMediaToList (media_list, CUnknown (enFD.GetNext()), VBoxDefs::FD);
+    mMediaList.clear();
+    {
+        CHardDisk2Vector vec = mVBox.GetHardDisks2();
+        AddHardDisksToList (mMediaList, mMediaList.end(), vec);
+    }
+    {
+        VBoxMediaList::iterator first = mMediaList.end();
+
+        CDVDImage2Vector vec = mVBox.GetDVDImages();
+        for (CDVDImage2Vector::ConstIterator it = vec.begin();
+             it != vec.end(); ++ it)
+        {
+            VBoxMedium medium (CMedium (*it), VBoxDefs::MediaType_DVD);
+
+            /* search for a proper alphabetic position */
+            VBoxMediaList::iterator jt = first;
+            for (; jt != mMediaList.end(); ++ jt)
+                if ((*jt).name().localeAwareCompare (medium.name()) > 0)
+                    break;
+
+            mMediaList.insert (jt, medium);
+
+            /* adjust the first item if inserted before it */
+            if (jt == first)
+                -- first;
+        }
+    }
+    {
+        VBoxMediaList::iterator first = mMediaList.end();
+
+        CFloppyImage2Vector vec = mVBox.GetFloppyImages();
+        for (CFloppyImage2Vector::ConstIterator it = vec.begin();
+             it != vec.end(); ++ it)
+        {
+            VBoxMedium medium (CMedium (*it), VBoxDefs::MediaType_Floppy);
+
+            /* search for a proper alphabetic position */
+            VBoxMediaList::iterator jt = first;
+            for (; jt != mMediaList.end(); ++ jt)
+                if ((*jt).name().localeAwareCompare (medium.name()) > 0)
+                    break;
+
+            mMediaList.insert (jt, medium);
+
+            /* adjust the first item if inserted before it */
+            if (jt == first)
+                -- first;
+        }
     }
 
     /* enumeration thread class */
-    class Thread : public QThread
+    class MediaEnumThread : public QThread
     {
     public:
 
-        Thread (const VBoxMediaList &aList) : mList (aList) {}
+        MediaEnumThread (const VBoxMediaList &aList) : mList (aList) {}
 
         virtual void run()
@@ -2219 +2711 @@
 
             CVirtualBox mVBox = vboxGlobal().virtualBox();
-            QObject *target = &vboxGlobal();
-
-            /* enumerating list */
+            QObject *self = &vboxGlobal();
+
+            /* enumerate the list */
             int index = 0;
             VBoxMediaList::const_iterator it;
@@ -2228 +2720 @@
                  ++ it, ++ index)
             {
-                VBoxMedia media = *it;
-                switch (media.type)
-                {
-                    case VBoxDefs::HD:
-                    {
-                        CHardDisk hd = media.disk;
-                        media.status =
-                            hd.GetAccessible() == TRUE ? VBoxMedia::Ok :
-                            hd.isOk() ? VBoxMedia::Inaccessible :
-                            VBoxMedia::Error;
-                        /* assign back to store error info if any */
-                        media.disk = hd;
-                        if (media.status == VBoxMedia::Inaccessible)
-                        {
-                            QUuid machineId = hd.GetMachineId();
-                            if (!machineId.isNull())
-                            {
-                                CMachine machine = mVBox.GetMachine (machineId);
-                                if (!machine.isNull() && (machine.GetState() >= KMachineState_Running))
-                                    media.status = VBoxMedia::Ok;
-                            }
-                        }
-                        QApplication::postEvent (target,
-                            new VBoxEnumerateMediaEvent (media, index));
-                        break;
-                    }
-                    case VBoxDefs::CD:
-                    {
-                        CDVDImage cd = media.disk;
-                        media.status =
-                            cd.GetAccessible() == TRUE ? VBoxMedia::Ok :
-                            cd.isOk() ? VBoxMedia::Inaccessible :
-                            VBoxMedia::Error;
-                        /* assign back to store error info if any */
-                        media.disk = cd;
-                        QApplication::postEvent (target,
-                            new VBoxEnumerateMediaEvent (media, index));
-                        break;
-                    }
-                    case VBoxDefs::FD:
-                    {
-                        CFloppyImage fd = media.disk;
-                        media.status =
-                            fd.GetAccessible() == TRUE ? VBoxMedia::Ok :
-                            fd.isOk() ? VBoxMedia::Inaccessible :
-                            VBoxMedia::Error;
-                        /* assign back to store error info if any */
-                        media.disk = fd;
-                        QApplication::postEvent (target,
-                            new VBoxEnumerateMediaEvent (media, index));
-                        break;
-                    }
-                    default:
-                    {
-                        AssertMsgFailed (("Invalid aMedia type\n"));
-                        break;
-                    }
-                }
+                VBoxMedium medium = *it;
+                medium.blockAndQueryState();
+                QApplication::postEvent (self,
+                    new VBoxMediaEnumEvent (medium, index));
             }
 
-            /* post the last message to indicate the end of enumeration */
+            /* post the end-of-enumeration event */
             if (!sVBoxGlobalInCleanup)
-                QApplication::postEvent (target, new VBoxEnumerateMediaEvent());
+                QApplication::postEvent (self, new VBoxMediaEnumEvent());
 
             COMBase::CleanupCOM();
@@ -2301 +2739 @@
     };
 
-    media_enum_thread = new Thread (media_list);
-    AssertReturnVoid (media_enum_thread);
-
-    /* emit mediaEnumStarted() after we set media_enum_thread to != NULL
+    mMediaEnumThread = new MediaEnumThread (mMediaList);
+    AssertReturnVoid (mMediaEnumThread);
+
+    /* emit mediaEnumStarted() after we set mMediaEnumThread to != NULL
      * to cause isMediaEnumerationStarted() to return TRUE from slots */
     emit mediaEnumStarted();
 
-    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);
-}
-
-/**
- *  Searches for a VBoxMedia object representing the given COM media object.
+    mMediaEnumThread->start();
+}
+
+/**
+ * Adds a new medium to the current media list and emits the #mediumAdded()
+ * signal.
+ *
+ * @sa #currentMediaList()
+ */
+void VBoxGlobal::addMedium (const VBoxMedium &aMedium)
+{
+    /* Note that we maitain the same order here as #startEnumeratingMedia() */
+
+    VBoxMediaList::iterator it = mMediaList.begin();
+
+    if (aMedium.type() == VBoxDefs::MediaType_HardDisk)
+    {
+        VBoxMediaList::iterator parent = mMediaList.end();
+
+        for (; it != mMediaList.end(); ++ it)
+        {
+            if ((*it).type() != VBoxDefs::MediaType_HardDisk)
+                break;
+
+            if (aMedium.parent() != NULL && parent == mMediaList.end())
+            {
+                if (&*it == aMedium.parent())
+                    parent = it;
+            }
+            else
+            {
+                /* break if met a parent's sibling (will insert before it) */
+                if (aMedium.parent() != NULL &&
+                    (*it).parent() == (*parent).parent())
+                    break;
+
+                /* compare to aMedium's siblings */
+                if ((*it).parent() == aMedium.parent() &&
+                    (*it).name().localeAwareCompare (aMedium.name()) > 0)
+                    break;
+            }
+        }
+
+        AssertReturnVoid (aMedium.parent() == NULL || parent != mMediaList.end());
+    }
+    else
+    {
+        for (; it != mMediaList.end(); ++ it)
+        {
+            /* skip HardDisks that come first */
+            if ((*it).type() == VBoxDefs::MediaType_HardDisk)
+                continue;
+
+            /* skip DVD when inserting Floppy */
+            if (aMedium.type() == VBoxDefs::MediaType_Floppy &&
+                (*it).type() == VBoxDefs::MediaType_DVD)
+                continue;
+
+            if ((*it).name().localeAwareCompare (aMedium.name()) > 0 ||
+                (aMedium.type() == VBoxDefs::MediaType_DVD &&
+                 (*it).type() == VBoxDefs::MediaType_Floppy))
+                break;
+        }
+    }
+
+    it = mMediaList.insert (it, aMedium);
+
+    emit mediumAdded (*it);
+}
+
+/**
+ * Updates the medium in the current media list and emits the #mediumUpdated()
+ * signal.
+ *
+ * @sa #currentMediaList()
+ */
+void VBoxGlobal::updateMedium (const VBoxMedium &aMedium)
+{
+    VBoxMediaList::Iterator it;
+    for (it = mMediaList.begin(); it != mMediaList.end(); ++ it)
+        if ((*it).id() == aMedium.id())
+            break;
+
+    AssertReturnVoid (it != mMediaList.end());
+
+    if (&*it != &aMedium)
+        *it = aMedium;
+
+    emit mediumUpdated (*it);
+}
+
+/**
+ * Removes the medium from the current media list and emits the #mediumRemoved()
+ * signal.
+ *
+ * @sa #currentMediaList()
+ */
+void VBoxGlobal::removeMedium (VBoxDefs::MediaType aType, const QUuid &aId)
+{
+    VBoxMediaList::Iterator it;
+    for (it = mMediaList.begin(); it != mMediaList.end(); ++ it)
+        if ((*it).id() == aId)
+            break;
+
+    AssertReturnVoid (it != mMediaList.end());
+
+#if DEBUG
+    /* sanity: must be no children */
+    {
+        VBoxMediaList::Iterator jt = it;
+        ++ jt;
+        AssertReturnVoid (jt == mMediaList.end() || (*jt).parent() != &*it);
+    }
+#endif
+
+    VBoxMedium *parent = (*it).parent();
+
+    /* remove the medium from the list to keep it in sync with the server "for
+     * free" when the medium is deleted from one of our UIs */
+    mMediaList.erase (it);
+
+    emit mediumRemoved (aType, aId);
+
+    /* also emit the parent update signal because some attributes like
+     * isReadOnly() may have been changed after child removal */
+    if (parent != NULL)
+    {
+        parent->refresh();
+        emit mediumUpdated (*parent);
+    }
+}
+
+/**
+ *  Searches for a VBoxMedum object representing the given COM medium object.
  *
  *  @return true if found and false otherwise.
  */
-bool VBoxGlobal::findMedia (const CUnknown &aObj, VBoxMedia &aMedia) const
-{
-    for (VBoxMediaList::ConstIterator it = media_list.begin();
-         it != media_list.end(); ++ it)
-    {
-        if ((*it).disk == aObj)
-        {
-            aMedia = (*it);
+bool VBoxGlobal::findMedium (const CMedium &aObj, VBoxMedium &aMedium) const
+{
+    for (VBoxMediaList::ConstIterator it = mMediaList.begin();
+         it != mMediaList.end(); ++ it)
+    {
+        if ((*it).medium() == aObj)
+        {
+            aMedium = (*it);
             return true;
         }
@@ -2447 +2975 @@
     machineStates [KMachineState_Restoring] =   tr ("Restoring", "MachineState");
     machineStates [KMachineState_Discarding] =  tr ("Discarding", "MachineState");
+    machineStates [KMachineState_SettingUp] =   tr ("Setting Up", "MachineState");
 
     sessionStates [KSessionState_Closed] =      tr ("Closed", "SessionState");
@@ -2484 +3013 @@
     diskTypes [KHardDiskType_Writethrough] =
         tr ("Writethrough", "DiskType");
-
-    diskStorageTypes [KHardDiskStorageType_VirtualDiskImage] =
-        tr ("Virtual Disk Image", "DiskStorageType");
-    diskStorageTypes [KHardDiskStorageType_ISCSIHardDisk] =
-        tr ("iSCSI", "DiskStorageType");
-    diskStorageTypes [KHardDiskStorageType_VMDKImage] =
-        tr ("VMDK Image", "DiskStorageType");
-    diskStorageTypes [KHardDiskStorageType_CustomHardDisk] =
-        tr ("Custom Hard Disk", "DiskStorageType");
-    diskStorageTypes [KHardDiskStorageType_VHDImage] =
-        tr ("VHD Image", "DiskStorageType");
+    diskTypes_Differencing =
+        tr ("Differencing", "DiskType");
 
     vrdpAuthTypes [KVRDPAuthType_Null] =
@@ -2583 +3103 @@
 
     mUserDefinedPortName = tr ("User-defined", "serial port");
+
+    {
+        QImage img =
+            QMessageBox::standardIcon (QMessageBox::Warning).convertToImage();
+        img = img.smoothScale (16, 16);
+        mWarningIcon.convertFromImage (img);
+        Assert (!mWarningIcon.isNull());
+
+        img =
+            QMessageBox::standardIcon (QMessageBox::Critical).convertToImage();
+        img = img.smoothScale (16, 16);
+        mErrorIcon.convertFromImage (img);
+        Assert (!mErrorIcon.isNull());
+    }
 
     detailReportTemplatesReady = false;
@@ -3220 +3754 @@
 
 /**
+ * Puts soft hyphens after every path component in the given file name.
+ *
+ * @param aFileName File name (must be a full path name).
+ */
+/* static */
+QString VBoxGlobal::locationForHTML (const QString &aFileName)
+{
+/// @todo (dmik) remove?
+//    QString result = QDir::convertSeparators (fn);
+//#ifdef Q_OS_LINUX
+//    result.replace ('/', "/<font color=red>&shy;</font>");
+//#else
+//    result.replace ('\\', "\\<font color=red>&shy;</font>");
+//#endif
+//    return result;
+    QFileInfo fi (aFileName);
+    return fi.fileName();
+}
+
+/**
  *  Reformats the input string @a aStr so that:
  *  - strings in single quotes will be put inside <nobr> and marked
@@ -3769 +4323 @@
 
 /**
+ * Joins two pixmaps horizontally with 2px space between them and returns the
+ * result.
+ *
+ * @param aPM1 Left pixmap.
+ * @param aPM2 Right pixmap.
+ */
+/* static */
+QPixmap VBoxGlobal::joinPixmaps (const QPixmap &aPM1, const QPixmap &aPM2)
+{
+    if (aPM1.isNull())
+        return aPM2;
+    if (aPM2.isNull())
+        return aPM1;
+
+    QPixmap res;
+
+    {
+        QImage img (aPM1.width() + aPM2.width() + 2,
+                    QMAX (aPM1.height(), aPM2.height()), 32);
+        img.setAlphaBuffer (true);
+        img.fill (0);
+        res.convertFromImage (img);
+    }
+
+    copyBlt (&res, 0, 0, &aPM1);
+    copyBlt (&res, aPM1.width() + 2, res.height() - aPM2.height(), &aPM2);
+
+    return res;
+}
+
+/**
  *  Searches for a widget that with @a aName (if it is not NULL) which inherits
  *  @a aClassName (if it is not NULL) and among children of @a aParent. If @a
@@ -3975 +4560 @@
         }
 
-        case VBoxDefs::EnumerateMediaEventType:
-        {
-            VBoxEnumerateMediaEvent *ev = (VBoxEnumerateMediaEvent *) e;
+        case VBoxDefs::MediaEnumEventType:
+        {
+            VBoxMediaEnumEvent *ev = (VBoxMediaEnumEvent *) e;
 
             if (!ev->mLast)
             {
-                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);
+                if (ev->mMedium.state() == KMediaState_Inaccessible &&
+                    !ev->mMedium.result().isOk())
+                    vboxProblem().cannotGetMediaAccessibility (ev->mMedium);
+                mMediaList [ev->mIndex] = ev->mMedium;
+                emit mediumEnumerated (mMediaList [ev->mIndex], ev->mIndex);
             }
             else
             {
                 /* the thread has posted the last message, wait for termination */
-                media_enum_thread->wait();
-                delete media_enum_thread;
-                media_enum_thread = 0;
-
-                emit mediaEnumFinished (media_list);
+                mMediaEnumThread->wait();
+                delete mMediaEnumThread;
+                mMediaEnumThread = 0;
+
+                emit mediaEnumFinished (mMediaList);
             }
 
@@ -4167 +4753 @@
         {KMachineState_Restoring, "state_restoring_16px.png"},
         {KMachineState_Discarding, "state_discarding_16px.png"},
+        {KMachineState_SettingUp, "settings_16px.png"},
     };
     mStateIcons.setAutoDelete (true); // takes ownership of elements
@@ -4193 +4780 @@
     vm_state_color.insert (KMachineState_Restoring,      &Qt::green);
     vm_state_color.insert (KMachineState_Discarding,     &Qt::green);
+    vm_state_color.insert (KMachineState_SettingUp,      &Qt::green);
 
     /* Redefine default large and small icon sizes. In particular, it is
@@ -4324 +4912 @@
     }
 
-    if (media_enum_thread)
+    if (mMediaEnumThread)
     {
         /* sVBoxGlobalInCleanup is true here, so just wait for the thread */
-        media_enum_thread->wait();
-        delete media_enum_thread;
-        media_enum_thread = 0;
+        mMediaEnumThread->wait();
+        delete mMediaEnumThread;
+        mMediaEnumThread = NULL;
     }
 
@@ -4345 +4933 @@
     vm_os_types.clear();
     /* media list contains a lot of CUUnknown, release them */
-    media_list.clear();
+    mMediaList.clear();
     /* the last step to ensure we don't use COM any more */
     mVBox.detach();
 
-    /* There may be VBoxEnumerateMediaEvent instances still in the message
+    /* There may be VBoxMediaEnumEvent instances still in the message
      * queue which reference COM objects. Remove them to release those objects
      * before uninitializing the COM subsystem. */
@@ -4411 +4999 @@
         while (en.HasMore())
         {
-            CHostUSBDevice iterator = en.GetNext();
-            CUSBDevice usb = CUnknown (iterator);
+            CHostUSBDevice dev = en.GetNext();
+            CUSBDevice usb (dev);
             int id = insertItem (vboxGlobal().details (usb));
             mUSBDevicesMap [id] = usb;
@@ -4421 +5009 @@
                     mConsole.GetUSBDevices().FindById (usb.GetId());
                 setItemChecked (id, !attachedUSB.isNull());
-                setItemEnabled (id, iterator.GetState() !=
+                setItemEnabled (id, dev.GetState() !=
                                 KUSBDeviceState_Unavailable);
             }

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

@@ -22 +22 @@
 
 #include "VBoxMediaComboBox.h"
-#include "VBoxDiskImageManagerDlg.h"
+#include "VBoxMediaManagerDlg.h"
 
 #include <qfileinfo.h>
@@ -31 +31 @@
 #include <qlistbox.h>
 
-VBoxMediaComboBox::VBoxMediaComboBox (QWidget *aParent, const char *aName,
-                                      int aType, bool aUseEmptyItem)
-    : QComboBox (aParent , aName),
-    mType (aType), mRequiredId (QUuid()), mUseEmptyItem (aUseEmptyItem)
+VBoxMediaComboBox::
+VBoxMediaComboBox (QWidget *aParent, const char *aName,
+                   VBoxDefs::MediaType aType, QUuid aMachineId /*= QUuid()*/)
+    : QComboBox (aParent , aName)
+    , mType (aType), mLastId (QUuid())
+    , mShowDiffs (false)
+    , mMachineId (aMachineId)
 {
     setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Fixed);
+
     /* 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 (mediumEnumerated (const VBoxMedium &, int)),
+             this, SLOT (mediumEnumerated (const VBoxMedium &, int)));
 
     /* 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 (&vboxGlobal(), SIGNAL (mediumAdded (const VBoxMedium &)),
+             this, SLOT (mediumAdded (const VBoxMedium &)));
+    connect (&vboxGlobal(), SIGNAL (mediumUpdated (const VBoxMedium &)),
+             this, SLOT (mediumUpdated (const VBoxMedium &)));
+    connect (&vboxGlobal(), SIGNAL (mediumRemoved (VBoxDefs::MediaType, const QUuid &)),
+             this, SLOT (mediumRemoved (VBoxDefs::MediaType, const QUuid &)));
 
     connect (this, SIGNAL (activated (int)),
              this, SLOT (processActivated (int)));
 
-    /* in some qt themes embedded list-box is not used by default, so create it */
+    /* in some qt themes the list-box is not used by default, so create it */
     if (!listBox())
         setListBox (new QListBox (this));
-    if (listBox())
-        connect (listBox(), SIGNAL (onItem (QListBoxItem*)),
-                 this, SLOT (processOnItem (QListBoxItem*)));
-
-    /* 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);
-    }
-}
-
+
+    AssertReturnVoid (listBox());
+
+    connect (listBox(), SIGNAL (onItem (QListBoxItem*)),
+             this, SLOT (processOnItem (QListBoxItem*)));
+}
+
+/**
+ * Fills this combobox with the current media list.
+ */
 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);
-    /* load current media list */
+    /* clear lists */
+    clear(), mMedia.clear();
+
+    /* load the current media list */
     VBoxMediaList list = vboxGlobal().currentMediaList();
     VBoxMediaList::const_iterator it;
     for (it = list.begin(); it != list.end(); ++ it)
-        mediaEnumerated (*it, 0);
-    /* activate item selected during current list loading */
-    processActivated (currentItem());
-}
-
+        mediumAdded (*it);
+
+    if (count() == 0)
+    {
+        /* no media of the desired type, add the "no media" pseudo-item */
+        addNoMediaItem();
+    }
+
+    /* inform the interested parties about the possibly changed active item's
+     * icon, text, tooltip etc. */
+    emit activated (currentItem());
+}
+
+/**
+ * Requests the global media list enumeration and repopulates the list with its
+ * results.
+ */
+void VBoxMediaComboBox::repopulate()
+{
+    if (!vboxGlobal().isMediaEnumerationStarted())
+        vboxGlobal().startEnumeratingMedia();
+    else
+        refresh();
+}
+
+QUuid VBoxMediaComboBox::id (int aIndex /*= -1*/)
+{
+    AssertReturn (aIndex == -1 ||
+                  (aIndex >= 0 && (size_t) aIndex < mMedia.size()),
+                  QUuid());
+
+    return mMedia [aIndex == -1 ? currentItem() : aIndex].id;
+}
+
+QString VBoxMediaComboBox::location (int aIndex /*= -1*/)
+{
+    AssertReturn (aIndex == -1 ||
+                  (aIndex >= 0 && (size_t) aIndex < mMedia.size()),
+                  QString::null);
+
+    return mMedia [aIndex == -1 ? currentItem() : aIndex].location;
+}
+
+/**
+ * Selects a media item with the given ID or does nothing if there is no such
+ * item. Note that this method, as opposed to QComboBox::setCurrentItem(int),
+ * does emit the activated() signal on success.
+ */
+void VBoxMediaComboBox::setCurrentItem (const QUuid &aId)
+{
+    mLastId = aId;
+
+    size_t index;
+    if (findMediaIndex (aId, index))
+    {
+        /* Note that the media combobox may be not populated here yet, so we
+         * don't assert */
+        QComboBox::setCurrentItem (index);
+        emit activated (index);
+    }
+}
+
+void VBoxMediaComboBox::setType (VBoxDefs::MediaType aType)
+{
+    mType = aType;
+}
+
+/**
+ * Enables or disables the "show diffs" mode.
+ *
+ * In disabled "show diffs" mode, this combobox will only include base hard
+ * disks plus differencing hard disks that are attached to the associated
+ * machine passed to the constructor in the current state (if any). Note
+ * that for these differencing hard disks, the details of their base hard disks
+ * are shown instead of their own details (human-friendly mode).
+ *
+ * In enabled "show diffs" mode, all hard disks, base and differencing, are
+ * shown.
+ *
+ * Note that you must call #refresh() in order for this change to take effect.
+ *
+ * @param aShowDiffs    @c true to enable "show diffs" mode.
+ */
+void VBoxMediaComboBox::setShowDiffs (bool aShowDiffs)
+{
+    AssertReturnVoid (aShowDiffs == true || !mMachineId.isNull());
+
+    mShowDiffs = aShowDiffs;
+}
 
 void VBoxMediaComboBox::mediaEnumStarted()
@@ -99 +175 @@
 }
 
-void VBoxMediaComboBox::mediaEnumerated (const VBoxMedia &aMedia, int /*aIndex*/)
-{
-    processMedia (aMedia);
-}
-
-
-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));
-        /* emit signal to ensure parent dialog process selection changes */
-        emit activated (currentItem());
-    }
-}
-
-
-void VBoxMediaComboBox::processMedia (const VBoxMedia &aMedia)
-{
-    if (!(aMedia.type & mType))
-        return;
-
-    switch (aMedia.type)
-    {
-        case VBoxDefs::HD:
+void VBoxMediaComboBox::mediumEnumerated (const VBoxMedium &aMedium, int /*aIndex*/)
+{
+    mediumUpdated (aMedium);
+}
+
+void VBoxMediaComboBox::mediumAdded (const VBoxMedium &aMedium)
+{
+    if (mType != aMedium.type())
+        return;
+
+    if (!mShowDiffs && aMedium.type() == VBoxDefs::MediaType_HardDisk)
+    {
+        if (aMedium.parent() != NULL)
         {
-            /* ignoring non-root disks */
-            CHardDisk hd = aMedia.disk;
-            if (hd.GetParent().isNull())
-                processHdMedia (aMedia);
-            break;
+            /* in !mShowDiffs mode, we ignore all diffs except ones that are
+             * directly attached to the related VM in the current state */
+            if (!aMedium.isAttachedInCurStateTo (mMachineId))
+                return;
         }
-        case VBoxDefs::CD:
-            processCdMedia (aMedia);
-            break;
-        case VBoxDefs::FD:
-            processFdMedia (aMedia);
-            break;
-        default:
-            AssertFailed();
-    }
-}
-
-void VBoxMediaComboBox::processHdMedia (const VBoxMedia &aMedia)
-{
-    QUuid mediaId;
-    QString toolTip;
-    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())
-        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);
-    QString name = QString ("%1 (%2)").arg (fi.fileName())
-                   .arg (QDir::convertSeparators (fi.dirPath()));
-    /* 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);
-
-    /* activate required item if it was updated */
-    if (aId == mRequiredId)
-        setCurrentItem (aId);
-    /* select last added item if there is no item selected */
+    }
+
+    appendItem (aMedium);
+
+    if (aMedium.id() == mLastId)
+    {
+        /* activate the required item if there is any */
+        setCurrentItem (aMedium.id());
+    }
     else if (currentText().isEmpty())
-        QComboBox::setCurrentItem (index == -1 ? count() - 1 : index);
-}
-
-void VBoxMediaComboBox::processActivated (int aItem)
-{
-    mRequiredId = mUuidList.isEmpty() || aItem < 0 ? QUuid() : QUuid (mUuidList [aItem]);
-    updateToolTip (aItem);
-}
-
-void VBoxMediaComboBox::updateToolTip (int aItem)
-{
-    /* combobox tooltip attaching */
+    {
+        /* select last added item if there is no item selected */
+        QComboBox::setCurrentItem (count() - 1);
+    }
+}
+
+void VBoxMediaComboBox::mediumUpdated (const VBoxMedium &aMedium)
+{
+    if (mType != aMedium.type())
+        return;
+
+    size_t index;
+    if (!findMediaIndex (aMedium.id(), index))
+        return;
+
+    replaceItem (index, aMedium);
+
+    /* emit the signal to ensure the parent dialog handles the change of
+     * the selected item's data */
+    emit activated (currentItem());
+}
+
+void VBoxMediaComboBox::mediumRemoved (VBoxDefs::MediaType aType,
+                                       const QUuid &aId)
+{
+    if (mType != aType)
+        return;
+
+    size_t index;
+    if (!findMediaIndex (aId, index))
+        return;
+
+    removeItem (index);
+
+    mMedia.erase (mMedia.begin() + index);
+
+    if (count() == 0)
+    {
+        /* no media left, add the "no media" pseudo-item */
+        addNoMediaItem();
+    }
+
+    /* emit the signal to ensure the parent dialog handles the change of
+     * the selected item */
+    emit activated (currentItem());
+}
+
+void VBoxMediaComboBox::processActivated (int aIndex)
+{
+    AssertReturnVoid (aIndex >= 0 && (size_t) aIndex < mMedia.size());
+
+    mLastId = mMedia [aIndex].id;
+
+    updateToolTip (aIndex);
+}
+
+void VBoxMediaComboBox::addNoMediaItem()
+{
+    AssertReturnVoid (count() == 0);
+    AssertReturnVoid (mMedia.size() == 0);
+
+    mMedia.append (
+        Medium (QUuid(), QString::null,
+                tr ("No media available. Use the Virtual Media "
+                    "Manager to add media of the corresponding type.")));
+    insertItem (tr ("<no media>"));
+
+    setCurrentItem (0);
+}
+
+void VBoxMediaComboBox::updateToolTip (int aIndex)
+{
+    /* set the combobox tooltip */
     QToolTip::remove (this);
-    if (!mTipList.isEmpty() && aItem >= 0)
-        QToolTip::add (this, mTipList [aItem]);
-}
-
-void VBoxMediaComboBox::processOnItem (QListBoxItem* aItem)
-{
-    /* combobox item's tooltip attaching */
+    if (aIndex >= 0 && (size_t) aIndex < mMedia.size())
+        QToolTip::add (this, mMedia [aIndex].toolTip);
+}
+
+void VBoxMediaComboBox::processOnItem (QListBoxItem *aItem)
+{
+    /* set the combobox item's tooltip */
     int index = listBox()->index (aItem);
     QToolTip::remove (listBox()->viewport());
-    QToolTip::add (listBox()->viewport(), mTipList [index]);
-}
-
-QUuid VBoxMediaComboBox::getId (int aId)
-{
-    return mUuidList.isEmpty() ? QUuid() :
-           aId == -1 ? QUuid (mUuidList [currentItem()]) :
-           QUuid (mUuidList [aId]);
-}
-
-void VBoxMediaComboBox::appendItem (const QString &aName,
-                                    const QUuid   &aId,
-                                    const QString &aTip,
-                                    QPixmap       *aPixmap)
-{
-    int currentIndex = currentItem();
-
-    int insertPosition = -1;
-    for (int i = 0; i < count(); ++ i)
-        /* Searching for the first real (non-null) vdi item
-           which have name greater than the item to be inserted.
-           This is necessary for sorting items alphabetically. */
-        if (text (i).localeAwareCompare (aName) > 0 &&
-            !getId (i).isNull())
+    QToolTip::add (listBox()->viewport(), mMedia [index].toolTip);
+}
+
+void VBoxMediaComboBox::appendItem (const VBoxMedium &aMedium)
+{
+    if (!mShowDiffs && aMedium.parent() != NULL)
+    {
+        /* We are adding the direct machine diff in !mShowDiffs mode. Since its
+         * base hard disk has been already appended (enumerated before), we want
+         * to replace the base with the diff to avoid shownig both (both would
+         * be labeled using the base filename and therefore look like
+         * duplicates). Note though that these visual duplicates are still
+         * possible in !mShowDiffs mode if the same base hard disk is attached*
+         * to the VM through different diffs (this is why we don't assert
+         * below on findMediaIndex() == true). However, this situation is
+         * unavoidable so we accept it assuming that the user will switch to
+           mShowDiffs mode if he needs clarity. */
+        size_t index;
+        if (findMediaIndex (aMedium.root().id(), index))
         {
-            insertPosition = i;
+            replaceItem (index, aMedium);
+            return;
+        }
+    }
+
+    if (count() == 1 && mMedia [0].id.isNull())
+    {
+        /* there is a "no media" pseudo-item, remove it */
+        clear(), mMedia.clear();
+    }
+
+    mMedia.append (Medium (aMedium.id(), aMedium.location(),
+                           aMedium.toolTipCheckRO (!mShowDiffs)));
+
+    insertItem (aMedium.iconCheckRO (!mShowDiffs),
+                aMedium.details (!mShowDiffs), -1);
+}
+
+void VBoxMediaComboBox::replaceItem (int aIndex, const VBoxMedium &aMedium)
+{
+    AssertReturnVoid (aIndex >= 0 && (size_t) aIndex < mMedia.size());
+
+    mMedia [aIndex].id = aMedium.id();
+    mMedia [aIndex].location = aMedium.location();
+    mMedia [aIndex].toolTip = aMedium.toolTipCheckRO (!mShowDiffs);
+
+    changeItem (aMedium.iconCheckRO (!mShowDiffs),
+                aMedium.details (!mShowDiffs), aIndex);
+
+    if (aIndex == currentItem())
+        updateToolTip (aIndex);
+}
+
+/**
+ * Searches for a medium with the given ID in mMedia and stores its index in @a
+ * aIndex. Returns @c true if the media was found and @c false otherwise (@a
+ * aIndex will be set to a value >= mMedia.size() in this case).
+ *
+ * @param aId       Media ID to search for.
+ * @param aIndex    Where to store the found media index.
+ */
+bool VBoxMediaComboBox::findMediaIndex (const QUuid &aId, size_t &aIndex)
+{
+    aIndex = 0;
+
+    for (; aIndex < mMedia.size(); ++ aIndex )
+        if (mMedia [aIndex ].id == aId)
             break;
-        }
-
-    insertPosition == -1 ? mUuidList.append (aId) :
-        mUuidList.insert (mUuidList.at (insertPosition), aId);
-
-    insertPosition == -1 ? mTipList.append (aTip) :
-        mTipList.insert (mTipList.at (insertPosition), aTip);
-
-    aPixmap ? insertItem (*aPixmap, aName, insertPosition) :
-              insertItem (aName, insertPosition);
-
-    if (insertPosition != -1 && currentIndex >= insertPosition)
-        QComboBox::setCurrentItem (currentIndex + 1);
-}
-
-void VBoxMediaComboBox::replaceItem (int            aNumber,
-                                     const QString &aName,
-                                     const QString &aTip,
-                                     QPixmap       *aPixmap)
-{
-    aPixmap ? changeItem (*aPixmap, aName, aNumber) : changeItem (aName, aNumber);
-    mTipList [aNumber] = aTip;
-}
-
-void VBoxMediaComboBox::setUseEmptyItem (bool aUseEmptyItem)
-{
-    mUseEmptyItem = aUseEmptyItem;
-}
-
-void VBoxMediaComboBox::setBelongsTo (const QUuid &aMachineId)
-{
-    mMachineId = aMachineId;
-}
-
-QUuid VBoxMediaComboBox::getBelongsTo()
-{
-    return mMachineId;
-}
-
-void VBoxMediaComboBox::setCurrentItem (const QUuid &aId)
-{
-    mRequiredId = aId;
-    int index = mUuidList.findIndex (mRequiredId);
-    if (index != -1)
-    {
-        QComboBox::setCurrentItem (index);
-        emit activated (index);
-    }
-}
-
-void VBoxMediaComboBox::setType (int aType)
-{
-    mType = aType;
-}
+
+    return aIndex < mMedia.size();
+}
+

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -602 +602 @@
 }
 
-void VBoxProblemReporter::cannotAccessUSB (const COMBase &obj)
+void VBoxProblemReporter::cannotAccessUSB (const COMBaseWithEI &obj)
 {
     /* If IMachine::GetUSBController(), IHost::GetUSBDevices() etc. return
@@ -702 +702 @@
 {
     AssertWrapperOk (progress);
-    CConsole console = CProgress (progress).GetInitiator();
+    CConsole console (CProgress (progress).GetInitiator());
     AssertWrapperOk (console);
 
@@ -762 +762 @@
 {
     AssertWrapperOk (progress);
-    CConsole console = CProgress (progress).GetInitiator();
+    CConsole console (CProgress (progress).GetInitiator());
     AssertWrapperOk (console);
 
@@ -788 +788 @@
 {
     AssertWrapperOk (progress);
-    CConsole console = CProgress (progress).GetInitiator();
+    CConsole console (CProgress (progress).GetInitiator());
     AssertWrapperOk (console);
 
@@ -814 +814 @@
 {
     AssertWrapperOk (progress);
-    CConsole console = CProgress (progress).GetInitiator();
+    CConsole console (CProgress (progress).GetInitiator());
     AssertWrapperOk (console);
 
@@ -859 +859 @@
 }
 
-void VBoxProblemReporter::cannotDiscardSnapshot (const CConsole &console,
-                                                 const CSnapshot &snapshot)
-{
-    message (
-        mainWindowShown(),
-        Error,
+void VBoxProblemReporter::cannotDiscardSnapshot (const CConsole &aConsole,
+                                                 const QString &aSnapshotName)
+{
+    message (mainWindowShown(), Error,
         tr ("Failed to discard the snapshot <b>%1</b> of the virtual "
             "machine <b>%2</b>.")
-            .arg (snapshot.GetName())
-            .arg (CConsole (console).GetMachine().GetName()),
-        formatErrorInfo (console));
-}
-
-void VBoxProblemReporter::cannotDiscardSnapshot (const CProgress &progress,
-                                                 const CSnapshot &snapshot)
-{
-    CConsole console = CProgress (progress).GetInitiator();
-
-    message (
-        mainWindowShown(),
-        Error,
+            .arg (aSnapshotName)
+            .arg (CConsole (aConsole).GetMachine().GetName()),
+        formatErrorInfo (aConsole));
+}
+
+void VBoxProblemReporter::cannotDiscardSnapshot (const CProgress &aProgress,
+                                                 const QString &aSnapshotName)
+{
+    CConsole console (CProgress (aProgress).GetInitiator());
+
+    message (mainWindowShown(), Error,
         tr ("Failed to discard the snapshot <b>%1</b> of the virtual "
             "machine <b>%2</b>.")
-            .arg (snapshot.GetName())
+            .arg (aSnapshotName)
             .arg (console.GetMachine().GetName()),
-        formatErrorInfo (progress.GetErrorInfo()));
+        formatErrorInfo (aProgress.GetErrorInfo()));
 }
 
@@ -900 +896 @@
 void VBoxProblemReporter::cannotDiscardCurrentState (const CProgress &progress)
 {
-    CConsole console = CProgress (progress).GetInitiator();
+    CConsole console (CProgress (progress).GetInitiator());
 
     message (
@@ -924 +920 @@
 void VBoxProblemReporter::cannotDiscardCurrentSnapshotAndState (const CProgress &progress)
 {
-    CConsole console = CProgress (progress).GetInitiator();
+    CConsole console (CProgress (progress).GetInitiator());
 
     message (
@@ -1024 +1020 @@
 }
 
-bool VBoxProblemReporter::confirmReleaseImage (QWidget *parent,
-                                               const QString &usage)
-{
-    return messageOkCancel (parent, Question,
-        tr ("<p>Releasing this media image will detach it from the "
-            "following virtual machine(s): <b>%1</b>.</p>"
-            "<p>Continue?</p>")
-            .arg (usage),
-        "confirmReleaseImage",
-        tr ("Continue", "detach image"));
-}
-
-void VBoxProblemReporter::sayCannotOverwriteHardDiskImage (QWidget *parent,
-                                                           const QString &src)
-{
-    message (parent, Info,
-        tr ("<p>The image file <b>%1</b> already exists. "
-            "You cannot create a new virtual hard disk that uses this file, "
-            "because it can be already used by another virtual hard disk.</p>"
-            "<p>Please specify a different image file name.</p>")
-            .arg (src));
-}
-
-int VBoxProblemReporter::confirmHardDiskImageDeletion (QWidget *parent,
-                                                        const QString &src)
-{
-    return message (parent, Question,
-        tr ("<p>Do you want to delete this hard disk's image file "
-            "<nobr><b>%1</b>?</nobr></p>"
-            "<p>If you select <b>Delete</b> then the image file will be permanently "
-            "deleted after unregistering the hard disk. This operation "
-            "cannot be undone.</p>"
-            "<p>If you select <b>Unregister</b> then the virtual hard disk will be "
-            "unregistered and removed from the collection, but the image file "
-            "will be left on your physical disk.</p>")
-            .arg (src),
+bool VBoxProblemReporter::confirmReleaseMedium (QWidget *aParent,
+                                                const VBoxMedium &aMedium,
+                                                const QString &aUsage)
+{
+    return messageOkCancel (aParent, Question,
+        tr ("<p>Are you sure you want to release the %1 "
+            "<nobr><b>%2</b></nobr>?</p>"
+            "<p>This will detach it from the "
+            "following virtual machine(s): <b>%3</b>.</p>")
+            .arg (toAccusative (aMedium.type()))
+            .arg (aMedium.location())
+            .arg (aUsage),
+        0 /* aAutoConfirmId */,
+        tr ("Release", "detach medium"));
+}
+
+bool VBoxProblemReporter::confirmRemoveMedium (QWidget *aParent,
+                                               const VBoxMedium &aMedium)
+{
+    QString msg =
+        tr ("<p>Are you sure you want to remove the %1 "
+            "<nobr><b>%2</b></nobr> from the list of known media?</p>")
+            .arg (toAccusative (aMedium.type()))
+            .arg (aMedium.location());
+
+    if (aMedium.type() == VBoxDefs::MediaType_HardDisk)
+    {
+        if (aMedium.state() == KMediaState_Inaccessible)
+            msg +=
+                tr ("Note that this hard disk is inaccessible so that its "
+                    "storage unit cannot be deleted right now.");
+        else
+            msg +=
+                tr ("The next dialog will let you choose whether you also "
+                    "want to delete the storage unit of this hard disk or "
+                    "keep it for later usage.");
+    }
+    else
+        msg +=
+            tr ("<p>Note that the storage unit of this medium will not be "
+                "deleted and therefore it will be possible to add it to "
+                "the list later again.</p>");
+
+    return messageOkCancel (aParent, Question, msg,
+        "confirmRemoveMedium", /* aAutoConfirmId */
+        tr ("Remove", "medium"));
+}
+
+void VBoxProblemReporter::sayCannotOverwriteHardDiskStorage (
+    QWidget *aParent, const QString &aLocation)
+{
+    message (aParent, Info,
+        tr ("<p>The hard disk storage unit at location <b>%1</b> already "
+            "exists. You cannot create a new virtual hard disk that uses this "
+            "location because it can be already used by another virtual hard "
+            "disk.</p>"
+            "<p>Please specify a different location.</p>")
+            .arg (aLocation));
+}
+
+int VBoxProblemReporter::confirmDeleteHardDiskStorage (
+    QWidget *aParent, const QString &aLocation)
+{
+    return message (aParent, Question,
+        tr ("<p>Do you want to delete the storage unit of the hard disk "
+            "<nobr><b>%1</b></nobr>?</p>"
+            "<p>If you select <b>Delete</b> then the specified storage unit "
+            "will be permanently deleted. This operation <b>cannot be "
+            "undone</b>.</p>"
+            "<p>If you select <b>Keep</b> then the hard disk will be only "
+            "removed from the list of known hard disks, but the storage unit "
+            "will be left untouched which makes it possible to add this hard "
+            "disk to the list later again.</p>")
+            .arg (aLocation),
         0, /* aAutoConfirmId */
         QIMessageBox::Yes,
         QIMessageBox::No | QIMessageBox::Default,
         QIMessageBox::Cancel | QIMessageBox::Escape,
-        tr ("Delete", "hard disk"),
-        tr ("Unregister", "hard disk"));
-}
-
-void VBoxProblemReporter::cannotDeleteHardDiskImage (QWidget *parent,
-                                                     const CVirtualDiskImage &vdi)
-{
-    /* below, we use CHardDisk (hd) to preserve current error info
+        tr ("Delete", "hard disk storage"),
+        tr ("Keep", "hard disk storage"));
+}
+
+void VBoxProblemReporter::cannotDeleteHardDiskStorage (QWidget *aParent,
+                                                       const CHardDisk2 &aHD,
+                                                       const CProgress &aProgress)
+{
+    /* below, we use CHardDisk2 (aHD) to preserve current error info
      * for formatErrorInfo() */
 
-    message (parent, Error,
-        tr ("Failed to delete the virtual hard disk image <b>%1</b>.")
-            .arg (CVirtualDiskImage (vdi).GetFilePath()),
-        formatErrorInfo (vdi));
-}
-
-bool VBoxProblemReporter::confirmHardDiskUnregister (QWidget *parent,
-                                                    const QString &src)
-{
-    return messageOkCancel (parent, Question,
-        tr ("<p>Do you want to remove (unregister) the virtual hard disk "
-            "<nobr><b>%1</b>?</nobr></p>")
-            .arg (src),
-        0 /* aAutoConfirmId */,
-        tr ("Unregister", "hard disk"));
+    message (aParent, Error,
+        tr ("Failed to delete the storage unit of the hard disk <b>%1</b>.")
+            .arg (CHardDisk2 (aHD).GetLocation()),
+        !aHD.isOk() ? formatErrorInfo (aHD) :
+        !aProgress.isOk() ? formatErrorInfo (aProgress) :
+        formatErrorInfo (aProgress.GetErrorInfo()));
 }
 
@@ -1110 +1136 @@
             "<p>Press the <b>Create</b> button to start the <i>New Virtual "
             "Disk</i> wizard and create a new hard disk, or press the "
-            "<b>Select</b> button to open the <i>Virtual Disk Manager</i> "
+            "<b>Select</b> button to open the <i>Virtual Media Manager</i> "
             "and select what to do.</p>"),
         0, /* aAutoConfirmId */
@@ -1120 +1146 @@
 }
 
-void VBoxProblemReporter::cannotCreateHardDiskImage (
-    QWidget *parent, const CVirtualBox &vbox, const QString &src,
-    const CVirtualDiskImage &vdi, const CProgress &progress)
-{
-    message (parent, Error,
-        tr ("Failed to create the virtual hard disk image <nobr><b>%1</b>.</nobr>")
-            .arg (src),
-        !vbox.isOk() ? formatErrorInfo (vbox) :
-        !vdi.isOk() ? formatErrorInfo (vdi) :
-        formatErrorInfo (progress.GetErrorInfo()));
+void VBoxProblemReporter::cannotCreateHardDiskStorage (
+    QWidget *aParent, const CVirtualBox &aVBox, const QString &aLocation,
+    const CHardDisk2 &aHD, const CProgress &aProgress)
+{
+    message (aParent, Error,
+        tr ("Failed to create the hard disk storage <nobr><b>%1</b>.</nobr>")
+            .arg (aLocation),
+        !aVBox.isOk() ? formatErrorInfo (aVBox) :
+        !aHD.isOk() ? formatErrorInfo (aHD) :
+        !aProgress.isOk() ? formatErrorInfo (aProgress) :
+        formatErrorInfo (aProgress.GetErrorInfo()));
 }
 
 void VBoxProblemReporter::cannotAttachHardDisk (
-    QWidget *parent, const CMachine &m, const QUuid &id,
-    KStorageBus bus, LONG channel, LONG dev)
-{
-    message (parent, Error,
-        tr ("Failed to attach a hard disk image with UUID %1 "
-            "to device slot %2 on channel %3 of the %4 bus of the machine <b>%5</b>.")
-            .arg (id)
-            .arg (vboxGlobal().toString (bus, channel, dev))
-            .arg (vboxGlobal().toString (bus, channel))
-            .arg (vboxGlobal().toString (bus))
-            .arg (CMachine (m).GetName()),
-        formatErrorInfo (m));
+    QWidget *aParent, const CMachine &aMachine, const QString &aLocation,
+    KStorageBus aBus, LONG aChannel, LONG aDevice)
+{
+    message (aParent, Error,
+        tr ("Failed to attach the hard disk <nobr><b>%1</b></nobr> "
+            "to the slot <i>%2</i> of the machine <b>%3</b>.")
+            .arg (aLocation)
+            .arg (vboxGlobal().toFullString (aBus, aChannel, aDevice))
+            .arg (CMachine (aMachine).GetName()),
+        formatErrorInfo (aMachine));
 }
 
 void VBoxProblemReporter::cannotDetachHardDisk (
-    QWidget *parent, const CMachine &m,
-    KStorageBus bus, LONG channel, LONG dev)
-{
-    message (parent, Error,
-        tr ("Failed to detach a hard disk image "
-            "from device slot %1 on channel %2 of the %3 bus of the machine <b>%4</b>.")
-            .arg (vboxGlobal().toString (bus, channel, dev))
-            .arg (vboxGlobal().toString (bus, channel))
-            .arg (vboxGlobal().toString (bus))
-            .arg (CMachine (m).GetName()),
-        formatErrorInfo (m));
-}
-
-void VBoxProblemReporter::cannotRegisterMedia (
-    QWidget *parent, const CVirtualBox &vbox,
-    VBoxDefs::DiskType type, const QString &src)
-{
-    QString media = type == VBoxDefs::HD ? tr ("hard disk") :
-                    type == VBoxDefs::CD ? tr ("CD/DVD image") :
-                    type == VBoxDefs::FD ? tr ("floppy image") :
-                    QString::null;
-
-    Assert (!media.isNull());
-
-    message (parent, Error,
-        tr ("Failed to register the %1 <nobr><b>%2</b></nobr>.")
-            .arg (media)
-            .arg (src),
-        formatErrorInfo (vbox));
-}
-
-void VBoxProblemReporter::cannotUnregisterMedia (
-    QWidget *parent, const CVirtualBox &vbox,
-    VBoxDefs::DiskType type, const QString &src)
-{
-    QString media = type == VBoxDefs::HD ? tr ("hard disk") :
-                    type == VBoxDefs::CD ? tr ("CD/DVD image") :
-                    type == VBoxDefs::FD ? tr ("floppy image") :
-                    QString::null;
-
-    Assert (!media.isNull());
-
-    message (parent, Error,
-        tr ("Failed to unregister the %1 <nobr><b>%2</b></nobr>.")
-            .arg (media)
-            .arg (src),
-        formatErrorInfo (vbox));
+    QWidget *aParent, const CMachine &aMachine, const QString &aLocation,
+    KStorageBus aBus, LONG aChannel, LONG aDevice)
+{
+    message (aParent, Error,
+        tr ("Failed to detach the hard disk <nobr><b>%1</b></nobr> "
+            "from the slot <i>%2</i> of the machine <b>%3</b>.")
+            .arg (aLocation)
+            .arg (vboxGlobal().toFullString (aBus, aChannel, aDevice))
+            .arg (CMachine (aMachine).GetName()),
+         formatErrorInfo (aMachine));
+}
+
+void VBoxProblemReporter::
+cannotMountMedium (QWidget *aParent, const CMachine &aMachine,
+                   const VBoxMedium &aMedium, const COMResult &aResult)
+{
+    message (aParent, Error,
+        tr ("Failed to mount the %1 <nobr><b>%2</b></nobr> "
+            "to the machine <b>%3</b>.")
+            .arg (toAccusative (aMedium.type()))
+            .arg (aMedium.location())
+            .arg (CMachine (aMachine).GetName()),
+      formatErrorInfo (aResult));
+}
+
+void VBoxProblemReporter::
+cannotUnmountMedium (QWidget *aParent, const CMachine &aMachine,
+                     const VBoxMedium &aMedium, const COMResult &aResult)
+{
+    message (aParent, Error,
+        tr ("Failed to unmount the %1 <nobr><b>%2</b></nobr> "
+            "from the machine <b>%3</b>.")
+            .arg (toAccusative (aMedium.type()))
+            .arg (aMedium.location())
+            .arg (CMachine (aMachine).GetName()),
+      formatErrorInfo (aResult));
+}
+
+void VBoxProblemReporter::cannotOpenMedium (
+    QWidget *aParent, const CVirtualBox &aVBox,
+    VBoxDefs::MediaType aType, const QString &aLocation)
+{
+    message (aParent, Error,
+        tr ("Failed to open the %1 <nobr><b>%2</b></nobr>.")
+            .arg (toAccusative (aType))
+            .arg (aLocation),
+        formatErrorInfo (aVBox));
+}
+
+void VBoxProblemReporter::cannotCloseMedium (
+    QWidget *aParent, const VBoxMedium &aMedium, const COMResult &aResult)
+{
+    message (aParent, Error,
+        tr ("Failed to close the %1 <nobr><b>%2</b></nobr>.")
+            .arg (toAccusative (aMedium.type()))
+            .arg (aMedium.location()),
+        formatErrorInfo (aResult));
 }
 
@@ -1229 +1264 @@
 }
 
-void VBoxProblemReporter::cannotGetMediaAccessibility (const CUnknown &unk)
-{
-    QString src;
-    CHardDisk hd;
-    CDVDImage dvd;
-    CFloppyImage floppy;
-
-    if (!(hd = unk).isNull())
-        src = hd.GetLocation();
-    else
-    if (!(dvd = unk).isNull())
-        src = dvd.GetFilePath();
-    else
-    if (!(floppy = unk).isNull())
-        src = floppy.GetFilePath();
-    else
-        AssertMsgFailed (("Not a valid CUnknown\n"));
-
+void VBoxProblemReporter::cannotGetMediaAccessibility (const VBoxMedium &aMedium)
+{
     message (qApp->activeWindow(), Error,
-        tr ("Failed to get the accessibility state of the media "
-            "<nobr><b>%1</b></nobr>. Some of the registered media may "
-            "become inaccessible.")
-            .arg (src),
-        formatErrorInfo (unk));
+        tr ("Failed to get the accessibility state of the medium "
+            "<nobr><b>%1</b></nobr>.")
+            .arg (aMedium.location()),
+        formatErrorInfo (aMedium.result()));
 }
 
@@ -1688 +1706 @@
 {
     int rc = message (&vboxGlobal().selectorWnd(), Warning,
-        tr ("<p>One or more of the registered virtual hard disks, CD/DVD or "
+        tr ("<p>One or more virtual hard disks, CD/DVD or "
             "floppy media are not currently accessible. As a result, you will "
             "not be able to operate virtual machines that use these media until "
             "they become accessible later.</p>"
-            "<p>Press <b>Check</b> to open the Virtual Disk Manager window and "
+            "<p>Press <b>Check</b> to open the Virtual Media Manager window and "
             "see what media are inaccessible, or press <b>Ignore</b> to "
             "ignore this message.</p>"),
@@ -2002 +2020 @@
 }
 
+/* static */
+QString VBoxProblemReporter::toAccusative (VBoxDefs::MediaType aType)
+{
+    QString type =
+        aType == VBoxDefs::MediaType_HardDisk ?
+            tr ("hard disk", "failed to close ...") :
+        aType == VBoxDefs::MediaType_DVD ?
+            tr ("CD/DVD image", "failed to close ...") :
+        aType == VBoxDefs::MediaType_Floppy ?
+            tr ("floppy image", "failed to close ...") :
+        QString::null;
+
+    Assert (!type.isNull());
+    return type;
+}
+
 /**
  * Formats the given COM result code as a human-readable string.

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

@@ -29 +29 @@
 #include "VBoxSnapshotsWgt.h"
 #include "VBoxNewVMWzd.h"
-#include "VBoxDiskImageManagerDlg.h"
+#include "VBoxMediaManagerDlg.h"
 #include "VBoxVMSettingsDlg.h"
 #include "VBoxGlobalSettingsDlg.h"
@@ -400 +400 @@
     /* actions */
 
-    fileDiskMgrAction = new QAction( this, "fileDiskMgrAction" );
-    fileDiskMgrAction->setIconSet (VBoxGlobal::iconSet ("diskim_16px.png"));
+    fileMediaMgrAction = new QAction( this, "fileMediaMgrAction" );
+    fileMediaMgrAction->setIconSet (VBoxGlobal::iconSet ("diskim_16px.png"));
     fileSettingsAction = new QAction(this, "fileSettingsAction");
     fileSettingsAction->setIconSet (VBoxGlobal::iconSet ("global_settings_16px.png"));
@@ -519 +519 @@
 
     QPopupMenu *fileMenu = new QPopupMenu(this, "fileMenu");
-    fileDiskMgrAction->addTo( fileMenu );
+    fileMediaMgrAction->addTo( fileMenu );
     fileMenu->insertSeparator();
     fileSettingsAction->addTo(fileMenu);
@@ -626 +626 @@
 
     /* signals and slots connections */
-    connect (fileDiskMgrAction, SIGNAL (activated()), this, SLOT(fileDiskMgr()));
+    connect (fileMediaMgrAction, SIGNAL (activated()), this, SLOT(fileMediaMgr()));
     connect (fileSettingsAction, SIGNAL (activated()), this, SLOT(fileSettings()));
     connect (fileExitAction, SIGNAL (activated()), this, SLOT (fileExit()));
@@ -712 +712 @@
 /////////////////////////////////////////////////////////////////////////////
 
-void VBoxSelectorWnd::fileDiskMgr()
-{
-    VBoxDiskImageManagerDlg::showModeless();
+void VBoxSelectorWnd::fileMediaMgr()
+{
+    VBoxMediaManagerDlg::showModeless();
 }
 
@@ -838 +838 @@
     VBoxVMListBoxItem *item = (VBoxVMListBoxItem *) vmListBox->selectedItem();
 
-    AssertMsgReturn (item, ("Item must be always selected here"), (void) 0);
+    AssertMsgReturnVoid (item, ("Item must be always selected here"));
 
     if (vboxProblem().confirmMachineDeletion (item->machine()))
@@ -847 +847 @@
         if (item->accessible())
         {
-            /* open a direct session to modify VM settings */
+            /* Open a direct session to modify VM settings */
             CSession session = vboxGlobal().openSession (id);
             if (session.isNull())
                 return;
             CMachine machine = session.GetMachine();
-            /* detach all hard disks before unregistering */
+            /* Detach all attached Hard Disks */
+            CHardDisk2AttachmentVector vec = machine.GetHardDisk2Attachments();
+            for (uint i = 0; i < vec.size(); ++ i)
             {
-                CHardDiskAttachmentEnumerator hen
-                    = machine.GetHardDiskAttachments().Enumerate();
-                while (hen.HasMore())
-                {
-                    CHardDiskAttachment att = hen.GetNext();
-                    machine.DetachHardDisk (att.GetBus(), att.GetChannel(), att.GetDevice());
-                }
+                CHardDisk2Attachment hda = vec [i];
+                machine.DetachHardDisk2 (hda.GetBus(), hda.GetChannel(), hda.GetDevice());
+                if (!machine.isOk())
+                    vboxProblem().cannotDetachHardDisk (this, machine,
+                        vboxGlobal().getMedium (CMedium (hda.GetHardDisk())).location(),
+                        hda.GetBus(), hda.GetChannel(), hda.GetDevice());
             }
-            /* commit changes */
+            /* Commit changes */
             machine.SaveSettings();
             if (!machine.isOk())
@@ -1140 +1141 @@
     vmListBoxCurrentChanged();
 
-    fileDiskMgrAction->setMenuText (tr ("Virtual &Disk Manager..."));
-    fileDiskMgrAction->setAccel (tr ("Ctrl+D"));
-    fileDiskMgrAction->setStatusTip (tr ("Display the Virtual Disk Manager dialog"));
+    fileMediaMgrAction->setMenuText (tr ("&Virtual Media Manager..."));
+    fileMediaMgrAction->setAccel (tr ("Ctrl+D"));
+    fileMediaMgrAction->setStatusTip (tr ("Display the Virtual Media Manager dialog"));
 
 #ifdef Q_WS_MAC
@@ -1435 +1436 @@
             break;
 
-        /* ignore the signal if a VBoxDiskImageManagerDlg window is active */
+        /* ignore the signal if a VBoxMediaManagerDlg window is active */
         if (qApp->activeWindow() &&
-            !strcmp (qApp->activeWindow()->className(), "VBoxDiskImageManagerDlg"))
+            !strcmp (qApp->activeWindow()->className(), "VBoxMediaManagerDlg"))
             break;
 
@@ -1443 +1444 @@
         VBoxMediaList::const_iterator it;
         for (it = list.begin(); it != list.end(); ++ it)
-            if ((*it).status == VBoxMedia::Inaccessible)
+            if ((*it).state() == KMediaState_Inaccessible)
                 break;
 
@@ -1450 +1451 @@
             /* Show the VDM dialog but don't refresh once more after a
              * just-finished refresh */
-            VBoxDiskImageManagerDlg::showModeless (false /* aRefresh */);
+            VBoxMediaManagerDlg::showModeless (false /* aRefresh */);
         }
     }

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

@@ -453 +453 @@
     const VBoxVMListBox *lb = vmListBox();
 
-    QFontMetrics fmName = QFontMetrics (lb->nameFont());
-    QFontMetrics fmShot = QFontMetrics (lb->shotFont());
-    QFontMetrics fmState = QFontMetrics (lb->stateFont (mSessionState));
+    QFontMetrics fmName (lb->nameFont());
+    QFontMetrics fmShot (lb->shotFont());
+    QFontMetrics fmState (lb->stateFont (mSessionState));
     const int marg = lb->margin();
 
@@ -492 +492 @@
     const VBoxVMListBox *lb = vmListBox();
 
-    QFontMetrics fmName = QFontMetrics (lb->nameFont());
-    QFontMetrics fmState = QFontMetrics (lb->stateFont (mSessionState));
+    QFontMetrics fmName (lb->nameFont());
+    QFontMetrics fmState (lb->stateFont (mSessionState));
     const int marg = lb->margin();
 
@@ -671 +671 @@
     const VBoxVMListBox *lb = vmListBox();
 
-    QFontMetrics fmName = QFontMetrics (lb->nameFont());
-    QFontMetrics fmShot = QFontMetrics (lb->shotFont());
-    QFontMetrics fmState = QFontMetrics (lb->stateFont (mSessionState));
+    QFontMetrics fmName (lb->nameFont());
+    QFontMetrics fmShot (lb->shotFont());
+    QFontMetrics fmState (lb->stateFont (mSessionState));
     const int marg = lb->margin();
 

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

@@ -244 +244 @@
             else
             {
+                /* pre-populate the media list before showing the main widget */
+                vboxGlobal().startEnumeratingMedia();
+
                 a.setMainWidget (&vboxGlobal().selectorWnd());
                 vboxGlobal().selectorWnd().show();
@@ -249 +252 @@
                 vboxGlobal().showRegistrationDialog (false /* aForce */);
 #endif
-                vboxGlobal().startEnumeratingMedia();
                 rc = a.exec();
             }

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

@@ -275 +275 @@
                             <widget class="QLineEdit" row="0" column="1">
                                 <property name="name">
-                                    <cstring>leVDIFolder</cstring>
+                                    <cstring>leHardDiskFolder</cstring>
                                 </property>
                                 <property name="frameShape">
@@ -284 +284 @@
                                 </property>
                                 <property name="whatsThis" stdset="0">
-                                    <string>Displays the path to the default VDI folder. This folder is used, if not explicitly specified otherwise, when adding existing or creating new virtual hard disks.</string>
+                                    <string>Displays the path to the default hard disk folder. This folder is used, if not explicitly specified otherwise, when adding existing or creating new virtual hard disks.</string>
                                 </property>
                             </widget>
@@ -300 +300 @@
                                 </property>
                                 <property name="text">
-                                    <string>VDI files</string>
+                                    <string>Hard Disks</string>
                                 </property>
                             </widget>
@@ -325 +325 @@
                             <widget class="QToolButton" row="0" column="3">
                                 <property name="name">
-                                    <cstring>tbResetVDIFolder</cstring>
+                                    <cstring>tbResetHardDiskFolder</cstring>
                                 </property>
                                 <property name="focusPolicy">
@@ -340 +340 @@
                                 </property>
                                 <property name="whatsThis" stdset="0">
-                                    <string>Resets the VDI folder path to the default value. The actual default path will be displayed after accepting the changes and opening this dialog again.</string>
+                                    <string>Resets the hard disk folder path to the default value. The actual default path will be displayed after accepting the changes and opening this dialog again.</string>
                                 </property>
                             </widget>
@@ -353 +353 @@
                             <widget class="QToolButton" row="0" column="2">
                                 <property name="name">
-                                    <cstring>tbSelectVDIFolder</cstring>
+                                    <cstring>tbSelectHardDiskFolder</cstring>
                                 </property>
                                 <property name="focusPolicy">
@@ -371 +371 @@
                                 </property>
                                 <property name="whatsThis" stdset="0">
-                                    <string>Opens a dialog to select the default VDI folder.</string>
+                                    <string>Opens a dialog to select the default hard disk folder.</string>
                                 </property>
                             </widget>
@@ -1163 +1163 @@
     </connection>
     <connection>
-        <sender>tbResetVDIFolder</sender>
+        <sender>tbResetHardDiskFolder</sender>
         <signal>clicked()</signal>
         <receiver>VBoxGlobalSettingsDlg</receiver>
@@ -1169 +1169 @@
     </connection>
     <connection>
-        <sender>tbSelectVDIFolder</sender>
+        <sender>tbSelectHardDiskFolder</sender>
         <signal>clicked()</signal>
         <receiver>VBoxGlobalSettingsDlg</receiver>
@@ -1256 +1256 @@
     <tabstop>listView</tabstop>
     <tabstop>chbAutoCapture</tabstop>
-    <tabstop>leVDIFolder</tabstop>
-    <tabstop>tbSelectVDIFolder</tabstop>
-    <tabstop>tbResetVDIFolder</tabstop>
+    <tabstop>leHardDiskFolder</tabstop>
+    <tabstop>tbSelectHardDiskFolder</tabstop>
+    <tabstop>tbResetHardDiskFolder</tabstop>
     <tabstop>leMachineFolder</tabstop>
     <tabstop>tbSelectMachineFolder</tabstop>

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

@@ -645 +645 @@
     /* default folders */
 
-    leVDIFolder->setText (props.GetDefaultVDIFolder());
+    leHardDiskFolder->setText (props.GetDefaultHardDiskFolder());
     leMachineFolder->setText (props.GetDefaultMachineFolder());
 
@@ -691 +691 @@
         {
             CHostUSBDeviceFilter hostFilter = en.GetNext();
-            CUSBDeviceFilter filter = CUnknown (hostFilter);
+            CUSBDeviceFilter filter (hostFilter);
             addUSBFilter (filter, false);
         }
@@ -726 +726 @@
     /* default folders */
 
-    if (leVDIFolder->isModified())
-        props.SetDefaultVDIFolder (leVDIFolder->text());
+    if (leHardDiskFolder->isModified())
+        props.SetDefaultHardDiskFolder (leHardDiskFolder->text());
     if (props.isOk() && leMachineFolder->isModified())
         props.SetDefaultMachineFolder (leMachineFolder->text());
@@ -774 +774 @@
         filter.SetActive (uli->isOn());
 
-        CHostUSBDeviceFilter insertedFilter = CUnknown (filter);
+        CHostUSBDeviceFilter insertedFilter (filter);
         if (mUSBFilterListModified)
             host.InsertUSBDeviceFilter (host.GetUSBDeviceFilters().GetCount(),
@@ -841 +841 @@
 
     QLineEdit *le = 0;
-    if (tb == tbResetVDIFolder) le = leVDIFolder;
+    if (tb == tbResetHardDiskFolder) le = leHardDiskFolder;
     else if (tb == tbResetMachineFolder) le = leMachineFolder;
     else if (tb == tbResetVRDPLib) le = leVRDPLib;
@@ -860 +860 @@
 
     QLineEdit *le = 0;
-    if (tb == tbSelectVDIFolder) le = leVDIFolder;
+    if (tb == tbSelectHardDiskFolder) le = leHardDiskFolder;
     else if (tb == tbSelectMachineFolder) le = leMachineFolder;
     else if (tb == tbSelectVRDPLib) le = leVRDPLib;
@@ -992 +992 @@
     hostFilter.SetAction (KUSBDeviceFilterAction_Hold);
 
-    CUSBDeviceFilter filter = CUnknown (hostFilter);
+    CUSBDeviceFilter filter (hostFilter);
     filter.SetActive (true);
     addUSBFilter (filter, true);
@@ -1025 +1025 @@
     hostFilter.SetAction (KUSBDeviceFilterAction_Hold);
 
-    CUSBDeviceFilter filter = CUnknown (hostFilter);
+    CUSBDeviceFilter filter (hostFilter);
     filter.SetVendorId (QString().sprintf ("%04hX", usb.GetVendorId()));
     filter.SetProductId (QString().sprintf ("%04hX", usb.GetProductId()));

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

@@ -56 +56 @@
                 <widget class="QCheckBox">
                     <property name="name">
-                        <cstring>mCbSATA</cstring>
+                        <cstring>mSATACheck</cstring>
                     </property>
                     <property name="text">
@@ -81 +81 @@
                             <cstring>unnamed</cstring>
                         </property>
-                        <widget class="QListView">
-                            <column>
+                        <vbox>
+                            <property name="name">
+                                <cstring>unnamed</cstring>
+                            </property>
+                            <widget class="QListView">
+                                <column>
+                                    <property name="text">
+                                        <string>Slot</string>
+                                    </property>
+                                    <property name="clickable">
+                                        <bool>true</bool>
+                                    </property>
+                                    <property name="resizable">
+                                        <bool>true</bool>
+                                    </property>
+                                </column>
+                                <column>
+                                    <property name="text">
+                                        <string>Hard Disk</string>
+                                    </property>
+                                    <property name="clickable">
+                                        <bool>true</bool>
+                                    </property>
+                                    <property name="resizable">
+                                        <bool>true</bool>
+                                    </property>
+                                </column>
+                                <property name="name">
+                                    <cstring>mLvHD</cstring>
+                                </property>
+                                <property name="allColumnsShowFocus">
+                                    <bool>true</bool>
+                                </property>
+                                <property name="resizeMode">
+                                    <enum>LastColumn</enum>
+                                </property>
+                                <property name="whatsThis" stdset="0">
+                                    <string>
+                                      &lt;qt&gt;Lists all hard disks attached to
+                                      this machine. Use a mouse double-click or the
+                                      &lt;tt&gt;F2&lt;/tt&gt;/&lt;tt&gt;Space&lt;/tt&gt;
+                                      key on the highlighted item to activate the
+                                      drop-down list and choose the desired value.
+                                      Use the context menu or buttons to the right
+                                      to add or remove hard disk
+                                      attachments.&lt;/qt&gt;
+                                    </string>
+                                </property>
+                            </widget>
+                            <widget class="QCheckBox">
+                                <property name="name">
+                                    <cstring>mShowDiffsCheck</cstring>
+                                </property>
                                 <property name="text">
-                                    <string>Slot</string>
-                                </property>
-                                <property name="clickable">
-                                    <bool>true</bool>
-                                </property>
-                                <property name="resizable">
-                                    <bool>true</bool>
-                                </property>
-                            </column>
-                            <column>
-                                <property name="text">
-                                    <string>Hard Disk</string>
-                                </property>
-                                <property name="clickable">
-                                    <bool>true</bool>
-                                </property>
-                                <property name="resizable">
-                                    <bool>true</bool>
-                                </property>
-                            </column>
-                            <property name="name">
-                                <cstring>mLvHD</cstring>
-                            </property>
-                            <property name="allColumnsShowFocus">
-                                <bool>true</bool>
-                            </property>
-                            <property name="resizeMode">
-                                <enum>LastColumn</enum>
-                            </property>
-                            <property name="whatsThis" stdset="0">
-                                <string>
-                                  &lt;qt&gt;Lists all hard disks attached to
-                                  this machine. Use a mouse double-click or the
-                                  &lt;tt&gt;F2&lt;/tt&gt;/&lt;tt&gt;Space&lt;/tt&gt;
-                                  key on the highlighted item to activate the
-                                  drop-down list and choose the desired value.
-                                  Use the context menu or buttons to the right
-                                  to add or remove hard disk
-                                  attachments.&lt;/qt&gt;
-                                </string>
-                            </property>
-                        </widget>
+                                    <string>&amp;Show Differencing Hard Disks</string>
+                                </property>
+                                <property name="whatsThis" stdset="0">
+                                    <string>
+                                      &lt;qt&gt;If checked, it will show
+                                      differencing hard disks actually attached
+                                      to the slots instead of their base hard
+                                      disks (shown in case of indirect
+                                      attachments) and will also let attach
+                                      other differencing hard disks explicitly.
+                                      Check this only if you need a complex hard
+                                      disk setup.&lt;/qt&gt;
+                                    </string>
+                                </property>
+                            </widget>
+                        </vbox>
                         <widget class="QLayoutWidget">
                             <property name="name">
@@ -218 +243 @@
         <property name="whatsThis" stdset="0">
             <string>
-              &lt;qt&gt;Invokes the Virtual Disk Manager to select a hard disk
+              &lt;qt&gt;Invokes the Virtual Media Manager to select a hard disk
               to attach to the currently highlighted slot.&lt;/qt&gt;
             </string>
@@ -241 +266 @@
         <signal>activated()</signal>
         <receiver>VBoxHardDiskSettings</receiver>
-        <slot>showVDM()</slot>
+        <slot>showMediaManager()</slot>
+    </connection>
+    <connection>
+        <sender>mSATACheck</sender>
+        <signal>toggled(bool)</signal>
+        <receiver>VBoxHardDiskSettings</receiver>
+        <slot>onSATACheckToggled(bool)</slot>
+    </connection>
+    <connection>
+        <sender>mLvHD</sender>
+        <signal>pressed(QListViewItem*,const QPoint&amp;,int)</signal>
+        <receiver>VBoxHardDiskSettings</receiver>
+        <slot>moveFocus(QListViewItem*, const QPoint&amp;,int)</slot>
+    </connection>
+    <connection>
+        <sender>mLvHD</sender>
+        <signal>currentChanged(QListViewItem*)</signal>
+        <receiver>VBoxHardDiskSettings</receiver>
+        <slot>onCurrentChanged(QListViewItem*)</slot>
+    </connection>
+    <connection>
+        <sender>mLvHD</sender>
+        <signal>contextMenuRequested(QListViewItem*,const QPoint&amp;,int)</signal>
+        <receiver>VBoxHardDiskSettings</receiver>
+        <slot>onContextMenuRequested(QListViewItem*,const QPoint&amp;,int)</slot>
+    </connection>
+    <connection>
+        <sender>mShowDiffsCheck</sender>
+        <signal>toggled(bool)</signal>
+        <receiver>VBoxHardDiskSettings</receiver>
+        <slot>onShowDiffsCheckToggled(bool)</slot>
     </connection>
 </connections>
@@ -259 +314 @@
     <include location="local" impldecl="in implementation">VBoxProblemReporter.h</include>
     <include location="local" impldecl="in implementation">VBoxMediaComboBox.h</include>
-    <include location="local" impldecl="in implementation">VBoxDiskImageManagerDlg.h</include>
+    <include location="local" impldecl="in implementation">VBoxMediaManagerDlg.h</include>
     <include location="local" impldecl="in implementation">VBoxNewHDWzd.h</include>
     <include location="local" impldecl="in implementation">VBoxHardDiskSettings.ui.h</include>
@@ -275 +330 @@
 <signals>
     <signal>afterCurrentChanged()</signal>
-    <signal>hddListChanged()</signal>
+    <signal>hardDiskListChanged()</signal>
 </signals>
 <slots>
     <slot>addHDItem()</slot>
     <slot>delHDItem()</slot>
-    <slot>showVDM()</slot>
+    <slot>showMediaManager()</slot>
     <slot>moveFocus( QListViewItem *, const QPoint &amp;, int )</slot>
     <slot>onCurrentChanged( QListViewItem * )</slot>
-    <slot>onToggleSATAController( bool aOn )</slot>
+    <slot>onSATACheckToggled( bool aOn )</slot>
+    <slot>onShowDiffsCheckToggled( bool aOn )</slot>
     <slot>onAfterCurrentChanged( QListViewItem * )</slot>
     <slot>onContextMenuRequested( QListViewItem *, const QPoint &amp;, int )</slot>
@@ -293 +349 @@
     <function>putBackToMachine()</function>
     <function returnType="QString">checkValidity()</function>
-    <function access="private" returnType="HDListItem*">createItem( HDSlotUniquizer *, const CMachine &amp; )</function>
+    <function access="private" returnType="HDListItem*">createItem()</function>
     <function access="private" returnType="bool">event( QEvent * )</function>
     <function access="private">showEvent( QShowEvent * )</function>

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

@@ -148 +148 @@
 
 /**
- *  QComboBox class reimplementation to use as selector for IDE & SATA
- *  slots.
+ * QComboBox class reimplementation to use as an editor for the device slot
+ * column.
  */
 class HDSlotItem : public QComboBox
@@ -258 +258 @@
 };
 
-/**
- *  VBoxMediaComboBox class reimplementation to use as selector for VDI
- *  image.
- */
-class HDVdiItem : public VBoxMediaComboBox
-{
-    Q_OBJECT
-
-public:
-
-    HDVdiItem (QWidget *aParent, int aType, QListViewItem *aItem)
-        : VBoxMediaComboBox (aParent, "HDVdiItem", aType)
-        , mItem (aItem)
-    {
-        setFocusPolicy (QWidget::NoFocus);
-        connect (&vboxGlobal(),
-                 SIGNAL (mediaRemoved (VBoxDefs::DiskType, const QUuid &)),
-                 this, SLOT (repaintHandler()));
-    }
-
-private slots:
-
-    void repaintHandler()
-    {
-        mItem->repaint();
-    }
-
-private:
-
-    QListViewItem *mItem;
-};
-
-QValueList<HDSlot> HDSlotUniquizer::list (HDSlotItem *aSubscriber, bool aFilter)
+QValueList <HDSlot> HDSlotUniquizer::list (HDSlotItem *aSubscriber, bool aFilter)
 {
     QValueList<HDSlot> list = mIDEList + mSATAList;
@@ -316 +284 @@
 }
 
+/**
+ * VBoxMediaComboBox class reimplementation to use as an editor for the hard
+ * disk column.
+ */
+class HDItem : public VBoxMediaComboBox
+{
+    Q_OBJECT
+
+public:
+
+    HDItem (QWidget *aParent, const char *aName, QUuid aMachineID,
+            QListViewItem *aItem)
+        : VBoxMediaComboBox (aParent, aName, VBoxDefs::MediaType_HardDisk,
+                             aMachineID)
+        , mItem (aItem)
+    {
+        setFocusPolicy (QWidget::NoFocus);
+
+        connect (this, SIGNAL (activated (int)),
+                 this, SLOT (onThisActivated (int)));
+    }
+
+private slots:
+
+    void onThisActivated (int)
+    {
+        mItem->repaint();
+    }
+
+private:
+
+    QListViewItem *mItem;
+};
+
 class HDSpaceItem : public QListViewItem
 {
@@ -337 +339 @@
     enum { HDListItemType = 1010 };
 
-    HDListItem (VBoxHardDiskSettings *aWidget, QListView *aParent,
-                QListViewItem *aAfter,
-                HDSlotUniquizer *aUniq, const CMachine &aMachine)
+    HDListItem (QListView *aParent, QListViewItem *aAfter,
+                VBoxHardDiskSettings *aSettings, HDSlotUniquizer *aUniq,
+                const QUuid &aMachineId)
         : QListViewItem (aParent, aAfter)
-        , mWidget (aWidget)
-        , mUniq (aUniq)
-        , mMachine (aMachine)
         , mFocusColumn (-1)
         , mAutoFocus (false)
     {
-        init();
-    }
-
-    HDListItem (VBoxHardDiskSettings *aWidget, QListView *aParent,
-                HDSlotUniquizer *aUniq, const CMachine &aMachine)
+        init (aSettings, aUniq, aMachineId);
+    }
+
+    HDListItem (QListView *aParent,
+                VBoxHardDiskSettings *aSettings, HDSlotUniquizer *aUniq,
+                const QUuid &aMachineId)
         : QListViewItem (aParent)
-        , mWidget (aWidget)
-        , mUniq (aUniq)
-        , mMachine (aMachine)
         , mFocusColumn (-1)
-    {
-        init();
+        , mAutoFocus (false)
+    {
+        init (aSettings, aUniq, aMachineId);
+    }
+
+    virtual ~HDListItem()
+    {
+        mHDCombo->deleteLater();
+        mSlotCombo->deleteLater();
     }
 
     int rtti() const { return HDListItemType; }
 
-    QString toolTip()
-    {
-        return QToolTip::textFor (mVector [1]);
-    }
-
-    HDListItem* nextSibling() const
-    {
-        QListViewItem *item = QListViewItem::nextSibling();
-        return item && item->rtti() == HDListItemType ?
-            static_cast<HDListItem*> (item) : 0;
-    }
-
-    void setId (const QUuid &aId) const
-    {
-        static_cast<VBoxMediaComboBox*> (mVector [1])->setCurrentItem (aId);
-    }
-
-    QUuid getId() const
-    {
-        return static_cast<VBoxMediaComboBox*> (mVector [1])->getId();
-    }
-
-    KStorageBus bus() const
-    {
-        return static_cast<HDSlotItem*> (mVector [0])->currentBus();
-    }
-
-    LONG channel() const
-    {
-        return static_cast<HDSlotItem*> (mVector [0])->currentChannel();
-    }
-
-    LONG device() const
-    {
-        return static_cast<HDSlotItem*> (mVector [0])->currentDevice();
-    }
+    QString toolTip() { return QToolTip::textFor (mHDCombo); }
+
+    void setId (const QUuid &aId) { mHDCombo->setCurrentItem (aId); }
+
+    QUuid id() const { return mHDCombo->id(); }
+    QString location() const { return mHDCombo->location(); }
+
+    KStorageBus bus() { return mSlotCombo->currentBus(); }
+
+    LONG channel() const { return mSlotCombo->currentChannel(); }
+
+    LONG device() const { return mSlotCombo->currentDevice(); }
 
     QString text (int aColumn) const
     {
-        return mVector [aColumn]->currentText();
+        AssertReturn (aColumn >= 0 && (size_t) aColumn < ELEMENTS (mCombos),
+                      QString::null);
+
+        return mCombos [aColumn]->currentText();
+    }
+
+    const QPixmap *pixmap (int aColumn) const
+    {
+        AssertReturn (aColumn >= 0 && (size_t) aColumn < ELEMENTS (mCombos),
+                      NULL);
+
+        return mCombos [aColumn]->pixmap (mCombos [aColumn]->currentItem());
     }
 
@@ -420 +411 @@
     {
         if (mFocusColumn >= 0)
-            if (mVector [mFocusColumn]->count())
-                mVector [mFocusColumn]->popup();
+        {
+            AssertReturnVoid ((size_t) mFocusColumn < ELEMENTS (mCombos));
+
+            if (mCombos [mFocusColumn]->count())
+                mCombos [mFocusColumn]->popup();
+        }
     }
 
@@ -429 +424 @@
     }
 
-    void setAttachment (const CHardDiskAttachment &aHda)
+    void setAttachment (const CHardDisk2Attachment &aHda)
     {
         QString device = vboxGlobal()
             .toFullString (aHda.GetBus(), aHda.GetChannel(), aHda.GetDevice());
 
-        if (mVector [0]->listBox()->findItem (device, Qt::ExactMatch))
-            static_cast<HDSlotItem*> (mVector [0])->setText (device);
-
-        static_cast<VBoxMediaComboBox*> (mVector [1])->
-            setCurrentItem (aHda.GetHardDisk().GetRoot().GetId());
-
-        mVector [0]->setHidden (true);
-        mVector [1]->setHidden (true);
-    }
-
-    int vdiCount()
-    {
-        return mVector [1]->count();
-    }
-
-    void tryToChooseExcluding (const QStringList &aUsedList)
-    {
-        for (int i = 0; i < mVector [1]->count(); ++ i)
-        {
-            if (!aUsedList.contains (mVector [1]->text (i)))
-            {
-                setId (static_cast<HDVdiItem*> (mVector [1])->getId (i));
+        if (mSlotCombo->listBox()->findItem (device, Qt::ExactMatch))
+            mSlotCombo->setText (device);
+
+        mHDCombo->setCurrentItem (aHda.GetHardDisk().GetId());
+    }
+
+    int hardDiskCount()
+    {
+        int count = mHDCombo->count();
+        if (count == 1 && mHDCombo-> id (0).isNull())
+            return 0; /* ignore the "no media" item */
+        return count;
+    }
+
+    void tryToSelectNotOneOf (const QValueList <QUuid> &aUsedList)
+    {
+        for (int i = 0; i < mHDCombo->count(); ++ i)
+        {
+            if (!aUsedList.contains (mHDCombo->id (i)))
+            {
+                mHDCombo->setCurrentItem (mHDCombo->id (i));
                 break;
             }
@@ -461 +455 @@
     }
 
+    void setShowDiffs (bool aOn)
+    {
+        if (mHDCombo->showDiffs() != aOn)
+        {
+            mHDCombo->setShowDiffs (aOn);
+            mHDCombo->refresh();
+        }
+    }
+
 private:
 
-    void init()
-    {
+    void init (VBoxHardDiskSettings *aSettings, HDSlotUniquizer *aUniq,
+               const QUuid &aMachineId)
+    {
+        AssertReturnVoid (listView()->columns() == ELEMENTS (mCombos));
+
         setSelectable (false);
-        mVector.setAutoDelete (true);
-        mVector.resize (listView()->columns());
-
-        QComboBox *cbslot = new HDSlotItem (listView()->viewport(), mUniq);
-        QObject::connect (cbslot, SIGNAL (activated (int)),
-                          mWidget, SIGNAL (hddListChanged()));
-        mVector.insert (0, cbslot);
-
-        VBoxMediaComboBox *cbvdi = new HDVdiItem (listView()->viewport(),
-                                                  VBoxDefs::HD, this);
-        QObject::connect (cbvdi, SIGNAL (activated (int)),
-                          mWidget, SIGNAL (hddListChanged()));
-        mVector.insert (1, cbvdi);
-        cbvdi->setBelongsTo (mMachine.GetId());
-        cbvdi->refresh();
+
+        mSlotCombo = new HDSlotItem (listView()->viewport(), aUniq);
+        QObject::connect (mSlotCombo, SIGNAL (activated (int)),
+                          aSettings, SIGNAL (hardDiskListChanged()));
+        mCombos [0] = mSlotCombo;
+
+        mHDCombo = new HDItem (listView()->viewport(), "mHDCombo",
+                               aMachineId, this);
+        QObject::connect (mHDCombo, SIGNAL (activated (int)),
+                          aSettings, SIGNAL (hardDiskListChanged()));
+        mCombos [1] = mHDCombo;
+
+        /* populate the media combobox */
+        mHDCombo->refresh();
+
 #ifdef Q_WS_MAC
         /* White background on Mac OS X */
-        cbslot->setPaletteBackgroundColor (cbslot->parentWidget()->paletteBackgroundColor());
-        cbvdi->setPaletteBackgroundColor (cbvdi->parentWidget()->paletteBackgroundColor());
+        mSlotCombo->setPaletteBackgroundColor (mSlotCombo->parentWidget()->
+                                               paletteBackgroundColor());
+        mHDCombo->setPaletteBackgroundColor (mHDCombo->parentWidget()->
+                                             paletteBackgroundColor());
 #endif /* Q_WS_MAC */
+
+        mSlotCombo->setHidden (true);
+        mHDCombo->setHidden (true);
     }
 
@@ -491 +502 @@
                     int aColumn, int aWidth, int aAlign)
     {
-        QComboBox *cb = mVector [aColumn];
-
-        int indent = 0;
-        for (int i = 0; i < aColumn; ++ i)
-            indent = listView()->columnWidth (i);
-
-        QRect rect = listView()->itemRect (this);
-
-        int xc = rect.x() + indent;
-        int yc = rect.y();
-        int wc = listView()->columnWidth (aColumn);
-        int hc = rect.height();
-
-        cb->move (xc, yc);
-        cb->resize (wc, hc);
+        AssertReturnVoid (aColumn >= 0 && (size_t) aColumn < ELEMENTS (mCombos));
+
+        QComboBox *cb = mCombos [aColumn];
+
+        /// @todo (r=dmik) show/hide functionality should be removed from here
+        /// to the appropriate places like focus handling routines
 
         if (aColumn == mFocusColumn)
         {
+            int indent = 0;
+            for (int i = 0; i < aColumn; ++ i)
+                indent = listView()->columnWidth (i);
+
+            QRect rect = listView()->itemRect (this);
+
+            int xc = rect.x() + indent;
+            int yc = rect.y();
+            int wc = listView()->columnWidth (aColumn);
+            int hc = rect.height();
+
+            cb->move (xc, yc);
+            cb->resize (wc, hc);
+
             if (cb->isHidden())
                 cb->show();
             if (mAutoFocus && !cb->hasFocus())
                 QTimer::singleShot (0, cb, SLOT (setFocus()));
-        }
-        else if (aColumn != mFocusColumn && !cb->isHidden())
+
+            return;
+
+        }
+
+        if (aColumn != mFocusColumn && !cb->isHidden())
             cb->hide();
 
@@ -532 +552 @@
     }
 
-    VBoxHardDiskSettings  *mWidget;
-    HDSlotUniquizer       *mUniq;
-    CMachine               mMachine;
-    QPtrVector<QComboBox>  mVector;
+    HDSlotItem            *mSlotCombo;
+    VBoxMediaComboBox     *mHDCombo;
+    QComboBox             *mCombos [2];
     int                    mFocusColumn;
     bool                   mAutoFocus;
@@ -585 +604 @@
         (VBoxGlobal::iconSet ("select_file_16px.png", "select_file_dis_16px.png"));
 
-    /* connections */
-    connect (mCbSATA, SIGNAL (toggled (bool)),
-             this, SLOT (onToggleSATAController (bool)));
-    connect (mLvHD, SIGNAL (pressed (QListViewItem*, const QPoint&, int)),
-             this, SLOT (moveFocus (QListViewItem*, const QPoint&, int)));
-    connect (mLvHD, SIGNAL (currentChanged (QListViewItem*)),
-             this, SLOT (onCurrentChanged (QListViewItem*)));
-    connect (mLvHD, SIGNAL (contextMenuRequested (QListViewItem*, const QPoint&, int)),
-             this, SLOT (onContextMenuRequested (QListViewItem*, const QPoint&, int)));
-
     /* rest */
 
@@ -606 +615 @@
 void VBoxHardDiskSettings::getFromMachine (const CMachine &aMachine)
 {
+    AssertReturnVoid (mMachine.isNull());
+    AssertReturnVoid (!aMachine.isNull());
+
     mMachine = aMachine;
 
@@ -614 +626 @@
             /* hide the SATA check box if the SATA controller is not available
              * (i.e. in VirtualBox OSE) */
-            mCbSATA->setHidden (true);
+            mSATACheck->setHidden (true);
         }
         else
         {
-            mCbSATA->setChecked (ctl.GetEnabled());
-        }
-    }
-
-    CHardDiskAttachmentEnumerator en =
-        mMachine.GetHardDiskAttachments().Enumerate();
-    while (en.HasMore())
-    {
-        CHardDiskAttachment hda = en.GetNext();
-        HDListItem *item = createItem (mSlotUniquizer, mMachine);
+            mSATACheck->setChecked (ctl.GetEnabled());
+        }
+    }
+
+    CHardDisk2AttachmentVector vec = mMachine.GetHardDisk2Attachments();
+    for (size_t i = 0; i < vec.size(); ++ i)
+    {
+        CHardDisk2Attachment hda = vec [i];
+        HDListItem *item = createItem();
         item->setAttachment (hda);
     }
+
     mLvHD->setSortColumn (0);
     mLvHD->sort();
@@ -642 +654 @@
     if (!ctl.isNull())
     {
-        ctl.SetEnabled (mCbSATA->isChecked());
+        ctl.SetEnabled (mSATACheck->isChecked());
     }
 
     /* Detach all attached Hard Disks */
-    CHardDiskAttachmentEnumerator en =
-        mMachine.GetHardDiskAttachments().Enumerate();
-    while (en.HasMore())
-    {
-        CHardDiskAttachment hda = en.GetNext();
-        mMachine.DetachHardDisk (hda.GetBus(), hda.GetChannel(), hda.GetDevice());
+    CHardDisk2AttachmentVector vec = mMachine.GetHardDisk2Attachments();
+    for (size_t i = 0; i < vec.size(); ++ i)
+    {
+        CHardDisk2Attachment hda = vec [i];
+        mMachine.DetachHardDisk2 (hda.GetBus(), hda.GetChannel(), hda.GetDevice());
         if (!mMachine.isOk())
             vboxProblem().cannotDetachHardDisk (this, mMachine,
+                vboxGlobal().getMedium (CMedium (hda.GetHardDisk())).location(),
                 hda.GetBus(), hda.GetChannel(), hda.GetDevice());
     }
 
-    /* Sort&Attach all listed Hard Disks */
+    /* Sort & attach all listed Hard Disks */
+
     mLvHD->setSortColumn (0);
     mLvHD->sort();
     LONG maxSATAPort = 1;
-    HDListItem *item = mLvHD->firstChild() &&
-        mLvHD->firstChild()->rtti() == HDListItem::HDListItemType ?
-        static_cast<HDListItem*> (mLvHD->firstChild()) : 0;
-    while (item)
-    {
-        if (item->bus() == KStorageBus_SATA)
-            maxSATAPort = maxSATAPort < (item->channel()+1) ?
-                          (item->channel()+1) : maxSATAPort;
-        mMachine.AttachHardDisk (item->getId(),
-            item->bus(), item->channel(), item->device());
+
+    for (QListViewItem *item = mLvHD->firstChild(); item;
+         item = item->nextSibling())
+    {
+        if (item->rtti() != HDListItem::HDListItemType)
+            continue;
+
+        HDListItem *hdi = static_cast <HDListItem *> (item);
+
+        if (hdi->bus() == KStorageBus_SATA)
+            maxSATAPort = QMAX (hdi->channel() + 1, maxSATAPort);
+        mMachine.AttachHardDisk2 (hdi->id(),
+            hdi->bus(), hdi->channel(), hdi->device());
         if (!mMachine.isOk())
-            vboxProblem().cannotAttachHardDisk (this, mMachine, item->getId(),
-                item->bus(), item->channel(), item->device());
-        item = item->nextSibling();
+            vboxProblem().cannotAttachHardDisk (this, mMachine,
+                hdi->location(), hdi->bus(), hdi->channel(), hdi->device());
     }
 
     if (!ctl.isNull())
     {
-        mMachine.GetSATAController().SetPortCount (maxSATAPort);
+        ctl.SetPortCount (maxSATAPort);
     }
 }
@@ -687 +702 @@
     QString result;
     QStringList slList;
-    QStringList idList;
+    QValueList <QUuid> idList;
 
     /* Search for coincidences through all the media-id */
-    HDListItem *item = mLvHD->firstChild() &&
-        mLvHD->firstChild()->rtti() == HDListItem::HDListItemType ?
-        static_cast<HDListItem*> (mLvHD->firstChild()) : 0;
-    while (item)
-    {
-        QString id = item->getId().toString();
-        if (item->getId().isNull())
+    for (QListViewItem *item = mLvHD->firstChild(); item;
+         item = item->nextSibling())
+    {
+        if (item->rtti() != HDListItem::HDListItemType)
+            continue;
+
+        HDListItem *hdi = static_cast <HDListItem *> (item);
+
+        QUuid id = hdi->id();
+        if (id.isNull())
         {
             result = tr ("No hard disk is selected for <i>%1</i>")
-                .arg (item->text (0));
+                .arg (hdi->text (0));
             break;
         }
@@ -714 +732 @@
             idList << id;
         }
-        item = item->nextSibling();
     }
 
@@ -722 +739 @@
 void VBoxHardDiskSettings::addHDItem()
 {
-    /* Create new item */
-    HDListItem *item = createItem (mSlotUniquizer, mMachine);
+    /* Create a new item */
+    HDListItem *item = createItem();
     item->moveFocusToColumn (1);
     mLvHD->setCurrentItem (item);
     if (!mLvHD->hasFocus())
         mLvHD->setFocus();
-    /* Qt3 isn't emits currentChanged() signal if first list-view item added */
+
+    /* Qt3 doesn't emit currentChanged() signal when the first item is added */
     if (mLvHD->childCount() == 1)
         onCurrentChanged (item);
 
-    /* Search through the attachments for the used VDIs */
-    QStringList usedList;
-    HDListItem *it = mLvHD->firstChild()->rtti() == HDListItem::HDListItemType ?
-        static_cast<HDListItem*> (mLvHD->firstChild()) : 0;
-    while (it && it != item)
-    {
-        usedList << it->text (1);
-        it = it->nextSibling();
-    }
-    item->tryToChooseExcluding (usedList);
-
-    /* Ask the user for method to add new vdi */
-    int result = mLvHD->childCount() - 1 > item->vdiCount() ?
+    /* Search through the attachments for the used hard disks */
+    QValueList <QUuid> usedList;
+    for (QListViewItem *it = mLvHD->firstChild(); it;
+         it = it->nextSibling())
+    {
+        if (it->rtti() != HDListItem::HDListItemType)
+            continue;
+
+        HDListItem *hdi = static_cast <HDListItem *> (it);
+
+        usedList << hdi->id();
+    }
+
+    item->tryToSelectNotOneOf (usedList);
+
+    /* Ask the user for a method to add a new hard disk */
+    int result = mLvHD->childCount() - 1 > item->hardDiskCount() ?
         vboxProblem().confirmRunNewHDWzdOrVDM (this) :
         QIMessageBox::Cancel;
@@ -752 +774 @@
         if (dlg.exec() == QDialog::Accepted)
         {
-            CHardDisk hd = dlg.hardDisk();
-            VBoxMedia::Status status =
-                hd.GetAccessible() ? VBoxMedia::Ok :
-                hd.isOk() ? VBoxMedia::Inaccessible :
-                VBoxMedia::Error;
-            vboxGlobal().addMedia (VBoxMedia (CUnknown (hd), VBoxDefs::HD, status));
+            CHardDisk2 hd = dlg.hardDisk();
             item->setId (dlg.hardDisk().GetId());
         }
     }
     else if (result == QIMessageBox::No)
-        showVDM();
-
-    emit hddListChanged();
+        showMediaManager();
+
+    emit hardDiskListChanged();
 }
 
@@ -786 +803 @@
     }
 
-    emit hddListChanged();
-}
-
-void VBoxHardDiskSettings::showVDM()
+    emit hardDiskListChanged();
+}
+
+void VBoxHardDiskSettings::showMediaManager()
 {
     HDListItem *item = mLvHD->currentItem() &&
         mLvHD->currentItem()->rtti() == HDListItem::HDListItemType ?
-        static_cast<HDListItem*> (mLvHD->currentItem()) : 0;
-
-    VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg",
-                                 WType_Dialog | WShowModal);
-
-    QUuid machineId = mMachine.GetId();
-    QUuid hdId = item->getId();
-
-    dlg.setup (VBoxDefs::HD, true, &machineId, true /* aRefresh */,
-               mMachine, hdId, QUuid(), QUuid());
-
-    if (dlg.exec() == VBoxDiskImageManagerDlg::Accepted)
-        item->setId (dlg.getSelectedUuid());
+        static_cast <HDListItem *> (mLvHD->currentItem()) : 0;
+
+    VBoxMediaManagerDlg dlg (this, "VBoxMediaManagerDlg",
+                             WType_Dialog | WShowModal);
+
+    dlg.setup (VBoxDefs::MediaType_HardDisk, true /* aDoSelect */,
+               true /* aRefresh */, mMachine, item->id(),
+               mShowDiffsCheck->isOn());
+
+    if (dlg.exec() == VBoxMediaManagerDlg::Accepted)
+        item->setId (dlg.selectedId());
 }
 
@@ -812 +827 @@
     if (aItem && aItem->rtti() == HDListItem::HDListItemType)
     {
-        static_cast<HDListItem*> (aItem)->moveFocusToColumn (aCol);
+        static_cast <HDListItem *> (aItem)->moveFocusToColumn (aCol);
         onAfterCurrentChanged (aItem);
     }
@@ -823 +838 @@
 }
 
-void VBoxHardDiskSettings::onToggleSATAController (bool aOn)
+void VBoxHardDiskSettings::onSATACheckToggled (bool aOn)
 {
     if (!aOn)
     {
-        HDListItem *firstItem = mLvHD->firstChild() &&
-            mLvHD->firstChild()->rtti() == HDListItem::HDListItemType ?
-            static_cast<HDListItem*> (mLvHD->firstChild()) : 0;
-
-        /* Search the list for the SATA ports in */
-        HDListItem *sataItem = firstItem;
-        while (sataItem)
-        {
-            if (sataItem->bus() == KStorageBus_SATA)
+        /* Search the list for the SATA ports */
+        HDListItem *sataItem = NULL;
+        for (QListViewItem *item = mLvHD->firstChild(); item;
+             item = item->nextSibling())
+        {
+            if (item->rtti() != HDListItem::HDListItemType)
+                continue;
+
+            HDListItem *hdi = static_cast <HDListItem *> (item);
+
+            if (hdi->bus() == KStorageBus_SATA)
+            {
+                sataItem = hdi;
                 break;
-            sataItem = sataItem->nextSibling();
+            }
         }
 
@@ -847 +866 @@
             {
                 /* Switch check-box back to "on" */
-                mCbSATA->blockSignals (true);
-                mCbSATA->setChecked (true);
-                mCbSATA->blockSignals (false);
+                mSATACheck->blockSignals (true);
+                mSATACheck->setChecked (true);
+                mSATACheck->blockSignals (false);
                 return;
             }
@@ -855 +874 @@
             {
                 /* Delete SATA items */
-                HDListItem *it = firstItem;
                 mLvHD->blockSignals (true);
-                while (it)
+                for (QListViewItem *item = mLvHD->firstChild(); item;)
                 {
-                    HDListItem *curIt = it;
-                    it = it->nextSibling();
-                    if (curIt->bus() == KStorageBus_SATA)
+                    if (item->rtti() == HDListItem::HDListItemType)
                     {
-                        if (curIt == mLvHD->currentItem())
-                            mPrevItem = 0;
-                        delete curIt;
+                        HDListItem *hdi = static_cast <HDListItem *> (item);
+                        if (hdi->bus() == KStorageBus_SATA)
+                        {
+                            if (hdi == mLvHD->currentItem())
+                                mPrevItem = NULL;
+
+                            item = hdi->nextSibling();
+                            delete hdi;
+                            continue;
+                        }
                     }
+
+                    item = item->nextSibling();
                 }
+
                 mLvHD->blockSignals (false);
-                emit hddListChanged();
+                emit hardDiskListChanged();
             }
         }
@@ -879 +905 @@
         mSlotUniquizer->setSATAPortsCount (newSATAPortsCount);
         onAfterCurrentChanged (mPrevItem);
+    }
+}
+
+void VBoxHardDiskSettings::onShowDiffsCheckToggled (bool aOn)
+{
+    for (QListViewItem *item = mLvHD->firstChild(); item;
+         item = item->nextSibling())
+    {
+        if (item->rtti() != HDListItem::HDListItemType)
+            continue;
+
+        HDListItem *hdi = static_cast <HDListItem *> (item);
+
+        hdi->setShowDiffs (aOn);
     }
 }
@@ -916 +956 @@
 }
 
-HDListItem* VBoxHardDiskSettings::createItem (HDSlotUniquizer *aUniq,
-                                              const CMachine &aMachine)
+HDListItem *VBoxHardDiskSettings::createItem()
 {
     QListViewItem *item = mLvHD->lastItem();
@@ -923 +962 @@
     HDListItem *last = item->itemAbove() &&
         item->itemAbove()->rtti() == HDListItem::HDListItemType ?
-        static_cast<HDListItem*> (item->itemAbove()) : 0;
-
-    return last ?
-        new HDListItem (this, mLvHD, last, aUniq, aMachine) :
-        new HDListItem (this, mLvHD, aUniq, aMachine);
+        static_cast <HDListItem *> (item->itemAbove()) : 0;
+
+    QUuid machineId = mMachine.GetId();
+
+    HDListItem *newItem = last ?
+        new HDListItem (mLvHD, last, this, mSlotUniquizer, machineId) :
+        new HDListItem (mLvHD, this, mSlotUniquizer, machineId);
+
+    AssertReturn (newItem != NULL, NULL);
+
+    newItem->setShowDiffs (mShowDiffsCheck->isOn());
+
+    return newItem;
 }
 
@@ -937 +984 @@
         case OnItemChangedEvent::Type:
         {
-            OnItemChangedEvent *e = static_cast<OnItemChangedEvent*> (aEvent);
+            OnItemChangedEvent *e = static_cast <OnItemChangedEvent *> (aEvent);
             onAfterCurrentChanged (e->mItem);
             break;
@@ -974 +1021 @@
             HDListItem *item = clickedItem &&
                 clickedItem->rtti() == HDListItem::HDListItemType ?
-                static_cast<HDListItem*> (clickedItem) : 0;
+                static_cast <HDListItem *> (clickedItem) : 0;
 
             if (!item && mAddAttachmentAct->isEnabled())
@@ -990 +1037 @@
             }
 
-            QMouseEvent *e = static_cast<QMouseEvent*> (aEvent);
+            QMouseEvent *e = static_cast <QMouseEvent *> (aEvent);
             QListViewItem *hoveredItem = mLvHD->itemAt (e->pos());
             HDListItem *item = hoveredItem &&
                 hoveredItem->rtti() == HDListItem::HDListItemType ?
-                static_cast<HDListItem*> (hoveredItem) : 0;
+                static_cast <HDListItem *> (hoveredItem) : 0;
 
             QString oldTip = QToolTip::textFor (mLvHD->viewport());
@@ -1014 +1061 @@
             HDListItem *item = mLvHD->currentItem() &&
                 mLvHD->currentItem()->rtti() == HDListItem::HDListItemType ?
-                static_cast<HDListItem*> (mLvHD->currentItem()) : 0;
+                static_cast <HDListItem *> (mLvHD->currentItem()) : 0;
 
             QKeyEvent *e = static_cast<QKeyEvent*> (aEvent);

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

@@ -5 +5 @@
 :folding=explicit:collapseFolds=1:
 
-     Copyright (C) 2006-2007 Sun Microsystems, Inc.
+     Copyright (C) 2006-2008 Sun Microsystems, Inc.
 
      This file is part of VirtualBox Open Source Edition (OSE), as
@@ -98 +98 @@
                         </property>
                         <property name="text">
-                            <string>&lt;p&gt;This wizard will help you to create a new virtual hard disk image for your virtual machine.&lt;/p&gt;
+                            <string>&lt;p&gt;This wizard will help you to create a new virtual hard disk for your virtual machine.&lt;/p&gt;
 &lt;p&gt;Use the &lt;b&gt;Next&lt;/b&gt; button to go to the next page of the wizard
 and the &lt;b&gt;Back&lt;/b&gt; button to return to the previous page.&lt;/p&gt;</string>
@@ -149 +149 @@
         </property>
         <attribute name="title">
-            <string>Virtual Disk Image Type</string>
+            <string>Hard Disk Storage Type</string>
         </attribute>
         <hbox>
@@ -204 +204 @@
                         </property>
                         <property name="text">
-                            <string>&lt;p&gt;Select the type of virtual hard disk image you want to create.&lt;/p&gt;
-&lt;p&gt;A &lt;b&gt;dynamically expanding image&lt;/b&gt; initially occupies a very small amount
+                            <string>&lt;p&gt;Select the type of virtual hard disk you want to create.&lt;/p&gt;
+&lt;p&gt;A &lt;b&gt;dynamically expanding storage&lt;/b&gt; initially occupies a very small amount
 of space on your physical hard disk. It will grow dynamically (up to
 the size specified) as the Guest OS claims disk space.&lt;/p&gt;
-&lt;p&gt;A &lt;b&gt;fixed-size image&lt;/b&gt; does not grow. It is stored in a file of approximately
-the same size as the size of the virtual hard disk. The creation of a fixed-size image may take a long
-time depending on the image size and the write performance of your harddisk.&lt;/p&gt;</string>
+&lt;p&gt;A &lt;b&gt;fixed-size storage&lt;/b&gt; does not grow. It is stored in a file of approximately
+the same size as the size of the virtual hard disk. The creation of a fixed-size storage may take a long
+time depending on the storage size and the write performance of your harddisk.&lt;/p&gt;</string>
                         </property>
                         <property name="alignment">
@@ -221 +221 @@
                         </property>
                         <property name="title">
-                            <string>Image Type</string>
+                            <string>Storage Type</string>
                         </property>
                         <property name="exclusive">
@@ -235 +235 @@
                                 </property>
                                 <property name="text">
-                                    <string>&amp;Dynamically expanding image</string>
+                                    <string>&amp;Dynamically expanding storage</string>
                                 </property>
                                 <property name="checked">
@@ -246 +246 @@
                                 </property>
                                 <property name="text">
-                                    <string>&amp;Fixed-size image</string>
+                                    <string>&amp;Fixed-size storage</string>
                                 </property>
                             </widget>
@@ -329 +329 @@
                         </property>
                         <property name="text">
-                            <string>&lt;p&gt;Press the &lt;b&gt;Select&lt;/b&gt; button to select the location and name of the file
-to store the virtual hard disk image or type a file name in the entry field.&lt;/p&gt;</string>
+                            <string>&lt;p&gt;Press the &lt;b&gt;Select&lt;/b&gt; button to select the location of a file
+to store the hard disk data or type a file name in the entry field.&lt;/p&gt;</string>
                         </property>
                         <property name="alignment">
@@ -341 +341 @@
                         </property>
                         <property name="title">
-                            <string>&amp;Image File Name</string>
+                            <string>&amp;Location</string>
                         </property>
                         <hbox>
@@ -393 +393 @@
                         </property>
                         <property name="text">
-                            <string>&lt;p&gt;Select the size of the virtual hard disk image in megabytes. This size will be reported to the Guest OS
-as the size of the virtual hard disk.&lt;/p&gt;</string>
+                            <string>&lt;p&gt;Select the size of the virtual hard disk in megabytes. This size will be reported to the Guest OS
+as the maximum size of this hard disk.&lt;/p&gt;</string>
                         </property>
                         <property name="alignment">
@@ -405 +405 @@
                         </property>
                         <property name="title">
-                            <string>Image &amp;Size</string>
+                            <string>&amp;Size</string>
                         </property>
                         <hbox>
@@ -624 +624 @@
                         </property>
                         <property name="text">
-                            <string>You are going to create a new virtual hard disk image with the following parameters:</string>
+                            <string>You are going to create a new virtual hard disk with the following parameters:</string>
                         </property>
                         <property name="alignment">
@@ -644 +644 @@
                         <property name="text">
                             <string>If the above settings are correct, press the &lt;b&gt;Finish&lt;/b&gt; button.
-                            Once you press it, a new hard disk image will be created.
+                            Once you press it, a new hard disk will be created.
                             </string>
                         </property>
@@ -708 +708 @@
     <include location="global" impldecl="in implementation">qvalidator.h</include>
     <include location="global" impldecl="in implementation">qlocale.h</include>
+    <include location="global" impldecl="in implementation">iprt/path.h</include>
 </includes>
 <forwards>
@@ -713 +714 @@
 </forwards>
 <variables>
-    <variable access="private">QIWidgetValidator *wvalNameAndSize;</variable>
-    <variable access="private">CHardDisk chd;</variable>
-    <variable access="private">int sliderScale;</variable>
-    <variable access="private">Q_UINT64 maxVDISize;</variable>
-    <variable access="private">Q_UINT64 currentSize;</variable>
-    <variable access="private">QITextEdit *teSummary;</variable>
+    <variable access="private">QIWidgetValidator *mWValNameAndSize;</variable>
+    <variable access="private">CHardDisk2 mHD;</variable>
+    <variable access="private">int mSliderScale;</variable>
+    <variable access="private">Q_UINT64 mMaxVDISize;</variable>
+    <variable access="private">Q_UINT64 mCurrentSize;</variable>
+    <variable access="private">QITextEdit *mSummaryText;</variable>
 </variables>
 <slots>
-    <slot>enableNext( const QIWidgetValidator * wval )</slot>
+    <slot>enableNext( const QIWidgetValidator * )</slot>
     <slot>revalidate( QIWidgetValidator * )</slot>
-    <slot>slSize_valueChanged( int val )</slot>
-    <slot>leSize_textChanged( const QString &amp; text )</slot>
+    <slot>slSize_valueChanged( int )</slot>
+    <slot>leSize_textChanged( const QString &amp; )</slot>
     <slot>tbNameSelect_clicked()</slot>
 </slots>
@@ -732 +733 @@
     <function>setRecommendedFileName( const QString &amp; aName )</function>
     <function>setRecommendedSize( Q_UINT64 aSize )</function>
-    <function returnType="QString">imageFileName()</function>
-    <function returnType="Q_UINT64">imageSize()</function>
-    <function returnType="bool">isDynamicImage()</function>
-    <function returnType="CHardDisk">hardDisk() { return chd; }</function>
-    <function>showPage( QWidget * page )</function>
-    <function>updateSizeToolTip (Q_UINT64)</function>
+    <function returnType="QString">location()</function>
+    <function returnType="bool">isDynamicStorage()</function>
+    <function returnType="CHardDisk2">hardDisk() { return mHD; }</function>
+    <function>showPage( QWidget * )</function>
+    <function>updateSizeToolTip( Q_UINT64 )</function>
     <function>accept()</function>
     <function access="private" returnType="bool">createHardDisk()</function>

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -40 +40 @@
 
 /**
- *  Composes a file name from the given relative or full file name
- *  based on the home directory and the default VDI directory.
+ * Composes a file name from the given relative or full file name based on the
+ * home directory and the default VDI directory. See IMedum::location for
+ * details.
  */
-static QString composeFullFileName (const QString file)
+static QString composeFullFileName (const QString &aName)
 {
     CVirtualBox vbox = vboxGlobal().virtualBox();
     QString homeFolder = vbox.GetHomeFolder();
-    QString defaultFolder = vbox.GetSystemProperties().GetDefaultVDIFolder();
-
-    QFileInfo fi = QFileInfo (file);
-    if (fi.fileName() == file)
+    QString defaultFolder = vbox.GetSystemProperties().GetDefaultHardDiskFolder();
+
+    /* Note: the logic below must match the logic of the IMedum::location
+     * setter, otherwise the returned path may differ from the path actually
+     * set for the hard disk by the VirtualBox API */
+
+    QFileInfo fi (aName);
+    if (fi.fileName() == aName)
     {
         /* no path info at all, use defaultFolder */
-        fi = QFileInfo (defaultFolder, file);
+        fi = QFileInfo (defaultFolder, aName);
     }
     else if (fi.isRelative())
     {
         /* resolve relatively to homeFolder */
-        fi = QFileInfo (homeFolder, file);
+        fi = QFileInfo (homeFolder, aName);
     }
 
     return QDir::convertSeparators (fi.absFilePath());
 }
-
-/// @todo (r=dmik) not currently used
-#if 0
-class QISizeValidator : public QValidator
-{
-public:
-
-    QISizeValidator (QObject * aParent,
-                     Q_UINT64 aMinSize, Q_UINT64 aMaxSize,
-                     const char * aName = 0) :
-        QValidator (aParent, aName), mMinSize (aMinSize), mMaxSize (aMaxSize) {}
-
-    ~QISizeValidator() {}
-
-    State validate (QString &input, int &/*pos*/) const
-    {
-        QRegExp regexp ("^([^M^G^T^P^\\d\\s]*)(\\d+(([^\\s^\\d^M^G^T^P]+)(\\d*))?)?(\\s*)([MGTP]B?)?$");
-        int position = regexp.search (input);
-        if (position == -1)
-            return Invalid;
-        else
-        {
-            if (!regexp.cap (1).isEmpty() ||
-                 regexp.cap (4).length() > 1 ||
-                 regexp.cap (5).length() > 2 ||
-                 regexp.cap (6).length() > 1)
-                return Invalid;
-
-            if (regexp.cap (7).length() == 1)
-                return Intermediate;
-
-            QString size = regexp.cap (2);
-            if (size.isEmpty())
-                return Intermediate;
-
-            bool result = false;
-            bool warning = false;
-            if (!regexp.cap (4).isEmpty() && regexp.cap (5).isEmpty())
-            {
-                size += "0";
-                warning = true;
-            }
-            QLocale::system().toDouble (size, &result);
-
-            Q_UINT64 sizeB = vboxGlobal().parseSize (input);
-            if (sizeB > mMaxSize || sizeB < mMinSize)
-                warning = true;
-
-            if (result)
-                return warning ? Intermediate : Acceptable;
-            else
-                return Invalid;
-        }
-    }
-
-protected:
-
-    Q_UINT64 mMinSize;
-    Q_UINT64 mMaxSize;
-};
-#endif
 
 static inline int log2i (Q_UINT64 val)
@@ -155 +99 @@
 }
 
+
+////////////////////////////////////////////////////////////////////////////////
+
+
 void VBoxNewHDWzd::init()
 {
@@ -175 +123 @@
     VBoxGlobal::adoptLabelPixmap (pmSummary);
 
-    /* Image type page */
+    /* Storage type page */
 
     /* Name and Size page */
@@ -181 +129 @@
     CSystemProperties sysProps = vboxGlobal().virtualBox().GetSystemProperties();
 
-    maxVDISize = sysProps.GetMaxVDISize();
+    mMaxVDISize = sysProps.GetMaxVDISize();
 
     /* Detect how many steps to recognize between adjacent powers of 2
-     * to ensure that the last slider step is exactly maxVDISize */
-    sliderScale = 0;
-    {
-        int pow = log2i (maxVDISize);
+     * to ensure that the last slider step is exactly mMaxVDISize */
+    mSliderScale = 0;
+    {
+        int pow = log2i (mMaxVDISize);
         Q_UINT64 tickMB = Q_UINT64 (1) << pow;
-        if (tickMB < maxVDISize)
+        if (tickMB < mMaxVDISize)
         {
             Q_UINT64 tickMBNext = Q_UINT64 (1) << (pow + 1);
-            Q_UINT64 gap = tickMBNext - maxVDISize;
-            /// @todo (r=dmik) overflow may happen if maxVDISize is TOO big
-            sliderScale = (int) ((tickMBNext - tickMB) / gap);
+            Q_UINT64 gap = tickMBNext - mMaxVDISize;
+            /// @todo (r=dmik) overflow may happen if mMaxVDISize is TOO big
+            mSliderScale = (int) ((tickMBNext - tickMB) / gap);
         }
     }
-    sliderScale = QMAX (sliderScale, 8);
+    mSliderScale = QMAX (mSliderScale, 8);
 
     leName->setValidator (new QRegExpValidator (QRegExp( ".+" ), this));
@@ -204 +152 @@
     leSize->setAlignment (Qt::AlignRight);
 
-    wvalNameAndSize = new QIWidgetValidator (pageNameAndSize, this);
-    connect (wvalNameAndSize, SIGNAL (validityChanged (const QIWidgetValidator *)),
+    mWValNameAndSize = new QIWidgetValidator (pageNameAndSize, this);
+    connect (mWValNameAndSize, SIGNAL (validityChanged (const QIWidgetValidator *)),
              this, SLOT (enableNext (const QIWidgetValidator *)));
-    connect (wvalNameAndSize, SIGNAL (isValidRequested (QIWidgetValidator *)),
+    connect (mWValNameAndSize, SIGNAL (isValidRequested (QIWidgetValidator *)),
              this, SLOT (revalidate (QIWidgetValidator *)));
-    /* we ask revalidate only when currentSize is changed after manually
+    /* we ask revalidate only when mCurrentSize is changed after manually
      * editing the line edit field; the slider cannot produce invalid values */
     connect (leSize, SIGNAL (textChanged (const QString &)),
-             wvalNameAndSize, SLOT (revalidate()));
+             mWValNameAndSize, SLOT (revalidate()));
 
     /* Summary page */
 
-    teSummary = new QITextEdit (pageSummary);
-    teSummary->setSizePolicy (QSizePolicy::Minimum, QSizePolicy::Minimum);
-    teSummary->setFrameShape (QTextEdit::NoFrame);
-    teSummary->setReadOnly (TRUE);
-    summaryLayout->insertWidget (1, teSummary);
+    mSummaryText = new QITextEdit (pageSummary);
+    mSummaryText->setSizePolicy (QSizePolicy::Minimum, QSizePolicy::Minimum);
+    mSummaryText->setFrameShape (QTextEdit::NoFrame);
+    mSummaryText->setReadOnly (TRUE);
+    summaryLayout->insertWidget (1, mSummaryText);
 
     /* filter out Enter keys in order to direct them to the default dlg button */
     QIKeyFilter *ef = new QIKeyFilter (this, Key_Enter);
-    ef->watchOn (teSummary);
+    ef->watchOn (mSummaryText);
 
     /* set initial values
      * ---------------------------------------------------------------------- */
 
-    /* Image type page */
+    /* Storage type page */
 
     /* Name and Size page */
+
+    /// @todo NEWMEDIA use extension as reported by CHardDiskFormat
 
     static ulong HDNumber = 0;
@@ -237 +187 @@
 
     slSize->setFocusPolicy (QWidget::StrongFocus);
-    slSize->setPageStep (sliderScale);
-    slSize->setLineStep (sliderScale / 8);
+    slSize->setPageStep (mSliderScale);
+    slSize->setLineStep (mSliderScale / 8);
     slSize->setTickInterval (0);
-    slSize->setMinValue (sizeMBToSlider (MinVDISize, sliderScale));
-    slSize->setMaxValue (sizeMBToSlider (maxVDISize, sliderScale));
+    slSize->setMinValue (sizeMBToSlider (MinVDISize, mSliderScale));
+    slSize->setMaxValue (sizeMBToSlider (mMaxVDISize, mSliderScale));
 
     txSizeMin->setText (vboxGlobal().formatSize (MinVDISize * _1M));
-    txSizeMax->setText (vboxGlobal().formatSize (maxVDISize * _1M));
+    txSizeMax->setText (vboxGlobal().formatSize (mMaxVDISize * _1M));
 
     /* limit the max. size of QLineEdit (STUPID Qt has NO correct means for that) */
@@ -255 +205 @@
     /* Summary page */
 
-    teSummary->setPaper (pageSummary->backgroundBrush());
+    mSummaryText->setPaper (pageSummary->backgroundBrush());
 
     /* update the next button state for pages with validation
      * (validityChanged() connected to enableNext() will do the job) */
-    wvalNameAndSize->revalidate();
+    mWValNameAndSize->revalidate();
 
     /* the finish button on the Summary page is always enabled */
@@ -302 +252 @@
 void VBoxNewHDWzd::setRecommendedSize (Q_UINT64 aSize)
 {
-    AssertReturnVoid (aSize >= MinVDISize && aSize <= maxVDISize);
-    currentSize = aSize;
-    slSize->setValue (sizeMBToSlider (currentSize, sliderScale));
-    leSize->setText (vboxGlobal().formatSize (currentSize * _1M));
-    updateSizeToolTip (currentSize * _1M);
-}
-
-
-QString VBoxNewHDWzd::imageFileName()
+    AssertReturnVoid (aSize >= MinVDISize && aSize <= mMaxVDISize);
+    mCurrentSize = aSize;
+    slSize->setValue (sizeMBToSlider (mCurrentSize, mSliderScale));
+    leSize->setText (vboxGlobal().formatSize (mCurrentSize * _1M));
+    updateSizeToolTip (mCurrentSize * _1M);
+}
+
+
+QString VBoxNewHDWzd::location()
 {
     QString name = QDir::convertSeparators (leName->text());
@@ -320 +270 @@
 
     QString ext = QFileInfo (name).extension();
-    /* compare against the proper case */
-#if defined (Q_OS_FREEBSD) || defined (Q_OS_LINUX) || defined (Q_OS_NETBSD) || defined (Q_OS_OPENBSD) || defined (Q_OS_SOLARIS)
-#elif defined (Q_OS_WIN) || defined (Q_OS_OS2) || defined (Q_OS_MACX)
-    ext = ext.lower();
-#else
-    #error Port me!
-#endif
-
-    if (ext != "vdi")
+
+    if (RTPathCompare (ext.utf8(), "vdi") != 0)
         name += ".vdi";
 
@@ -335 +278 @@
 
 
-Q_UINT64 VBoxNewHDWzd::imageSize()
-{
-    return currentSize;
-}
-
-
-bool VBoxNewHDWzd::isDynamicImage()
+bool VBoxNewHDWzd::isDynamicStorage()
 {
     return rbDynamicType->isOn();
@@ -362 +299 @@
     if (pg == pageNameAndSize)
     {
-        valid = currentSize >= MinVDISize && currentSize <= maxVDISize;
+        valid = mCurrentSize >= MinVDISize && mCurrentSize <= mMaxVDISize;
     }
 
@@ -380 +317 @@
     if (currentPage() == pageNameAndSize)
     {
-        if (QFileInfo (imageFileName()).exists())
+        if (QFileInfo (location()).exists())
         {
-            vboxProblem().sayCannotOverwriteHardDiskImage (this, imageFileName());
+            vboxProblem().sayCannotOverwriteHardDiskStorage (this, location());
             return;
         }
@@ -393 +330 @@
         type = VBoxGlobal::removeAccelMark (type);
 
-        Q_UINT64 sizeB = imageSize() * _1M;
+        Q_UINT64 sizeB = mCurrentSize * _1M;
 
         // compose summary
@@ -404 +341 @@
         ))
             .arg (type)
-            .arg (composeFullFileName (imageFileName()))
+            .arg (composeFullFileName (location()))
             .arg (VBoxGlobal::formatSize (sizeB))
             .arg (sizeB);
-        teSummary->setText (summary);
+        mSummaryText->setText (summary);
         /* set Finish to default */
         finishButton()->setDefault (true);
@@ -436 +373 @@
     else if (page == pageSummary)
     {
-        teSummary->setFocus();
+        mSummaryText->setFocus();
     }
 
@@ -454 +391 @@
 
 /**
- *  Performs steps necessary to create a hard disk. This method handles all
- *  errors and shows the corresponding messages when appropriate.
+ * Performs steps necessary to create a hard disk. This method handles all
+ * errors and shows the corresponding messages when appropriate.
  *
- *  @return     wheter the creation was successful or not
+ * @return Wheter the creation was successful or not.
  */
 bool VBoxNewHDWzd::createHardDisk()
 {
-    QString src = imageFileName();
-    Q_UINT64 size = imageSize();
-
-    AssertReturn (!src.isEmpty(), false);
-    AssertReturn (size > 0, false);
+    QString loc = location();
+
+    AssertReturn (!loc.isEmpty(), false);
+    AssertReturn (mCurrentSize > 0, false);
 
     CVirtualBox vbox = vboxGlobal().virtualBox();
 
     CProgress progress;
-    CHardDisk hd = vbox.CreateHardDisk (KHardDiskStorageType_VirtualDiskImage);
-
-    /// @todo (dmik) later, change wrappers so that converting
-    //  to CUnknown is not necessary for cross-assignments
-    CVirtualDiskImage vdi = CUnknown (hd);
+
+    CHardDisk2 hd = vbox.CreateHardDisk2 (QString ("VDI"), loc);
 
     if (!vbox.isOk())
     {
-        vboxProblem().cannotCreateHardDiskImage (this,
-                                                 vbox, src, vdi, progress);
+        vboxProblem().cannotCreateHardDiskStorage (this, vbox, loc, hd,
+                                                   progress);
         return false;
     }
 
-    vdi.SetFilePath (src);
-
-    if (isDynamicImage())
-        progress = vdi.CreateDynamicImage (size);
+    if (isDynamicStorage())
+        progress = hd.CreateDynamicStorage (mCurrentSize);
     else
-        progress = vdi.CreateFixedImage (size);
-
-    if (!vdi.isOk())
-    {
-        vboxProblem().cannotCreateHardDiskImage (this,
-                                                 vbox, src, vdi, progress);
+        progress = hd.CreateFixedStorage (mCurrentSize);
+
+    if (!hd.isOk())
+    {
+        vboxProblem().cannotCreateHardDiskStorage (this, vbox, loc, hd,
+                                                   progress);
         return false;
     }
@@ -499 +430 @@
     vboxProblem().showModalProgressDialog (progress, caption(), parentWidget());
 
-    if (progress.GetResultCode() != 0)
-    {
-        vboxProblem().cannotCreateHardDiskImage (this,
-                                                 vbox, src, vdi, progress);
+    if (!progress.isOk() || progress.GetResultCode() != 0)
+    {
+        vboxProblem().cannotCreateHardDiskStorage (this, vbox, loc, hd,
+                                                   progress);
         return false;
     }
 
-    vbox.RegisterHardDisk (hd);
-    if (!vbox.isOk())
-    {
-        vboxProblem().cannotRegisterMedia (this, vbox, VBoxDefs::HD,
-                                           vdi.GetFilePath());
-        /* delete the image file on failure */
-        vdi.DeleteImage();
-        return false;
-    }
-
-    chd = hd;
+    /* inform everybody there is a new medium */
+    vboxGlobal().addMedium (VBoxMedium (CMedium (hd),
+                                        VBoxDefs::MediaType_HardDisk,
+                                        KMediaState_Created));
+
+    mHD = hd;
     return true;
 }
@@ -525 +451 @@
     if (focusWidget() == slSize)
     {
-        currentSize = sliderToSizeMB (val, sliderScale);
-        leSize->setText (vboxGlobal().formatSize (currentSize * _1M));
-        updateSizeToolTip (currentSize * _1M);
+        mCurrentSize = sliderToSizeMB (val, mSliderScale);
+        leSize->setText (vboxGlobal().formatSize (mCurrentSize * _1M));
+        updateSizeToolTip (mCurrentSize * _1M);
     }
 }
@@ -536 +462 @@
     if (focusWidget() == leSize)
     {
-        currentSize = vboxGlobal().parseSize (text);
-        updateSizeToolTip (currentSize);
-        currentSize /= _1M;
-        slSize->setValue (sizeMBToSlider (currentSize, sliderScale));
+        mCurrentSize = vboxGlobal().parseSize (text);
+        updateSizeToolTip (mCurrentSize);
+        mCurrentSize /= _1M;
+        slSize->setValue (sizeMBToSlider (mCurrentSize, mSliderScale));
     }
 }
@@ -558 +484 @@
     {
         CVirtualBox vbox = vboxGlobal().virtualBox();
-        fld = QFileInfo (vbox.GetSystemProperties().GetDefaultVDIFolder());
+        fld = QFileInfo (vbox.GetSystemProperties().GetDefaultHardDiskFolder());
         if (!fld.exists())
             fld = vbox.GetHomeFolder();
     }
 
-//    QFileDialog fd (this, "NewDiskImageDialog", TRUE);
+//    QFileDialog fd (this, "NewMediaDialog", TRUE);
 //    fd.setMode (QFileDialog::AnyFile);
 //    fd.setViewMode (QFileDialog::List);
@@ -574 +500 @@
         tr ("Hard disk images (*.vdi)"),
         this,
-        "NewDiskImageDialog",
+        "NewMediaDialog",
         tr ("Select a file for the new hard disk image file"));
 

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

@@ -6 +6 @@
 :folding=explicit:collapseFolds=1:
 
-     Copyright (C) 2006-2007 Sun Microsystems, Inc.
+     Copyright (C) 2006-2008 Sun Microsystems, Inc.
 
      This file is part of VirtualBox Open Source Edition (OSE), as
@@ -757 +757 @@
 disk using the <b>New</b> button or select an existing hard disk
 image from the drop-down list or by pressing the <b>Existing</b>
-button (to invoke the Virtual Disk Manager dialog).</p>
+button (to invoke the Virtual Media Manager dialog).</p>
 <p>If you need a more complicated hard disk setup, you can also skip this
 step and attach hard disks later using the VM Settings dialog.&lt;/p&gt;</string>
@@ -789 +789 @@
                         </property>
                         <property name="title">
-                            <string>B&amp;oot Hard Disk (Primary Master)</string>
+                            <string>Boot Hard &amp;Disk (Primary Master)</string>
+                        </property>
+                        <property name="checkable">
+                            <bool>true</bool>
                         </property>
                         <grid>
@@ -991 +994 @@
         <signal>clicked()</signal>
         <receiver>VBoxNewVMWzd</receiver>
-        <slot>showNewVDIWizard()</slot>
+        <slot>showNewHardDiskWizard()</slot>
     </connection>
     <connection>
@@ -997 +1000 @@
         <signal>clicked()</signal>
         <receiver>VBoxNewVMWzd</receiver>
-        <slot>showVDIManager()</slot>
+        <slot>showHardDiskManager()</slot>
     </connection>
     <connection>
@@ -1033 +1036 @@
     <include location="local" impldecl="in implementation">VBoxUtils.h</include>
     <include location="local" impldecl="in implementation">VBoxGlobal.h</include>
-    <include location="local" impldecl="in implementation">VBoxDiskImageManagerDlg.h</include>
+    <include location="local" impldecl="in implementation">VBoxMediaManagerDlg.h</include>
     <include location="local" impldecl="in implementation">VBoxNewHDWzd.h</include>
     <include location="local" impldecl="in implementation">VBoxMediaComboBox.h</include>
@@ -1045 +1048 @@
     <variable access="private">QIWidgetValidator *wvalMemory;</variable>
     <variable access="private">QIWidgetValidator *wvalHDD;</variable>
-    <variable access="private">QUuid uuidHD;</variable>
-    <variable access="private">CHardDisk chd;</variable>
-    <variable access="private">CMachine cmachine;</variable>
-    <variable access="private">VBoxMediaComboBox *mediaCombo;</variable>
+    <variable access="private">CHardDisk2 mHardDisk;</variable>
+    <variable access="private">CMachine mMachine;</variable>
+    <variable access="private">VBoxMediaComboBox *mHDCombo;</variable>
     <variable access="private">QITextEdit *teSummary;</variable>
 </variables>
@@ -1054 +1056 @@
     <slot>enableNext( const QIWidgetValidator * wval )</slot>
     <slot>revalidate( QIWidgetValidator * wval )</slot>
-    <slot>showVDIManager()</slot>
-    <slot>showNewVDIWizard()</slot>
+    <slot>showHardDiskManager()</slot>
+    <slot>showNewHardDiskWizard()</slot>
     <slot>slRAM_valueChanged( int val )</slot>
     <slot>leRAM_textChanged( const QString &amp; text )</slot>
     <slot>cbOS_activated( int item )</slot>
-    <slot>currentMediaChanged( int item )</slot>
 </slots>
 <functions>

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -103 +103 @@
 
     /* HDD Images page */
-    mediaCombo = new VBoxMediaComboBox (grbHDA, "mediaCombo", VBoxDefs::HD, true);
-    grbHDALayout->addMultiCellWidget (mediaCombo, 0, 0, 0, 2);
-    setTabOrder (mediaCombo, pbNewHD);
+    mHDCombo = new VBoxMediaComboBox (grbHDA, "mHDCombo",
+                                      VBoxDefs::MediaType_HardDisk);
+    grbHDALayout->addMultiCellWidget (mHDCombo, 0, 0, 0, 2);
+    setTabOrder (mHDCombo, pbNewHD);
     setTabOrder (pbNewHD, pbExistingHD);
-    connect (mediaCombo, SIGNAL (activated (int)),
-             this, SLOT (currentMediaChanged (int)));
-    if (!vboxGlobal().isMediaEnumerationStarted())
-        vboxGlobal().startEnumeratingMedia();
-    else
-        mediaCombo->refresh();
-
-    /// @todo (dmik) remove?
-    wvalHDD = new QIWidgetValidator (pageHDD, this);
-    connect (wvalHDD, SIGNAL (validityChanged (const QIWidgetValidator *)),
-             this, SLOT (enableNext (const QIWidgetValidator *)));
-    connect (wvalHDD, SIGNAL (isValidRequested (QIWidgetValidator *)),
-             this, SLOT (revalidate (QIWidgetValidator *)));
+
+    /* request to check media accessibility */
+    mHDCombo->repopulate();
 
     /* Summary page */
@@ -176 +167 @@
     wvalNameAndOS->revalidate();
     wvalMemory->revalidate();
-    wvalHDD->revalidate();
 
     /* the finish button on the Summary page is always enabled */
@@ -222 +212 @@
 }
 
-
 void VBoxNewVMWzd::revalidate (QIWidgetValidator *wval)
 {
@@ -229 +218 @@
     bool valid = wval->isOtherValid();
 
-    if (wval == wvalHDD)
-    {
-        if (!chd.isNull() && mediaCombo->getId() != chd.GetId())
-            ensureNewHardDiskDeleted();
-    }
-
-    wval->setOtherValid( valid );
-}
-
+    wval->setOtherValid (valid);
+}
 
 void VBoxNewVMWzd::showPage (QWidget *page)
@@ -243 +225 @@
     if (page == pageSummary)
     {
-        if (!mediaCombo->currentItem())
+        bool haveHardDisk = grbHDA->isChecked() && !mHDCombo->id().isNull();
+
+        if (!haveHardDisk)
         {
             if (!vboxProblem().confirmHardDisklessMachine (this))
@@ -258 +242 @@
             .arg (slRAM->value());
 
-        if (mediaCombo->currentItem())
+        if (haveHardDisk)
             summary += QString (tr (
                 "<tr><td>Boot Hard Disk:</td><td>%4</td></tr>"))
-                .arg (mediaCombo->currentText());
+                .arg (mHDCombo->currentText());
 
         teSummary->setText ("<table>" + summary + "</table>");
@@ -276 +260 @@
     QWizard::showPage (page);
 
-    /*
-     *  fix focus on the last page. when we go to the last page
-     *  having the Next in focus the focus goes to the Cancel
-     *  button because when the Next hides Finish is not yet shown.
-     */
+    /* fix focus on the last page. when we go to the last page having the Next
+     * in focus the focus goes to the Cancel button because when the Next hides
+       Finish is not yet shown. */
     if (page == pageSummary && focusWidget() == cancelButton())
         finishButton()->setFocus();
@@ -290 +272 @@
         slRAM->setFocus();
     else if (page == pageHDD)
-        mediaCombo->setFocus();
+        mHDCombo->setFocus();
     else if (page == pageSummary)
         teSummary->setFocus();
@@ -299 +281 @@
 void VBoxNewVMWzd::accept()
 {
-    /*
-     *  Try to create the machine when the Finish button is pressed.
-     *  On failure, the wisard will remain open to give it another try.
-     */
+    /* Try to create the machine when the Finish button is pressed. On
+     * failure, the wizard will remain open to give it another try. */
     if (constructMachine())
         QWizard::accept();
@@ -312 +292 @@
 
     /* create a machine with the default settings file location */
-    if (cmachine.isNull())
-    {
-        cmachine = vbox.CreateMachine (QString(), leName->text(), QUuid());
+    if (mMachine.isNull())
+    {
+        mMachine = vbox.CreateMachine (QString(), leName->text(), QUuid());
         if (!vbox.isOk())
         {
@@ -320 +300 @@
             return false;
         }
-        if (uuidHD.isNull() || !chd.isNull())
-            cmachine.SetExtraData (VBoxDefs::GUI_FirstRun, "yes");
+
+        /* The FirstRun wizard is to be shown only when we don't attach any hard
+         * disk or attach a new (empty) one. Selecting an existing hard disk
+         * will cancel the wizard. */
+        if (mHDCombo->id().isNull() || !mHardDisk.isNull())
+            mMachine.SetExtraData (VBoxDefs::GUI_FirstRun, "yes");
     }
 
@@ -330 +314 @@
     AssertMsg (!type.isNull(), ("vmGuestOSType() must return non-null type"));
     QString typeId = type.GetId();
-    cmachine.SetOSTypeId (typeId);
+    mMachine.SetOSTypeId (typeId);
 
     if (typeId == "os2warp3"  ||
@@ -336 +320 @@
         typeId == "os2warp45" ||
         typeId == "ecs")
-        cmachine.SetHWVirtExEnabled (KTSBool_True);
+        mMachine.SetHWVirtExEnabled (KTSBool_True);
 
     /* RAM size */
-    cmachine.SetMemorySize (slRAM->value());
+    mMachine.SetMemorySize (slRAM->value());
 
     /* add one network adapter (NAT) by default */
     {
-        CNetworkAdapter cadapter = cmachine.GetNetworkAdapter (0);
+        CNetworkAdapter cadapter = mMachine.GetNetworkAdapter (0);
 #ifdef VBOX_WITH_E1000
         /* Default to e1k on solaris */
@@ -358 +342 @@
 
     /* register the VM prior to attaching hard disks */
-    vbox.RegisterMachine (cmachine);
+    vbox.RegisterMachine (mMachine);
     if (!vbox.isOk())
     {
-        vboxProblem().cannotCreateMachine (vbox, cmachine, this);
+        vboxProblem().cannotCreateMachine (vbox, mMachine, this);
         return false;
     }
 
-    /* Boot hard disk (Primary Master) */
-    if (!uuidHD.isNull())
+    /* Boot hard disk (IDE Primary Master) */
+    QUuid hardDiskId = mHDCombo->id();
+    if (!hardDiskId.isNull())
     {
         bool ok = false;
-        QUuid id = cmachine.GetId();
+        QUuid id = mMachine.GetId();
         CSession session = vboxGlobal().openSession (id);
         if (!session.isNull())
         {
             CMachine m = session.GetMachine();
-            m.AttachHardDisk (uuidHD, KStorageBus_IDE, 0, 0);
+            m.AttachHardDisk2 (hardDiskId, KStorageBus_IDE, 0, 0);
             if (m.isOk())
             {
@@ -384 +369 @@
             }
             else
-                vboxProblem().cannotAttachHardDisk (this, m, uuidHD,
+                vboxProblem().cannotAttachHardDisk (this, m,
+                                                    mHDCombo->location(),
                                                     KStorageBus_IDE, 0, 0);
             session.Close();
@@ -393 +379 @@
             vbox.UnregisterMachine (id);
             if (vbox.isOk())
-                cmachine.DeleteSettings();
+                mMachine.DeleteSettings();
             return false;
         }
     }
 
-    /* ensure we don't delete a newly created hard disk on success */
-    chd.detach();
+    /* ensure we don't try to delete a newly created hard disk on success */
+    mHardDisk.detach();
 
     return true;
@@ -406 +392 @@
 void VBoxNewVMWzd::ensureNewHardDiskDeleted()
 {
-    if (!chd.isNull())
-    {
-        QUuid hdId = chd.GetId();
-        CVirtualBox vbox = vboxGlobal().virtualBox();
-        vbox.UnregisterHardDisk (chd.GetId());
-        if (!vbox.isOk())
-            vboxProblem().cannotUnregisterMedia (this, vbox, VBoxDefs::HD,
-                                                 chd.GetLocation());
+    if (!mHardDisk.isNull())
+    {
+        /* remember ID as it may be lost after the deletion */
+        QUuid id = mHardDisk.GetId();
+
+        bool success = false;
+
+        CProgress progress = mHardDisk.DeleteStorage();
+        if (mHardDisk.isOk())
+        {
+            vboxProblem().showModalProgressDialog (progress, caption(),
+                                                   parentWidget());
+            if (progress.isOk() && progress.GetResultCode() == S_OK)
+                success = true;
+        }
+
+        if (success)
+            vboxGlobal().removeMedium (VBoxDefs::MediaType_HardDisk, id);
         else
-        {
-            CVirtualDiskImage vdi = CUnknown (chd);
-            if (!vdi.isNull())
-            {
-                vdi.DeleteImage();
-                if (!vdi.isOk())
-                    vboxProblem().cannotDeleteHardDiskImage (this, vdi);
-            }
-        }
-        chd.detach();
-        vboxGlobal().removeMedia (VBoxDefs::HD, hdId);
+            vboxProblem().cannotDeleteHardDiskStorage (this, mHardDisk,
+                                                       progress);
+        mHardDisk.detach();
     }
 }
@@ -431 +419 @@
 CMachine VBoxNewVMWzd::machine()
 {
-    return cmachine;
-}
-
-void VBoxNewVMWzd::showVDIManager()
-{
-    VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg", WType_Dialog | WShowModal);
-    dlg.setup (VBoxDefs::HD, true);
-    QUuid newId = dlg.exec() == VBoxDiskImageManagerDlg::Accepted ?
-        dlg.getSelectedUuid() : mediaCombo->getId();
-
-    if (uuidHD != newId)
-    {
-        ensureNewHardDiskDeleted();
-        uuidHD = newId;
-        mediaCombo->setCurrentItem (uuidHD);
-    }
-    mediaCombo->setFocus();
-    /* revailidate */
-    wvalHDD->revalidate();
-}
-
-void VBoxNewVMWzd::showNewVDIWizard()
+    return mMachine;
+}
+
+void VBoxNewVMWzd::showHardDiskManager()
+{
+    VBoxMediaManagerDlg dlg (this, "VBoxMediaManagerDlg", WType_Dialog | WShowModal);
+    dlg.setup (VBoxDefs::MediaType_HardDisk, true);
+
+    if (dlg.exec() == VBoxMediaManagerDlg::Accepted)
+    {
+        QUuid newId = dlg.selectedId();
+        if (mHDCombo->id() != newId)
+        {
+            ensureNewHardDiskDeleted();
+            mHDCombo->setCurrentItem (newId);
+        }
+    }
+
+    mHDCombo->setFocus();
+}
+
+void VBoxNewVMWzd::showNewHardDiskWizard()
 {
     VBoxNewHDWzd dlg (this, "VBoxNewHDWzd");
@@ -464 +452 @@
     {
         ensureNewHardDiskDeleted();
-        chd = dlg.hardDisk();
-        /* fetch uuid and name/path */
-        uuidHD = chd.GetId();
-        /* update media combobox */
-        VBoxMedia::Status status =
-            chd.GetAccessible() == TRUE ? VBoxMedia::Ok :
-            chd.isOk() ? VBoxMedia::Inaccessible :
-            VBoxMedia::Error;
-        vboxGlobal().addMedia (VBoxMedia (CUnknown (chd), VBoxDefs::HD, status));
-        mediaCombo->setCurrentItem (uuidHD);
-        mediaCombo->setFocus();
-        /* revailidate */
-        wvalHDD->revalidate();
+        mHardDisk = dlg.hardDisk();
+
+        mHDCombo->setCurrentItem (mHardDisk.GetId());
+        mHDCombo->setFocus();
     }
 }
@@ -484 +463 @@
     leRAM->setText (QString().setNum (val));
 }
-
 
 void VBoxNewVMWzd::leRAM_textChanged (const QString &text)
@@ -505 +483 @@
 }
 
-void VBoxNewVMWzd::currentMediaChanged (int)
-{
-    uuidHD = mediaCombo->getId();
-    /* revailidate */
-    wvalHDD->revalidate();
-}

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

@@ -556 +556 @@
         return;
 
+    QString snapName = mMachine.GetSnapshot (snapId).GetName();
+
     CConsole console = session.GetConsole();
     CProgress progress = console.DiscardSnapshot (snapId);
@@ -565 +567 @@
 
         if (progress.GetResultCode() != 0)
-            vboxProblem().cannotDiscardSnapshot (progress, mMachine.GetSnapshot (snapId));
+            vboxProblem().cannotDiscardSnapshot (progress, snapName);
     }
     else
-        vboxProblem().cannotDiscardSnapshot (console, mMachine.GetSnapshot (snapId));
+        vboxProblem().cannotDiscardSnapshot (console, snapName);
 
     session.Close();

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

@@ -80 +80 @@
         case VBoxUSBFilterSettings::HostType:
         {
-            const CHostUSBDeviceFilter filter = CUnknown (aFilter);
+            const CHostUSBDeviceFilter filter (aFilter);
             KUSBDeviceFilterAction action = filter.GetAction();
             if (action == KUSBDeviceFilterAction_Ignore)
@@ -150 +150 @@
             case VBoxUSBFilterSettings::HostType:
             {
-                CHostUSBDeviceFilter filter = CUnknown (mFilter);
+                CHostUSBDeviceFilter filter (mFilter);
                 filter.SetAction (vboxGlobal().toUSBDevFilterAction (
                     cbAction->currentText()));

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

@@ -6 +6 @@
 :folding=explicit:collapseFolds=1:
 
-     Copyright (C) 2007 Sun Microsystems, Inc.
+     Copyright (C) 2007-2008 Sun Microsystems, Inc.
 
      This file is part of VirtualBox Open Source Edition (OSE), as
@@ -647 +647 @@
         <signal>clicked()</signal>
         <receiver>VBoxVMFirstRunWzd</receiver>
-        <slot>openVdm()</slot>
+        <slot>openMediaManager()</slot>
     </connection>
 </connections>
@@ -657 +657 @@
     <include location="local" impldecl="in implementation">VBoxGlobal.h</include>
     <include location="local" impldecl="in implementation">VBoxMediaComboBox.h</include>
-    <include location="local" impldecl="in implementation">VBoxDiskImageManagerDlg.h</include>
+    <include location="local" impldecl="in implementation">VBoxMediaManagerDlg.h</include>
 </includes>
 <forwards>
@@ -676 +676 @@
     <slot>mediaTypeChanged()</slot>
     <slot>mediaSourceChanged()</slot>
-    <slot>openVdm()</slot>
+    <slot>openMediaManager()</slot>
 </slots>
 <functions>

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

@@ -53 +53 @@
 
     /* media page */
-    cbImage = new VBoxMediaComboBox (bgSource, "cbImage", VBoxDefs::CD);
+    cbImage = new VBoxMediaComboBox (bgSource, "cbImage", VBoxDefs::MediaType_DVD);
     ltVdm->insertWidget (0, cbImage);
     tbVdm->setIconSet (VBoxGlobal::iconSet ("select_file_16px.png",
@@ -110 +110 @@
     machine = aMachine;
 
-    CHardDiskAttachmentEnumerator en = machine.GetHardDiskAttachments().Enumerate();
-    if (en.HasMore())
+    CHardDisk2AttachmentVector vec = machine.GetHardDisk2Attachments();
+    if (vec.size() != 0)
     {
         txWelcomeHD->setHidden (true);
@@ -209 +209 @@
         {
             CDVDDrive virtualDrive = machine.GetDVDDrive();
-            virtualDrive.MountImage (cbImage->getId());
+            virtualDrive.MountImage (cbImage->id());
         }
     }
@@ -227 +227 @@
         {
             CFloppyDrive virtualDrive = machine.GetFloppyDrive();
-            virtualDrive.MountImage (cbImage->getId());
+            virtualDrive.MountImage (cbImage->id());
         }
     }
@@ -283 +283 @@
 
         /* Switch media images type to CD */
-        cbImage->setType (VBoxDefs::CD);
+        cbImage->setType (VBoxDefs::MediaType_DVD);
     }
     /* Floppy Media type selected */
@@ -308 +308 @@
 
         /* Switch media images type to FD */
-        cbImage->setType (VBoxDefs::FD);
-    }
-    /* Update media images list */
-    if (!vboxGlobal().isMediaEnumerationStarted())
-        vboxGlobal().startEnumeratingMedia();
-    else
-        cbImage->refresh();
+        cbImage->setType (VBoxDefs::MediaType_Floppy);
+    }
+
+    /* Repopulate the media list */
+    cbImage->repopulate();
 
     /* Revalidate updated page */
@@ -332 +330 @@
 
 
-void VBoxVMFirstRunWzd::openVdm()
-{
-    VBoxDiskImageManagerDlg vdm (this, "VBoxDiskImageManagerDlg",
-                                 WType_Dialog | WShowModal);
-    QUuid machineId = machine.GetId();
-    VBoxDefs::DiskType type = rbCdType->isChecked() ? VBoxDefs::CD :
-        rbFdType->isChecked() ? VBoxDefs::FD : VBoxDefs::InvalidType;
-    vdm.setup (type, true, &machineId);
-    if (vdm.exec() == VBoxDiskImageManagerDlg::Accepted)
-    {
-        cbImage->setCurrentItem (vdm.getSelectedUuid());
+void VBoxVMFirstRunWzd::openMediaManager()
+{
+    VBoxDefs::MediaType type =
+        rbCdType->isChecked() ? VBoxDefs::MediaType_DVD :
+        rbFdType->isChecked() ? VBoxDefs::MediaType_Floppy :
+        VBoxDefs::MediaType_Invalid;
+
+    AssertReturnVoid (type != VBoxDefs::MediaType_Invalid);
+
+    VBoxMediaManagerDlg dlg (this, "VBoxMediaManagerDlg",
+                             WType_Dialog | WShowModal);
+
+    dlg.setup (type, true /* aDoSelect */);
+    if (dlg.exec() == VBoxMediaManagerDlg::Accepted)
+    {
+        cbImage->setCurrentItem (dlg.selectedId());
 
         /* Revalidate updated page */

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

@@ -143 +143 @@
     connect (&vboxGlobal(), SIGNAL (mediaEnumFinished (const VBoxMediaList &)),
              this, SLOT (updateDetails()));
-    connect (mConsole, SIGNAL (mediaChanged (VBoxDefs::DiskType)),
+    connect (mConsole, SIGNAL (mediumChanged (VBoxDefs::MediaType)),
              this, SLOT (updateDetails()));
     connect (mConsole, SIGNAL (sharedFoldersChanged()),
@@ -435 +435 @@
     /* details page update */
     mDetailsText->setText (
-        vboxGlobal().detailsReport (mSession.GetMachine(), false /* isNewVM */,
-                                    false /* withLinks */, false /* refresh */));
+        vboxGlobal().detailsReport (mSession.GetMachine(), false /* aIsNewVM */,
+                                    false /* aWithLinks */));
 }
 
@@ -561 +561 @@
 
         /* IDE Hard Disk (Primary Master) */
-        if (!m.GetHardDisk (KStorageBus_IDE, 0, 0).isNull())
+        if (!m.GetHardDisk2 (KStorageBus_IDE, 0, 0).isNull())
         {
             hdStat += formatHardDisk (KStorageBus_IDE, 0, 0, "IDE00");
@@ -568 +568 @@
 
         /* IDE Hard Disk (Primary Slave) */
-        if (!m.GetHardDisk (KStorageBus_IDE, 0, 1).isNull())
+        if (!m.GetHardDisk2 (KStorageBus_IDE, 0, 1).isNull())
         {
             hdStat += formatHardDisk (KStorageBus_IDE, 0, 1, "IDE01");
@@ -575 +575 @@
 
         /* IDE Hard Disk (Secondary Slave) */
-        if (!m.GetHardDisk (KStorageBus_IDE, 1, 1).isNull())
+        if (!m.GetHardDisk2 (KStorageBus_IDE, 1, 1).isNull())
         {
             hdStat += formatHardDisk (KStorageBus_IDE, 1, 1, "IDE11");
@@ -584 +584 @@
         for (int i = 0; i < 30; ++ i)
         {
-            if (!m.GetHardDisk (KStorageBus_SATA, i, 0).isNull())
+            if (!m.GetHardDisk2 (KStorageBus_SATA, i, 0).isNull())
             {
                 hdStat += formatHardDisk (KStorageBus_SATA, i, 0,
@@ -649 +649 @@
         return QString::null;
 
-    CHardDisk hd = mSession.GetMachine().GetHardDisk (aBus, aChannel, aDevice);
+    CHardDisk2 hd = mSession.GetMachine().GetHardDisk2 (aBus, aChannel, aDevice);
     QString header = "<tr><td></td><td colspan=3><nobr><u>%1</u></nobr></td></tr>";
     QString name = vboxGlobal().toFullString (aBus, aChannel, aDevice);

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

@@ -1643 +1643 @@
                                                 </property>
                                                 <property name="whatsThis" stdset="0">
-                                                    <string>Invokes the Virtual Disk Manager to select a CD/DVD image to mount.</string>
+                                                    <string>Invokes the Virtual Media Manager to select a CD/DVD image to mount.</string>
                                                 </property>
                                             </widget>
@@ -1842 +1842 @@
                                                 </property>
                                                 <property name="whatsThis" stdset="0">
-                                                    <string>Invokes the Virtual Disk Manager to select a Floppy image to mount.</string>
+                                                    <string>Invokes the Virtual Media Manager to select a Floppy image to mount.</string>
                                                 </property>
                                             </widget>
@@ -3032 +3032 @@
     <include location="local" impldecl="in implementation">VBoxUSBFilterSettings.h</include>
     <include location="local" impldecl="in implementation">VBoxSharedFoldersSettings.h</include>
-    <include location="local" impldecl="in implementation">VBoxDiskImageManagerDlg.h</include>
+    <include location="local" impldecl="in implementation">VBoxMediaManagerDlg.h</include>
     <include location="local" impldecl="in implementation">VBoxMediaComboBox.h</include>
     <include location="local" impldecl="in implementation">QIRichLabel.h</include>
@@ -3039 +3039 @@
 <forwards>
     <forward>class VBoxMediaComboBox</forward>
-    <forward>class VBoxDiskImageManagerDlg</forward>
+    <forward>class VBoxMediaManagerDlg</forward>
     <forward>class VBoxUSBMenu</forward>
     <forward>class VBoxSharedFoldersSettings</forward>
@@ -3084 +3084 @@
     <slot>revalidate( QIWidgetValidator * wval )</slot>
     <slot>updateWhatsThis( bool gotFocus = false )</slot>
-    <slot>showImageManagerISODVD()</slot>
-    <slot>showImageManagerISOFloppy()</slot>
-    <slot>showVDImageManager( QUuid *id, VBoxMediaComboBox *le, QLabel *tx = NULL )</slot>
+    <slot>showDVDManager()</slot>
+    <slot>showFloppyManager()</slot>
+    <slot>showMediaManager( QUuid *, VBoxMediaComboBox * )</slot>
     <slot>addNetworkAdapter( const CNetworkAdapter &amp; )</slot>
     <slot>updateNetworksList()</slot>
@@ -3127 +3127 @@
     <function access="private">showEvent( QShowEvent * )</function>
     <function access="private">updateShortcuts()</function>
-    <function access="private" returnType="QString">getHdInfo( QGroupBox*, QUuid )</function>
     <function access="private">loadInterfacesList()</function>
     <function access="private">loadNetworksList()</function>

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

@@ -598 +598 @@
              this, SLOT (revalidate (QIWidgetValidator *)));
 
-    connect (mHDSettings, SIGNAL (hddListChanged()), wvalHDD, SLOT (revalidate()));
-    connect (mHDSettings, SIGNAL (hddListChanged()), this, SLOT (resetFirstRunFlag()));
+    connect (mHDSettings, SIGNAL (hardDiskListChanged()), wvalHDD, SLOT (revalidate()));
+    connect (mHDSettings, SIGNAL (hardDiskListChanged()), this, SLOT (resetFirstRunFlag()));
 
     /* CD/DVD-ROM Drive Page */
@@ -607 +607 @@
                          "virtual machine. Note that the CD/DVD drive is always connected to the "
                          "Secondary Master IDE controller of the machine."));
-    cbISODVD = new VBoxMediaComboBox (bgDVD, "cbISODVD", VBoxDefs::CD);
+    cbISODVD = new VBoxMediaComboBox (bgDVD, "cbISODVD", VBoxDefs::MediaType_DVD);
     cdLayout->insertWidget(0, cbISODVD);
     QWhatsThis::add (cbISODVD, tr ("Displays the image file to mount to the virtual CD/DVD "
@@ -622 +622 @@
     connect (rbISODVD, SIGNAL (stateChanged (int)), wvalDVD, SLOT (revalidate()));
     connect (cbISODVD, SIGNAL (activated (int)), this, SLOT (cdMediaChanged()));
-    connect (tbISODVD, SIGNAL (clicked()), this, SLOT (showImageManagerISODVD()));
+    connect (tbISODVD, SIGNAL (clicked()), this, SLOT (showDVDManager()));
 
     /* setup iconsets -- qdesigner is not capable... */
@@ -633 +633 @@
                      tr ("When checked, mounts the specified media to the Floppy drive of the "
                          "virtual machine."));
-    cbISOFloppy = new VBoxMediaComboBox (bgFloppy, "cbISOFloppy", VBoxDefs::FD);
+    cbISOFloppy = new VBoxMediaComboBox (bgFloppy, "cbISOFloppy", VBoxDefs::MediaType_Floppy);
     fdLayout->insertWidget(0, cbISOFloppy);
     QWhatsThis::add (cbISOFloppy, tr ("Displays the image file to mount to the virtual Floppy "
@@ -648 +648 @@
     connect (rbISOFloppy, SIGNAL (stateChanged (int)), wvalFloppy, SLOT (revalidate()));
     connect (cbISOFloppy, SIGNAL (activated (int)), this, SLOT (fdMediaChanged()));
-    connect (tbISOFloppy, SIGNAL (clicked()), this, SLOT (showImageManagerISOFloppy()));
+    connect (tbISOFloppy, SIGNAL (clicked()), this, SLOT (showFloppyManager()));
 
     /* setup iconsets -- qdesigner is not capable... */
@@ -1178 +1178 @@
 {
     resetFirstRunFlag();
-    uuidISODVD = bgDVD->isChecked() ? cbISODVD->getId() : QUuid();
+    uuidISODVD = bgDVD->isChecked() ? cbISODVD->id() : QUuid();
     /* revailidate */
     wvalDVD->revalidate();
@@ -1187 +1187 @@
 {
     resetFirstRunFlag();
-    uuidISOFloppy = bgFloppy->isChecked() ? cbISOFloppy->getId() : QUuid();
+    uuidISOFloppy = bgFloppy->isChecked() ? cbISOFloppy->id() : QUuid();
     /* revailidate */
     wvalFloppy->revalidate();
 }
 
-
-QString VBoxVMSettingsDlg::getHdInfo (QGroupBox *aGroupBox, QUuid aId)
-{
-    QString notAttached = tr ("<not attached>", "hard disk");
-    if (aId.isNull())
-        return notAttached;
-    return aGroupBox->isChecked() ?
-        vboxGlobal().details (vboxGlobal().virtualBox().GetHardDisk (aId), true) :
-        notAttached;
-}
 
 void VBoxVMSettingsDlg::updateWhatsThis (bool gotFocus /* = false */)
@@ -1234 +1224 @@
 }
 
+
 void VBoxVMSettingsDlg::setWarning (const QString &warning)
 {
@@ -1246 +1237 @@
 }
 
+
 /**
- *  Sets up this dialog.
+ * Sets up this dialog.
  *
- *  If @a aCategory is non-null, it should be one of values from the hidden
- *  '[cat]' column of #listView (see VBoxVMSettingsDlg.ui in qdesigner)
- *  prepended with the '#' sign. In this case, the specified category page
- *  will be activated when the dialog is open.
+ * If @a aCategory is non-null, it should be one of values from the hidden
+ * '[cat]' column of #listView (see VBoxVMSettingsDlg.ui in qdesigner) prepended
+ * with the '#' sign. In this case, the specified category page will be
+ * activated when the dialog is open.
  *
- *  If @a aWidget is non-null, it should be a name of one of widgets
- *  from the given category page. In this case, the specified widget
- *  will get focus when the dialog is open.
+ * If @a aWidget is non-null, it should be a name of one of widgets from the
+ * given category page. In this case, the specified widget will get focus when
+ * the dialog is open.
  *
- *  @note Calling this method after the dialog is open has no sense.
+ * @note Calling this method after the dialog is open has no sense.
  *
- *  @param  aCategory   Category to select when the dialog is open or null.
- *  @param  aWidget     Category to select when the dialog is open or null.
+ * @param  aCategory    Category to select when the dialog is open or null.
+ * @param  aWidget      Category to select when the dialog is open or null.
  */
 void VBoxVMSettingsDlg::setup (const QString &aCategory, const QString &aControl)
@@ -1303 +1295 @@
     }
 }
+
 
 void VBoxVMSettingsDlg::listView_currentChanged (QListViewItem *item)
@@ -1652 +1645 @@
             case KDriveState_ImageMounted:
             {
-                CFloppyImage img = floppy.GetImage();
-                QString src = img.GetFilePath();
+                CFloppyImage2 img = floppy.GetImage();
+                QString src = img.GetLocation();
                 AssertMsg (!src.isNull(), ("Image file must not be null"));
                 QFileInfo fi (src);
@@ -1724 +1717 @@
             case KDriveState_ImageMounted:
             {
-                CDVDImage img = dvd.GetImage();
-                QString src = img.GetFilePath();
+                CDVDImage2 img = dvd.GetImage();
+                QString src = img.GetLocation();
                 AssertMsg (!src.isNull(), ("Image file must not be null"));
                 QFileInfo fi (src);
@@ -2103 +2096 @@
 
 
-void VBoxVMSettingsDlg::showImageManagerISODVD() { showVDImageManager (&uuidISODVD, cbISODVD); }
-void VBoxVMSettingsDlg::showImageManagerISOFloppy() { showVDImageManager(&uuidISOFloppy, cbISOFloppy); }
-
-void VBoxVMSettingsDlg::showVDImageManager (QUuid *id, VBoxMediaComboBox *cbb, QLabel*)
-{
-    VBoxDefs::DiskType type = VBoxDefs::InvalidType;
-    if (cbb == cbISODVD)
-        type = VBoxDefs::CD;
-    else if (cbb == cbISOFloppy)
-        type = VBoxDefs::FD;
+void VBoxVMSettingsDlg::showDVDManager()
+{
+    showMediaManager (&uuidISODVD, cbISODVD);
+}
+
+
+void VBoxVMSettingsDlg::showFloppyManager()
+{
+    showMediaManager (&uuidISOFloppy, cbISOFloppy);
+}
+
+
+void VBoxVMSettingsDlg::showMediaManager (QUuid *aId, VBoxMediaComboBox *aCombo)
+{
+    VBoxDefs::MediaType type = VBoxDefs::MediaType_Invalid;
+
+    if (aCombo == cbISODVD)
+        type = VBoxDefs::MediaType_DVD;
+    else if (aCombo == cbISOFloppy)
+        type = VBoxDefs::MediaType_Floppy;
+
+    AssertReturnVoid (type != VBoxDefs::MediaType_Invalid);
+
+    VBoxMediaManagerDlg dlg (this, "VBoxMediaManagerDlg",
+                             WType_Dialog | WShowModal);
+
+    dlg.setup (type, true /* aDoSelect */, true /* aRefresh */, cmachine,
+               aCombo->id());
+
+    if (dlg.exec() == VBoxMediaManagerDlg::Accepted)
+    {
+        *aId = dlg.selectedId();
+        resetFirstRunFlag();
+    }
     else
-        type = VBoxDefs::HD;
-
-    VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg",
-                                 WType_Dialog | WShowModal);
-    QUuid machineId = cmachine.GetId();
-    QUuid hdId = type == VBoxDefs::HD ? cbb->getId() : QUuid();
-    QUuid cdId = type == VBoxDefs::CD ? cbb->getId() : QUuid();
-    QUuid fdId = type == VBoxDefs::FD ? cbb->getId() : QUuid();
-    dlg.setup (type, true, &machineId, true /* aRefresh */, cmachine,
-               hdId, cdId, fdId);
-    if (dlg.exec() == VBoxDiskImageManagerDlg::Accepted)
-    {
-        *id = dlg.getSelectedUuid();
-        resetFirstRunFlag();
-    }
-    else
-    {
-        *id = cbb->getId();
-    }
-
-    cbb->setCurrentItem (*id);
-    cbb->setFocus();
+    {
+        *aId = aCombo->id();
+    }
+
+    aCombo->setCurrentItem (*aId);
+    aCombo->setFocus();
 
     /* revalidate pages with custom validation */
-    wvalHDD->revalidate();
     wvalDVD->revalidate();
     wvalFloppy->revalidate();
 }
+
 
 void VBoxVMSettingsDlg::addNetworkAdapter (const CNetworkAdapter &aAdapter)
@@ -2194 +2195 @@
 }
 
+
 void VBoxVMSettingsDlg::updateNetworksList()
 {
@@ -2222 +2224 @@
     mLockNetworkListUpdate = false;
 }
+
 
 void VBoxVMSettingsDlg::addSerialPort (const CSerialPort &aPort)
@@ -2257 +2260 @@
 }
 
+
 void VBoxVMSettingsDlg::addParallelPort (const CParallelPort &aPort)
 {
@@ -2289 +2293 @@
 }
 
+
 void VBoxVMSettingsDlg::slRAM_valueChanged( int val )
 {
@@ -2294 +2299 @@
 }
 
+
 void VBoxVMSettingsDlg::leRAM_textChanged( const QString &text )
 {
@@ -2299 +2305 @@
 }
 
+
 void VBoxVMSettingsDlg::slVRAM_valueChanged( int val )
 {
@@ -2304 +2311 @@
 }
 
+
 void VBoxVMSettingsDlg::leVRAM_textChanged( const QString &text )
 {
     slVRAM->setValue( text.toInt() );
 }
+
 
 void VBoxVMSettingsDlg::cbOS_activated (int item)
@@ -2322 +2331 @@
 }
 
+
 void VBoxVMSettingsDlg::tbResetSavedStateFolder_clicked()
 {
@@ -2332 +2342 @@
 }
 
+
 void VBoxVMSettingsDlg::tbSelectSavedStateFolder_clicked()
 {
@@ -2354 +2365 @@
 }
 
+
 // USB Filter stuff
 ////////////////////////////////////////////////////////////////////////////////
+
 
 void VBoxVMSettingsDlg::usbAdapterToggled (bool aOn)
@@ -2363 +2376 @@
     grbUSBFilters->setEnabled (aOn);
 }
+
 
 void VBoxVMSettingsDlg::addUSBFilter (const CUSBDeviceFilter &aFilter, bool isNew)
@@ -2405 +2419 @@
 }
 
+
 void VBoxVMSettingsDlg::lvUSBFilters_currentChanged (QListViewItem *item)
 {
@@ -2427 +2442 @@
 }
 
+
 void VBoxVMSettingsDlg::lvUSBFilters_contextMenuRequested (QListViewItem *,
                                                            const QPoint &aPoint, int)
@@ -2433 +2449 @@
 }
 
+
 void VBoxVMSettingsDlg::lvUSBFilters_setCurrentText (const QString &aText)
 {
@@ -2440 +2457 @@
     item->setText (lvUSBFilters_Name, aText);
 }
+
 
 void VBoxVMSettingsDlg::addUSBFilterAct_activated()
@@ -2468 +2486 @@
 }
 
+
 void VBoxVMSettingsDlg::addUSBFilterFromAct_activated()
 {
@@ -2480 +2499 @@
     usbDevicesMenu->exec (pos);
 }
+
 
 void VBoxVMSettingsDlg::menuAddUSBFilterFrom_activated (int aIndex)
@@ -2513 +2533 @@
 }
 
+
 void VBoxVMSettingsDlg::removeUSBFilterAct_activated()
 {
@@ -2530 +2551 @@
 }
 
+
 void VBoxVMSettingsDlg::USBFilterUpAct_activated()
 {
@@ -2551 +2573 @@
 }
 
+
 void VBoxVMSettingsDlg::USBFilterDownAct_activated()
 {
@@ -2565 +2588 @@
 }
 
+
 #include "VBoxVMSettingsDlg.ui.moc"